कोई चरण बनाना

इस गाइड में, ऐसा चरण बनाने का तरीका बताया गया है जिसे उपयोगकर्ता, 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": "calculatorDemo",
          "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. पुष्टि करें कि फ़्लो उम्मीद के मुताबिक चल रहा है. फ़्लो बिल्डर के गतिविधि टैब पर जाकर, लॉग देखें. गतिविधि टैब में कस्टम लॉग बनाने का तरीका जानने के लिए, गतिविधि लॉग देखें.