Simplificando los JSON en Navision: ¡Empaqueta tus DLLs en una única y Ejecuta en Navision sin Complicaciones!

¡Saludos, comunidad apasionada de NaviWorld! En nuestra travesía por la simplificación de los Json en Navision, hemos explorado la creación de las clases CreateJson y ReadJson. Hoy, el ansiado día ha llegado: descubriremos cómo ejecutar con éxito todo lo que hemos construido en las últimas semanas.

También al final de todo os mostrare un truquillo para el empaquetado de todas las DLL, quedaros hasta el final.

Sin mas dilación, ¡Vamos, manos a la obra! 🤗

Puesta en Marcha: Compilación, Recolección de DLLs y Despliegue en Navision:
La aventura comienza compilando nuestro proyecto en Visual Studio y recogiendo todas las DLLs generadas en el proceso. Estas piezas clave son fundamentales para la siguiente fase.
Dirijámonos a nuestras instancias de Navision y, en la carpeta de servicios, peguemos con orgullo nuestras DLLs. Este paso es esencial para la integración perfecta de nuestras creaciones en el clásico entorno de Navision.

Estos dos procesos los podemos ver en profundidad en el post de Integración de DLL en Navision.

Codeunit en Acción: Crear y Leer Json:
Dentro del Classic, creamos una nueva codeunit que albergará dos funciones cruciales: una para crear Json y otra para leer Json. Vamos a adentrarnos en ambas funciones.

OBJECT Codeunit 50000 Mgt Json DLL
{
  CODE
  {

    LOCAL PROCEDURE ProcedureCreateJson@1000000000();

    BEGIN

    END;

    LOCAL PROCEDURE ProcedureReadJson@1000000001();
    BEGIN
   
    END;
  }
}

Crear Json:
En esta función, preparamos variables esenciales, inicializamos el Json principal y agregamos los primeros datos. Exploramos la creación de un Json anidado para contactos y un Json Array para productos. Finalmente, mostramos el resultado por pantalla.

    LOCAL PROCEDURE ProcedureCreateJson@1000000000();
    VAR
      CreateJsonDLL@1000000002 : DotNet "'MgtJson, Version=1.0.0.1, Culture=neutral,  
        PublicKeyToken=1036d3165c08df63'.MgtJson.Class.CreateJson";
      Item@1000000000 : Record 27;
      Customer@1000000001 : Record 18;
      Contact@1000000003 : Record 5050;
    BEGIN
      //inicializamos la variable de crear Json
      CLEAR(CreateJsonDLL);
      CreateJsonDLL := CreateJsonDLL.CreateJson();

      //nos posicionamos en las tablas que queremos a¤adir en nuestro Json
      Customer.FINDFIRST();
      Contact.SETRANGE("No.",Customer."Primary Contact No.");
      Contact.FINDFIRST();
      Item.FINDSET();

      //emepzamos creando el init del Json principal
      CreateJsonDLL.InitJson();

      //a¤adimos datos a ese Json
      CreateJsonDLL.AddLine('customer_no',Customer."No.");
      CreateJsonDLL.AddLine('customer_name',Customer.Name);

      //ahora le a¤adimos un Json anidado a nuestro Json
      CreateJsonDLL.InitAnidado('contact');
      CreateJsonDLL.AddLine('contact_name',Contact.Name);
      CreateJsonDLL.AddLine('contact_adress',Contact.Address);
      CreateJsonDLL.EndAnidado();

      //creamos el Json Array
      CreateJsonDLL.InitArray('item');

      //hacemos el buble para a¤adir cada Json dentro de nuestro Json Array.
      REPEAT
        CreateJsonDLL.InitJson();
        CreateJsonDLL.AddLine('no',Item."No.");
        CreateJsonDLL.AddLine('description',Item.Description);
        CreateJsonDLL.EndJson();
      UNTIL Item.NEXT() = 0;

      //cerramos el Json Array y el Json principal
      CreateJsonDLL.EndArray();
      CreateJsonDLL.EndJson();

      //devolvemos el Json en formato Texto.
      MESSAGE(CreateJsonDLL.ReturnJSon());
    END;

Leer Json:
En la función de lectura, inicializamos variables y añadimos un Json de prueba. Mostramos mensajes para verificar la existencia de tags y visualizamos datos específicos. Procedemos a recoger y tratar un Json de contactos, un Json inventado de productos, y exploramos la dinámica de un Json Array.

      //añadimos un Json de pruebas
      JsonText :=
      '{'+
      '  "customer_no": "01121212",'+
      '  "customer_name": "Spotsmeyers Furnishings John",'+
      '  "contact": {'+
      '    "contact_name": "Mr. Mike Nash",'+
      '    "contact_adress": "612 South Sunset Drive"'+
      '  },'+
      '  "items": {'+
      '    "no1": "1000",'+
      '    "description1": "Bicicleta",'+
      '    "no2": "1001",'+
      '    "description2": "Bicicleta ruta",'+
      '    "no3": "1100",'+
      '    "description3": "Rueda delantera"'+
      '  },'+
      '  "item_jsonarray": ['+
      '    {'+
      '      "no": "1000",'+
      '      "description": "Bicicleta"'+
      '    },'+
      '    {'+
      '      "no": "1001",'+
      '      "description": "Bicicleta ruta"'+
      '    },'+
      '    {'+
      '      "no": "1100",'+
      '      "description": "Rueda delantera"'+
      '    }'+
      '  ]'+
      '}';

      //inicializamos la variable de leer Json y le pasamos el  Json en el constructor
      CLEAR(ReadJsonDLL);
      ReadJsonDLL := ReadJsonDLL.ReadJson(JsonText);

      // mostramos si existe o no el tag
      MESSAGE('Existe el Tag "CustNo": ' + FORMAT(ReadJsonDLL.ExistsTag('CustNo')) + '  y el TAG "customer_no": 
        '+FORMAT(ReadJsonDLL.ExistsTag('customer_no')));

      //mostramos dos datos que hay en el Json
      MESSAGE('Nombre del cliente: ' +ReadJsonDLL.GetValueJson_FromTag('customer_name') + ' N§ cliente: 
         '+ReadJsonDLL.GetValueJson_FromTag('customer_no'));

      //recogemos el Json anidado y lo a¤adimos a una nueva variable
      JsonText := ReadJsonDLL.GetJson_FormJson('contact');
      CLEAR(ReadJsonDLL2);
      ReadJsonDLL2 := ReadJsonDLL2.ReadJson(JsonText);

      //mostramos los datos de dentro del Json anidado
      MESSAGE('Nombre del contacto: ' +ReadJsonDLL2.GetValueJson_FromTag('contact_name') + ' Direcci¢n contacto: 
        '+ReadJsonDLL2.GetValueJson_FromTag('contact_adress'));

      //recogemos el Json anidado que recorreremos como un array
      JsonText := ReadJsonDLL.GetJson_FormJson('items');
      CLEAR(ReadJsonDLL2);
      ReadJsonDLL2 := ReadJsonDLL2.ReadJson(JsonText);

      // devolvemos el count del Json y lo mostramos
      CountJson := ReadJsonDLL2.GetCountJson();
      MESSAGE('total registros en el Json: ' + FORMAT(CountJson));

      //recorremos el Json y mostramos el valor y el tag.
      FOR i := 0 TO CountJson-1 DO BEGIN
        MESSAGE('tag: ' + ReadJsonDLL2.GetTagJson_FromPosition(i) + '   valor: ' + ReadJsonDLL2.GetValueJson_FromPosition(i));
      END;

      //recogemos el Json array para su lectura
      JsonText := ReadJsonDLL.GetJson_FormJson('item_jsonarray');
      CLEAR(ReadJsonDLL);
      ReadJsonDLL := ReadJsonDLL.ReadJson(JsonText);

      // devolvemos el count del Json Array y lo mostramos
      CountJson := ReadJsonDLL.GetCountJsonArray();
      MESSAGE('total registros en Array: ' + FORMAT(CountJson));

      //recorremos el Json Array y mostramos los datos de dentro de cada Json.
      FOR i := 0 TO CountJson-1 DO BEGIN
        JsonText := ReadJsonDLL.GetValue_FromJsonArray(i);
        CLEAR(ReadJsonDLL2);
        ReadJsonDLL2 := ReadJsonDLL2.ReadJson(JsonText);
        MESSAGE('No producto: ' + ReadJsonDLL2.GetValueJson_FromTag('no') + '   Descripci¢n: ' + 
         ReadJsonDLL2.GetValueJson_FromTag('description'));
      END;

Este proceso, aunque demostrado con mensajes, puede integrarse directamente con tablas o tablas temporales en Navision.

Ilmerge, empaquetado en un mismo saco.

Llegamos al emocionante final de nuestra odisea sobre las DLLs, pero antes de cerrar el capítulo, hay un último truco que cambiará tu forma de gestionar extensiones en Navision. Después de ejecutar DLLs en Navision, nos enfrentamos al desafío de múltiples DLLs. ¿La solución? ¡ilmerge! Descubre cómo simplificar tu aplicación con este método magistral.

Compilando Extensiones: Un Resumen Rápido:
En nuestro viaje, creamos y ejecutamos diversas DLLs, especialmente una para trabajar con Json. Sin embargo, surge un problema: múltiples DLLs que debemos llevar y mantener junto a la nuestra. Aquí es donde ilmerge se convierte en nuestro héroe para consolidar todo en una única extensión.

Empaquetando DLLs con ilmerge:
La maravilla de ilmerge radica en su capacidad para fusionar DLLs en una sola. Después de compilar tu proyecto, te encuentras con varias DLLs vinculadas. Este podría ser un desafío al agregar más extensiones, pero ilmerge lo convierte en un proceso fluido.

• Desde el NuGet, busca e instala ilmerge y MSBuild.ILMerge.Task en tu proyecto. Estos paquetes abrirán las puertas a la consolidación.

• Observa los nuevos archivos generados en tu proyecto, pero presta especial atención a “packages.config”. Aquí, añade referencias de otras DLLs para que ilmerge las empacé todas juntas.

• Sin más ajustes, compila tu proyecto y ¡voilà! Notarás que solo tu extensión brilla, sin rastro de las DLLs adicionales.

En conclusión, nos hemos enfrentado al desafío de gestionar Json en Navision y de unificar múltiples DLLs al desplegarlas. Pasando por la creación inicial de las clases hasta la compilacion en una sola DLL y por ultimo el crear una codeunit en Navision para ejecutar todo estos procesos de manejo de Json.

Todo este proceso, completo, está detalladamente explicado en mi repositorio de GitHub.

Aunque esta saga llega a su fin, nuevas emocionantes travesías nos esperan. Mantente atento a mis futuras publicaciones, donde exploraremos más secretos de la programación en Navision.

¡Hasta la próxima, desarrolladores!