EVCB_OCPP.OCPPServer.16J/EVCB_OCPP.WSServer/Service/VendorIdReplaceService.cs

using EVCB_OCPP.Packet.Messages.Core;
using EVCB_OCPP.WSServer.Message;
using EVCB_OCPP.WSServer.Service.WsService;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EVCB_OCPP.WSServer.Service
{
    public static class VendorIdReplaceServiceExt
    {
        public static Task InitVendorIdReplaceService(this IHost host)
        {
            var server = host.Services.GetRequiredService<ProtalServer>();
            var vendorIdReplaceService = host.Services.GetRequiredService<VendorIdReplaceService>();
            server.InitActions.Add(vendorIdReplaceService.GetAndRecordVendorId);
            return host.Services.GetRequiredService<StationConfigService>().Init();
        }
    }

    internal class VendorIdReplaceService
    {
        public VendorIdReplaceService(
            ProtalServer protalServer
            , ServerMessageService messageService
            , ConfirmWaitingMessageSerevice confirmWaitingMessageSerevice
            , ILogger<VendorIdReplaceService> logger
            )
        {
            this.protalServer = protalServer;
            this.messageService = messageService;
            this.confirmWaitingMessageSerevice = confirmWaitingMessageSerevice;
            this.logger = logger;
        }


        private static string Session_VID_Key = "StationConfigService_Station";

        private readonly ProtalServer protalServer;
        private readonly ServerMessageService messageService;
        private readonly ConfirmWaitingMessageSerevice confirmWaitingMessageSerevice;
        private readonly ILogger<VendorIdReplaceService> logger;

        internal async Task GetAndRecordVendorId(WsClientData wsClient, CancellationToken token)
        {
            var getEvseCurrentConfigResponse = await GetEvseCurrentConfig(wsClient.ChargeBoxId, token);

            if (!getEvseCurrentConfigResponse.Success ||
                getEvseCurrentConfigResponse.Message is not GetConfigurationConfirmation confirmation)
            {
                logger.LogWarning("{chargeBoxId} get config from evse failed", wsClient.ChargeBoxId);
                return;
            }

            var vendorId = confirmation.configurationKey?.FirstOrDefault(x => x.key == "ChargePointVendorId");
            if (vendorId is null)
            {
                logger.LogWarning("{chargeBoxId} get vendorId from evse failed", wsClient.ChargeBoxId);
                return;
            }

            SetSessionVendorId(wsClient, vendorId.value);
        }


        private async Task<MessageResult> GetEvseCurrentConfig(string chargeBoxId, CancellationToken token = default)
        {
            var sendTask = async () => await messageService.SendGetEVSEConfigureRequest(chargeBoxId);
            var response = await confirmWaitingMessageSerevice.SendAndWaitUntilResultAsync(sendTask, token);
            return response;
        }

        private int? GetSessionVendorId(WsClientData session)
        {
            if (session is null ||
                !session.Data.ContainsKey(Session_VID_Key))
            {
                return null;
            }
            return (int?)session.Data[Session_VID_Key];
        }

        private void SetSessionVendorId(WsClientData session, string vid)
        {
            if (session is null)
            {
                return;
            }
            session.Data[Session_VID_Key] = vid;
        }
    }
}