laatzen/Common/LaaProduction/LaaProductionAPI.cs

namespace LaaProduction
{
    using Newtonsoft.Json;

    using System;
    using System.Collections.Generic;
    using System.Net.Http;
    using System.Net.Http.Headers;
    using System.Runtime.InteropServices;
    using System.Text;

    [ClassInterface(ClassInterfaceType.AutoDual)]
    public partial class LaaProductionAPI
    {
        private const string Bearer = nameof(Bearer);
        private const string RoutePrefix = "/LaaProductionWeb/API";

        private readonly HttpClient httpClient;

        private string bearer;

        public LaaProductionAPI()
        {
            this.httpClient = new HttpClient()
            {
                BaseAddress = new Uri("http://sla12iis01.emea.sensus.net")
                //BaseAddress = new Uri("http://localhost:59768")
            };
        }

        public string Login(string assembly, int majorV, int minorV, int buildV, string username, string password)
        {
            var data = new LoginModel
            {
                Assembly = assembly,
                MajorV = majorV,
                MinorV = minorV,
                BuildV = buildV,
                Username = username,
                Password = password.ComputeBase64Hash()
            };

            if (!data.TryValidate(out string errors))
            {
                return errors;
            }

            var error = default(Error);

            try
            {
                using (var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, new Uri($"{RoutePrefix}/Login/Local", UriKind.Relative)))
                {
                    httpRequestMessage.Content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");

                    var httpResponseMessage = this.httpClient
                        .SendAsync(httpRequestMessage)
                        .ConfigureAwait(true)
                        .GetAwaiter()
                        .GetResult();

                    if (httpResponseMessage?.Content != null)
                    {
                        using (httpResponseMessage)
                        {
                            var responseContent = httpResponseMessage
                                .Content
                                .ReadAsStringAsync()
                                .ConfigureAwait(true)
                                .GetAwaiter()
                                .GetResult();

                            try
                            {
                                if (!httpResponseMessage.IsSuccessStatusCode)
                                {
                                    error = JsonConvert.DeserializeObject<Error>(responseContent);
                                }
                                else
                                {
                                    this.bearer = JsonConvert.DeserializeObject<string>(responseContent);
                                }
                            }
                            catch (Exception e)
                            {
                                error.Message = e.Message;
                                error.MessageDetail = e.StackTrace;
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                return $"{e.Message}{Environment.NewLine}{e.StackTrace}";
            }

            if (string.IsNullOrWhiteSpace(this.bearer))
            {
                return "Invalid login attempt at '~/LaaProductionWeb/API/Login/Local'!";
            }
            else if (error != null)
            {
                return error.ToString();
            }


            return default(string);
        }

        public EquipmentsResult GetPendingInspections()
        {
            var result = new EquipmentsResult();

            try
            {
                var uri = new Uri($"{RoutePrefix}/Personalization/Software/PendingInspections", UriKind.Relative);

                using (var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri))
                {
                    httpRequestMessage
                        .Headers
                        .Authorization = new AuthenticationHeaderValue(Bearer, this.bearer);

                    var httpResponseMessage = this.httpClient
                        .SendAsync(httpRequestMessage)
                        .ConfigureAwait(true)
                        .GetAwaiter()
                        .GetResult();

                    if (httpResponseMessage?.Content != null)
                    {
                        using (httpResponseMessage)
                        {
                            var responseContent = httpResponseMessage
                                .Content
                                .ReadAsStringAsync()
                                .ConfigureAwait(true)
                                .GetAwaiter()
                                .GetResult();

                            try
                            {
                                if (!httpResponseMessage.IsSuccessStatusCode)
                                {
                                    result.Error = JsonConvert.DeserializeObject<Error>(responseContent);
                                }
                                else
                                {
                                    var pendingInspections = JsonConvert.DeserializeObject<IEnumerable<Equipment>>(responseContent);

                                    result.AddRange(pendingInspections);
                                }
                            }
                            catch (Exception e)
                            {
                                httpResponseMessage.Dispose();
                                httpRequestMessage.Dispose();

                                result.Error = new Error
                                {
                                    Message = e.Message,
                                    MessageDetail = e.StackTrace
                                };
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                result.Error = new Error
                {
                    Message = e.Message,
                    MessageDetail = e.StackTrace
                };
            }

            return result;
        }

        public Error TryRequestQAP(int auftragNr, int positionNr)
        {
            try
            {
                var uri = new Uri($"{RoutePrefix}/Production/VFM/QAPReady/{auftragNr}/{positionNr}", UriKind.Relative);

                using (var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri))
                {
                    httpRequestMessage
                        .Headers
                        .Authorization = new AuthenticationHeaderValue(Bearer, this.bearer);

                    var httpResponseMessage = this.httpClient
                        .SendAsync(httpRequestMessage)
                        .ConfigureAwait(true)
                        .GetAwaiter()
                        .GetResult();

                    using (httpResponseMessage)
                    {
                        if (httpResponseMessage.IsSuccessStatusCode == false)
                        {
                            var responseContent = httpResponseMessage
                                .Content
                                .ReadAsStringAsync()
                                .ConfigureAwait(true)
                                .GetAwaiter()
                                .GetResult();

                            return JsonConvert.DeserializeObject<Error>(responseContent);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                return new Error
                {
                    Message = e.Message,
                    MessageDetail = e.StackTrace
                };
            }

            return default(Error);
        }
    }
}