FIXED: Chemistry JSON dump tool and companion GitHub Action (#6222)

Co-authored-by: ShadowCommander <10494922+ShadowCommander@users.noreply.github.com>
Co-authored-by: moonheart08 <moonheart08@users.noreply.github.com>

Content.Server/GuideGenerator/UniversalJsonConverter.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Content.Server.GuideGenerator
+{
+    // This class is used as a shim to help do polymorphic serialization of objects into JSON
+    // (serializing objects that inherit abstract base classes or interfaces) since
+    // System.Text.Json (our new JSON solution) doesn't support that while Newtonsoft.Json (our old
+    // solution) does.
+    public class UniversalJsonConverter<T> : JsonConverter<T>
+    {
+
+        // This converter can only convert types that are T or descend from T.
+        public override bool CanConvert(Type typeToConvert)
+        {
+            return typeof(T).IsAssignableFrom(typeToConvert);
+        }
+
+        // We don't support deserialization right now. In order to do so, we'd need to bundle a
+        // field like "$type" with our objects so they'd be reserialized into the correct base class
+        // but that presents a security hazard.
+        public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            // Throwing a NotImplementedException here allows the Utf8JsonReader to provide
+            // an error message that provides the specific JSON path of the problematic object
+            // rather than a generic error message. At least in theory. Haven't tested that.
+            throw new NotImplementedException();
+        }
+
+        // The bread and butter. Deserialize an object of parameter type T.
+        // This method is automatically called when the JSON writer finds an object of a type
+        // where we've registered this class as its converter using the [JsonConverter(...)] attribute
+        public override void Write(Utf8JsonWriter writer, T obj, JsonSerializerOptions options)
+        {
+            // If the object is null, don't include it.
+            if (obj is null)
+            {
+                writer.WriteNullValue();
+                return;
+            }
+
+            // Use reflection to get a list of fields and properties on the object we're serializing.
+            // Using obj.GetType() here instead of typeof(T) allows us to get the true base class rather
+            // than the abstract ancestor, even if we're parameterized with that abstract class.
+            FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            PropertyInfo[] properties = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+            // Since the JSON writer will have already written the field name, we need to write the object itself.
+            // Since we only use this class to serialize complex objects, we know we'll be writing a JSON object, so open one.
+            writer.WriteStartObject();
+
+            // For each field, try to write it into the object.
+            foreach (FieldInfo field in fields)
+            {
+                // If the field has a [JsonIgnore] attribute, skip it
+                if (Attribute.GetCustomAttribute(field, typeof(JsonIgnoreAttribute), true) != null) continue;
+
+                // exclude fields that are compiler autogenerated like "__BackingField" fields
+                if (Attribute.GetCustomAttribute(field, typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute), true) != null) continue;
+
+                // If the field has a [JsonPropertyName] attribute, get the property name. Otherwise, use the field name.
+                JsonPropertyNameAttribute? attr = (JsonPropertyNameAttribute?) Attribute.GetCustomAttribute(field, typeof(JsonPropertyNameAttribute), true);
+                string name = attr == null ? field.Name : attr.Name;
+
+                // Write a new key/value pair into the JSON object itself.
+                WriteKV(writer, name, field.GetValue(obj), options);
+            }
+
+            // Repeat the same process for each property.
+            foreach (PropertyInfo prop in properties)
+            {
+                // If the field has a [JsonIgnore] attribute, skip it
+                if (Attribute.GetCustomAttribute(prop, typeof(JsonIgnoreAttribute), true) != null) continue;
+
+                // If the property has a [JsonPropertyName] attribute, get the property name. Otherwise, use the property name.
+                JsonPropertyNameAttribute? attr = (JsonPropertyNameAttribute?) Attribute.GetCustomAttribute(prop, typeof(JsonPropertyNameAttribute), true);
+                string name = attr == null ? prop.Name : attr.Name;
+
+                // Write a new key/value pair into the JSON object itself.
+                WriteKV(writer, name, prop.GetValue(obj), options);
+            }
+
+            // Close the object, we're done!
+            writer.WriteEndObject();
+        }
+
+        // This is a little utility method to write a key/value pair inside a JSON object.
+        // It's used for all the actual writing.
+        public void WriteKV(Utf8JsonWriter writer, string key, object? obj, JsonSerializerOptions options)
+        {
+            // First, write the property name
+            writer.WritePropertyName(key);
+
+            // Then, recurse. This ensures that primitive values will be written directly, while
+            // more complex values can use any custom converters we've registered (like this one.)
+            JsonSerializer.Serialize(writer, obj, options);
+        }
+    }
+}