इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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>

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

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

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

यह नीति कब लागू होती है:

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

उदाहरण

प्रॉक्सी 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 कॉन्फ़िगरेशन में इस्तेमाल किए जाने वाले कुछ एलिमेंट में भी काम करते हैं.

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

नीति	मैसेज टेंप्लेट के साथ काम करने वाले एलिमेंट और चाइल्ड एलिमेंट
ऐक्सेस कंट्रोल की नीति	`<SourceAddress>`, `mask` एट्रिब्यूट और आईपी पते के लिए.
AssignmentMessage की नीति	`<Set>` चाइल्ड एलिमेंट: पेलोड, ContentType, वर्ब, वर्शन, पाथ, स्टेटस कोड, वरण वाक्यांश, हेडर, क्वेरीParams, formParams `<Add>` चाइल्ड एलिमेंट: हेडर, QueryParams, FormsParams `<AssignVariable>` चाइल्ड एलिमेंट: `<Template>`
एक्सटेंशन की कॉल आउट की नीति	`<Input>`
ExtractVariables की नीति	`<JsonPath>` `<XMLPath>` के लिए, मैसेज का टेंप्लेट स्वीकार नहीं किया जाता.
GenerateJWS नीति पुष्टि JWS नीति	`<Payload>` (सिर्फ़ GenerateJWS नीति) `<AdditionalHeaders><Claim>` * ये एलिमेंट, मैसेज टेंप्लेट के साथ सिर्फ़ तब काम करते हैं, जब type=map.
GenerateJWT की नीति पुष्टि करेंJWT नीति	`<AdditionalClaims><Claim>` `<AdditionalHeaders><Claim>` * ये एलिमेंट, मैसेज टेंप्लेट के साथ सिर्फ़ तब काम करते हैं, जब type=map.
LDAP नीति	`<SearchQuery>`
MessageLogging नीति	`<Syslog><Message>` `<File><Message>`
OASपुष्टि की नीति	`<OASResource>` एलिमेंट
riseFault की नीति	`<Set>` एलिमेंट: पेलोड, ContentType, वर्ब, वर्शन, पाथ, स्टेटस कोड, वजह वाक्यांश, हेडर, क्वेरीParams, FormsParams `<Add>` एलिमेंट: हेडर, QueryParams, FormsParams
SAMLAssertion की नीति	`<Template>` * सिर्फ़ तब, जब नीति हस्ताक्षर `<GenerateSAMLAssertion>` हो
सेवा कॉलआउट की नीति	`<Set>` एलिमेंट: पेलोड, ContentType, वर्ब, वर्शन, पाथ, स्टेटस कोड, वजह वाक्यांश, /Headers, QueryParams, formParams `<Add>` एलिमेंट: हेडर, QueryParams, FormsParams `<HTTPTargetConnection>/<URL>`: ध्यान दें कि स्ट्रिंग का पहला हिस्सा एचटीटीपी या एचटीटीपीएस होना चाहिए.

टारगेट एंडपॉइंट के ऐसे एलिमेंट जो मैसेज के टेंप्लेट स्वीकार करते हैं

HTTPTargetConnection एलिमेंट	मैसेज के टेंप्लेट के साथ काम करने वाले चाइल्ड एलिमेंट
SSLInfo	चालू है, KeyAlias, KeyStore, TrustStore, ClientAuthEnabled, CLRStore
LocalTargetConnection	Apiप्रॉक्सी, प्रॉक्सीEndpoint
पाथ	लागू नहीं

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

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

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

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

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

<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 के वर्शन में, क्लाउड रिलीज़ 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."
}

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

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

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

फ़ंक्शन कॉल को नेस्ट नहीं किया जा सकता. उदाहरण के लिए, ये काम नहीं किए जा सकते:

{substring({timeFormat("yyyy-MM-dd","1494390266")},0,4)}

हैश फ़ंक्शन

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

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

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

सिंटैक्स

फ़ंक्शन	जानकारी
`md5Hex(string)`	हेक्साडेसिमल संख्या के रूप में बताए गए MD5 हैश की गणना करता है.
`sha1Hex(string)`	हेक्साडेसिमल संख्या के रूप में बताए गए SHA1 हैश की गणना करता है.
`sha256Hex(string)`	हेक्साडेसिमल संख्या के रूप में बताए गए SHA256 हैश की गणना करता है.
`sha384Hex(string)`	हेक्साडेसिमल संख्या के रूप में बताए गए SHA384 हैश की गणना करता है.
`sha512Hex(string)`	हेक्साडेसिमल संख्या के रूप में बताए गए SHA512 हैश की गणना करता है.

तर्क

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

उदाहरण

फ़ंक्शन कॉल:

sha256Hex('abc')

नतीजा:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

फ़ंक्शन कॉल:

var str = 'abc';
sha256Hex(str)

नतीजा:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

Base64 हैश फ़ंक्शन

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

सिंटैक्स

फ़ंक्शन	जानकारी
`md5Base64(string)`	Base64 कोड में बदली गई वैल्यू के तौर पर दिखाए गए MD5 हैश को प्रोसेस करता है.
`sha1Base64(string)`	Base64 कोड में बदली गई वैल्यू के तौर पर दिखाए गए SHA1 हैश की जांच करता है.
`sha256Base64(string)`	यह Base64 कोड में बदली गई वैल्यू के तौर पर दिखाए गए SHA256 हैश को प्रोसेस करता है.
`sha384Base64(string)`	यह उस SHA384 हैश की गणना करता है जिसे Base64 कोड में बदले गए वैल्यूर के तौर पर दिखाया गया है.
`sha512Base64(string)`	Base64 कोड में बदली गई वैल्यू के तौर पर दिखाए गए SHA512 हैश की जांच करता है.

तर्क

उदाहरण

फ़ंक्शन कॉल:

sha256Base64('abc')

नतीजा:

ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=

फ़ंक्शन कॉल:

var str = 'abc';
sha256Base64(str)

नतीजा:

ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=

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

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

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

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

सिंटैक्स

फ़ंक्शन	जानकारी
`encodeBase64(string)`	Base64 कोड में बदलने के तरीके का इस्तेमाल करके स्ट्रिंग को कोड में बदलता है. उदाहरण के लिए: `encodeBase64(value)`, जब `value` `abc` को होल्ड करता है, तो फ़ंक्शन स्ट्रिंग देता है: `YWJj`
`decodeBase64(string)`	Base64 से कोड में बदली गई स्ट्रिंग को डिकोड करता है. उदाहरण के लिए: `decodeBase64(value)` जब `value` को होल्ड करके `aGVsbG8sIHdvcmxk` होता है, तब फ़ंक्शन, स्ट्रिंग `hello, world` दिखाता है.

तर्क

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>

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

किसी स्ट्रिंग को बड़े या सभी छोटे अक्षरों में बदलें.

सिंटैक्स

फ़ंक्शन	जानकारी
`toUpperCase(string)`	स्ट्रिंग को बड़े अक्षरों (अपरकेस) में बदलें.
`toLowerCase(string)`	स्ट्रिंग को अंग्रेज़ी के छोटे अक्षरों में बदलें.

आर्ग्यूमेंट

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 - (ज़रूरी नहीं) स्ट्रिंग का आखिरी इंडेक्स. अगर स्ट्रिंग नहीं दी जाती है, तो आखिरी इंडेक्स, स्ट्रिंग का आखिरी हिस्सा होता है.

उदाहरण

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

वैरिएबल का नाम	वैल्यू
`alpha`	ABCDEFGHIJKLMNOPQRSTUVWXYZ
`seven`	7

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

मैसेज टेंप्लेट एक्सप्रेशन	नतीजा
`{substring(alpha,22)}`	`WXYZ`
`hello {substring(alpha,22)}`	`hello WXYZ`
`{substring(alpha,-4)}`	`WXYZ`
`{substring(alpha,-8,-4)}`	`STUV`
`{substring(alpha,0,10)}`	`ABCDEFGHIJ`
`{substring(alpha,0,seven)}`	`ABCDEFG`

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

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

सिंटैक्स

replaceAll(string,regex,value)

तर्क

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

उदाहरण

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

वैरिएबल का नाम	वैल्यू
`header`	`Bearer ABCDEFGHIJKLMNOPQRSTUVWXYZ-9993`
`regex1`	`"^Bearer "`
`replacement`	`"TOKEN: "`

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

मैसेज टेंप्लेट एक्सप्रेशन	नतीजा
`{replaceAll(header,"9993",'')}`	`Bearer ABCDEFGHIJKLMNOPQRSTUVWXYZ-`
`{replaceAll(header,regex1,'')}`	`ABCDEFGHIJKLMNOPQRSTUVWXYZ-9993`
`{replaceAll(header,regex1,replacement)}`	`TOKEN: ABCDEFGHIJKLMNOPQRSTUVWXYZ-9993`

पहले फ़ंक्शन को बदलें

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

सिंटैक्स

replaceFirst(string,regex,value)

तर्क

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

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

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

सिंटैक्स

फ़ंक्शन	जानकारी
escapeJSON(स्ट्रिंग)	बैकस्लैश-एस्केप डबल-कोट्स.
escapeXML(स्ट्रिंग)	ऐंगल ब्रैकेट, अपॉस्ट्रफ़ी, डबल कोट, और ऐंपरसैंड को संबंधित एक्सएमएल इकाइयों से बदलता है. एक्सएमएल 1.0 दस्तावेज़ों के लिए इस्तेमाल करें. XML1.0 दस्तावेज़ों के लिए escapeXML और 1.1 दस्तावेज़ों के लिए escapeXML11 का इस्तेमाल करें.
escapeXML11(स्ट्रिंग)	escapeXML की तरह ही काम करता है, लेकिन एक्सएमएल v1.1 इकाइयों के लिए. नीचे इस्तेमाल की जानकारी देखें.
एनकोडएचटीएमएल(स्ट्रिंग)	अपॉस्ट्रफ़ी, ऐंगल ब्रैकेट, और ऐंपरसैंड को कोड में बदलता है.

तर्क

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

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

एक्सएमएल 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)}

इसमें नतीजे:

"bread" & "butter"

टाइम फ़ॉर्मैट के फ़ंक्शन

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

सिंटैक्स

फ़ंक्शन	जानकारी
`timeFormat(format,str)`	स्थानीय टाइम ज़ोन के हिसाब से फ़ॉर्मैट की गई तारीख दिखाता है.
`timeFormatMs(format,str)`	स्थानीय टाइम ज़ोन के हिसाब से फ़ॉर्मैट की गई तारीख दिखाता है.
`timeFormatUTC(format,str)`	यूटीसी में फ़ॉर्मैट की गई तारीख दिखाता है.
`timeFormatUTCMs(format,str)`	यूटीसी में फ़ॉर्मैट की गई तारीख दिखाता है.

तर्क

format - तारीख/समय के फ़ॉर्मैट की स्ट्रिंग. यह लिटरल स्ट्रिंग या स्ट्रिंग वैरिएबल हो सकता है.
str - समय की वैल्यू वाली स्ट्रिंग या स्ट्रिंग फ़्लो वैरिएबल. समय FormatMs के लिए वैल्यू, seconds-since-epoch या मिलीसेकंड-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 हैश फ़ंक्शन के साथ HMAC की गणना करता है.
`hmacSha256(key,valueToSign[,keyencoding[,outputencoding]])`	SHA-256 हैश फ़ंक्शन के साथ एक HMAC को कोड में बदलता है.
`hmacSha384(key,valueToSign[,keyencoding[,outputencoding]])`	SHA-384 हैश फ़ंक्शन के साथ एक HMAC को कोड में बदलता है.
`hmacSha512(key,valueToSign[,keyencoding[,outputencoding]])`	SHA-512 हैश फ़ंक्शन के साथ एक HMAC को कोड में बदलता है.
`hmacMd5(key,valueToSign[,keyencoding[,outputencoding]])`	एमडी5 हैश फ़ंक्शन के साथ एचएमएसी को कोड में बदलता है.
`hmacSha1(key, valueToSign [,keyencoding[,outputencoding]])`	यह नीति, SHA-1 एन्क्रिप्शन एल्गोरिदम के साथ एक एचएमएसी को कोड में बदल देती है.

सुरक्षा नोट: SHA-1 और MD-5 को यहां पूरा जानकारी देने के लिए शामिल किया गया है. हालांकि, Google का सुझाव है कि लोग इन हैश का इस्तेमाल न करें. Google ने पहली बार 2017 में, SHA-1 के ख़िलाफ़ टकराव का इस्तेमाल किया है और एनआईएसटी का इस्तेमाल करने का सुझाव भी देता है. एनआईएसटी यह सुझाव भी देता है कि लोग SHA-1 का इस्तेमाल बंद कर दें. सीएमयू सॉफ़्टवेयर इंजीनियरिंग इंस्टिट्यूट ने सबसे पहले यह सुझाव दिया था कि साल 2008 में, लोगों को किसी भी स्थिति में एमडी5 एल्गोरिदम का इस्तेमाल करने से बचना चाहिए.

तर्क

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

उदाहरण

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

<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 पर हस्ताक्षर करने की प्रोसेस के साथ किया जा सकता है. इस उदाहरण में, एडब्ल्यूएस सिग्नेचर v4 के लिए हस्ताक्षर का हिसाब लगाने के लिए इस्तेमाल किए जाने वाले कैस्केड किए गए एचएमएसी के पांच लेवल जनरेट करने के लिए, AssignmentsMessage नीति का इस्तेमाल किया गया है:

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

उदाहरण

{random()}

नतीजे कुछ इस तरह के होते हैं:

5211338197474042880

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

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

सिंटैक्स

xeger(regex)

आर्ग्यूमेंट

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

उदाहरण

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

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

उदाहरण के तौर पर दिया गया नतीजा:

शून्य-कोलेसेसिंग फ़ंक्शन

firstnonnull() फ़ंक्शन सबसे बाएं, नॉन-शून्य तर्क की वैल्यू दिखाता है.

सिंटैक्स

firstnonnull(var1,var_n)

आर्ग्यूमेंट

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 - (ज़रूरी नहीं) यह बताता है कि क्वेरी का सही टाइप क्या है. यह नोडसेट, नोड, संख्या, बूलियन, स्ट्रिंग हो सकता है. यह डिफ़ॉल्ट रूप से नोडसेट को दिखाता है. आम तौर पर, डिफ़ॉल्ट विकल्प ही सही विकल्प होता है.

उदाहरण 1

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

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

साथ ही, AssignmentsMessage नीति में 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 की तरह दिखने वाली स्ट्रिंग के तौर पर जोड़ें. उदाहरण के लिए, एसओएपी बॉडी का चाइल्ड एलिमेंट चुनने वाला 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)}

चौथा उदाहरण: यह तय करना कि रिटर्न किस तरह का है

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