इनपुट वैरिएबल की पुष्टि करना

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

इस गाइड में, इनपुट वैरिएबल की पुष्टि करने का तरीका बताया गया है.

इनपुट वैरिएबल तय करते समय, यह पुष्टि करें कि उपयोगकर्ता ने सही वैल्यू डाली है. यह सबसे सही तरीका है. उदाहरण के लिए, अगर आपने उपयोगकर्ता से कोई संख्या डालने के लिए कहा है, तो यह पुष्टि करना कि उसने a के बजाय 1 डाला है, इस बात की पुष्टि करता है कि आपका चरण बिना किसी गड़बड़ी के पूरा हो गया है.

इनपुट वैरिएबल की पुष्टि करने के दो तरीके हैं:

• क्लाइंट-साइड से की जाने वाली पुष्टि: क्लाइंट-साइड से की जाने वाली पुष्टि की मदद से, उपयोगकर्ता के इनपुट की पुष्टि सीधे उसके डिवाइस पर की जाती है. उपयोगकर्ता को तुरंत सुझाव मिलते हैं. साथ ही, चरण को कॉन्फ़िगर करते समय, इनपुट में हुई किसी भी गड़बड़ी को ठीक किया जा सकता है.
• सर्वर साइड से की जाने वाली पुष्टि: सर्वर साइड से की जाने वाली पुष्टि की मदद से, पुष्टि के दौरान सर्वर पर लॉजिक चलाया जा सकता है. यह तब काम आता है, जब आपको ऐसी जानकारी ढूंढनी हो जो क्लाइंट के पास नहीं है. जैसे, अन्य सिस्टम या डेटाबेस में मौजूद डेटा.

क्लाइंट-साइड से होने वाली पुष्टि

क्लाइंट-साइड की पुष्टि करने के दो तरीके हैं:

• बुनियादी पुष्टि के लिए, जैसे कि यह पुष्टि करना कि किसी विजेट में कुछ वर्णों से कम वर्ण हैं या उसमें @ सिंबल शामिल है, Google Workspace ऐड-ऑन की कार्ड सेवा की Validation क्लास को लागू करें.
• बेहतर तरीके से पुष्टि करने के लिए, जैसे कि विजेट की वैल्यू की तुलना अन्य विजेट की वैल्यू से करने के लिए, CardService का इस्तेमाल करके, यहां दिए गए कार्ड विजेट में कॉमन एक्सप्रेशन लैंग्वेज (सीईएल) की पुष्टि करने की सुविधा जोड़ी जा सकती है.

Validation क्लास को शुरू करना

यहां दिए गए उदाहरण से पुष्टि होती है कि TextInput विजेट में 10 या उससे कम वर्ण हैं:

Apps Script

const validation = CardService.newValidation().setCharacterLimit('10').setInputType(
    CardService.InputType.TEXT);

पुष्टि करने के अन्य विकल्पों के लिए, CEL की मदद से पुष्टि करने की सुविधा का इस्तेमाल करें.

सीईएल की पुष्टि करना

कॉमन एक्सप्रेशन लैंग्वेज (सीईएल) की मदद से पुष्टि करने पर, तुरंत इनपुट की जांच की जा सकती है. इसमें सर्वर साइड से होने वाली पुष्टि में लगने वाला समय नहीं लगता. ऐसा इसलिए होता है, क्योंकि यह इनपुट वैल्यू की उन जांचों को क्लाइंट साइड पर ले जाता है जो अन्य सेवाओं से डेटा के लुकअप पर निर्भर नहीं होती हैं.

कार्ड के व्यवहार को तय करने के लिए भी CEL का इस्तेमाल किया जा सकता है. जैसे, पुष्टि के नतीजे के आधार पर किसी विजेट को दिखाना या छिपाना. इस तरह का व्यवहार, गड़बड़ी का ऐसा मैसेज दिखाने या छिपाने के लिए फ़ायदेमंद होता है जिससे उपयोगकर्ताओं को अपने इनपुट ठीक करने में मदद मिलती है.

CEL की पूरी पुष्टि करने के लिए, इन कॉम्पोनेंट का इस्तेमाल किया जाता है:

• कार्ड में ExpressionData: इसमें पुष्टि करने का तय किया गया लॉजिक और विजेट ट्रिगर करने का लॉजिक होता है. ऐसा तब होता है, जब तय की गई कोई शर्त पूरी हो जाती है.

  • Id: मौजूदा कार्ड में मौजूद ExpressionData के लिए यूनीक आइडेंटिफ़ायर.
  • Expression: यह पुष्टि करने के लॉजिक को तय करने वाली सीईएल स्ट्रिंग है. उदाहरण के लिए, "value1 == value2").
  • Conditions: यह शर्तों की एक सूची होती है. इसमें पहले से तय किए गए पुष्टि के नतीजों (SUCCESS या FAILURE) का कलेक्शन होता है. शर्तें, विजेट-साइड EventAction से Triggers के ज़रिए जुड़ी होती हैं. साथ ही, actionRuleId को शेयर किया जाता है.
  • कार्ड-लेवल EventAction: यह कार्ड में CEL की पुष्टि करने की सुविधा चालू करता है. साथ ही, पोस्ट-इवेंट ट्रिगर के ज़रिए ExpressionData फ़ील्ड को नतीजों के विजेट से जोड़ता है.
    • actionRuleId: इस EventAction के लिए यूनीक आईडी.
    • ExpressionDataAction: इस ऐक्शन से सीईएल का आकलन शुरू होता है. यह दिखाने के लिए, इसे START_EXPRESSION_EVALUATION पर सेट करें.
    • Trigger: यह Conditions को विजेट-साइड EventActions से कनेक्ट करता है. यह actionRuleId पर आधारित होता है.

• विजेट-लेवल EventAction: यह विकल्प, नतीजे वाले विजेट के व्यवहार को कंट्रोल करता है. ऐसा तब होता है, जब सफलता या असफलता की शर्त पूरी हो जाती है. उदाहरण के लिए, नतीजे दिखाने वाला विजेट एक TextParagraph हो सकता है. इसमें गड़बड़ी का मैसेज होता है, जो पुष्टि न होने पर ही दिखता है.

  • actionRuleId: यह कार्ड के साइड पैनल में मौजूद Trigger से मेल खाता है.actionRuleId
  • CommonWidgetAction: यह ऐसी कार्रवाइयों को तय करता है जिनमें आकलन शामिल नहीं होते. जैसे, विजेट की दृश्यता को अपडेट करना.
    • UpdateVisibilityAction: यह एक ऐसा ऐक्शन है जिससे किसी विजेट के दिखने या न दिखने की स्थिति (दिख रहा है या छिपा हुआ है) अपडेट होती है.

यहां दिए गए उदाहरण में, यह जांचने के लिए CEL की पुष्टि करने की सुविधा को लागू करने का तरीका बताया गया है कि दो टेक्स्ट इनपुट बराबर हैं या नहीं. अगर ये दोनों वैल्यू बराबर नहीं हैं, तो गड़बड़ी का मैसेज दिखता है.

• 

  पहली इमेज: जब failCondition की शर्त पूरी हो जाती है (इनपुट बराबर नहीं होते हैं), तो गड़बड़ी का मैसेज दिखाने वाले विजेट को VISIBLE पर सेट कर दिया जाता है और वह दिखने लगता है.

• 

  दूसरी इमेज: जब successCondition की शर्त पूरी हो जाती है (इनपुट बराबर होते हैं), तब गड़बड़ी का मैसेज दिखाने वाले विजेट को HIDDEN पर सेट कर दिया जाता है और वह नहीं दिखता.

यहां ऐप्लिकेशन कोड और JSON मेनिफ़ेस्ट फ़ाइल का उदाहरण दिया गया है:

Apps Script

function onConfig() {

  // Create a Card
  let card = CardService.newCardBuilder();

  const textInput_1 = CardService.newTextInput()
    .setTitle("Input number 1")
    .setFieldName("value1"); // FieldName's value must match a corresponding ID defined in the inputs[] array in the manifest file.
  const textInput_2 = CardService.newTextInput()
    .setTitle("Input number 2")
    .setFieldName("value2"); // FieldName's value must match a corresponding ID defined in the inputs[] array in the manifest file.
  let sections = CardService.newCardSection()
    .setHeader("Two number equals")
    .addWidget(textInput_1)
    .addWidget(textInput_2);

  // CEL Validation

  // Define Conditions
  const condition_success = CardService.newCondition()
    .setActionRuleId("CEL_TEXTINPUT_SUCCESS_RULE_ID")
    .setExpressionDataCondition(
      CardService.newExpressionDataCondition()
      .setConditionType(
        CardService.ExpressionDataConditionType.EXPRESSION_EVALUATION_SUCCESS));
  const condition_fail = CardService.newCondition()
    .setActionRuleId("CEL_TEXTINPUT_FAILURE_RULE_ID")
    .setExpressionDataCondition(
      CardService.newExpressionDataCondition()
      .setConditionType(
        CardService.ExpressionDataConditionType.EXPRESSION_EVALUATION_FAILURE));

  // Define Card-side EventAction
  const expressionDataAction = CardService.newExpressionDataAction()
    .setActionType(
      CardService.ExpressionDataActionType.START_EXPRESSION_EVALUATION);
  // Define Triggers for each Condition respectively
  const trigger_success = CardService.newTrigger()
    .setActionRuleId("CEL_TEXTINPUT_SUCCESS_RULE_ID");
  const trigger_failure = CardService.newTrigger()
    .setActionRuleId("CEL_TEXTINPUT_FAILURE_RULE_ID");

  const eventAction = CardService.newEventAction()
    .setActionRuleId("CEL_TEXTINPUT_EVALUATION_RULE_ID")
    .setExpressionDataAction(expressionDataAction)
    .addPostEventTrigger(trigger_success)
    .addPostEventTrigger(trigger_failure);

  // Define ExpressionData for the current Card
  const expressionData = CardService.newExpressionData()
    .setId("expData_id")
    .setExpression("value1 == value2") // CEL expression
    .addCondition(condition_success)
    .addCondition(condition_fail)
    .addEventAction(eventAction);
  card = card.addExpressionData(expressionData);

  // Create Widget-side EventActions and a widget to display error message
  const widgetEventActionFail = CardService.newEventAction()
    .setActionRuleId("CEL_TEXTINPUT_FAILURE_RULE_ID")
    .setCommonWidgetAction(
      CardService.newCommonWidgetAction()
      .setUpdateVisibilityAction(
        CardService.newUpdateVisibilityAction()
        .setVisibility(
          CardService.Visibility.VISIBLE)));
  const widgetEventActionSuccess = CardService.newEventAction()
    .setActionRuleId("CEL_TEXTINPUT_SUCCESS_RULE_ID")
    .setCommonWidgetAction(
      CardService.newCommonWidgetAction()
      .setUpdateVisibilityAction(
        CardService.newUpdateVisibilityAction()
        .setVisibility(
          CardService.Visibility.HIDDEN)));
  const errorWidget = CardService.newTextParagraph()
    .setText("The first and second value must match.")
    .setVisibility(CardService.Visibility.HIDDEN) // Initially hidden
    .addEventAction(widgetEventActionFail)
    .addEventAction(widgetEventActionSuccess);
  sections = sections.addWidget(errorWidget);

  card = card.addSection(sections);
  // Build and return the Card
  return card.build();
}

JSON मेनिफ़ेस्ट फ़ाइल

{
  "timeZone": "America/Los_Angeles",
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "addOns": {
    "common": {
      "name": "CEL validation example",
      "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": "CEL Demo",
          "description": "Demonstrates CEL Validation",
          "workflowAction": {
            "inputs": [
              {
                "id": "value1",
                "description": "The first number",
                "cardinality": "SINGLE",
                "dataType": {
                  "basicType": "INTEGER"
                }
              },
              {
                "id": "value2",
                "description": "The second number",
                "cardinality": "SINGLE",
                "dataType": {
                  "basicType": "INTEGER"
                }
              }
            ],
            "onConfigFunction": "onConfig",
            "onExecuteFunction": "onExecute"
          }
        }
      ]
    }
  }
}

ध्यान दें: टेक्स्ट इनपुट का fieldName, मेनिफ़ेस्ट फ़ाइल में inputs फ़ील्ड में तय किए गए id से मेल खाना चाहिए. ज़्यादा जानने के लिए, मेनिफ़ेस्ट फ़ाइल में इनपुट वैरिएबल तय करना

देखें.

CEL की पुष्टि करने वाले विजेट और कार्रवाइयां

ऐसे कार्ड विजेट जो CEL की पुष्टि करने की सुविधा के साथ काम करते हैं

इन विजेट में CEL की पुष्टि करने की सुविधा काम करती है:

• TextInput
• SelectionInput
• DateTimePicker

CEL की पुष्टि करने के लिए उपलब्ध कार्रवाइयां

• अंकगणितीय कार्रवाइयां
  • +: इससे int64, uint64 या double में से किसी भी दो संख्याओं को जोड़ा जाता है.
  • -: दो int64, uint64 या double संख्याओं को घटाता है.
  • *: यह फ़ंक्शन, दो int64, uint64 या double संख्याओं को गुणा करता है.
  • /: दो int64, uint64 या double संख्याओं को भाग देता है (पूर्णांक भागफल).
  • %: यह फ़ंक्शन, दो int64 या uint64 संख्याओं का मॉड्युलो निकालता है.
  • -: यह int64 या uint64 नंबर को नेगेटिव बनाता है.
• लॉजिकल ऑपरेशन:
  • &&: यह दो बूलियन वैल्यू पर लॉजिकल AND ऑपरेशन करता है.
  • ||: यह दो बूलियन वैल्यू पर लॉजिकल OR ऑपरेशन करता है.
  • !: यह बूलियन वैल्यू पर लॉजिकल NOT ऑपरेशन करता है.
• तुलना करने वाले ऑपरेटर:
  • ==: यह फ़ंक्शन जांच करता है कि दो वैल्यू बराबर हैं या नहीं. इसमें नंबर और सूचियां इस्तेमाल की जा सकती हैं.
  • !=: यह फ़ंक्शन जांच करता है कि दो वैल्यू बराबर नहीं हैं. इसमें नंबर और सूचियां इस्तेमाल की जा सकती हैं.
  • <: इससे यह पता चलता है कि पहली int64, uint64 या double संख्या, दूसरी संख्या से कम है या नहीं.
  • <=: इससे यह पता चलता है कि पहली संख्या int64, uint64 या double, दूसरी संख्या से छोटी है या उसके बराबर है.
  • >: इससे यह पता चलता है कि पहला int64, uint64 या double नंबर, दूसरे नंबर से बड़ा है या नहीं.
  • >=: यह फ़ंक्शन जांच करता है कि पहला int64, uint64 या double नंबर, दूसरे नंबर से बड़ा है या उसके बराबर है.
• कार्रवाइयों की सूची:
  • in: इससे यह पता चलता है कि कोई वैल्यू सूची में मौजूद है या नहीं. इसमें नंबर, स्ट्रिंग, और नेस्ट की गई सूचियों का इस्तेमाल किया जा सकता है.
  • size: यह फ़ंक्शन, सूची में मौजूद आइटम की संख्या दिखाता है. इसमें संख्याओं और नेस्ट की गई सूचियों का इस्तेमाल किया जा सकता है.

CEL की पुष्टि करने के लिए, इन स्थितियों में सहायता नहीं मिलती

• बाइनरी ऑपरेशन के लिए आर्ग्युमेंट का साइज़ गलत है: बाइनरी ऑपरेशन (उदाहरण के लिए, add_int64, equals) के लिए सिर्फ़ दो आर्ग्युमेंट की ज़रूरत होती है. आर्ग्युमेंट की संख्या अलग होने पर, गड़बड़ी का मैसेज दिखेगा.
• यूनरी ऑपरेशन के लिए, आर्ग्युमेंट का साइज़ गलत है: यूनरी ऑपरेशन (उदाहरण के लिए, negate_int64) के लिए सिर्फ़ एक आर्ग्युमेंट की ज़रूरत होती है. आर्ग्युमेंट की संख्या अलग होने पर, गड़बड़ी का मैसेज दिखेगा.
• संख्या से जुड़े ऑपरेशन में इस्तेमाल न किए जा सकने वाले टाइप: संख्या से जुड़े बाइनरी और यूनरी ऑपरेशन में सिर्फ़ नंबर आर्ग्युमेंट स्वीकार किए जाते हैं. अन्य टाइप (उदाहरण के लिए, बूलियन) देने पर गड़बड़ी होगी.

सर्वर-साइड से होने वाली पुष्टि

सर्वर-साइड से होने वाली पुष्टि की सुविधा की मदद से, सर्वर-साइड लॉजिक को चलाया जा सकता है. इसके लिए, आपको अपने चरण के कोड में onSaveFunction() को सेट करना होगा. जब उपयोगकर्ता, चरण के कॉन्फ़िगरेशन कार्ड से हट जाता है, तो onSaveFunction() चलता है. इससे आपको उपयोगकर्ता के इनपुट की पुष्टि करने में मदद मिलती है.

अगर उपयोगकर्ता का इनपुट मान्य है, तो saveWorkflowAction दिखाएं.

अगर उपयोगकर्ता का इनपुट अमान्य है, तो कॉन्फ़िगरेशन कार्ड दिखाएं. इसमें उपयोगकर्ता को गड़बड़ी का मैसेज दिखेगा. साथ ही, यह भी बताया जाएगा कि गड़बड़ी को कैसे ठीक किया जाए.

सर्वर-साइड से पुष्टि करने की प्रोसेस एसिंक्रोनस होती है. इसलिए, उपयोगकर्ता को इनपुट में हुई गड़बड़ी के बारे में तब तक पता नहीं चल सकता, जब तक वह अपने फ़्लो को पब्लिश नहीं कर लेता.

मेनिफ़ेस्ट फ़ाइल में, पुष्टि किए गए हर इनपुट का id, कोड में मौजूद कार्ड विजेट के name से मेल खाना चाहिए.

यहां दिए गए उदाहरण से पुष्टि होती है कि उपयोगकर्ता के टेक्स्ट इनपुट में "@" चिह्न शामिल है:

मेनिफ़ेस्ट फ़ाइल

मेनिफ़ेस्ट फ़ाइल के इस हिस्से में, onSaveFunction() नाम का एक फ़ंक्शन बताया गया है. इसका नाम "onSave" है:

JSON

{
  "timeZone": "America/Los_Angeles",
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "addOns": {
    "common": {
      "name": "Server-side validation example",
      "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 an email address",
          "workflowAction": {
            "inputs": [
              {
                "id": "email",
                "description": "email address",
                "cardinality": "SINGLE",
                "required": true,
                "dataType": {
                  "basicType": "STRING"
                }
              }
            ],
            "onConfigFunction": "onConfigCalculate",
            "onExecuteFunction": "onExecuteCalculate",
            "onSaveFunction": "onSave"
          }
        }
      ]
    }
  }
}

ऐप्लिकेशन कोड

चरण के कोड में, onSave() नाम का एक फ़ंक्शन शामिल है. यह पुष्टि करता है कि उपयोगकर्ता के डाले गए स्ट्रिंग में @ शामिल है. अगर ऐसा है, तो यह फ़्लो के चरण को सेव करता है. अगर ऐसा नहीं होता है, तो यह गड़बड़ी के मैसेज वाला कॉन्फ़िगरेशन कार्ड दिखाता है. इसमें गड़बड़ी को ठीक करने का तरीका बताया जाता है.

Apps Script

/**
 * Validates user input asynchronously when the user
 * navigates away from a step's configuration card.
*/
function onSave(event) {

  // "email" matches the input ID specified in the manifest file.
  var email = event.workflow.actionInvocation.inputs["email"];

  // Validate that the email address contains an "@" sign:
  if(email.includes("@")) {

  // If successfully validated, save and proceed.
    return {
      "hostAppAction" : {
        "workflowAction" : {
          "saveWorkflowAction" : {}
        }
      }
    };

  // If the input is invalid, return a card with an error message
  } else {

var card = {
    "sections": [
      {
        "header": "Collect Email",
        "widgets": [
          {
            "textInput": {
              "name": "email",
              "label": "email address",
              "hostAppDataSource" : {
                "workflowDataSource" : {
                  "includeVariables" : true
                }
              }
            }
          },
          {
            "textParagraph": {
              "text": "<b>Error:</b> Email addresses must include the '@' sign.",
              "maxLines": 1
            }
          }
        ]
      }
    ]
  };
  return pushCard(card);
  }
}

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

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