Adding Handler to properly utilize the API results

ChaosBot/Lodestone/LodestoneRank.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace ChaosBot.Lodestone
+{
+    public partial class LodestoneRankApi
+    {
+        [JsonProperty("success")]
+        public bool Success { get; set; }
+
+        [JsonProperty("error")]
+        public object Error { get; set; }
+
+        [JsonProperty("data")]
+        public List<LodestoneRank> Data { get; set; }
+    }
+
+    public partial class LodestoneRank
+    {
+        [JsonProperty("lodestoneId")]
+        [JsonConverter(typeof(ParseStringConverter))]
+        public long LodestoneId { get; set; }
+
+        [JsonProperty("ingameRole")]
+        public ERole IngameRole { get; set; }
+
+        [JsonProperty("firstSeen")]
+        public DateTimeOffset FirstSeen { get; set; }
+
+        [JsonProperty("displayName")]
+        public string DisplayName { get; set; }
+
+        [JsonProperty("shouldBeRole")]
+        public ERole? ShouldBeRole { get; set; }
+
+        [JsonProperty("discordId")]
+        public string DiscordId { get; set; }
+    }
+
+    public enum ERole { Council, Initiate, Member, Mentor, Recruit };
+
+    public partial class LodestoneRankApi
+    {
+        public static LodestoneRankApi FromJson(string json) => JsonConvert.DeserializeObject<LodestoneRankApi>(json, ChaosBot.Lodestone.Converter.Settings);
+    }
+
+    public static class Serialize
+    {
+        public static string ToJson(this LodestoneRankApi self) => JsonConvert.SerializeObject(self, ChaosBot.Lodestone.Converter.Settings);
+    }
+
+    internal static class Converter
+    {
+        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
+        {
+            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
+            DateParseHandling = DateParseHandling.None,
+            Converters =
+            {
+                ERoleConverter.Singleton,
+                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
+            },
+        };
+    }
+
+    internal class ERoleConverter : JsonConverter
+    {
+        public override bool CanConvert(Type t) => t == typeof(ERole) || t == typeof(ERole?);
+
+        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null) return null;
+            var value = serializer.Deserialize<string>(reader);
+            switch (value)
+            {
+                case "Council":
+                    return ERole.Council;
+                case "Initiate":
+                    return ERole.Initiate;
+                case "Member":
+                    return ERole.Member;
+                case "Mentor":
+                    return ERole.Mentor;
+                case "Recruit":
+                    return ERole.Recruit;
+            }
+            throw new Exception("Cannot unmarshal type ERole");
+        }
+
+        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+        {
+            if (untypedValue == null)
+            {
+                serializer.Serialize(writer, null);
+                return;
+            }
+            var value = (ERole)untypedValue;
+            switch (value)
+            {
+                case ERole.Council:
+                    serializer.Serialize(writer, "Council");
+                    return;
+                case ERole.Initiate:
+                    serializer.Serialize(writer, "Initiate");
+                    return;
+                case ERole.Member:
+                    serializer.Serialize(writer, "Member");
+                    return;
+                case ERole.Mentor:
+                    serializer.Serialize(writer, "Mentor");
+                    return;
+                case ERole.Recruit:
+                    serializer.Serialize(writer, "Recruit");
+                    return;
+            }
+            throw new Exception("Cannot marshal type ERole");
+        }
+
+        public static readonly ERoleConverter Singleton = new ERoleConverter();
+    }
+
+    internal class ParseStringConverter : JsonConverter
+    {
+        public override bool CanConvert(Type t) => t == typeof(long) || t == typeof(long?);
+
+        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null) return null;
+            var value = serializer.Deserialize<string>(reader);
+            long l;
+            if (Int64.TryParse(value, out l))
+            {
+                return l;
+            }
+            throw new Exception("Cannot unmarshal type long");
+        }
+
+        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+        {
+            if (untypedValue == null)
+            {
+                serializer.Serialize(writer, null);
+                return;
+            }
+            var value = (long)untypedValue;
+            serializer.Serialize(writer, value.ToString());
+            return;
+        }
+
+        public static readonly ParseStringConverter Singleton = new ParseStringConverter();
+    }
+}