मैसेज के टेंप्लेट

आपको Apigee Edge का दस्तावेज़ दिख रहा है.
Apigee X के दस्तावेज़ पर जाएं. जानकारी

इस विषय में, एपीआई प्रॉक्सी में मैसेज टेंप्लेट इस्तेमाल करने का तरीका बताया गया है. साथ ही, फ़ंक्शन का रेफ़रंस दिया गया है.

मैसेज टेंप्लेट क्या होता है?

मैसेज टेंप्लेट की मदद से, कुछ नीति और TargetEndpoint एलिमेंट में वैरिएबल स्ट्रिंग सब्स्टिट्यूशन किया जा सकता है. यह सुविधा, जहां उपलब्ध है वहां प्रॉक्सी के चालू होने पर स्ट्रिंग को डाइनैमिक तौर पर भरने की सुविधा देती है.

मैसेज टेंप्लेट में, फ़्लो वैरिएबल के रेफ़रंस और लिटरल टेक्स्ट का कोई भी कॉम्बिनेशन शामिल किया जा सकता है. फ़्लो वैरिएबल के नाम कर्ली ब्रेसिज़ में होने चाहिए. कर्ली ब्रेसिज़ में मौजूद नहीं होने वाले टेक्स्ट को लिटरल टेक्स्ट के तौर पर आउटपुट किया जाता है.

यह भी देखें: मैसेज टेंप्लेट कहां इस्तेमाल किए जा सकते हैं?

उदाहरण

उदाहरण के लिए, Assign Message नीति की मदद से, <Payload> एलिमेंट में मैसेज टेंप्लेट का इस्तेमाल किया जा सकता है:

<AssignMessage name="set-dynamic-content">
  <AssignTo createNew="false" type="response"></AssignTo>
  <Set>
    <Payload contentType="application/json">
      {"name":"Alert", "message":"You entered an invalid username: {user.name}"}
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
</AssignMessage>

ऊपर दिए गए उदाहरण में, फ़्लो वैरिएबल user.name (घुंघराले ब्रैकेट में) की वैल्यू का आकलन किया जाएगा. इसके बाद, इसे रनटाइम के दौरान पेलोड स्ट्रिंग में बदल दिया जाएगा. इसलिए, उदाहरण के लिए, अगर user.name=jdoe, तो पेलोड में मैसेज का आउटपुट यह होगा: You entered an invalid username: jdoe. अगर वैरिएबल को हल नहीं किया जा सकता, तो एक खाली स्ट्रिंग आउटपुट होती है.

उदाहरण

जब कोटा पूरा हो जाता है, तो कॉलर को काम का मैसेज भेजना एक अच्छा तरीका है. इस पैटर्न का इस्तेमाल आम तौर पर "गड़बड़ी के नियम" के साथ किया जाता है, ताकि कॉलर को आउटपुट दिया जा सके. इससे कॉलर को कोटे के उल्लंघन के बारे में जानकारी मिलती है. नीचे दी गई Assign Message नीति में, मैसेज टेंप्लेट का इस्तेमाल किया जाता है. इनका इस्तेमाल, कई XML एलिमेंट में कोटे की जानकारी को डाइनैमिक तरीके से भरने के लिए किया जाता है:

<AssignMessage name='AM-QuotaViolationMessage'>
  <Description>message for quota exceeded</Description>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Set>
    <Headers>
      <Header name='X-Quota-Reset'>{ratelimit.Quota-1.expiry.time}</Header>
      <Header name='X-Quota-Allowed'>{ratelimit.Quota-1.allowed.count}</Header>
      <Header name='X-Quota-Available'>{ratelimit.Quota-1.available.count}</Header>
    </Headers>
    <Payload contentType='application/json'>{
  "error" : {
    "message" : "you have exceeded your quota",
    "clientId" : "{request.queryparam.apikey}"
  }
}
    </Payload>
    <StatusCode>429</StatusCode>
    <ReasonPhrase>Quota Exceeded</ReasonPhrase>
  </Set>
</AssignMessage>

AssignMessage नीति में, <Set> एलिमेंट में मौजूद इन एलिमेंट के लिए, मैसेज टेंप्लेट बनाने की सुविधा उपलब्ध है:

• हेडर
• QueryParam
• FormParam
• PayLoad
• वर्शन
• क्रिया
• पथ
• StatusCode
• ReasonPhrase

फिर से ध्यान दें कि मैसेज टेंप्लेट में फ़्लो वैरिएबल घुंघराले ब्रैकेट में होने चाहिए.

इस नीति के लागू होने पर:

• हेडर एलिमेंट को, फ़्लो वैरिएबल की वैल्यू मिलती हैं.
• पेलोड में लिटरल टेक्स्ट और वैरिएबल, दोनों शामिल होते हैं. client_id को डाइनैमिक तरीके से पॉप्युलेट किया जाता है.
• StatusCode और ReasonPhrase में सिर्फ़ लिटरल टेक्स्ट शामिल होता है. हालांकि, अगर आपको मैसेज टेंप्लेटिंग का इस्तेमाल करना है, तो ये एलिमेंट भी इसका समर्थन करते हैं.

उदाहरण

प्रॉक्सी TargetEndpoint की परिभाषा में, <SSLInfo> के चाइल्ड-एलिमेंट, मैसेज टेंप्लेट बनाने की सुविधा के साथ काम करते हैं. नीतियों में इस्तेमाल किए गए पैटर्न के मुताबिक, कर्ली ब्रेसिज़ में मौजूद फ़्लो वैरिएबल को तब बदल दिया जाता है, जब प्रॉक्सी एक्ज़ीक्यूट होती है.

<TargetEndpoint name="default">
  …
  <HTTPTargetConnection>
    <SSLInfo>
        <Enabled>{myvars.ssl.enabled}</Enabled>
        <ClientAuthEnabled>{myvars.ssl.client.auth.enabled}</ClientAuthEnabled>
        <KeyStore>{myvars.ssl.keystore}</KeyStore>
        <KeyAlias>{myvars.ssl.keyAlias}</KeyAlias>
        <TrustStore>{myvars.ssl.trustStore}</TrustStore>
    </SSLInfo>

  </HTTPTargetConnection>
  …
</TargetEndpoint>

मैसेज टेंप्लेट का इस्तेमाल कहां किया जा सकता है?

मैसेज टेंप्लेट, कई नीतियों के साथ-साथ TargetEndpoint कॉन्फ़िगरेशन में इस्तेमाल किए गए कुछ एलिमेंट के साथ काम करते हैं.

मैसेज टेंप्लेट स्वीकार करने वाली नीतियां

TargetEndpoint के वे एलिमेंट जो मैसेज टेंप्लेट स्वीकार करते हैं

मैसेज के टेम्प्लेट का सिंटैक्स

इस सेक्शन में, मैसेज टेंप्लेट इस्तेमाल करने के लिए ज़रूरी नियमों के बारे में बताया गया है.

वैरिएबल दिखाने के लिए कर्ली ब्रैकेट का इस्तेमाल करना

वैरिएबल के नामों को कर्ली ब्रेसिज़ { } में रखें. अगर वैरिएबल मौजूद नहीं है, तो आउटपुट में एक खाली स्ट्रिंग दिखेगी. हालांकि, मैसेज टेंप्लेट में डिफ़ॉल्ट वैल्यू तय की जा सकती हैं. ये ऐसी वैल्यू होती हैं जिन्हें वैरिएबल के हल न होने पर बदला जाता है. मैसेज टेंप्लेट में डिफ़ॉल्ट वैल्यू सेट करना लेख पढ़ें.

ध्यान दें कि पूरे मैसेज टेंप्लेट स्ट्रिंग को कोटेशन मार्क में रखना ज़रूरी नहीं है, लेकिन ऐसा किया जा सकता है. उदाहरण के लिए, यहां दिए गए दो मैसेज टेंप्लेट एक जैसे हैं:

<Set>
    <Headers>
        <Header name="x-h1">"Hello {user.name}"</Header>
        <Header name="x-h1">Hello {user.name}</Header>
    </Headers>
</Set>

मैसेज टेंप्लेट में डिफ़ॉल्ट वैल्यू सेट करना

अगर टेंप्लेट वाले वैरिएबल को हल नहीं किया जा सकता, तो Edge एक खाली स्ट्रिंग को बदल देता है. हालांकि, डिफ़ॉल्ट वैल्यू इस तरह से तय की जा सकती है:

<Header name="x-h1">Test message. id = {request.header.id:Unknown}</Header>

ऊपर दिए गए सैंपल में, अगर वैरिएबल request.header.id को हल नहीं किया जा सकता, तो इसकी वैल्यू को Unknown से बदल दिया जाता है. उदाहरण के लिए:

Test message. id = Unknown

फ़ंक्शन एक्सप्रेशन में स्पेस इस्तेमाल करने की अनुमति नहीं है

मैसेज टेंप्लेट फ़ंक्शन एक्सप्रेशन में कहीं भी स्पेस की अनुमति नहीं है. उदाहरण के लिए:

अनुमति है:

{substring(alpha,0,4)}
{createUuid()}
{randomLong(10)}

अनुमति नहीं है:

{substring( alpha, 0, 4 )}
{ createUuid( ) }
{randomLong( 10 )}

JSON पेलोड के लिए लेगसी सिंटैक्स

Edge के Cloud release 16.08.17 से पहले के वर्शन में, JSON पेलोड में वैरिएबल रेफ़रंस दिखाने के लिए कर्ली ब्रेसिस का इस्तेमाल नहीं किया जा सकता था. उन पुराने वर्शन में, आपको डेलिमिटर वर्णों के बारे में बताने के लिए variablePrefix और variableSuffix एट्रिब्यूट का इस्तेमाल करना होता था. साथ ही, वैरिएबल के नामों को रैप करने के लिए इनका इस्तेमाल करना होता था. जैसे:

<Set>
  <Payload contentType="application/json" variablePrefix="@" variableSuffix="#">
    {"name":"foo", "type":"@variable_name#"}
  </Payload>
</Set>

Apigee का सुझाव है कि आप कर्ली ब्रेस वाले नए सिंटैक्स का इस्तेमाल करें. हालांकि, पुराना सिंटैक्स अब भी काम करता है.

मैसेज टेंप्लेट फ़ंक्शन का इस्तेमाल करना

Edge, फ़ंक्शन का एक सेट उपलब्ध कराता है. इसका इस्तेमाल मैसेज टेंप्लेट में किया जा सकता है. इससे स्ट्रिंग वैरिएबल को एस्केप, एन्कोड, हैश, और फ़ॉर्मैट किया जा सकता है.

मैसेज टेंप्लेट के फ़ंक्शन के बारे में ज़्यादा जानकारी के लिए, मैसेज टेंप्लेट के फ़ंक्शन का रेफ़रंस लेख पढ़ें.

उदाहरण: toLowerCase()

स्ट्रिंग वैरिएबल को छोटे अक्षरों में बदलने के लिए, पहले से मौजूद toLowerCase() फ़ंक्शन का इस्तेमाल करें:

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
        <Headers>
            <Header name="x-h1">Test header: {toLowerCase(foo.bar:FOO)}</Header>
        </Headers>
    </Set>
</AssignMessage>

अगर foo.bar फ़्लो वैरिएबल हल हो जाता है, तो इसके सभी वर्ण अंग्रेज़ी के छोटे अक्षरों में होंगे. अगर foo.bar को हल नहीं किया जाता है, तो डिफ़ॉल्ट वैल्यू FOO को बदल दिया जाता है और इसे छोटे अक्षरों में बदल दिया जाता है. उदाहरण के लिए:

Test header: foo

उदाहरण: escapeJSON()

यहां इस्तेमाल का एक दिलचस्प उदाहरण दिया गया है: मान लें कि आपका बैकएंड ऐप्लिकेशन, JSON रिस्पॉन्स दिखाता है. इसमें मान्य एस्केप वर्ण शामिल होते हैं. उदाहरण के लिए:

{
      "code": "INVALID",
      "user_message": "Invalid value for \"logonId\" check your input."
}

मान लें कि आपको इस मैसेज को क्लाइंट कॉलर को कस्टम पेलोड में वापस भेजना है. इसके लिए, आम तौर पर टारगेट रिस्पॉन्स पेलोड से मैसेज निकाला जाता है. इसके बाद, असाइन मैसेज का इस्तेमाल करके, उसे कस्टम प्रॉक्सी रिस्पॉन्स में जोड़ा जाता है. इसका मतलब है कि उसे क्लाइंट को वापस भेजा जाता है.

यहां Extract Variables नीति दी गई है, जो user_message की जानकारी को standard.systemMessage नाम के वैरिएबल में एक्सट्रैक्ट करती है:

<ExtractVariables name="EV-BackendErrorResponse">
    <DisplayName>EV-BackendErrorResponse</DisplayName>
    <JSONPayload>
        <Variable name="standard.systemMessage">
            <JSONPath>$.user_message</JSONPath>
        </Variable>
    </JSONPayload>
</ExtractVariables>

यहां, असाइन मैसेज की एक ऐसी नीति दी गई है जो पूरी तरह से मान्य है. यह नीति, निकाले गए वैरिएबल को रिस्पॉन्स पेलोड (प्रॉक्सी रिस्पॉन्स) में जोड़ती है:

<AssignMessage name="AM-SetStandardFaultResponse">
    <DisplayName>AM-SetStandardFaultResponse</DisplayName>
    <Set>
        <Payload contentType="application/json">
           {
              "systemMessage": "{standard.systemMessage}"
           }
        </Payload>
    </Set>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

माफ़ करें, कोई समस्या आ गई है. Extract Variables नीति ने मैसेज के कुछ हिस्से के आस-पास मौजूद, एस्केप किए गए कोटेशन वर्णों को हटा दिया है. इसका मतलब है कि क्लाइंट को मिला जवाब, अमान्य JSON है. यह साफ़ तौर पर आपकी उम्मीद के मुताबिक नहीं है!

{
    "systemMessage": "Invalid value for "logonId" check your input."
}

इस समस्या को हल करने के लिए, Assign Message नीति में बदलाव किया जा सकता है. इसके लिए, message template function का इस्तेमाल करें. यह फ़ंक्शन, JSON में मौजूद कोटेशन मार्क को एस्केप करता है. यह फ़ंक्शन, escapeJSON(), JSON एक्सप्रेशन में मौजूद किसी भी कोट या अन्य खास वर्णों को एस्केप करता है:

<AssignMessage name="AM-SetStandardFaultResponse">
    <DisplayName>AM-SetStandardFaultResponse</DisplayName>
    <Set>
        <Payload contentType="application/json">
           {
              "systemMessage": "{escapeJSON(standard.systemMessage)}"
           }
        </Payload>
    </Set>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

यह फ़ंक्शन, एम्बेड किए गए कोट को एस्केप करता है. इससे मान्य JSON मिलता है, जो आपको चाहिए था:

{
      "systemMessage": "Invalid value for \"logonId\" check your input.",
}

मैसेज टेंप्लेट, डाइनैमिक स्ट्रिंग बदलने की सुविधा है. इसका इस्तेमाल कुछ नीतियों और TargetEndpoint की परिभाषाओं में किया जा सकता है. मैसेज टेंप्लेट फ़ंक्शन की मदद से, मैसेज टेंप्लेट में कई ज़रूरी कार्रवाइयां की जा सकती हैं. जैसे, हैशिंग, स्ट्रिंग में बदलाव करना, वर्णों को एस्केप करना वगैरह.

उदाहरण के लिए, यहां दी गई AssignMessage नीति में, मैसेज टेंप्लेट में toLowerCase() फ़ंक्शन का इस्तेमाल किया गया है:

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
       <Headers>
         <Header name="x-h1">Test header: {Hello, toLowerCase(user.name)}</Header>
       </Headers>
    </Set>
</AssignMessage>

इस विषय में, मैसेज टेंप्लेट फ़ंक्शन, उनके आर्ग्युमेंट, और आउटपुट के बारे में बताया गया है. इस विषय में यह माना गया है कि आपको मैसेज टेंप्लेट और उनके इस्तेमाल के संदर्भों के बारे में जानकारी है.

हैश फ़ंक्शन

हैश वैल्यू का हिसाब लगाता है और उस हैश का स्ट्रिंग रिप्रेजेंटेशन दिखाता है.

हेक्साडेसिमल हैश फ़ंक्शन

हैश वैल्यू का हिसाब लगाता है और उस हैश के स्ट्रिंग प्रज़ेंटेशन को हेक्साडेसिमल संख्या के तौर पर दिखाता है.

सिंटैक्स

तर्क

string - हैश फ़ंक्शन में सिर्फ़ एक स्ट्रिंग आर्ग्युमेंट होता है. इस पर हैश एल्गोरिदम लागू किया जाता है. आर्ग्युमेंट, लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल हो सकता है.

उदाहरण

फ़ंक्शन कॉल:

sha256Hex('abc')

नतीजा:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

फ़ंक्शन कॉल:

var str = 'abc';
sha256Hex(str)

नतीजा:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

Base64 हैश फ़ंक्शन

यह फ़ंक्शन, हैश वैल्यू का हिसाब लगाता है. साथ ही, उस हैश के स्ट्रिंग प्रज़ेंटेशन को Base64 के तौर पर कोड की गई वैल्यू के तौर पर दिखाता है.

सिंटैक्स

तर्क

string - हैश फ़ंक्शन में सिर्फ़ एक स्ट्रिंग आर्ग्युमेंट होता है. इस पर हैश एल्गोरिदम लागू किया जाता है. आर्ग्युमेंट, लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वेरिएबल हो सकता है.

उदाहरण

फ़ंक्शन कॉल:

sha256Base64('abc')

नतीजा:

ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=

फ़ंक्शन कॉल:

var str = 'abc';
sha256Base64(str)

नतीजा:

ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=

स्ट्रिंग फ़ंक्शन

मैसेज टेंप्लेट में मौजूद स्ट्रिंग पर कार्रवाइयां करें.

Base64 एन्कोडिंग फ़ंक्शन

Base64 एन्कोडिंग स्कीम का इस्तेमाल करके, स्ट्रिंग को कोड में बदलें और डिकोड करें.

सिंटैक्स

तर्क

string - वह स्ट्रिंग जिसे कोड में बदलना है या डिकोड करना है. यह लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल हो सकता है.

उदाहरण

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
       <Headers>
         <Header name="x-h1">Hello, {decodeBase64('d29ybGQK')}</Header>
       </Headers>
    </Set>
</AssignMessage>

केस कन्वर्ज़न फ़ंक्शन

किसी स्ट्रिंग को पूरी तरह से अपरकेस या लोअरकेस में बदलें.

सिंटैक्स

आर्ग्युमेंट

string - वह स्ट्रिंग जिसे बदलना है. यह लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल हो सकता है.

उदाहरण

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
       <Headers>
         <Header name="x-h1">Hello, {toLowerCase(user.name)}</Header>
       </Headers>
    </Set>
</AssignMessage>

सबस्ट्रिंग फ़ंक्शन

यह फ़ंक्शन, दी गई स्ट्रिंग के शुरुआती और आखिरी इंडेक्स के बीच के वर्ण दिखाता है.

सिंटैक्स

substring(str,start_index,end_index)

तर्क

• str - लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल.
• start_index - स्ट्रिंग में शुरुआती इंडेक्स.
• end_index - (ज़रूरी नहीं) स्ट्रिंग में आखिरी इंडेक्स. अगर यह वैल्यू नहीं दी जाती है, तो इंडेक्स के आखिर में स्ट्रिंग खत्म हो जाती है.

उदाहरण

यहां दिए गए उदाहरणों के लिए, मान लें कि ये फ़्लो वैरिएबल मौजूद हैं:

इन वैरिएबल का इस्तेमाल करने वाले फ़ंक्शन कॉल के नतीजे यहां दिए गए हैं:

'सभी बदलें' फ़ंक्शन

यह फ़ंक्शन, किसी स्ट्रिंग पर रेगुलर एक्सप्रेशन लागू करता है. साथ ही, मैच करने वाले किसी भी टेक्स्ट को बदली गई वैल्यू से बदल देता है.

सिंटैक्स

replaceAll(string,regex,value)

तर्क

• string - कोई लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल, जिसमें बदलाव करने हैं.
• regex - एक रेगुलर एक्सप्रेशन.
• value - स्ट्रिंग में रेगुलर एक्सप्रेशन से मैच करने वाली सभी वैल्यू को बदलने के लिए इस्तेमाल की जाने वाली वैल्यू.

उदाहरण

यहां दिए गए उदाहरणों के लिए, मान लें कि ये फ़्लो वैरिएबल मौजूद हैं:

इन वैरिएबल का इस्तेमाल करने वाले फ़ंक्शन कॉल के नतीजे यहां दिए गए हैं:

REPLACE फ़ंक्शन

यह फ़ंक्शन, स्ट्रिंग में रेगुलर एक्सप्रेशन से मेल खाने वाले सिर्फ़ पहले टेक्स्ट को बदलता है.

सिंटैक्स

replaceFirst(string,regex,value)

तर्क

• string - कोई लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल, जिसमें बदलाव करने हैं.
• regex - एक रेगुलर एक्सप्रेशन.
• value - यह वह वैल्यू होती है जिसका इस्तेमाल, स्ट्रिंग में रेगुलर एक्सप्रेशन से मैच होने वाले टेक्स्ट को बदलने के लिए किया जाता है.

कैरेक्टर एस्केप और एन्कोडिंग फ़ंक्शन

ऐसे फ़ंक्शन जो किसी स्ट्रिंग में मौजूद खास वर्णों को एस्केप या कोड में बदलते हैं.

सिंटैक्स

तर्क

string - वह स्ट्रिंग जिसे एस्केप करना है. यह लिटरल स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल हो सकता है.

इस्तेमाल की जानकारी

XML 1.1, कुछ कंट्रोल वर्णों को दिखा सकता है. हालांकि, यह नल बाइट या अनपेयर्ड यूनिकोड सरोगेट कोडपॉइंट को नहीं दिखा सकता. भले ही, उन्हें एस्केप कर दिया गया हो. escapeXML11() फ़ंक्शन, उन वर्णों को हटाता है जो इन रेंज में नहीं आते:

[#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]

escapeXML11() फ़ंक्शन, इन रेंज में मौजूद वर्णों को एस्केप करता है:

[#x1-#x8] | [#xB-#xC] | [#xE-#x1F] | [#x7F-#x84] | [#x86-#x9F]

उदाहरण

मान लें कि food नाम का एक फ़्लो वैरिएबल मौजूद है, जिसकी वैल्यू यह है: "bread" & "butter". इसके बाद, फ़ंक्शन:

{escapeHTML(food)}

इसके नतीजे:

समय के फ़ॉर्मैट से जुड़े फ़ंक्शन

यह फ़ंक्शन, समय को स्ट्रिंग के तौर पर दिखाता है. इसे स्थानीय टाइम ज़ोन या यूटीसी के हिसाब से फ़ॉर्मैट किया जाता है.

सिंटैक्स

तर्क

• format - तारीख/समय के फ़ॉर्मैट वाली स्ट्रिंग. यह लिटरल स्ट्रिंग या स्ट्रिंग वैरिएबल हो सकता है.
• str - यह एक स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल है, जिसमें समय की वैल्यू होती है. timeFormatMs के लिए, वैल्यू को seconds-since-epoch या milliseconds-since-epoch में दिखाया जा सकता है.

उदाहरण

मान लें कि ये वैल्यू दी गई हैं और स्थानीय टाइमज़ोन पैसिफ़िक है:

• epoch_time_ms = 1494390266000
• epoch_time = 1494390266
• fmt1 = yyyy-MM-dd
• fmt2 = yyyy-MM-dd HH-mm-ss
• fmt3 = yyyyMMddHHmmss

ये फ़ंक्शन, ये नतीजे दिखाते हैं:

फ़ंक्शन	आउटपुट
timeFormatMs(fmt1,epoch_time_ms)	2017-05-09
timeFormat(fmt1,epoch_time)	2017-05-09
timeFormat(fmt2,epoch_time)	2017-05-09 21:24:26
timeFormat(fmt3,epoch_time)	20170509212426
timeFormatUTC(fmt1,epoch_time)	2017-05-10
timeFormatUTC(fmt2,epoch_time)	2017-05-10 04:24:26
timeFormatUTC(fmt3,epoch_time)	20170510042426

एचएमएसी कैलकुलेशन फ़ंक्शन

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

सिंटैक्स

सुविधा	ब्यौरा
hmacSha224(key,valueToSign[,keyencoding[,outputencoding]])	यह SHA-224 हैश फ़ंक्शन का इस्तेमाल करके, एचएमएसी की गणना करता है.
hmacSha256(key,valueToSign[,keyencoding[,outputencoding]])	यह SHA-256 हैश फ़ंक्शन का इस्तेमाल करके, एचएमएसी को कोड में बदलता है.
hmacSha384(key,valueToSign[,keyencoding[,outputencoding]])	यह SHA-384 हैश फ़ंक्शन का इस्तेमाल करके, एचएमएसी को कोड में बदलता है.
hmacSha512(key,valueToSign[,keyencoding[,outputencoding]])	यह SHA-512 हैश फ़ंक्शन का इस्तेमाल करके, एचएमएसी को एन्कोड करता है.
hmacMd5(key,valueToSign[,keyencoding[,outputencoding]])	यह MD5 हैश फ़ंक्शन का इस्तेमाल करके, एचएमएसी को कोड में बदलता है.
hmacSha1(key, valueToSign [,keyencoding[,outputencoding]])	यह SHA-1 एन्क्रिप्शन एल्गोरिदम की मदद से, एचएमएसी को कोड में बदलता है.

तर्क

• key - (ज़रूरी है) यह पैरामीटर, एचएमएसी को कंप्यूट करने के लिए इस्तेमाल की गई सीक्रेट कुंजी के बारे में बताता है. इसे स्ट्रिंग के तौर पर कोड में बदला जाता है.
• valueToSign - (ज़रूरी है) इस पैरामीटर में, साइन किए जाने वाले मैसेज के बारे में बताया जाता है. यह एक स्ट्रिंग होनी चाहिए.
• keyencoding - (ज़रूरी नहीं) सीक्रेट कुंजी स्ट्रिंग को इस तय किए गए एन्कोडिंग के हिसाब से डिकोड किया जाएगा. मान्य वैल्यू: hex, base16, base64, utf-8. डिफ़ॉल्ट: utf-8
• outputencoding - (ज़रूरी नहीं) यह पैरामीटर, आउटपुट के लिए इस्तेमाल किए जाने वाले एन्कोडिंग एल्गोरिदम के बारे में बताता है. मान्य वैल्यू: hex, base16, base64. वैल्यू केस-इनसेंसिटिव होती हैं. hex और base16 एक जैसे हैं. डिफ़ॉल्ट: base64

उदाहरण

इस उदाहरण में, HMAC-256 की गिनती करने और उसे फ़्लो वैरिएबल को असाइन करने के लिए, AssignMessage नीति का इस्तेमाल किया गया है:

<AssignMessage name='AM-HMAC-1'>
  <AssignVariable>
    <Name>valueToSign</Name>
    <Template>{request.header.apikey}.{request.header.date}</Template>
  </AssignVariable>
  <AssignVariable>
    <Name>hmac_value</Name>
    <Template>{hmacSha256(private.secretkey,valueToSign)}</Template>
  </AssignVariable>
</AssignMessage>

इस उदाहरण में, कैस्केडिंग एचएमएसी जनरेट करने का तरीका बताया गया है. इसका इस्तेमाल AWS Signature v4 की साइनिंग प्रोसेस के साथ किया जा सकता है. इस उदाहरण में, AssignMessage नीति का इस्तेमाल करके, कैस्केड किए गए एचएमएसी के पांच लेवल जनरेट किए गए हैं. इनका इस्तेमाल, AWS Signature v4 के लिए सिग्नेचर का हिसाब लगाने के लिए किया जाता है:

<AssignMessage name='AM-HMAC-AWS-1'>
  <!-- 1 -->
  <AssignVariable>
    <Name>DateValue</Name>
    <Template>{timeFormatUTCMs('yyyyMMdd',system.timestamp)}</Template>
  </AssignVariable>
  <!-- 2 -->
  <AssignVariable>
    <Name>FirstKey</Name>
    <Template>AWS4{private.secret_aws_access_key}</Template>
  </AssignVariable>
  <!-- 3 -->
  <AssignVariable>
    <Name>DateKey</Name>
    <Template>{hmacSha256(FirstKey,DateValue,'utf-8','base16')}</Template>
  </AssignVariable>
  <!-- 4 -->
  <AssignVariable>
    <Name>DateRegionKey</Name>
    <Template>{hmacSha256(DateKey,aws_region,'base16','base16')}</Template>
  </AssignVariable>
  <!-- 5 -->
  <AssignVariable>
    <Name>DateRegionServiceKey</Name>
    <Template>{hmacSha256(DateRegionKey,aws_service,'base16','base16')}</Template>
  </AssignVariable>
  <!-- 6 -->
  <AssignVariable>
    <Name>SigningKey</Name>
    <Template>{hmacSha256(DateRegionServiceKey,'aws4_request','base16','base16')}</Template>
  </AssignVariable>
  <!-- 7 -->
  <AssignVariable>
    <Name>aws4_hmac_value</Name>
    <Template>{hmacSha256(SigningKey,stringToSign,'base16','base16')}</Template>
  </AssignVariable>
</AssignMessage>

अन्य फ़ंक्शन

UUID फ़ंक्शन बनाना

यह फ़ंक्शन, यूयूआईडी जनरेट करता है और उसे दिखाता है.

सिंटैक्स

createUuid()

तर्क

कोई नहीं.

उदाहरण

{createUuid()}

नतीजे का उदाहरण:

ec3ca9be-d1e1-4ef4-aee4-4a58f3130db8

Random Long Generator फ़ंक्शन

यह फ़ंक्शन, एक यादृच्छिक पूर्णांक दिखाता है.

सिंटैक्स

randomLong(args)

तर्क

• अगर कोई आर्ग्युमेंट नहीं दिया जाता है, तो फ़ंक्शन एक रैंडम पूर्णांक दिखाता है. यह पूर्णांक, Java SecureRandom क्लास के हिसाब से तय होता है.
• अगर एक आर्ग्युमेंट मौजूद है, तो उसे कैलकुलेशन की सबसे कम वैल्यू माना जाता है.
• अगर दूसरा आर्ग्युमेंट मौजूद है, तो इसे कैलकुलेशन की ज़्यादा से ज़्यादा वैल्यू माना जाता है.

उदाहरण

{random()}

इस तरह का दिखता है:

5211338197474042880

रेगुलर एक्सप्रेशन जनरेट करने वाला टूल

ऐसी टेक्स्ट स्ट्रिंग जनरेट करें जो दिए गए रेगुलर एक्सप्रेशन से मेल खाती हो.

सिंटैक्स

xeger(regex)

आर्ग्यूमेंट

regex - एक रेगुलर एक्सप्रेशन.

उदाहरण

इस उदाहरण में, बिना किसी शून्य वाली सात अंकों की स्ट्रिंग जनरेट की गई है:

xeger('[1-9]{7}')

नतीजे का उदाहरण:

9857253

नल-कोएलसिंग फ़ंक्शन

firstnonnull() फ़ंक्शन, सबसे बाईं ओर मौजूद ऐसे आर्ग्युमेंट की वैल्यू दिखाता है जो शून्य नहीं है.

सिंटैक्स

firstnonnull(var1,varnn>)

आर्ग्यूमेंट

var1 - यह कॉन्टेक्स्ट वैरिएबल है.

var_n - एक या उससे ज़्यादा कॉन्टेक्स्ट वैरिएबल. सबसे दाईं ओर मौजूद आर्ग्युमेंट को स्ट्रिंग पर सेट किया जा सकता है, ताकि फ़ॉलबैक वैल्यू दी जा सके. फ़ॉलबैक वैल्यू वह वैल्यू होती है जो बाईं ओर मौजूद किसी भी आर्ग्युमेंट के सेट न होने पर सेट की जाती है.

उदाहरण

इस टेबल में, फ़ंक्शन इस्तेमाल करने का तरीका बताया गया है:

टेंप्लेट	Var1	Var2	Var3	नतीजा
{firstnonnull(var1,var2)}	सेट नहीं है	foo	लागू नहीं	foo
{firstnonnull(var1,var2)}	foo	bar	लागू नहीं	foo
{firstnonnull(var1,var2)}	foo	सेट नहीं है	लागू नहीं	foo
{firstnonnull(var1,var2,var3)}	foo	bar	baz	foo
{firstnonnull(var1,var2,var3)}	सेट नहीं है	bar	baz	bar
{firstnonnull(var1,var2,var3)}	सेट नहीं है	सेट नहीं है	baz	baz
{firstnonnull(var1,var2,var3)}	सेट नहीं है	सेट नहीं है	सेट नहीं है	null
{firstnonnull(var1)}	सेट नहीं है	लागू नहीं	लागू नहीं	null
{firstnonnull(var1)}	foo	लागू नहीं	लागू नहीं	foo
{firstnonnull(var1,var2)}	""	bar	लागू नहीं	""
{firstnonnull(var1,var2,'fallback value')}	null	null	fallback value	fallback value

XPath फ़ंक्शन

यह फ़ंक्शन, किसी XML वैरिएबल पर XPath एक्सप्रेशन लागू करता है.

सिंटैक्स

xpath(xpath_expression,xml_string,[datatype])

तर्क

xpath_expression - एक XPath एक्सप्रेशन.

xml_string - एक्सएमएल वाला फ़्लो वैरिएबल या स्ट्रिंग.

datatype - (वैकल्पिक) इससे क्वेरी के लिए, जवाब का पसंदीदा रिटर्न टाइप तय किया जाता है. यह नोडसेट, नोड, संख्या, बूलियन, स्ट्रिंग हो सकता है. यह डिफ़ॉल्ट रूप से nodeset पर सेट होता है. डिफ़ॉल्ट सेटिंग आम तौर पर सही होती है.

उदाहरण 1

मान लें कि कॉन्टेक्स्ट वैरिएबल, एक्सएमएल स्ट्रिंग और XPath एक्सप्रेशन को इस तरह से तय करते हैं:

xml = "<tag><tagid>250397</tagid><readerid>1</readerid><rssi>74</rssi><date>2019/06/15</date></tag>"
xpath = "/tag/tagid"

साथ ही, AssignMessage नीति में xpath() फ़ंक्शन का इस्तेमाल इस तरह किया जाता है:

<AssignMessage>
  <AssignVariable>
    <Name>extracted_tag</Name>
    <Template>{xpath(xpath,xml)}</Template>
  </AssignVariable>
</AssignMessage><

यह फ़ंक्शन, <tagid>250397</tagid> वैल्यू दिखाता है. यह वैल्यू, extracted_tag नाम के कॉन्टेक्स्ट वैरिएबल में रखी जाती है.

उदाहरण 2

अगर आपको सिर्फ़ नोड की वैल्यू चाहिए, तो text() फ़ंक्शन का इस्तेमाल करें. इसका तरीका यहां दिया गया है:

<AssignMessage>
  <AssignVariable>
    <Name>extracted_tag</Name>
    <Template>{xpath('/tag/tagid/text()',xml)}</Template>
  </AssignVariable>
</AssignMessage>

इस कार्रवाई के बाद, कॉन्टेक्स्ट वैरिएबल extracted_tag को 250397 पर सेट कर दिया जाता है

अगर एक से ज़्यादा नोड चुने जाते हैं, तो xpath() का नतीजा, चुने गए सभी नोड की वैल्यू होती है. इन वैल्यू को कॉमा लगाकर जोड़ा जाता है.

तीसरा उदाहरण: एक्सएमएल नेमस्पेस

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

<AssignMessage>
  <AssignVariable>
    <Name>soapns</Name>
    <Value>soap:http://schemas.xmlsoap.org/soap/envelope/</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>xpathexpression</Name>
    <Value>/soap:Envelope/soap:Body/*</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>extracted_element</Name>
    <Template>{xpath(xpathexpression,xml,soapns)}</Template>
  </AssignVariable>
</AssignMessage>

अन्य नेमस्पेस के लिए, xpath() फ़ंक्शन में ज़्यादा से ज़्यादा 10 पैरामीटर जोड़े जा सकते हैं.

सिंगल कोटेशन मार्क में बंद की गई स्ट्रिंग के तौर पर, सामान्य XPath एक्सप्रेशन तय किया जा सकता है:

{xpath('/tag/tagid/text()',xml)}

अगर XPath एक्सप्रेशन में नेमस्पेस प्रीफ़िक्स (और कोलन) शामिल हैं, तो आपको उस XPath एक्सप्रेशन को किसी वैरिएबल को असाइन करना होगा. साथ ही, एक्सप्रेशन को सीधे तौर पर इस्तेमाल करने के बजाय, वैरिएबल का नाम तय करना होगा.

{xpath(xpathexpression,xml,ns1)}

उदाहरण 4: मनचाहा रिटर्न टाइप तय करना

xpath() फ़ंक्शन को पास किया गया तीसरा पैरामीटर (ज़रूरी नहीं) क्वेरी के लिए, नतीजे के टाइप के बारे में बताता है.

कुछ XPath क्वेरी, न्यूमेरिक या बूलियन वैल्यू दिखा सकती हैं. उदाहरण के लिए, count() फ़ंक्शन एक संख्या दिखाता है. यह एक मान्य XPath क्वेरी है:

count(//Record/Fields/Pair)

यह मान्य क्वेरी, बूलियन वैल्यू दिखाती है:

count(//Record/Fields/Pair)>0

ऐसे मामलों में, xpath() फ़ंक्शन को तीसरे पैरामीटर के साथ लागू करें. इससे उस टाइप के बारे में पता चलेगा:

{xpath(expression,xml,'number')}
{xpath(expression,xml,'boolean')}

अगर तीसरे पैरामीटर में कोलन मौजूद है, तो इसे नेमस्पेस आर्ग्युमेंट के तौर पर माना जाता है. अगर ऐसा नहीं है, तो इसे रिटर्न टाइप माना जाता है. इस मामले में, अगर तीसरा पैरामीटर मान्य वैल्यू में से कोई एक नहीं है (केस को अनदेखा करके), तो xpath() फ़ंक्शन डिफ़ॉल्ट रूप से नोडसेट दिखाता है.

JSON पाथ फ़ंक्शन

यह फ़ंक्शन, JSON वैरिएबल पर JSON पाथ एक्सप्रेशन लागू करता है.

सिंटैक्स

jsonPath(json-path,json-var,want-array)

तर्क

• (ज़रूरी है) json-path: (स्ट्रिंग) JSON पाथ एक्सप्रेशन.
• (ज़रूरी है) json-var: (स्ट्रिंग) फ़्लो वैरिएबल या JSON वाली स्ट्रिंग.
• (ज़रूरी नहीं) want-array: (स्ट्रिंग) अगर इस पैरामीटर को 'true' पर सेट किया जाता है और नतीजों का सेट एक कलेक्शन है, तो कलेक्शन के सभी एलिमेंट दिखाए जाते हैं. किसी अन्य वैल्यू पर सेट होने पर या इस पैरामीटर को शामिल न करने पर, नतीजों के सेट के कलेक्शन का सिर्फ़ शून्यवां एलिमेंट दिखता है. अगर नतीजे का सेट एक ऐरे नहीं है, तो तीसरे पैरामीटर को अनदेखा कर दिया जाता है.

उदाहरण 1

अगर यह मैसेज टेंप्लेट है:

The address is {jsonPath($.results[?(@.name == 'Mae West')].address.line1,the_json_variable)}

और the_json_variable में यह शामिल है:

{
  "results" : [
    {
      "address" : {
        "line1" : "18250 142ND AV NE",
        "city" : "Woodinville",
        "state" : "Washington",
        "zip" : "98072"
      },
      "name" : "Fred Meyer"
    },
    {
      "address" : {
        "line1" : "1060 West Addison Street",
        "city" : "Chicago",
        "state" : "Illinois",
        "zip" : "60613"
      },
      "name" : "Mae West"
    }
  ]
} 

फ़ंक्शन का नतीजा यह है:

The address is 1060 West Addison Street

ध्यान दें कि इस मामले में, नतीजे का सेट एक एलिमेंट है, न कि एलिमेंट का कलेक्शन. अगर नतीजे का सेट एक कलेक्शन होता, तो कलेक्शन का सिर्फ़ पहला एलिमेंट दिखाया जाता. पूरा कलेक्शन वापस पाने के लिए, तीसरे पैरामीटर के तौर पर 'true' का इस्तेमाल करके फ़ंक्शन को कॉल करें. ऐसा अगले उदाहरण में दिखाया गया है.

उदाहरण 2

अगर यह मैसेज टेंप्लेट है:

{jsonPath($.config.quota[?(@.operation=='ManageOrder')].appname,the_json_variable,'true')}

और the_json_variable में यह शामिल है:

{
  "results" : [
     {
      "config": {
        "quota": [
          {
            "appname": "A",
            "operation": "ManageOrder",
            "value": "900"
          },
          {
            "appname": "B",
            "operation": "ManageOrder",
            "value": "1000"
          },
          {
            "appname": "B",
            "operation": "SubmitOrder",
            "value": "800"
          }
        ]
      }
    }
  ]
} 

फ़ंक्शन का नतीजा यह है:

['A','B']