private static void ErrorParse(IRestCallbackClient response, List <string> _errorData)
        {
            if (!response.Content.IsNullOrWhiteSpace())
            {
                var a = response.Content.FromJson <List <string> >();

                if (a.IsNull())
                {
                    var simpleString = response.Content.FromJson <ErrorWraper>();
                    if (!simpleString.IsNull() && !simpleString.Result)
                    {
                        _errorData.Add(simpleString.Error ?? simpleString.Data ?? response.Content);
                    }
                }
                else
                {
                    _errorData.AddRange(a);
                }
            }
        }
        public static T ExecuteRequest <T>(IRestCallbackClient response) where T : class, IResponseService, new()
        {
            var _errorData = new List <string>();


            try
            {
                CrossConnectivity.Current.ConnectivityChanged -= Current_ConnectivityChanged;
                CrossConnectivity.Current.ConnectivityChanged += Current_ConnectivityChanged;
            }
            catch
            {
            }

            var data = new T();

            data.Code = response.StatusCode;

            if (!string.IsNullOrEmpty(response.ErrorMessage) &&
                string.IsNullOrEmpty(response.Content))
            {
                if (!IsOnline())
                {
                    data.IsOnline        = false;
                    data.ErrorHttpClient = response.ErrorMessage;
                    data.LocalError      = Tuple.Create(ConfigResponse.Instance.ErrorNet, ErrorType.Net);
                    data.UIMessage       = data.LocalError.Item1;
                    return(data);
                }

                data.IsOnline        = true;
                data.Code            = response.StatusCode;
                data.ErrorHttpClient = response.ErrorMessage;

                ErrorParse(response, _errorData);
                data.ServerContent = Tuple.Create(response.Content, _errorData);
                data.LocalError    = Tuple.Create(ConfigResponse.Instance.ErrorServer, ErrorType.Server);
                data.UIMessage     = data.LocalError.Item1;

                return(data);
            }

            try
            {
                if (response.StatusCode <= 304 && string.IsNullOrWhiteSpace(response.Content))
                {
                    const string content = "Not Content";

                    ErrorParse(response, _errorData);

                    var results = new T
                    {
                        IsOnline        = true,
                        Code            = response.StatusCode,
                        ErrorHttpClient = response.ErrorMessage,
                        LocalError      = Tuple.Create(content, ErrorType.None),
                        ServerContent   = Tuple.Create(content, _errorData)
                    };

                    return(results);
                }

                var result = response.Content.FromJson <T>();

                if (result.IsNull())
                {
                    throw new Exception("Not Content");
                }

                ErrorParse(response, _errorData);


                result.IsOnline        = true;
                result.Code            = response.StatusCode;
                result.ETag            = response.ETag;
                result.ErrorHttpClient = response.ErrorMessage;
                result.ServerContent   = Tuple.Create(response.Content, _errorData);
                result.LocalError      = Tuple.Create(response.ErrorMessage, ErrorType.None);
                result.UIMessage       = result.LocalError.Item1;

                return(result);
            }
            catch
            {
                try
                {
                    var result = response.Content.FromJson <BaseMResponse <List <string> > >();
                    ErrorParse(response, _errorData);
                    data.IsOnline        = true;
                    data.ErrorHttpClient = response.ErrorMessage;
                    data.ServerContent   = Tuple.Create(response.Content, _errorData);
                    data.LocalError      = Tuple.Create(ConfigResponse.Instance.ErrorServer, ErrorType.Server);
                    data.UIMessage       = data.LocalError.Item1;

                    return(data);
                }
                catch
                {
                    data.IsOnline = true;
                    ErrorParse(response, _errorData);

                    data.ErrorHttpClient = response.ErrorMessage;
                    data.ServerContent   = Tuple.Create(response.Content, _errorData);
                    data.LocalError      = Tuple.Create(ConfigResponse.Instance.ErrorModel, ErrorType.Serialization);
                    data.UIMessage       = data.LocalError.Item1;

                    return(data);
                }
            }
        }