Esempio n. 1
0
        public async Task <Object> SendHttpHeadRequest()
        {
            try
            {
                HttpRequestMessage.Method = HttpMethod.Head;
                System.Uri Uri = null;
                System.Uri.TryCreate(BaseAppConstants.BaseUrl + RequestUri, UriKind.Relative, out Uri);

                HttpRequestMessage.RequestUri = Uri;

                HttpResponseMessage = await Client.SendAsync(HttpRequestMessage);

                if (HttpResponseMessage != null)
                {
                    HttpContent = await HttpResponseMessage.Content.ReadAsStringAsync();

                    if (!HttpResponseMessage.IsSuccessStatusCode)
                    {
                        var result = await HttpResponseMessage.Content.ReadAsStringAsync();

                        string message = "";
                        if (!string.IsNullOrEmpty(result))
                        {
                            var responseOutput = JObject.Parse(result);
                            message = (string)responseOutput["Message"];
                        }

                        UnSuccessfullStatusCodeException ex = new UnSuccessfullStatusCodeException(message);
                        ex.StatusCode = (int)HttpResponseMessage.StatusCode;
                        throw ex;
                    }
                }
            }
            catch (UnSuccessfullStatusCodeException e1)
            {
                Client.Dispose();
                throw e1;
            }

            catch (HttpRequestException e2)
            {
                Client.Dispose();

                throw new Exception(e2.Message);
            }

            catch (TaskCanceledException e3)
            {
                Client.Dispose();
                throw e3;
            }
            catch (Exception e4)
            {
                Client.Dispose();
                throw e4;
            }

            return(HttpResponseMessage.StatusCode);
        }
Esempio n. 2
0
        public async Task SendHttpGetRequest()
        {
            try
            {
                HttpRequestMessage.Method = HttpMethod.Get;

                HttpResponseMessage = await Client.GetAsync(BaseAppConstants.BaseUrl + RequestUri);

                if (HttpResponseMessage != null)
                {
                    HttpContent = await HttpResponseMessage.Content.ReadAsStringAsync();

                    if (!HttpResponseMessage.IsSuccessStatusCode)
                    {
                        var result = await HttpResponseMessage.Content.ReadAsStringAsync();

                        var responseOutput = JObject.Parse(result);
                        var message        = (string)responseOutput["Message"];
                        UnSuccessfullStatusCodeException ex = new UnSuccessfullStatusCodeException(message);
                        ex.StatusCode = (int)HttpResponseMessage.StatusCode;
                        throw ex;
                    }
                }
            }
            catch (UnSuccessfullStatusCodeException ex)
            {
                Client.Dispose();
                throw ex;
            }

            catch (HttpRequestException ex)
            {
                Client.Dispose();

                throw new Exception(ex.Message);
            }

            catch (TaskCanceledException ex)
            {
                Client.Dispose();
                throw ex;
            }
            catch (Exception e)
            {
                Client.Dispose();
                throw e;
            }
        }
Esempio n. 3
0
        public async Task <object> SendHttpPutRequest()
        {
            try
            {
                HttpRequestMessage.Method = HttpMethod.Put;

                HttpResponseMessage = await Client.PutAsync(BaseAppConstants.BaseUrl + RequestUri, new StringContent(HttpContent, Encoding.UTF8, "application/json"));

                if (HttpResponseMessage != null)
                {
                    HttpContent = await HttpResponseMessage.Content.ReadAsStringAsync();

                    if (!HttpResponseMessage.IsSuccessStatusCode)
                    {
                        var result = await HttpResponseMessage.Content.ReadAsStringAsync();

                        var responseOutput = JObject.Parse(result);
                        var message        = (string)responseOutput["Message"];
                        UnSuccessfullStatusCodeException ex = new UnSuccessfullStatusCodeException(message);
                        ex.StatusCode = (int)HttpResponseMessage.StatusCode;
                        throw ex;
                    }
                }
            }
            catch (UnSuccessfullStatusCodeException ex)
            {
                Client.Dispose();
                throw ex;
            }
            catch (Exception e)
            {
                Client.Dispose();
                if (e.Message == BaseAppConstants.NoInternetConnSystemMessage)
                {
                    UnSuccessfullStatusCodeException exception = new UnSuccessfullStatusCodeException(BaseAppConstants.NoInternetConnUserMessage);
                    exception.StatusCode = BaseAppConstants.NoInternetConnStatusCode;
                    throw exception;
                }
                else
                {
                    throw e;
                }
            }

            return(HttpResponseMessage);
        }
Esempio n. 4
0
        public async Task <Object> SendHttpPostRequest()
        {
            try
            {
                Client.CancelPendingRequests();

                HttpResponseMessage = await Client.PostAsync(BaseAppConstants.BaseUrl + RequestUri
                                                             ,
                                                             new StringContent(HttpContent,
                                                                               Encoding.UTF8,
                                                                               "application/json"));

                if (HttpResponseMessage != null)
                {
                    HttpContent = await HttpResponseMessage.Content.ReadAsStringAsync();

                    if (!HttpResponseMessage.IsSuccessStatusCode)
                    {
                        var result = await HttpResponseMessage.Content.ReadAsStringAsync();

                        var responseOutput = JObject.Parse(result);
                        var message        = (string)responseOutput["Message"];
                        UnSuccessfullStatusCodeException ex = new UnSuccessfullStatusCodeException(message);
                        ex.StatusCode = (int)HttpResponseMessage.StatusCode;
                        throw ex;
                    }
                }
            }
            catch (UnSuccessfullStatusCodeException ex)
            {
                Client.Dispose();
                throw ex;
            }
            catch (Exception e)
            {
                Client.Dispose();
                throw e;
            }


            return(HttpResponseMessage);
        }