कोई चरण बनाना

इस गाइड में, ऐसा चरण बनाने का तरीका बताया गया है जिसे उपयोगकर्ता, Google Workspace Studio में मौजूद एजेंट में जोड़ सकते हैं.

किसी एजेंट के टास्क के क्रम में एक चरण होता है. इन चरणों से एजेंट शुरू नहीं किया जा सकता.

उदाहरण के लिए, मान लें कि कोई ऐसा चरण है जिसमें अंकगणित की जाती है. यह उपयोगकर्ता से दो वैल्यू और गणित की कोई कार्रवाई करने के लिए कहता है. इसके बाद, यह वैल्यू पर गणित की कार्रवाई करता है और नतीजा दिखाता है.

पहली इमेज: इसमें दिखाया गया है कि उपयोगकर्ता, एजेंट के हिस्से के तौर पर कैलकुलेटर स्टेप को कॉन्फ़िगर कर रहा है.

कोई चरण बनाने के लिए, उसे ऐड-ऑन की मेनिफ़ेस्ट फ़ाइल में कॉन्फ़िगर करें. इसके बाद, Google Workspace ऐड-ऑन के कोड में ऐप्लिकेशन लॉजिक लिखें. इसके बाद, चरण को डिप्लॉय करें और उसकी जांच करें.

चरण तय करना

किसी चरण को कॉन्फ़िगर करने के लिए, उसे मेनिफ़ेस्ट फ़ाइल में तय करें और उसके ऐप्लिकेशन लॉजिक को कोड में लिखें.

मेनिफ़ेस्ट फ़ाइल में चरण तय करना

मेनिफ़ेस्ट फ़ाइल में, appsscript.json:

1. onConfigFunction और onExecuteFunction को ऐड-ऑन के कोड में मौजूद फ़ंक्शन के नाम पर सेट करें. इस उदाहरण में, फ़ंक्शन को onConfigCalculate() और onExecuteCalculate() कहा जाता है.
   • onConfigFunction चरण को सेट अप और कॉन्फ़िगर करता है. अगर ज़रूरी हो, तो यह कुकी उपयोगकर्ताओं से ऐसा डेटा इकट्ठा करती है जो इस चरण को पूरा करने के लिए ज़रूरी है. जैसे, ईमेल भेजने के लिए पता. इस गाइड के उदाहरण में, हमने दो वैल्यू और एक गणितीय कार्रवाई के बारे में पूछा है.
   • onExecuteFunction चरण को लागू करता है. अगर उपयोगकर्ताओं से डेटा इकट्ठा किया गया था, तो वह डेटा इस फ़ंक्शन को पास किया जाता है. अगर लागू हो, तो आउटपुट दिखाता है. इस गाइड के उदाहरण में, गणित की कैलकुलेशन का नतीजा दिखाया गया है.

2. ज़रूरी इनपुट और आउटपुट सेट करें. इससे चरण को डेटा इकट्ठा करने और उसे बाद के चरणों में भेजने में मदद मिलती है. इस उदाहरण में, उपयोगकर्ता से दो वैल्यू और inputs[] में तय किया गया गणित का कोई ऑपरेशन करने के लिए कहा गया है. कैलकुलेट किए गए नतीजे को outputs[] में बताए गए तरीके से आउटपुट करें.

   इनपुट और आउटपुट के बारे में ज़्यादा जानने के लिए, इनपुट वैरिएबल और आउटपुट वैरिएबल देखें. यह पक्का करें कि एजेंट बिना किसी गड़बड़ी के काम करें. इसके लिए, इनपुट वैरिएबल की पुष्टि करें.

कैल्क्यूलेटर वाले चरण के लिए मेनिफ़ेस्ट फ़ाइल यहां दी गई है:

JSON

{
  "timeZone": "America/Los_Angeles",
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "addOns": {
    "common": {
      "name": "Calculator",
      "logoUrl": "https://www.gstatic.com/images/branding/productlogos/calculator_search/v1/web-24dp/logo_calculator_search_color_1x_web_24dp.png",
      "useLocaleFromApp": true
    },
    "flows": {
      "workflowElements": [
        {
          "id": "actionElement",
          "state": "ACTIVE",
          "name": "Calculate",
          "description": "Asks the user for two values and a math operation, then performs the math operation on the values and outputs the result.",
          "workflowAction": {
            "inputs": [
              {
                "id": "value1",
                "description": "value1",
                "cardinality": "SINGLE",
                "dataType": {
                  "basicType": "INTEGER"
                }
              },
              {
                "id": "value2",
                "description": "value2",
                "cardinality": "SINGLE",
                "dataType": {
                  "basicType": "INTEGER"
                }
              },
              {
                "id": "operation",
                "description": "operation",
                "cardinality": "SINGLE",
                "dataType": {
                  "basicType": "STRING"
                }
              }
            ],
            "outputs": [
              {
                "id": "result",
                "description": "Calculated result",
                "cardinality": "SINGLE",
                "dataType": {
                  "basicType": "INTEGER"
                }
              }
            ],
            "onConfigFunction": "onConfigCalculate",
            "onExecuteFunction": "onExecuteCalculate"
          }
        }
      ]
    }
  }
}

इसके बाद, कोड में चरण तय करके, कोड लिखें.

कोड में चरण तय करना

ऐप्लिकेशन कोड में, यह तरीका अपनाएं:

1. onConfigFunction लिखें. इस उदाहरण में इसे onConfigCalculate() कहा गया है. उपयोगकर्ता, एजेंट में चरण जोड़ते समय, एजेंट बिल्डर में चरण के पहलुओं को कॉन्फ़िगर कर सकते हैं. उपयोगकर्ता से ज़रूरी जानकारी इकट्ठा करने के लिए, onConfigFunction एक कॉन्फ़िगरेशन कार्ड तय करता है.

   कार्ड, ऐड-ऑन में यूज़र इंटरफ़ेस बनाने के लिए बिल्डिंग ब्लॉक होते हैं. कार्ड में तय किया गया लेआउट, बटन जैसे इंटरैक्टिव यूज़र इंटरफ़ेस (यूआई) एलिमेंट, और इमेज जैसे रिच मीडिया का इस्तेमाल किया जा सकता है. कार्ड की मदद से, उपयोगकर्ता से ऐसा डेटा इकट्ठा किया जा सकता है जिसकी ज़रूरत किसी चरण को पूरा करने के लिए होती है. जैसे, ईमेल भेजने के लिए ईमेल पता.

   OnConfigFunction एक कार्ड दिखाता है. इस कार्ड में, उस यूज़र इंटरफ़ेस (यूआई) के बारे में बताया गया है जहां उपयोगकर्ता, चरण का डेटा सेट करते हैं. इस उदाहरण में, onConfigFunction एक कार्ड बनाता है. इसमें उपयोगकर्ता से दो वैल्यू और गणित की एक कार्रवाई के बारे में पूछा जाता है.

2. इस उदाहरण में दिए गए onExecuteFunction को onExecuteCalculate() कहा जाता है. जब कोई चरण किसी एजेंट में चलता है, तब OnExecuteFunction चलता है. उपयोगकर्ता ने कॉन्फ़िगरेशन के दौरान जो भी इनपुट वैल्यू सेट की हैं उन्हें onConfigurationFunction में बताए गए तरीके के मुताबिक OnExecuteFunction को पास किया जाता है.

   OnExecuteFunction() लिखें, ताकि यह दिए गए इनपुट का इस्तेमाल करके, अपने टास्क को एक साथ पूरा कर सके. ध्यान रखें कि OnExecuteFunction() को आपके एजेंट के मेनिफ़ेस्ट में तय किए गए सभी आउटपुट दिखाने चाहिए. ऐसा न होने पर, गड़बड़ी होगी.

इस कोड सैंपल में, एक सहायक फ़ंक्शन outputVariables() शामिल है. यह फ़ंक्शन, दिए गए वैरिएबल को बनाता है और उन्हें चरण के आउटपुट के तौर पर भेजता है.

आपका चरण अब टेस्टिंग के लिए तैयार है.

कैल्क्यूलेटर वाले चरण के लिए कोड यहां दिया गया है:

Apps Script

/**
 * Generates and displays a configuration card for the sample calculation step.
 *
 * This function creates a card with input fields for two values and a drop-down
 * for selecting an arithmetic operation.
 *
 * The input fields are configured to let the user select outputs from previous
 * steps as input values using the `hostAppDataSource` property.
 */
function onConfigCalculate() {
  const firstInput = CardService.newTextInput()
  .setFieldName("value1")
  .setTitle("First Value")
  .setHostAppDataSource(
    CardService.newHostAppDataSource()
      .setWorkflowDataSource(
        CardService.newWorkflowDataSource()
          .setIncludeVariables(true)
      )
  );
  const secondInput = CardService.newTextInput()
    .setFieldName("value2")
    .setTitle("Second Value").setHostAppDataSource(
      CardService.newHostAppDataSource()
        .setWorkflowDataSource(
          CardService.newWorkflowDataSource()
            .setIncludeVariables(true)
        )
    );
  const selectionInput = CardService.newSelectionInput()
    .setTitle("operation")
    .setFieldName("operation")
    .setType(CardService.SelectionInputType.DROPDOWN)
    .addItem("+", "+", false)
    .addItem("-", "-", true)
    .addItem("x", "x", false)
    .addItem("/", "/", false);

  const sections = CardService.newCardSection()
    .setHeader("Action_sample: Calculate")
    .setId("section_1")
    .addWidget(firstInput)
    .addWidget(selectionInput)
    .addWidget(secondInput)

  var card = CardService.newCardBuilder()
    .addSection(sections)
    .build();

  return card;
}

/**
* Returns output variables from a step.
*
* This function constructs an object that, when returned, sends the
* provided variable values as output from the current step.
* The variable values are logged to the console for debugging purposes.
*/
function outputVariables(variableDataMap) {
const workflowAction = AddOnsResponseService.newReturnOutputVariablesAction()
  .setVariableDataMap(variableDataMap);

const hostAppAction = AddOnsResponseService.newHostAppAction()
  .setWorkflowAction(workflowAction);

const renderAction = AddOnsResponseService.newRenderActionBuilder()
  .setHostAppAction(hostAppAction)
  .build();

return renderAction;
}

/**
 * Executes the calculation step based on the inputs from a flow event.
 *
 * This function retrieves input values and the operation from the flow event,
 * performs the calculation, and returns the result as an output variable.
 * The function logs the event for debugging purposes.
 */
function onExecuteCalculate(event) {
  console.log("output: " + JSON.stringify(event));
  var calculatedValue = 0;
  var value1 = event.workflow.actionInvocation.inputs["value1"].integerValues[0];
  var value2 = event.workflow.actionInvocation.inputs["value2"].integerValues[0];
  var operation = event.workflow.actionInvocation.inputs["operation"].stringValues[0];

  if (operation == "+") {
    calculatedValue = value1 + value2;
  } else if (operation == "-") {
    calculatedValue = value1 - value2;
  } else if (operation == "x") {
    calculatedValue = value1 * value2;
  } else if (operation == "/") {
    calculatedValue = value1 / value2;
  }

  const variableDataMap = { "result": AddOnsResponseService.newVariableData().addIntegerValue(calculatedValue) };

  return outputVariables(variableDataMap);
}

अपने कदम की जांच करना

अपने चरण की जांच करने के लिए, अपने ऐड-ऑन के लिए टेस्ट डिप्लॉयमेंट सेट अप करें. इसके बाद, चरण को किसी एजेंट में जोड़ें और फिर एजेंट को चलाएं.

1. अपने ऐड-ऑन के लिए टेस्ट डिप्लॉयमेंट सेट अप करें:

   1. Apps Script एडिटर में स्क्रिप्ट प्रोजेक्ट खोलें.
   2. डिप्लॉय करें > टेस्ट डिप्लॉयमेंट पर क्लिक करें.
   3. इंस्टॉल करें क्लिक करें.
   4. सबसे नीचे, हो गया पर क्लिक करें.

   Apps Script प्रोजेक्ट को दूसरे उपयोगकर्ताओं के साथ शेयर करके, उन्हें ऐड-ऑन को आज़माने की अनुमति दी जा सकती है. इसके लिए, उन्हें बदलाव करने का ऐक्सेस देना ज़रूरी है. इसके बाद, उपयोगकर्ताओं को पिछले चरण पूरे करने के लिए कहें.

   इंस्टॉल होने के बाद, यह ऐड-ऑन एजेंट के लिए तुरंत उपलब्ध हो जाता है. ऐड-ऑन दिखने से पहले, आपको एजेंटों की सूची रीफ़्रेश करनी पड़ सकती है. ऐड-ऑन का इस्तेमाल करने से पहले, आपको इसे अनुमति देनी होगी.

   टेस्ट डिप्लॉयमेंट के बारे में ज़्यादा जानने के लिए, अनपब्लिश किए गए ऐड-ऑन को इंस्टॉल करना लेख पढ़ें.

2. एजेंट खोलें.

3. ऐसा एजेंट बनाएं जिसमें आपका चरण शामिल हो:

   1. नया एजेंट पर क्लिक करें.
   2. चुनें कि एजेंट कैसे शुरू होगा. किसी चरण की जांच करते समय, ऐसा स्टार्टर चुनना बेहतर होता है जिसे खुद शुरू किया जा सके. जैसे, खुद को ईमेल भेजना. अगर आपके चरण के लिए किसी इनपुट वैरिएबल की ज़रूरत है, तो स्टार्टर के आउटपुट के तौर पर इनपुट वैरिएबल को कॉन्फ़िगर करें.
   3. चरण जोड़ें पर क्लिक करें. आपने जिस चरण को बनाया या अपडेट किया है उसे चुनें. इसे कैलकुलेट करें कहा जाता है.
   4. अपने चरण को कॉन्फ़िगर करें. कैलकुलेट करने के चरण के लिए, दो वैल्यू और गणित की कोई कार्रवाई चुनें. यह चरण अपने-आप सेव हो जाता है.
   5. अपने चरण के आउटपुट की जांच करने के लिए, एक और चरण जोड़ें. उदाहरण के लिए, किसी ईमेल मैसेज में आउटपुट जोड़ने के लिए, Gmail का मैसेज भेजें चरण जोड़ा जा सकता है. मैसेज में, वैरिएबल पर क्लिक करें और अपने चरण का आउटपुट चुनें. कैलकुलेट करने के चरण के लिए, वैरिएबल > दूसरा चरण: कैलकुलेट किया गया नतीजा > कैलकुलेट किया गया नतीजा चुनें. वैरिएबल, मैसेज फ़ील्ड में चिप के तौर पर दिखता है.
   6. चालू करें पर क्लिक करें. आपका एजेंट इस्तेमाल के लिए तैयार है.

4. अपने एजेंट के स्टार्टर को चालू करके, एजेंट को चलाएँ. उदाहरण के लिए, अगर आपको ईमेल मिलने पर एजेंट शुरू करना है, तो खुद को एक ईमेल भेजें.

5. पुष्टि करें कि एजेंट उम्मीद के मुताबिक काम कर रहा है. एजेंट बिल्डर के गतिविधि टैब पर जाकर, लॉग देखें. गतिविधि टैब में कस्टम लॉग बनाने का तरीका जानने के लिए, गतिविधि के लॉग देखें.

मिलते-जुलते विषय

• इनपुट वैरिएबल
• इनपुट वैरिएबल की पुष्टि करना
• आउटपुट वैरिएबल
• कस्टम संसाधन तय करना
• डाइनैमिक वैरिएबल
• गतिविधि और गड़बड़ियों को लॉग करना
• Workspace Studio के इवेंट ऑब्जेक्ट