Masterarbeit/QuellCode/CentronERP/Centron.Api.docuFORM/DocuFormRestApiClient.cs

using Centron.Api.docuFORM.Helper;
using Centron.Api.docuFORM.Models;
using Centron.Api.docuFORM.Models.Swagger;
using Centron.Api.docuFORM.Models.Swagger.Responses;
using Centron.Core;
using Centron.Core.Extensions;
using Centron.Interfaces.BL;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Reflection;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Centron.Api.docuFORM
{
    public class DocuFormRestApiClient : IDocuFormApiClient, IDisposable
    {
        #region Fields
        private readonly HttpClient _httpClient;
        private bool _disposed = false;
        #endregion


        #region Ctor
        public DocuFormRestApiClient(string serverAddress)
        {
            try
            {
                var trimmedAddress = serverAddress.TrimEnd('/');
                var handler = new SocketsHttpHandler() { MaxConnectionsPerServer = 20 };
                this._httpClient = new HttpClient(handler) { BaseAddress = new Uri(trimmedAddress) };
                this._httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            }
            catch(Exception ex)
            {
                throw new Exception($"Fehler beim Initalisieren des HTTP-Clients für folgende Adresse \"{serverAddress}\"!{Environment.NewLine}{ex.Message}");
            }            
        }
        #endregion


        #region Methods        
        public async Task<string> RequestAuthorization(AuthCodeRequest authCodeRequest)
        {
            Guard.NotNull(authCodeRequest, nameof(authCodeRequest));

            var requestUrl = DocuFormRequestHelper.CreateAuthorizationRequestURI(authCodeRequest);

            var response = await this._httpClient.GetAsync(requestUrl);
            var contentString = await response.Content.ReadAsStringAsync();

            if (!response.IsSuccessStatusCode)
                throw new HttpRequestException($"Fehler während der Authorisierung bei docuFORM: {contentString}");

            return contentString;
        }  
        
        public async Task<AuthTokenResponse> RequestToken(AuthTokenRequest tokenRequest)
        {
             Guard.NotNull(tokenRequest, nameof(tokenRequest));

            var paremeters = DocuFormRequestHelper.RequestToParameters(tokenRequest);

            var request = new HttpRequestMessage(HttpMethod.Post, DocuFormRestApiConstants._endpointAuthToken)
            {
                Content = new FormUrlEncodedContent(paremeters) 
            };

            var response = await this._httpClient.SendAsync(request);
            var responseContentString = await response.ReadContentAndThrowIfError();
            
            var authToken = JsonSerializer.Deserialize<AuthTokenResponse>(responseContentString);

            if(authToken == null)
                throw new HttpRequestException($"No auth token was received!");

            return authToken;
        }  
        
        public async Task<Result<DevicesResponse>> GetAllDevices(string token)
        {
            var requestUri = DocuFormRestApiConstants._endpointDevices;
            var request = new HttpRequestMessage(HttpMethod.Get, requestUri);

            var response = await this._httpClient.SendRequestWithToken(request, token);                

            return await response.CheckResponseAndDeserializeContent<DevicesResponse>(); 
        }

        public async Task<Result<DeviceCountersResponse>> GetDeviceCounters(string token, int deviceId, DateTime? requestedDate = null)
        {
            var requestUri = DocuFormRestApiConstants._endpointDevices + $"/{deviceId}/counters";

            if (requestedDate.HasValue)
            {
                var utcDate = requestedDate.Value.ToUniversalTime();
                requestUri += $"?date={utcDate.ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture)}";
            }                

            var request = new HttpRequestMessage(HttpMethod.Get, requestUri);

            var response = await this._httpClient.SendRequestWithToken(request, token);                

            return await response.CheckResponseAndDeserializeContent<DeviceCountersResponse>(); 
        }
        #endregion


        #region IDisposable Support
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed && disposing)
            {
                _httpClient?.Dispose();
                _disposed = true;
            }
        }        
        #endregion
    }
}