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

using NLog;
using OCPPServer.Protocol;
using OCPPServer.SubProtocol;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Config;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using EVCB_OCPP.Packet.Messages.Basic;
using EVCB_OCPP.Packet.Messages.Core;
using EVCB_OCPP.WSServer.Message;
using EVCB_OCPP.Packet.Messages;
using EVCB_OCPP.Domain;
using EVCB_OCPP.Domain.Models.Database;
using System.Threading;
using System.Data.Entity;
using EVCB_OCPP.Packet.Features;
using EVCB_OCPP.Packet.Features.Core;
using Newtonsoft.Json;
using OCPPPackage.Profiles;
using System.Threading.Tasks;
using EVCB_OCPP.WSServer.Helper;
using System.Data.SqlClient;
using EVCB_OCPP.Packet.Messages.FirmwareManagement;
using EVCB_OCPP.Packet.Messages.RemoteTrigger;
using System.Configuration;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

namespace EVCB_OCPP.WSServer
{
    internal class ProtalServer
    {
        static private ILogger logger = NLog.LogManager.GetCurrentClassLogger();

        private Dictionary<string, ClientData> ClientDic = new Dictionary<string, ClientData>();
        private readonly Object _lockClientDic = new object();
        private readonly Object _lockConfirmPacketList = new object();
        private ProfileHandler _profileHandler = new ProfileHandler();
        private List<NeedConfirmMessage> NeedConfirmPacketList = new List<NeedConfirmMessage>();
        private DateTime checkUpdateDt = DateTime.Now;
        private 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",






        };
        private List<Profile> profiles = new List<Profile>()
        {
             new CoreProfile(),
             new FirmwareManagementProfile(),
             new ReservationProfile(),
             new RemoteTriggerProfile(),
             new SmartChargingProfile(),
             new LocalAuthListManagementProfile()
        };
        private CancellationTokenSource _cts = new CancellationTokenSource();
        private CancellationToken _ct;


        internal ProtalServer()
        {
            _ct = _cts.Token;
            WarmUpLog();
        }


        internal void Start()
        {

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

            OpenNetwork();

            Task serverCommandTask = new Task(ServerMessageTrigger, _ct);
            serverCommandTask.Start();

            Task serverUpdateTask = new Task(ServerUpdateTrigger, _ct);
            serverUpdateTask.Start();

            while (true)
            {
                var input = Console.ReadLine();

                switch (input.ToLower())
                {
                    case "stop":
                        logger.Info("Command stop");
                        Stop();
                        break;

                    case "gc":
                        logger.Info("Command GC");
                        GC.Collect();
                        break;

                    case "lc":
                        {
                            logger.Info("Command List Clients");
                            Dictionary<string, ClientData> _copyClientDic = null;
                            lock (_lockClientDic)
                            {
                                _copyClientDic = new Dictionary<string, ClientData>(ClientDic);

                            }
                            var list = _copyClientDic.Select(c => c.Value).ToList();
                            int i = 1;
                            foreach (var c in list)
                            {
                                logger.Info(i + ":" + c.ChargeBoxId);
                                i++;
                            }

                        }
                        break;
                    case "lcn":
                        {
                            logger.Info("Command List Customer Name");
                            Dictionary<string, ClientData> _copyClientDic = null;
                            lock (_lockClientDic)
                            {
                                _copyClientDic = new Dictionary<string, ClientData>(ClientDic);

                            }
                            var lcn = ClientDic.Select(c => c.Value.CustomerName).Distinct().ToList();
                            int iLcn = 1;
                            foreach (var c in lcn)
                            {
                                logger.Info(iLcn + ":" + c + ":" + ClientDic.Where(z => z.Value.CustomerName == c).Count().ToString());
                                iLcn++;
                            }

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

                    case "silent":
                        logger.Info("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 = "info";
                        }
                        xe.Save("NLog.config");
                        break;
                    case "show":
                        logger.Info("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");
                        break;
                    case "rcl":
                        break;
                    default:
                        break;
                }
            }
        }

        internal void Stop()
        {
            if (_cts != null)
            {
                _cts.Cancel();
            }
        }

        private void CheckEVSEConfigure(string chargeBoxId)
        {


            using (var db = new MainDBContext())
            {

                var _sn = db.MachineConfigure.Where(x => x.ChargeBoxId == chargeBoxId).Select(x => x.ChargeBoxId).FirstOrDefault();
                if (string.IsNullOrEmpty(_sn))
                {
                    db.ServerMessage.Add(new ServerMessage()
                    {
                        ChargeBoxId = chargeBoxId,
                        CreatedBy = "Server",
                        CreatedOn = DateTime.Now,
                        OutAction = Actions.GetConfiguration.ToString(),
                        OutRequest = JsonConvert.SerializeObject(
                            new GetConfigurationRequest()
                            {
                                key = new List<string>()

                            },
                            new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None }),
                        SerialNo = Guid.NewGuid().ToString(),
                        InMessage = string.Empty

                    });

                    db.SaveChanges();
                }
            }
        }


        private void OpenNetwork()
        {

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

            List<IListenerConfig> llistener = new List<IListenerConfig>();
            //System.Net.IPAddress.Any.ToString()
            // llistener.Add(new ListenerConfig { Ip = "", Port = Convert.ToInt32(wssserverPort), Backlog = 100, Security = serverSecurity });
            llistener.Add(new ListenerConfig { Ip = System.Net.IPAddress.Any.ToString(), Port = Convert.ToInt32(GlobalConfig.GetWS_Port()), Backlog = 100, Security = "None" });
            llistener.Add(new ListenerConfig { Ip = System.Net.IPAddress.Any.ToString(), Port = Convert.ToInt32(GlobalConfig.GetWSS_Port()), Backlog = 100, Security = "tls" });
            var config = ConfigurationManager.GetSection("superSocket") as IConfigurationSource;
            ICertificateConfig Certificate = config.Servers.ElementAt(0).Certificate;
            IEnumerable<IListenerConfig> listeners = llistener;

            //設定server config
            var serverConfig = new ServerConfig
            {
                //Port = Convert.ToInt32(2012),
                //Ip = "172.17.40.13",
                MaxRequestLength = 4096,
                //Security = serverSecurity,
                Certificate = Certificate,
                Listeners = listeners,


            };

            //Setup with listening port
            if (!appServer.Setup(serverConfig, logFactory: new OCPPLogFactory()))
            {
                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)
        {
            Console.WriteLine(session.RemoteEndPoint.Address);
            WriteMachineLog(session.ChargeBoxId, string.Format("CloseReason: {0}", value), "Connection", "");
            RemoveClient(session);
            // close Connection
        }

        private void AppServer_NewSessionConnected(ClientData session)
        {
            Console.WriteLine("------------New");
            session.m_ReceiveData += new ClientData.OCPPClientDataEventHandler<ClientData, String>(ReceivedMessage);
            try
            {
                lock (_lockClientDic)
                {
                    ClientData _removeClient = null;

                    ClientDic.TryGetValue(session.ChargeBoxId, out _removeClient);
                    if (_removeClient != null)
                    {
                        RemoveClient(_removeClient);
                    }
                    ClientDic.Add(session.ChargeBoxId, session);
                 
                    Console.WriteLine("------------New" + (session == null ? "Oops" : session.ChargeBoxId));
                    WriteMachineLog(session.ChargeBoxId, "", "Connection", "");
                }
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("NewSessionConnected Ex: {0}", ex.ToString()));
            }


        }

        private void ReceivedMessage(ClientData session, string rawdata)
        {

            BasicMessageHandler msgAnalyser = new BasicMessageHandler();
            MessageResult analysisResult = msgAnalyser.AnalysisReceiveData(session, rawdata);


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

            if (analysisResult.Success == false)
            {
                //解析RawData就發生錯誤
                if (!string.IsNullOrEmpty(analysisResult.CallErrorMsg))
                {
                    Send(session, analysisResult.CallErrorMsg, string.Format("{0} {1}", analysisResult.Action, "Error"));
                }
                else
                {
                    BaseMessage _baseMsg = analysisResult.Message as BaseMessage;
                    string replyMsg = msgAnalyser.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
            {

                Actions action = Convertor.GetAction(analysisResult.Action);
                switch (analysisResult.Id)
                {
                    case BasicMessageHandler.TYPENUMBER_CALL:
                        {
                            ProcessRequestMessage(analysisResult, session, action);

                        }
                        break;
                    case BasicMessageHandler.TYPENUMBER_CALLRESULT:
                        {

                            ProcessConfirmationMessage(analysisResult, session, action);
                        }
                        break;
                    case BasicMessageHandler.TYPENUMBER_CALLERROR:
                        {
                            //只處理 丟出Request 收到Error的訊息
                            if (analysisResult.Success)
                            {
                                ProcessErrorMessage(analysisResult, session, action);
                            }

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

                }
            }


        }

        private void ProcessRequestMessage(MessageResult analysisResult, ClientData session, Actions action)
        {
            BasicMessageHandler msgAnalyser = new BasicMessageHandler();
            if (!session.IsCheckIn && action != Actions.BootNotification)
            {
                string response = msgAnalyser.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":
                        {

                            bool oldstatus = session.IsCheckIn;
                            var replyResult = _profileHandler.ExecuteCoreRequest(action, session, (IRequest)analysisResult.Message);
                            if (replyResult.Success)
                            {
                                string response = msgAnalyser.GenerateConfirmation(analysisResult.UUID, (IConfirmation)replyResult.Message);
                                Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Confirmation"));
                                if (action == Actions.BootNotification && replyResult.Message is BootNotificationConfirmation)
                                {
                                    if (((BootNotificationConfirmation)replyResult.Message).status == Packet.Messages.SubTypes.RegistrationStatus.Accepted)
                                    {
                                        session.IsCheckIn = true;
                                        if (!oldstatus)
                                        {
                                            using (var db = new MainDBContext())
                                            {
                                                var machine = db.Machine.Where(x => x.ChargeBoxId == session.ChargeBoxId).FirstOrDefault();
                                                if (machine != null)
                                                {
                                                    machine.ConnectionType = session.Origin.Contains("https") ? 2 : 1;
                                                    db.SaveChanges();
                                                }
                                            }


                                            CheckEVSEConfigure(session.ChargeBoxId);
                                        }
                                    }
                                }

                            }
                            else
                            {
                                string response = msgAnalyser.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 "FirmwareManagement":
                        {
                            var replyResult = _profileHandler.ExecuteFirmwareManagementRequest(action, session, (IRequest)analysisResult.Message);
                            if (replyResult.Success)
                            {
                                string response = msgAnalyser.GenerateConfirmation(analysisResult.UUID, (IConfirmation)replyResult.Message);
                                Send(session, response, string.Format("{0} {1}", analysisResult.Action, "Confirmation"));

                            }
                            else
                            {
                                string response = msgAnalyser.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 = msgAnalyser.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;

                }
            }
        }

        private void ProcessConfirmationMessage(MessageResult analysisResult, ClientData session, Actions action)
        {
            BasicMessageHandler msgAnalyser = new BasicMessageHandler();
            if (ReConfirmMessage(analysisResult))
            {
                var profileName = profiles.Where(x => x.IsExisted(analysisResult.Action)).Select(x => x.Name).FirstOrDefault();
                MessageResult confirmResult = null;
                switch (profileName)
                {
                    case "Core":
                        {
                            confirmResult = _profileHandler.ExecuteCoreConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "FirmwareManagement":
                        {
                            confirmResult = _profileHandler.ExecuteFirmwareManagementConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "RemoteTrigger":
                        {
                            confirmResult = _profileHandler.ExecuteRemoteTriggerConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "Reservation":
                        {
                            confirmResult = _profileHandler.ExecuteReservationConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "LocalAuthListManagement":
                        {
                            confirmResult = _profileHandler.ExecuteLocalAuthListManagementConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    case "SmartCharging":
                        {
                            confirmResult = _profileHandler.ExecuteSmartChargingConfirm(action, session, (IConfirmation)analysisResult.Message, analysisResult.RequestId);
                        }
                        break;
                    default:
                        {
                            string replyMsg = msgAnalyser.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.Error(string.Format("Action:{0} MessageId:{1}  ExecuteConfirm Error:{2} ",
                        analysisResult.Action, analysisResult.UUID, confirmResult.Exception.ToString()));
                }
            }
            else
            {
                string replyMsg = msgAnalyser.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 ProcessErrorMessage(MessageResult analysisResult, ClientData session, Actions action)
        {
            BasicMessageHandler msgAnalyser = new BasicMessageHandler();
            if (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 = msgAnalyser.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 = msgAnalyser.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.ChargeBoxId, msg, messageType, errorMsg, true);
                    session.Send(msg);
                }

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


        }

        async private void ServerUpdateTrigger()
        {
            for (; ; )
            {
                if (_ct.IsCancellationRequested)
                {
                    break;
                }

                var min_Interval = (DateTime.Now - checkUpdateDt).TotalMinutes;
                if (min_Interval > 3)
                {
                    BasicMessageHandler msgAnalyser = new BasicMessageHandler();
                    Dictionary<string, ClientData> _copyClientDic = null;
                    lock (_lockClientDic)
                    {
                        _copyClientDic = new Dictionary<string, ClientData>(ClientDic);

                    }
                    checkUpdateDt = DateTime.Now;
                    using (var db = new MainDBContext())
                    {
                        //var needUpdateChargers = db.Machine.Where(x => x.FW_AssignedMachineVersionId.HasValue == true &&
                        //    x.FW_AssignedMachineVersionId != x.FW_VersionReport && x.Online == true)
                        //    .Select(x => new { x.Id, x.ChargeBoxId, x.FW_AssignedMachineVersionId }).ToList();

                        var needUpdateChargers = db.Machine.Where(x => x.FW_AssignedMachineVersionId.HasValue == true &&
                          x.FW_AssignedMachineVersionId != x.FW_VersionReport && x.Online == true)
                          .Select(x => x.ChargeBoxId).ToList();

                        foreach (var chargeBoxId in needUpdateChargers)
                        {
                            try
                            {
                               

                                ClientData session;
                                if (_copyClientDic.TryGetValue(chargeBoxId, out session))
                                {
                                  
                                    string requestId = Guid.NewGuid().ToString();
                                   // using (var db = new MainDBContext())
                                   
                                    if (session.IsCheckIn)
                                    {

                                        var _request = new TriggerMessageRequest()
                                        {
                                            requestedMessage = Packet.Messages.SubTypes.MessageTrigger.FirmwareStatusNotification
                                        };

                                        var uuid = session.queue.store(_request);
                                        string rawRequest = msgAnalyser.GenerateRequest(uuid, _request.Action, _request);
                                        Send(session, rawRequest, string.Format("{0} {1}", _request.Action, "Request"), "");

                                        #region OCTT   ,測試韌體更新方式
                                        //--------------------> OCTT   ,測試韌體更新方式
                                        //{
                                        //    var machine = db.Machine.Where(x => x.FW_AssignedMachineVersionId.HasValue == true &&
                                        //        x.FW_AssignedMachineVersionId != x.FW_VersionReport && x.ChargeBoxId == session.ChargeBoxId)
                                        //        .Select(x => new { x.Id, x.FW_AssignedMachineVersionId }).FirstOrDefault();

                                        //    if (machine != null)
                                        //    {
                                        //        var mv = db.MachineVersion.Include(c => c.PublishVersion)
                                        //         .Include(c => c.PublishVersion.PublishVersionFiles)
                                        //         .Include(c => c.PublishVersion.PublishVersionFiles.Select(z => z.UploadFile))
                                        //         .Where(c => c.Id == machine.FW_AssignedMachineVersionId.Value).First();

                                        //        string downloadUrl = mv.PublishVersion.PublishVersionFiles.FirstOrDefault().UploadFile.FileUrl;

                                        //        var _updateFWrequest = new UpdateFirmwareRequest()
                                        //        {
                                        //            location = new Uri(downloadUrl),
                                        //            retries = 3,
                                        //            retrieveDate = DateTime.Now,
                                        //            retryInterval = 10
                                        //        };
                                        //        db.MachineOperateRecord.Add(new MachineOperateRecord()
                                        //        {
                                        //            CreatedOn = DateTime.Now,
                                        //            ChargeBoxId = session.ChargeBoxId,
                                        //            SerialNo = requestId,
                                        //            RequestContent = JsonConvert.SerializeObject(_updateFWrequest, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None }),
                                        //            EVSE_Status = 0,
                                        //            EVSE_Value = "Fw Version:" + machine.FW_AssignedMachineVersionId,
                                        //            Status = 0,
                                        //            RequestType = 0,

                                        //        });

                                        //        db.ServerMessage.Add(new ServerMessage()
                                        //        {
                                        //            ChargeBoxId = session.ChargeBoxId,
                                        //            CreatedBy = "Server",
                                        //            CreatedOn = DateTime.Now,
                                        //            OutAction = _updateFWrequest.Action.ToString(),
                                        //            OutRequest = JsonConvert.SerializeObject(_updateFWrequest, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None }),
                                        //            SerialNo = requestId,
                                        //            InMessage = string.Empty

                                        //        });

                                        //        db.SaveChanges();

                                        //    }

                                        //}
                                        #endregion
                                    }



                                }


                            }
                            catch (Exception ex)
                            {
                                logger.Error(string.Format("serverUpdateTrigger ChargeBoxId:{0}  Ex:{1}", chargeBoxId, ex.ToString()));
                            }
                        }
                    }
                    await Task.Delay(1000);
                    //  Thread.CurrentThread.Join(1000);
                }
            }
        }

        async private void ServerMessageTrigger()
        {
            for (; ; )
            {
                if (_ct.IsCancellationRequested)
                {
                    break;
                }

                try
                {
                    RemoveConfirmMessage();

                    BasicMessageHandler msgAnalyser = new BasicMessageHandler();
                    using (var db = new MainDBContext())
                    {
                        DateTime startDt = DateTime.Now.AddSeconds(-30);
                        DateTime dt = new DateTime(1991, 1, 1);
                        //Console.WriteLine(string.Format("{0} IN", DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")));
                        var commandList = db.ServerMessage.Where(c => c.ReceivedOn == dt && c.UpdatedOn == dt && c.CreatedOn >= startDt && c.CreatedOn <= DateTime.Now).AsNoTracking().ToList();
                        //處理主機傳送的有指令
                        var cmdMachineList = commandList.Select(c => c.ChargeBoxId).Distinct().ToList();
                        if (commandList.Count > 0)
                        {
                            Console.WriteLine(string.Format("Now:{0} commandList Count:{1} ", DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"), commandList.Count));
                        }

                        foreach (var charger_SN in cmdMachineList)
                        {
                            ClientData session;
                            string uuid = string.Empty;
                            if (ClientDic.TryGetValue(charger_SN, out session))
                            {
                                Console.WriteLine(string.Format("charger_SN:{0} startDt:{1} CreatedOn:{2}", charger_SN, startDt.ToString("yyyy/MM/dd HH:mm:ss"), DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")));
                                if (session.IsCheckIn)
                                {
                                    var cmdList = commandList.Where(c => c.ChargeBoxId == charger_SN).ToList();

                                    foreach (var item in cmdList)
                                    {
                                        IRequest request = null;
                                        Actions action = Actions.None;
                                        Enum.TryParse(item.OutAction, out action);
                                        Type _RequestType = null;

                                        for (int i = 0; i < profiles.Count; i++)
                                        {
                                            var feature = profiles[i].GetFeaturebyAction(item.OutAction);

                                            if (feature != null)
                                            {
                                                _RequestType = feature.GetRequestType();
                                                break;
                                            }
                                        }

                                        if (_RequestType != null)
                                        {
                                            request = JsonConvert.DeserializeObject(item.OutRequest, _RequestType) as IRequest;
                                            uuid = session.queue.store(request);
                                            string rawRequest = msgAnalyser.GenerateRequest(uuid, item.OutAction, request);
                                            Send(session, rawRequest, string.Format("{0} {1}", action, "Request"), "");
                                        }

                                        AddConfirmMessage(charger_SN, item.Id, item.SerialNo, item.OutAction, uuid);

                                        #region 更新資料表單一欄位
                                        var _UpdatedItem = new ServerMessage() { Id = item.Id, UpdatedOn = DateTime.Now };
                                        db.Configuration.AutoDetectChangesEnabled = false;//自動呼叫DetectChanges()比對所有的entry集合的每一個屬性Properties的新舊值
                                        db.Configuration.ValidateOnSaveEnabled = false;// 因為Entity有些欄位必填，若不避開會有Validate錯誤
                                                                                       // var _UpdatedItem = db.ServerMessage.Where(x => x.Id == item.Id).FirstOrDefault();
                                        db.ServerMessage.Attach(_UpdatedItem);
                                        _UpdatedItem.UpdatedOn = DateTime.Now;
                                        db.Entry(_UpdatedItem).Property(x => x.UpdatedOn).IsModified = true;// 可以直接使用這方式強制某欄位要更新，只是查詢集合耗效能而己

                                        db.SaveChanges();

                                        #endregion


                                    }

                                }
                            }
                        }
                        db.ChangeTracker.DetectChanges();
                    }

                    await Task.Delay(1000);
                    //  Thread.CurrentThread.Join(1000);
                }
                catch (Exception ex)
                {
                    logger.Error(string.Format("ServerMessageTrigger  Ex:{0}", ex.ToString()));
                }
            }
        }


        private void AddConfirmMessage(string chargePointSerialNumber, int table_id, string requestId, string action, string msg_id)
        {
            NeedConfirmMessage _needConfirmMsg = new NeedConfirmMessage();
            _needConfirmMsg.Id = table_id;
            _needConfirmMsg.SentAction = action;
            _needConfirmMsg.SentOn = DateTime.Now;
            _needConfirmMsg.SentTimes = 1;
            _needConfirmMsg.ChargePointSerialNumber = chargePointSerialNumber;
            _needConfirmMsg.RequestId = requestId;
            _needConfirmMsg.SentUniqueId = msg_id;

            if (_needConfirmActions.Contains(action))
            {

                lock (_lockConfirmPacketList)
                {
                    NeedConfirmPacketList.Add(_needConfirmMsg);
                    if (action == "GetConfiguration")
                    {
                        Console.WriteLine("AddConfirmMessage: " + msg_id);
                    }
                }
            }
        }

        private void RemoveConfirmMessage()
        {

            var before_3mins = DateTime.Now.AddMinutes(-3);
            lock (_lockConfirmPacketList)
            {
                var removeList = NeedConfirmPacketList.Where(x => x.SentTimes == 0 || x.SentOn < before_3mins).ToList();
                foreach (var item in removeList)
                {
                    NeedConfirmPacketList.Remove(item);
                }
            }
        }

        private bool ReConfirmMessage(MessageResult analysisResult)
        {
            bool confirmed = false;
            if (_needConfirmActions.Contains(analysisResult.Action))
            {
                if (analysisResult.Action == "GetConfiguration")
                {
                    Console.WriteLine("ReConfirmMessage: " + analysisResult.UUID);
                }
                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 = new MainDBContext())
                    {
                        var sc = db.ServerMessage.Where(x => x.Id == foundRequest.Id).FirstOrDefault();
                        sc.InMessage = JsonConvert.SerializeObject(analysisResult.Message, Formatting.None);
                        sc.ReceivedOn = DateTime.Now;
                        db.SaveChanges();
                        Console.WriteLine(string.Format("Now:{0} ServerMessage Id:{1} ", DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"), foundRequest.Id));

                    }
                    confirmed = true;



                }
                else if (analysisResult.Action == Actions.TriggerMessage.ToString())
                {
                    confirmed = true;
                }
                else
                {
                    logger.Error(string.Format("Received no record Action:{0} MessageId:{1} ", analysisResult.Action, analysisResult.UUID));
                }
            }

            return confirmed;
        }




        private void RemoveClient(ClientData session)
        {
            Console.WriteLine("*********");

            if (session != null)
            {

                logger.Trace("RemoveClient[" + session.ChargeBoxId + "]");
                RemoveClientDic(session);
                try
                {
                    session.m_ReceiveData -= new ClientData.OCPPClientDataEventHandler<ClientData, String>(ReceivedMessage);
                    session.Close(CloseReason.ServerClosing);
                }
                catch (Exception ex)
                {
                    //logger.Warn("Close client socket error!!");
                    logger.Warn(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))
            {
                lock (_lockClientDic)
                {

                    if (ClientDic.ContainsKey(session.ChargeBoxId))
                    {
                        ClientDic.Remove(session.ChargeBoxId);
                        logger.Trace("RemoveClient ContainsKey " + session.ChargeBoxId);
                    }
                }
            }

        }

        private void WarmUpLog()
        {

            using (var log = new ConnectionLogDBContext())
            {
                log.MachineConnectionLog.ToList();
            }
        }

        private void WriteMachineLog(string sn, string data, string messageType, string errorMsg = "", bool isSent = false)
        {
            try
            {
                if (string.IsNullOrEmpty(sn) || string.IsNullOrEmpty(data)) return;
                using (var db = new ConnectionLogDBContext())
                {
                    string sp = "[dbo].[uspInsertMachineConnectionLog] @CreatedOn," +
                          "@ChargeBoxId,@MessageType,@Data,@Msg,@IsSent";
                    var dd = DateTime.Now;
                    SqlParameter[] parameter =
                    {
                      new SqlParameter("CreatedOn",dd),
                      new SqlParameter("ChargeBoxId",sn.Replace("'","''")),
                      new SqlParameter("MessageType",messageType.Replace("'","''")),
                      new SqlParameter("Data",data.Replace("'","''")),
                      new SqlParameter("Msg",errorMsg.Replace("'","''")),
                      new  SqlParameter("IsSent",isSent)
               };

                    db.Database.ExecuteSqlCommand(sp, parameter);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }


        }
    }
}