DC_Initlizer/AwInitilizer/Procedure/VersionLogProcedure.cs

using AwInitilizer.Assist;
using CsuWebApiLib;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Markup;

namespace AwInitilizer.Procedure.VersionLog
{
    public class VersionLogProcedure : ProcedureBase
    {
        private static readonly string SoftwareVersionHeader = "FullsetTestingVersion";

        private static readonly List<string> excludeHeaderList = new List<string>()
        {
            "FactoryConfiguration",
            "DDFactoryConfiguration0",
            "DDFactoryConfiguration1",
            "DDFactoryConfiguration2",
            "FactoryConfiguration",
            "AuxPower5V",
            "AuxPower12V",
            "AuxPower24V",
            "AuxPower48V",
            "CsuHwRev",
            "FirmwareUpdate",
            "FanModuleHwRev",
            "RelayModuleHwRev"
        };

        private static readonly Dictionary<string, string> MesReportNamePair = new Dictionary<string, string>
        {
            { "CsuBootLoadFwRev","CSU Bootloader" },
            { "CsuKernelFwRev","CSU Kernel" },
            { "CsuRootFsFwRev","CSU Rootfs" },
            { "CsuPrimFwRev","Primary MCU" },
            { "FanModuleFwRev","FAN Module" },
            { "LedModuleFwRev","LED Module" },
            { "LcmFwRev","LCM UI" },
            { "RelayModuleFwRev","Relay Module" },
            { "PsuPrimFwRev","PSU Primary" },
            { "PsuSecFwRev","PSU Secondary" },
            { "TelcomModemFwRev","Telecom Module" },
            { "AuxPwrFwRev","Aux Power" },
            { "FourthGenModuleVersion","Fourth Gen Module" },
            { "Connector1FwRev","Connector 1" },
            { "Connector2FwRev","Connector 2" },
        };

        public enum ErrorType
        {
            None,
            ReadVersionFail,
        }

        public enum LogEvent
        {
        }

        public ErrorType Error { get; set; } = ErrorType.None;

        public bool ReportToMes { get; set; } = true;

        private ProcedureLog.LogWriter<VersionLogProcedure, LogEvent> LogWriter;

        public VersionLogProcedure() : base()
        {
            Name = "Version Logger";
            Content = "Report version back to MES";

            LogWriter = new ProcedureLog.LogWriter<VersionLogProcedure, LogEvent>(this);
        }

        internal override async Task<bool> Run()
        {
            var versionPair = await GetVersion();
            if (versionPair == null)
            {
                Error = ErrorType.ReadVersionFail;
                return false;
            }

            foreach (var infoPair in versionPair)
            {
                if (string.IsNullOrEmpty(infoPair.Value))
                {
                    continue;
                }

                if (!excludeHeaderList.Contains(infoPair.Key))
                {
                    var mesKey = GetMesReportKey(infoPair.Key);
                    if (ReportToMes)
                    {
                        LogWriter.Report(mesKey, infoPair.Value);
                    }
                    else
                    {
                        LogWriter.Log(string.Format("{0} {1}", mesKey, infoPair.Value));
                    }
                    //LogPair.Add(infoPair.Key, infoPair.Value);
                }
            }


            var assembly = System.Reflection.Assembly.GetExecutingAssembly();
            var version = assembly.GetName().Version.ToString();
            var gitVersion = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion;
            var logVersion = string.Format("{0}-{1}", version, gitVersion);

            if (ReportToMes)
            {
                LogWriter.Report(SoftwareVersionHeader, logVersion);
            }
            else
            {
                LogWriter.Log(string.Format("{0} {1}", SoftwareVersionHeader, logVersion));
            }

            return true;
        }

        private string GetMesReportKey(string readVersion)
        {
            if(MesReportNamePair.ContainsKey(readVersion))
            {
                return MesReportNamePair[readVersion];
            }
            return readVersion;
        }

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

                //Logger.Print("Get Version Failed", isError: true);
                //Logger.Print(e.Message + "", isError: true);

                //InfoLog += "Get Version Failed\n";
                //InfoLog += e.Message;
                //InfoLog += "\n";

                return null;
            }
        }
    }
}