JSON2Class, el conversor de JSON a ObjectScript que siempre deseaste

¿Cuantas veces habéis tenido que recibir o generar un JSON y habéis añorado el poder trabajar sobre él haciendo uso de DTLs y sin tener que ir manejando DynamicObjects intentando recordar cual era el nombre de cada campo?

¿Deseas trocear y hacer más digerible tu gigantesco JSON?

En mi caso, nunca, pero he pensado que a alguien le podría resultar de utilidad una funcionalidad que capture tu JSON y lo descomponga en una serie de clases de ObjectScript con las que puedas trabajar de forma más cómoda y sencilla.

Pues bien...¡contemplad el JSON2Class en toda su gloria!

¿Cómo funciona JSON2Class?

Muy sencillo, aprovecha las capacidades de Embedded Python para trocear y analizar tu JSON y generar las clases asociadas al mismo. Estas clases generadas serán de dos tipos:

• %Persistent: para la clase principal o root.
• %SerialObject: para todas las subclases que colgarán de la principal.

Para ello tiene en consideración los siguientes puntos:

Palabras reservadas

No nos vale cualquier nombre de propiedad que venga en tu JSON, por lo que se modificará añadiendo al final del nombre JSON, de tal forma que "language" pasará a ser "languageJSON".

Carácteres especiales

También se eliminan los carácteres especiales como "_", por lo que "patient_name" pasará a denominarse "patientname".

%JSONFIELDNAME

Para evitar que a la hora de convertir nuevamente la clase a JSON se han añadido a las propiedades que ven modificados sus nombres el atributo %JSONFIELDNAME que nos permite mantener la etiqueta original cuando lo exportemos a JSON.

Generando las clases

Toda la funcionalidad se encuentra dentro de la clase Utils.JSON2Class y para invocar el proceso de generación disponemos del método:

ClassMethod Convert(
    json As %String,
    basePackage As %String = "App.Model",
    rootClassName As %String = "Root",
    outDir As %String = "/shared/generated"
) As %String

Analicemos los atributos del ClassMethod:

• json: será nuestro json de plantilla que queremos generar. 
• basePackage: el package sobre el que se implementarán todas las clases. 
• rootClassName: el nombre de la clase persistente que ejercerá de raíz.
• outDir: directorio local donde se van a generar los ficheros de las clases.

Ejemplo:

Hemos partido de un JSON típico como sería un recurso FHIR de tipo paciente:

{
	"resourceType": "Patient",
	"id": "example",
	"identifier": [
		{
			"use": "usual",
			"type": {
				"coding": [
					{
						"system": "http://terminology.hl7.org/CodeSystem/v2-0203",
						"code": "MR"
					}
				]
			},
			"system": "urn:oid:1.2.36.146.595.217.0.1",
			"value": "12345",
			"period": {
				"start": "2001-05-06"
			},
			"assigner": {
				"display": "Acme Healthcare"
			}
		}
	],
	"active": true,
	"name": [
		{
			"use": "official",
			"family": "Chalmers",
			"given": [
				"Peter",
				"James"
			]
		},
		{
			"use": "usual",
			"given": [
				"Jim"
			]
		},
		{
			"use": "maiden",
			"family": "Windsor",
			"given": [
				"Peter",
				"James"
			],
			"period": {
				"end": "2002"
			}
		}
	],
	"telecom": [
		{
			"use": "home"
		},
		{
			"system": "phone",
			"value": "(03) 5555 6473",
			"use": "work",
			"rank": 1
		},
		{
			"system": "phone",
			"value": "(03) 3410 5613",
			"use": "mobile",
			"rank": 2
		},
		{
			"system": "phone",
			"value": "(03) 5555 8834",
			"use": "old",
			"period": {
				"end": "2014"
			}
		}
	],
	"gender": "male",
	"birthDate": "1974-12-25",
	"_birthDate": {
		"extension": [
			{
				"url": "http://hl7.org/fhir/StructureDefinition/patient-birthTime",
				"valueDateTime": "1974-12-25T14:35:45-05:00"
			}
		]
	},
	"deceasedBoolean": false,
	"address": [
		{
			"use": "home",
			"type": "both",
			"text": "534 Erewhon St\nPeasantVille, Rainbow, Vic3999",
			"line": [
				"534 Erewhon St"
			],
			"city": "PleasantVille",
			"district": "Rainbow",
			"state": "Vic",
			"postalCode": "3999",
			"period": {
				"start": "1974-12-25"
			}
		}
	],
	"contact": [
		{
			"relationship": [
				{
					"coding": [
						{
							"system": "http://terminology.hl7.org/CodeSystem/v2-0131",
							"code": "N"
						}
					]
				}
			],
			"name": {
				"family": "du Marché",
				"_family": {
					"extension": [
						{
							"url": "http://hl7.org/fhir/StructureDefinition/humanname-own-prefix",
							"valueString": "VV"
						}
					]
				},
				"given": [
					"Bénédicte"
				]
			},
			"additionalName": [
				{
					"use": "nickname",
					"given": [
						"Béné"
					]
				}
			],
			"telecom": [
				{
					"system": "phone",
					"value": "+33 (237) 998327"
				}
			],
			"address": {
				"use": "home",
				"type": "both",
				"line": [
					"534 Erewhon St"
				],
				"city": "PleasantVille",
				"district": "Rainbow",
				"state": "Vic",
				"postalCode": "3999",
				"period": {
					"start": "1974-12-25"
				}
			},
			"additionalAddress": [
				{
					"use": "work",
					"line": [
						"123 Smart St"
					],
					"city": "PleasantVille",
					"state": "Vic",
					"postalCode": "3999"
				}
			],
			"gender": "female",
			"period": {
				"start": "2012"
			}
		}
	],
	"managingOrganization": {
		"reference": "Organization/1"
	}
}

Y al ejecutar el conversor hemos obtenido las siguientes clases:

Veamos ahora el objeto Root, que será nuestra clase principal del paciente:

Class App.Model.Root Extends (%Persistent, %JSON.Adaptor)
{

Property resourceType As %String;

Property idJSON As %String(%JSONFIELDNAME = "id");

Property identifier As list Of App.Model.Root.Identifier;

Property active As %Boolean;

Property name As list Of App.Model.Root.Name;

Property telecom As list Of App.Model.Root.Telecom;

Property gender As %String;

Property birthDate As %String;

Property deceasedBoolean As %Boolean;

Property address As list Of App.Model.Root.Address;

Property contact As list Of App.Model.Root.Contact;

Property managingOrganization As App.Model.Root.ManagingOrganization;

}

Et voila! Ya podemos almacenar nuestro JSON como un objeto al uso.

Siguientes pasos

No esta mal poder generar automáticamente las clases, pero será interesante poder transformar automáticamente el JSON a una instancia de las clases que hemos creado teniendo en cuenta las particularidades de los nombres de las propiedades.

Lo dejaremos en la pila de cosas por hacer.