The Dictionary Data Type represents an unordered collection of keys and values and is optimized for fast lookup of values. Each addition to the dictionary consists of a value and its associated key. Every key in a Dictionary must be unique. It is on my list of favorite “new” AL Data Types, and I find it often easier to work with a dictionary than another object type.

In this example, a JSON Object’s value keys (not the array or object keys) are copied into a Dictionary Data Type variable.

procedure JsonObjectValuestoDictionary(JObject: JsonObject; var ObjectDictionary: Dictionary of [Text, Text])
var
    IsHandled: Boolean;
    JsonToken: JsonToken;
    DuplicateKeyErr: label 'Duplicate Key %1', Comment = '%1 Key Name';
    ObjectKeys: List of [Text];
    JKey: Text;
    JValue: Text;
begin
    Clear(ObjectDictionary);

    OnBeforeJsonObjectValuestoDictionary(JObject, ObjectDictionary, IsHandled);
    if IsHandled then
        exit;

    ObjectKeys := JObject.Keys();
    foreach JKey in ObjectKeys do begin
        JObject.Get(Jkey, JsonToken);
        if JsonToken.IsValue then begin
            if ObjectDictionary.ContainsKey(JKey) then
                Error(DuplicateKeyErr, JKey);
            JsonToken.WriteTo(JValue);
            ObjectDictionary.Add(DelChr(JKey, '=', '"'), DelChr(JValue, '=', '"'));
        end;
    end;

    OnAfterJsonObjectValuestoDictionary(JObject, ObjectDictionary);
end;

[BusinessEvent(false)]
local procedure OnAfterJsonObjectValuestoDictionary(JObject: JsonObject; var ObjectDictionary: Dictionary of [Text, Text])
begin
end;

[BusinessEvent(false)]
local procedure OnBeforeJsonObjectValuestoDictionary(JObject: JsonObject; var ObjectDictionary: Dictionary of [Text, Text]; var Handled: Boolean)
begin
end;

Note: The code and information discussed in this article are for informational and demonstration purposes only. This content was created referencing Microsoft Dynamics 365 Business Central 2022 Wave 2 online.

A JSON (JavaScript Object Notation) file is a standard text file used to store data in a structured, organized way. It is a simple, human-readable format often used for transmitting data between a server and a web application or between different systems.

A JSON file consists of a series of key-value pairs separated by commas. The keys are always strings, and the values can be strings, numbers, booleans, arrays, or objects.

I had previously discussed an example demonstrating a basic model with enough information to create a simple JSON file with AL for Microsoft Dynamics 365 Business Central. The example created a JSON file displayed here:

{
    "Customer": {
        "No": "10000",
        "Address": "192 Market Square",
        "Address_2": "",
        "City": "",
        "County": "NJ",
        "Country_Region": "US",
        "Post_Code": "",
        "Ship-to": [
            {
                "Code": "LEWES ROAD",
                "Address": "2 Lewes Road",
                "Address_2": "",
                "City": "Atlanta",
                "County": "GA",
                "Post_Code": "31772"
            },
            {
                "Code": "PARK ROAD",
                "Address": "10 Park Road",
                "Address_2": "",
                "City": "Atlanta",
                "County": "GA",
                "Post_Code": "31772"
            }
        ]
    }
}

The example below shows a basic model to provide enough information to get started reading a simple JSON, resembling the file above, with AL for Microsoft Dynamics 365 Business Central using Codeunit 5459 “JSON Management.”

There are many ways to code a solution, and opinion or situation determines the best (including the Json datatypes). Codeunit 5459 “JSON Management” has many methods for working with JSON files. I encourage you to explore the codeunit.

local procedure ReadJSON(JsonObjectText: Text)
    var
        Customer: Record Customer;
        ShiptoAddress: Record "Ship-to Address";
        ArrayJSONManagement: Codeunit "JSON Management";
        JSONManagement: Codeunit "JSON Management";
        ObjectJSONManagement: Codeunit "JSON Management";
        i: Integer;
        CodeText: Text;
        CustomerJsonObject: Text;
        JsonArrayText: Text;
        ShipToJsonObject: Text;
    begin
        JSONManagement.InitializeObject(JsonObjectText);
        if JSONManagement.GetArrayPropertyValueAsStringByName('Customer', CustomerJsonObject) then begin
            ObjectJSONManagement.InitializeObject(CustomerJsonObject);

            Customer.Init();
            ObjectJSONManagement.GetStringPropertyValueByName('No', CodeText);
            Customer.Validate("No.", CopyStr(CodeText.ToUpper(), 1, MaxStrLen(Customer."No.")));
            ObjectJSONManagement.GetStringPropertyValueByName('Address', CodeText);
            Customer.Validate("Address", CopyStr(CodeText, 1, MaxStrLen(Customer."Address")));
            Customer.Insert();

            JSONManagement.InitializeObject(CustomerJsonObject);
            if JSONManagement.GetArrayPropertyValueAsStringByName('Ship-to', JsonArrayText) then begin
                ArrayJSONManagement.InitializeCollection(JsonArrayText);
                for i := 0 to ArrayJSONManagement.GetCollectionCount() - 1 do begin
                    ArrayJSONManagement.GetObjectFromCollectionByIndex(ShipToJsonObject, i);
                    ObjectJSONManagement.InitializeObject(ShipToJsonObject);

                    ShiptoAddress.Init();
                    ShiptoAddress.Validate("Customer No.", Customer."No.");
                    ObjectJSONManagement.GetStringPropertyValueByName('Code', CodeText);
                    ShiptoAddress.Validate("Code", CopyStr(CodeText.ToUpper(), 1, MaxStrLen(ShiptoAddress.Code)));
                    ShiptoAddress.Validate("Address", CopyStr(CodeText, 1, MaxStrLen(ShiptoAddress.Address)));
                    ShiptoAddress.Insert();

                end;
            end;
        end;
    end;

Note: The code and information discussed in this article are for informational and demonstration purposes only. This content was created referencing Microsoft Dynamics 365 Business Central 2022 Wave 2 online.

JSON (JavaScript Object Notation) is an open standard file format that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and arrays (or other serializable values).

In today’s digital age, the exchange of data between Microsoft Dynamics 365 Business Central and other systems is often necessary. In a previous post, I covered a basic example of creating an XML file with AL. Along with XML files, I am often asked how to generate JSON files. Here is an example of creating a basic JSON file in AL.

The  example below demonstrates a basic model to provide enough information to create a simple file; consider it “Getting Started.” There are many ways to code a solution, and opinion or situation determines the best. Within Microsoft Dynamics 365 Business Central, JSON can be processed codeunit 5459 “JSON Management.” I  do use this codeunit often and may cover this example using the codeunit in the future.

    local procedure CreateJSON(Customer: Record Customer)
    var
        ShiptoAddress: Record "Ship-to Address";
        JArray: JsonArray;
        CustObject: JsonObject;
        JsonObject: JsonObject;
        ShiptoObject: JsonObject;
        JsonData: Text;

    begin
        Clear(JsonObject);
        Clear(CustObject);

        CustObject.Add('No', Customer."No.");
        CustObject.Add('Address', Customer.Address);
        CustObject.Add('Address_2', Customer."Address 2");
        CustObject.Add('City', Customer.City);
        CustObject.Add('County', Customer.County);
        CustObject.Add('Country_Region', Customer."Country/Region Code");
        CustObject.Add('Post_Code', Customer."Post Code");

        ShiptoAddress.SetRange("Customer No.", Customer."No.");
        if ShiptoAddress.FindSet() then begin
            Clear(JArray);
            repeat
                Clear(ShiptoObject);
                ShiptoObject.Add('Code', ShiptoAddress.Code);
                ShiptoObject.Add('Address', ShiptoAddress.Address);
                ShiptoObject.Add('Address_2', ShiptoAddress."Address 2");
                ShiptoObject.Add('City', ShiptoAddress.City);
                ShiptoObject.Add('County', ShiptoAddress.County);
                ShiptoObject.Add('Post_Code', ShiptoAddress."Post Code");
                JArray.Add(ShiptoObject);
            until ShiptoAddress.Next() = 0;
            CustObject.Add('Ship-to', JArray);
        end;

        JsonObject.Add('Customer', CustObject);

        JsonObject.WriteTo(JsonData);

    end;

The above code creates the JSON file displayed here:

{
    "Customer": {
        "No": "10000",
        "Address": "192 Market Square",
        "Address_2": "",
        "City": "",
        "County": "NJ",
        "Country_Region": "US",
        "Post_Code": "",
        "Ship-to": [
            {
                "Code": "LEWES ROAD",
                "Address": "2 Lewes Road",
                "Address_2": "",
                "City": "Atlanta",
                "County": "GA",
                "Post_Code": "31772"
            },
            {
                "Code": "PARK ROAD",
                "Address": "10 Park Road",
                "Address_2": "",
                "City": "Atlanta",
                "County": "GA",
                "Post_Code": "31772"
            }
        ]
    }
}

Note: The code and information discussed in this article are for informational and demonstration purposes only. This content was created referencing Microsoft Dynamics 365 Business Central 2022 Wave 2 online.