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;

namespace EVCB_OCPP.WSServer
{
    internal class ProtalServer
    {

        internal Dictionary<string, ClientData> ClientDic = new Dictionary<string, ClientData>();
        static private ILogger logger = NLog.LogManager.GetCurrentClassLogger();
        private readonly Object _lockClientDic = new object();
        private readonly Object _lockConfirmPacketList = new object();
        ProfileHandler _profileHandler = new ProfileHandler();
        private List<NeedConfirmMessage> NeedConfirmPacketList = new List<NeedConfirmMessage>();
        private List<string> _needConfirmActions = new List<string>()
        {
            "GetConfiguration",
            "ChangeConfiguration",
            "RemoteStartTransaction",
            "RemoteStopTransaction",
            "ChangeAvailability",
            "ClearCache",
            "DataTransfer",
            "Reset",
             "UnlockConnector",


        };
        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;

        }


        internal void Start()
        {
            OpenNetwork();


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

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

                switch (input.ToLower())
                {
                    case "stop":

                        break;

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

                    case "lc":
                        logger.Info("Command List Clients");

                        break;

                    case "lcn":
                        logger.Info("Command List Customer Name");

                        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;
                }
            }
        }

        private void InitEVSEConfigure(string sn)
        {
            List<MachineConfigure> configures = new List<MachineConfigure>();
            configures.Add(new MachineConfigure() { ConfigureName = StandardConfiguration.AuthorizeRemoteTxRequests, ConfigureSetting = "" });
            using (var db = new MainDBContext())
            {
                var _sn = db.MachineConfigure.Where(x => x.ChargeBoxId == sn).Select(x => x.ChargeBoxId).FirstOrDefault();
                if (string.IsNullOrEmpty(_sn))
                {
                    db.MachineConfigure.Add(new MachineConfigure()
                    {

                    });
                }
            }
        }


        private void OpenNetwork()
        {
            //載入OCPP Protocol
            var appServer = new OCPPWSServer(new OCPPSubProtocol());

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

            // llistener.Add(new ListenerConfig { Ip = "", Port = Convert.ToInt32(wssserverPort), Backlog = 100, Security = serverSecurity });
            llistener.Add(new ListenerConfig { Ip = "172.17.40.13", Port = Convert.ToInt32(2012), Backlog = 100, Security = "None" });

            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)
        {
            WriteMachineLog(session.ChargeBoxId, string.Format("CloseReason: {0}", value), "Connection", "");
            RemoveClient(session);
            // close Connection
        }

        private void AppServer_NewSessionConnected(ClientData session)
        {
            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);
                    WriteMachineLog(session.ChargeBoxId, "", "Connection", "");
                }
            }
            catch (Exception ex)
            {

            }


        }

        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}", analysisResult.Action, analysisResult.Id == 2 ? "Request" : (analysisResult.Id == 3 ? "Confirmation" : "Error")));

            if (analysisResult.Success == false)
            {
                //解析RawData就發生錯誤
                if (!string.IsNullOrEmpty(analysisResult.CallErrorMsg))
                {
                    Send(session, rawdata, 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":
                        {
                            if (!session.IsCheckIn && action == Actions.BootNotification)
                            {

                                var requestId = Guid.NewGuid();
                                //測試命令
                                try
                                {


                                    //using (var db = new MainDBContext())
                                    //{
                                    //    //db.MachineOperateRecord.Add(new MachineOperateRecord()
                                    //    //{
                                    //    //    CreatedOn = DateTime.Now,
                                    //    //    ChargePointSerialNumber = session.ChargePointSerialNumber,
                                    //    //    SerialNo = requestId.ToString(),
                                    //    //    RequestContent = JsonConvert.SerializeObject(new GetConfigurationRequest() { key = new List<string>() { StandardConfiguration.HeartbeatInterval } }),
                                    //    //    EVSE_Status = 0,
                                    //    //    Status = 0,
                                    //    //    RequestType = 1,


                                    //    //});
                                    //    //core 26 項 設定
                                    //    GetConfigurationRequest core_getConfigReq = new GetConfigurationRequest()
                                    //    {

                                    //        key = new List<string>()
                                    //     {
                                    //           StandardConfiguration.AuthorizeRemoteTxRequests,
                                    //           StandardConfiguration.ClockAlignedDataInterval,
                                    //           StandardConfiguration.ConnectionTimeOut,
                                    //           //StandardConfiguration.HeartbeatInterval,
                                    //           //StandardConfiguration.HeartbeatInterval,
                                    //           //StandardConfiguration.LocalAuthorizeOffline,
                                    //           //StandardConfiguration.LocalPreAuthorize,
                                    //           //StandardConfiguration.MeterValuesAlignedData,
                                    //           //StandardConfiguration.MeterValuesAlignedDataMaxLength,
                                    //           //StandardConfiguration.MeterValuesSampledData,
                                    //           //StandardConfiguration.MeterValuesSampledDataMaxLength,
                                    //           //StandardConfiguration.MeterValueSampleInterval,
                                    //           //StandardConfiguration.NumberOfConnectors,
                                    //           //StandardConfiguration.ResetRetries,
                                    //           //StandardConfiguration.ConnectorPhaseRotation,
                                    //           //StandardConfiguration.ConnectorPhaseRotationMaxLength,
                                    //           //StandardConfiguration.StopTransactionOnEVSideDisconnect,
                                    //           //StandardConfiguration.StopTransactionOnInvalidId,
                                    //           //StandardConfiguration.StopTxnAlignedData,
                                    //           //StandardConfiguration.StopTxnAlignedDataMaxLength,
                                    //           //StandardConfiguration.StopTxnSampledData,
                                    //           //StandardConfiguration.StopTxnSampledDataMaxLength,
                                    //           //StandardConfiguration.SupportedFeatureProfiles,
                                    //           //StandardConfiguration.SupportedFeatureProfilesMaxLength,
                                    //           //StandardConfiguration.TransactionMessageAttempts,
                                    //           //StandardConfiguration.TransactionMessageRetryInterval,
                                    //           //StandardConfiguration.UnlockConnectorOnEVSideDisconnect,
                                    //           //StandardConfiguration.WebSocketPingInterval

                                    //     }
                                    //    };
                                    //    db.ServerMessage.Add(new ServerMessage()
                                    //    {
                                    //        ChargeBoxId = session.ChargeBoxId,
                                    //        CreatedBy = "Server",
                                    //        CreatedOn = DateTime.Now,
                                    //        OutAction = Actions.GetConfiguration.ToString(),
                                    //        OutRequest = JsonConvert.SerializeObject(core_getConfigReq),
                                    //        SerialNo = Guid.Empty.ToString(),
                                    //        InMessage = string.Empty

                                    //    });

                                    //    db.SaveChanges();
                                    //}
                                }
                                catch (Exception ex)
                                {

                                }

                            }
                            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;
                                    }
                                }
                            }
                            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 (ConfirmMessage(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;
                    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 (ConfirmMessage(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;
                    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);
                    session.Send(msg);
                }

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


        }

        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.CreatedOn >= startDt && c.CreatedOn <= DateTime.Now).AsNoTracking().ToList();
                        //處理主機傳送的有指令
                        var cmdMachineList = commandList.Select(c => c.ChargeBoxId).Distinct().ToList();
                        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);



                                    }
                                }
                            }
                        }
                    }

                    Task.Delay(2000);
                }
                catch (Exception ex)
                {
                    logger.Error("ServerMessageTrigger stop");
                    logger.Error(ex);
                }
            }
        }


        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);
                }
            }
        }

        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 ConfirmMessage(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.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.Indented);
                        sc.ReceivedOn = DateTime.Now;
                        db.SaveChanges();

                    }
                    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)
        {
            logger.Trace("RemoveClient" + session.ChargeBoxId);
            RemoveClientDic(session);
            if (session != null)
            {
                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)
        {
            lock (_lockClientDic)
            {
                if (ClientDic.ContainsKey(session.ChargeBoxId))
                {
                    ClientDic.Remove(session.ChargeBoxId);
                    logger.Trace("RemoveClient ContainsKey " + session.ChargeBoxId);
                }
            }
        }

        private void WriteMachineLog(string sn, string data, string messageType, string errorMsg = "")
        {

            using (var db = new ConnectionLogDBContext())
            {
                string sp = "[dbo].[uspInsertMachineConnectionLog] @CreatedOn," +
                      "@ChargeBoxId,@MessageType,@Data,@Msg";
                var dd = DateTime.Now.AddDays(-1);
                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("'","''"))
               };

                db.Database.ExecuteSqlCommand(sp, parameter);
            }
        }
    }
}