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

using Dapper;
using EVCB_OCPP.Domain;
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.Packet.Messages.RemoteTrigger;
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 Newtonsoft.Json.Linq;

using OCPPServer.Protocol;
using OCPPServer.SubProtocol;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Config;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Security.Authentication;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using NLog;
using Microsoft.Extensions.Configuration;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using ProtoBuf.Serializers;
using System.Net;
using Microsoft.AspNetCore.Builder;
using NLog.Extensions.Logging;
using Microsoft.Data.SqlClient;
using System.Collections.ObjectModel;
using System.Collections.Concurrent;
using EVCB_OCPP.WSServer.SuperSocket;
using Microsoft.Extensions.Logging;

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
            , IDbContextFactory<MainDBContext> maindbContextFactory
            , IMainDbService mainDbService
            , IDbContextFactory<ConnectionLogDBContext> connectionLogdbContextFactory
            , SqlConnectionFactory<WebDBConetext> webDbConnectionFactory
            , SqlConnectionFactory<MainDBContext> mainDbConnectionFactory
            , IHostEnvironment environment
            , IOCPPWSServerFactory ocppWSServerFactory
            , IConnectionLogdbService connectionLogdbService
            , WebDbService webDbService
            , IServiceProvider serviceProvider,
            OuterHttpClient httpClient)
        {
            _ct = _cts.Token;
            this.logger = logger;
            this.configuration = configuration;
            this.maindbContextFactory = maindbContextFactory;
            this.mainDbService = mainDbService;
            this.webDbConnectionFactory = webDbConnectionFactory;
            //this.connectionLogdbContextFactory = connectionLogdbContextFactory;
            this.ocppWSServerFactory = ocppWSServerFactory;
            this.connectionLogdbService = connectionLogdbService;
            this.webDbService = webDbService;
            this.httpClient = httpClient;
            isInDocker = !string.IsNullOrEmpty(configuration["DOTNET_RUNNING_IN_CONTAINER"]);

            // = configuration.GetConnectionString("WebDBContext");
            this.profileHandler = serviceProvider.GetService<ProfileHandler>();// new ProfileHandler(configuration, serviceProvider);
            _loadingBalanceService = new LoadingBalanceService(mainDbConnectionFactory, webDbConnectionFactory);

            WarmUpLog();
        }

        #region private fields
        private OuterHttpClient httpClient;
        private DateTime lastcheckdt = DateTime.UtcNow.AddSeconds(-20);
        private ConcurrentDictionary<string, ClientData> clientDic = new ConcurrentDictionary<string, ClientData>();
        //private readonly Object _lockClientDic = new object();
        private readonly Object _lockConfirmPacketList = new object();
        private readonly ILogger<ProtalServer> logger;
        private readonly IConfiguration configuration;
        //private readonly IServiceProvider serviceProvider;
        private readonly IDbContextFactory<MainDBContext> maindbContextFactory;
        private readonly IMainDbService mainDbService;
        private readonly SqlConnectionFactory<WebDBConetext> webDbConnectionFactory;

        //private readonly IDbContextFactory<ConnectionLogDBContext> connectionLogdbContextFactory;
        private readonly IOCPPWSServerFactory ocppWSServerFactory;
        private readonly IConnectionLogdbService connectionLogdbService;
        private readonly WebDbService webDbService;
        private readonly ProfileHandler profileHandler;//= new ProfileHandler();
        //private readonly string webConnectionString;// = ConfigurationManager.ConnectionStrings["WebDBContext"].ConnectionString;
        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 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(),
        };
        private CancellationTokenSource _cts = new CancellationTokenSource();
        private CancellationToken _ct;
        #endregion

        internal Dictionary<string, ClientData> ClientDic
        {
            get
            {
                Dictionary<string, ClientData> toReturn = null;
                toReturn = new Dictionary<string, ClientData>(clientDic);
                return toReturn;
            }
        }

        internal List<NeedConfirmMessage> ResendMessage
        {
            get
            {
                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 Task.CompletedTask;
        }

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

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

        internal void Start()
        {
            Console.WriteLine("Starting Server...");

            if (!GlobalConfig.LoadAPPConfig(configuration))
            {
                Console.WriteLine("Please check App.Config setting .");
                return;
            }
            
            OpenNetwork();


            RunHttpConsoleService();
            return;
            if (!isInDocker)
            {
                Task consoleReadTask = new Task(RunConsoleInteractive);
                consoleReadTask.Start();
                //RunConsoleInteractive();
                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, ClientData> _copyClientDic = null;
                            _copyClientDic = new Dictionary<string, ClientData>(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, ClientData> _copyClientDic = null;
                            _copyClientDic = new Dictionary<string, ClientData>(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;
                }
            }
        }

        private void RunHttpConsoleService()
        {
            var appBuilder = WebApplication.CreateBuilder();
            appBuilder.Services.AddSingleton<IHostLifetime, DummyHostLifeTime>();
            var app = appBuilder.Build();

            var helpFunc = () => {
                return string.Join("\r\n", new[] { 
                    "Command help!!",
                    "lcn : List Customer Name",
                    "gc : GC Collect",
                    "lc : List Clients",
                    "silent : silent",
                    "show : show log"
                });
            };
            app.MapGet("/", helpFunc);
            app.MapGet("/help", helpFunc);

            app.MapPost("/stop", () => {
                Stop();
                return "Command stop";
            });

            app.MapPost("/gc", () => {
                GC.Collect();
                return "Command GC";
            });

            app.MapPost("/lc", () => {
                List<string> toReturn = new List<string>() { "Command List Clients" };
                Dictionary<string, ClientData> _copyClientDic = null;
                _copyClientDic = new Dictionary<string, ClientData>(clientDic);
                var list = _copyClientDic.Select(c => c.Value).ToList();
                int i = 1;
                foreach (var c in list)
                {
                    toReturn.Add(i + ":" + c.ChargeBoxId + " " + c.SessionID);
                    i++;
                }
                return string.Join("\r\n", toReturn);
            });

            app.MapPost("/lcn", () => {
                List<string> toReturn = new List<string> { "Command List Customer Name" };
                Dictionary<string, ClientData> _copyClientDic = null;
                _copyClientDic = new Dictionary<string, ClientData>(clientDic);
                var lcn = clientDic.Select(c => c.Value.CustomerName).Distinct().ToList();
                int iLcn = 1;
                foreach (var c in lcn)
                {
                    toReturn.Add(iLcn + ":" + c + ":" + clientDic.Where(z => z.Value.CustomerName == c).Count().ToString());
                    iLcn++;
                }
                return string.Join("\r\n", toReturn);
            });

            app.MapPost("/silent", () => {
                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);
                    }
                }
                return "Command silent";
            });

            app.MapPost("/show", () => {
                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);
                    }
                }
                return "Command show";
            });

            app.MapGet("/threads", () => {
                ThreadPool.GetMaxThreads(out var maxWorkerThread,out var maxCompletionPortThreads);
                ThreadPool.GetAvailableThreads(out var avaliableWorkerThread, out var avaliableCompletionPortThreads);
                return $"WorkerThread:{avaliableWorkerThread}/{maxWorkerThread} CompletionPortThreads{avaliableCompletionPortThreads}/{maxCompletionPortThreads}";
            });

            app.MapPost("/threads", (int min, int max) => {
                ThreadPool.GetMaxThreads(out var maxWorkerThread, out var maxCompletionPortThreads);
                ThreadPool.GetAvailableThreads(out var avaliableWorkerThread, out var avaliableCompletionPortThreads); 
                ThreadPool.SetMinThreads(min, 0);
                ThreadPool.SetMaxThreads(max, maxCompletionPortThreads);
                return $"WorkerThread:{avaliableWorkerThread}/{maxWorkerThread} CompletionPortThreads{avaliableCompletionPortThreads}/{maxCompletionPortThreads}";
            });

            app.Urls.Add("http://*:54088");

            _ = app.RunAsync();

            var builder = WebApplication.CreateBuilder();
            //builder.Configuration.AddJsonFile("./EVCB_OCPP.WSServer/appsettings.json");
            //var sec = builder.Configuration.GetSection("ReverseProxy");
            //Console.WriteLine($"Printing.............");
            //foreach (var pair in sec.AsEnumerable())
            //{
            //    Console.WriteLine($"{pair.Key}:{pair.Value} \n");
            //}

            builder.Services.AddReverseProxy()
                .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));
            builder.Services.AddSingleton<IHostLifetime, DummyHostLifeTime>();
            var yarpApp = builder.Build();
            yarpApp.Urls.Add("http://*:80");
            yarpApp.MapReverseProxy();
            _ = yarpApp.RunAsync();
        }

        internal void Stop()
        {
            _cts?.Cancel();
        }

        private async void CheckEVSEConfigure(string chargeBoxId)
        {
            if (string.IsNullOrEmpty(chargeBoxId)) return;
            await mainDbService.AddServerMessage(
                ChargeBoxId: chargeBoxId,
                OutAction: Actions.GetConfiguration.ToString(),
                OutRequest: new GetConfigurationRequest() { key = new List<string>() }
                );
        }

        private void OpenNetwork()
        {

            //載入OCPP Protocol
            OCPPWSServer 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!");
                return;
            }

            appServer.NewSessionConnected += AppServer_NewSessionConnected;
            appServer.SessionClosed += AppServer_SessionClosed;


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

        private void AppServer_SessionClosed(ClientData session, CloseReason value)
        {
            WriteMachineLog(session, string.Format("CloseReason: {0}", value), "Connection", "");
            RemoveClient(session);
        }

        private async void AppServer_NewSessionConnected(ClientData 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;
                }
                //ClientData _removeClient = null;

                //var addedClient = clientDic.GetOrAdd(session.ChargeBoxId, session);
                if (clientDic.ContainsKey(session.ChargeBoxId))
                {
                    var oldSession = clientDic[session.ChargeBoxId];
                    WriteMachineLog(oldSession, "Duplicate Logins", "Connection", "");
                    oldSession.Close(CloseReason.ServerShutdown);
                    RemoveClient(oldSession);
                }
                clientDic[session.ChargeBoxId] = session;

                //clientDic.TryGetValue(session.ChargeBoxId, out _removeClient);
                //if (addedClient != session)
                //{
                //    WriteMachineLog(addedClient, "Duplicate Logins", "Connection", "");
                //    addedClient.Close(CloseReason.ServerShutdown);
                //    RemoveClient(addedClient);
                //}

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

                using (var db = await maindbContextFactory.CreateDbContextAsync())
                {
                    var machine = await db.Machines.Where(x => x.ChargeBoxId == session.ChargeBoxId).FirstOrDefaultAsync();
                    if (machine != null)
                    {
                        machine.ConnectionType = session.Origin.Contains("https") ? 2 : 1;
                        await db.SaveChangesAsync();
                    }

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


        }

        async private void ReceivedMessageTimeLimited(ClientData 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(ClientData 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, ClientData 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"));
            }
            else
            {
                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 == null ? string.Empty : replyResult.Exception.ToString());

                                if (action == Actions.BootNotification && replyResult.Message is BootNotificationConfirmation)
                                {
                                    session.IsCheckIn = true;
                                    if (((BootNotificationConfirmation)replyResult.Message).status == Packet.Messages.SubTypes.RegistrationStatus.Accepted)
                                    {
                                        CheckEVSEConfigure(session.ChargeBoxId);
                                        
                                        await mainDbService.AddServerMessage(
                                            ChargeBoxId: session.ChargeBoxId,
                                            OutAction: Actions.ChangeConfiguration.ToString(),
                                            OutRequest: new ChangeConfigurationRequest()
                                            {
                                                key = "TimeOffset",
                                                value = "+08:00"
                                            });
                                    }
                                    else
                                    {
                                        using (var db = await maindbContextFactory.CreateDbContextAsync())
                                        {
                                            var machine = await db.Machines.Where(x => x.ChargeBoxId == session.ChargeBoxId).FirstOrDefaultAsync();
                                            if (machine != null)
                                            {
                                                if (machine.ConnectorType.Contains("6") || machine.ConnectorType.Contains("7") || machine.ConnectorType.Contains("8") || machine.ConnectorType.Contains("9"))
                                                {
                                                    session.IsAC = false;
                                                }
                                                machine.ConnectionType = session.Origin.Contains("https") ? 2 : 1;
                                                await db.SaveChangesAsync();
                                            }
                                        }

                                        await SetDefaultFee(session);
                                    }
                                }

                                if (action == Actions.Authorize && replyResult.Message is AuthorizeConfirmation)
                                {
                                    var authorizeRequest = (IRequest)analysisResult.Message as AuthorizeRequest;
                                    if (session.UserDisplayPrices.ContainsKey(authorizeRequest.idTag))
                                    {
                                        await mainDbService.AddServerMessage(
                                            ChargeBoxId: session.ChargeBoxId,
                                            OutAction: Actions.DataTransfer.ToString(),
                                            OutRequest: new DataTransferRequest() { 
                                                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, ClientData 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, ClientData 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(ClientData 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()));
            }


        }

        async private Task<string> SetDefaultFee(ClientData client)
        {
            string displayPriceText = string.Empty;
            string charingPriceText = string.Empty;

            if (string.IsNullOrEmpty(client.ChargeBoxId)) return displayPriceText;

            try
            {

                using (SqlConnection conn = await webDbConnectionFactory.CreateAsync())
                {
                    var parameters = new DynamicParameters();
                    parameters.Add("@MachineId", client.MachineId, DbType.String, ParameterDirection.Input, 36);
                    string displayPricestrSql = "";
                    string strSql = "";

                    if (client.IsAC)
                    {
                        displayPricestrSql = "   SELECT  [AC_BillingMethod] as BillingMethod,[AC_FeeName] as FeeName,[AC_Fee] as ChargingFeebyHour" +
                    "  ,[AC_ParkingFee] as ParkingFee, [Currency]  FROM[StationMachine]  left join[dbo].[Station]" +
                    "  on[StationMachine].StationId = Station.[Id]  where StationMachine.MachineId=@MachineId and Station.IsBilling=1; ";

                        strSql = " SELECT CAST( [StartTime] as varchar(5)) StartTime,CAST( [EndTime] as varchar(5)) EndTime,[Fee]  FROM[StationMachine]  left join [dbo].[StationFee]" +
                       " on[StationMachine].StationId = StationFee.StationId  where StationMachine.MachineId =@MachineId and StationFee.IsAC=1; ";
                    }
                    else
                    {
                        displayPricestrSql = "   SELECT  [DC_BillingMethod] as BillingMethod,[DC_FeeName] as FeeName,[DC_Fee] as ChargingFeebyHour" +
                   "  ,[DC_ParkingFee] as ParkingFee, [Currency]  FROM[StationMachine]  left join[dbo].[Station]" +
                   "  on[StationMachine].StationId = Station.[Id]  where StationMachine.MachineId=@MachineId and Station.IsBilling=1; ";

                        strSql = " SELECT CAST( [StartTime] as varchar(5)) StartTime,CAST( [EndTime] as varchar(5)) EndTime,[Fee]  FROM[StationMachine]  left join [dbo].[StationFee]" +
                       " on[StationMachine].StationId = StationFee.StationId  where StationMachine.MachineId =@MachineId and StationFee.IsAC=0; ";

                    }
                    //var result = await conn.QueryAsync<StationFee>(displayPricestrSql, parameters);
                    var result = await conn.QueryFirstOrDefaultAsync<StationFee>(displayPricestrSql, parameters);
                    if (result == default)
                    {
                        return string.Empty;
                    }
                    var stationPrice = result;//.First();

                    if (stationPrice.BillingMethod == 1)
                    {
                        var chargingPriceResult = await conn.QueryAsync<ChargingPrice>(strSql, parameters);
                        client.ChargingPrices = chargingPriceResult.ToList();
                        if (string.IsNullOrEmpty(client.ChargingPrices[0].StartTime))
                        {
                            client.ChargingPrices = new List<ChargingPrice>();
                        }
                    }

                    displayPriceText = stationPrice.FeeName;
                    client.BillingMethod = stationPrice.BillingMethod;
                    client.Currency = stationPrice.Currency;
                    client.ChargingFeebyHour = stationPrice.ChargingFeebyHour;
                    client.ParkingFee = stationPrice.ParkingFee;
                    client.IsBilling = true;
                }
            }
            catch (Exception ex)
            {
                logger.LogError("SetDefaultFee", ex.ToString());
            }

            return displayPriceText;
        }

        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;

                    using (var db = await maindbContextFactory.CreateDbContextAsync())
                    {
                        var sc = await db.ServerMessages.Where(x => x.Id == foundRequest.Id).FirstOrDefaultAsync();
                        sc.InMessage = JsonConvert.SerializeObject(analysisResult.Message, Formatting.None);
                        sc.ReceivedOn = DateTime.UtcNow;
                        await db.SaveChangesAsync();
                        //  Console.WriteLine(string.Format("Now:{0} ServerMessage Id:{1} ", DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss"), foundRequest.Id));

                    }
                    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(ClientData session)
        {
            if (session == null)
            {
                return;
            }

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

            if (session.Connected)
            {
                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(ClientData 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(ClientData 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 + "]********************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);
            }


        }
    }
}