using RestSharp;

using System;

using System.Globalization;

using Coloque_Isso_Em_Um_Arquivo_Separado;

​

public class Program

{

    public static void Main()

    {

        RestClient client = new RestClient("https://apis.averbeporto.com.br/php/conn.php");

        RestRequest request = new RestRequest();

        request.Method = Method.Post;

        request.AddHeader("Content-Type", "application/x-www-form-urlencoded");

        request.AddParameter("mod", "login");

        request.AddParameter("comp", "5");

        request.AddParameter("user", "00000001000136");

        request.AddParameter("pass", "0000");

        var response = client.ExecutePost(request);

        string conteudo = response.Content;

        Welcome4 seuResultado = Welcome4.FromJson(conteudo);

​

        Console.WriteLine(String.Format("Seu username: {0} ",seuResultado.C.UserName));

        Console.WriteLine(String.Format("Seu Email: {0} ",seuResultado.C.Email));

    }

}

​

​

namespace Coloque_Isso_Em_Um_Arquivo_Separado

{

    using System;

    using System.Globalization;

    using Newtonsoft.Json;

    using Newtonsoft.Json.Converters;

​

    public partial class Welcome4

    {

        [JsonProperty("success")]

        public long Success { get; set; }

​

        [JsonProperty("C")]

        public C C { get; set; }

​

        [JsonProperty("S")]

        public Empty[] S { get; set; }

    }

​

    public partial class C

    {

        [JsonProperty("id")]

        [JsonConverter(typeof(ParseStringConverter))]

        public long Id { get; set; }

​

        [JsonProperty("userName")]

        public string UserName { get; set; }

​

        [JsonProperty("name")]

        public string Name { get; set; }

​

        [JsonProperty("email")]

        public string Email { get; set; }

​

        [JsonProperty("portal_groups_id")]

        [JsonConverter(typeof(ParseStringConverter))]

        public long PortalGroupsId { get; set; }

​

        [JsonProperty("type")]

        public string Type { get; set; }

​

        [JsonProperty("ses")]

        public string Ses { get; set; }

    }

​

    public partial class Menu

    {

        [JsonProperty("items")]

        public Empty[] Items { get; set; }

    }

​

    public partial class Empty

    {

        [JsonProperty("perm", NullValueHandling = NullValueHandling.Ignore)]

        [JsonConverter(typeof(ParseStringConverter))]

        public long? Perm { get; set; }

​

        [JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]

        [JsonConverter(typeof(ParseStringConverter))]

        public long? Id { get; set; }

​

        [JsonProperty("fileName", NullValueHandling = NullValueHandling.Ignore)]

        public string FileName { get; set; }

​

        [JsonProperty("fPath", NullValueHandling = NullValueHandling.Ignore)]

        public FPath? FPath { get; set; }

​

        [JsonProperty("bPath", NullValueHandling = NullValueHandling.Ignore)]

        public BPath? BPath { get; set; }

​

        [JsonProperty("text")]

        public string Text { get; set; }

​

        [JsonProperty("modId", NullValueHandling = NullValueHandling.Ignore)]

        public string ModId { get; set; }

​

        [JsonProperty("modName")]

        public object ModName { get; set; }

​

        [JsonProperty("menu")]

        public Menu Menu { get; set; }

​

        [JsonProperty("idx", NullValueHandling = NullValueHandling.Ignore)]

        [JsonConverter(typeof(ParseStringConverter))]

        public long? Idx { get; set; }

​

        [JsonProperty("active", NullValueHandling = NullValueHandling.Ignore)]

        [JsonConverter(typeof(ParseStringConverter))]

        public long? Active { get; set; }

​

        [JsonProperty("iconCls", NullValueHandling = NullValueHandling.Ignore)]

        public string IconCls { get; set; }

​

        [JsonProperty("mPath", NullValueHandling = NullValueHandling.Ignore)]

        public MPath? MPath { get; set; }

​

        [JsonProperty("tourName", NullValueHandling = NullValueHandling.Ignore)]

        public string TourName { get; set; }

​

        [JsonProperty("hidden", NullValueHandling = NullValueHandling.Ignore)]

        [JsonConverter(typeof(ParseStringConverter))]

        public long? Hidden { get; set; }

​

        [JsonProperty("autoStart", NullValueHandling = NullValueHandling.Ignore)]

        [JsonConverter(typeof(ParseStringConverter))]

        public long? AutoStart { get; set; }

    }

​

    public enum BPath { BPathPhp, Php, PhpReports };

​

    public enum FPath { Js, JsMod, JsRpt };

​

    public enum MPath { Empty, GhsLocAdm, GhsLocReports };

​

    public partial class Welcome4

    {

        public static Welcome4 FromJson(string json) => JsonConvert.DeserializeObject<Welcome4>(json, Coloque_Isso_Em_Um_Arquivo_Separado.Converter.Settings);

    }

​

    public static class Serialize

    {

        public static string ToJson(this Welcome4 self) => JsonConvert.SerializeObject(self, Coloque_Isso_Em_Um_Arquivo_Separado.Converter.Settings);

    }

​

    internal static class Converter

    {

        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings

        {

            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,

            DateParseHandling = DateParseHandling.None,

            Converters =

            {

                BPathConverter.Singleton,

                FPathConverter.Singleton,

                MPathConverter.Singleton,

                new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }

            },

        };

    }

​

    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 BPathConverter : JsonConverter

    {

        public override bool CanConvert(Type t) => t == typeof(BPath) || t == typeof(BPath?);

​

        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 "../php/":

                    return BPath.BPathPhp;

                case "php/":

                    return BPath.Php;

                case "php/reports/":

                    return BPath.PhpReports;

            }

            throw new Exception("Cannot unmarshal type BPath");

        }

​

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)

        {

            if (untypedValue == null)

            {

                serializer.Serialize(writer, null);

                return;

            }

            var value = (BPath)untypedValue;

            switch (value)

            {

                case BPath.BPathPhp:

                    serializer.Serialize(writer, "../php/");

                    return;

                case BPath.Php:

                    serializer.Serialize(writer, "php/");

                    return;

                case BPath.PhpReports:

                    serializer.Serialize(writer, "php/reports/");

                    return;

            }

            throw new Exception("Cannot marshal type BPath");

        }

​

        public static readonly BPathConverter Singleton = new BPathConverter();

    }

​

    internal class FPathConverter : JsonConverter

    {

        public override bool CanConvert(Type t) => t == typeof(FPath) || t == typeof(FPath?);

​

        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 "../js/mod/":

                    return FPath.JsMod;

                case "js/":

                    return FPath.Js;

                case "js/rpt/":

                    return FPath.JsRpt;

            }

            throw new Exception("Cannot unmarshal type FPath");

        }

​

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)

        {

            if (untypedValue == null)

            {

                serializer.Serialize(writer, null);

                return;

            }

            var value = (FPath)untypedValue;

            switch (value)

            {

                case FPath.JsMod:

                    serializer.Serialize(writer, "../js/mod/");

                    return;

                case FPath.Js:

                    serializer.Serialize(writer, "js/");

                    return;

                case FPath.JsRpt:

                    serializer.Serialize(writer, "js/rpt/");

                    return;

            }

            throw new Exception("Cannot marshal type FPath");

        }

​

        public static readonly FPathConverter Singleton = new FPathConverter();

    }

​

    internal class MPathConverter : JsonConverter

    {

        public override bool CanConvert(Type t) => t == typeof(MPath) || t == typeof(MPath?);

​

        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 "":

                    return MPath.Empty;

                case "Ghs.loc.adm":

                    return MPath.GhsLocAdm;

                case "Ghs.loc.reports":

                    return MPath.GhsLocReports;

            }

            throw new Exception("Cannot unmarshal type MPath");

        }

​

        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)

        {

            if (untypedValue == null)

            {

                serializer.Serialize(writer, null);

                return;

            }

            var value = (MPath)untypedValue;

            switch (value)

            {

                case MPath.Empty:

                    serializer.Serialize(writer, "");

                    return;

                case MPath.GhsLocAdm:

                    serializer.Serialize(writer, "Ghs.loc.adm");

                    return;

                case MPath.GhsLocReports:

                    serializer.Serialize(writer, "Ghs.loc.reports");

                    return;

            }

            throw new Exception("Cannot marshal type MPath");

        }

​

        public static readonly MPathConverter Singleton = new MPathConverter();

    }

}

​

​