EVCB_OCPP.OCPPServer.16J/EVCB_OCPP.WSServer/ProtalServer.cs

using EVCB_OCPP.Packet.Features;
using EVCB_OCPP.Packet.Messages;
using EVCB_OCPP.Packet.Messages.Basic;
using EVCB_OCPP.Packet.Messages.Core;
using EVCB_OCPP.WSServer.Dto;
using EVCB_OCPP.WSServer.Helper;
using EVCB_OCPP.WSServer.Message;
using EVCB_OCPP.WSServer.Service;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json;

using OCPPServer.Protocol;
using OCPPServer.SubProtocol;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Config;
using System.Data;
using System.Diagnostics;
using System.Security.Authentication;
using System.Xml.Linq;
using NLog;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Builder;
using NLog.Extensions.Logging;
using System.Collections.Concurrent;
using EVCB_OCPP.WSServer.SuperSocket;
using Microsoft.Extensions.Logging;
using System.Net.WebSockets;
using SuperWebSocket;
using System.Net;
using System.Text;

namespace EVCB_OCPP.WSServer
{
    public class DestroyRequest : IRequest
    {
        public string Action { get; set; }

        public bool TransactionRelated()
        {
            return false;
        }

        public bool Validate()
        {
            return true;
        }
    }

    public class ProtalServer : IHostedService
    {
        //static private ILogger logger = NLog.LogManager.GetCurrentClassLogger();

        public ProtalServer(
            ILogger<ProtalServer> logger
            , IConfiguration configuration
            , IMainDbService mainDbService
            , IOCPPWSServerFactory ocppWSServerFactory
            , IConnectionLogdbService connectionLogdbService
            , LoadingBalanceService loadingBalanceService
            , ServerMessageService serverMessageService
            , WebDbService webDbService
            , ProfileHandler profileHandler
            , WebsocketService<WsClientData> websocketService
            , OuterHttpClient httpClient)
        {
            this.logger = logger;
            this.configuration = configuration;
            this.mainDbService = mainDbService;
            this.ocppWSServerFactory = ocppWSServerFactory;
            this.connectionLogdbService = connectionLogdbService;
            this.webDbService = webDbService;
            this.httpClient = httpClient;
            isInDocker = !string.IsNullOrEmpty(configuration["DOTNET_RUNNING_IN_CONTAINER"]);

            this.profileHandler = profileHandler;// new ProfileHandler(configuration, serviceProvider);
            this.websocketService = websocketService;
            this._loadingBalanceService = loadingBalanceService;// new LoadingBalanceService(mainDbConnectionFactory, webDbConnectionFactory);
            this.messageService = serverMessageService;
            WarmUpLog();
        }

        #region private fields
        private OuterHttpClient httpClient;
        private DateTime lastcheckdt = DateTime.UtcNow.AddSeconds(-20);
        private ConcurrentDictionary<string, WsClientData> clientDic = new ConcurrentDictionary<string, WsClientData>();
        //private readonly Object _lockClientDic = new object();
        private readonly Object _lockConfirmPacketList = new object();
        private readonly ILogger<ProtalServer> logger;
        private readonly IConfiguration configuration;
        private readonly IMainDbService mainDbService;

        private readonly IOCPPWSServerFactory ocppWSServerFactory;
        private readonly IConnectionLogdbService connectionLogdbService;
        private readonly WebDbService webDbService;
        private readonly ProfileHandler profileHandler;
        private readonly WebsocketService<WsClientData> websocketService;
        private readonly bool isInDocker;
        private List<NeedConfirmMessage> needConfirmPacketList = new List<NeedConfirmMessage>();
        private DateTime checkUpdateDt = DateTime.UtcNow;
        private DateTime _CheckFeeDt = DateTime.UtcNow;
        private DateTime _CheckLBDt = DateTime.UtcNow;
        private DateTime _CheckDenyListDt = DateTime.UtcNow.AddDays(-1);
        private readonly LoadingBalanceService _loadingBalanceService;// = new LoadingBalanceService();
        private readonly ServerMessageService messageService;
        private List<StationInfoDto> _StationInfo = new List<StationInfoDto>();

        private readonly List<string> needConfirmActions = new List<string>()
        {
             "GetConfiguration",
             "ChangeConfiguration",
             "RemoteStartTransaction",
             "RemoteStopTransaction",
             "ChangeAvailability",
             "ClearCache",
             "DataTransfer",
             "Reset",
             "UnlockConnector",
             "TriggerMessage",
             "GetDiagnostics",
             "UpdateFirmware",
             "GetLocalListVersion",
             "SendLocalList",
             "SetChargingProfile",
             "ClearChargingProfile",
             "GetCompositeSchedule",
             "ReserveNow",
             "CancelReservation",
             "ExtendedTriggerMessage"
        };
        private readonly List<Profile> profiles = new List<Profile>()
        {
             new CoreProfile(),
             new FirmwareManagementProfile(),
             new ReservationProfile(),
             new RemoteTriggerProfile(),
             new SmartChargingProfile(),
             new LocalAuthListManagementProfile(),
             new SecurityProfile(),
        };

        #endregion

        private OCPPWSServer appServer;
        private WebApplication appApi;
        private WebApplication yarpApp;

        internal Dictionary<string, WsClientData> GetClientDic()
        {
            Dictionary<string, WsClientData> toReturn = null;
            toReturn = new Dictionary<string, WsClientData>(clientDic);
            return toReturn;
        }

        internal List<NeedConfirmMessage> GetResendMessage()
        {
            List<NeedConfirmMessage> sendMessages = new List<NeedConfirmMessage>();
            lock (_lockConfirmPacketList)
            {
                sendMessages = needConfirmPacketList.Where(x => x.SentTimes > 1 && x.CreatedBy == "Server").ToList();

            }

            return sendMessages;
        }

        internal IReadOnlyList<Profile> Profiles => profiles.AsReadOnly();
        internal LoadingBalanceService LoadingBalanceService => _loadingBalanceService;
        internal ProfileHandler ProfileHandler => profileHandler;

        public async Task StartAsync(CancellationToken cancellationToken)
        {
            GlobalConfig.DenyModelNames = await webDbService.GetDenyModelNames();
            Start();
            return;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return Stop();
            //return Task.CompletedTask;
        }

        internal void UpdateClientDisplayPrice(string key,string price)
        {
            clientDic[key].DisplayPrice = price;
        }

        internal void SendMsg(WsClientData session, string msg, string messageType, string errorMsg = "")
        {
            Send(session,msg,messageType,errorMsg);
        }

        internal void Start()
        {
            logger.LogTrace("Starting Server...");

            if (!GlobalConfig.LoadAPPConfig(configuration))
            {
                logger.LogError("Please check App.Config setting .");
                return;
            }
            
            StartWsService();

            if (!isInDocker)
            {
                Task consoleReadTask = new Task(RunConsoleInteractive);
                consoleReadTask.Start();
                //RunConsoleInteractive();
                return;
            }
            return;
        }

        private void RunConsoleInteractive()
        {
            while (true)
            {
                if (Console.In is null)
                {
                    break;
                }

                var input = Console.ReadLine();

                switch (input.ToLower())
                {
                    case "stop":
                        Console.WriteLine("Command stop");
                        Stop();
                        break;

                    case "gc":
                        Console.WriteLine("Command GC");
                        GC.Collect();
                        break;
                    case "lc":
                        {
                            Console.WriteLine("Command List Clients");
                            Dictionary<string, WsClientData> _copyClientDic = null;
                            _copyClientDic = new Dictionary<string, WsClientData>(clientDic);
                            var list = _copyClientDic.Select(c => c.Value).ToList();
                            int i = 1;
                            foreach (var c in list)
                            {
                                Console.WriteLine(i + ":" + c.ChargeBoxId + " " + c.SessionID);
                                i++;
                            }
                        }
                        break;
                    case "lcn":
                        {
                            Console.WriteLine("Command List Customer Name");
                            Dictionary<string, WsClientData> _copyClientDic = null;
                            _copyClientDic = new Dictionary<string, WsClientData>(clientDic);
                            var lcn = clientDic.Select(c => c.Value.CustomerName).Distinct().ToList();
                            int iLcn = 1;
                            foreach (var c in lcn)
                            {
                                Console.WriteLine(iLcn + ":" + c + ":" + clientDic.Where(z => z.Value.CustomerName == c).Count().ToString());
                                iLcn++;
                            }

                        }
                        break;
                    case "help":
                        Console.WriteLine("Command help!!");
                        Console.WriteLine("lcn : List Customer Name");
                        Console.WriteLine("gc : GC Collect");
                        Console.WriteLine("lc : List Clients");
                        Console.WriteLine("cls : clear console");
                        Console.WriteLine("silent : silent");
                        Console.WriteLine("show : show log");
                        // logger.Info("rcl : show Real Connection Limit");
                        break;
                    case "cls":
                        Console.WriteLine("Command clear");
                        Console.Clear();
                        break;

                    case "silent":
                        Console.WriteLine("Command silent");
                        //var xe = XElement.Load("NLog.config");
                        //var xns = xe.GetDefaultNamespace();
                        //var minlevelattr = xe.Descendants(xns + "rules").Elements(xns + "logger")
                        //    .Where(c => c.Attribute("writeTo").Value.Equals("console")).Attributes("minlevel").FirstOrDefault();
                        //if (minlevelattr != null)
                        //{

                        //    minlevelattr.Value = "Warn";
                        //}
                        //xe.Save("NLog.config");
                        foreach (var rule in LogManager.Configuration.LoggingRules)
                        {
                            if (rule.RuleName != "ConsoleLog")
                            {
                                continue;
                            }

                            var isTargetRule = rule.Targets.Any(x => x.Name.ToLower() == "console");

                            if (isTargetRule)
                            {
                                rule.SetLoggingLevels(NLog.LogLevel.Warn, NLog.LogLevel.Off);
                            }
                        }
                        break;
                    case "show":
                        Console.WriteLine("Command show");
                        //var xe1 = XElement.Load("NLog.config");
                        //var xns1 = xe1.GetDefaultNamespace();
                        //var minlevelattr1 = xe1.Descendants(xns1 + "rules").Elements(xns1 + "logger")
                        //    .Where(c => c.Attribute("writeTo").Value.Equals("console")).Attributes("minlevel").FirstOrDefault();
                        //if (minlevelattr1 != null)
                        //{

                        //    minlevelattr1.Value = "trace";
                        //}
                        //xe1.Save("NLog.config");
                        foreach (var rule in LogManager.Configuration.LoggingRules)
                        {
                            if (rule.RuleName != "ConsoleLog")
                            {
                                continue;
                            }

                            var isTargetRule = rule.Targets.Any(x => x.Name.ToLower() == "console");

                            if (isTargetRule)
                            {
                                rule.SetLoggingLevels(NLog.LogLevel.Trace, NLog.LogLevel.Off);
                            }
                        }
                        break;
                    case "rcl":
                        break;
                    default:
                        break;
                }
            }
        }

        internal Task Stop()
        {
            appServer?.Stop();
            return Task.WhenAll(new []{ 
                appApi?.StopAsync(),
                yarpApp?.StopAsync() 
            });
        }

        private void StartWsService()
        {

            //載入OCPP Protocol
            //appServer = ocppWSServerFactory.Create(new List<OCPPSubProtocol>() { new OCPPSubProtocol(), new OCPPSubProtocol(" ocpp1.6"), new OCPPSubProtocol("ocpp2.0") });
            //var appServer = new OCPPWSServer(new List<OCPPSubProtocol>() { new OCPPSubProtocol(), new OCPPSubProtocol(" ocpp1.6"), new OCPPSubProtocol("ocpp2.0") });

            //List<IListenerConfig> llistener = new List<IListenerConfig>();

            //if (GlobalConfig.GetWS_Port() != 0)
            //{
            //    llistener.Add(new ListenerConfig { Ip = System.Net.IPAddress.Any.ToString(), Port = GlobalConfig.GetWS_Port(), Backlog = 100, Security = "None" });
            //}

            //foreach (var securityport in GlobalConfig.GetWSS_Ports())
            //{
            //    llistener.Add(new ListenerConfig { Ip = System.Net.IPAddress.Any.ToString(), Port = securityport, Backlog = 100, Security = SslProtocols.Tls12.ToString() });
            //}

            //var config = ConfigurationManager.GetSection("superSocket") as IConfigurationSource;\
            //var certificate = configuration.GetSection("superSocket").GetSection("Servers:0").GetSection("Certificate").Get<CertificateConfig>();
            //var certificate = configuration.GetSection("SuperSocketServerCertificate").Get<CertificateConfig>();
            //ICertificateConfig Certificate = certificate;
            //IEnumerable<IListenerConfig> listeners = llistener;

            //設定server config
            var serverConfig = new ServerConfig
            {
                SendingQueueSize = 10,
                //Port = Convert.ToInt32(2012),
                //Ip = "172.17.40.13",
                MaxRequestLength = 204800,
                //Security = serverSecurity,
                //Certificate = Certificate,
                //Listeners = listeners,
                //  LogAllSocketException = true,
                KeepAliveTime = 10,
                // LogBasicSessionActivity = true
                //Security = "None"
            };

            //Setup with listening port
            //if (!appServer.Setup(serverConfig, logFactory: new NLogLoggerFactory()))
            //{
            //    //Console.WriteLine("Failed to setup!");
            //    logger.LogCritical("Failed to setup!");
            //    return;
            //}

            websocketService.ValidateHandshake = WebsocketServiceValidateHandshake;
            websocketService.NewSessionConnected += AppServer_NewSessionConnected;
            websocketService.SessionClosed += AppServer_SessionClosed;


            //Try to start the appServer
            if (!appServer.Start())
            {
                logger.LogCritical("Failed to start!");
                //Console.ReadKey();
                return;
            }
        }

        private async Task<bool> WebsocketServiceValidateHandshake(WsClientData session)
        {
            session.ISOCPP20 = session.SecWebSocketProtocol.ToLower().Contains("ocpp2.0");

            int securityProfile = 0;
            string authorizationKey = string.Empty;
            if (string.IsNullOrEmpty(session.Path))
            {
                //logger.Log();
                logger.LogWarning("===========================================");
                logger.LogWarning("session.Path EMPTY");
                logger.LogWarning("===========================================");
            }

            string[] words = session.Path.ToString().Split('/');
            session.ChargeBoxId = words.Last();

            foreach (var denyModel in GlobalConfig.DenyModelNames)
            {
                if (string.IsNullOrEmpty(denyModel))
                {
                    continue;
                }

                if (session.ChargeBoxId.StartsWith(denyModel))
                {

                    StringBuilder responseBuilder = new StringBuilder();

                    responseBuilder.AppendFormatWithCrCf(@"HTTP/{0} {1} {2}", "1.1",
                    (int)HttpStatusCode.Unauthorized, @"Unauthorized");

                    responseBuilder.AppendWithCrCf();
                    string sb = responseBuilder.ToString();
                    byte[] data = Encoding.UTF8.GetBytes(sb);

                    ((IWebSocketSession)session).SendRawData(data, 0, data.Length);
                    logger.LogTrace(sb);
                    return false;
                }
            }

            if (configuration["MaintainMode"] == "1")
            {
                session.ChargeBoxId = session.ChargeBoxId + "_2";
            }

            logger.LogInformation(string.Format("ValidateHandshake: {0}", session.Path));
            bool isExistedSN = false;
            bool authorizated = false;

            var info = mainDbService.GetMachineIdAndCustomerInfo(session.ChargeBoxId).Result;
            //var machine = db.Machine.Where(x => x.ChargeBoxId == session.ChargeBoxId && x.IsDelete == false).Select(x => new { x.CustomerId, x.Id }).AsNoTracking().FirstOrDefault();
            //session.CustomerName = machine == null ? "Unknown" : db.Customer.Where(x => x.Id == machine.CustomerId).Select(x => x.Name).FirstOrDefault();
            //session.CustomerId = machine == null ? Guid.Empty : machine.CustomerId;
            //session.MachineId = machine == null ? String.Empty : machine.Id;
            //isExistedSN = machine == null ? false : true;
            session.CustomerName = info.CustomerName;
            session.CustomerId = info.CustomerId;
            session.MachineId = info.MachineId;
            isExistedSN = !string.IsNullOrEmpty(info.MachineId);// machine == null ? false : true;

            if (!isExistedSN)
            {
                StringBuilder responseBuilder = new StringBuilder();

                responseBuilder.AppendFormatWithCrCf(@"HTTP/{0} {1} {2}", "1.1",
                (int)HttpStatusCode.NotFound, @"Not Found");

                responseBuilder.AppendWithCrCf();
                string sb = responseBuilder.ToString();
                byte[] data = Encoding.UTF8.GetBytes(sb);
                ((IWebSocketSession)session).SendRawData(data, 0, data.Length);

                logger.LogInformation(sb);
                return false;
            }

            //var configVaule = db.MachineConfigurations.Where(x => x.ChargeBoxId == session.ChargeBoxId && x.ConfigureName == StandardConfiguration.SecurityProfile)
            //                  .Select(x => x.ConfigureSetting).FirstOrDefault();
            var configVaule = mainDbService.GetMachineSecurityProfile(session.ChargeBoxId).Result;
            int.TryParse(configVaule, out securityProfile);

            if (session.ISOCPP20)
            {
                // 1.6 server only support change server  function
                securityProfile = 0;
            }

            if (securityProfile == 3 && session.UriScheme == "ws")
            {
                StringBuilder responseBuilder = new StringBuilder();

                responseBuilder.AppendFormatWithCrCf(@"HTTP/{0} {1} {2}", "1.1",
                (int)HttpStatusCode.Unauthorized, @"Unauthorized");

                responseBuilder.AppendWithCrCf();
                string sb = responseBuilder.ToString();
                byte[] data = Encoding.UTF8.GetBytes(sb);

                ((IWebSocketSession)session).SendRawData(data, 0, data.Length);
                logger.LogInformation(sb);
                return false;
            }

            if (securityProfile == 1 || securityProfile == 2)
            {
                if (securityProfile == 2 && session.UriScheme == "ws")
                {
                    authorizated = false;
                }

                //if (session.Items.ContainsKey("Authorization") || session.Items.ContainsKey("authorization"))
                if (!string.IsNullOrEmpty(session.AuthHeader))
                {
                    //authorizationKey = db.MachineConfigurations.Where(x => x.ChargeBoxId == session.ChargeBoxId && x.ConfigureName == StandardConfiguration.AuthorizationKey)
                    //                    .Select(x => x.ConfigureSetting).FirstOrDefault();
                    authorizationKey = await mainDbService.GetMachineAuthorizationKey(session.ChargeBoxId);

                    if (session.ISOCPP20)
                    {
                        // 1.6 server only support change server  function
                        securityProfile = 0;
                    }

                    logger.LogInformation("***********Authorization   ");

                    if (!string.IsNullOrEmpty(authorizationKey))
                    {
                        //string base64Encoded = session.Items.ContainsKey("Authorization") ? session.Items["Authorization"].ToString().Replace("Basic ", "") : session.Items["authorization"].ToString().Replace("Basic ", "");
                        string base64Encoded = session.AuthHeader.Replace("Basic ", "");
                        byte[] data = Convert.FromBase64String(base64Encoded);
                        string[] base64Decoded = Encoding.ASCII.GetString(data).Split(':');
                        logger.LogInformation("***********Authorization   " + Encoding.ASCII.GetString(data));
                        if (base64Decoded.Count() == 2 && base64Decoded[0] == session.ChargeBoxId && base64Decoded[1] == authorizationKey)
                        {
                            authorizated = true;
                        }
                    }





                }
                else
                {
                    authorizated = true;

                }



                if (!authorizated)
                {
                    StringBuilder responseBuilder = new StringBuilder();

                    responseBuilder.AppendFormatWithCrCf(@"HTTP/{0} {1} {2}", "1.1",
                    (int)HttpStatusCode.Unauthorized, @"Unauthorized");

                    responseBuilder.AppendWithCrCf();
                    string sb = responseBuilder.ToString();
                    byte[] data = Encoding.UTF8.GetBytes(sb);

                    ((IWebSocketSession)session).SendRawData(data, 0, data.Length);
                    logger.LogInformation(sb);
                    return false;
                }
            }





            logger.LogInformation(string.Format("ValidateHandshake PASS: {0}", session.Path));
            return true;
        }

        private async void AppServer_NewSessionConnected(object sender, WsClientData session)
        {
            logger.LogDebug(string.Format("{0} NewSessionConnected", session.Path));

            try
            {
                bool isNotSupported = session.SecWebSocketProtocol.Contains("ocpp1.6") ? false : session.SecWebSocketProtocol.Contains("ocpp2.0") ? false : true;
                if (isNotSupported)
                {
                    //logger.LogDebug(string.Format("ChargeBoxId:{0} SecWebSocketProtocol:{1} NotSupported", session.ChargeBoxId, session.SecWebSocketProtocol));
                    WriteMachineLog(session, string.Format("SecWebSocketProtocol:{0} NotSupported", session.SecWebSocketProtocol), "Connection", "");
                    return;
                }

                TryRemoveDuplicatedSession(session);
                clientDic[session.ChargeBoxId] = session;

                session.m_ReceiveData += ReceivedMessageTimeLimited;
                // logger.LogDebug("------------New " + (session == null ? "Oops" : session.ChargeBoxId));
                WriteMachineLog(session, "NewSessionConnected", "Connection", "");

                await mainDbService.UpdateMachineConnectionType(session.ChargeBoxId, session.Origin.Contains("https") ? 2 : 1);

            }
            catch (Exception ex)
            {
                logger.LogError(string.Format("NewSessionConnected Ex: {0}", ex.ToString()));
            }
        }

        private void AppServer_SessionClosed(object sender, WsClientData session)
        {
            CloseReason value = CloseReason.ServerShutdown;
            WriteMachineLog(session, string.Format("CloseReason: {0}", value), "Connection", "");
            RemoveClient(session);
        }

        private void TryRemoveDuplicatedSession(WsClientData session)
        {
            if (clientDic.ContainsKey(session.ChargeBoxId))
            {
                var oldSession = clientDic[session.ChargeBoxId];
                WriteMachineLog(oldSession, "Duplicate Logins", "Connection", "");
                oldSession.Close(CloseReason.ServerShutdown);
                RemoveClient(oldSession);
            }
        }

        async private void ReceivedMessageTimeLimited(WsClientData session, string rawdata)
        {
            CancellationTokenSource tokenSource = new();
            var task = ReceivedMessage(session, rawdata);
            var completedTask = await Task.WhenAny(task, Task.Delay(90_000, tokenSource.Token));

            if (completedTask != task)
            {
                logger.LogCritical("Process timeout: {0} ", rawdata);
                await task;
                return;
            }

            tokenSource.Cancel();
            return;
        }

        async private Task ReceivedMessage(WsClientData session, string rawdata)
        {
            try
            {
                BasicMessageHandler msgAnalyser = new BasicMessageHandler();
                MessageResult analysisResult = msgAnalyser.AnalysisReceiveData(session, rawdata);

                WriteMachineLog(session, rawdata,
                     string.Format("{0} {1}", string.IsNullOrEmpty(analysisResult.Action) ? "unknown" : analysisResult.Action, analysisResult.Id == 2 ? "Request" : (analysisResult.Id == 3 ? "Confirmation" : "Error")), analysisResult.Exception == null ? "" : analysisResult.Exception.Message);

                if (session.ResetSecurityProfile)
                {
                    logger.LogError(string.Format("[{0}] ChargeBoxId:{1} ResetSecurityProfile", DateTime.UtcNow, session.ChargeBoxId));
                    RemoveClient(session);
                    return;
                }


                if (!analysisResult.Success)
                {
                    //解析RawData就發生錯誤
                    if (!string.IsNullOrEmpty(analysisResult.CallErrorMsg))
                    {
                        Send(session, analysisResult.CallErrorMsg, string.Format("{0} {1}", analysisResult.Action, "Error"));
                    }
                    else
                    {
                        if (analysisResult.Message == null)
                        {
                            string replyMsg = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                            string errorMsg = string.Empty;
                            if (analysisResult.Exception != null)
                            {
                                errorMsg = analysisResult.Exception.ToString();
                            }

                            Send(session, replyMsg, string.Format("{0} {1}", "unknown", "Error"), "EVSE's sent essage has parsed Failed. ");
                        }
                        else
                        {
                            BaseMessage _baseMsg = analysisResult.Message as BaseMessage;


                            string replyMsg = BasicMessageHandler.GenerateCallError(_baseMsg.Id, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                            string errorMsg = string.Empty;
                            if (analysisResult.Exception != null)
                            {
                                errorMsg = analysisResult.Exception.ToString();
                            }

                            Send(session, replyMsg, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
                        }

                    }
                }
                else
                {
                    switch (analysisResult.Id)
                    {
                        case BasicMessageHandler.TYPENUMBER_CALL:
                            {
                                if (!session.ISOCPP20)
                                {
                                    Actions action = Convertor.GetAction(analysisResult.Action);
                                    try
                                    {
                                        await ProcessRequestMessage(analysisResult, session, action);
                                    }
                                    catch (Exception e)
                                    {
                                        logger.LogError($"Processing {action} exception!");
                                        throw;
                                    }
                                }
                                else
                                {
                                    EVCB_OCPP20.Packet.Features.Actions action = Convertor.GetActionby20(analysisResult.Action);
                                    MessageResult result = new MessageResult() { Success = true };
                                    //ocpp20 處理
                                    switch (action)
                                    {

                                        case EVCB_OCPP20.Packet.Features.Actions.BootNotification:
                                            {
                                                EVCB_OCPP20.Packet.Messages.BootNotificationRequest _request = (EVCB_OCPP20.Packet.Messages.IRequest)analysisResult.Message as EVCB_OCPP20.Packet.Messages.BootNotificationRequest;

                                                var confirm = new EVCB_OCPP20.Packet.Messages.BootNotificationResponse() { CurrentTime = DateTime.UtcNow, Interval = 180, Status = EVCB_OCPP20.Packet.DataTypes.EnumTypes.RegistrationStatusEnumType.Pending };

                                                result.Message = confirm;
                                                result.Success = true;

                                                string response = BasicMessageHandler.GenerateConfirmationofOCPP20(analysisResult.UUID, (EVCB_OCPP20.Packet.Messages.IConfirmation)result.Message);
                                                Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Response"), result.Exception == null ? string.Empty : result.Exception.ToString());


                                                var request = new EVCB_OCPP20.Packet.Messages.SetNetworkProfileRequest()
                                                {
                                                    ConfigurationSlot = 1,
                                                    ConnectionData = new EVCB_OCPP20.Packet.DataTypes.NetworkConnectionProfileType()
                                                    {
                                                        OcppVersion = EVCB_OCPP20.Packet.DataTypes.EnumTypes.OCPPVersionEnumType.OCPP20,
                                                        OcppTransport = EVCB_OCPP20.Packet.DataTypes.EnumTypes.OCPPTransportEnumType.JSON,
                                                        MessageTimeout = 30,
                                                        OcppCsmsUrl = session.UriScheme == "ws" ? GlobalConfig.OCPP20_WSUrl : GlobalConfig.OCPP20_WSSUrl,
                                                        OcppInterface = EVCB_OCPP20.Packet.DataTypes.EnumTypes.OCPPInterfaceEnumType.Wired0
                                                    }

                                                };
                                                var uuid = session.queue20.store(request);
                                                string requestText = BasicMessageHandler.GenerateRequestofOCPP20(uuid, "SetNetworkProfile", request);
                                                Send(session, requestText, "SetNetworkProfile");

                                            }
                                            break;
                                        default:
                                            {
                                                logger.LogError(string.Format("We don't implement messagetype:{0} of raw data :{1} by {2}", analysisResult.Id, rawdata, session.ChargeBoxId));
                                            }
                                            break;
                                    }

                                }
                            }
                            break;
                        case BasicMessageHandler.TYPENUMBER_CALLRESULT:
                            {
                                if (!session.ISOCPP20)
                                {
                                    Actions action = Convertor.GetAction(analysisResult.Action);
                                    ProcessConfirmationMessage(analysisResult, session, action);
                                }
                                else
                                {
                                    EVCB_OCPP20.Packet.Features.Actions action = Convertor.GetActionby20(analysisResult.Action);
                                    MessageResult result = new MessageResult() { Success = true };
                                    //ocpp20 處理
                                    switch (action)
                                    {

                                        case EVCB_OCPP20.Packet.Features.Actions.SetNetworkProfile:
                                            {
                                                EVCB_OCPP20.Packet.Messages.SetNetworkProfileResponse response = (EVCB_OCPP20.Packet.Messages.IConfirmation)analysisResult.Message as EVCB_OCPP20.Packet.Messages.SetNetworkProfileResponse;

                                                if (response.Status == EVCB_OCPP20.Packet.DataTypes.EnumTypes.SetNetworkProfileStatusEnumType.Accepted)
                                                {
                                                    var request = new EVCB_OCPP20.Packet.Messages.SetVariablesRequest()
                                                    {
                                                        SetVariableData = new List<EVCB_OCPP20.Packet.DataTypes.SetVariableDataType>()
                                                         {
                                                              new EVCB_OCPP20.Packet.DataTypes.SetVariableDataType()
                                                              {
                                                                    Component=new EVCB_OCPP20.Packet.DataTypes.ComponentType()
                                                                    {
                                                                         Name="OCPPCommCtrlr",

                                                                    },
                                                                     AttributeType= EVCB_OCPP20.Packet.DataTypes.EnumTypes.AttributeEnumType.Actual,
                                                                     AttributeValue= JsonConvert.SerializeObject(new List<int>(){ 1 }),
                                                                     Variable=new EVCB_OCPP20.Packet.DataTypes.VariableType()
                                                                    {
                                                                            Name="NetworkConfigurationPriority",

                                                                    }


                                                              }
                                                         }

                                                    };
                                                    var uuid = session.queue20.store(request);
                                                    string requestText = BasicMessageHandler.GenerateRequestofOCPP20(uuid, "SetVariables", request);
                                                    Send(session, requestText, "SetVariables");
                                                }

                                            }
                                            break;
                                        case EVCB_OCPP20.Packet.Features.Actions.SetVariables:
                                            {
                                                EVCB_OCPP20.Packet.Messages.SetVariablesResponse response = (EVCB_OCPP20.Packet.Messages.IConfirmation)analysisResult.Message as EVCB_OCPP20.Packet.Messages.SetVariablesResponse;

                                                if (response.SetVariableResult[0].AttributeStatus == EVCB_OCPP20.Packet.DataTypes.EnumTypes.SetVariableStatusEnumType.RebootRequired)
                                                {
                                                    var request = new EVCB_OCPP20.Packet.Messages.ResetRequest()
                                                    {
                                                        Type = EVCB_OCPP20.Packet.DataTypes.EnumTypes.ResetEnumType.OnIdle

                                                    };
                                                    var uuid = session.queue20.store(request);
                                                    string requestText = BasicMessageHandler.GenerateRequestofOCPP20(uuid, "Reset", request);
                                                    Send(session, requestText, "Reset");

                                                }
                                            }
                                            break;
                                        default:
                                            {
                                                logger.LogError(string.Format("We don't implement messagetype:{0} of raw data :{1} by {2}", analysisResult.Id, rawdata, session.ChargeBoxId));
                                            }
                                            break;
                                    }
                                }

                            }
                            break;
                        case BasicMessageHandler.TYPENUMBER_CALLERROR:
                            {
                                //只處理 丟出Request 收到Error的訊息                              
                                if (analysisResult.Success && analysisResult.Message != null)
                                {
                                    Actions action = Convertor.GetAction(analysisResult.Action);
                                    ProcessErrorMessage(analysisResult, session, action);
                                }

                            }
                            break;
                        default:
                            {
                                logger.LogError(string.Format("Can't analyze messagetype:{0} of raw data :{1} by {2}", analysisResult.Id, rawdata, session.ChargeBoxId));
                            }
                            break;

                    }
                }

                await Task.Delay(10);
            }
            catch (Exception ex)
            {


                if (ex.InnerException != null)
                {
                    logger.LogError(string.Format("{0} **Inner Exception :{1} ", session.ChargeBoxId + rawdata, ex.ToString()));


                }
                else
                {
                    logger.LogError(string.Format("{0} **Exception :{1} ", session.ChargeBoxId, ex.ToString()));
                }
            }
        }

        private async Task ProcessRequestMessage(MessageResult analysisResult, WsClientData session, Actions action)
        {
            Stopwatch outter_stopwatch = Stopwatch.StartNew();
            //BasicMessageHandler msgAnalyser = new BasicMessageHandler();
            if (!session.IsCheckIn && action != Actions.BootNotification)
            {
                string response = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.GenericError, OCPPErrorDescription.NotChecked);
                Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Error"));
                return;
            }

            var profileName = profiles.Where(x => x.IsExisted(analysisResult.Action)).Select(x => x.Name).FirstOrDefault();
            switch (profileName)
            {
                case "Core":
                    {
                        var replyResult = await profileHandler.ExecuteCoreRequest(action, session, (IRequest)analysisResult.Message).ConfigureAwait(false);

                        var sendTimer = Stopwatch.StartNew();
                        if (replyResult.Success)
                        {
                            string response = BasicMessageHandler.GenerateConfirmation(analysisResult.UUID, (IConfirmation)replyResult.Message);

                            Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Confirmation"), replyResult.Exception is null ? string.Empty : replyResult.Exception.ToString());

                            if (action == Actions.BootNotification 
                                && replyResult.Message is BootNotificationConfirmation bootNotificationConfirmation)
                            {
                                if (bootNotificationConfirmation.status == Packet.Messages.SubTypes.RegistrationStatus.Accepted)
                                {
                                    session.IsCheckIn = true;

                                    await messageService.SendGetEVSEConfigureRequest(session.ChargeBoxId);

                                    await messageService.SendChangeConfigurationRequest(
                                        session.ChargeBoxId, key: "TimeOffset", value: "+08:00");
                                }
                                else
                                {
                                    bool? isAC = await mainDbService.GetChargeBoxIdIsAc(session.ChargeBoxId);
                                    if (isAC is not null)
                                    {
                                        session.IsAC = isAC.Value;
                                    }

                                    await mainDbService.UpdateMachineConnectionType(session.ChargeBoxId, session.Origin.Contains("https") ? 2 : 1);
                                    await webDbService.SetDefaultFee(session);
                                }
                            }

                            if (action == Actions.Authorize && replyResult.Message is AuthorizeConfirmation)
                            {
                                var authorizeRequest = (IRequest)analysisResult.Message as AuthorizeRequest;
                                if (session.UserDisplayPrices.ContainsKey(authorizeRequest.idTag))
                                {
                                    await messageService.SendDataTransferRequest(
                                        session.ChargeBoxId,
                                        messageId: "SetUserPrice",
                                        vendorId:"Phihong Technology",
                                        data: JsonConvert.SerializeObject(
                                            new
                                            {
                                                idToken = authorizeRequest.idTag,
                                                price = session.UserDisplayPrices[authorizeRequest.idTag]
                                            })
                                        );
                                }
                            }

                        }
                        else
                        {
                            if (action == Actions.StopTransaction && replyResult.CallErrorMsg == "Reject Response Message")
                            {
                                //do nothing 
                            }
                            else
                            {
                                string response = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                                string errorMsg = replyResult.Exception != null ? replyResult.Exception.ToString() : string.Empty;

                                Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
                            }
                        }
                        sendTimer.Stop();
                        if(sendTimer.ElapsedMilliseconds/1000 > 1)
                        {
                            logger.LogCritical("ProcessRequestMessage Send Cost {time} sec", sendTimer.ElapsedMilliseconds / 1000);
                        }

                        if (action == Actions.StartTransaction)
                        {
                            var stationId = await _loadingBalanceService.GetStationIdByMachineId(session.MachineId);
                            var _powerDic = await _loadingBalanceService.GetSettingPower(stationId);
                            if (_powerDic != null)
                            {
                                foreach (var kv in _powerDic)
                                {
                                    try
                                    {
                                        if (kv.Value.HasValue)
                                        {
                                            profileHandler.SetChargingProfile(kv.Key, kv.Value.Value, Packet.Messages.SubTypes.ChargingRateUnitType.W);
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        logger.LogError(string.Format("Set Profile Exception: {0}", ex.ToString()));
                                    }

                                }
                            }
                        }

                        if (action == Actions.StopTransaction)
                        {
                            var stationId = await _loadingBalanceService.GetStationIdByMachineId(session.MachineId);
                            var _powerDic = await _loadingBalanceService.GetSettingPower(stationId);
                            if (_powerDic != null)
                            {
                                foreach (var kv in _powerDic)
                                {
                                    try
                                    {
                                        if (kv.Value.HasValue)
                                        {
                                            profileHandler.SetChargingProfile(kv.Key, kv.Value.Value, Packet.Messages.SubTypes.ChargingRateUnitType.W);
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        logger.LogError(string.Format("Set Profile Exception: {0}", ex.ToString()));
                                    }
                                }
                            }
                        }

                    }
                    break;
                case "FirmwareManagement":
                    {
                        var replyResult = await profileHandler.ExecuteFirmwareManagementRequest(action, session, (IRequest)analysisResult.Message);
                        if (replyResult.Success)
                        {
                            string response = BasicMessageHandler.GenerateConfirmation(analysisResult.UUID, (IConfirmation)replyResult.Message);
                            Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Confirmation", replyResult.Exception == null ? string.Empty : replyResult.Exception.ToString()));

                        }
                        else
                        {
                            string response = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                            string errorMsg = replyResult.Exception != null ? replyResult.Exception.ToString() : string.Empty;

                            Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
                        }

                    }
                    break;
                case "Security":
                    {
                        var replyResult = profileHandler.ExecuteSecurityRequest(action, session, (IRequest)analysisResult.Message);
                        if (replyResult.Success)
                        {
                            string response = BasicMessageHandler.GenerateConfirmation(analysisResult.UUID, (IConfirmation)replyResult.Message);
                            Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Confirmation", replyResult.Exception == null ? string.Empty : replyResult.Exception.ToString()));

                        }
                        else
                        {
                            string response = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                            string errorMsg = replyResult.Exception != null ? replyResult.Exception.ToString() : string.Empty;

                            Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
                        }
                    }
                    break;
                default:
                    {
                        string replyMsg = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                        string errorMsg = string.Format("Couldn't find action name: {0} of profile", action);
                        Send(session, replyMsg, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
                    }
                    break;
            }
            
            outter_stopwatch.Stop();
            if (outter_stopwatch.ElapsedMilliseconds > 1000)
            {
                logger.LogCritical("ProcessRequestMessage {action} too long {time} sec", action.ToString(), outter_stopwatch.ElapsedMilliseconds / 1000);
            }
        }

        async private void ProcessConfirmationMessage(MessageResult analysisResult, WsClientData session, Actions action)
        {

            BasicMessageHandler msgAnalyser = new BasicMessageHandler();
            if (await ReConfirmMessage(analysisResult))
            {
                var profileName = profiles.Where(x => x.IsExisted(analysisResult.Action)).Select(x => x.Name).FirstOrDefault();
                MessageResult confirmResult = null;
                switch (profileName)
                {
                    case "Core":
                        {
                            confirmResult = await profileHandler.ExecuteCoreConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "FirmwareManagement":
                        {
                            confirmResult = await profileHandler.ExecuteFirmwareManagementConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "RemoteTrigger":
                        {
                            confirmResult = await profileHandler.ExecuteRemoteTriggerConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "Reservation":
                        {
                            confirmResult = await profileHandler.ExecuteReservationConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "LocalAuthListManagement":
                        {
                            confirmResult = await profileHandler.ExecuteLocalAuthListManagementConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "SmartCharging":
                        {
                            confirmResult = await profileHandler.ExecuteSmartChargingConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "Security":
                        {
                            confirmResult = profileHandler.ExecuteSecurityConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    default:
                        {
                            string replyMsg = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                            string errorMsg = string.Format("Couldn't find action name: {0} of profile", action);
                            Send(session, replyMsg, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
                        }
                        break;

                }

                if (confirmResult == null || !confirmResult.Success)
                {
                    logger.LogError(string.Format("Action:{0} MessageId:{1}  ExecuteConfirm Error:{2} ",
                        analysisResult.Action, analysisResult.UUID, confirmResult.Exception.ToString()));
                }
            }
            else
            {
                string replyMsg = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                string errorMsg = string.Format("Action:{0} MessageId:{1}  didn't exist in confirm message", analysisResult.Action, analysisResult.UUID);
                Send(session, replyMsg, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
            }
        }

        private async void ProcessErrorMessage(MessageResult analysisResult, WsClientData session, Actions action)
        {
            BasicMessageHandler msgAnalyser = new BasicMessageHandler();
            if (await ReConfirmMessage(analysisResult))
            {
                var profileName = profiles.Where(x => x.IsExisted(analysisResult.Action)).Select(x => x.Name).FirstOrDefault();
                switch (profileName)
                {
                    case "Core":
                        {
                            _ = profileHandler.ReceivedCoreError(action, analysisResult.ReceivedErrorCode, session, analysisResult.RequestId);
                        }
                        break;
                    case "FirmwareManagement":
                        {
                            _ = profileHandler.ReceivedFirmwareManagementError(action, analysisResult.ReceivedErrorCode, session, analysisResult.RequestId);
                        }
                        break;
                    case "RemoteTrigger":
                        {
                            _ = profileHandler.ReceivedRemoteTriggerError(action, analysisResult.ReceivedErrorCode, session, analysisResult.RequestId);
                        }
                        break;
                    case "Reservation":
                        {
                            _ = profileHandler.ExecuteReservationError(action, analysisResult.ReceivedErrorCode, session, analysisResult.RequestId);
                        }
                        break;
                    case "LocalAuthListManagement":
                        {
                            _ = profileHandler.ReceivedLocalAuthListManagementError(action, analysisResult.ReceivedErrorCode, session, analysisResult.RequestId);
                        }
                        break;
                    case "SmartCharging":
                        {
                            _ = profileHandler.ReceivedSmartChargingError(action, analysisResult.ReceivedErrorCode, session, analysisResult.RequestId);
                        }
                        break;
                    default:
                        {
                            string replyMsg = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                            string errorMsg = string.Format("Couldn't find action name: {0} of profile", action);
                            Send(session, replyMsg, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);
                        }
                        break;

                }
            }
            else
            {
                string replyMsg = BasicMessageHandler.GenerateCallError(analysisResult.UUID, OCPPErrorCodes.InternalError, OCPPErrorDescription.InternalError);
                string errorMsg = string.Format("Action:{0} MessageId:{1}  didn't exist in confirm message", analysisResult.Action, analysisResult.UUID);
                Send(session, replyMsg, string.Format("{0} {1}", analysisResult.Action, "Error"), errorMsg);


            }
        }

        private void Send(WsClientData session, string msg, string messageType, string errorMsg = "")
        {
            try
            {

                if (session != null)
                {
                    WriteMachineLog(session, msg, messageType, errorMsg, true);
                    session.Send(msg);
                }

            }
            catch (Exception ex)
            {
                logger.LogError(string.Format("Send Ex:{0}", ex.ToString()));
            }
        }

        internal void AddConfirmMessage(string chargePointSerialNumber, int table_id, string requestId, string action, string msg_id, string createdBy, string sendMessage)
        {
            NeedConfirmMessage _needConfirmMsg = new NeedConfirmMessage();
            _needConfirmMsg.Id = table_id;
            _needConfirmMsg.SentAction = action;
            _needConfirmMsg.SentOn = DateTime.UtcNow;
            _needConfirmMsg.SentTimes = 4;
            _needConfirmMsg.ChargePointSerialNumber = chargePointSerialNumber;
            _needConfirmMsg.RequestId = requestId;
            _needConfirmMsg.SentUniqueId = msg_id;
            _needConfirmMsg.CreatedBy = createdBy;
            _needConfirmMsg.SentMessage = sendMessage;

            if (needConfirmActions.Contains(action))
            {

                lock (_lockConfirmPacketList)
                {
                    needConfirmPacketList.Add(_needConfirmMsg);
                }
            }
        }

        internal void RemoveConfirmMessage()
        {
            var before10Mins = DateTime.UtcNow.AddMinutes(-10);
            lock (_lockConfirmPacketList)
            {
                var removeList = needConfirmPacketList.Where(x => x.SentTimes == 0 || x.SentOn < before10Mins).ToList();
                foreach (var item in removeList)
                {
                    needConfirmPacketList.Remove(item);
                }
            }
        }

        private async Task<bool> ReConfirmMessage(MessageResult analysisResult)
        {
            bool confirmed = false;
            if (needConfirmActions.Contains(analysisResult.Action))
            {

                NeedConfirmMessage foundRequest = null;
                lock (_lockConfirmPacketList)
                {
                    foundRequest = needConfirmPacketList.Where(x => x.SentUniqueId == analysisResult.UUID).FirstOrDefault();
                }

                if (foundRequest != null && foundRequest.Id > 0)
                {
                    foundRequest.SentTimes = 0;
                    foundRequest.SentInterval = 0;
                    analysisResult.RequestId = foundRequest.RequestId;

                    await mainDbService.UpdateServerMessage(foundRequest.Id, inMessage: JsonConvert.SerializeObject(analysisResult.Message, Formatting.None), receivedOn: DateTime.UtcNow);
                    
                    confirmed = true;
                }
                else if (analysisResult.Action == Actions.TriggerMessage.ToString())
                {
                    confirmed = true;
                }
                else
                {
                    logger.LogError(string.Format("Received no record Action:{0} MessageId:{1} ", analysisResult.Action, analysisResult.UUID));
                }
            }

            return confirmed;
        }




        internal void RemoveClient(WsClientData session)
        {
            if (session == null)
            {
                return;
            }

            if (!string.IsNullOrEmpty(session.MachineId))
                logger.LogTrace("RemoveClient[" + session.ChargeBoxId + "]");

            if (session.State == WebSocketState.Open)
            {
                session.Close(CloseReason.ServerShutdown);
            }
            RemoveClientDic(session);
            try
            {
                session.m_ReceiveData -= ReceivedMessageTimeLimited;
                // session.Close(CloseReason.ServerShutdown);

            }
            catch (Exception ex)
            {
                //logger.LogWarning("Close client socket error!!");
                logger.LogWarning(string.Format("Close client socket error!! {0} Msg:{1}", session.ChargeBoxId, ex.Message));
            }

            if (session != null)
            {
                session = null;
            }
        }

        private void RemoveClientDic(WsClientData session)
        {
            if (string.IsNullOrEmpty(session.ChargeBoxId))
            {
                return;
            }

            if (clientDic.ContainsKey(session.ChargeBoxId))
            {
                if (clientDic[session.ChargeBoxId].SessionID == session.SessionID)
                {
                    logger.LogDebug(String.Format("ChargeBoxId:{0} Remove SessionId:{1} Removed SessionId:{2}", session.ChargeBoxId, session.SessionID, clientDic[session.ChargeBoxId].SessionID));

                    clientDic.Remove(session.ChargeBoxId, out _);
                    logger.LogTrace("RemoveClient ContainsKey " + session.ChargeBoxId);
                }

            }
        }

        private void WarmUpLog()
        {
            connectionLogdbService.WarmUpLog();
        }

        private void WriteMachineLog(WsClientData clientData, string data, string messageType, string errorMsg = "", bool isSent = false)
        {
            try
            {

                if (clientData == null || string.IsNullOrEmpty(data)) return;

                if (clientData.ChargeBoxId == null)
                {
                    logger.LogCritical(clientData.Path.ToString() + "]********************session ChargeBoxId null sessionId=" + clientData.SessionID);
                }

                connectionLogdbService.WriteMachineLog(clientData, data, messageType, errorMsg, isSent);
            }
            catch (Exception ex)
            {
                //Console.WriteLine(ex.ToString());
                logger.LogError(ex,ex.Message);
            }


        }
    }
}