chaosbot/ChaosBot/Lodestone/LodestoneRank.cs

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("RecruitDate")]
        public DateTimeOffset RecruitDate { get; set; }
        
        [JsonProperty("MemberDate")]
        public DateTimeOffset MemberDate { 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, Inactive, 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 "Inactive":
                    return ERole.Inactive;
                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.Inactive:
                    serializer.Serialize(writer, "Inactive");
                    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();
    }
}