Política XMLtoJSON

Estás consultando la documentación de Apigee Edge.
Consulta la documentación de Apigee X.
Información

Qué

Esta política convierte mensajes del formato de lenguaje de marcación extensible (XML) a la notación de objetos de JavaScript (JSON), lo que te brinda varias opciones para controlar cómo se convierten los mensajes.

Si se desea convertir una respuesta con formato XML en una respuesta con formato JSON, la política se debe adjuntar a un flujo de respuesta (por ejemplo, Response/ProxyEndpoint/PostFlow).

Acerca de

En una situación de mediación típica, una política de JSON a XML en el flujo de solicitud entrante se suele vincular con una política de XML a JSON en el flujo de respuesta saliente. Cuando se combinan políticas de esta manera, se puede exponer una API de JSON para servicios de backend que solo admiten XML de forma nativa.

En situaciones en que las diversas apps cliente que consumen las API pueden requerir JSON o XML, el formato de respuesta se puede configurar de forma dinámica mediante la configuración de políticas de JSON a XML y de XML a JSON para ejecutarlas de manera condicional. Consulta Variables y condiciones de flujo para ver una implementación de esta situación.


Ejemplos

Para ver un análisis detallado sobre la conversión entre JSON y XML, consulta http://community.apigee.com/articles/1839/converting-between-xml-and-json-what-you-need-to-k.html.

Convierte una respuesta

<XMLToJSON name="ConvertToJSON">
  <Options>
  </Options>
  <OutputVariable>response</OutputVariable>
  <Source>response</Source>
</XMLToJSON>

Esta configuración, que es la configuración mínima necesaria para convertir XML en JSON, toma un mensaje de respuesta con formato XML como la fuente y, luego, crea un mensaje con formato JSON que se propaga en la OutputVariable de response. Edge usa automáticamente el contenido de esta variable como mensaje para el siguiente paso de procesamiento.


Referencia del elemento

A continuación, se describen los elementos y los atributos que puedes configurar en esta política.

<XMLToJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1">
    <DisplayName>XML to JSON 1</DisplayName>
    <Source>response</Source>
    <OutputVariable>response</OutputVariable>
    <Options>
        <RecognizeNumber>true</RecognizeNumber>
        <RecognizeBoolean>true</RecognizeBoolean>
        <RecognizeNull>true</RecognizeNull>
        <NullValue>NULL</NullValue>
        <NamespaceBlockName>#namespaces</NamespaceBlockName>
        <DefaultNamespaceNodeName>&</DefaultNamespaceNodeName>
        <NamespaceSeparator>***</NamespaceSeparator>
        <TextAlwaysAsProperty>true</TextAlwaysAsProperty>
        <TextNodeName>TEXT</TextNodeName>
        <AttributeBlockName>FOO_BLOCK</AttributeBlockName>
        <AttributePrefix>BAR_</AttributePrefix>
        <OutputPrefix>PREFIX_</OutputPrefix>
        <OutputSuffix>_SUFFIX</OutputSuffix>
        <StripLevels>2</StripLevels>
        <TreatAsArray>
            <Path unwrap="true">teachers/teacher/studentnames/name</Path>
        </TreatAsArray>
    </Options>
    <!-- Use Options or Format, not both -->
    <Format>yahoo</Format>
</XMLToJSON>

Atributos <XMLtoJSON>

<XMLtoJSON async="false" continueOnError="false" enabled="true" name="XML-to-JSON-1"> 

En la siguiente tabla, se describen los atributos que son comunes a todos los elementos principales de las políticas:

Atributo Descripción Predeterminada Presencia
name

El nombre interno de la política. El valor del atributo name puede contener letras, números, espacios, guiones, guiones bajos y puntos. Este valor no puede superar los 255 caracteres.

De forma opcional, usa el elemento <DisplayName> para etiquetar la política en el editor de proxy de la IU de administración con un nombre de lenguaje natural diferente.

No disponible Obligatorias
continueOnError

Configúralo como false para mostrar un error cuando una política falla. Este es el comportamiento previsto para la mayoría de las políticas.

Configúralo como true para continuar con la ejecución del flujo incluso después de que una política falle.

false Opcional
enabled

Configúralo como true para aplicar la política.

Configúralo como false para desactivar la política. La política no se aplicará incluso si permanece adjunta a un flujo.

true Opcional
async

Este atributo dejó de estar disponible.

false Funciones obsoletas

Elemento <DisplayName>

Se usan además del atributo name para etiquetar la política en el editor de proxy de la IU de administración con un nombre de lenguaje natural diferente.

<DisplayName>Policy Display Name</DisplayName>
Predeterminada

No disponible

Si omites este elemento, se usa el valor del atributo name de la política.

Presencia Opcional
Tipo Cadena

Elemento <Source>

La variable, la solicitud o la respuesta, que contiene el mensaje XML que quieres convertir en JSON.

El encabezado de tipo de contenido HTTP del mensaje fuente debe establecerse como application/xml; de lo contrario, la política no se aplica.

Si <Source> no está definido, se trata como un mensaje (que se resuelve como solicitud cuando la política se adjunta a un flujo de solicitud, o como respuesta cuando la política se adjunta a un flujo de respuesta).

Si la variable de origen no se puede resolver o se resuelve en un tipo que no es de mensaje, la política muestra un error.

<Source>response</Source>
Valor predeterminado solicitud o respuesta, determinadas por la ubicación en la que se agrega la política al flujo del proxy de API
Presencia Opcional
Tipo mensaje

Elemento <OutputVariable>

Almacena el resultado de la conversión de formato XML a JSON. Por lo general, es el mismo valor que el origen, es decir, la respuesta XML suele convertirse en una respuesta JSON.

La carga útil del mensaje XML se analiza y se convierte en JSON, y el encabezado de tipo de contenido HTTP del mensaje con formato XML se establece en application/json.

Si no se especifica OutputVariable, source se trata como OutputVariable. Por ejemplo, si el source es response, entonces OutputVariable se configura de forma predeterminada como response.

<OutputVariable>response</OutputVariable>
Predeterminada solicitud o respuesta, determinadas por la ubicación en la que se agrega la política al flujo del proxy de API
Presencia Este elemento es obligatorio cuando la variable definida en el elemento <Source> es de tipo de string.
Tipo mensaje

<Options>

Las opciones te permiten controlar la conversión de XML a JSON. Usa el grupo <Options>, que te permite agregar una configuración de conversión específica, o el elemento <Format>, que te permite hacer referencia a una plantilla de opciones predefinidas. No puedes usar <Options> y <Format> al mismo tiempo.

El elemento <Options> es obligatorio si no se usa <Format>.

Elemento <Options>/<RecognizeNumber>

Si es verdadero, los campos de número en la carga útil de XML conservan su formato original.

<RecognizeNumber>true</RecognizeNumber>

Considera el siguiente ejemplo de XML:

<a>
  <b>100</b>
  <c>value</c>
</a>

Si es true, se convierte en lo siguiente:

{
    "a": {
        "b": 100,
        "c": "value"
    }
}

Si es false, se convierte en lo siguiente:

{
    "a": {
        "b": "100",
        "c": "value"
    }
}
Predeterminada false
Presencia Opcional
Tipo Booleano

Elemento <Options>/<RecognizeBoolean>

Permite que la conversión mantenga valores booleanos verdaderos o falsos en lugar de convertir los valores en strings.

<RecognizeBoolean>true</RecognizeBoolean>

Observa este ejemplo de XML:

<a>
  <b>true</b>
  <c>value</c>
</a>

Si es true, se convierte en lo siguiente:

{
    "a": {
        "b": true,
        "c": "value"
    }
}

Si es false, se convierte en lo siguiente:

{
    "a": {
        "b": "true",
        "c": "value"
    }
}
Predeterminada false
Presencia Opcional
Tipo Booleano

Elemento <Options>/<RecognizeNull>

Te permite convertir valores vacíos en valores nulos.

<RecognizeNull>true</RecognizeNull>

Observa el siguiente XML:

<a>
  <b></b>
  <c>value</c>
</a>

Si es true, se convierte en lo siguiente:

{
  "a": {
    "b": null,
    "c": "value"
  }
}

Si es false, se convierte en lo siguiente:

{
  "a": {
    "b": {},
    "c": "value"
  }
}
Predeterminada false
Presencia Opcional
Tipo Booleano

Elemento <Options>/<NullValue>

Indica el valor al que se deben convertir los valores nulos reconocidos en el mensaje de origen. El valor predeterminado es null. Esta opción solo es efectiva si RecognizeNull es verdadero.

<NullValue>not-present</NullValue>

Valor predeterminado null
Presencia Opcional
Tipo Cadena

<Options>/<NamespaceBlockName>
<Options>/<DefaultNamespaceNodeName>
<Options>/<NamespaceSeparator> elements

Usa estos elementos en conjunto.

<NamespaceBlockName>#namespaces</NamespaceBlockName>
<DefaultNamespaceNodeName>&</DefaultNamespaceNodeName>
<NamespaceSeparator>***</NamespaceSeparator>

Considera el siguiente ejemplo de XML:

<a xmlns="http://ns.com" xmlns:ns1="http://ns1.com">
  <ns1:b>value</ns1:b>
</a>

Si no se especifica NamespaceSeparator, se genera la siguiente estructura JSON:

{
    "a": {
        "b": "value"
    }
}

Si los elementos NamespaceBlockName, DefaultNamespaceNodeName y NamespaceSeparator se especifican como #namespaces, & y ***, respectivamente, entonces se genera la siguiente estructura JSON:

{
    "a": {
        "#namespaces": {
            "&": "http://ns.com",
            "ns1": "http://ns1.com"
        },
        "ns1***b": "value"
    }
}
Predeterminada Consulta los ejemplos anteriores.
Presencia Opcional
Sin embargo, si especificas <NamespaceBlockName>, también debes especificar los otros dos elementos.
Tipo strings

Elementos <Options>/<TextAlwaysAsProperty>
y <Options>/<TextNodeName>

Usa estos elementos en conjunto.

Si se configura como true, el contenido del elemento XML se convierte en una propiedad de string.

<TextAlwaysAsProperty>true</TextAlwaysAsProperty>
<TextNodeName>TEXT</TextNodeName>

Observa el siguiente XML:

<a>
  <b>value1</b>
  <c>value2<d>value3</d>value4</c>
</a>

Si TextAlwaysAsProperty se configura como true, y TextNodeName se especifica como TEXT, se genera la siguiente estructura JSON:

{
  "a": {
    "b": {
      "TEXT": "value1"
    },
    "c": {
      "TEXT": [
        "value2",
        "value4"
        ],
        "d": {
          "TEXT": "value3"
        }
      }
    }
}

Si TextAlwaysAsProperty se configura como false, y TextNodeName se especifica como TEXT, se genera la siguiente estructura JSON:

{
  "a": {
    "b": "value1",
    "c": {
      "TEXT": [
        "value2",
        "value4"
      ],
      {
        "d": "value3",
      }
    }
}
Predeterminada <TextAlwaysAsProperty>: falso
<TextNodeName>: no se aplica
Presencia Opcional
Tipo <TextAlwaysAsProperty>: booleano
<TextNodeName>: string

Elementos <Options>/<AttributeBlockName>
y <Options>/<AttributePrefix>

Usa estos elementos en conjunto.

Te permite agrupar valores en un bloque JSON y agregar prefijos a los nombres de atributos.

<AttributeBlockName>FOO_BLOCK</AttributeBlockName>
<AttributePrefix>BAR_</AttributePrefix>

Considera el siguiente ejemplo de XML:

<a attrib1="value1" attrib2="value2"/>

Si los atributos (AttributeBlockName y AttributePrefix) se especifican como se define en el ejemplo de XML a JSON, se genera la siguiente estructura JSON:

{
  "a": {
    "FOO_BLOCK": {
      "BAR_attrib1": "value1",
      "BAR_attrib2": "value2"
    }
  }
}

Si solo se especifica AttributeBlockName, se genera la siguiente estructura JSON:

{
    "a": {
        "FOO_BLOCK": {
            "attrib1": "value1",
            "attrib2": "value2"
        }
    }
}

Si solo se especifica AttributePrefix, se genera la siguiente estructura JSON:

{
    "a": {
        "BAR_attrib1": "value1",
        "BAR_attrib2": "value2"
    }
}

Si no se especifica ninguna, se genera la siguiente estructura JSON:

{
    "a": {
        "attrib1": "value1",
        "attrib2": "value2"
    }
}
Valor predeterminado Consulta los ejemplos anteriores.
Presencia Opcional
Tipo Cadena

Elementos <Options>/<OutputPrefix>
y <Options>/<OutputSuffix>

Usa estos elementos en conjunto.

<OutputPrefix>PREFIX_</OutputPrefix>
<OutputSuffix>_SUFFIX</OutputSuffix>

Considera el siguiente ejemplo de XML:

<a>value</a>

Si los atributos (OutputPrefix y OutputSuffix) se especifican como se define en el ejemplo de XML a JSON, se genera la siguiente estructura JSON:

PREFIX_{
    "a": "value"
}_SUFFIX

Si solo se especifica OutputPrefix, se genera la siguiente estructura JSON:

PREFIX_{
  "a" : "value"
}

Si solo se especifica OutputSuffix, se genera la siguiente estructura JSON:

{
  "a" : "value"
}_SUFFIX

Si no se especifican OutputPrefix ni OutputSuffix, se genera la siguiente estructura JSON:

{
    "a": "value"
}
Valor predeterminado Consulta los ejemplos anteriores.
Presencia Opcional
Tipo Cadena

Elemento <Options>/<StripLevels>

<Options>
    <StripLevels>4</StripLevels>
</Options>

A veces, las cargas útiles XML, como SOAP, tienen muchos niveles superiores que no quieres incluir en el JSON convertido. A continuación, se muestra un ejemplo de una respuesta de SOAP que contiene muchos niveles:

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/Schemata-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
      <GetCityWeatherByZIPResponse xmlns="http://ws.cdyne.com/WeatherWS/">
          <GetCityWeatherByZIPResult>
              <State>CO</State>
              <City>Denver</City>
              <Description>Sunny</Description>
              <Temperature>62</Temperature>
          </GetCityWeatherByZIPResult>
      </GetCityWeatherByZIPResponse>
  </soap:Body>
</soap:Envelope>

Hay 4 niveles antes de llegar al nivel de estado, ciudad, descripción y temperatura. Sin usar <StripLevels>, la respuesta JSON convertida se vería de la siguiente manera:

{
   "Envelope" : {
      "Body" : {
         "GetCityWeatherByZIPResponse" : {
            "GetCityWeatherByZIPResult" : {
               "State" : "CO",
               "City" : "Denver",
               "Description" : "Sunny",
               "Temperature" : "62"
            }
         }
      }
   }
}

Si deseas quitar esos primeros 4 niveles de la respuesta JSON, debes establecer <StripLevels>4</StripLevels>, lo que generará el siguiente JSON:

{
  "State" : "CO",
  "City" : "Denver",
  "Description" : "Sunny",
  "Temperature" : "62"
}

Puedes quitar niveles hasta el primer elemento que contiene varios elementos secundarios. ¿Qué significa eso? Veamos un ejemplo de JSON más complejo:

{
   "Envelope" : {
      "Body" : {
         "GetCityForecastByZIPResponse" : {
            "GetCityForecastByZIPResult" : {
               "ResponseText" : "City Found",
               "ForecastResult" : {
                  "Forecast" : [
                     {
                        "ProbabilityOfPrecipiation" : {
                           "Nighttime" : "00",
                           "Daytime" : 10
                        }  ...

En el ejemplo, el nivel 3 es GetCityForecastByZIPResponse, que solo tiene un elemento secundario. Entonces, si usaras <StripLevels>3</StripLevels> (se deben quitar los primeros tres niveles), el JSON se vería así:

{
   "GetCityForecastByZIPResult" : {
      "ResponseText" : "City Found",
      "ForecastResult" : {
         "Forecast" : [
            {
               "ProbabilityOfPrecipiation" : {
                  "Nighttime" : "00",
                  "Daytime" : 10
               }  ...

Ten en cuenta que GetCityForecastByZIPResult tiene varios elementos secundarios. Como es el primer elemento que contiene varios elementos secundarios, puedes quitar este último nivel con <StripLevels>4</StripLevels>, lo que generará el siguiente JSON:

{
   "ResponseText" : "City Found",
   "ForecastResult" : {
      "Forecast" : [
         {
            "ProbabilityOfPrecipiation" : {
               "Nighttime" : "00",
               "Daytime" : 10
            }  ...

Debido a que el nivel 4 es el primer nivel que contiene varios elementos secundarios, no puedes anular los niveles inferiores a él. Si configuras el nivel de banda en 5, 6, 7, etc., seguirás recibiendo la respuesta anterior.

Valor predeterminado 0 (sin quitar niveles)
Presencia Opcional
Tipo Número entero

Elemento <Options>/<TreatAsArray>/<Path>

<Options>
    <TreatAsArray>
        <Path unwrap="true">teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

Esta combinación de elementos te permite asegurarte de que los valores de un documento XML se coloquen en un array de JSON. Esto es útil, por ejemplo, cuando la cantidad de elementos secundarios puede variar (de uno a varios) y quieres asegurarte de que los valores estén siempre en un array. Esto ayuda a mantener tu código estable, ya que puedes obtener datos del array de la misma manera cada vez. Por ejemplo: $.teachers.teacher.studentnames[0] obtiene el primer valor de nombre de estudiante en el array, sin importar la cantidad de valores en el array.

Observemos el comportamiento predeterminado de la conversión XML a JSON y, luego, exploremos cómo controlar el resultado mediante <TreatAsArray>/<Path>.

Cuando un documento XML contiene un elemento con varios valores secundarios (por lo general, basado en un esquema en el que el maxOccurs='unbounded' del elemento), la política de XML a JSON coloca automáticamente esos valores en un array. Por ejemplo, el siguiente bloque XML

<teacher>
    <name>teacherA</name>
    <studentnames>
        <name>student1</name>
        <name>student2</name>
    </studentnames>
</teacher>

se convierte al siguiente JSON de forma automática sin una configuración de política especial:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}
           }
      }
}

Observa que los dos nombres de los alumnos se colocan en un arreglo.

Sin embargo, si solo aparece un alumno en el documento XML, la política de XML a JSON trata automáticamente el valor como una sola string, no como un arreglo de strings, como se muestra en el siguiente ejemplo:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : "student1"
              }
          }
      }
}

En los ejemplos anteriores, los datos similares se convirtieron de otra manera; una vez como un array, otra como una sola string. Aquí es donde el elemento <TreatAsArray>/<Path> te permite controlar el resultado. Por ejemplo, puedes asegurarte de que los nombres de los alumnos siempre se coloquen en un array, aunque solo haya un valor. Para configurar esto, identifica la ruta de acceso al elemento cuyos valores deseas incluir en un array, de la siguiente manera:

<Options>
    <TreatAsArray>
        <Path>teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>

Con la configuración anterior, el JSON se escribiría de esta manera:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : ["student1"]
              }
            ]
          }
      }
}

Observa que student1 ahora está en un array. Ahora, independientemente de si hay uno o varios estudiantes, puedes recuperarlos desde un array de JSON en tu código con la siguiente ruta JSON: $.teachers.teacher.studentnames.name[0]

El elemento <Path> también tiene un atributo unwrap, que se explica en la siguiente sección.

Valor predeterminado N/A
Presencia Opcional
Tipo Cadena

Atributos

 <Options>
    <TreatAsArray>
        <Path unwrap="true">teachers/teacher/studentnames/name</Path>
    </TreatAsArray>
</Options>
Atributo Descripción Presencia Tipo
unwrap

Valor predeterminado: false

Quita el elemento del resultado JSON. Usa esto para optimizar o aplanar (“separar”) el JSON, que también abrevia la JSONPath necesaria para recuperar valores. Por ejemplo, en lugar de $.teachers.teacher.studentnames.name[*], puedes aplanar el JSON y usar $.teachers.studentnames[*].

Este es un ejemplo de JSON:

{
  "teachers" : {
      "teacher" : {
          "name" : "teacherA",
          "studentnames" : {
              "name" : [
                 "student1",
                 "student2"
              ]}...

En este ejemplo, puedes argumentar que el elemento teacher y el elemento name de studentnames no son necesarios. Por lo tanto, podrás quitarlos o separarlos. A continuación, te mostramos cómo configurar el elemento <Path> para que realices estas acciones:

<TreatAsArray>
    <Path unwrap="true">teachers/teacher</Path>
    <Path unwrap="true">teachers/teacher/studentnames/name</Path>
</TreatAsArray>

El atributo unwrap se configura como verdadero, y se proporcionan las rutas a los elementos que se separarán. El resultado JSON se verá de la siguiente manera:

{
  "teachers" : [{
      "name" : "teacherA",
      "studentnames" : ["student1","student2"]
      }]...

Ten en cuenta que, como el elemento <Path> está en el elemento <TreatAsArray>, ambos elementos de la ruta se tratarán como arreglos en el resultado JSON.

Opcional Booleano

Para obtener más ejemplos y una explicación de las funciones, consulta este artículo de la comunidad de Apigee: https://community.apigee.com/content/kbentry/33374/new-edge-minifeature-the-treatasarray-option-in-th.html.

<Format>

El formato te permite controlar la conversión de XML a JSON. Ingresa el nombre de una plantilla predefinida que contiene una combinación específica de elementos de opciones que se describen en este tema. Los formatos predefinidos incluyen los siguientes: xml.com, yahoo, google y badgerFish.

Usa el elemento <Format> o el grupo <Options>. No puedes usar <Format> y <Options> al mismo tiempo.

A continuación, se presentan las definiciones de Format de cada plantilla predefinida.

xml.com

<RecognizeNull>true</RecognizeNull>
<TextNodeName>#text</TextNodeName>
<AttributePrefix>@</AttributePrefix>

yahoo

<RecognizeNumber>true</RecognizeNumber>
<TextNodeName>content</TextNodeName>

google

<TextNodeName>$t</TextNodeName>
<NamespaceSeparator>$</NamespaceSeparator>
<TextAlwaysAsProperty>true</TextAlwaysAsProperty>

badgerFish

<TextNodeName>$</TextNodeName>
<TextAlwaysAsProperty>true</TextAlwaysAsProperty>
<AttributePrefix>@</AttributePrefix>
<NamespaceSeparator>:</NamespaceSeparator>
<NamespaceBlockName>@xmlns</NamespaceBlockName>
<DefaultNamespaceNodeName>$</DefaultNamespaceNodeName>

Sintaxis del elemento:

<Format>yahoo</Format>
Predeterminada Ingresa el nombre de un formato disponible:
xml.com, yahoo, google y badgerFish
Presencia Se requiere si no se usa <Options>.
Tipo Cadena

Esquemas


Referencia de errores

En esta sección, se describen los códigos y mensajes de error que se muestran y las variables de fallas que establece Edge cuando esta política activa un error. Esta información es importante para saber si estás desarrollando reglas de fallas con el propósito de manejar fallas. Para obtener más información, consulta Qué debes saber sobre los errores de políticas y Cómo solucionar fallas.

Errores de entorno de ejecución

Estos errores pueden producirse cuando se ejecuta la política.

Código de falla Estado de HTTP Causa Corregir
steps.xmltojson.ExecutionFailed 500 Este error se produce cuando la carga útil de entrada (XML) está vacía, el XML de entrada no es válido o tiene errores de formato.
steps.xmltojson.InCompatibleType 500 Este error se genera si el tipo de variable definida en el elemento <Source> y el elemento <OutputVariable> no son iguales. Es obligatorio que el tipo de variables incluidas dentro del elemento <Source> y el elemento <OutputVariable> coincidan.
steps.xmltojson.InvalidSourceType 500 Este error ocurre si el tipo de variable que se usa para definir el elemento <Source> no es válido. Los tipos válidos de variables son mensajes y strings.
steps.xmltojson.OutputVariableIsNotAvailable 500 Este error se genera si la variable especificada en el elemento <Source> de la política de XML a JSON es de tipo string y no se define el elemento <OutputVariable>. El elemento <OutputVariable> es obligatorio cuando la variable definida en el elemento <Source> es de tipo de string.
steps.xmltojson.SourceUnavailable 500 Este error se produce si la variable message especificada en el elemento <Source> de la política XML a JSON es una de las siguientes opciones:
  • Está fuera del alcance (no disponible en el flujo específico en el que se ejecuta la política)
  • no se puede resolver (no está definido)

Errores en la implementación

Estos errores pueden generarse cuando implementas un proxy que contiene esta política.

Nombre del error Causa Corregir
EitherOptionOrFormat Si uno de los elementos <Options> o <Format> no se declara en la política de XML a JSON, la implementación del proxy de API falla.
UnknownFormat Si el elemento <Format> dentro de la política de XML a JSON tiene un formato desconocido definido, la implementación del proxy de API falla. Los formatos predefinidos incluyen xml.com, yahoo, google y badgerFish.

Variables con fallas

Estas variables se configuran cuando se genera un error de entorno de ejecución. Para obtener más información, consulta Qué debes saber sobre los errores de la política.

Variables Donde Ejemplo
fault.name="fault_name" fault_name es el nombre de la falla, como se indica en la tabla de Errores del entorno de ejecución anterior. El nombre de la falla es la última parte del código de la falla. fault.name = "SourceUnavailable"
xmltojson.policy_name.failed policy_name es el nombre especificado por el usuario de la política que generó la falla. xmltojson.XMLtoJSON-1.failed = true

Ejemplo de respuesta de error

{
  "fault": {
    "faultstring": "XMLToJSON[XMLtoJSON-1]: Source xyz is not available",
    "detail": {
      "errorcode": "steps.xml2json.SourceUnavailable"
    }
  }
}

Ejemplo de regla de falla

<faultrule name="VariableOfNonMsgType"></faultrule><FaultRule name="XML to JSON Faults">
    <Step>
        <Name>AM-SourceUnavailableMessage</Name>
        <Condition>(fault.name Matches "SourceUnavailable") </Condition>
    </Step>
    <Step>
        <Name>AM-BadXML</Name>
        <Condition>(fault.name = "ExecutionFailed")</Condition>
    </Step>
    <Condition>(xmltojson.XMLtoJSON-1.failed = true) </Condition>
</FaultRule>

Temas relacionados

De JSON a XML: política de JSON a XML