D365 – Finance and Operations: OData Integration

				
					using Common.Connectors.FoServiceClient.ConnectorSettings;
using Common.Connectors.FoServiceClient.Entities;
using Common.Exceptions;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Net.Http;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Common.Connectors.FoServiceClient.Services;
using WorkOrder.D365FS.Out.D365FO.Connector.ExternalAccess.Interfaces;
using Microsoft.Extensions.Caching.Memory;
using Serilog;

namespace WorkOrder.D365FS.Out.D365FO.Connector.Services
{
    public class FoServiceClient : IFoServiceClient
    {
        private readonly FoServiceClientSettings foServiceClientSettings;
        private readonly IMemoryCache cache;
        private const string TOKENNAME = "D365TOKEN";
        private readonly Httpclient client;


        public FoServiceClient(IOptions<Settings> options, IMemoryCache memoryCache)
        {
            this.foServiceClientSettings = options.Value.FoServiceClientSettings;
            cache = this.foServiceClientSettings.UseAccesTokenCache ? memoryCache : null;
            client = this.CreateClient(this.foServiceClientSettings.EnvironmentUrl)
        }
              
        /// <summary>
        /// Get entity
        /// </summary>
        /// <typeparam name="T">Generic parameter</typeparam>
        /// <param name="requestUri">Request Uri</param>
        /// <returns>Type that is defined for generic T </returns>
        public async Task<T> GetEntity<T>(string requestUri) where T : class
        {
            Log.Information($"Getting {typeof(T)} entites from Finance and Operations.");
            var oDataResponse = await this.SendRequestList<T>(requestUri, HttpMethod.Get)
                .ConfigureAwait(false);

            if (oDataResponse.Value.Any())
            {
                if(oDataResponse.Value.Count > 1)
                {
                    throw new UnrecoverableArgumentException($"The Expected output of the odata response was more then 1, output records:{oDataResponse.Value.Count}");
                }
                else
                {
                    return oDataResponse.Value.First();
                }             
            }
            else
            {
                return new T();
            }
        }
              
        private async Task<OdataResponseList<T>> SendRequest<T>(string requestUri, HttpMethod httpMethod, T body = null) where T : class
        {
                var accessToken = await FetchToken();
                var request = new HttpRequestMessage(httpMethod, requestUri);
                request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);

                if (HttpMethod.Post == httpMethod || HttpMethod.Patch == httpMethod)
                {
                    request.Headers.Add("Prefer", "return=representation");
                    request.Content = new StringContent(
                        JsonConvert.SerializeObject(body),
                        Encoding.UTF8,
                        "application/json");
                }

                var response = client.SendAsync(request).Result;
                try
                {
                    switch (response.StatusCode)
                    {
                        case HttpStatusCode.OK:
                        case HttpStatusCode.Created:
                            Log.Information($"Fo web api responded with status code {response.StatusCode} and reason pharse {response.ReasonPhrase}.");
                            var ODataResponseFo = JsonConvert.DeserializeObject<OdataResponseList<T>>(await response.Content.ReadAsStringAsync());
                            if (ODataResponseFo.Value is null)
                            {
                                ODataResponseFo.Value = JsonConvert.DeserializeObject<List<T>>(await response.Content.ReadAsStringAsync());
                            }
                            return ODataResponseFo;
                            
                        case HttpStatusCode.TooManyRequests:
                            Log.Information($"Fo web api responded with status code {response.StatusCode} and reason pharse {response.ReasonPhrase}.");
                            var deltaInSeconds = response.Headers.RetryAfter.Delta ?? throw new Exception();

                            Log.Information($"Fo web api server is busy, waiting for {deltaInSeconds} seconds to send a new request.");
                            await Task.Delay(deltaInSeconds);
                            return await SendRequestList<T>(requestUri, httpMethod, body);

                        default:
                            var detailedErrorMessage = response.Content.ReadAsStringAsync().Result;
                            if (detailedErrorMessage.Contains("0x80043b06", StringComparison.OrdinalIgnoreCase))
                            {
                                throw new UnrecoverableException($"Datverse responded for {typeof(T)} with status code: {response.StatusCode} and reason pharse: {response.ReasonPhrase}, detailed error message {detailedErrorMessage}");
                            }
                            else
                            {
                                throw new InvalidOperationException($"Datverse responded for {typeof(T)} with status code: {response.StatusCode} and reason pharse: {response.ReasonPhrase}, detailed error message {detailedErrorMessage}");
                            }
                    }
                }
                catch (Exception ex)
                {

                    throw new UnrecoverableException($"Datverse responded for {typeof(T)} with status code: {ex} and reason pharse: {response.ReasonPhrase}, detailed error message ");
                }            
        }

        private HttpClient CreateClient(string resourceUri)
        {
            var zeroHours = 0;
            var zeroSeconds = 0;

            var client = new HttpClient
            {
                BaseAddress = new Uri(resourceUri),
                Timeout = new TimeSpan(
                    zeroHours,
                    foServiceClientSettings.TimeoutInMinutes,
                    zeroSeconds)
            };

            client.DefaultRequestHeaders.Add("OData-MaxVersion", "4.0");
            client.DefaultRequestHeaders.Add("OData-Version", "4.0");
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            return client;
        }

        /// <summary>
        /// Fetching token with caching
        /// </summary>
        /// <returns>Return the token</returns>
        private async Task<string> FetchToken()
        {
            string accesToken;

            if (cache != null)
            {
                if (!cache.TryGetValue(TOKENNAME, out accesToken))
                {
                    var tokenResult = await OAuthAccessToken.GetTokenAsync(foServiceClientSettings);

                    var options = new MemoryCacheEntryOptions()
                        .SetAbsoluteExpiration(tokenResult.ExpiresOn);
                    cache.Set(TOKENNAME, tokenResult.AccessToken, options);
                    accesToken = tokenResult.AccessToken;
                }
            }
            else
            {
                var tokenResult = await OAuthAccessToken.GetTokenAsync(foServiceClientSettings);
                accesToken = tokenResult.AccessToken;
            }
            return accesToken;
        }
    }
}