‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

‫AssignMessage policy

אתם צופים במסמכי התיעוד של Apigee Edge.
כדאי לעיין במסמכי התיעוד של Apigee X. מידע

מה

המדיניות AssignMessage משנה או יוצרת הודעות חדשות של בקשות ותגובות במהלך ה-Flow של proxy ל-API. המדיניות מאפשרת לכם לבצע את הפעולות הבאות בהודעות האלה:

הוספה של פרמטרים חדשים של טופס, כותרות או פרמטרים של שאילתה להודעה
העתקה של מאפיינים קיימים מהודעה אחת להודעה אחרת
הסרת כותרות, פרמטרים של שאילתות, פרמטרים של טפסים ו/או מטען ייעודי (payload) של הודעות מהודעה
הגדרה של ערך המאפיינים הקיימים בהודעה

בדרך כלל, באמצעות מדיניות AssignMessage מוסיפים, משנים או מסירים מאפיינים של הבקשה או התגובה. עם זאת, אפשר גם להשתמש במדיניות AssignMessage כדי ליצור בקשה או הודעת תגובה בהתאמה אישית ולהעביר אותה ליעד חלופי, כמו שמתואר במאמר בנושא יצירת הודעות בקשה בהתאמה אישית.

תרחישים לדוגמה

יש הרבה מצבים שבהם כדאי לשנות בקשה או הודעת תגובה במהלך העיבוד ב-Apigee Edge. לדוגמה:

הגדרת ערך ברירת מחדל לפרמטר של מחרוזת שאילתה או לסוג אחר של קלט.
הסרת כותרות HTTP מהודעת בקשה לפני שההודעה מועברת לשירות backend.
הוספת כותרות HTTP לפני שליחת תגובה לאפליקציה למשתמשים.
הוספת תוכן של הודעת JSON או XML לפני שליחת תגובה.
ליצור הודעות בקשה או תשובה מלאות. לדוגמה, אפשר להשתמש במדיניות ServiceCallout כדי להפעיל API מרוחק מתוך שרת proxy של API. אפשר להשתמש במדיניות AssignMessage כדי ליצור הודעת בקשה בהתאמה אישית ולהקצות אותה למשתנה. לאחר מכן, משתמשים ב-Service Callout כדי לשלוח את ההודעה הזו ל-API המרוחק.
מוסיפים כותרות לבקשות ולתשובות לצורך ניפוי באגים ופתרון בעיות.

המדיניות AssignMessage יכולה ליצור או לשנות הודעות או משתני זרימה. אפשר להשתמש במדיניות הזו כדי לשנות הודעות בקשה לפני ששולחים אותן דרך שרת proxy למערכות במעלה הזרם, או כדי לשנות הודעות תגובה לפני שמעבירים אותן לאפליקציות של צרכני API.

רכיב `<AssignMessage>`

מגדיר מדיניות AssignMessage.

ערך ברירת מחדל	מידע נוסף מופיע בכרטיסייה מדיניות ברירת המחדל שבהמשך.
חובה?	חובה
סוג	אובייקט מורכב
רכיב אב	לא רלוונטי
רכיבי צאצא	`<Add>` `<AssignTo>` `<AssignVariable>` `<Copy>` `<DisplayName>` `<IgnoreUnresolvedVariables>` `<Remove>` `<Set>`

רכיב <AssignMessage> משתמש בתחביר הבא:

תחביר

רכיב <AssignMessage> משתמש בתחביר הבא:

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <!-- All AssignMessage child elements are optional -->
  <Add>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Add>

  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>

  <AssignVariable>
    <Name>variable_name</Name>
    <Ref>source_variable</Ref>
    <Template>message_template</Template>
    or
    <Template ref='template_variable'></Template>
    <Value>variable_value</Value>
  </AssignVariable>

  <Copy source="[request|response]">
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>[false|true]</Path>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>[false|true]</ReasonPhrase>
    <StatusCode>[false|true]</StatusCode>
    <Verb>[false|true]</Verb>
    <Version>[false|true]</Version>
  </Copy>

  <DisplayName>policy_display_name</DisplayName>

  <IgnoreUnresolvedVariables>[true|false]
  </IgnoreUnresolvedVariables>

  <Remove>
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Remove>

  <Set>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>path</Path>
    <Payload contentType="content_type" variablePrefix="prefix"
        variableSuffix="suffix">new_payload</Payload>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>reason_for_error or {variable}</ReasonPhrase>
    <StatusCode>HTTP_status_code or {variable}</StatusCode>
    <Verb>[GET|POST|PUT|PATCH|DELETE|{variable}]</Verb>
    <Version>[1.0|1.1|{variable}]</Verb>
  </Set>

</AssignMessage>

מדיניות ברירת המחדל

בדוגמה הבאה מוצגות הגדרות ברירת המחדל כשמוסיפים מדיניות AssignMessage לתהליך בממשק המשתמש של Edge:

<AssignMessage continueOnError="false" enabled="true" name="assign-message-default">
  <DisplayName>Assign Message-1</DisplayName>
  <Properties/>
  <Copy source="request">
    <Headers/>
    <QueryParams/>
    <FormParams/>
    <Payload/>
    <Verb/>
    <StatusCode/>
    <ReasonPhrase/>
    <Path/>
  </Copy>
  <Remove>
    <Headers>
      <Header name="h1"/>
    </Headers>
    <QueryParams>
      <QueryParam name="q1"/>
    </QueryParams>
    <FormParams>
      <FormParam name="f1"/>
    </FormParams>
    <Payload/>
  </Remove>
  <Add>
    <Headers/>
    <QueryParams/>
    <FormParams/>
  </Add>
  <Set>
    <Headers/>
    <QueryParams/>
    <FormParams/>
    <!-- <Verb>GET</Verb> -->
    <Path/>
  </Set>
  <AssignVariable>
    <Name>name</Name>
    <Value/>
    <Ref/>
  </AssignVariable>
  <IgnoreUnresolvedVariables>true
  </IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

כשמוסיפים מדיניות חדשה של AssignMessage בממשק המשתמש של Edge, התבנית מכילה placeholders לכל הפעולות האפשריות. בדרך כלל, בוחרים את הפעולות שרוצים לבצע באמצעות המדיניות הזו ומסירים את שאר רכיבי הצאצא. לדוגמה, אם רוצים לבצע פעולת העתקה, אפשר להשתמש ברכיב <Copy> ולהסיר את <Add>, <Remove> ורכיבי צאצא אחרים מהמדיניות כדי שהיא תהיה קריאה יותר.

לרכיב הזה יש את המאפיינים הבאים, המשותפים לכל כללי המדיניות:

מאפיין	ברירת מחדל	חובה?	תיאור
`name`	לא רלוונטי	נדרש	השם הפנימי של המדיניות. הערך של המאפיין `name` יכול להכיל אותיות, מספרים, רווחים, מקפים, קווים תחתונים ונקודות. האורך המקסימלי של הערך הוא 255 תווים. אפשר להשתמש ברכיב `<DisplayName>` כדי להוסיף תווית למדיניות בכלי לעריכת שרת proxy של ממשק המשתמש לניהול, ולהשתמש בשם אחר בשפה טבעית.
`continueOnError`	false	אופציונלי	צריך להגדיר את הערך 'False' כדי להחזיר שגיאה כשהמדיניות נכשלת. זו התנהגות צפויה ברוב סוגי המדיניות. הערך של הפרמטר הוא TRUE כדי שביצוע הפעולות יתבצע גם אחרי שמדיניות תיכשל.
`enabled`	true	אופציונלי	כדי לאכוף את המדיניות צריך להגדיר את הערך True. מגדירים את המדיניות כ-"false" כדי "להשבית" את המדיניות. המדיניות הזו לא תיאכף גם אם היא תצורף לתהליך.
`async`	false	הוצא משימוש	המאפיין הזה הוצא משימוש.

בטבלה הבאה מפורטים רכיבי המשנה של <AssignMessage>:

רכיב צאצא	חובה?	תיאור
פעולות נפוצות
`<Add>`	אופציונלי	מוסיף מידע לאובייקט של ההודעה שצוין ברכיב `<AssignTo>`. ‫`<Add>` מוסיף כותרות או פרמטרים להודעה שלא קיימים בהודעה המקורית. כדי להחליף כותרות או פרמטרים קיימים, משתמשים ברכיב `<Set>`.
`<Copy>`	אופציונלי	מעתין מידע מה הודעה שצוינה במאפיין `source` לה הודעה שצוינה ברכיב `<AssignTo>`.
`<Remove>`	אופציונלי	מוחק את הרכיבים שצוינו ממשתנה ההודעה שצוין ברכיב `<AssignTo>`.
`<Set>`	אופציונלי	הפונקציה מחליפה ערכים של מאפיינים קיימים בבקשה או בתגובה, שצוינו ברכיב `<AssignTo>`. `<Set>` מחליף כותרות או פרמטרים שכבר קיימים בהודעה המקורית. כדי להוסיף כותרות או פרמטרים חדשים, משתמשים ברכיב `<Add>`.
רכיבים משניים אחרים
`<AssignTo>`	אופציונלי	מציינת על איזו הודעה חלה מדיניות AssignMessage. יכול להיות שמדובר בבקשה או בתגובה רגילות, או בהודעה חדשה בהתאמה אישית.
`<AssignVariable>`	אופציונלי	מקצה ערך למשתנה זרימה. אם המשתנה לא קיים, הפונקציה `<AssignVariable>` יוצרת אותו.
`<IgnoreUnresolvedVariables>`	אופציונלי	קובעת אם העיבוד ייפסק כשנתקלים במשתנה לא פתור.

כל אחד מרכיבי הצאצא האלה מתואר בקטעים הבאים.

דוגמאות

בדוגמאות הבאות אפשר לראות כמה מהדרכים שבהן אפשר להשתמש במדיניות AssignMessage:

‫1: הוספת כותרת

בדוגמה הבאה מוסיפים כותרת לבקשה באמצעות הרכיב <Add>:

<AssignMessage name="AM-add-headers-1">
  <Add>
    <Headers>
      <Header name="partner-id">{verifyapikey.VAK-1.developer.app.partner-id}</Header>
    </Headers>
  </Add>
  <AssignTo>request</AssignTo>
</AssignMessage>

‫2: הסרת מטען ייעודי

בדוגמה הבאה, המטען הייעודי למטרה מוסר מהתגובה באמצעות הרכיב <Remove>:

<AssignMessage name="AM-remove-1">
  <DisplayName>remove-1</DisplayName>
  <Remove>
    <Payload>true</Payload>
  </Remove>
  <AssignTo>response</AssignTo>
</AssignMessage>

‫3: שינוי התשובה

בדוגמה הבאה משנים אובייקט תגובה קיים על ידי הוספת כותרת:

<AssignMessage name="AM-modify-response">
  <Set>
    <Headers>
      <Header name="Cache-Hit">{lookupcache.LookupCache-1.cachehit}</Header>
    </Headers>
  </Set>
  <IgnoreUnresolvedVariables>false
  </IgnoreUnresolvedVariables>
  <AssignTo>response</AssignTo>
</AssignMessage>

בדוגמה הזו לא נוצרת הודעה חדשה. במקום זאת, הוא משנה הודעת תגובה קיימת על ידי הוספת כותרת HTTP.

מכיוון שבמקרה הזה צוין response כשם המשתנה ברכיב <AssignTo>, המדיניות הזו משנה את אובייקט התגובה שהוגדר במקור עם נתונים שהוחזרו על ידי שרת היעד.

כותרת ה-HTTP שנוספת להודעת התגובה על ידי המדיניות הזו נגזרת ממשתנה שאוכלס על ידי מדיניות LookupCache. לכן, הודעת התגובה ששונתה על ידי מדיניות Assign Message הזו מכילה כותרת HTTP שמציינת אם התוצאות נמשכו מהמטמון או לא. הגדרת כותרות בתגובה יכולה להיות שימושית לניפוי באגים ולפתרון בעיות.

‫4: הגדרת תוכן דינמי

אתם יכולים להשתמש בפונקציה Assign Message כדי להטמיע תוכן דינמי במטען הייעודי (payload) של הודעות בקשה ותשובה.

כדי להטמיע משתני Edge Flow במטען ייעודי (payload) בפורמט XML, צריך להוסיף את המשתנה המיועד בסוגריים מסולסלים, כך: {prefix.name}.

בדוגמה הבאה מוטמע הערך של משתנה הזרימה של כותרת ה-HTTP‏ user-agent באלמנט XML שנקרא User-agent:

<AssignMessage name="AM-set-dynamic-content">
  <AssignTo>response</AssignTo>
  <Set>
    <Payload contentType="text/xml">
      <User-agent>{request.header.user-agent}</User-agent>
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>false
  </IgnoreUnresolvedVariables>
</AssignMessage>

במטענים ייעודיים (payloads) בפורמט JSON, אפשר להוסיף משתנים באמצעות המאפיינים variablePrefix ו-variableSuffix עם תווי תיחום, כמו בדוגמה הבאה:

<AssignMessage name="set-payload">
  <Payload contentType="application/json" variablePrefix="@" variableSuffix="#">
  {
     "user-agent": "@request.header.user-agent#"
  }
  </Payload>
</AssignMessage>

רשימה מלאה של משתני התהליך מופיעה כאן.

החל מגרסת הענן 16.08.17, אפשר להשתמש גם בסוגריים מסולסלים כדי להוסיף משתנים.

‫5: הסרת פרמטר של שאילתה

בדוגמה הבאה מוסר פרמטר השאילתה apikey מהבקשה:

<AssignMessage name="AM-remove-query-param">
  <Remove>
    <QueryParams>
      <QueryParam name="apikey"/>
    </QueryParams>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

מומלץ להסיר את פרמטר השאילתה apikey מהודעת הבקשה כשמשתמשים במדיניות VerifyAPIKey לאימות משתמשים. הפעולה הזו מונעת העברה של מידע רגיש וחשוב ליעד בקצה העורפי.

‫6: הגדרה או קבלת משתנים

בדוגמה הבאה נעשה שימוש בשלוש מדיניות של הקצאת הודעות:

יצירת שלושה משתני רצף פעולות בבקשה, עם ערכים סטטיים
קבלת משתני התהליך באופן דינמי במדיניות השנייה בתהליך הבקשה
הגדרתם במטען הייעודי (payload) של התגובה

<!-- Policy #1: Set variables in the request -->

<AssignMessage name="AM-set-variables">
    <!-- Create a variable named myAppSecret -->
    <AssignVariable>
        <Name>myAppSecret</Name>
        <Value>42</Value>
    </AssignVariable>
    <!-- Create a variable named config.environment -->
    <AssignVariable>
        <Name>config.environment</Name>
        <Value>test</Value>
    </AssignVariable>
    <!-- Create a variable named config.protocol -->
    <AssignVariable>
        <Name>config.protocol</Name>
        <Value>gopher</Value>
    </AssignVariable>
</AssignMessage>

במדיניות הראשונה, הרכיב <AssignVariable> יוצר ומגדיר שלוש משתנים בבקשה. כל רכיב <Name> מציין שם משתנה, וכל רכיב <Value> מציין את הערך.

המדיניות השנייה משתמשת ברכיב <AssignVariable> כדי לקרוא את הערכים ויוצרת שלושה משתנים חדשים:

<!-- Policy #2: Get variables from the request -->
<AssignMessage continueOnError="false" enabled="true" name="get-variables">
  <AssignTo createNew="false" transport="http" type="request"/>
  <!-- Get the value of myAppSecret and create a new variable, secret -->
  <AssignVariable>
    <Name>secret</Name>
    <Ref>myAppSecret</Ref>
    <Value>0</Value>
  </AssignVariable>
  <!-- Get the value of config.environment and create a new variable, environment -->
  <AssignVariable>
    <Name>environment</Name>
    <Ref>config.environment</Ref>
    <Value>default</Value>
  </AssignVariable>
  <!-- Get the value of config.protocol and create a new variable, protocol -->
  <AssignVariable>
    <Name>protocol</Name>
    <Ref>config.protocol</Ref>
    <Value>default</Value>
  </AssignVariable>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</AssignMessage>

במדיניות השנייה, רכיב <Ref> מפנה למשתנה המקור, ורכיבי <Name> מציינים את השמות של המשתנים החדשים. אם אין גישה למשתנה שאליו מתייחס הרכיב <Ref>, אפשר להשתמש בערך שצוין ברכיב <Value>.

כדי לנסות את קבוצת המדיניות הזו:

מוסיפים את מדיניות מספר 1 ומדיניות מספר 2 לזרימת הבקשה. חשוב להקפיד להציב את מדיניות מספר 1 לפני מדיניות מספר 2.
מוסיפים את המדיניות השלישית בתהליך התגובה.

המדיניות השלישית משתמשת ברכיב <Set> כדי להוסיף את המשתנים לתשובה. בדוגמה הבאה מוצג מטען ייעודי (payload) של XML בתגובה ש-Edge מחזיר ללקוח:

<!-- Policy #3: Add variables to the response -->
<AssignMessage continueOnError="false" enabled="true" name="put-em-in-the-payload">
  <DisplayName>put-em-in-the-payload</DisplayName>
  <Set>
    <Payload contentType="application/xml">
      <wrapper>
        <secret>{secret}</secret>
        <config>
          <environment>{environment}</environment>
          <protocol>{protocol}</protocol>
        </config>
      </wrapper>
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true
  </IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

הערה: התחביר לגישה למשתני זרימה ב-<Set> הוא להוסיף אותם בין סוגריים מסולסלים.

חשוב להגדיר את המאפיין contentType של רכיב <Payload> לערך application/xml.

שולחים בקשה ל-proxy ל-API; לדוגמה:

curl -vL https://ahamilton-eval-test.apigee.net/myproxy

אם רוצים, אפשר להעביר את התוצאות דרך כלי כמו xmllint כדי שה-XML יוצג במבנה מעוצב:

curl -vL https://ahamilton-eval-test.apigee.net/myproxy | xmllint --format -

גוף התגובה אמור להיראות כך:

<wrapper>
  <secret>42</secret>
  <config>
    <environment>test</environment>
    <protocol>gopher</protocol>
  </config>
</wrapper>

‫7: קבלת כותרות תגובה של קריאה לשירות

בדוגמה הבאה, נניח שמדיניות ServiceCallout נמצאת בבקשת ה-proxy ל-API, ותגובת ה-callout מכילה כמה כותרות עם אותו שם (Set-Cookie). בהנחה שמשתנה התגובה של Service Callout הוא ברירת המחדל calloutResponse, המדיניות הבאה מקבלת את ערך הכותרת השני של Set-Cookie.

<AssignMessage name="AM-Payload-from-SC-header">
  <Set>
    <Payload contentType="application/json">
      {"Cookies from Service Callout":" {calloutResponse.header.Set-Cookie.2}"}
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true
  </IgnoreUnresolvedVariables>
  <AssignTo>response</AssignTo>
</AssignMessage>

כדי לראות רשימה של כל ערכי הכותרות, משתמשים במשתנה הבא במקום זאת:

{calloutResponse.header.Set-Cookie.values}

לכל רכיב צאצא בהפניה הזו יש דוגמאות נוספות. דוגמאות נוספות זמינות בדוגמה של AssignMessage ב-GitHub.

הפניה לרכיב צאצא

בקטע הזה מתוארים רכיבי הבן של <AssignMessage>.

`<Add>`

מוסיף מידע לבקשה או לתשובה, שמוגדר על ידי הרכיב <AssignTo>.

הרכיב <Add> מוסיף להודעה מאפיינים חדשים שלא קיימים בהודעה המקורית. כדי לשנות את הערכים של מאפיינים קיימים, משתמשים ברכיב <Set>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	סוג מורכב
רכיב אב	`<AssignMessage>`
רכיבי צאצא	`<FormParams>` `<Headers>` `<QueryParams>`

רכיב <Add> משתמש בתחביר הבא:

תחבירs1

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Add>
</AssignMessage>

דוגמה 1s2

בדוגמה הבאה נעשה שימוש ברכיב <FormParams> כדי לקבל את הערכים של שלושה פרמטרים של מחרוזת שאילתה מהבקשה הראשונית ולהגדיר אותם כפרמטרים של טופס בבקשה של נקודת היעד:

<AssignMessage name="AM-add-formparams-3">
  <Add>
    <FormParams>
      <FormParam name="username">{request.queryparam.name}</FormParam>
      <FormParam name="zip_code">{request.queryparam.zipCode}</FormParam>
      <FormParam name="default_language">{request.queryparam.lang}</FormParam>
    </FormParams>
  </Add>
  <Remove>
    <QueryParams/>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 2s3

בדוגמה הבאה נעשה שימוש ברכיב <Headers> כדי להוסיף כותרת partner-id לבקשה שתישלח לנקודת היעד:

<AssignMessage name="AM-add-headers-1">
  <Add>
    <Headers>
      <Header name="partner-id">{verifyapikey.VAK-1.developer.app.partner-id}</Header>
    </Headers>
  </Add>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 3s4

בדוגמה הבאה נעשה שימוש ברכיב <QueryParams> כדי להוסיף לבקשה פרמטר שאילתה יחיד עם ערך סטטי:

<AssignMessage name="AM-add-queryparams-1">
  <Add>
    <QueryParams>
      <QueryParam name="myParam">42</QueryParam>
    </QueryParams>
  </Add>
  <AssignTo>request</AssignTo>
</AssignMessage>

בדוגמה הזו נעשה שימוש ב-<Add> בתהליך המקדים של הבקשה. אם בודקים את התוצאות בכלי כמו כלי המעקב, הבקשה אל https://example-target.com/get הופכת ל-https://example-target.com/get?myParam=42.

רכיבי הצאצא של <Add> תומכים בהחלפה דינמית של מחרוזות, שנקראת תבניות הודעות.

`<FormParams>` (ילד/ה של `<Add>`)

הוספת פרמטרים חדשים של טופס להודעת הבקשה. לרכיב הזה אין השפעה על הודעת תגובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<FormParam>`
רכיב אב	`<Add>`
רכיבי צאצא	`<FormParam>`

רכיב <FormParams> משתמש בתחביר הבא:

תחבירs5

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>
  </Add>
</AssignMessage>

דוגמה 1s6

בדוגמה הבאה מתווספים לבקשה פרמטר טופס יחיד (answer) וערך סטטי (42):

<AssignMessage name="AM-add-formparams-1">
  <Add>
    <FormParams>
      <FormParam name="answer">42</FormParam>
    </FormParams>
  </Add>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 2s7

בדוגמה הבאה מקבלים את הערך של פרמטר השאילתה name, מוסיפים אותו לבקשה כפרמטר של טופס ואז מסירים את פרמטר השאילתה:

<AssignMessage name="AM-Swap-QueryParam-to-FormParams">
  <Add>
    <FormParam name="name">{request.queryparam.name}</FormParam>
  </Add>
  <Remove>
    <QueryParam name="name"/>
  </Remove>
</AssignMessage>

שימו לב שבמקרה הזה לא צוין יעד עם <AssignTo>. המדיניות הזו מוסיפה את הפרמטר לבקשה בלבד.

דוגמה 3s8

בדוגמה הבאה מוסיפים כמה פרמטרים של טופס לבקשה:

<AssignMessage name="AM-add-formparams-3">
  <Add>
    <FormParams>
      <FormParam name="username">{request.queryparam.name}</FormParam>
      <FormParam name="zip_code">{request.queryparam.zipCode}</FormParam>
      <FormParam name="default_language">{request.queryparam.lang}</FormParam>
    </FormParams>
  </Add>
  <Remove>
    <QueryParams/>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

בדוגמה הזו, הפרמטרים של מחרוזת השאילתה מתקבלים מהבקשה המקורית ומוסיפים אותם כפרמטרים של טופס עם שמות שונים. לאחר מכן, המערכת מסירה את הפרמטרים המקוריים של השאילתה. ‫Apigee ישלח את הבקשה ששונתה לנקודת היעד.

אפשר להשתמש בכלי המעקב כדי לראות את התהליך. אפשר לראות שגוף הבקשה מכיל את נתוני הטופס בקידוד כתובת URL, שהועברו במקור כפרמטרים של מחרוזת שאילתה:

username=nick&zip_code=90210&default_language=en

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

פועל HTTP: ‏ POST
סוג ההודעה: בקשה
אחת (או שתי) מהאפשרויות הבאות:
- נתוני טופס: מוגדר לערך כלשהו או ל-"" (המחרוזת הריקה). לדוגמה, אם הפרומפט הוא curl, מוסיפים -d "" לבקשה.
- הכותרת Content-Length: הערך שמוגדר הוא 0 (אם אין נתונים בבקשה המקורית, אחרת, האורך הנוכחי בבייטים). לדוגמה, אם רוצים להוסיף את הפקודה curl add -H "Content-Length: 0" לבקשה.

לדוגמה:

curl -vL -X POST -d "" -H "Content-Type: application/x-www-form-urlencoded"
  https://ahamilton-eval-test.apigee.net/am-test

כשמוסיפים <FormParams>, דפדפן Edge מגדיר את הכותרת Content-Type של הבקשה לערך application/x-www-form-urlencoded לפני שליחת ההודעה לשירות היעד.

`<Headers>` (ילד/ה של `<Add>`)

הפעולה מוסיפה כותרות חדשות לבקשה או לתגובה שצוינו, באמצעות רכיב <AssignTo>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של `<Header>` אלמנטים
רכיב אב	`<Add>`
רכיבי צאצא	`<Header>`

רכיב <Headers> משתמש בתחביר הבא:

תחבירs9

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Add>
</AssignMessage>

דוגמה 1s10

בדוגמה הבאה מוסיפים כותרת partner-id להודעת הבקשה, ומקצים לכותרת הזו את הערך של משתנה הזרימה verifyapikey.VAK-1.developer.app.partner-id.

<AssignMessage name="AM-add-headers-1">
  <Add>
    <Headers>
      <Header name="partner-id">{verifyapikey.VAK-1.developer.app.partner-id}</Header>
    </Headers>
  </Add>
  <AssignTo>request</AssignTo>
</AssignMessage>

`<QueryParams>` (ילד/ה של `<Add>`)

הוספת פרמטרים חדשים של שאילתה לבקשה. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<QueryParam>`
רכיב אב	`<Add>`
רכיבי צאצא	`<QueryParam>`

רכיב <QueryParams> משתמש בתחביר הבא:

תחבירs11

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Add>
</AssignMessage>

דוגמה 1s12

בדוגמה הבאה, פרמטר השאילתה myParam מתווסף לבקשה והערך 42 מוקצה לו:

<AssignMessage name="AM-add-queryparams-1">
  <Add>
    <QueryParams>
      <QueryParam name="myParam">42</QueryParam>
    </QueryParams>
  </Add>
  <AssignTo>request</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

פועל HTTP: ‏ GET
סוג ההודעה: בקשה

בנוסף, אפשר להגדיר פרמטרים של שאילתה רק כשהמאפיין type של רכיב <AssignTo> הוא הודעת בקשה. הגדרתם בתשובה לא משפיעה.

אם מגדירים במדיניות מערך ריק של פרמטרים של שאילתה (<Add><QueryParams/></Add>), המדיניות לא מוסיפה פרמטרים של שאילתה. התוצאה זהה לתוצאה של השמטת <QueryParams>.

`<AssignTo>`

קובעת על איזה אובייקט פועלת מדיניות AssignMessage. האפשרויות הן:

הודעת הבקשה: request שהתקבלה על ידי proxy ל-API
הודעת התגובה: response שהוחזרה משרת היעד
הודעה מותאמת אישית: אובייקט מותאם אישית של בקשה או תגובה

חשוב לשים לב שבמקרים מסוימים אי אפשר לשנות את האובייקט שעליו חלה מדיניות AssignMessage. לדוגמה, אי אפשר להשתמש ב-<Add> או ב-<Set> כדי להוסיף או לשנות פרמטרים של שאילתה (<QueryParams>) או פרמטרים של טופס (<FormParams>) בתגובה. אפשר לשנות רק את הפרמטרים של השאילתה ואת הפרמטרים של הטופס בבקשה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת
רכיב אב	`<AssignMessage>`
רכיבי צאצא	ללא

אם לא מציינים את <AssignTo>, או אם מציינים את הרכיב <AssignTo> אבל לא מציינים ערך טקסט לרכיב, המדיניות פועלת על בקשת ברירת המחדל או התגובה, בהתאם למקום שבו המדיניות מופעלת. אם המדיניות מופעלת בתהליך הבקשה, היא משפיעה על הודעת הבקשה. אם היא מופעלת בתהליך התגובה, המדיניות משפיעה על התגובה כברירת מחדל.

רכיב <AssignTo> משתמש בתחביר הבא:

תחבירs13

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>
</AssignMessage>

דוגמה 1s14

בדוגמה הבאה מצוין שהיעד הוא הבקשה המקורית שתישלח לנקודת הקצה של היעד:

<AssignMessage name="assignto-1">
<!-- DO NOT do this -->
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

הערה: אם המאפיין createNew מוגדר לערך false ולא מצוינת הודעה מפורשת, לרכיב AssignTo אין השפעה פונקציונלית. במקרים כאלה, הכללת התג מיותרת ושווה להשמטה מלאה של הרכיב. כדי לראות דוגמאות מעשיות לשימוש יעיל ברכיב AssignTo, אפשר לעיין בדוגמאות האחרות שסיפקנו.

דוגמה 2s15

בדוגמה הבאה נוצר אובייקט בקשה חדש:

<AssignMessage name="AM-assignto-2"> 
  <AssignTo createNew="true" transport="http" type="request">NameOfNewMessage</AssignTo> 
</AssignMessage>

כשיוצרים אובייקט בקשה או תגובה חדש, הרכיבים האחרים במדיניות AssignMessage (כמו <Add>,‏ <Set> ו-<Copy>) פועלים על אובייקט הבקשה החדש הזה.

אפשר לגשת לאובייקט הבקשה החדש במדיניות אחרת בהמשך התהליך, או לשלוח את אובייקט הבקשה החדש לשירות חיצוני באמצעות מדיניות ServiceCallout.

דוגמה 3s16

בדוגמה הבאה נוצר אובייקט בקשה חדש בשם MyRequestObject:

<AssignMessage name="assignto-2">
  <AssignTo createNew="true" transport="http" type="request"&gt;MyRequestObject&lt;/AssignTo>
</AssignMessage>

בטבלה הבאה מתוארים המאפיינים של <AssignTo>:

מאפיין תיאור חובה? סוג

מאפיין	תיאור	חובה?	סוג
`createNew`	קובעת אם המדיניות הזו יוצרת הודעה חדשה כשמגדירים ערכים. אם הערך הוא true, המדיניות יוצרת משתנה חדש מהסוג שצוין על ידי `type` (request או response). אם לא מציינים את השם של המשתנה החדש, המדיניות יוצרת אובייקט חדש של בקשה או תגובה, על סמך הערך של `type`. זהירות: כשיוצרים אובייקט בקשה או תגובה חדש, אובייקט הבקשה או התגובה הקיים נמחק ומוחלף בחדש, כלומר כל המידע באובייקט אובד. אם הערך הוא false, המדיניות מגיבה באחת משתי דרכים: אם `<AssignTo>` יכול לפתור את שם המשתנה לבקשה או לתגובה, הוא ממשיך בעיבוד. לדוגמה, אם המדיניות נמצאת בתהליך של בקשה, המשתנה הוא אובייקט הבקשה. אם המדיניות נמצאת בתגובה, המשתנה הוא אובייקט התגובה. אם אי אפשר לפתור את `<AssignTo>`, או אם הוא נפתר לסוג שאינו הודעה, המדיניות מחזירה שגיאה. אם לא מציינים את `createNew`, המדיניות מגיבה באחת משתי דרכים: אם ערך הטקסט של `<AssignTo>` הוא הודעה, העיבוד עובר לשלב הבא. אם לא ניתן לפתור את ערך הטקסט של `<AssignTo>`, או אם הוא נפתר לסוג שאינו סוג הודעה, נוצר משתנה חדש מסוג שצוין ב-`type`.	אופציונלי	בוליאני
`transport`	מציין את סוג התעבורה של סוג ההודעה של הבקשה או התגובה. ערך ברירת המחדל הוא 'http' (הערך הנתמך היחיד).	אופציונלי	מחרוזת
`type`	מציין את סוג ההודעה החדשה, כשהערך של `createNew` הוא true. הערכים התקינים הם request או response. אם משמיטים את המאפיין הזה, Edge יוצר בקשה או תגובה, בהתאם למיקום שבו המדיניות הזו מופעלת בתהליך.	אופציונלי	מחרוזת

createNew

קובעת אם המדיניות הזו יוצרת הודעה חדשה כשמגדירים ערכים.

אם הערך הוא true, המדיניות יוצרת משתנה חדש מהסוג שצוין על ידי type (request או response). אם לא מציינים את השם של המשתנה החדש, המדיניות יוצרת אובייקט חדש של בקשה או תגובה, על סמך הערך של type.

אם הערך הוא false, המדיניות מגיבה באחת משתי דרכים:

אם <AssignTo> יכול לפתור את שם המשתנה לבקשה או לתגובה, הוא ממשיך בעיבוד. לדוגמה, אם המדיניות נמצאת בתהליך של בקשה, המשתנה הוא אובייקט הבקשה. אם המדיניות נמצאת בתגובה, המשתנה הוא אובייקט התגובה.
אם אי אפשר לפתור את <AssignTo>, או אם הוא נפתר לסוג שאינו הודעה, המדיניות מחזירה שגיאה.

אם לא מציינים את createNew, המדיניות מגיבה באחת משתי דרכים:

אם ערך הטקסט של <AssignTo> הוא הודעה, העיבוד עובר לשלב הבא.
אם לא ניתן לפתור את ערך הטקסט של <AssignTo>, או אם הוא נפתר לסוג שאינו סוג הודעה, נוצר משתנה חדש מסוג שצוין ב-type.

אופציונלי

בוליאני

transport

מציין את סוג התעבורה של סוג ההודעה של הבקשה או התגובה.

ערך ברירת המחדל הוא 'http' (הערך הנתמך היחיד).

אופציונלי

מחרוזת

type

מציין את סוג ההודעה החדשה, כשהערך של createNew הוא true. הערכים התקינים הם request או response.

אם משמיטים את המאפיין הזה, Edge יוצר בקשה או תגובה, בהתאם למיקום שבו המדיניות הזו מופעלת בתהליך.

אופציונלי

מחרוזת

`<AssignVariable>`

מקצה ערך למשתנה זרימה. אם משתנה הזרימה לא קיים, הפונקציה <AssignVariable> יוצרת אותו.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	סוג מורכב
רכיב אב	`<AssignMessage>`
רכיבי צאצא	`<Name>` (חובה) `<Ref>` `<Template>` `<Value>`

הערך שאפשר להקצות למשתנה זרימה יכול להיות אחד מהערכים הבאים:

מחרוזת ליטרלית: משתמשים ברכיב המשני <Value> כדי לציין ערך מחרוזת ליטרלי למשתנה של זרימת העבודה.
משתנה של זרימת נתונים: משתמשים ברכיב המשני <Ref> כדי לציין את הערך של משתנה קיים של זרימת נתונים עבור משתנה היעד של זרימת הנתונים. רשימה מלאה של משתני זרימה שאפשר להשתמש בהם כמקור זמינה במאמר חומר עזר בנושא משתני זרימה.
תבנית הודעה: משתמשים ברכיב המשני <Template> כדי לציין תבנית הודעה לאינטרפולציה, כדי לקבל את הערך שיוצב במשתנה היעד של הזרימה.

רכיב <AssignVariable> משתמש בתחביר הבא:

תחבירs17

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
    <Ref>source_variable</Ref>
    <Template>message_template</Template>
    or
    <Template ref='template_variable'></Template>
    <Value>variable_value</Value>
  </AssignVariable>
</AssignMessage>

משתמשים ברכיב <Ref> כדי לציין את משתנה המקור. אם המשתנה שאליו מתבצעת ההפניה באמצעות <Ref> לא נגיש, Edge משתמש בערך שצוין ברכיב <Value>. אם מגדירים את <Template>, הוא מקבל עדיפות על פני רכיבי הצאצא האחרים.

דוגמה 1s18

בדוגמה הבאה מוגדר הערך של משתנה חדש, myvar, כערך המילולי '42':

<AssignMessage name="assignvariable-1">
  <AssignVariable>
    <Name>myvar</Name>
    <Value>42</Value>
  </AssignVariable>
</AssignMessage>

דוגמה 2s19

בדוגמה הבאה מוקצה הערך של משתנה הזרימה request.header.user-agent למשתנה זרימת היעד myvar, והערך של פרמטר השאילתה country מוקצה למשתנה זרימת היעד Country:

<AssignMessage name="assignvariable-2">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
</AssignMessage>

אם אחת מההקצאות נכשלת, Edge מקצה במקום זאת את הערך ErrorOnCopy למשתנה היעד של זרימת הנתונים.

אם משתני הזרימה myvar או Country לא קיימים, <AssignVariable> יוצר אותם.

דוגמה 3s20

בדוגמה הבאה נעשה שימוש ברכיב הצאצא <Template> כדי לשרשר שתי משתני הקשר עם מחרוזת מילולית (מקף) ביניהם:

<AssignMessage name='AV-via-template-1'>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template>{system.uuid}-{messageid}</Template>
  </AssignVariable>
</AssignMessage>

שימוש נפוץ ב-<AssignVariable> הוא להגדרת ערך ברירת מחדל לפרמטר של שאילתה, לכותרת או לערך אחר שאפשר להעביר עם הבקשה. כדי לעשות את זה, משתמשים בשילוב של רכיבי הצאצא <Ref> ו-<Value>. מידע נוסף זמין בדוגמאות ל-<Ref>.

`<Name>` (ילד/ה של `<AssignVariable>`)

מציין את השם של משתנה היעד של זרימת הנתונים (למשל, המשתנה שהערך שלו מוגדר על ידי מדיניות AssignMessage). אם המשתנה שצוין ב-<AssignVariable> לא קיים, המדיניות יוצרת משתנה בשם הזה.

ערך ברירת מחדל	לא רלוונטי
חובה?	חובה
סוג	מחרוזת
רכיב אב	`<AssignVariable>`
רכיבי צאצא	ללא

רכיב <Name> משתמש בתחביר הבא:

תחבירs21

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
  </AssignVariable>
</AssignMessage>

דוגמה 1s22

בדוגמה הבאה, משתנה היעד הוא myvar, והוא מוגדר לערך המילולי '42':

<AssignMessage name="assignvariable-1">
  <AssignVariable>
    <Name>myvar</Name>
    <Value>42</Value>
  </AssignVariable>
</AssignMessage>

אם myvar לא קיים, הפונקציה <AssignVariable> יוצרת אותו.

`<Ref>` (ילד/ה של `<AssignVariable>`)

מציין את המקור של ההקצאה כמשתנה זרימה. משתנה הזרימה יכול להיות אחד ממשתני הזרימה המוגדרים מראש (כפי שמפורט בהפניה למשתני זרימה), או משתנה זרימה מותאם אישית שיצרתם.

הערך של <Ref> תמיד מתפרש כמשתנה של זרימת נתונים. אי אפשר לציין מחרוזת מילולית כערך. כדי להקצות ערך מחרוזת מילולי, צריך להשתמש במקום זאת ברכיב <Value>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת
רכיב אב	`<AssignVariable>`
רכיבי צאצא	ללא

כשמציינים משתנה של זרימת נתונים באמצעות <Ref>, לא כוללים את הסוגריים המסולסלים {} שבהם בדרך כלל משתמשים כדי להפנות למשתנה של זרימת נתונים. לדוגמה, כדי להגדיר את הערך של המשתנה החדש לערך של המשתנה client.host flow:

Do this (no brackets):
  <Ref>client.host</Ref>

Do NOT do this (brackets):
  <Ref>{client.host}</Ref>

כדי להגדיר ערך ברירת מחדל למשתנה זרימה של היעד, משתמשים ב-<Value> בשילוב עם <Ref>. אם משתנה הזרימה שצוין על ידי <Ref> לא קיים, אי אפשר לקרוא אותו או שהוא null,‏ Edge מקצה במקום זאת את הערך של <Value> למשתנה זרימת היעד.

רכיב <Ref> משתמש בתחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
    <Ref>source_variable</Ref>
  </AssignVariable>
</AssignMessage>

דוגמה 1s23

בדוגמה הבאה מוקצה הערך של משתנה הזרימה request.header.user-agent למשתנה זרימת היעד myvar, והערך של פרמטר השאילתה country מוקצה למשתנה Country:

<AssignMessage name="assignvariable-4">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
  </AssignVariable>
</AssignMessage>

בדוגמה הזו, לא הוגדר ב-Edge ערך ברירת מחדל (או ערך חלופי) לאף אחת מהמטלות.

דוגמה 2s23

<AssignMessage name="assignvariable-2">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
</AssignMessage>

בדוגמה הזו, אם הערכים של request.header.user-agent משתנה הזרימה או של Country פרמטר השאילתה הם null, לא ניתנים לקריאה או פגומים, Edge מקצה את הערך ErrorOnCopy למשתנים החדשים.

דוגמה 3s24

מקרה שימוש נפוץ ב-<AssignVariable> הוא הגדרת ערך ברירת המחדל של פרמטר שאילתה, כותרת או ערך אחר שאפשר להעביר עם הבקשה. לדוגמה, אתם יוצרים proxy ל-API למזג אוויר, שבו הבקשה כוללת פרמטר שאילתה יחיד בשם w. הפרמטר הזה מכיל את מזהה העיר שרוצים לקבל את נתוני מזג האוויר שלה. כתובת ה-URL של הבקשה היא מהצורה:

http://myCO.com/v1/weather/forecastrss?w=city_ID

כדי להגדיר ערך ברירת מחדל ל-w, יוצרים מדיניות AssignMessage כמו בדוגמה הבאה:

<AssignMessage continueOnError="false" enabled="true" name="assignvariable-3">
  <AssignTo createNew="false" transport="http" type="request"/>
  <IgnoreUnresolvedVariables>true
  </IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>request.queryparam.w</Name>
    <Ref>request.queryparam.w</Ref>
    <Value>12797282</Value>
  </AssignVariable>
</AssignMessage>

בדוגמה הזו, <AssignVariable> מקבל את הערך של request.queryparam.w ומקצה אותו לעצמו. אם משתנה הזרימה הוא null, כלומר פרמטר השאילתה w הושמט מהבקשה, בדוגמה הזו נעשה שימוש בערך ברירת המחדל מהרכיב <Value>. לכן, אפשר לשלוח בקשה ל-API proxy הזה בלי פרמטר השאילתה w:

http://myCO.com/v1/weather/forecastrss

…ועדיין להחזיר תוצאה תקינה מ-proxy ל-API.

בניגוד לשימוש ב-<Value>, הערך של <Ref> חייב להיות משתנה של זרימת נתונים, כמו מאפיין של אובייקט request,‏ response או target. הערך יכול להיות גם משתנה זרימה מותאם אישית שיצרתם.

אם מציינים משתנה של זרימת נתונים שלא קיים עבור הערך של <Ref>, והערך של <IgnoreUnresolvedVariables> הוא true,‏ Edge יציג שגיאה.

`<Template>` (ילד/ה של `<AssignVariable>`)

מציינים תבנית הודעה. תבנית של הודעה מאפשרת לבצע החלפה של מחרוזות משתנות כשהמדיניות מופעלת, ויכולה לשלב מחרוזות מילוליות עם שמות משתנים שמוקפים בסוגריים מסולסלים. בנוסף, תבניות הודעות תומכות ב פונקציות כמו ביטול בריחה והמרת אותיות רישיות.

משתמשים במאפיין ref כדי לציין משתנה זרימה שבו הערך של המשתנה הוא תבנית הודעה. לדוגמה, אפשר לאחסן תבנית הודעה כמאפיין מותאם אישית באפליקציית מפתחים. כש-Edge מזהה את אפליקציית המפתחים אחרי שהוא מאמת את מפתח ה-API או את אסימון האבטחה (באמצעות מדיניות נוספת), רכיב <AssignVariable> יכול להשתמש בתבנית ההודעה מתוך המאפיין המותאם אישית של האפליקציה, שזמין כמשתנה של זרימת נתונים ממדיניות האבטחה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת
רכיב אב	`<AssignVariable>`
רכיבי צאצא	ללא

רכיב <Template> משתמש בתחביר הבא:

תחבירs25

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Template>message_template</Template>
    or
    <Template ref='template_variable'></Template>
  </AssignVariable>
</AssignMessage>

דוגמה 1s26

בדוגמה הבאה נעשה שימוש בתחביר של תבניות הודעות כדי לשרשר שתי משתני הקשר עם מחרוזת מילולית (מקף) ביניהם:

<AssignMessage name='AV-via-template-1'>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template>{system.uuid}-{messageid}</Template>
  </AssignVariable>
</AssignMessage>

דוגמה 2s27

בדוגמה הבאה מוגדר משתנה זרימה, שבו הערך של המשתנה הוא תבנית הודעה שהוגדרה מראש. אפשר להשתמש באפשרות הזו אם רוצים להוסיף תבנית מוגדרת מראש בזמן הריצה בלי לשנות את המדיניות:

<AssignMessage name='AV-via-template-indirectly'>  
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template ref='my_template_variable'/>
  </AssignVariable>
</AssignMessage>

דוגמה 3s28

בדוגמה הבאה מצוינים משתנה של זרימת נתונים וערך טקסט. במקרה כזה, אם המשתנה שאליו מתבצעת ההפניה הוא לא null, הערך הזה ישמש כתבנית. אם הערך שאליו יש הפניה הוא null, המערכת משתמשת בערך הטקסט (במקרה הזה, {system.uuid}-{messageid}) כתבנית. התבנית הזו שימושית כדי לספק ערך של 'שינוי ברירת מחדל', במקרים שבהם רוצים לשנות את תבנית ברירת המחדל (חלק הטקסט) עם ערכים שמוגדרים באופן דינמי. לדוגמה, משפט מותנה יכול לאחזר ערך ממפת מפתח/ערך ולהגדיר את המשתנה שאליו מתייחסים לערך הזה:

<AssignMessage name='AV-template-with-fallback'> 
 <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template ref='my_variable'>{system.uuid}-{messageid}</Template>
  </AssignVariable>
</AssignMessage>

`<Value>` (ילד/ה של `<AssignVariable>`)

הגדרה של הערך של משתנה הזרימה של היעד שהוגדר באמצעות <AssignVariable>. הערך תמיד מתפרש כמחרוזת ליטרלית. אי אפשר להשתמש במשתנה של זרימת נתונים כערך, גם אם מקיפים את הערך בסוגריים מסולסלים ({}). כדי להשתמש במשתנה של זרימת נתונים, צריך להשתמש במקום זאת ב-<Ref>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת
רכיב אב	`<AssignVariable>`
רכיבי צאצא	ללא

כשמשתמשים בו בשילוב עם הרכיב <Ref>, <Value> משמש כערך ברירת המחדל (או כערך חלופי). אם לא מציינים את <Ref>, אם אי אפשר לפתור את הערך שלו או אם הוא null, המערכת משתמשת בערך של <Value>.

רכיב <Value> משתמש בתחביר הבא:

תחבירs29

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
    <Value>variable_value</Value>
  </AssignVariable>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדר הערך של משתנה זרימה היעד, myvar, לערך המילולי '42':

<AssignMessage name="assignvariable-1">
  <AssignVariable>
    <Name>myvar</Name>
    <Value>42</Value>
  </AssignVariable>
</AssignMessage>

דוגמה 2

בדוגמה הבאה, הערך של משתנה הזרימה request.header.user-agent מוקצה למשתנה הזרימה myvar, והערך של פרמטר השאילתה country מוקצה למשתנה Country:

<AssignMessage name="assignvariable-2">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
</AssignMessage>

אם אחת מההקצאות נכשלת, <AssignVariable> מקצה במקום זאת את הערך ErrorOnCopy למשתנה זרימה של היעד.

`<Copy>`

מעתין ערכים מה הודעה שצוינה על ידי המאפיין source להודעה שצוינה על ידי רכיב <AssignTo>. אם לא מציינים יעד באמצעות <AssignTo>, המדיניות הזו מעתיקה את הערכים לבקשה או לתשובה, בהתאם למיקום שבו המדיניות הזו מופעלת בתהליך.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת
רכיב אב	`<AssignMessage>`
רכיבי צאצא	`<FormParams>` `<Headers>` `<Path>` `<Payload>` `<QueryParams>` `<ReasonPhrase>` `<StatusCode>` `<Verb>` `<Version>`

אם לא מציינים רכיבי צאצא מתחת לרכיב <Copy>, כל החלקים של הודעת המקור שצוינה יועתקו.

רכיב <Copy> משתמש בתחביר הבא:

תחבירs30

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
    <Copy source="[request|response]">
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>[false|true]</Path>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>[false|true]</ReasonPhrase>
    <StatusCode>[false|true]</StatusCode>
    <Verb>[false|true]</Verb>
    <Version>[false|true]</Version>
  </Copy>
  <!-- Used as the destination for the <Copy> values -->
  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>
</AssignMessage>

דוגמה 1s31

בדוגמה הבאה רואים העתקה של כותרת, שלושה פרמטרים של טופס, הנתיב וכל הפרמטרים של השאילתה מההודעה request לבקשה מותאמת אישית חדשה בשם newRequest:

<AssignMessage name="AM-copy-1">
  <AssignTo createNew="true" transport="http" type="request">newRequest</AssignTo>
  <Copy source="request">
    <Headers>
      <Header name="Header_Name_1"/>
    </Headers>
    <FormParams>
      <FormParam name="Form_Param_Name_1"/>
      <FormParam name="Form_Param_Name_2"/>
      <FormParam name="Form_Param_Name_3"/>
    </FormParams>
    <Path>true</Path>
    <QueryParams/>
  </Copy>
</AssignMessage>

מכיוון שרכיבים כמו <Payload> ו-<Verb> לא קיימים, המדיניות לא מעתיקה את החלקים האלה של ההודעה.

דוגמה 2s32

בדוגמה הבאה, קודם מסירים את כל מה שיש בהודעה הקיימת response, ואז מעתיקים את כל הערכים מהודעה אחרת שנקראת secondResponse אל ההודעה response:

<AssignMessage name='AM-Copy-Response'>
  <AssignTo createNew="false" transport="http" type="response">response</AssignTo>
  <!-- first remove any existing values -->
  <Remove/>
  <!-- then copy everything from the designated message -->
  <Copy source="secondResponse"/>
</AssignMessage>

לרכיב <Copy> יש מאפיין אחד:

מאפיין תיאור חובה? סוג

source

מאפיין	תיאור	חובה?	סוג
source	מציין את אובייקט המקור של ההעתקה. אם לא מציינים את `source`, ברירת המחדל היא `message`, שערכו משתנה בהתאם לזרימה שבה המדיניות מופעלת. אם המדיניות מופעלת במהלך זרימת הבקשה, המשתנה `message` מתייחס לאובייקט `request`. אם המדיניות מופעלת במהלך זרימת התגובה, המשתנה `message` מתייחס לאובייקט `response`. אם אי אפשר לפתור את משתנה המקור, או שהוא נפתר כסוג שאינו הודעה, `<Copy>` לא מגיב.	אופציונלי	מחרוזת

מציין את אובייקט המקור של ההעתקה.

אם לא מציינים את source, ברירת המחדל היא message, שערכו משתנה בהתאם לזרימה שבה המדיניות מופעלת. אם המדיניות מופעלת במהלך זרימת הבקשה, המשתנה message מתייחס לאובייקט request. אם המדיניות מופעלת במהלך זרימת התגובה, המשתנה message מתייחס לאובייקט response.
אם אי אפשר לפתור את משתנה המקור, או שהוא נפתר כסוג שאינו הודעה, <Copy> לא מגיב.

אופציונלי

מחרוזת

`<FormParams>` (ילד/ה של `<Copy>`)

מעתיק פרמטרים של טופס מהבקשה שצוינה על ידי מאפיין source של רכיב <Copy> לבקשה שצוינה על ידי רכיב <AssignTo>. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<FormParam>` או מערך ריק
רכיב אב	`<Copy>`
רכיבי צאצא	`<FormParam>`

רכיב <FormParams> משתמש בתחביר הבא:

תחבירs33

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  </Copy>
</AssignMessage>

דוגמה 1s34

בדוגמה הבאה מועתק פרמטר טופס יחיד מהבקשה לבקשה המותאמת אישית MyCustomRequest:

<AssignMessage name="copy-formparams-1">
  <Copy source="request">
    <FormParams>
      <FormParam name="paramName">Form param value 1</FormParam>
    </FormParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 2s35

בדוגמה הבאה מועתקים כל הפרמטרים של הטופס לבקשה המותאמת אישית MyCustomRequest:

<AssignMessage name="copy-formparams-2">
  <Copy source="request">
    <FormParams/>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 3s36

בדוגמה הבאה מועתקים שלושה פרמטרים של טופס לבקשה המותאמת אישית MyCustomRequest:

<AssignMessage name="copy-formparams-3">
  <Copy source="request">
    <FormParams>
      <FormParam name="paramName1"/>
      <FormParam name="paramName2"/>
      <FormParam name="paramName3"/>
    </FormParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 4s37

אם יש כמה פרמטרים של טופס עם אותו שם, משתמשים בתחביר הבא:

<AssignMessage name="copy-formparams-4">
  <Copy source="request">
    <FormParams>
      <FormParam name="f1"/>
      <FormParam name="f2"/>
      <FormParam name="f3.2"/>
    </FormParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

בדוגמה הזו, הפונקציה מעתיקה את הערכים f1,‏ f2 ואת הערך השני של f3. אם למשתנה f3 יש רק ערך אחד, הוא לא מועתק.

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

פועל HTTP: ‏ POST
סוג ההודעה: תגובה
אחת (או שתי) מהאפשרויות הבאות:
- נתוני טופס: מוגדר לערך כלשהו או ל-"" (המחרוזת הריקה). לדוגמה, אם הפרומפט הוא curl, מוסיפים -d "" לבקשה.
- Content-Length כותרת: הערך צריך להיות 0 (אם אין נתונים בבקשה המקורית), אחרת צריך לציין את האורך הנוכחי. לדוגמה, אם רוצים להוסיף את הפקודה curl add -H "Content-Length: 0" לבקשה.

כשמעתיקים את <FormParams>, ‏ <Copy> מגדיר את Content-Type של ההודעה ל-application/x-www-form-urlencoded לפני שליחת ההודעה לשירות היעד.

`<Headers>` (ילד/ה של `<Copy>`)

מעתיק כותרות HTTP מהודעת הבקשה או התגובה שצוינה על ידי מאפיין source של רכיב <Copy> אל הודעת הבקשה או התגובה שצוינה על ידי רכיב <AssignTo>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<Header>` או מערך ריק
רכיב אב	`<Copy>`
רכיבי צאצא	`<Header>`

רכיב <Headers> משתמש בתחביר הבא:

תחבירs38

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Copy>
</AssignMessage>

דוגמה 1s39

בדוגמה הבאה מועתקת הכותרת user-agent מהבקשה לאובייקט הבקשה המותאם אישית החדש:

<AssignMessage name="copy-headers-1">
  <Copy source="request">
    <Headers>
      <Header name="user-agent"/>
    </Headers>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 2s40

כדי להעתיק את כל הכותרות, משתמשים ברכיב <Headers> ריק, כמו בדוגמה הבאה:

<AssignMessage name="copy-headers-2">
  <Copy source="request">
    <Headers/>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 3s41

אם יש כמה כותרות עם אותו שם, משתמשים בתחביר הבא:

<AssignMessage name="copy-headers-3">
  <Copy source="request">
    <Headers>
      <Header name="h1"/>
      <Header name="h2"/>
      <Header name="h3.2"/>
    </Headers>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

בדוגמה הזו, הפונקציה מעתיקה את הערכים h1,‏ h2 ואת הערך השני של h3. אם ל-h3 יש רק ערך אחד, הוא לא מועתק.

`<Path>` (ילד/ה של `<Copy>`)

הפונקציה קובעת אם להעתיק את הנתיב מבקשת המקור לבקשת היעד. לרכיב הזה אין השפעה על התשובה.

אם הערך הוא true, המדיניות הזו מעתיקה את הנתיב מה הודעת הבקשה שצוינה על ידי מאפיין source של הרכיב <Copy> אל הודעת הבקשה שצוינה על ידי הרכיב <AssignTo>.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<Copy>`
רכיבי צאצא	ללא

רכיב <Path> משתמש בתחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Path>[false|true]</Path>
  </Copy>
</AssignMessage>

דוגמה 1s42

הדוגמה הבאה מראה שהמדיניות AssignMessage צריכה להעתיק את הנתיב מבקשת המקור לאובייקט הבקשה החדש והמותאם אישית:

<AssignMessage name="copy-path-1">
  <Copy source="request">
    <Path>true</Path>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<Path> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: בקשה

`<Payload>` (ילד/ה של `<Copy>`)

קובעת אם יש להעתיק את מטען הייעודי (payload) מהמקור ליעד. המקור והיעד יכולים להיות בקשות או תגובות.

אם הערך הוא true, המדיניות הזו מעתיקה את מטען הנתונים מהההודעה שצוינה על ידי מאפיין source של רכיב <Copy> אל ההודעה שצוינה על ידי רכיב <AssignTo>.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<Copy>`
רכיבי צאצא	ללא

רכיב <Payload> משתמש בתחביר הבא:

תחבירs43

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Payload>[false|true]</Payload>
  </Copy>
</AssignMessage>

דוגמה 1s44

בדוגמה הבאה, הערך של <Payload> מוגדר כ-true, כך שמטען ייעודי (payload) הבקשה מועתק מהבקשה לתגובה:

<AssignMessage name="AM-copy-payload-1">
  <Copy source="request">
    <Payload>true</Payload>
  </Copy>
  <AssignTo>response</AssignTo>
</AssignMessage>

`<QueryParams>` (ילד/ה של `<Copy>`)

מעתין פרמטרים של מחרוזת שאילתה מהבקשה שצוינה על ידי מאפיין source של רכיב <Copy> אל בקשה שצוינה על ידי רכיב <AssignTo>. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<QueryParam>` או מערך ריק
רכיב אב	`<QueryParam>`
רכיבי צאצא	ללא

רכיב <QueryParams> משתמש בתחביר הבא:

תחבירs45

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Copy>
</AssignMessage>

דוגמה 1s46

בדוגמה הבאה מועתק פרמטר השאילתה my_param מהבקשה לאובייקט בקשה מותאם אישית חדש:

<AssignMessage name="copy-queryparams-1">
  <Copy source="request">
    <QueryParams>
      <QueryParam name="my_param"/>
    </QueryParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 2s47

בדוגמה הבאה מועתקים כל פרמטרי השאילתה מהבקשה לאובייקט בקשה מותאם אישית חדש:

<AssignMessage name="copy-queryparams-2">
  <Copy source="request">
    <QueryParams/>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 3s48

אם יש כמה פרמטרים של שאילתה עם אותו שם, משתמשים בתחביר הבא:

<AssignMessage name="copy-queryparams-3">
  <Copy source="request">
    <QueryParams>
      <QueryParam name="qp1"/>
      <QueryParam name="qp2"/>
      <QueryParam name="qp3.2"/>
    </QueryParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

בדוגמה הזו, הפונקציה מעתיקה את הערכים 'qp1', ‏ 'qp2' ואת הערך השני של 'qp3'. אם למשתנה qp3 יש רק ערך אחד, הוא לא מועתק.

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

פועל HTTP: ‏ GET
סוג ההודעה: בקשה

`<ReasonPhrase>` (ילד/ה של `<Copy>`)

קובע אם צריך להעתיק את משפט הסיבה מתגובת המקור לתגובת היעד. לרכיב הזה אין השפעה על הבקשה.

אם הערך הוא True, המדיניות הזו מעתיקה את ReasonPhrase מהתגובה שצוינה על ידי המאפיין source של הרכיב <Copy> אל התגובה שצוינה על ידי הרכיב <AssignTo>.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<Copy>`
רכיבי צאצא	ללא

רכיב <ReasonPhrase> משתמש בתחביר הבא:

תחבירs49

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <ReasonPhrase>[false|true]</ReasonPhrase>
  </Copy>
</AssignMessage>

דוגמה 1s50

בדוגמה הבאה, הערך של <ReasonPhrase> מוגדר ל-true. עם רכיב המקור <AssignTo> כפי שצוין, הפונקציה <Copy> מעתיקה את משפט הסיבה מהודעת התגובה שצוינה לאובייקט response:

<AssignMessage name="AM-copy-reasonphrase-1">
  <Copy source="serviceCalloutResponse">
    <ReasonPhrase>true</ReasonPhrase>
  </Copy>
  <AssignTo>response</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<ReasonPhrase> רק אם הודעות המקור והיעד הן מסוג תגובה.

`<StatusCode>` (ילד/ה של `<Copy>`)

ההגדרה קובעת אם קוד הסטטוס מועתק מהתגובה של המקור לתגובה של היעד. לרכיב הזה אין השפעה על הבקשה.

אם הערך הוא true, המדיניות מעתיקה את קוד הסטטוס מה הודעת התגובה שצוינה על ידי מאפיין source של רכיב <Copy> לה הודעת התגובה שצוינה על ידי רכיב <AssignTo>.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<Copy>`
רכיבי צאצא	ללא

רכיב <StatusCode> משתמש בתחביר הבא:

תחבירs52

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <StatusCode>[false|true]</StatusCode>
  </Copy>
</AssignMessage>

דוגמה 1s53

בדוגמה הבאה, הערך של <StatusCode> מוגדר כ-true, ולכן קוד הסטטוס מועתק מאובייקט התגובה שמוגדר כברירת מחדל לאובייקט תגובה חדש ומותאם אישית:

<AssignMessage name="copy-statuscode-1">
  <Copy source="response">
    <StatusCode>true</StatusCode>
  </Copy>
  <AssignTo createNew="true" transport="http" type="response">MyCustomResponse</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<StatusCode> רק אם הודעות המקור והיעד הן מסוג תגובה.

שימוש נפוץ ב-<StatusCode> הוא להגדרת קוד סטטוס של תגובת ה-proxy לערך שונה מזה שהתקבל מהיעד.

`<Verb>` (ילד/ה של `<Copy>`)

הפונקציה קובעת אם פועל ה-HTTP מועתק מבקשת המקור לבקשת היעד. לרכיב הזה אין השפעה על התשובה.

אם הערך הוא true, הפועל שנמצא במאפיין source של הרכיב <Copy> מועתק לבקשה שצוינה ברכיב <AssignTo>.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<Copy>`
רכיבי צאצא	ללא

רכיב <Verb> משתמש בתחביר הבא:

תחבירs54

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Verb>[false|true]</Verb>
  </Copy>
</AssignMessage>

דוגמה 1s55

בדוגמה הבאה, הערך של <Verb> מוגדר כ-true, כך שהפועל מועתק מהבקשה שמוגדרת כברירת מחדל לבקשה חדשה בהתאמה אישית:

<AssignMessage name="copy-verb-1">
  <Copy source="request">
    <Verb>true</Verb>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<Verb> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: בקשה

`<Version>` (ילד/ה של `<Copy>`)

הפונקציה קובעת אם גרסת ה-HTTP מועתקת מבקשת המקור לבקשת היעד. לרכיב הזה אין השפעה על התשובה.

אם הערך הוא true, המערכת מעתיקה את גרסת ה-HTTP שנמצאת במאפיין source של האלמנט <Copy> לאובייקט שצוין באלמנט <AssignTo>.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<Copy>`
רכיבי צאצא	ללא

רכיב <Version> משתמש בתחביר הבא:

תחבירs56

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Version>[false|true]</Version>
  </Copy>
</AssignMessage>

דוגמה 1s57

בדוגמה הבאה, הערך של <Version> מוגדר כ-true בבקשה, מה שגורם להעתקת הגרסה מאובייקט הבקשה שמוגדר כברירת מחדל לאובייקט בקשה חדש ומותאם אישית:

<AssignMessage name="copy-version-1">
  <Copy source="request">
    <Version>true</Version>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<Version> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: בקשה

`<DisplayName>`

אפשר להשתמש במאפיין הזה בנוסף למאפיין name כדי לתת למדיניות שם אחר, שנשמע יותר טבעי, ולתייג אותה בכלי לעריכת ה-proxy בממשק ניהול.

הרכיב <DisplayName> משותף לכל סוגי המדיניות.

ערך ברירת המחדל	לא רלוונטי
חובה?	אופציונלי. אם לא מציינים את `<DisplayName>`, המערכת משתמשת בערך של מאפיין `name` של המדיניות
סוג	מחרוזת
רכיב אב	<`PolicyElement`>
רכיבי צאצא	ללא

התחביר של רכיב <DisplayName> הוא:

תחביר

<PolicyElement>
  <DisplayName>policy_display_name</DisplayName>
  ...
</PolicyElement>

דוגמה

<PolicyElement>
  <DisplayName>My Validation Policy</DisplayName>
</PolicyElement>

לרכיב <DisplayName> אין מאפיינים או רכיבי צאצא.

`<IgnoreUnresolvedVariables>`

קובעת אם העיבוד ייפסק כשנתקלים במשתנה לא פתור.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<AssignMessage>`
רכיבי צאצא	ללא

הערך true גורם להתעלמות ממשתנים שלא נפתרו ולהמשך העיבוד. אחרת false. ערך ברירת המחדל הוא false.

הגדרה של <IgnoreUnresolvedVariables> ל-true שונה מהגדרה של continueOnError של <AssignMessage> ל-true, כי היא ספציפית להגדרה ולקבלת ערכים של משתנים. אם מגדירים את continueOnError ל-true, ‏ Edge מתעלם מכל השגיאות, ולא רק משגיאות שנתקל בהן כשמשתמשים במשתנים.

רכיב <IgnoreUnresolvedVariables> משתמש בתחביר הבא:

תחבירs58

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <IgnoreUnresolvedVariables>[true|false]
  </IgnoreUnresolvedVariables>
</AssignMessage>

דוגמה 1s59

בדוגמה הבאה, הערך של <IgnoreUnresolvedVariables> מוגדר ל-true:

<AssignMessage name="AM-Set-Headers">
  <Set>
    <Headers>
      <Header name='new-header'>{possibly-defined-variable}<Header>
    </Headers>
  </Set>
  <IgnoreUnresolvedVariables>true
  </IgnoreUnresolvedVariables>
</AssignMessage>

מכיוון שהמדיניות <IgnoreUnresolvedVariables> מוגדרת לערך true, אם המשתנה possibly-defined-variable לא מוגדר, המדיניות הזו לא תגרום לשגיאה.

`<Remove>`

הסרת כותרות, פרמטרים של שאילתות, פרמטרים של טפסים ו/או מטען הייעודי (payload) של ההודעה מהודעה. ההודעה יכולה להיות בקשה או תגובה. כדי לציין על איזו הודעה <Remove> פועל הרכיב, משתמשים ברכיב <AssignTo>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	סוג מורכב
רכיב אב	`<AssignMessage>`
רכיבי צאצא	`<FormParams>` `<Headers>` `<Payload>` `<QueryParams>`

תרחיש נפוץ לשימוש ב-<Remove> הוא מחיקה של פרמטר שאילתה או כותרת שמכילים מידע רגיש מאובייקט הבקשה הנכנסת, כדי להימנע מהעברה שלו לשרת העורפי.

רכיב <Remove> משתמש בתחביר הבא:

תחבירs60

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Remove>
</AssignMessage>

דוגמה 1s61

בדוגמה הבאה, גוף ההודעה מוסר מהתגובה:

<AssignMessage name="AM-remove-1">
  <DisplayName>remove-1</DisplayName>
  <Remove>
    <Payload>true</Payload>
  </Remove>
  <AssignTo>response</AssignTo>
</AssignMessage>

בתהליך התגובה, המדיניות הזו מסירה את גוף התגובה ומחזירה רק כותרות HTTP ללקוח.

דוגמה 2s62

בדוגמה הבאה מוסרים כל פרמטרי הטופס ופרמטר שאילתה מהאובייקט request:

<AssignMessage name="AM-remove-2">
  <Remove>
    <!-- Empty (<FormParams/>) removes all form parameters -->
    <FormParams/>
    <QueryParams>
      <QueryParam name="qp1"/>
    </QueryParams>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 3s63

בדוגמה הבאה מוסר כל התוכן מאובייקט של הודעה:

<AssignMessage name="AM-remove-3">
  <Remove/>
  <AssignTo>request</AssignTo>
</AssignMessage>

בדרך כלל עושים את זה רק אם מתכוונים להשתמש ברכיב <Set> או ברכיב <Copy> כדי להגדיר ערכי החלפה מסוימים בהודעה.

`<FormParams>` (ילד/ה של `<Remove>`)

מסיר מהבקשה את הפרמטרים שצוינו בטופס. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<FormParam>` או מערך ריק
רכיב אב	`<Remove>`
רכיבי צאצא	`<FormParam>`

רכיב <FormParams> משתמש בתחביר הבא:

תחבירs64

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  </Remove>
</AssignMessage>

דוגמה 1s65

בדוגמה הבאה, שלושה פרמטרים של טופס מוסרים מהבקשה:

<AssignMessage name="AM-remove-formparams-1">
  <Remove>
    <FormParams>
      <FormParam name="form_param_1"/>
      <FormParam name="form_param_2"/>
      <FormParam name="form_param_3"/>
    </FormParams>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 2s66

בדוגמה הבאה מוסרים מהבקשה כל הפרמטרים של הטופס:

<AssignMessage name="AM-remove-formparams-2">
  <Remove>
    <FormParams/>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 3s67

אם יש כמה פרמטרים של טופס עם אותו שם, משתמשים בתחביר הבא:

<AssignMessage name="AM-remove-formparams-3">
  <Remove>
    <FormParams>
      <FormParam name="f1"/>
      <FormParam name="f2"/>
      <FormParam name="f3.2"/>
    </FormParams>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

בדוגמה הזו מוסרים הערכים f1,‏ f2 והערך השני של f3. אם ל-f3 יש רק ערך אחד, הוא לא יוסר.

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: בקשה
Content-Type: "application/x-www-form-urlencoded"

`<Headers>` (ילד/ה של `<Remove>`)

הסרה של כותרות ה-HTTP שצוינו מהבקשה או מהתגובה, שצוינו ברכיב <AssignTo>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<Header>` או מערך ריק
רכיב אב	`<Remove>`
רכיבי צאצא	`<Header>`

רכיב <Headers> משתמש בתחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Remove>
</AssignMessage>

דוגמה 1s68

בדוגמה הבאה, הכותרת user-agent מוסרת מהבקשה:

<AssignMessage name="AM-remove-one-header">
  <Remove>
    <Headers>
      <Header name="user-agent"/>
    </Headers>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 2s69

בדוגמה הבאה, כל הכותרות מוסרות מהבקשה:

<AssignMessage name="AM-remove-all-headers">
  <Remove>
    <Headers/>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 3s70

אם יש כמה כותרות עם אותו שם, משתמשים בתחביר הבא:

<AssignMessage name="AM-remove-headers-3">
  <Remove>
    <Headers>
      <Header name="h1"/>
      <Header name="h2"/>
      <Header name="h3.2"/>
    </Headers>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

בדוגמה הזו, הערכים h1,‏ h2 והערך השני של h3 מוסרים מהבקשה. אם ל-h3 יש רק ערך אחד, הוא לא יוסר.

`<Payload>` (ילד/ה של `<Remove>`)

המאפיין הזה קובע אם <Remove> מוחק את מטען הייעודי (payload) בבקשה או בתגובה, שמוגדר על ידי הרכיב <AssignTo>. הערך true מוחק את מטען הייעודי (payload), והערך false לא מוחק אותו. ערך ברירת המחדל הוא false.

ערך ברירת מחדל	לא נכון
חובה?	אופציונלי
סוג	בוליאני
רכיב אב	`<Remove>`
רכיבי צאצא	ללא

רכיב <Payload> משתמש בתחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <Payload>[false|true]</Payload>
  </Remove>
</AssignMessage>

דוגמה 1s71

בדוגמה הבאה, הערך של <Payload> מוגדר כ-true, כדי שמטען הייעודי (payload) של הבקשה יימחק:

<AssignMessage name="AM-remove-payload-1">
  <Remove>
    <Payload>true</Payload>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

`<QueryParams>` (ילד/ה של `<Remove>`)

הפונקציה מסירה מהבקשה את הפרמטרים שצוינו של השאילתה. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<QueryParam>` או מערך ריק
רכיב אב	`<Remove>`
רכיבי צאצא	`<QueryParam>`

רכיב <QueryParams> משתמש בתחביר הבא:

תחבירs72

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Remove>
</AssignMessage>

דוגמה 1s73

בדוגמה הבאה מוסר פרמטר שאילתה יחיד מהבקשה:

<AssignMessage name="AM-remove-queryparams-1">
  <Remove>
      <QueryParams>
        <QueryParam name="qp1"/>
      </QueryParams>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 2s74

בדוגמה הבאה מוסרים כל פרמטרים של שאילתה מהבקשה:

<AssignMessage name="AM-remove-queryparams-2">
  <Remove>
      <QueryParams/>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 3s75

אם יש כמה פרמטרים של שאילתה עם אותו שם, צריך להשתמש בתחביר הבא:

<AssignMessage name="AM-remove-queryparams-3">
  <Remove>
      <QueryParams>
        <QueryParam name="qp1"/>
        <QueryParam name="qp2"/>
        <QueryParam name="qp3.2"/>
      </QueryParams>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

בדוגמה הזו, הערכים qp1,‏ qp2 והערך השני של qp3 מוסרים מהבקשה. אם ל-qp3 יש רק ערך אחד, הוא לא יוסר.

דוגמה 4s76

בדוגמה הבאה מוסר פרמטר השאילתה apikey מהבקשה:

<AssignMessage name="AM-remove-query-param">
  <Remove>
    <QueryParams>
      <QueryParam name="apikey"/>
    </QueryParams>
  </Remove>
  <AssignTo>request</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

פועל HTTP: ‏ GET
סוג ההודעה: בקשה

`<Set>`

הגדרת מידע בהודעת הבקשה או התגובה, שמוגדר על ידי הרכיב <AssignTo>. ‫<Set> מחליף כותרות או פרמטרים של שאילתות או טפסים שכבר קיימים בהודעה המקורית. כותרות ופרמטרים של שאילתות וטפסים בהודעת HTTP יכולים להכיל כמה ערכים. כדי להוסיף ערכים נוספים לכותרת או לפרמטר, צריך להשתמש ברכיב <Add>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	סוג מורכב
רכיב אב	`<AssignMessage>`
רכיבי צאצא	`<FormParams>` `<Headers>` `<Payload>` `<Path>` `<QueryParams>` `<ReasonPhrase>` `<StatusCode>` `<Verb>` `<Version>`

הערה: רכיבי המשנה של <Set> תומכים בתכונה של החלפת מחרוזות דינמית שנקראת תבניות הודעות.

רכיב <Set> משתמש בתחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>path</Path>
    <Payload contentType="content_type" variablePrefix="prefix"
        variableSuffix="suffix">new_payload</Payload>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>reason_for_error or {variable}</ReasonPhrase>
    <StatusCode>HTTP_status_code or {variable}</StatusCode>
    <Verb>[GET|POST|PUT|PATCH|DELETE|{variable}]</Verb>
    <Version>[1.0|1.1|{variable}]</Verb>
  </Set>
</AssignMessage>

דוגמה 1s77

בדוגמה הבאה מוגדרת כותרת ספציפית. כשהמדיניות הזו מצורפת לזרימת הבקשה, היא מאפשרת למערכת במעלה הזרם לקבל כותרת נוספת שלא נכללה בבקשה המקורית שנכנסה.

<AssignMessage name="AM-Set-Header">
  <Set>
    <Headers>
        <Header name="authenticated-developer">{verifyapikey.VAK-1.developer.id}</Header>
    </Headers>
  </Set>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 2s78

בדוגמה הבאה, המטען הייעודי (payload) של התגובה נדרס, וגם הכותרת Content-Type.

<AssignMessage name="AM-Overwrite-Payload">
  <Set>
    <Payload contentType="application/json">{ "status" : 42 }</Payload>
  </Set>
  <AssignTo>response</AssignTo>
</AssignMessage>

`<FormParams>` (ילד/ה של `<Set>`)

האלמנט הזה מחליף את הפרמטרים הקיימים בטופס בבקשה בערכים החדשים שאתם מציינים. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<FormParam>`
רכיב אב	`<Set>`
רכיבי צאצא	`<FormParam>`

רכיב <FormParams> משתמש בתחביר הבא:

תחבירs79

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  </Set>
</AssignMessage>

דוגמה 1s80

בדוגמה הבאה מוגדר פרמטר של טופס בשם myparam לערך של המשתנה request.header.myparam בבקשה חדשה ומותאמת אישית:

<AssignMessage name="AM-set-formparams-1">
  <Set>
    <FormParams>
      <FormParam name="myparam">{request.header.myparam}</FormParam>
    </FormParams>
  </Set>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

פועל HTTP: ‏ POST
סוג ההודעה: בקשה

אם מגדירים פרמטרים ריקים של טופס במדיניות (<Add><FormParams/></Add>), המדיניות לא מוסיפה פרמטרים של טופס. זהה למצב שבו לא מציינים את <FormParams>.

‫<Set> משנה את Content-Type של ההודעה ל-application/x-www-form-urlencoded לפני שהוא שולח אותה לנקודת הקצה של היעד.

`<Headers>` (ילד/ה של `<Set>`)

הפעולה מחליפה כותרות HTTP קיימות בבקשה או בתגובה, שמוגדרות על ידי הרכיב <AssignTo>.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של `<Header>` אלמנטים
רכיב אב	`<Set>`
רכיבי צאצא	`<Header>`

רכיב <Headers> משתמש בתחביר הבא:

תחבירs81

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Set>
</AssignMessage>

דוגמה 1s81

בדוגמה הבאה, הכותרת x-ratelimit-remaining מוגדרת לערך של המשתנה ratelimit.Quota-1.available.count:

<AssignMessage name="AM-Set-RateLimit-Header">
  <Set>
    <Headers>
      <Header name="X-RateLimit-Remaining">{ratelimit.Quota-1.available.count}</Header>
    </Headers>
  </Set>
  <AssignTo>response</AssignTo>
</AssignMessage>

אם מגדירים כותרות ריקות במדיניות (<Set><Headers/></Set>), המדיניות לא מגדירה כותרות. הפעולה הזו תהיה זהה להשמטת <Headers>.

`<Path>` (ילד/ה של `<Set>`)

הערה:

האלמנט הזה לא פועל כרגע כמו שהוא אמור לפעול כדי לבטל או לשכתב כתובת URL של יעד של שרת proxy. (היא כן פועלת להגדרת הנתיב ב-Service Callouts, כמו שמוצג בדוגמה Learn by Doing שבהמשך).

לפעמים צריך לשלוח הודעה לכתובת URL ששונה מכתובת ה-URL שמוגדרת ב-TargetEndpoint של שרת proxy של API. אם רוצים לשכתב את כתובת ה-URL של היעד, צריך לבטל את המשתנה target.url ב-TargetEndpoint באמצעות האלמנט <AssignVariable>. (אי אפשר לבטל את target.url ב-ProxyEndpoint, כי Edge מגדיר את המשתנה ב-TargetEndpoint).

בדוגמה הבאה אפשר לראות איך מדיניות AssignMessage מבטלת את target.url. שוב, מוסיפים את המדיניות לבקשת TargetEndpoint. במקרה של מדיניות כזו, שרת ה-proxy יקרא לכתובת ה-URL שמופיעה למטה במקום לכתובת ה-URL שמוגדרת ב-TargetEndpoint.

<AssignMessage name="Assign-Message-1">
...
  <AssignVariable>
    <Name>target.url</Name>
    <Value>http://mocktarget.apigee.net/user?user=Dude</Value>
  </AssignVariable>
...

אפשר גם להשתמש במדיניות JavaScript ב-TargetEndpoint כדי לשנות את target.url.

`<Payload>` (ילד/ה של `<Set>`)

ההגדרה מגדירה את גוף ההודעה של בקשה או תגובה, שמוגדר על ידי הרכיב <AssignTo>. המטען הייעודי (payload) יכול להיות כל סוג תוכן תקין, כמו טקסט פשוט, JSON או XML.

ערך ברירת מחדל	מחרוזת ריקה
חובה?	אופציונלי
סוג	מחרוזת
רכיב אב	`<Set>`
רכיבי צאצא	ללא

רכיב <Payload> משתמש בתחביר הבא:

תחבירs82

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Payload contentType="content_type" variablePrefix="prefix"
        variableSuffix="suffix">new_payload</Payload>
  </Set>
</AssignMessage>

דוגמה 1s83

בדוגמה הבאה מוגדר מטען ייעודי (payload) של טקסט פשוט:

<AssignMessage name="set-payload-1">
  <Set>
    <Payload contentType="text/plain">42</Payload>
  </Set>
</AssignMessage>

דוגמה 2s84

בדוגמה הבאה מוגדר מטען ייעודי (payload) של JSON:

<AssignMessage name="set-payload-2">
  <Set>
    <Payload contentType="application/json">
      {"name":"foo", "type":"bar"}
    </Payload>
  </Set>
</AssignMessage>

דוגמה 3s85

בדוגמה הבאה, ערכי משתנים מוכנסים למטען הייעודי (payload) על ידי הוספת סוגריים מסולסלים לשמות המשתנים:

<AssignMessage name="set-payload-3">
  <Set>
    <Payload contentType="application/json">
      {"name":"foo", "type":"{variable_name}"}
    </Payload>
  </Set>
</AssignMessage>

בגרסאות קודמות של Apigee, לא הייתה אפשרות להשתמש בסוגריים מסולסלים כדי לציין הפניות למשתנים במטענים ייעודיים (payloads) בפורמט JSON. בגרסאות האלה, הייתם צריכים להשתמש במאפיינים variablePrefix ו-variableSuffix כדי לציין תווים להפרדה, ולהשתמש בהם כדי להקיף שמות של משתנים, כמו בדוגמה הבאה:

<AssignMessage name="set-payload-3b">
  <Set>
    <Payload contentType="application/json" variablePrefix="@" variableSuffix="#">
      {"name":"foo", "type":"@variable_name#"}
    </Payload>
  </Set>
</AssignMessage>

התחביר הישן הזה עדיין עובד.

דוגמה 4s86

התוכן של <Payload> מטופל כתבנית הודעה. המשמעות היא שמדיניות AssignMessage מחליפה משתנים שמוקפים בסוגריים מסולסלים בערך של המשתנים שאליהם מתבצעת ההפניה בזמן הריצה.

בדוגמה הבאה נעשה שימוש בתחביר של סוגריים מסולסלים כדי להגדיר חלק מהמטען הייעודי (payload) כערך משתנה:

<AssignMessage name="set-payload-4">
  <Set>
    <Payload contentType="text/xml">
      <root>
        <e1>sunday</e1>
        <e2>funday</e2>
        <e3>{var1}</e3>
      </root>
    </Payload>
  </Set>
</AssignMessage>

בטבלה הבאה מתוארים המאפיינים של <Payload>:

מאפיין	תיאור	נוכחות	סוג
`contentType`	אם מציינים ערך `contentType`, הוא מוקצה לכותרת ה-HTTP‏ `Content-Type`.	אופציונלי	מחרוזת
`variablePrefix`	אפשר לציין את התו שמשמש כתוחם מוביל במשתנה זרימה. ברירת המחדל היא '{". מידע נוסף זמין במאמר הפניה למשתני זרימה.	אופציונלי	Char
`variableSuffix`	אפשר לציין את התו המפריד בסוף משתנה זרימה. ברירת המחדל היא '}'. מידע נוסף זמין במאמר הפניה למשתני זרימה.	אופציונלי	Char

`<QueryParams>` (ילד/ה של `<Set>`)

הפרמטר מחליף ערכים קיימים של פרמטרים של שאילתות בבקשה בערכים חדשים. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מערך של רכיבי `<QueryParam>`
רכיב אב	`<Set>`
רכיבי צאצא	`<QueryParam>`

רכיב <QueryParams> משתמש בתחביר הבא:

תחבירs87

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Set>
</AssignMessage>

דוגמה 1s88

בדוגמה הבאה מוגדר פרמטר השאילתה address עם הערך של המשתנה request.header.address:

<AssignMessage name="AM-set-queryparams-1">  <Set>
    <QueryParams>
      <QueryParam name="address">{request.header.address}</QueryParam>
    </QueryParams>
  </Set>
</AssignMessage>

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

פועל HTTP: ‏ GET
סוג ההודעה: בקשה

אם מגדירים פרמטרים ריקים של שאילתה במדיניות (<Set><QueryParams/></Set>), המדיניות לא מגדירה פרמטרים של שאילתה. התוצאה זהה להשמטת <QueryParams>.

`<ReasonPhrase>` (ילד/ה של `<Set>`)

מגדיר את משפט הסיבה בתגובה. בדרך כלל משתמשים באפשרות הזו לניפוי באגים בשילוב עם <StatusCode>. לרכיב הזה אין השפעה על הבקשה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת
רכיב אב	`<Set>`
רכיבי צאצא	ללא

רכיב <ReasonPhrase> משתמש בתחביר הבא:

תחבירs89

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <ReasonPhrase>reason_for_error or {variable}</ReasonPhrase>
  </Set>
</AssignMessage>

דוגמה 1s90

בדוגמה הבאה מוגדרת סיבת הפנייה הפשוטה:

<AssignMessage name="set-reasonphrase-1">
  <Set>
    <ReasonPhrase>Bad medicine</ReasonPhrase>
  </Set>
  <AssignTo createNew="true" transport="http" type="response"/>
</AssignMessage>

דוגמה 2s91

התוכן של <ReasonPhrase> מטופל כתבנית הודעה. המשמעות היא ששם של משתנה שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה, כמו בדוגמה הבאה:

<AssignMessage name="AM-set-reasonphrase-2">
  <Set>
    <ReasonPhrase>{calloutresponse.reason.phrase}</ReasonPhrase>
  </Set>
  <AssignTo>response</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<ReasonPhrase> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: תגובה

`<StatusCode>` (ילד/ה של `<Set>`)

הגדרת קוד הסטטוס בתשובה. לרכיב הזה אין השפעה על הבקשה.

ערך ברירת מחדל	‫'200' (כשהמאפיין `createNew` של `<AssignTo>` מוגדר כ-'true')
חובה?	אופציונלי
סוג	מחרוזת או `variable`
רכיב אב	`<Set>`
רכיבי צאצא	ללא

רכיב <StatusCode> משתמש בתחביר הבא:

תחבירs92

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <StatusCode>HTTP_status_code or {variable}</StatusCode>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדר קוד סטטוס פשוט:

<AssignMessage name="AM-set-statuscode-404">
  <Set>
    <StatusCode>404</StatusCode>
  </Set>
  <AssignTo>response</AssignTo>
</AssignMessage>

דוגמה 2

התוכן של <StatusCode> מטופל כתבנית הודעה. המשמעות היא ששם משתנה שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה, כמו בדוגמה הבאה:

<AssignMessage name="set-statuscode-2">
  <Set>
    <StatusCode>{calloutresponse.status.code}</StatusCode>
  </Set>
  <AssignTo>response</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<StatusCode> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: תגובה

`<Verb>` (ילד/ה של `<Set>`)

מגדיר את פועל ה-HTTP בבקשה. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת או `variable`
רכיב אב	`<Set>`
רכיבי צאצא	ללא

רכיב <Verb> משתמש בתחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Verb>[GET|POST|PUT|PATCH|DELETE|{variable}]</Verb>
  </Set>
</AssignMessage>

דוגמה 1s93

בדוגמה הבאה מוגדר פועל פשוט בבקשה:

<AssignMessage name="AM-set-verb-1">
  <Set>
    <Verb>POST</Verb>
  </Set>
  <AssignTo>request</AssignTo>
</AssignMessage>

דוגמה 2s94

התוכן של <Verb> מטופל כתבנית הודעה. המשמעות היא ששם של משתנה שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה.

בדוגמה הבאה משתמשים במשתנה כדי לאכלס פועל:

<AssignMessage name="AM-set-verb-to-dynamic-value">
  <Set>
    <Verb>{my_variable}</Verb>
  </Set>
  <AssignTo>request</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<Verb> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: בקשה

`<Version>` (ילד/ה של `<Set>`)

הגדרת גרסת ה-HTTP בבקשה. לרכיב הזה אין השפעה על התשובה.

ערך ברירת מחדל	לא רלוונטי
חובה?	אופציונלי
סוג	מחרוזת או `variable`
רכיב אב	`<Set>`
רכיבי צאצא	ללא

רכיב <Version> משתמש בתחביר הבא:

תחבירs95

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Version>[1.0|1.1|{variable}]</Verb>
  </Set>
</AssignMessage>

דוגמה 1s96

בדוגמה הבאה, מספר הגרסה מוגדר כ-1.1:

<AssignMessage name="AM-set-version-1">
  <Set>
    <Version>1.1</Version>
  </Set>
 </AssignMessage>

דוגמה 2

בדוגמה הבאה נעשה שימוש במשתנה בסוגריים מסולסלים כדי להגדיר את מספר הגרסה:

<AssignMessage name="AM-set-version-2">
  <Set>
    <Version>{my_version}</Version>
  </Set>
  <AssignTo>request</AssignTo>
</AssignMessage>

התוכן של <Version> מטופל כתבנית הודעה. המשמעות היא ששם של משתנה שמוקף בסוגריים מסולסלים יוחלף בזמן הריצה בערך של המשתנה שאליו מתבצעת ההפניה.

אפשר להשתמש ב-<Version> רק אם מתקיימים הקריטריונים הבאים:

סוג ההודעה: בקשה

יצירת הודעות בקשה בהתאמה אישית

אפשר להשתמש במדיניות AssignMessage כדי ליצור הודעת בקשה בהתאמה אישית. אחרי שיוצרים בקשה בהתאמה אישית, אפשר להשתמש בה בדרכים הבאות:

גישה למשתנים שלו במדיניות אחרת
העברה לשירות חיצוני

כדי ליצור הודעת בקשה בהתאמה אישית, משתמשים ברכיב <AssignTo> במדיניות AssignMessage. מגדירים את createNew לערך true ומציינים את שם ההודעה החדשה בגוף של הרכיב, כמו בדוגמה הבאה:

<AssignMessage name="AM-assignto-2"> 
  <AssignTo createNew="true" transport="http" type="request">NameOfNewMessage</AssignTo> 
</AssignMessage>

כברירת מחדל, Edge לא עושה כלום עם הודעת הבקשה המותאמת אישית. אחרי שיוצרים את התמונה, Edge ממשיך בתהליך עם הבקשה המקורית. כדי להשתמש בבקשה מותאמת אישית, מוסיפים לממשק ה-proxy מדיניות כמו מדיניות ServiceCallout, שיכולה להעביר את הבקשה המותאמת אישית לשירות חיצוני.

בדוגמאות הבאות נוצרות הודעות בקשה בהתאמה אישית:

דוגמה 1s97

בדוגמה הבאה נוצר אובייקט בקשה מותאם אישית באמצעות Assign Message:

<AssignMessage name="AssignMessage-3">
  <AssignTo createNew="true" type="request">MyCustomRequest</AssignTo>
  <Copy>
    <Headers>
     <Header name="user-agent"/>
    </Headers>
  </Copy>
  <Set>
    <QueryParams>
      <QueryParam name="address">{request.queryparam.addy}</QueryParam>
    </QueryParams>
    <Verb>GET</Verb>
  </Set>
  <IgnoreUnresolvedVariables>false
  </IgnoreUnresolvedVariables>
</AssignMessage>

בדוגמה הזו:

יוצרת אובייקט חדש של הודעת בקשה בשם MyCustomRequest.
ב-MyCustomRequest, המדיניות הזו:
- מעתין את הערך של כותרת ה-HTTP‏ user-agent מהבקשה הנכנסת להודעה החדשה. מכיוון שהרכיב <Copy> משתמש בהפניה מוחלטת למשתנה של זרימת הנתונים user-agent, אין צורך לציין את המאפיין source לרכיב <Copy>.
- מגדיר את פרמטר השאילתה address בהודעה המותאמת אישית לערך של פרמטר השאילתה addy של הבקשה הנכנסת.
- מגדיר את פועל ה-HTTP ל-GET.
הערך של <IgnoreUnresolvedVariables> מוגדר כ-false. אם הערך של <IgnoreUnresolvedVariables> הוא false, ואחד מהמשתנים שהמדיניות מנסה להוסיף לא קיים, Edge יפסיק את העיבוד בזרימת ה-API.

דוגמה 2s98

דוגמה נוספת שמראה איך ליצור אובייקט בקשה בהתאמה אישית באמצעות Assign Message:

<AssignMessage name="AssignMessage-2">
  <AssignTo createNew="true" type="request">partner.request</AssignTo>
  <Set>
    <Verb>POST</Verb>
    <Payload contentType="text/xml">
      <request><operation>105</operation></request>
    </Payload>
  </Set>
</AssignMessage>

בדוגמה הזו נוצרת בקשה חדשה בהתאמה אישית בשם partner.request. לאחר מכן, הוא מגדיר את הערכים של <Verb> ושל <Payload> בבקשה החדשה.

אפשר לגשת להודעת בקשה בהתאמה אישית במדיניות אחרת של AssignMessage שמופיעה בהמשך התהליך. בדוגמה הבאה מוצג הערך של הכותרת user-agent של הודעת הבקשה המותאמת אישית:

<AssignMessage name="custom-request-1-access">
  <DisplayName>custom-request-1-access</DisplayName>
  <AssignTo>partner.request</AssignTo>
  <Set>
    <Headers>
      <Header name="user-agentCopyCustomRequest">{MyCustomRequest.header.user-agent}</Header>
    </Headers>
  </Set>
</AssignMessage>

סרטונים

כדאי לצפות בסרטונים הבאים כדי לקבל מידע נוסף על המדיניות בנושא AssignMessage.

וידאו	תיאור
למה צריך להקצות מדיניות הודעות?	כאן אפשר לקרוא על היתרונות של שימוש במדיניות AssignMessage כדי לשנות את בקשת ה-API או התגובה בלי לשנות את קוד ה-Backend.
העתקת רכיבי API באמצעות מדיניות AssignMessage	העתקת רכיבים מבקשת API או מתשובת API ויצירת אובייקט בקשה או תשובה חדש באמצעות מדיניות AssignMessage.
הסרת רכיבי API באמצעות מדיניות AssignMessage	מסירים רכיבי API ומשנים את ה-API לפני שהוא מגיע לשרת העורפי לטירגוט באמצעות המדיניות AssignMessage.
הוספה והגדרה של רכיבי API באמצעות מדיניות AssignMessage	אפשר לשנות בקשת API או תגובה על ידי הוספה של פרמטרים של שאילתות, כותרות, פרמטרים של טפסים או מטענים ייעודיים (payloads) באמצעות מדיניות AssignMessage.
יצירת משתנים מותאמים אישית באמצעות מדיניות AssignMessage	הגדרת משתני זרימה מותאמים אישית באמצעות מדיניות AssignMessage ושימוש במשתנים במדיניות אחרת ב-proxy ל-API.
יצירת אובייקטים חדשים של בקשות או תגובות באמצעות מדיניות AssignMessage	יוצרים אובייקטים חדשים של בקשות או תגובות ל-API באמצעות מדיניות AssignMessage בזמן הריצה של ה-API.
יצירת API מדומה באמצעות מדיניות AssignMessage	כדי ליצור API פשוט ל-REST לצורך הדמיה, מוסיפים את מדיניות AssignMessage בתהליך התגובה.
הגדרה או שינוי של מטען ייעודי (payload) באמצעות מדיניות AssignMessage	ממירים בקשת REST לבקשת SOAP על ידי הגדרת SOAP Payload באמצעות מדיניות AssignMessage בזמן הריצה של ה-API.

קודי שגיאה

בקטע הזה מתוארים קודי השגיאה והודעות השגיאה שהוחזרו, ומשתני התקלה שמוגדרים על ידי Edge כשהמדיניות הזו גורמת לשגיאה. חשוב לדעת את המידע הזה אם אתם מפתחים כללי כשל כדי לטפל בתקלות. מידע נוסף זמין במאמר מה צריך לדעת? מידע על שגיאות שקשורות למדיניות וטיפול פגמים.

שגיאות זמן ריצה

השגיאות האלה עשויות להתרחש כשהמדיניות מופעלת.

קוד תקלה סטטוס HTTP סיבה תיקון

steps.assignmessage.SetVariableFailed 500 המדיניות לא הצליחה להגדיר משתנה. לראות את מחרוזת השגיאה של שם ה- משתנה שלא נפתר.

קוד תקלה	סטטוס HTTP	סיבה
`steps.assignmessage.SetVariableFailed`	500	המדיניות לא הצליחה להגדיר משתנה. לראות את מחרוזת השגיאה של שם ה- משתנה שלא נפתר.
`steps.assignmessage.VariableOfNonMsgType`	500	השגיאה הזו מתקבלת אם המאפיין `source` ברכיב `<Copy>` מוגדר כמשתנה שאינו מסוג message. משתנים של סוגי הודעות מייצגים את כל הבקשות והתשובות של HTTP. אפליקציית Edge המובנית משתני הזרימה `request`, `response` ו-`message` הם מסוג הודעה. מידע נוסף על משתני הודעות קראו את חומר העזר בנושא משתנים.
`steps.assignmessage.UnresolvedVariable`	500	השגיאה הזו מתקבלת אם המשתנה שצוין במדיניות 'הקצאת הודעה' הוא: לא בהיקף (לא זמין בתהליך הספציפי שבו המדיניות מופעלת) או לא ניתן לפתרון (לא מוגדר)

steps.assignmessage.VariableOfNonMsgType

500

השגיאה הזו מתקבלת אם המאפיין source ברכיב <Copy> מוגדר כמשתנה שאינו מסוג message.

משתנים של סוגי הודעות מייצגים את כל הבקשות והתשובות של HTTP. אפליקציית Edge המובנית משתני הזרימה request, response ו-message הם מסוג הודעה. מידע נוסף על משתני הודעות קראו את חומר העזר בנושא משתנים.

steps.assignmessage.UnresolvedVariable

500

השגיאה הזו מתקבלת אם המשתנה שצוין במדיניות 'הקצאת הודעה' הוא:

לא בהיקף (לא זמין בתהליך הספציפי שבו המדיניות מופעלת)
לא ניתן לפתרון (לא מוגדר)

שגיאות פריסה

השגיאות האלה עשויות להתרחש כאשר פורסים שרת proxy שמכיל את המדיניות הזו.

שם השגיאה	סיבה	תיקון
`InvalidIndex`	אם האינדקס שצוין ברכיבים `<Copy>` ו/או `<Remove>` של הקצאת ההודעה היא 0 או מספר שלילי, אז הפריסה של שרת ה-proxy ל-API נכשלת.
`InvalidVariableName`	אם רכיב הצאצא `<Name>` ריק או לא צוין ברכיב `<AssignVariable>`, הפריסה של שרת ה-proxy ל-API נכשלת כי אין שם משתנה חוקי שצריך להקצות לו ערך. צריך להזין שם משתנה חוקי.
`InvalidPayload`	מטען ייעודי (payload) שצוין במדיניות אינו חוקי.

משתני כשל

המשתנים האלה מוגדרים כשהמדיניות הזו גורמת לשגיאה בזמן הריצה. לקבלת מידע נוסף, ראה מה לדעת על שגיאות שקשורות למדיניות.

משתנים	איפה	דוגמה
`fault.name="fault_name"`	`fault_name` הוא שם השגיאה, כפי שמצוין בטבלה שגיאות זמן ריצה שלמעלה. שם השגיאה הוא החלק האחרון בקוד השגיאה.	`fault.name Matches "UnresolvedVariable"`
`assignmessage.policy_name.failed`	`policy_name` הוא השם שצוין על ידי המשתמש של המדיניות שגרמה לבעיה.	`assignmessage.AM-SetResponse.failed = true`

דוגמה לתגובת שגיאה

הערה: לטיפול בשגיאות, השיטה המומלצת היא חלק errorcode מתגובת השגיאה. אל תסתמכו על הטקסט faultstring, כי הוא עשוי להשתנות.

{  
   "fault":{  
      "detail":{  
         "errorcode":"steps.assignmessage.VariableOfNonMsgType"
      },
      "faultstring":"AssignMessage[AM-SetResponse]: value of variable is not of type Message"
   }
}

דוגמה לכלל שגוי

    <FaultRule name="Assign Message Faults">    <Step>
        <Name>AM-CustomNonMessageTypeErrorResponse</Name>
        <Condition>(fault.name Matches "VariableOfNonMsgType") </Condition>
    </Step>
    <Step>
        <Name>AM-CustomSetVariableErrorResponse</Name>
        <Condition>(fault.name = "SetVariableFailed")</Condition>
    </Step>
    <Condition>(assignmessage.failed = true) </Condition>
</FaultRule>

סכימות

כל סוג מדיניות מוגדר על ידי סכימת XML ‏ (.xsd). סכימות מדיניות זמינות ב-GitHub.

נושאים קשורים

דוגמאות פעילות של מדיניות AssignMessage זמינות בדוגמאות של API Platform.

דוגמה מתקדמת יותר להחלפת הערך target.url מ-ProxyEndpoint מופיעה במאמר הזה בקהילת Apigee.

כדי לראות איך פועלת ההגדרה של נתיב במדיניות ServiceCallout, אפשר לעיין בדוגמה הזו של תרגול מעשי בדוגמאות של Apigee ב-GitHub. פשוט משכפלים את המאגר ופועלים לפי ההוראות בנושא הזה. בדוגמה נעשה שימוש במדיניות AssignMessage כדי להגדיר נתיב בקשה, ואז נעשה שימוש במדיניות Service Callout כדי לשלוח את הבקשה לשירות חיצוני.

‫AssignMessage policy

מה

תרחישים לדוגמה

רכיב <AssignMessage>

תחביר

מדיניות ברירת המחדל

דוגמאות

‫1: הוספת כותרת

‫2: הסרת מטען ייעודי

‫3: שינוי התשובה

‫4: הגדרת תוכן דינמי

‫5: הסרת פרמטר של שאילתה

‫6: הגדרה או קבלת משתנים

‫7: קבלת כותרות תגובה של קריאה לשירות

הפניה לרכיב צאצא

<Add>

תחבירs1

דוגמה 1s2

דוגמה 2s3

דוגמה 3s4

<FormParams> (ילד/ה של <Add>)

תחבירs5

דוגמה 1s6

דוגמה 2s7

דוגמה 3s8

<Headers> (ילד/ה של <Add>)

תחבירs9

דוגמה 1s10

<QueryParams> (ילד/ה של <Add>)

תחבירs11

דוגמה 1s12

<AssignTo>

תחבירs13

דוגמה 1s14

דוגמה 2s15

דוגמה 3s16

<AssignVariable>

תחבירs17

דוגמה 1s18

דוגמה 2s19

דוגמה 3s20

<Name> (ילד/ה של <AssignVariable>)

תחבירs21

דוגמה 1s22

<Ref> (ילד/ה של <AssignVariable>)

תחביר

דוגמה 1s23

דוגמה 2s23

דוגמה 3s24

<Template> (ילד/ה של <AssignVariable>)

תחבירs25

דוגמה 1s26

דוגמה 2s27

דוגמה 3s28

<Value> (ילד/ה של <AssignVariable>)

תחבירs29

דוגמה 1

דוגמה 2

<Copy>

תחבירs30

דוגמה 1s31

דוגמה 2s32

<FormParams> (ילד/ה של <Copy>)

תחבירs33

דוגמה 1s34

דוגמה 2s35

דוגמה 3s36

דוגמה 4s37

<Headers> (ילד/ה של <Copy>)

תחבירs38

דוגמה 1s39

דוגמה 2s40

דוגמה 3s41

<Path> (ילד/ה של <Copy>)

תחביר

דוגמה 1s42

<Payload> (ילד/ה של <Copy>)

תחבירs43

דוגמה 1s44

<QueryParams> (ילד/ה של <Copy>)

רכיב `<AssignMessage>`

`<Add>`

`<FormParams>` (ילד/ה של `<Add>`)

`<Headers>` (ילד/ה של `<Add>`)

`<QueryParams>` (ילד/ה של `<Add>`)

`<AssignTo>`

`<AssignVariable>`

`<Name>` (ילד/ה של `<AssignVariable>`)

`<Ref>` (ילד/ה של `<AssignVariable>`)

`<Template>` (ילד/ה של `<AssignVariable>`)

`<Value>` (ילד/ה של `<AssignVariable>`)

`<Copy>`

`<FormParams>` (ילד/ה של `<Copy>`)

`<Headers>` (ילד/ה של `<Copy>`)

`<Path>` (ילד/ה של `<Copy>`)

`<Payload>` (ילד/ה של `<Copy>`)

`<QueryParams>` (ילד/ה של `<Copy>`)

`<ReasonPhrase>` (ילד/ה של `<Copy>`)

`<StatusCode>` (ילד/ה של `<Copy>`)

`<Verb>` (ילד/ה של `<Copy>`)

`<Version>` (ילד/ה של `<Copy>`)

`<DisplayName>`

`<IgnoreUnresolvedVariables>`

`<Remove>`

`<FormParams>` (ילד/ה של `<Remove>`)

`<Headers>` (ילד/ה של `<Remove>`)

`<Payload>` (ילד/ה של `<Remove>`)

`<QueryParams>` (ילד/ה של `<Remove>`)

`<Set>`

`<FormParams>` (ילד/ה של `<Set>`)

`<Headers>` (ילד/ה של `<Set>`)

`<Path>` (ילד/ה של `<Set>`)

`<Payload>` (ילד/ה של `<Set>`)

`<QueryParams>` (ילד/ה של `<Set>`)

`<ReasonPhrase>` (ילד/ה של `<Set>`)