JSON spr

// <auto-generated />
//
// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
//
//    using JSON;
//
//    var Spritpreisrechnerat = Spritpreisrechnerat.FromJson(jsonString);

namespace JSON
{
    using System;
    using System.Collections.Generic;

    using System.Globalization;
    using Newtonsoft.Json;
    using Newtonsoft.Json.Converters;

    public partial class Spritpreisrechnerat
    {
        [JsonProperty("id")]
        public long Id { get; set; }

        [JsonProperty("name")]
        public string Name { get; set; }

        [JsonProperty("location")]
        public Location Location { get; set; }

        [JsonProperty("contact")]
        public Contact Contact { get; set; }

        [JsonProperty("openingHours")]
        public OpeningHour[] OpeningHours { get; set; }

        [JsonProperty("offerInformation")]
        public OfferInformation OfferInformation { get; set; }

        [JsonProperty("paymentMethods")]
        public PaymentMethods PaymentMethods { get; set; }

        [JsonProperty("paymentArrangements")]
        public PaymentArrangements PaymentArrangements { get; set; }

        [JsonProperty("position")]
        public long Position { get; set; }

        [JsonProperty("open")]
        public bool Open { get; set; }

        [JsonProperty("distance")]
        public double Distance { get; set; }

        [JsonProperty("prices")]
        public Price[] Prices { get; set; }

        [JsonProperty("otherServiceOffers", NullValueHandling = NullValueHandling.Ignore)]
        public string OtherServiceOffers { get; set; }
    }

    public partial class Contact
    {
        [JsonProperty("mail", NullValueHandling = NullValueHandling.Ignore)]
        public string Mail { get; set; }

        [JsonProperty("telephone", NullValueHandling = NullValueHandling.Ignore)]
        public string Telephone { get; set; }

        [JsonProperty("fax", NullValueHandling = NullValueHandling.Ignore)]
        public string Fax { get; set; }

        [JsonProperty("website", NullValueHandling = NullValueHandling.Ignore)]
        public string Website { get; set; }
    }

    public partial class Location
    {
        [JsonProperty("address")]
        public string Address { get; set; }

        [JsonProperty("postalCode")]
        [JsonConverter(typeof(ParseStringConverter))]
        public long PostalCode { get; set; }

        [JsonProperty("city")]
        public City City { get; set; }

        [JsonProperty("latitude")]
        public double Latitude { get; set; }

        [JsonProperty("longitude")]
        public double Longitude { get; set; }
    }

    public partial class OfferInformation
    {
        [JsonProperty("service")]
        public bool Service { get; set; }

        [JsonProperty("selfService")]
        public bool SelfService { get; set; }

        [JsonProperty("unattended")]
        public bool Unattended { get; set; }
    }

    public partial class OpeningHour
    {
        [JsonProperty("day")]
        public Day Day { get; set; }

        [JsonProperty("label")]
        public Label Label { get; set; }

        [JsonProperty("order")]
        public long Order { get; set; }

        [JsonProperty("from")]
        public From From { get; set; }

        [JsonProperty("to")]
        public To To { get; set; }
    }

    public partial class PaymentArrangements
    {
        [JsonProperty("cooperative")]
        public bool Cooperative { get; set; }

        [JsonProperty("clubCard")]
        public bool ClubCard { get; set; }
    }

    public partial class PaymentMethods
    {
        [JsonProperty("cash")]
        public bool Cash { get; set; }

        [JsonProperty("debitCard")]
        public bool DebitCard { get; set; }

        [JsonProperty("creditCard")]
        public bool CreditCard { get; set; }

        [JsonProperty("others", NullValueHandling = NullValueHandling.Ignore)]
        public string Others { get; set; }
    }

    public partial class Price
    {
        [JsonProperty("fuelType")]
        public string FuelType { get; set; }

        [JsonProperty("amount")]
        public double Amount { get; set; }

        [JsonProperty("label")]
        public string Label { get; set; }
    }

    public enum City { Wien };

    public enum Day { Di, Do, Fe, Fr, Mi, Mo, Sa, So };

    public enum From { The0000, The0600, The0700 };

    public enum Label { Dienstag, Donnerstag, Feiertag, Freitag, Mittwoch, Montag, Samstag, Sonntag };

    public enum To { The2000, The2100, The2200, The2400 };

    public partial class Spritpreisrechnerat
    {
        public static Spritpreisrechnerat[] FromJson(string json) => JsonConvert.DeserializeObject<Spritpreisrechnerat[]>(json, JSON.Converter.Settings);
    }

    public static class Serialize
    {
        public static string ToJson(this Spritpreisrechnerat[] self) => JsonConvert.SerializeObject(self, JSON.Converter.Settings);
    }

    internal static class Converter
    {
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
            Converters =
            {
                CityConverter.Singleton,
                DayConverter.Singleton,
                FromConverter.Singleton,
                LabelConverter.Singleton,
                ToConverter.Singleton,
                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
            },
        };
    }

    internal class CityConverter : JsonConverter
    {
        public override bool CanConvert(Type t) => t == typeof(City) || t == typeof(City?);

        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);
            if (value == "Wien")
            {
                return City.Wien;
            }
            throw new Exception("Cannot unmarshal type City");
        }

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (City)untypedValue;
            if (value == City.Wien)
            {
                serializer.Serialize(writer, "Wien");
                return;
            }
            throw new Exception("Cannot marshal type City");
        }

        public static readonly CityConverter Singleton = new CityConverter();
    }

    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();
    }

    internal class DayConverter : JsonConverter
    {
        public override bool CanConvert(Type t) => t == typeof(Day) || t == typeof(Day?);

        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 "DI":
                    return Day.Di;
                case "DO":
                    return Day.Do;
                case "FE":
                    return Day.Fe;
                case "FR":
                    return Day.Fr;
                case "MI":
                    return Day.Mi;
                case "MO":
                    return Day.Mo;
                case "SA":
                    return Day.Sa;
                case "SO":
                    return Day.So;
            }
            throw new Exception("Cannot unmarshal type Day");
        }

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (Day)untypedValue;
            switch (value)
            {
                case Day.Di:
                    serializer.Serialize(writer, "DI");
                    return;
                case Day.Do:
                    serializer.Serialize(writer, "DO");
                    return;
                case Day.Fe:
                    serializer.Serialize(writer, "FE");
                    return;
                case Day.Fr:
                    serializer.Serialize(writer, "FR");
                    return;
                case Day.Mi:
                    serializer.Serialize(writer, "MI");
                    return;
                case Day.Mo:
                    serializer.Serialize(writer, "MO");
                    return;
                case Day.Sa:
                    serializer.Serialize(writer, "SA");
                    return;
                case Day.So:
                    serializer.Serialize(writer, "SO");
                    return;
            }
            throw new Exception("Cannot marshal type Day");
        }

        public static readonly DayConverter Singleton = new DayConverter();
    }

    internal class FromConverter : JsonConverter
    {
        public override bool CanConvert(Type t) => t == typeof(From) || t == typeof(From?);

        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 "00:00":
                    return From.The0000;
                case "06:00":
                    return From.The0600;
                case "07:00":
                    return From.The0700;
            }
            throw new Exception("Cannot unmarshal type From");
        }

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (From)untypedValue;
            switch (value)
            {
                case From.The0000:
                    serializer.Serialize(writer, "00:00");
                    return;
                case From.The0600:
                    serializer.Serialize(writer, "06:00");
                    return;
                case From.The0700:
                    serializer.Serialize(writer, "07:00");
                    return;
            }
            throw new Exception("Cannot marshal type From");
        }

        public static readonly FromConverter Singleton = new FromConverter();
    }

    internal class LabelConverter : JsonConverter
    {
        public override bool CanConvert(Type t) => t == typeof(Label) || t == typeof(Label?);

        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 "Dienstag":
                    return Label.Dienstag;
                case "Donnerstag":
                    return Label.Donnerstag;
                case "Feiertag":
                    return Label.Feiertag;
                case "Freitag":
                    return Label.Freitag;
                case "Mittwoch":
                    return Label.Mittwoch;
                case "Montag":
                    return Label.Montag;
                case "Samstag":
                    return Label.Samstag;
                case "Sonntag":
                    return Label.Sonntag;
            }
            throw new Exception("Cannot unmarshal type Label");
        }

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (Label)untypedValue;
            switch (value)
            {
                case Label.Dienstag:
                    serializer.Serialize(writer, "Dienstag");
                    return;
                case Label.Donnerstag:
                    serializer.Serialize(writer, "Donnerstag");
                    return;
                case Label.Feiertag:
                    serializer.Serialize(writer, "Feiertag");
                    return;
                case Label.Freitag:
                    serializer.Serialize(writer, "Freitag");
                    return;
                case Label.Mittwoch:
                    serializer.Serialize(writer, "Mittwoch");
                    return;
                case Label.Montag:
                    serializer.Serialize(writer, "Montag");
                    return;
                case Label.Samstag:
                    serializer.Serialize(writer, "Samstag");
                    return;
                case Label.Sonntag:
                    serializer.Serialize(writer, "Sonntag");
                    return;
            }
            throw new Exception("Cannot marshal type Label");
        }

        public static readonly LabelConverter Singleton = new LabelConverter();
    }

    internal class ToConverter : JsonConverter
    {
        public override bool CanConvert(Type t) => t == typeof(To) || t == typeof(To?);

        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 "20:00":
                    return To.The2000;
                case "21:00":
                    return To.The2100;
                case "22:00":
                    return To.The2200;
                case "24:00":
                    return To.The2400;
            }
            throw new Exception("Cannot unmarshal type To");
        }

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
        {
            if (untypedValue == null)
            {
                serializer.Serialize(writer, null);
                return;
            }
            var value = (To)untypedValue;
            switch (value)
            {
                case To.The2000:
                    serializer.Serialize(writer, "20:00");
                    return;
                case To.The2100:
                    serializer.Serialize(writer, "21:00");
                    return;
                case To.The2200:
                    serializer.Serialize(writer, "22:00");
                    return;
                case To.The2400:
                    serializer.Serialize(writer, "24:00");
                    return;
            }
            throw new Exception("Cannot marshal type To");
        }

        public static readonly ToConverter Singleton = new ToConverter();
    }
}