कोई चरण बनाना

सीमित झलक: ऐड-ऑन की मदद से Google Workspace Studio की सुविधाओं को बढ़ाने की सुविधा, सीमित झलक के तौर पर उपलब्ध है. ज़्यादा जानें

इस गाइड में, ऐसा चरण बनाने का तरीका बताया गया है जिसे उपयोगकर्ता, 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 चलता है. onConfigFunction में बताए गए कॉन्फ़िगरेशन के दौरान, उपयोगकर्ता की सेट की गई सभी इनपुट वैल्यू, 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 प्रोजेक्ट को दूसरे उपयोगकर्ताओं के साथ शेयर करके, उन्हें ऐड-ऑन को आज़माने की अनुमति दी जा सकती है. इसके लिए, उन्हें बदलाव करने का ऐक्सेस देना ज़रूरी है. इसके बाद, उपयोगकर्ताओं को ऊपर दिया गया तरीका अपनाने के लिए कहें.

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

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

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

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

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

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

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

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

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