Exemplo n.º 1
0
        internal static async Task <IResponse <Stream> > GetStreamResponseAsync(this HttpClient client, string path,
                                                                                MediaFormat mediaFormat)
        {
            try
            {
                using (var request = Helpers.HttpRequestHelper.CreateRequest(HttpMethod.Get, path))
                {
                    using (var response = await client.ExecuteRequestAsync(request, CancellationToken.None))
                    {
                        var status       = response.StatusCode;
                        var reasonPhrase = response.ReasonPhrase;
                        var contentType  = response.Content.Headers.ContentType;

                        if (contentType != null && response.IsInResponsibleFormat())
                        {
                            var resultObjectFromMultiPart = await response.Content.ReadAsMultipartAsync();

                            var messagesFromMultiPart =
                                await resultObjectFromMultiPart.Contents[0].ReadAsAsync <List <ServiceMessage> >();

                            Stream streamResult = null;
                            if (resultObjectFromMultiPart.Contents.Count > 1)
                            {
                                streamResult = await resultObjectFromMultiPart.Contents[1].ReadAsStreamAsync();
                            }

                            return(ResponseFactory <Stream> .Custom((ResponseStatus)status,
                                                                    messagesFromMultiPart.Select(m => m.Message).ToList(), streamResult));
                        }

                        if (response.IsSuccessStatusCode)
                        {
                            var resultObject = await response.Content.ReadAsStreamAsync();

                            return(ResponseFactory <Stream> .Custom((ResponseStatus)status, resultObject));
                        }

                        return(ResponseFactory <Stream> .Custom((ResponseStatus)status,
                                                                $"Status: {status} - ReasonPhrase: {reasonPhrase}"));
                    }
                }
            }
            catch (Exception ex)
            {
                if (ex is OperationCanceledException)
                {
                    return(ResponseFactory <Stream> .Exception(ex));
                }

                return(ResponseFactory <Stream> .Exception(ex,
                                                           new List <string> {
                    StaticResources.ExecutionFailureMessage, ex.Message
                }));
            }
        }
Exemplo n.º 2
0
        internal static async Task <IResponse> PrepareResponseAsync(this HttpResponseMessage response)
        {
            try
            {
                if (response == null)
                {
                    return(ResponseFactory.Error(
                               $"Specified {nameof(HttpResponseMessage)} is null, could not create {nameof(IResponse)}.",
                               ErrorResponseStatus.BadRequest));
                }

                var status       = response.StatusCode;
                var reasonPhrase = response.ReasonPhrase;
                var contentType  = response.Content.Headers.ContentType;

                if (contentType != null && response.IsInResponsibleFormat())
                {
                    var multiContent = await response.Content.ReadAsMultipartAsync();

                    var multiMessages = await multiContent.Contents[0].ReadAsAsync <List <ServiceMessage> >();

                    return(ResponseFactory.Custom((ResponseStatus)status,
                                                  multiMessages.Select(m => m.Message).ToList()));
                }

                var responseContent = await TryToCastResponseToAString(response);

                if (!string.IsNullOrWhiteSpace(responseContent))
                {
                    return(ResponseFactory.Custom((ResponseStatus)status, new List <string>
                    {
                        $"Status: {status} - ReasonPhrase: {reasonPhrase}",
                        $"{responseContent}"
                    }));
                }

                return(ResponseFactory.Custom((ResponseStatus)status,
                                              $"Status: {status} - ReasonPhrase: {reasonPhrase}"));
            }
            catch (Exception ex)
            {
                if (ex is OperationCanceledException)
                {
                    return(ResponseFactory.Exception(ex));
                }

                return(ResponseFactory.Exception(ex,
                                                 new List <string> {
                    StaticResources.ExecutionFailureMessage, ex.Message
                }));
            }
        }
Exemplo n.º 3
0
        internal static async Task <IResponse <T> > PrepareResponseAsync <T>(this HttpResponseMessage response)
        {
            try
            {
                if (response == null)
                {
                    return(ResponseFactory <T> .Error(
                               $"Specified {nameof(HttpResponseMessage)} is null, could not create {nameof(IResponse<T>)}.",
                               ErrorResponseStatus.BadRequest));
                }

                var status       = response.StatusCode;
                var reasonPhrase = response.ReasonPhrase;
                var contentType  = response.Content.Headers.ContentType;

                if (contentType != null && response.IsInResponsibleFormat())
                {
                    var resultObjectFromMultiPart = await response.Content.ReadAsMultipartAsync();

                    var messagesFromMultiPart =
                        await resultObjectFromMultiPart.Contents[0].ReadAsAsync <List <ServiceMessage> >();

                    var value = default(T);
                    if (resultObjectFromMultiPart.Contents.Count > 1)
                    {
                        value = await resultObjectFromMultiPart.Contents[1].ReadAsAsync <T>();
                    }

                    return(ResponseFactory <T> .Custom((ResponseStatus)status,
                                                       messagesFromMultiPart.Select(m => m.Message).ToList(), value));
                }

                if (response.IsSuccessStatusCode)
                {
                    var resultObject = await response.Content.ReadAsAsync <T>();

                    return(ResponseFactory <T> .Custom((ResponseStatus)status, resultObject));
                }

                var responseContent = await TryToCastResponseToAString(response);

                if (!string.IsNullOrWhiteSpace(responseContent))
                {
                    return(ResponseFactory <T> .Custom((ResponseStatus)status, new List <string>
                    {
                        $"Status: {status} - ReasonPhrase: {reasonPhrase}",
                        $"{responseContent}"
                    }));
                }

                return(ResponseFactory <T> .Custom((ResponseStatus)status,
                                                   $"Status: {status} - ReasonPhrase: {reasonPhrase}"));
            }
            catch (Exception ex)
            {
                return(ResponseFactory <T> .Exception(ex,
                                                      new List <string> {
                    StaticResources.ExecutionFailureMessage, ex.Message
                }));
            }
        }