using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

using System.Text.Json.Nodes;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/78473147/net-serializing-a-complex-dto-to-json-string

​

#nullable enable

​

[JsonDerivedType(typeof(ChangeBucketDto), "changeBucketDto"), JsonDerivedType(typeof(TrackedChangeDto), "trackedChangeDto")]

public class Dto

{

    /// <summary>

    /// The unique identifier of the entity

    /// </summary>

    [JsonPropertyName("key")]

    public required string Key { get; set; }

}

​

public class ChangeBucketDto : Dto

{

    [JsonRequired]

    [JsonPropertyName("text")]

    public required string Text { get; set; }

    [JsonRequired]

    [JsonPropertyName("changes")]

    public required List<TrackedChangeDto> Changes { get; set; }

}

​

public class TrackedChangeDto : Dto

{

    [JsonRequired]

    [JsonPropertyName("origin")]

    public required ChangeOrigin Origin { get; set; }

    [JsonPropertyName("oldValue")]

    public JsonNode? OldValue { get; set; }

    [JsonPropertyName("newValue")]

    public JsonNode? NewValue { get; set; }

    [JsonRequired]

    [JsonPropertyName("changeType")]

    public required string ChangeType { get; set; }

    [JsonRequired]

    [JsonPropertyName("displayOrder")]

    public required List<string> DisplayOrder { get; set; }

    [JsonRequired]

    [JsonPropertyName("lastModified")]

    public required DateTime LastModified { get; set; }

    [JsonRequired]

    [JsonPropertyName("live")]

    public required bool Live { get; set; }

}

​

public class ChangeOrigin

{

    [JsonPropertyName("ContainerName")]

    public string? ContainerName { get; set; }

​

    [JsonPropertyName("FileName")]

    public string? FileName { get; set; }

}

​

    class TestClass

    {

        public static void Test()

        {

            var inputOptions = new JsonSerializerOptions

            {

            };

            var inputStringified = GetInputJson();

            var json = JsonSerializer.Deserialize<List<ChangeBucketDto>>(inputStringified, inputOptions);

            var options = new JsonSerializerOptions

            {

                WriteIndented = true,

            };

            var stringified = JsonSerializer.Serialize(json, options);

            Console.WriteLine(stringified);

            Assert.That(JsonNode.DeepEquals(JsonSerializer.Deserialize<JsonNode>(inputStringified, options), JsonNode.Parse(stringified)));

        }   

        static string GetInputJson() =>

"""

[

  {

    "text": "Vragen",

    "changes": [],

    "key": "questions"

  },

  {

    "text": "Berichten",

    "changes": [

      {

        "origin": {

          "ContainerName": "answers",

          "FileName": "answers.json"

        },

        "oldValue": {

          "key": "Foo",

          "languages": [

            { "NL": "Bor" },

            { "EN": "Bar" }

          ],

          "type": "message"

        },

        "newValue": {

          "key": "Foo",

          "languages": [

            { "NL": "Bar" },

            { "EN": "Bar" }

          ],

          "type": "message"

        },

        "changeType": "Update",

        "displayOrder": [

          "key",

          "languages",

          "type"

        ],

        "lastModified": "2024-05-13T17:23:30.509Z",

        "live": true,

        "key": "change-highlights-Maintenance"

      }

    ],

    "key": "answers"

  },

  {

    "text": "FAQs",

    "changes": [],

    "key": "faqs"

  },

  {

    "text": "Dialogen",

    "changes": [],

    "key": "dialogs"

  },

  {

    "text": "Highlights",

    "changes": [

      {

        "origin": {

          "ContainerName": "highlights",

          "FileName": "highlights.json"

        },

        "oldValue": {

          "key": "Foo",

          "languages": [

            { "NL": "Bor" },

            { "EN": "Bar" }

          ],

          "enabled": "true",

          "repeat": "true",

          "timeSpan": 7,

          "timeStampFrom": "2023-12-13T11:50",

          "timeStampTo": "2023-12-13T17:00"

        },

        "newValue": {

          "key": "Foo",

          "languages": [

            { "NL": "Bar" },

            { "EN": "Bar" }

          ],

          "enabled": "true",

          "repeat": "true",

          "timeSpan": 7,

          "timeStampFrom": "2023-12-13T11:50",

          "timeStampTo": "2023-12-13T18:00"

        },

        "changeType": "Update",

        "displayOrder": [

          "key",

          "languages",

          "enabled",

          "repeat",

          "timeSpan",

          "timeStampFrom",

          "timeStampTo"

        ],

        "lastModified": "2024-05-13T17:23:30.509Z",

        "live": true,

        "key": "change-highlights-Maintenance"

      }

    ],

    "key": "highlights"

  },

  {

    "text": "Groepsincidenten",

    "changes": [],

    "key": "groupincidents"

  },

  {

    "text": "Kennisbanken",

    "changes": [],

    "key": "knowledgesources"

  }

]

""";

    }

​

    public static partial class JsonExtensions

    {

        public static ref Utf8JsonReader ReadAndAssert(ref this Utf8JsonReader reader) { if (!reader.Read()) { throw new JsonException(); } return ref reader; }

        public static T ThrowOnNull<T>(this T? value) where T : class => value ?? throw new ArgumentNullException();

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1}), {2}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion);

            Console.WriteLine("System.Text.Json version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​