private static async Task <Hashtable> ExecAsync(String method, String uri, Object data, String contentType)
            {
                Hashtable response;

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(API_BASE_URL + uri);

                request.Proxy.Credentials = CredentialCache.DefaultCredentials; //To bypass proxy

                request.UserAgent   = "MercadoPago .NET SDK v" + MercadoPago.version;
                request.Accept      = MIME_JSON;
                request.Method      = method;
                request.ContentType = contentType;
                await SetDataAsync(request, data, contentType);

                String responseBody = null;

                try
                {
                    HttpWebResponse apiResult = (HttpWebResponse)await request.GetResponseAsync();

                    responseBody = await new StreamReader(apiResult.GetResponseStream()).ReadToEndAsync();

                    response = new Hashtable
                    {
                        ["status"]   = (int)apiResult.StatusCode,
                        ["response"] = JSON.JsonDecode(responseBody)
                    };
                }
                catch (WebException e)
                {
                    Console.WriteLine(e.Message);
                    responseBody = await new StreamReader(e.Response.GetResponseStream()).ReadToEndAsync();
                    try
                    {
                        response = new Hashtable
                        {
                            ["status"]   = (int)((HttpWebResponse)e.Response).StatusCode,
                            ["response"] = JSON.JsonDecode(responseBody)
                        };
                    }
                    catch (Exception e2)
                    {
                        response = new Hashtable
                        {
                            ["status"]   = 500,
                            ["response"] = e2.Message
                        };
                    }
                }

                return(response);
            }
        public async Task <Hashtable> GetAuthorizedPaymentAsync(String id)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            Hashtable authorizedPaymentInfo = await RestClient.GetAsync("/authorized_payments/" + id + "?access_token=" + accessToken);

            return(authorizedPaymentInfo);
        }
        public async Task <Hashtable> GetPreapprovalPaymentAsync(String id)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            Hashtable preapprovalPaymentResult = await RestClient.GetAsync("/preapproval/" + id + "?access_token=" + accessToken);

            return(preapprovalPaymentResult);
        }
        public async Task <Hashtable> UpdatePreferenceAsync(String id, Hashtable preference)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            Hashtable preferenceResult = await RestClient.PutAsync("/checkout/preferences/" + id + "?access_token=" + accessToken, preference);

            return(preferenceResult);
        }
        public async Task <Hashtable> GetPaymentAsync(String id)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            String uriPrefix = this.sandbox ? "/sandbox" : "";

            Hashtable paymentInfo = await RestClient.GetAsync(uriPrefix + "/collections/notifications/" + id + "?access_token=" + accessToken);

            return(paymentInfo);
        }
        public async Task <Hashtable> GetMerchantOrderAsync(string merchantOrederId)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            String uriPrefix = this.sandbox ? "/sandbox" : "";

            Hashtable merchantOrderInfo = await RestClient.GetAsync(uriPrefix + "/merchant_orders/" + merchantOrederId + "?access_token=" + accessToken);

            return(merchantOrderInfo);
        }
        public async Task <Hashtable> CancelPreapprovalPaymentAsync(String id)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            Hashtable cancelStatus = new Hashtable
            {
                ["status"] = "cancelled"
            };

            Hashtable response = await RestClient.PutAsync("/preapproval/" + id + "?access_token=" + accessToken, cancelStatus);

            return(response);
        }
        public async Task <Hashtable> RefundPaymentAsync(String id)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            Hashtable refundStatus = new Hashtable
            {
                ["status"] = "refunded"
            };

            Hashtable response = await RestClient.PutAsync("/collections/" + id + "?access_token=" + accessToken, refundStatus);

            return(response);
        }
        public async Task <Hashtable> SearchPaymentAsync(Dictionary <String, String> filters, long offset = 0, long limit = 0)
        {
            String accessToken;

            try
            {
                accessToken = await this.GetAccessTokenAsync();
            }
            catch (Exception e)
            {
                return((Hashtable)JSON.JsonDecode(e.Message));
            }

            filters.Add("offset", offset.ToString());
            filters.Add("limit", limit.ToString());

            String filtersQuery = this.BuildQuery(filters);

            String uriPrefix = this.sandbox ? "/sandbox" : "";

            Hashtable collectionResult = await RestClient.GetAsync(uriPrefix + "/collections/search?" + filtersQuery + "&access_token=" + accessToken);

            return(collectionResult);
        }
 public async Task <Hashtable> PutAsync(String uri, String data, Dictionary <String, String> parameters) =>
 await this.PutAsync(uri, (Hashtable)JSON.JsonDecode(data), parameters);
 public async Task <Hashtable> CreatePreapprovalPaymentAsync(String preapprovalPayment) => await this.CreatePreapprovalPaymentAsync((Hashtable)JSON.JsonDecode(preapprovalPayment));
 public async Task <Hashtable> UpdatePreferenceAsync(String id, String preference) => await this.UpdatePreferenceAsync(id, (Hashtable)JSON.JsonDecode(preference));
 public async Task <Hashtable> CreatePreferenceAsync(String preference) => await this.CreatePreferenceAsync((Hashtable)JSON.JsonDecode(preference));