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

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

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

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

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

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

मैसेज टेंप्लेट का इस्तेमाल कहां किया जा सकता है? लेख भी पढ़ें.

उदाहरण

उदाहरण के लिए, मैसेज असाइन करने की नीति की मदद से, <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. अगर वैरिएबल को हल नहीं किया जा सकता, तो खाली स्ट्रिंग आउटपुट होती है.

उदाहरण

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

<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 पेलोड के लिए लेगसी सिंटैक्स

16.08.17 को Cloud रिलीज़ होने से पहले के Edge वर्शन में, 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."
}

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

यहां वैरिएबल एक्सट्रैक्ट करने की नीति दी गई है, जो 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>

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

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

इस समस्या को हल करने के लिए, 'मैसेज असाइन करें' नीति में बदलाव करके, मैसेज टेंप्लेट फ़ंक्शन का इस्तेमाल किया जा सकता है. यह फ़ंक्शन, 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>

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

हैश फ़ंक्शन

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

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

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

सिंटैक्स

तर्क

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

उदाहरण

फ़ंक्शन कॉल:

sha256Hex('abc')

नतीजा:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

फ़ंक्शन कॉल:

var str = 'abc';
sha256Hex(str)

नतीजा:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

Base64 हैश फ़ंक्शन

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

सिंटैक्स

तर्क

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

उदाहरण

फ़ंक्शन कॉल:

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 First फ़ंक्शन

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

सिंटैक्स

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 के लिए, वैल्यू को युग के बाद से सेकंड या युग के बाद से मिलीसेकंड में दिया जा सकता है.

उदाहरण

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

• 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

रैंडम लॉन्ग जनरेटर फ़ंक्शन

कोई रैंडम लॉन्ग इंटिजर दिखाता है.

सिंटैक्स

randomLong(args)

तर्क

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

उदाहरण

{random()}

इससे कुछ ऐसा नतीजा मिलता है:

5211338197474042880

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

किसी दी गई रेगुलर एक्सप्रेशन से मैच करने वाली टेक्स्ट स्ट्रिंग जनरेट करता है.

सिंटैक्स

xeger(regex)

आर्ग्यूमेंट

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

उदाहरण

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

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

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

9857253

शून्य को जोड़ने वाला फ़ंक्शन

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

सिंटैक्स

firstnonnull(var1,varn)

आर्ग्यूमेंट

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 फ़ंक्शन

एक्सएमएल वैरिएबल पर 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"

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

<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 जैसी दिखती है. उदाहरण के लिए, xpath() फ़ंक्शन, SOAP बॉडी के चाइल्ड एलिमेंट को चुनता है. यह फ़ंक्शन कुछ ऐसा हो सकता है:

<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)}

चौथा उदाहरण: सामान लौटाने का तरीका तय करना

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']