EVCB_OCPP.OCPPServer.16J/EVCB_OCPP.WSServer/Service/BusinessService/OuterBusinessService.cs

using EVCB_OCPP.Domain;
using EVCB_OCPP.Domain.Models.MainDb;
using EVCB_OCPP.Packet.Messages.SubTypes;
using EVCB_OCPP.WSServer.Dto;
using EVCB_OCPP.WSServer.Service.DbService;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace EVCB_OCPP.WSServer.Service.BusinessService
{
    internal class CPOOuterResponse
    {
        public CPOOuterResponse()
        {
            StatusCode = 0;

        }

        public int StatusCode { set; get; }

        public string StatusMessage { set; get; }

        public string Data { set; get; }

        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
        public string SerialNo { set; get; }


        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
        public string ErrorDetail { set; get; }


    }
    internal class CustomerSignMaterial
    {
        internal bool CallsThirdParty { set; get; }

        internal string Id { set; get; }

        internal string APIUrl { set; get; }

        internal string SaltKey { set; get; }

        internal bool InstantStopTxReport { set; get; }
    }
    public class OuterBusinessService : IBusinessService
    {

        private readonly ILogger<OuterBusinessService> logger;
        private readonly IDbContextFactory<MainDBContext> maindbContextFactory;
        private readonly IMainDbService mainDbService;
        private readonly OuterHttpClient httpClient;

        private string _CustomerId = string.Empty;
        private CustomerSignMaterial signMaterial = null;

        public string CustomerId
        {
            get => _CustomerId;
            set
            {
                _CustomerId = value;
                signMaterial = GetSign(_CustomerId).Result;
            }
        }

        internal CustomerSignMaterial CustomerSignMaterial
        {
            get => signMaterial;
            set
            {
                signMaterial = value;
                _CustomerId = signMaterial.Id;
            }
        }

        public OuterBusinessService(
            ILogger<OuterBusinessService> logger,
            IDbContextFactory<MainDBContext> maindbContextFactory,
            IMainDbService mainDbService,
            OuterHttpClient httpClient)
        {
            this.logger = logger;
            this.maindbContextFactory = maindbContextFactory;
            this.mainDbService = mainDbService;
            this.httpClient = httpClient;
        }


        async public Task<IdTokenInfo> Authorize(string chargeBoxId, string idTag, int? connectorId = null, string source = null)
        {
            //return new IdTokenInfo() { IdTagInfo = new IdTagInfo()
            //{
            //    expiryDate = DateTime.UtcNow.AddDays(1),
            //    status = AuthorizationStatus.Accepted 
            //} };

            //await Task.Delay(10);
            IdTokenInfo result = new IdTokenInfo() { IdTagInfo = new IdTagInfo() { status = AuthorizationStatus.Invalid } };

            try
            {
                logger.LogInformation(chargeBoxId + " Charging Monitor======================================>");

                string requestParams = idTag.StartsWith("vid:") ? await GetRequestParamsAsPnC(chargeBoxId, idTag, connectorId, source) : GetRequestParamsAsNormal(chargeBoxId, idTag, source);
                logger.LogInformation($"{chargeBoxId} Authorize : {signMaterial.APIUrl + requestParams}");
                HttpResult response = await httpClient.Post(signMaterial.APIUrl + requestParams, new Dictionary<string, string>()
                            {
                                { "PartnerId",signMaterial.Id}
                            }, requestBody: null, saltkey: signMaterial.SaltKey).ConfigureAwait(false);
                logger.LogInformation($"{chargeBoxId} response : {JsonConvert.SerializeObject(response)}");

                if (response.Success)
                {
                    //Console.WriteLine(response.Response);
                    var _httpResult = JsonConvert.DeserializeObject<CPOOuterResponse>(response.Response);
                    JObject jo = JObject.Parse(_httpResult.Data);

                    if (jo.ContainsKey("ExpiryDate"))
                    {
                        DateTime dt = jo["ExpiryDate"].Value<DateTime>();
                        result.IdTagInfo.expiryDate = dt;
                    }

                    if (jo.ContainsKey("ParentIdTag"))
                    {
                        string _Message = jo["ParentIdTag"].Value<string>();
                        result.IdTagInfo.parentIdTag = _Message;

                    }

                    if (jo.ContainsKey("ChargePointFee"))
                    {


                        for (int i = 0; i < jo["ChargePointFee"].Count(); i++)
                        {
                            if (i == 0)
                            {
                                result.ChargePointFee = new List<ChargePointFee>();
                            }
                            result.ChargePointFee.Add(jo["ChargePointFee"][i].ToObject<ChargePointFee>());
                        }

                    }

                    if (jo.ContainsKey("ChargepointFee"))
                    {

                        for (int i = 0; i < jo["ChargepointFee"].Count(); i++)
                        {
                            if (i == 0)
                            {
                                result.ChargePointFee = new List<ChargePointFee>();
                            }

                            result.ChargePointFee.Add(jo["ChargepointFee"][i].ToObject<ChargePointFee>());
                        }

                    }

                    if (jo.ContainsKey("AccountBalance"))
                    {
                        decimal accountBalance = jo["AccountBalance"].Value<decimal>();
                        result.AccountBalance = accountBalance;
                    }


                    if (jo.ContainsKey("Status"))
                    {
                        string _Message = jo["Status"].Value<string>();
                        result.IdTagInfo.status = (AuthorizationStatus)Enum.Parse(typeof(AuthorizationStatus), _Message);
                    }
                }
                else
                {
                    logger.LogError(chargeBoxId + " OuterBusinessService.Authorize Fail: " + response.Response);
                }

            }
            catch (Exception ex)
            {
                result.IdTagInfo.status = AuthorizationStatus.Invalid;

                logger.LogError(chargeBoxId + " OuterBusinessService.Authorize Ex: " + ex.ToString());
            }

            return result;

        }

        async public Task NotifyFaultStatus(ErrorDetails details)
        {

            try
            {
                if (signMaterial.CallsThirdParty)
                {
                    var response = await httpClient.Post(signMaterial.APIUrl + "connectorfault", new Dictionary<string, string>()
                            {
                                { "PartnerId",signMaterial.Id}

                            }, details, signMaterial.SaltKey).ConfigureAwait(false);
                }
            }
            catch (Exception ex)
            {

                logger.LogError(details.ChargeBoxId + " OuterBusinessService.NotifyFaultStatus Ex: " + ex.ToString());
            }


        }

        async public Task NotifyConnectorUnplugged(string chargeBoxId, string data)
        {
            try
            {
                JObject jo = JObject.Parse(data);

                var details = new { ChargeBoxId = chargeBoxId, SessionId = jo["idTx"].Value<int>(), Timestamp = jo["timestamp"].Value<DateTime>() };
                if (signMaterial.CallsThirdParty)
                {
                    var response = await httpClient.Post(signMaterial.APIUrl + "connectorunplugged", new Dictionary<string, string>()
                            {
                                { "PartnerId",signMaterial.Id}

                            }, details, signMaterial.SaltKey).ConfigureAwait(false);


                }


            }
            catch (Exception ex)
            {

                logger.LogError(chargeBoxId + " OuterBusinessService.NotifyConnectorUnplugged Ex: " + ex.ToString());
            }

        }

        private async Task<CustomerSignMaterial> GetSign(string customerId)
        {
            Guid Id = new Guid(customerId);
            CustomerSignMaterial _customer = new CustomerSignMaterial();


            //using (var db = new MainDBContext())
            //using (var db = maindbContextFactory.CreateDbContextAsync())
            //{
            //    _customer = await db.Customer.Where(x => x.Id == Id).Select(x => new CustomerSignMaterial() { Id = x.Id.ToString(), APIUrl = x.ApiUrl, SaltKey = x.ApiKey, CallsThirdParty = x.CallPartnerApiOnSchedule }).FirstOrDefaultAsync();
            //}
            var _customerDb = await mainDbService.GetCustomer(Id);
            if (_customerDb is not null)
            {
                _customer.Id = _customerDb.Id.ToString();
                _customer.APIUrl = _customerDb.ApiUrl;
                _customer.SaltKey = _customerDb.ApiKey;
                _customer.CallsThirdParty = _customerDb.CallPartnerApiOnSchedule;
            }
            return _customer;
        }

        private async ValueTask<string> GetRequestParamsAsPnC(string chargeBoxId, string idTag, int? connectorId, string source)
        {
            idTag = idTag.Replace("vid:", "");

            if (connectorId is null)
            {
                using (var db = await maindbContextFactory.CreateDbContextAsync())
                {
                    var connectorStatuses = await db.ConnectorStatus.Where(x => x.ChargeBoxId == chargeBoxId).
                         Select(x => new { x.ConnectorId, x.Status, x.CreatedOn }).ToListAsync();

                    var connectorStatus = connectorStatuses.Where(x => x.Status == 2).OrderByDescending(x => x.CreatedOn).FirstOrDefault();
                    if (connectorStatus != null)
                    {
                        connectorId = connectorStatus.ConnectorId;
                    }
                }

                if (connectorId is null)
                {
                    connectorId = -1;
                }
            }
            var requestParamString = string.Format("charging_auth?ChargeBoxId={0}&ConnectorId={1}&IdTag={2}", chargeBoxId, connectorId, idTag);
            if (!string.IsNullOrEmpty(source))
            {
                requestParamString += $"&Action={source}";
            }
            return requestParamString;
        }

        private string GetRequestParamsAsNormal(string chargeBoxId, string idTag, string source)
        {
            var requestParamString = string.Format("charging_auth?ChargeBoxId={0}&IdTag={1}", chargeBoxId, idTag);
            if (!string.IsNullOrEmpty(source))
            {
                requestParamString += $"&Action={source}";
            }
            return requestParamString;
        }

        public Task NotifyConnectorUnplugged(string data)
        {
            throw new NotImplementedException();
        }

        public async ValueTask<NotifyTransactionCompletedResult> NotifyTransactionCompleted(TransactionRecord tx, Dictionary<string, decimal> roundedPeriodEnergy = null)
        {
            if (signMaterial == null || !signMaterial.InstantStopTxReport)
            {
                return null;
            }

            var toReturn = new NotifyTransactionCompletedResult();

            //var PeriodEnergy = await mainDbService.GetTransactionPeriodEnergy(tx.Id);

            var request = new
            {
                ChargeBoxId = tx.ChargeBoxId,
                ConnectorId = tx.ConnectorId,
                SessionId = tx.Id,
                MeterStart = tx.MeterStart,
                MeterStop = tx.MeterStop,
                IdTag = tx.StartIdTag,
                StartTime = tx.StartTime.ToString(GlobalConfig.UTC_DATETIMEFORMAT),
                StopTime = tx.StopTime.ToString(GlobalConfig.UTC_DATETIMEFORMAT),
                StopReason = tx.StopReasonId < 1 ? "Unknown" : (tx.StopReasonId > 12 ? "Unknown" : ((Reason)tx.StopReasonId).ToString()),
                Receipt = tx.Receipt,
                TotalCost = tx.Cost,
                Fee = tx.Fee,
                PeriodEnergy = roundedPeriodEnergy,
                StartSOC = int.TryParse(tx.StartSoc, out int StartSOCint) ? StartSOCint : (int?)null,
                StopSOC = int.TryParse(tx.StopSoc, out int StopSOCint) ? StopSOCint : (int?)null

            };

            logger.LogDebug("completed_session " + JsonConvert.SerializeObject(request, GlobalConfig.JSONSERIALIZER_FORMAT));
            var response = await httpClient.Post(
                signMaterial.APIUrl + "completed_session", 
                new Dictionary<string, string>()
                {
                    { "PartnerId", CustomerId}
                }, 
                request,
                signMaterial.SaltKey);

            logger.LogDebug("completed_session Response" + response.Response);

            if (!response.Success)
            {
                toReturn.ErrorMsg = !string.IsNullOrEmpty(response.Response) ? response.Response : response.StatusCode.ToString();
                return toReturn;
            }

            if (!string.IsNullOrEmpty(response.Response))
            {
                var _httpResult = JsonConvert.DeserializeObject<CPOOuterResponse>(response.Response);
                logger.LogDebug("completed_session Response" + response.Response);
                JObject jo = JObject.Parse(_httpResult.Data);
                if (jo.ContainsKey("CouponPoint"))
                {
                    toReturn.CouponPoint = jo["CouponPoint"].Value<Decimal>();
                }

                if (jo.ContainsKey("FarewellMessage"))
                {
                    toReturn.FarewellMessage = jo["FarewellMessage"].Value<string>();
                }
            }

            return toReturn;
        }
    }
}