Esta página foi traduzida pela API Cloud Translation.

Solução de problemas de erro de ambiente de execução da política JSON para XML

Você está visualizando a documentação do Apigee Edge.
Acesse a documentação da Apigee X. informações

SourceUnavailable

Código do erro

steps.json2xml.SourceUnavailable

Corpo da resposta de erro

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

Exemplo de erro

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

Causa

Esse erro ocorrerá se a variável message especificada no elemento <Source> da política JSON para XML se enquadrar em uma destas situações:

Fora do escopo (não disponível no fluxo específico em que a política está sendo executada) ou
Não é possível resolver (não está definida)

Por exemplo, esse erro ocorrerá se a política JSON para XML for executada no fluxo de solicitação, mas o elemento <Source> for definido como a variável response, que não existe no fluxo de solicitação.

Diagnóstico

Identifique a política JSON para XML em que o erro ocorreu e o nome da variável que não está disponível. É possível encontrar os dois itens no elemento faultstring da resposta de erro. Por exemplo, no faultstring a seguir, o nome da política é Convert-JSONToXML e a variável é response:
```
"faultstring": "JSONToXML[Convert-JSONToXML]: Source response is not available"
```

No XML da política JSON para XML com falha, verifique se o nome da variável definida no elemento <Source> corresponde ao nome da variável identificado na string de falha (etapa 1 acima). Por exemplo, a seguinte política JSON para XML especifica uma variável chamada response no elemento <Source>, que corresponde ao que está em 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>

Determine se a variável usada no elemento <Source> está definida e disponível no fluxo em que a política JSON para XML está sendo executada.
Se a variável for:
- Fora do escopo (não disponível no fluxo específico em que a política está sendo executada) ou
- Não é possível resolver (não está definida)
essa será a causa do erro.

Por exemplo, digamos que a política JSON para XML mostrada acima seja executada no fluxo de solicitação. Lembre-se de que a variável response foi usada no elemento <Source> da política JSON para XML. A variável de resposta está disponível apenas no fluxo de resposta.

Como a variável response não existe no fluxo de solicitação, você recebe o código do erro:
```
steps.json2xml.SourceUnavailable
```

Resolução

Verifique se a variável definida no elemento <Source> da política JSON para XML com falha está definida e existe no fluxo em que a política é executada.

Para corrigir a política JSON para XML de exemplo mostrada acima, modifique o elemento <Source> para usar a variável request, porque ela existe no fluxo de solicitação:

  <?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

Código do erro

steps.json2xml.ExecutionFailed

Corpo da resposta de erro

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

Causas possíveis

Veja a seguir as possíveis causas para esse erro:

Causa	Descrição
Payload de entrada ausente	O payload de entrada (JSON) está vazio.
Entrada inválida ou malformada	A entrada (JSON) transmitida para a política JSON para XML é inválida ou está malformada.

Causa: payload de entrada ausente

Na política JSON para XML, se o conteúdo (payload) da variável especificada no elemento <Source> estiver vazio, esse erro ocorrerá.

Por exemplo, se o elemento <Source> na política JSON para XML for definido como uma variável request ou response e precisar conter um payload JSON, mas se o payload estiver vazio, o erro ocorrerá.

Diagnóstico

Identifique a política JSON para XML em que o erro ocorreu. Você encontra essas informações no elemento faultstring da resposta de erro. Por exemplo, no faultstring a seguir, o nome da política é Convert-JSONToXML:
```
"faultstring": "JSONToXML[Convert-JSONToXML]: Execution failed due to reason: Expecting { or [ at line 1"
```

Examine o elemento <Source> no XML da política JSON para XML com falha e determine a variável especificada. Por exemplo, a seguinte política JSON para XML tem o elemento <Source> definido como 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>

Verifique se a variável especificada para o elemento <Source> na política está vazia. Se estiver vazia, essa será a causa do erro.

No exemplo da política JSON para XML mostrado acima, o payload da solicitação (ou seja, o corpo da solicitação) que foi enviado pelo cliente está vazio.

Exemplo:
```
curl -v "http://<org>-<env>.apigee.net/v1/testjsontoxml" -H "Content-Type: application/json"
```
Como o payload de resposta JSON está vazio, você recebe o código do erro:
```
steps.json2xml.ExecutionFailed
```
Esse erro também poderá ocorrer se o elemento <Source> estiver definido como resposta, mas um payload vazio for transmitido pelo servidor de back-end.

Observação: o cabeçalho HTTP Content-Type da mensagem de origem precisa ser definido como application/json. Caso contrário, a política será ignorada durante o processamento e, portanto, não será aplicada.

Resolução

Verifique se a entrada transmitida para a política JSON para XML no elemento <Source> é um payload JSON válido e não vazio.

Para corrigir o problema com a política JSON para XML de amostra, passe um payload JSON válido. Exemplo:

Crie um arquivo chamado city.json com o seguinte conteúdo:

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

Faça a chamada de API usando um comando curl da seguinte maneira:

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

Causa: entrada inválida ou malformada

Se a política JSON para XML analisar uma entrada inválida ou malformada, você receberá esse erro.

Por exemplo, se o JSON inválido a seguir for fornecido como entrada para a política JSON para XML,

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

você receberá o erro:

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

Diagnóstico

Identifique a política JSON para XML em que o erro ocorreu. Você encontra essas informações no elemento faultstring da resposta de erro. Por exemplo, no faultstring a seguir, o nome da política é Convert-JSONToXML:
```
"faultstring": "JSONToXML[Convert-JSONToXML]: Execution failed due to reason: Expecting { or [ at line 1"
```

Examine o elemento <Source> especificado no XML da política JSON para XML com falha. Por exemplo, a seguinte política JSON para XML tem o elemento <Source> definido como a variável 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>

Valide se a entrada especificada no elemento <Source> é um payload JSON válido. Se a entrada for inválida ou estiver malformada, essa será a causa do erro.

Suponha que o seguinte JSON inválido foi passado para a política
```
[
    "args": ["name" : "Google" ]
]
```
Veja o exemplo de uma chamada de API que mostra como a solicitação foi passada:
```
curl -v "http://<org>-<env>.apigee.net/v1/testjsontoxml" -H "Content-Type:
application/json" -X POST -d '[ "args" : ["name" : "Google" ]]'
```
O payload JSON transmitido na solicitação é inválido porque o objeto JSON começa e termina com colchetes ([ ]). Por esse motivo, você recebe o código do erro:

steps.json2xml.ExecutionFailed

Observação: um payload JSON pode conter objetos JSON e/ou matrizes JSON. Um objeto JSON válido começa com { e termina com }. Uma matriz JSON válida (no nível mais externo), começa com [ e termina com ].

Esse erro também poderá ocorrer se o elemento <Source> tiver sido definido como resposta, mas o payload da resposta JSON for inválido ou estiver malformado.

Observação: o cabeçalho HTTP Content-type da mensagem de origem precisa ser definido como application/json. Caso contrário, a política não será aplicada, o que significa que ela será ignorada durante o processamento.

Resolução

Verifique se a entrada transmitida para a política JSON para XML no elemento <Source> é válida e não está malformada.

Para corrigir o problema com a política JSON para XML de amostra discutida acima, passe uma solicitação de payload JSON válida da seguinte forma:

{
  "args"  : {

        "name"  :  "Google"
   }
}

OutputVariableIsNotAvailable

Código do erro

steps.json2xml.OutputVariableIsNotAvailable

Corpo da resposta de erro

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

Exemplo de erro

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

Causa

Esse erro ocorrerá se a variável especificada no elemento <Source> da política JSON para XML for do tipo string e o elemento <OutputVariable> não for definido. O elemento <OutputVariable> é obrigatório quando a variável definida no elemento <Source> é do tipo string.

Diagnóstico

Identifique a política JSON para XML em que o erro ocorreu. É possível encontrar isso no elemento faultstring da resposta de erro. Por exemplo, no faultstring a seguir, o nome da política é Check-JSONToXML:
```
"faultstring": "JSONToXML[Check-JSONToXML]: Output variable is not available."
```

Na política JSON para XML com falha, valide se o <OutputVariable> está ausente.

A seguinte amostra da política JSONToXML tem um elemento <OutputVariable> ausente:

<?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>

Determine o tipo de variável especificado no elemento <Source>:
1. Localize o código na API Proxy em que a variável foi definida primeiro.
2. Depois de descobrir a política em que a variável é definida e preenchida primeiro, você precisará determinar o tipo dessa variável da seguinte forma:
  1. Verifique o valor do atributo de tipo (se houver).
  2. Se o atributo de tipo não estiver presente, a variável será considerada uma string.
3. Se o tipo da variável for string, essa será a causa do erro. Saiba mais sobre as variáveis comuns e os tipos delas na Referência de variáveis.
Por exemplo, observe a variável PostalCode na política JSON para XML acima.

Por exemplo, considere uma política "Atribuir mensagem" que é usada para atribuir um valor a uma variável chamada PostalCode, conforme mostrado abaixo:
```
<?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>
```
Observe que o tipo de variável definido em <AssignVariable> é uma string. Portanto, a variável PostalCode é do tipo string.

Lembre-se de que a variável PostalCode é usada no elemento <Source> da política JSONToXML:
```
<Source>PostalCode</Source>
```
Como PostalCode é do tipo string e o elemento <OutputVariable> está ausente, você recebe o código do erro:
```
steps.json2xml.OutputVariableIsNotAvailable
```

Resolução

Garanta que a variável especificada no elemento <Source> da política JSONToXML seja do tipo string e o elemento <OutputVariable> esteja definido na política.

Para corrigir a política JSONToXML discutida acima, inclua um elemento <OutputVariable>, conforme mostrado abaixo.

  <?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

Código do erro

steps.json2xml.InCompatibleTypes

Corpo da resposta de erro

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

Exemplo de erro

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

Causa

Esse erro ocorrerá se o tipo da variável definido no elemento <Source> e o elemento <OutputVariable> não forem os mesmos. É obrigatório que o tipo das variáveis contidas no elemento <Source> e no elemento <OutputVariable> seja igual.

Os tipos válidos são message e string.

Diagnóstico

Identifique a política JSON para XML em que o erro ocorreu. É possível encontrar isso no elemento faultstring da resposta de erro. Por exemplo, no faultstring a seguir, o nome da política é JSONToXML_checktype:
```
"faultstring": "JSONToXML[JSONToXML_checktype]: String can not be assigned to message type."
```

Na política JSON para XML com falha, observe os valores especificados em <OutputVariable> e <Source>.

Veja o seguinte exemplo de política:

<?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>

Determine o tipo de variável especificado nos elementos <Source> e <OutputVariable>:
1. Localize o código na API Proxy em que cada uma dessas variáveis foi definida primeiro.
2. Depois de descobrir a política em que a variável é definida e preenchida primeiro, você precisará determinar o tipo dessa variável da seguinte forma:
  1. Verifique o valor do atributo de tipo (se houver).
  2. Se o atributo de tipo não estiver presente, a variável será considerada uma string.
3. Se o tipo da variável especificada em <Source> for string e o tipo de <OutputVariable> for mensagem, ou vice-versa, essa será a causa do erro. Saiba mais sobre as variáveis comuns e os tipos delas na Referência de variáveis.
Como exemplo, considere uma política "Atribuir mensagem" usada para atribuir um valor a uma variável chamada PostalCode, conforme mostrado abaixo:
```
<?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>
```
Observe que o tipo de variável definido em <AssignVariable> é string. Portanto, a variável PostalCode é do tipo string.

Lembre-se de que a variável PostalCode é usada no elemento <Source> da política JSONToXML:
```
<Source>PostalCode</Source>
```
Da mesma forma, lembre-se de que a variável response é usada no elemento <OutputVariable> da política JSONToXML:
```
<OutputVariable>response</OutputVariable>
```
Como PostalCode é do tipo string e a variável response é do tipo mensagem, eles são tipos incompatíveis, portanto, você recebe o código do erro:
```
steps.json2xml.InCompatibleTypes
```
O erro acima também poderá ocorrer se a variável no elemento <Source> for do tipo message, mas a variável no elemento <OutputVariable> for do tipo string.

Resolução

Garanta que o tipo da variável definido no elemento <Source> e no elemento <OutputVariable> seja sempre o mesmo. É obrigatório que o tipo das variáveis contidas no elemento <Source> e no elemento <OutputVariable> seja igual. Ou seja, garanta que o tipo de ambos os elementos <Source> e <OutputVariable> seja string ou mensagem.

Para corrigir a política JSON para XML discutida acima, você pode declarar outra variável PostalCode_output do tipo string usando a política "Atribuir mensagem" e usar essa variável no elemento <OutputVariable> da política JSON para XML.

Política "Atribuir mensagem" modificada:

<?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>

Política JSONToXML modificada:

<?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

Código do erro

steps.json2xml.InvalidSourceType

Corpo da resposta de erro

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

Exemplo de erro

{
    "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

Este erro ocorrerá se o tipo da variável usado para definir o elemento <Source> for inválido. Os tipos válidos de variável são message e string.

Diagnóstico

Identifique o tipo de origem inválido usado na política JSON para XML. Você encontra essas informações na mensagem de erro. Por exemplo, no erro a seguir, o tipo inválido é "Inteiro".
```
"faultstring": "JSONToXML[class java.lang.Integer]: Invalid source type class java.lang.Integer. Valid source types are [message, string]."
```
Examine todas as políticas JSON para XML na API Proxy específica onde a falha ocorreu. Na política JSON para XML com falha, anote o nome da variável especificada em <Source>.

Aqui está uma amostra de política que tem a variável chamada EmployeeID especificada no 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>

Determine o tipo da variável especificado no elemento <Source>:
1. Localize o código na API Proxy em que essa variável foi definida primeiro.
2. Depois de descobrir a política em que a variável é definida e preenchida primeiro, você precisará determinar o tipo dessa variável da seguinte forma:
  1. Verifique o valor do atributo de tipo (se houver).
  2. Se o atributo de tipo não estiver presente, a variável será considerada uma string.
3. Se o tipo da variável especificado em <Source> não for do tipo mensagem nem string, essa será a causa do erro. Saiba mais sobre as variáveis comuns e os tipos delas na Referência de variáveis.
Como exemplo, vamos considerar que a política ExtractVariables é usada para extrair o valor de um payload JSON e define o valor como a variável EmployeeID do tipo inteiro, como mostrado abaixo:
```
<?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>
```
Lembre-se de que a variável EmployeeID é usada no elemento <Source> da política JSONToXML:
```
<Source>EmployeeID</Source>
```
Como o tipo dessa variável é Integer, que não é um tipo <Source> válido, a API Proxy falha com o erro:
```
steps.json2xml.InvalidSourceType
```

Resolução

Verifique se o tipo da variável usado para especificar o elemento <Source> é válido. Os tipos válidos de <Source> são message e string.

Para evitar o erro acima com a política JSONToXML, você pode usar a variável de solicitação, que é do tipo mensagem, ou qualquer outra string que seja um payload JSON válido.