कोई चरण बनाना

Gemini Alpha प्रोग्राम: फ़्लो, Gemini Alpha प्रोग्राम के तहत उपलब्ध है.

इस गाइड में, ऐसा चरण बनाने का तरीका बताया गया है जिसे उपयोगकर्ता, Google Workspace Flows में किसी फ़्लो में जोड़ सकते हैं.

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

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

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

कोई चरण बनाने के लिए, उसे ऐड-ऑन की मेनिफ़ेस्ट फ़ाइल में कॉन्फ़िगर करें. इसके बाद, 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, एक RenderActions ऑब्जेक्ट दिखाता है. इसमें एक कार्ड होता है. इस कार्ड में, यूज़र इंटरफ़ेस (यूआई) के बारे में बताया गया है. इस यूज़र इंटरफ़ेस (यूआई) में उपयोगकर्ता, चरण का डेटा सेट करते हैं. इस उदाहरण में, 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 card also includes a "Save"
 * button to save the step configuration for the workflow.
 *
 * The input fields are configured to let the user select outputs from previous
 * workflow steps as input values using the `hostAppDataSource` property.
 */
function onConfigCalculate() {
  var card = {
    "sections": [
      {
        "header": "Step example: Calculate",
        "widgets": [
          {
            "textInput": {
              "name": "value1",
              "label": "First value",
              "hostAppDataSource" : {
                "workflowDataSource" : {
                  "includeVariables" : true
                }
              }
            }
          },
          {
            "selectionInput": {
              "name": "operation",
              "label": "Operation",
              "type": "DROPDOWN",
              "items": [
                {
                  "text": "+",
                  "value": "+",
                },
                {
                  "text": "-",
                  "value": "-",
                },
                {
                  "text": "x",
                  "value": "x",
                },
                {
                  "text": "/",
                  "value": "/",
                }
              ]
            }
          },
          {
            "textInput": {
              "name": "value2",
              "label": "Second value",
              "hostAppDataSource" : {
                "workflowDataSource" : {
                  "includeVariables" : true
                }
              }
            }
          }
        ]
      }
    ]
  };
  return {
    "action": {
      "navigations": [{
        "push_card": 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(variableValues) {
  var renderAction =  {
    "hostAppAction" : {
      "workflowAction" : {
        "returnOutputVariablesAction" : {
          "variables" : variableValues
        }
      }
    }
  };
  console.log("renderAction: " + JSON.stringify(renderAction));
  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;
  }
  return outputVariables([{
    "variableId": "result",
    "variableData": {
        "integerValues": [
          calculatedValue
        ]
      },
  }]);
}

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

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

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

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

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

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

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

2. फ़्लो खोलें.

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

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

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

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

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

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