DC_Initlizer/InitializerModel/EvseSettingConfig.cs

using Newtonsoft.Json;
using PhihongEv.Lib;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace InitializerModel
{
    public enum EvseSettingConfigLoadError
    {
        None,
        LoadConfigRootFolderNotfound,
        LoadConfigFolderNotfound,
        LoadConfigModelFolderNotfound,
        LoadConfigModelInitNotfound,
        LoadConfigModelInitFormatError,

        InitModelNameEmpty,
        InitModelNameError,
        InitIccidEmpty,
        InitImsiEmpty,
        InitFirmwareNameEmpty,
        InitFirmwareVersionEmpty,
        InitFirmwareFileEmpty,
        InitFirmwareFileMissing,
        InitFirmwareFileHeaderFormat,
    }

    public class EvseSettingConfigLoadResult
    {
        public EvseSettingConfigLoadError Error { get; set; }
        public EvseSettingConfigModel Result { get; set; }
        public string ErrorFirmware { get; set; }
        public string ConfigFolderPath { get; set; }
    }

    public static class EvseSettingConfig
    {
        public static List<string> GetModelList()
        {
            try
            {
                var defaultPath = AppSettingConfig.Instance.FirmwareRoot;
                if (string.IsNullOrEmpty(defaultPath))
                {
                    defaultPath = ".\\";
                }
                var settingRootFolder = Path.GetFullPath(defaultPath);
                var frimwareDirectorys = Directory.GetDirectories(settingRootFolder);
                return frimwareDirectorys.Select(x => Path.GetFileName(x)).ToList();
            }
            catch
            {

            }
            return new List<string>();
        }

        public static string GetModelFolder(string modelName)
        {
            var defaultPath = AppSettingConfig.Instance.FirmwareRoot;
            if (string.IsNullOrEmpty(defaultPath))
            {
                defaultPath = ".\\";
            }
            var settingRootFolder = Path.GetFullPath(defaultPath);
            string modelDirectoy = Path.Combine(settingRootFolder, modelName);
            return modelDirectoy;
        }

        public static string GetModelIniPath(string modelName)
        {
            var modelDirectoy = GetModelFolder(modelName);
            string modelSeettingFilePath = Path.Combine(modelDirectoy, modelName + ".ini");
            return modelSeettingFilePath;
        }

        public static EvseSettingConfigLoadResult TryLoad(string modelName)
        {
            var toReturn = new EvseSettingConfigLoadResult();
            string settingRootFolder;

            try
            {
                var defaultPath = AppSettingConfig.Instance.FirmwareRoot;
                if (string.IsNullOrEmpty(defaultPath))
                {
                    defaultPath = ".\\";
                }
                settingRootFolder = Path.GetFullPath(defaultPath);
            }
            catch
            {
                toReturn.Error = EvseSettingConfigLoadError.LoadConfigRootFolderNotfound;
                return toReturn;
            }

            if (!Directory.Exists(settingRootFolder))
            {
                toReturn.Error = EvseSettingConfigLoadError.LoadConfigFolderNotfound;
                return toReturn;
            }

            string modelDirectoy = Path.Combine(settingRootFolder, modelName);
            if (!Directory.Exists(modelDirectoy))
            {
                toReturn.Error = EvseSettingConfigLoadError.LoadConfigModelFolderNotfound;
                return toReturn;
            }
            toReturn.ConfigFolderPath = modelDirectoy;

            string modelSeettingFilePath = Path.Combine(modelDirectoy, modelName + ".ini");
            if (!File.Exists(modelSeettingFilePath))
            {
                toReturn.Error = EvseSettingConfigLoadError.LoadConfigModelInitNotfound;
                return toReturn;
            }

            //check format
            var settingString = File.ReadAllText(modelSeettingFilePath);
            EvseSettingConfigModel setting;
            try
            {
                setting = JsonConvert.DeserializeObject<EvseSettingConfigModel>(settingString);
                CompatibilityDataUpdate(setting);
            }
            catch
            {
                toReturn.Error = EvseSettingConfigLoadError.LoadConfigModelInitFormatError;
                return toReturn;
            }

            if (string.IsNullOrEmpty(setting.ModelName))
            {
                toReturn.Error = EvseSettingConfigLoadError.InitModelNameEmpty;
                return toReturn;
            }

            if (!ModelName.TryLooseParse(setting.ModelName, out _))
            {
                toReturn.Error = EvseSettingConfigLoadError.InitModelNameError;
                return toReturn;
            }

            if (setting.IsSimInsert)
            {
                if (string.IsNullOrEmpty(setting.SimICCID))
                {
                    toReturn.Error = EvseSettingConfigLoadError.InitIccidEmpty;
                    return toReturn;
                }

                if (string.IsNullOrEmpty(setting.SimIMSI))
                {
                    toReturn.Error = EvseSettingConfigLoadError.InitImsiEmpty;
                    return toReturn;
                }
            }

            if (setting.IsSubSimInsert)
            {
                if (string.IsNullOrEmpty(setting.SubSimICCID))
                {
                    toReturn.Error = EvseSettingConfigLoadError.InitIccidEmpty;
                    return toReturn;
                }

                if (string.IsNullOrEmpty(setting.SubSimIMSI))
                {
                    toReturn.Error = EvseSettingConfigLoadError.InitImsiEmpty;
                    return toReturn;
                }
            }

            if (setting.FirmwareUpdateList != null)
            {
                for (int firmwareIndex = 0; firmwareIndex < setting.FirmwareUpdateList.Count; firmwareIndex++)
                {
                    var model = setting.FirmwareUpdateList[firmwareIndex];
                    bool isVersionVaild = !string.IsNullOrEmpty(model.Version);
                    bool isFileNameVaild = !string.IsNullOrEmpty(model.FirmwareFileName);
                    bool isNoduleNameVaild = !string.IsNullOrEmpty(model.Module);

                    if (!isNoduleNameVaild)
                    {
                        //HintDialog.ShowMessage("Firmware module name should not empty");
                        //HintDialog.ShowMessage(Resx.AppResources.InitFirmwareNameEmptyAlert);
                        //isCheckPassed = false;
                        toReturn.Error = EvseSettingConfigLoadError.InitFirmwareNameEmpty;
                        return toReturn;
                    }
                    if (isVersionVaild || isFileNameVaild)
                    {
                        if (!isVersionVaild)
                        {
                            //HintDialog.ShowMessage($"Version should not empty while {model.Module} firmware is set");
                            //HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareVersionEmptyAlert, model.Module));
                            //isCheckPassed = false;
                            toReturn.Error = EvseSettingConfigLoadError.InitFirmwareVersionEmpty;
                            toReturn.ErrorFirmware = model.Module;
                            return toReturn;
                        }

                        //if (!isFileNameVaild)
                        //{
                        //    //HintDialog.ShowMessage($"File name should not empty while {model.Module} version is set");
                        //    //HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareFileEmptyAlert, model.Module));
                        //    //isCheckPassed = false;
                        //    toReturn.Error = EvseSettingConfigLoadError.InitFirmwareFileEmpty;
                        //    toReturn.ErrorFirmware = model.Module;
                        //    return toReturn;
                        //}

                        var folderPath = System.IO.Path.GetDirectoryName(modelSeettingFilePath);
                        if (isVersionVaild && isFileNameVaild)
                        {
                            var filePath = System.IO.Path.Combine(folderPath, model.FirmwareFileName);
                            //check file exist
                            if (!File.Exists(filePath))
                            {
                                ////HintDialog.ShowMessage($"{model.Module} Firemware file is missing");
                                //HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareFileMissingAlert, model.Module));
                                //isCheckPassed = false;
                                toReturn.Error = EvseSettingConfigLoadError.InitFirmwareFileMissing;
                                toReturn.ErrorFirmware = model.Module;
                                return toReturn;
                            }
                            else
                            {
                                try
                                {
                                    //isCheckPassed = CheckFileHeaderModel(setting, isCheckPassed, model, filePath);
                                }
                                catch
                                {
                                    //HintDialog.ShowMessage($"{model.Module} Firemware header ERROR");
                                    //HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareFileHeaderFormatAlert, model.Module));
                                    //isCheckPassed = false;
                                    toReturn.Error = EvseSettingConfigLoadError.InitFirmwareFileHeaderFormat;
                                    toReturn.ErrorFirmware = model.Module;
                                    return toReturn;
                                }

                                model.FirmwareFileName = filePath;
                            }
                        }
                    }
                }
            }

            toReturn.Error = EvseSettingConfigLoadError.None;
            toReturn.Result = setting;
            return toReturn;
        }

        private static void CompatibilityDataUpdate(EvseSettingConfigModel setting)
        {
            if (string.IsNullOrEmpty(setting.SimICCID))
            {
                setting.SimICCID = setting.ICCID;
            }
            if (string.IsNullOrEmpty(setting.SimIMSI))
            {
                setting.SimIMSI = setting.IMSI;
            }

            if (setting.SkipButtonTest)
            {
                setting.ButtonTestMode = ButtonTestModeType.SkipButtonTest;
            }
            if (setting.SkipEmergencyButton)
            {
                setting.ButtonTestMode = ButtonTestModeType.SkipEmergencyButton;
            }

            if (string.IsNullOrEmpty(setting.IpAddress))
            {
                setting.IpAddress = "192.168.1.10";
            }
        }
    }
}