DC_Initlizer/AwInitilizer/Procedure/FirmwareCheckVersionProcedure.cs


using AwInitilizer.Assist;
using AwInitilizer.Model;
using CsuWebApiLib;
using InitializerModel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AwInitilizer.Procedure.FirmwareCheckVersion
{
    public enum ErrorType
    {
        None,
        RestartTimeout,
        VersionCheckFail,
    }

    public enum LogEvent
    {

    }

    public class FirmwareCheckVersionProcedure : ProcedureBase
    {
        public ErrorType Error { get; set; } = ErrorType.None;
        public Func<UpdateData, List<FirmwareUpdateModel>> GetFirmwareUpdateModel { get; set; }

        private ProcedureLog.LogWriter<FirmwareCheckVersionProcedure, LogEvent> LogWriter;

        private readonly static Dictionary<LogEvent, string> ReportDict = new Dictionary<LogEvent, string>()
        {
        };

        private readonly static Dictionary<LogEvent, string> LogDict = new Dictionary<LogEvent, string>()
        {
        };

        public FirmwareCheckVersionProcedure() : base()
        {
            Name = "Firmware Version Check";
            Content = "Wait restart and check firmware versions";

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

        internal override async Task<bool> Run()
        {
            var updateList = GetUpdateList();
            if (updateList == null || updateList.Count == 0)
            {
                LogWriter.Log("firmware list empty, skip procedure");
                return true;
            }

            if (UpdateData.IsIdleCheckPass)
            {
                return await RunWithNoBootCheck();
            }
            return await RunWithBootCheck();
        }

        internal async Task<bool> RunWithNoBootCheck()
        {
            await Task.Delay(TimeSpan.FromMinutes(2));
            await Task.Delay(5_000);

            int pollingCnt = 0;
            for (pollingCnt = 0; pollingCnt < 56; pollingCnt++)
            {
                await Task.Delay(TimeSpan.FromSeconds(15));

                var checkVersionResult = await CheckVersion();
                if (checkVersionResult)
                {
                    return true;
                }
            }

            Error = ErrorType.VersionCheckFail;
            return false;
        }

        internal async Task<bool> RunWithBootCheck()
        {
            //wait restart
            bool response = false;
            int pollingCnt = 0;
            await Task.Delay(TimeSpan.FromMinutes(2));
            for (pollingCnt = 0; pollingCnt < 56; pollingCnt++)
            {
                await Task.Delay(TimeSpan.FromSeconds(15));
                response = await ChekCsuBootCompelete();
                if (response)
                    break;
            }

            LogWriter.Log(string.Format("EVSE connet elapsed minute(s) : {0}, Expect:<16", (pollingCnt * 0.25) + 2));

            //timeout
            if (pollingCnt >= 56)
            {
                Error = ErrorType.RestartTimeout;

                return false;
            }

            await Task.Delay(5_000);

            //get version 
            var versionPair = await GetVersion();
            var updatedList = GetUpdateList();

            if (versionPair == null)
            {
                Error = ErrorType.VersionCheckFail;
                return false;
            }

            //check all version
            foreach (var model in updatedList)
            {
                var checkResult = CheckModelbyList(model, versionPair);
                if (!checkResult)
                {
                    Error = ErrorType.VersionCheckFail;
                    return false;
                }
            }

            return true;
        }

        private async Task<bool> CheckVersion()
        {
            //get version 
            var versionPair = await GetVersion();
            var updatedList = GetUpdateList();

            if (versionPair == null)
            {
                //Error = ErrorType.VersionCheckFail;
                return false;
            }

            foreach (var model in updatedList)
            {
                var checkResult = CheckModelbyList(model, versionPair);
                if (!checkResult)
                {
                    //Error = ErrorType.VersionCheckFail;
                    return false;
                }
            }

            return true;
        }

        private bool CheckModelbyList(FirmwareUpdateModel model, Dictionary<string,string> versionPair)
        {
            if (string.IsNullOrEmpty(model.Module))
            {
                return true;
            }

            var logPairName = $"{model.Module}VersionCheck";

            if (versionPair.Keys.Contains(model.Module))
            {
                LogWriter.Log(string.Format("Read {0} version : {1} , Expect:{2}", model.Module, versionPair[model.Module], model.Version));

                bool isVersionMatched = false;
                if (model.Module == "CsuRootFsFwRev" ||
                    model.Module.StartsWith("DDCsuRootFsFwRev"))
                {
                    isVersionMatched = versionPair[model.Module].StartsWith(model.Version);
                }
                else
                {
                    isVersionMatched = versionPair[model.Module] == model.Version;
                }

                if (isVersionMatched)
                {
                    LogWriter.Report(logPairName,"success");

                    return true;
                }
                else
                {
                    LogWriter.Report(logPairName, "fail", isError: true);

                    return false;
                }
            }
            else if (model.Module.ToLower() == "dtb")
            {
                //pass
                return true;
            }
            else
            {
                //model name not found
                LogWriter.Report(logPairName, "fail", isError: true);
                LogWriter.Log($"Model {model.Module} version not found");

                return false;
            }
        }

        internal async Task<Dictionary<string, string>> GetVersion(bool isConnectTest = false)
        {
            try
            {
                var result = await EvApi.GetVersion();
                LogWriter.Log($"get version response:{result.Response}", isDebugLog: true);
                return result.Result;
            }
            catch (Exception e)
            {
                if (!isConnectTest)
                {
                    LogWriter.Log("Get Version Failed");
                    LogWriter.Log(e.Message, isDebugLog: true);
                }

                return null;
            }
        }

        private List<FirmwareUpdateModel> GetUpdateList()
        {
            var updateList = UpdateData.FirmwareUpdateModels;
            if (GetFirmwareUpdateModel != null)
            {
                updateList = GetFirmwareUpdateModel(UpdateData);
            }
            return updateList;
        }
    }
}