Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Risoluzione dei problemi relativi agli errori di runtime dei criteri JSON to XML

Stai visualizzando la documentazione di Apigee Edge.
Consulta la documentazione di Apigee X. info

SourceUnavailable

Codice di errore

steps.json2xml.SourceUnavailable

Corpo della risposta di errore

{
    "fault": {
        "faultstring": "JSONToXML[policy_name]: Source [source_variable] is not available",
        "detail": {
            "errorcode": "steps.json2xml.SourceUnavailable"
        }
    }
}

Errore di esempio

{
    "fault": {
        "faultstring": "JSONToXML[Convert-JSONToXML]: Source response is not available",
        "detail": {
            "errorcode": "steps.json2xml.SourceUnavailable"
        }
    }
}

Causa

Questo errore si verifica se la variabile message specificata nell'elemento <Source> del criterio JSON to XML è:

Al di fuori dell'ambito (non disponibile nel flusso specifico in cui viene eseguito il criterio) o
Impossibile risolvere (non è definito)

Ad esempio, questo errore si verifica se la policy da JSON a XML deve essere eseguita nel flusso di richiesta, ma l'elemento <Source> è impostato sulla variabile response, che non esiste nel flusso di richiesta.

Diagnosi

Identifica la policy JSON to XML in cui si è verificato l'errore e il nome della variabile non disponibile. Puoi trovare entrambi questi elementi nell'elemento faultstring della risposta di errore. Ad esempio, nel seguente faultstring, il nome della policy è Convert-JSONToXML e la variabile è response:
```
"faultstring": "JSONToXML[Convert-JSONToXML]: Source response is not available"
```

Nell'XML della policy JSON in XML non riuscita, verifica che il nome della variabile impostata nell'elemento <Source> corrisponda al nome della variabile identificato nella stringa di errore (passaggio 1 sopra). Ad esempio, il seguente criterio JSON in XML specifica una variabile denominata response nell'elemento <Source>, che corrisponde a quanto presente in faultstring:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<JSONToXML async="false" continueOnError="false" enabled="true" name="Convert-JSONToXML">
    <DisplayName>Convert-JSONToXML</DisplayName>
    <Properties/>
    <Options>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
    <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
        <NamespaceSeparator>:</NamespaceSeparator>
        <TextNodeName>#text</TextNodeName>
        <AttributeBlockName>#attrs</AttributeBlockName>
        <AttributePrefix>@</AttributePrefix>
        <InvalidCharsReplacement>_</InvalidCharsReplacement>
        <ObjectRootElementName>Root</ObjectRootElementName>
        <ArrayRootElementName>Array</ArrayRootElementName>
        <ArrayItemElementName>Item</ArrayItemElementName>
    </Options>
    <OutputVariable>request</OutputVariable>
    <Source>response</Source>
</JSONToXML>

Determina se la variabile utilizzata nell'elemento <Source> è definita e disponibile nel flusso in cui viene eseguito il criterio JSON in XML.
Se la variabile è:
- Al di fuori dell'ambito (non disponibile nel flusso specifico in cui viene eseguito il criterio) o
- Impossibile risolvere (non è definito)
allora è questa la causa dell'errore.

Ad esempio, supponiamo che la policy JSON to XML mostrata sopra debba essere eseguita nel flusso request. Ricorda che la variabile response viene utilizzata nell'elemento <Source> del criterio JSON to XML. La variabile di risposta è disponibile solo nel flusso di risposta.

Poiché la variabile response non esiste nel flusso di richiesta, ricevi il codice di errore:
```
steps.json2xml.SourceUnavailable
```

Risoluzione

Assicurati che la variabile impostata nell'elemento <Source> del criterio JSON in XML non riuscito sia definita ed esista nel flusso in cui viene eseguito il criterio.

Per correggere l'esempio di policy JSON in XML mostrato sopra, puoi modificare l'elemento <Source> in modo che utilizzi la variabile request, perché esiste nel flusso della richiesta:

  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <JSONToXML async="false" continueOnError="false" enabled="true" name="Convert-JSONToXML">
      <DisplayName>Convert-JSONToXML</DisplayName>
      <Properties/>
      <Options>
          <NullValue>NULL</NullValue>
          <NamespaceBlockName>#namespaces</NamespaceBlockName>
          <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
          <NamespaceSeparator>:</NamespaceSeparator>
          <TextNodeName>#text</TextNodeName>
          <AttributeBlockName>#attrs</AttributeBlockName>
          <AttributePrefix>@</AttributePrefix>
          <InvalidCharsReplacement>_</InvalidCharsReplacement>
          <ObjectRootElementName>Root</ObjectRootElementName>
          <ArrayRootElementName>Array</ArrayRootElementName>
          <ArrayItemElementName>Item</ArrayItemElementName>
      </Options>
      <OutputVariable>request</OutputVariable>
      <Source>request</Source>
  </JSONToXML>

ExecutionFailed

Codice di errore

steps.json2xml.ExecutionFailed

Corpo della risposta di errore

{
   "fault": {
        "faultstring": "JSONToXML[policy_name]: Execution failed due to reason: Expecting { or [ at line 1",
        "detail": {
            "errorcode": "steps.json2xml.ExecutionFailed"
        }
    }
}

Possibili cause

Le possibili cause di questo errore sono:

Causa	Descrizione
Payload di input mancante	Il payload di input (JSON) è vuoto.
Input non valido o malformato	L'input (JSON) passato al criterio JSON to XML non è valido o è malformato.

Causa: payload di input mancante

Nell'ambito del criterio da JSON a XML, questo errore si verifica se il contenuto (payload) della variabile specificata nell'elemento <Source> è vuoto.

Ad esempio, se l'elemento <Source> nella policy JSON to XML è impostato come variabile request o response e deve contenere un payload JSON, ma se il payload è vuoto, si verifica l'errore.

Diagnosi

Identifica la policy JSON to XML in cui si è verificato l'errore. Puoi trovare queste informazioni nell'elemento faultstring della risposta all'errore. Ad esempio, nel seguente faultstring, il nome della policy è Convert-JSONToXML:
```
"faultstring": "JSONToXML[Convert-JSONToXML]: Execution failed due to reason: Expecting { or [ at line 1"
```

Esamina l'elemento <Source> nel file XML delle norme JSON in XML non riuscito e determina la variabile specificata. Ad esempio, il seguente criterio JSON to XML ha l'elemento <Source> impostato su request:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<JSONToXML async="false" continueOnError="false" enabled="true" name="Convert-JSONToXML">
<DisplayName>Convert-JSONToXML</DisplayName>
<Properties/>
<Options>
    <NullValue>NULL</NullValue>
    <NamespaceBlockName>#namespaces</NamespaceBlockName>
    <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
    <NamespaceSeparator>:</NamespaceSeparator>
    <TextNodeName>#text</TextNodeName>
    <AttributeBlockName>#attrs</AttributeBlockName>
    <AttributePrefix>@</AttributePrefix>
    <InvalidCharsReplacement>_</InvalidCharsReplacement>
    <ObjectRootElementName>Root</ObjectRootElementName>
    <ArrayRootElementName>Array</ArrayRootElementName>
    <ArrayItemElementName>Item</ArrayItemElementName>
</Options>
<OutputVariable>request</OutputVariable>
<Source>request</Source>
</JSONToXML>

Controlla se la variabile specificata per l'elemento <Source> nella policy è vuota. Se è vuoto, è questa la causa dell'errore.

Nel criterio JSON to XML di esempio mostrato sopra, il payload della richiesta (ovvero il corpo della richiesta) inviato dal client è vuoto.

Ad esempio:
```
curl -v "http://<org>-<env>.apigee.net/v1/testjsontoxml" -H "Content-Type: application/json"
```
Poiché il payload della risposta JSON è vuoto, ricevi il codice di errore:
```
steps.json2xml.ExecutionFailed
```
Questo errore può verificarsi anche se l'elemento <Source> è impostato su response, ma il server di backend trasmette un payload vuoto.

Nota :l'intestazione HTTP Content-Type del messaggio di origine deve essere impostata su application/json; in caso contrario, la norma viene ignorata durante l'elaborazione e pertanto non viene applicata.

Risoluzione

Assicurati che l'input passato al criterio JSON to XML nell'elemento <Source> sia un payload JSON valido e non vuoto.

Per risolvere il problema con la policy JSON in XML di esempio, trasmetti un payload JSON valido. Ad esempio:

Crea un file denominato city.json con i seguenti contenuti:

{
  "Name":"Apigee",
  "City":"Bengaluru",
  "Pincode":"560016"
}

Effettua la chiamata API utilizzando un comando cURL come segue:

curl -v "http://<org>-<env>.apigee.net/v1/testxmltojson" -H "Content-Type: application/json" -X POST -d @company.json

Causa: input non valido o non corretto

Se il criterio JSON to XML analizza un input non valido o non corretto, viene visualizzato questo errore.

Ad esempio, se il seguente JSON non valido viene fornito come input alla policy JSON to XML,

[
    "args": ["name" : "Google" ]
]

riceverai il messaggio di errore:

"faultstring": "JSONToXML[Convert-JSONToXML]: Execution failed due to reason: Expecting { or [ at line 1"

Diagnosi

Identifica la policy JSON to XML in cui si è verificato l'errore. Puoi trovare queste informazioni nell'elemento faultstring della risposta all'errore. Ad esempio, nel seguente faultstring, il nome della policy è Convert-JSONToXML:
```
"faultstring": "JSONToXML[Convert-JSONToXML]: Execution failed due to reason: Expecting { or [ at line 1"
```

Esamina l'elemento <Source> specificato nel file XML dei criteri JSON in XML non riuscito. Ad esempio, la seguente policy JSON to XML ha l'elemento <Source> impostato sulla variabile request:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<JSONToXML async="false" continueOnError="false" enabled="true" name="Convert-JSONToXML">
  <DisplayName>Convert-JSONToXML</DisplayName>
  <Properties/>
  <Options>
      <NullValue>NULL</NullValue>
      <NamespaceBlockName>#namespaces</NamespaceBlockName>
      <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
      <NamespaceSeparator>:</NamespaceSeparator>
      <TextNodeName>#text</TextNodeName>
      <AttributeBlockName>#attrs</AttributeBlockName>
      <AttributePrefix>@</AttributePrefix>
      <InvalidCharsReplacement>_</InvalidCharsReplacement>
      <ObjectRootElementName>Root</ObjectRootElementName>
      <ArrayRootElementName>Array</ArrayRootElementName>
      <ArrayItemElementName>Item</ArrayItemElementName>
  </Options>
  <OutputVariable>request</OutputVariable>
  <Source>request</Source>
</JSONToXML>

Verifica se l'input specificato nell'elemento <Source> è un payload JSON valido. Se l'input non è valido o ha un formato non corretto, questo è il motivo dell'errore.

Supponiamo che il seguente JSON non valido sia stato trasmesso al criterio
```
[
    "args": ["name" : "Google" ]
]
```
Ecco la chiamata API di esempio che mostra come è stata trasmessa la richiesta:
```
curl -v "http://<org>-<env>.apigee.net/v1/testjsontoxml" -H "Content-Type:
application/json" -X POST -d '[ "args" : ["name" : "Google" ]]'
```
Il payload JSON passato nella richiesta non è valido perché l'oggetto JSON inizia e termina con parentesi quadre ([ ]). Per questo motivo, ricevi il codice di errore:

steps.json2xml.ExecutionFailed

Nota: un payload JSON può contenere oggetti JSON e/o array JSON. Un oggetto JSON valido inizia con { e termina con }. Un array JSON valido (al livello più esterno) inizia con [ e termina con ].

Questo errore può verificarsi anche se l'elemento <Source> è stato impostato su response, ma il payload della risposta JSON non è valido o non ha un formato corretto.

Nota :l'intestazione HTTP Content-type del messaggio di origine deve essere impostata su application/json, altrimenti la norma non viene applicata, ovvero viene ignorata durante l'elaborazione.

Risoluzione

Assicurati che l'input passato al criterio JSON to XML nell'elemento <Source> sia valido e non malformato.

Per risolvere il problema con il criterio JSON in XML di esempio descritto sopra, trasmetti una richiesta di payload JSON valida nel seguente modo:

{
  "args"  : {

        "name"  :  "Google"
   }
}

OutputVariableIsNotAvailable

Codice di errore

steps.json2xml.OutputVariableIsNotAvailable

Corpo della risposta di errore

{
    "fault": {
        "faultstring": "JSONToXML[policy_name]: Output variable is not available.",
        "detail": {
            "errorcode": "steps.json2xml.OutputVariableIsNotAvailable"
        }
    }
}

Errore di esempio

{
    "fault": {
        "faultstring": "JSONToXML[Check-JSONToXML]: Output variable is not available.",
        "detail": {
            "errorcode": "steps.json2xml.OutputVariableIsNotAvailable"
        }
    }
}

Causa

Questo errore si verifica se la variabile specificata nell'elemento <Source> del criterio da JSON a XML è di tipo stringa e l'elemento <OutputVariable> non è definito. L'elemento <OutputVariable> è obbligatorio quando la variabile definita nell'elemento <Source> è di tipo stringa.

Diagnosi

Identifica la policy JSON to XML in cui si è verificato l'errore. Puoi trovare questa informazione nell'elemento faultstring della risposta di errore. Ad esempio, nel seguente faultstring, il nome della policy è Check-JSONToXML:
```
"faultstring": "JSONToXML[Check-JSONToXML]: Output variable is not available."
```

Nella convalida della policy JSON in XML non riuscita, verifica se manca <OutputVariable>.

Il seguente criterio JSONToXML di esempio presenta un elemento <OutputVariable> mancante:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<JSONToXML async="false" continueOnError="false" enabled="true" name="JSONToXML">
    <DisplayName>Check-JSONToXML</DisplayName>
    <Properties/>
    <Options>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
        <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
        <NamespaceSeparator>:</NamespaceSeparator>
        <TextNodeName>#text</TextNodeName>
        <AttributeBlockName>#attrs</AttributeBlockName>
        <AttributePrefix>@</AttributePrefix>
        <InvalidCharsReplacement>_</InvalidCharsReplacement>
        <ObjectRootElementName>Root</ObjectRootElementName>
        <ArrayRootElementName>Array</ArrayRootElementName>
        <ArrayItemElementName>Item</ArrayItemElementName>
    </Options>
    <Source>PostalCode</Source>
</JSONToXML>

Determina il tipo di variabile specificato nell'elemento <Source>:
1. Individua il codice all'interno del proxy API in cui è stata definita per prima la variabile.
2. Una volta individuata la policy in cui la variabile viene definita e compilata per prima, devi determinare il tipo di variabile nel seguente modo:
  1. Controlla il valore dell'attributo type (se presente).
  2. Se l'attributo type non è presente, la variabile viene considerata una stringa.
3. Se il tipo della variabile è stringa, questa è la causa dell'errore. Puoi scoprire di più sulle variabili comuni e sui relativi tipi nella Guida di riferimento alle variabili.
Ad esempio, esamina la variabile PostalCode nel criterio JSON in XML riportato sopra.

Ad esempio, considera che un criterio Assegna messaggio viene utilizzato per assegnare un valore a una variabile denominata PostalCode come mostrato di seguito:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<AssignMessage async="false" continueOnError="false" enabled="true" name="Assign_PostalCode">
    <DisplayName>Assign_PostalCode</DisplayName>
    <Properties/>
    <AssignVariable>
        <Name>PostalCode</Name>
        <Value>{"value":"56008"}</Value>
        <Ref/>
    </AssignVariable>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>
```
Tieni presente che il tipo di variabile impostato in <AssignVariable> è stringa. Pertanto, la variabile PostalCode è di tipo stringa.

Ora, ricorda che la variabile PostalCode viene utilizzata nell'elemento <Source> del criterio JSONToXML:
```
<Source>PostalCode</Source>
```
Poiché PostalCode è di tipo stringa e l'elemento <OutputVariable> non è presente, ricevi il codice di errore:
```
steps.json2xml.OutputVariableIsNotAvailable
```

Risoluzione

Assicurati che, se la variabile specificata nell'elemento <Source> del criterio JSONToXML è di tipo stringa, l'elemento <OutputVariable> sia definito all'interno del criterio.

Per correggere la policy JSONToXML descritta sopra, includi un elemento <OutputVariable> come mostrato di seguito.

  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <JSONToXML async="false" continueOnError="false" enabled="true" name="JSONToXML">
      <DisplayName>Check-JSONToXML</DisplayName>
      <Properties/>
      <Options>
          <NullValue>NULL</NullValue>
          <NamespaceBlockName>#namespaces</NamespaceBlockName>
          <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
          <NamespaceSeparator>:</NamespaceSeparator>
          <TextNodeName>#text</TextNodeName>
          <AttributeBlockName>#attrs</AttributeBlockName>
          <AttributePrefix>@</AttributePrefix>
          <InvalidCharsReplacement>_</InvalidCharsReplacement>
          <ObjectRootElementName>Root</ObjectRootElementName>
          <ArrayRootElementName>Array</ArrayRootElementName>
          <ArrayItemElementName>Item</ArrayItemElementName>
      </Options>
      <OutputVariable>response</OutputVariable>
      <Source>PostalCode</Source>
  </JSONToXML>

InCompatibleTypes

Codice di errore

steps.json2xml.InCompatibleTypes

Corpo della risposta di errore

{
    "fault": {
        "faultstring": "JSONToXML[policy_name]: String can not be assigned to message type.",
        "detail": {
            "errorcode": "steps.json2xml.InCompatibleTypes"
        }
    }
}

Errore di esempio

{
    "fault": {
        "faultstring": "JSONToXML[JSONToXML_checktype]: String can not be assigned to message type.",
        "detail": {
            "errorcode": "steps.json2xml.InCompatibleTypes"
        }
    }
}

Causa

Questo errore si verifica se il tipo di variabile definito nell'elemento <Source> e nell'elemento <OutputVariable> non è lo stesso. È obbligatorio che il tipo di variabili contenute nell'elemento <Source> e nell'elemento <OutputVariable> corrisponda.

I tipi validi sono message e string.

Diagnosi

Identifica la policy JSON to XML in cui si è verificato l'errore. Puoi trovare questa informazione nell'elemento faultstring della risposta di errore. Ad esempio, nel seguente faultstring, il nome della policy è JSONToXML_checktype:
```
"faultstring": "JSONToXML[JSONToXML_checktype]: String can not be assigned to message type."
```

Nella nota relativa al criterio JSON in XML non riuscito, annota i valori specificati in <OutputVariable> e <Source>.

Considera la seguente policy di esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<JSONToXML async="false" continueOnError="false" enabled="true" name="JSONToXML_checktype">
    <DisplayName>JSONToXML_checktype</DisplayName>
    <Properties/>
    <Options>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
        <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
        <NamespaceSeparator>:</NamespaceSeparator>
        <TextNodeName>#text</TextNodeName>
        <AttributeBlockName>#attrs</AttributeBlockName>
        <AttributePrefix>@</AttributePrefix>
        <InvalidCharsReplacement>_</InvalidCharsReplacement>
        <ObjectRootElementName>Root</ObjectRootElementName>
        <ArrayRootElementName>Array</ArrayRootElementName>
        <ArrayItemElementName>Item</ArrayItemElementName>
    </Options>
    <OutputVariable>response</OutputVariable>
    <Source>PostalCode</Source>
</JSONToXML>

Determina il tipo di variabile specificato negli elementi <Source> e <OutputVariable>:
1. Individua il codice all'interno del proxy API in cui è stata definita per prima ciascuna di queste variabili.
2. Una volta individuata la policy in cui la variabile viene definita e compilata per prima, devi determinare il tipo di variabile nel seguente modo:
  1. Controlla il valore dell'attributo type (se presente).
  2. Se l'attributo type non è presente, la variabile viene considerata una stringa.
3. Se il tipo di variabile specificato in <Source> è stringa mentre il tipo di <OutputVariable> è messaggio o viceversa, questa è la causa dell'errore. Puoi scoprire di più sulle variabili comuni e sui relativi tipi nella Guida di riferimento alle variabili.
Ad esempio, considera una policy Assegna messaggio utilizzata per assegnare un valore a una variabile denominata PostalCode come mostrato di seguito:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<AssignMessage async="false" continueOnError="false" enabled="true" name="Assign_PostalCode">
    <DisplayName>Assign_PostalCode</DisplayName>
    <Properties/>
    <AssignVariable>
        <Name>PostalCode</Name>
        <Value>{"value":"56008"}</Value>
        <Ref/>
    </AssignVariable>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>
```
Tieni presente che il tipo di variabile impostato in <AssignVariable> è stringa, pertanto la variabile PostalCode è di tipo stringa.

Ora, ricorda che la variabile PostalCode viene utilizzata nell'elemento <Source> del criterio JSONToXML:
```
<Source>PostalCode</Source>
```
Allo stesso modo, ricorda che la variabile response viene utilizzata nell'elemento <OutputVariable> del criterio JSONToXML:
```
<OutputVariable>response</OutputVariable>
```
Poiché PostalCode è di tipo stringa mentre la variabile response è di tipo messaggio, i tipi non sono compatibili, quindi ricevi il codice di errore:
```
steps.json2xml.InCompatibleTypes
```
L'errore precedente può verificarsi anche se la variabile nell'elemento <Source> è di tipo message, ma la variabile nell'elemento <OutputVariable> è di tipo stringa.

Risoluzione

Assicurati che il tipo di variabile definito nell'elemento <Source> e nell'elemento <OutputVariable> sia sempre lo stesso. È obbligatorio che il tipo di variabili contenute nell'elemento <Source> e nell'elemento <OutputVariable> corrisponda. ovvero assicurati che il tipo di elementi <Source> e <OutputVariable> sia stringa o messaggio.

Per correggere la policy JSON to XML descritta sopra, puoi dichiarare un'altra variabile PostalCode_output di tipo stringa utilizzando la policy Assign Message e utilizzare questa variabile nell'elemento <OutputVariable> della policy JSON to XML.

Policy Assegna messaggio modificata:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<AssignMessage async="false" continueOnError="false" enabled="true" name="Assign_PostalCode">
    <DisplayName>Assign_PostalCode</DisplayName>
    <Properties/>
    <AssignVariable>
        <Name>PostalCode</Name>
        <Value>{"value":"56008"}</Value>
        <Ref/>
    </AssignVariable>
    <AssignVariable>
        <Name>PostalCode_output</Name>
        <Ref/>
    </AssignVariable>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

Policy JSONToXML modificata:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<JSONToXML async="false" continueOnError="false" enabled="true" name="JSONToXML">
    <DisplayName>JSONToXML_checktype</DisplayName>
    <Properties/>
    <Options>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
        <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
        <NamespaceSeparator>:</NamespaceSeparator>
        <TextNodeName>#text</TextNodeName>
        <AttributeBlockName>#attrs</AttributeBlockName>
        <AttributePrefix>@</AttributePrefix>
        <InvalidCharsReplacement>_</InvalidCharsReplacement>
        <ObjectRootElementName>Root</ObjectRootElementName>
        <ArrayRootElementName>Array</ArrayRootElementName>
        <ArrayItemElementName>Item</ArrayItemElementName>
    </Options>
    <OutputVariable>PostalCode_output</OutputVariable>
    <Source>PostalCode</Source>
</JSONToXML>

InvalidSourceType

Codice di errore

steps.json2xml.InvalidSourceType

Corpo della risposta di errore

{
    "fault": {
        "faultstring": "JSONToXML[class invalid_class]: Invalid source type class invalid_class. Valid source types are [message, string].",
        "detail": {
            "errorcode": "steps.json2xml.InvalidSourceType"
        }
    }
}

Errore di esempio

{
    "fault": {
        "faultstring": "JSONToXML[class java.lang.Integer]: Invalid source type class java.lang.Integer. Valid source types are [message, string].",
        "detail": {
            "errorcode": "steps.json2xml.InvalidSourceType"
        }
    }
}

Causa

Questo errore si verifica se il tipo di variabile utilizzato per definire l'elemento <Source> non è valido.I tipi di variabili validi sono message e string.

Diagnosi

Identifica il tipo di origine non valido utilizzato nel criterio JSON in XML. Puoi trovare queste informazioni nel messaggio di errore. Ad esempio, nel seguente errore, il tipo non valido è Integer.
```
"faultstring": "JSONToXML[class java.lang.Integer]: Invalid source type class java.lang.Integer. Valid source types are [message, string]."
```
Esamina tutte le norme JSON to XML nel proxy API specifico in cui si è verificato l'errore. Nella policy JSON to XML non riuscita, annota il nome della variabile specificata in <Source>.

Ecco un esempio di policy in cui la variabile denominata EmployeeID è specificata nell'elemento <Source>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<JSONToXML async="false" continueOnError="false" enabled="true" name="JSONToXML">
    <DisplayName>Check_SourceType</DisplayName>
    <Properties/>
    <Options>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
        <DefaultNamespaceNodeName>$default</DefaultNamespaceNodeName>
        <NamespaceSeparator>:</NamespaceSeparator>
        <TextNodeName>#text</TextNodeName>
        <AttributeBlockName>#attrs</AttributeBlockName>
        <AttributePrefix>@</AttributePrefix>
        <InvalidCharsReplacement>_</InvalidCharsReplacement>
        <ObjectRootElementName>Root</ObjectRootElementName>
        <ArrayRootElementName>Array</ArrayRootElementName>
        <ArrayItemElementName>Item</ArrayItemElementName>
    </Options>
    <OutputVariable>request</OutputVariable>
    <Source>EmployeeID</Source>
</JSONToXML>

Determina il tipo di variabile specificato nell'elemento <Source>:
1. Individua il codice all'interno del proxy API in cui è stata definita per la prima volta questa variabile.
2. Una volta individuata la policy in cui la variabile viene definita e compilata per prima, devi determinare il tipo di variabile nel seguente modo:
  1. Controlla il valore dell'attributo type (se presente).
  2. Se l'attributo type non è presente, la variabile viene considerata una stringa.
3. Se il tipo della variabile specificata in <Source> non è di tipo messaggio o stringa, questo è il motivo dell'errore. Puoi scoprire di più sulle variabili comuni e sui relativi tipi nella Guida di riferimento alle variabili.
Ad esempio, supponiamo che il criterio ExtractVariables venga utilizzato per estrarre il valore da un payload JSON e impostare il valore sulla variabile EmployeeID di tipo integer come mostrato di seguito:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ExtractVariables name="ExtractJSONVariables">
    <Source>request</Source>
    <JSONPayload>
        <Variable name="EmployeeID" type="integer">
            <JSONPath>$.ID</JSONPath>
        </Variable>
    </JSONPayload>
</ExtractVariables>
```
Ora, ricorda che la variabile EmployeeID viene utilizzata nell'elemento <Source> del criterio JSONToXML:
```
<Source>EmployeeID</Source>
```
Poiché il tipo di questa variabile è Integer, che non è un tipo <Source> valido, il proxy API non riesce a essere eseguito e viene visualizzato l'errore:
```
steps.json2xml.InvalidSourceType
```

Risoluzione

Assicurati che il tipo di variabile utilizzato per specificare l'elemento <Source> sia valido. I tipi di <Source> validi sono message e string.

Per evitare l'errore sopra riportato con il criterio JSONToXML, puoi utilizzare la variabile request di tipo messaggio o qualsiasi altra stringa che sia un payload JSON valido.