DC_Initlizer/AwInitilizer/Procedure/BasicInfoUpdateProcedure.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace AwInitilizer.Procedure.BasicInfoUpdate
{
    public enum ErrorType
    {
        None,
        EvseConnectFail,
        ModelNameWriteFail,
        SerialNumberWriteFail,
        RtcUpdateFail,
        SettingSaveFail,
        RestartConnectFail,
        ModelNameGetFail,
        ModelNameMismach,
        SerialNumberGetFail,
        SerialNumberMismach,
        UtcTimeMismatch,
    }

    public enum LogEvent
    {
        EvseConnect,
        ModelNameWrite,
        SerialNumberWrite,
        RtcWrite,
        SettingSave,
        RestartConnect,
        ModelNameRead,
        SerialNumberRead,
        RtcRead,
    }

    public class BasicInfoUpdateProcedure : ProcedureBase
    {
        public ErrorType Error { get; set; } = ErrorType.None;

        private ProcedureLog.LogWriter<BasicInfoUpdateProcedure, LogEvent> LogWriter;

        private readonly static Dictionary<LogEvent, string> ReportDict = new Dictionary<LogEvent, string>()
        {
            {LogEvent.EvseConnect,"BaseUpdateSocketConnect" },
            {LogEvent.ModelNameWrite,"ModelNameWrite" },
            {LogEvent.SerialNumberWrite,"SerialNumberWrite" },
            {LogEvent.RtcWrite,"RtcUpdate" },
            {LogEvent.SettingSave,"SettingSave" },
            {LogEvent.RestartConnect,"BaseUpdateSocketReConnect" },
            {LogEvent.ModelNameRead,"ModelNameRead" },
            {LogEvent.SerialNumberRead,"SerialNumberRead" },
            {LogEvent.RtcRead,"RtcRead" },
        };

        private readonly static Dictionary<LogEvent, string> LogDict = new Dictionary<LogEvent, string>()
        {
            {LogEvent.EvseConnect,"EVSE connect {0}" },
            {LogEvent.ModelNameWrite,"Model Name write {0}" },
            {LogEvent.SerialNumberWrite,"Serial Number write {0}" },
            {LogEvent.RtcWrite,"RTC time write {0}" },
            {LogEvent.SettingSave,"Setting save {0}" },
            {LogEvent.RestartConnect,"Evse reconnect after write {0}" },
            {LogEvent.ModelNameRead,"Model Name read {0}" },
            {LogEvent.SerialNumberRead,"Serial Number read {0}" },
            {LogEvent.RtcRead,"RTC time read {0}" },
        };

        public BasicInfoUpdateProcedure() : base()
        {
            Name = "Basic Intlize";
            Content = "Set and check Model Name,SerilNumber,DateTime.";

            LogWriter = new ProcedureLog.LogWriter<BasicInfoUpdateProcedure, LogEvent>(this)
            {
                ReportPair = ReportDict,
                LogPair = LogDict
            };
        }

        internal override async Task<bool> Run()
        {
            if (!await base.CheckAndCreateSocket())
            {
                LogWriter.Report(LogEvent.EvseConnect, "fail", isError: true);
                Error = ErrorType.EvseConnectFail;

                return false;
            }

            //base.serialPortocol.OnMsgReceived += SerialPortocol_OnMsgReceived; 
            if (!await serialPortocol.SetModelName(UpdateData.ModelName))
            {
                LogWriter.Report(LogEvent.ModelNameWrite, "fail", isError: true);
                Error = ErrorType.ModelNameWriteFail;

                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.ModelNameWrite, "success");
            }

            if (!await serialPortocol.SetSerialNumber(UpdateData.SerialNumber))
            {
                LogWriter.Report(LogEvent.SerialNumberWrite, "fail", isError: true);
                Error = ErrorType.SerialNumberWriteFail;

                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.SerialNumberWrite, "success");
            }

            var setDateTime = DateTime.Now.ToUniversalTime();

            if (!await serialPortocol.SetUTCTime(setDateTime))
            {
                LogWriter.Report(LogEvent.RtcWrite, "fail", isError: true);
                Error = ErrorType.RtcUpdateFail;

                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.RtcWrite, "success");
            }

            if (!await serialPortocol.SettingChangeConfirm())
            {
                LogWriter.Report(LogEvent.SettingSave, "fail", isError: true);
                Error = ErrorType.SettingSaveFail;

                return false;
            }
            else
            {
                LogWriter.Report(LogEvent.SettingSave, "success");
            }

            LogWriter.Log("Waiting EVSE reboot...");

            serialPortocol.Close();
            await Task.Delay(TimeSpan.FromMinutes(1));

            if (!await base.CheckAndCreateSocket())
            {
                LogWriter.Report(LogEvent.RestartConnect, "fail", isError: true);
                Error = ErrorType.RestartConnectFail;

                return false;
            }

            var receivedModelName = await serialPortocol.GetModelName();
            //LogWriter.Report(LogEvent.ModelNameRead, receivedModelName);

            if (string.IsNullOrEmpty(receivedModelName))
            {
                LogWriter.Log("Model name get failed after reboot");
                LogWriter.Log(serialPortocol.LatestErrorMessage, isDebugLog: true);
                Error = ErrorType.ModelNameGetFail;
                LogWriter.Report(LogEvent.ModelNameRead, "empty" , isError: true);
                return false;
            }
            else
            {
                LogWriter.Log(string.Format("Read Model name : {0} , Expect:{1}", receivedModelName, UpdateData.ModelName));

                if (receivedModelName != UpdateData.ModelName)
                {
                    Error = ErrorType.ModelNameMismach;
                    LogWriter.Report(LogEvent.ModelNameRead, receivedModelName, isError: true);
                    return false;
                }
                LogWriter.Report(LogEvent.ModelNameRead, receivedModelName);
                LogWriter.Log("Model Name update Success");
            }

            var receivedSerialNumber = await serialPortocol.GetSerialNumber();
            //LogWriter.Report(LogEvent.SerialNumberRead, receivedSerialNumber);

            if (string.IsNullOrEmpty(receivedSerialNumber))
            {
                LogWriter.Log("Serial number get failed after reboot");
                LogWriter.Log(serialPortocol.LatestErrorMessage, isDebugLog: true);

                Error = ErrorType.SerialNumberGetFail;
                LogWriter.Report(LogEvent.SerialNumberRead, "empty" , isError: true);
                return false;
            }
            else
            {
                LogWriter.Log(string.Format("Read Serial number : {0} , Expect:{1}", receivedSerialNumber, UpdateData.SerialNumber));

                if (receivedSerialNumber != UpdateData.SerialNumber)
                {
                    Error = ErrorType.SerialNumberMismach;
                    LogWriter.Report(LogEvent.SerialNumberRead, receivedSerialNumber, isError: true);
                    return false;
                }
                LogWriter.Report(LogEvent.SerialNumberRead, receivedSerialNumber);
                LogWriter.Log("Serial Number update Success");
            }

            var receivedDateTime = await serialPortocol.GetUTCTime();
            //LogWriter.Report(LogEvent.RtcRead, receivedDateTime?.ToString("yyyyMMddHHmmss"));

            if (receivedDateTime == null)
            {
                LogWriter.Log("UTC Time receive failed");
                Error = ErrorType.EvseConnectFail;
                LogWriter.Report(LogEvent.RtcRead, "empty", isError: true);
                return false;
            }
            else
            {
                LogWriter.Log(string.Format("Read UTC time : {0} , CurrentTime:{1}", receivedDateTime?.ToString("yyyyMMddHHmmss"), DateTime.Now.ToUniversalTime().ToString("yyyyMMddHHmmss")));

                var diff = receivedDateTime.Value - DateTime.Now.ToUniversalTime();
                if (Math.Abs(diff.TotalSeconds) > 10)
                {
                    Error = ErrorType.UtcTimeMismatch;
                    LogWriter.Report(LogEvent.RtcRead, receivedDateTime?.ToString("yyyyMMddHHmmss"), isError: true);
                    return false;
                }
                LogWriter.Report(LogEvent.RtcRead, receivedDateTime?.ToString("yyyyMMddHHmmss"), isError: false);
                LogWriter.Log("UTC Time update Success");
            }

            for (var pollingCnt = 0; pollingCnt < 56; pollingCnt++)
            {
                await Task.Delay(TimeSpan.FromSeconds(15));
                var response = await ChekCsuBootCompelete();
                if (response)
                    break;
            }

            return true;
        }
    }
}