DC_Initlizer/AwInitilizer/MainWindow.xaml.cs

using AwInitilizer.Assist;
using AwInitilizer.Model;
using AwInitilizer.Procedure;
using InitializerModel;
using MesAdaptor;
using Microsoft.Win32;
using Newtonsoft.Json;
using PhihongEv.Lib;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Media.Media3D;
using System.Windows.Navigation;
using System.Windows.Threading;

namespace AwInitilizer
{
    enum UpdateStatus
    {
        Idle,
        Updating,
        Sucess,
        Fail
    }

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window, Interface.IIogger
    {
        public event EventHandler OnUpdateStarting;
        public event EventHandler OnUpdateCompleted;

        private DispatcherTimer LogoutTimer;

        private KeyinListener keyinListener;

        private bool IsInitilizing = false;

        private SystemID inputSystemID;
        private string csuFilePath;
        private string mcuFilePath;

        private ZhongShengLedControl ledControl;

        private MainViewModel ViewModel => DataContext as MainViewModel;

        private UpdateStatus _UpdateStatus = UpdateStatus.Idle;
        private UpdateStatus UpdateStatus
        {
            get => _UpdateStatus;
            set => SetUpdateStatus(value);
        }

        public MainWindow()
        {
            InitializeComponent();

            Title += "_V" + Assembly.GetExecutingAssembly().GetName().Version;

            ServicePointManager.ServerCertificateValidationCallback +=
                (sender, cert, chain, sslPolicyErrors) => true;
            System.Net.ServicePointManager.Expect100Continue = false;

            LogoutTimer = new DispatcherTimer();
            LogoutTimer.Interval = TimeSpan.FromMinutes(1);
            LogoutTimer.Tick += LogoutTimer_Tick;

            keyinListener = new KeyinListener(this);
            keyinListener.OnSystemIDReseived += KeyinListener_OnSystemIDReseived;

            if (!string.IsNullOrEmpty(AppSettingConfig.Instance.JohnSenLedComPort))
            {
                ledControl = new ZhongShengLedControl(AppSettingConfig.Instance.JohnSenLedComPort, this);
            }

            Loaded += MainWindow_Loaded;
            Closing += MainWindow_Closing;

            this.DataContext = new MainViewModel();

            //var test = SystemID.TryParse("AWLU770001W1P0D2045A001A0",out var systemID);
            //this.DataContext = new MainViewModel()
            //{
            //    SystemID = systemID,
            //    ModelName = "AWLU770001W1P0",
            //    SettingModelName = "AWLU770001W1P0",
            //    SerialNumber = "D2045A001A0",
            //    //FourGenModuleVersion = "EC25AFFAR07A08M4G",
            //    IsSimInsert = false,
            //    //ICCID = "12345678901234567890",
            //    //IMSI = "123456789012345",
            //    //CSUVersion = "V1.01.01.0601.00",
            //    //MCUVersion = "D0.52.40.1770.P0",
            //    IsInputCheckpassed = true,
            //    FirmwareUpdateModels = new List<FirmwareUpdateModel>(),

            //};
            UpdateProcedure();

            LogoutTimer.Start();
        }

        private void KeyinListener_OnSystemIDReseived(object sender, SystemID systemID)
        {
            SystemIDScanReseived(systemID);
        }

        private async void MainWindow_Closing(object sender, CancelEventArgs e)
        {
            //if (ledControl != null)
            //{
            //    e.Cancel = true;
            //    await Task.Factory.StartNew(async () =>
            //    {
            //        await ledControl?.DisposeAsync();
            //        Environment.Exit(0);
            //    }, TaskCreationOptions.AttachedToParent);
            //}
        }

        protected override void OnClosing(CancelEventArgs e)
        {
            base.OnClosing(e);

            try
            {
                LogoutTimer.Tick -= LogoutTimer_Tick;
                LogoutTimer.Stop();

                if (ledControl != null)
                {
                    Task.Factory.StartNew(() =>
                    {
                        ledControl?.DisposeAsync().Wait();
                    }, TaskCreationOptions.AttachedToParent).Wait();
                    //ledControl?.DisposeAsync().Wait();
                }
                //ledControl?.Dispose();
            }
            catch
            {

            }

            //Environment.Exit(0);
        }

        private void MainWindow_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            CheckDisplayManulEnterSN(e.Key);
            ResetLogoutTimer();
        }

        private void SystemIDScanReseived(SystemID systemID)
        {
            ViewModel.IsInputCheckpassed = false;
            inputSystemID = systemID;
            var serialNumber = systemID.ToString();
            if (!SajetConnect.SajetTransSnCheck(ref serialNumber))
            {
                HintDialog.ShowMessage(Resx.AppResources.SnWoMisMatch);
                return;
            }
            else
            {
                if (LoadConfigBySystemID(systemID))
                {
                    UpdateStatus = UpdateStatus.Idle;
                }
            }
        }

        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            Loaded -= MainWindow_Loaded;

            UpdateStatus = UpdateStatus.Idle;

            //init intilize procedure list
            //procedures.Add(new BasicInfoUpdateProcedure());
            //procedures.Add(new FourGenModuleCheckProcedure());
            //procedures.Add(new CsuFirmwareUpdateProcedure());
            //procedures.Add(new McuFirmwareUpdateProcedure());
            //procedures.Add(new ButtonStatusCheckPorcedure());
            //procedures.Add(new RestarttoIdleProcedure());

            //ViewModel.UpdateProcedure.Add(new VersionLogProcedure());

            //uxProcedureDataGrid.ItemsSource = procedures;\

            //            var test = new HintDialog();
            //            test.ImgPath = "pack://application:,,,/AwInitilizer;component/Image/Blue.png";
            //            test.Message = "BLUE BOTTON"
            //;           test.ShowDialog();

            DisplayLogin();

            var tester = new ProcedureBase();
            _ = tester.ChekCsuBootCompelete();
        }

        private void StartInit_Click(object sender, RoutedEventArgs e)
        {
            //check again
            ViewModel.IsInputCheckpassed = false;
            inputSystemID = ViewModel.SystemID;
            var serialNumber = inputSystemID.ToString();
            if (!SajetConnect.SajetTransSnCheck(ref serialNumber))
            {
                HintDialog.ShowMessage(Resx.AppResources.SnWoMisMatch);
                return;
            }

            ViewModel.IsInputCheckpassed = CheckInputData();
            if (ViewModel.IsInputCheckpassed)
            {
                ViewModel.IsUpdating = true;
                UpdateStatus = UpdateStatus.Updating;
                EvHttpClientLogger.Instance.StartNewLog(serialNumber);
                _ = UpdateTask();
            }
        }

        //private void CSUFileSelect_Click(object sender, RoutedEventArgs e)
        //{
        //    OpenFileDialog openFileDialog = new OpenFileDialog();
        //    if (openFileDialog.ShowDialog() == true){
        //        ViewModel.CSUFileName = openFileDialog.SafeFileName;
        //        ViewModel.CSUFilePath = openFileDialog.FileName;
        //    }
        //}

        //private void MCUFileSelect_Click(object sender, RoutedEventArgs e)
        //{
        //    OpenFileDialog openFileDialog = new OpenFileDialog();
        //    if (openFileDialog.ShowDialog() == true)
        //    {
        //        ViewModel.MCUFileName = openFileDialog.SafeFileName;
        //        ViewModel.MCUFilePath = openFileDialog.FileName;
        //    }
        //}

        #region
        private bool CheckInputData()
        {
            bool isAvaliable = true;
            string alertMsg = string.Empty;
            UpdateData updateData;
            if (DataContext is MainViewModel viewModel)
            {
                updateData = viewModel;
            }
            else
            {
                throw new Exception("DataContext type error");
            }


            if (string.IsNullOrEmpty(updateData.ModelName))
            {
                //alertMsg += "Model Name is Required\n";
                alertMsg += Resx.AppResources.ModelNameEmptyAlert + "\n";
                isAvaliable = false;
            }
            else if (ViewModel.SettingModelName != updateData.ModelName)
            {
                //alertMsg += "Model Name setting is Mismathed\n";
                alertMsg += Resx.AppResources.ModelNameMismatchAlert + "\n";
                isAvaliable = false;
            }

            if (string.IsNullOrEmpty(updateData.SerialNumber))
            {
                //alertMsg += "Serial Number is Required\n";
                alertMsg += Resx.AppResources.SerialNumberEmptyAlert + "\n";
                isAvaliable = false;
            }

            var systemIDString = updateData.ModelName + updateData.SerialNumber;
            if (!string.IsNullOrEmpty(systemIDString))
            {
                if (SystemID.TryLooseParse(systemIDString, out SystemID systemID))
                {
                    updateData.SystemID = systemID;
                }
                else
                {
                    //alertMsg += "Model Name format Error\n";
                    alertMsg += Resx.AppResources.ModelNameErrorAlert + "\n";
                    isAvaliable = false;
                }
            }

            if (updateData.SystemID != null &&
                updateData.SystemID.ModelName.Network.Description.Contains("4G"))
            {
                if (string.IsNullOrEmpty(updateData.FourGenModuleVersion))
                {
                    //alertMsg += "4G Module Version is Required\n";
                    alertMsg += Resx.AppResources.FourGenVersionEmptyAlert + "\n";
                    isAvaliable = false;
                }

                if (updateData.IsSimInsert)
                {
                    if (string.IsNullOrEmpty(updateData.SimICCID))
                    {
                        //alertMsg += "ICCID is Required when sim installed\n";
                        alertMsg += Resx.AppResources.IccidEmptyAlert + "\n";
                        isAvaliable = false;
                    }

                    if (string.IsNullOrEmpty(updateData.SimIMSI))
                    {
                        //alertMsg += "IMSI is Required when sim installed\n";
                        alertMsg += Resx.AppResources.ImsiEmptyAlert + "\n";
                        isAvaliable = false;
                    }
                }
            }

            if (updateData.FirmwareUpdateModels == null)
            {
                //alertMsg += "FirmwareUpdateModels should be decalred\n";
                alertMsg += Resx.AppResources.FirmwareListNullAlert + "\n";
                isAvaliable = false;
            }
            else
            {
                foreach (var model in updateData.FirmwareUpdateModels)
                {
                    if (string.IsNullOrEmpty(model.Module))
                    {
                        //alertMsg += "Firmware module name is Required\n";
                        alertMsg += Resx.AppResources.FirmwareNameEmptyAlert + "\n";
                        isAvaliable = false;
                    }

                    if (string.IsNullOrEmpty(model.Version))
                    {
                        //alertMsg += "Firmware module name is Required\n";
                        alertMsg += Resx.AppResources.FirmwareVersionEmptyAlert + "\n";
                        isAvaliable = false;
                    }

                    if (string.IsNullOrEmpty(model.FirmwareFileName))
                    {
                        //alertMsg += "Firmware file is Required\n";
                        alertMsg += Resx.AppResources.FirmwareFileEmptyAlert + "\n";
                        isAvaliable = false;
                    }
                }
            }

            if (!isAvaliable)
            {
                HintDialog.ShowMessage(alertMsg);
            }
            return isAvaliable;
        }

        private async Task UpdateTask()
        {
            DateTime startTime, stopTime;

            startTime = DateTime.Now;

            ProcedureBase.UpdateData = ViewModel;
            ProcedureBase.Logger = this;

            MesErrorCode mesErrorCode = MesErrorCode.None;

            OnUpdateStarting?.Invoke(this, null);

            //Dictionary<string, string> logPairs = new Dictionary<string, string>();
            ValueReportDatas reportDatas = new ValueReportDatas();
            //logPairs.Add("ModelName", ViewModel.SystemID.ModelName.ToString());
            //logPairs.Add("SerialNumber", ViewModel.SystemID.SerialNumber);
            EvHttpClient.ResetServerIpAddress(ViewModel.IpAddress);

            ViewModel.IsUpdating = true;
            var procedureList = ViewModel.UpdateProcedure.Where(x => x.IsActivated).ToList();
            int procedureIndex;
            for (procedureIndex = 0; procedureIndex < procedureList.Count; procedureIndex++)
            {
                procedureList[procedureIndex].MesLogData.Clear();
                procedureList[procedureIndex].Reset();
            }

            for (procedureIndex = 0; procedureIndex < procedureList.Count; procedureIndex++)
            {
                uxProgress.Value = (procedureIndex * 100 / procedureList.Count);
                uxProgressRate.Content = ((int)(procedureIndex * 100 / procedureList.Count)) + "%";
                uxStatusBar.Content = string.Format(Resx.AppResources.StatusBarUpdating, procedureList[procedureIndex].Name);// $"Processing {procedureList[procedureIndex].Name}";

                var result = await procedureList[procedureIndex].DoWork();

                foreach (var procedureLog in procedureList[procedureIndex].MesLogData)
                {
                    //logPairs[procedureLog.Key] = procedureLog.Val;
                    reportDatas.Add(procedureLog);
                }

                if (!result)
                {
                    mesErrorCode = Converter.MesErrorCodeMaper.GetMesErrorCode(procedureList[procedureIndex]);
                    break;
                }
            }

            //report MES result
            ReportMESLog(reportDatas);

            if (procedureIndex == procedureList.Count)
            {
                uxProgress.Value = 100;
                uxProgressRate.Content = "100%";
                UpdateStatus = UpdateStatus.Sucess;
                //report Success
                SajetConnect.SajetTranFinishSuccess();
                CsvReport(true, reportDatas);
            }
            else
            {
                UpdateStatus = UpdateStatus.Fail;
                //uxStatusBar.Content = $"Process {procedureList[procedureIndex].Name} Failed";
                uxStatusBar.Content = string.Format(Resx.AppResources.StatusBarFailed, procedureList[procedureIndex].Name);
                //report Fail
                SajetConnect.SajetTranFinishFail(mesErrorCode);
                CsvReport(false ,reportDatas);
            }

            stopTime = DateTime.Now;
            ViewModel.UpdateElpased = stopTime - startTime;

            CreateLogFile();
            CreateUploadCustomterLogFile();
            ViewModel.IsUpdating = false;
            ViewModel.IsInputCheckpassed = false;

            OnUpdateCompleted?.Invoke(this, null);
        }

        private void ReportMESLog(ValueReportDatas logPairs)
        {
            //report value
            var reportResult = SajetConnect.SajetTransReport(logPairs);
        }
        
        private void CsvReport(bool isTestPass, ValueReportDatas reportDatas)
        {
            var fileName = string.Format("{0}_{1}.csv", ViewModel.SystemID + ViewModel.SerialNumber, DateTime.Now.ToString("yyyyMMddHHmmssffff"));
            var folderName = "CSV";
            var filePath = Path.Combine(folderName, fileName);

            if (File.Exists(fileName))
            {
                File.Delete(fileName);
            }

            if (!Directory.Exists(folderName))
            {
                Directory.CreateDirectory(folderName);
            }

            FileStream fileStream = new FileStream(filePath, FileMode.Create);
            StreamWriter fileWriter = new StreamWriter(fileStream);

            fileWriter.WriteLine("key,value");
            fileWriter.WriteLine(string.Format("{0},{1}", "IsTestPass", isTestPass.ToString()));

            foreach (var data in reportDatas)
            {
                fileWriter.WriteLine(string.Format("{0},{1}", data.Key, data.Val));
            }
            fileWriter.Close();
            fileStream.Close();
        }

        private void CreateLogFile()
        {
            var fileName = ViewModel.SystemID + ViewModel.SerialNumber + DateTime.Now.ToString("yyyyMMddHHmmssffff") + ".txt";
            var folderName = "Log";
            var filePath = Path.Combine(folderName, fileName);
            string content = "";

            if (File.Exists(fileName))
            {
                File.Delete(fileName);
            }

            if (!Directory.Exists("Log"))
            {
                Directory.CreateDirectory("Log");
            }

            FileStream fileStream = new FileStream(filePath, FileMode.Create);
            StreamWriter fileWriter = new StreamWriter(fileStream);

            fileWriter.WriteLine("Barcode");
            fileWriter.WriteLine($"Model name:{ ViewModel.ModelName } , Serial number: { ViewModel.SerialNumber }");

            fileWriter.WriteLine("==========================");
            fileWriter.WriteLine("Setting file");
            fileWriter.WriteLine($"Model name:{ ViewModel.SettingModelName}");
            fileWriter.WriteLine($"4G Module Version:{ ViewModel.FourGenModuleVersion}");
            fileWriter.WriteLine($"Is sim insert:{ ViewModel.IsSimInsert}");
            fileWriter.WriteLine($"sim ICCID:{ ViewModel.SimICCID}");
            fileWriter.WriteLine($"sim IMSI:{ ViewModel.SimIMSI}");

            foreach (var model in ViewModel.FirmwareUpdateModels)
            {
                fileWriter.WriteLine($"{model.Module} version:{ model.Version}");
            }

            var procedureList = ViewModel.UpdateProcedure.ToList();
            for (int procedureIndex = 0; procedureIndex < procedureList.Count; procedureIndex++)
            {
                var procedure = procedureList[procedureIndex];
                fileWriter.WriteLine("==========================");
                fileWriter.WriteLine(procedure.Name);
                fileWriter.WriteLine("Is Activated:" + (procedure.IsActivated ? "Yes" : "No"));
                fileWriter.WriteLine("Status:" + procedure.Status.ToString());
                fileWriter.WriteLine(procedure.InfoLog);
            }

            fileWriter.WriteLine("==========================");
            fileWriter.Close();
            fileStream.Close();
        }

        private void CreateUploadCustomterLogFile()
        {
            var fileName = ViewModel.SystemID + ViewModel.SerialNumber + "_" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".txt";
            var folderName = "CustomerLog";
            var filePath = Path.Combine(folderName, fileName);

            if (File.Exists(fileName))
            {
                File.Delete(fileName);
            }

            if (!Directory.Exists("CustomerLog"))
            {
                Directory.CreateDirectory("CustomerLog");
            }

            CreateCustomerLog(filePath);
        }

        private void CreateCustomerLog(string filePath)
        {
            FileStream fileStream = new FileStream(filePath, FileMode.Create);
            StreamWriter fileWriter = new StreamWriter(fileStream);

            string borderString = "================================================================================";

            //fileWriter.WriteLine("                           Switch Mode Power Supply");
            fileWriter.WriteLine("                        Button Test and Firmware update");
            fileWriter.WriteLine("                                  test report");
            fileWriter.WriteLine("");

            fileWriter.WriteLine("Test Program Name : {0,-30}    ", "FirmwareUpdate");
            fileWriter.WriteLine("Serial No         : {0,-30}System Time  : {1}", ViewModel.SystemID.ToString(), DateTime.Now.ToString());
            fileWriter.WriteLine("Model Name        : {0,-30}Elapsed Time : {1}", ViewModel.ModelName, ViewModel.UpdateElpased.ToString(@"hh\:mm\:ss"));
            fileWriter.WriteLine("LOT Number        :                               Environment  : ");
            fileWriter.WriteLine("Order Number      :                               Inspector    : {0}", ViewModel.UserID);
            fileWriter.WriteLine("Customer          :                               Test Result  : {0}", ViewModel.UpdateProcedure.Last().Status == ProcedureStatus.PASS ? "PASS" : "FAIL");
            fileWriter.WriteLine("");

            fileWriter.WriteLine(borderString);

            for (int procedureIndex = 0; procedureIndex < ViewModel.UpdateProcedure.Count; procedureIndex++)
            {
                var procedure = ViewModel.UpdateProcedure[procedureIndex];
                fileWriter.WriteLine("STEP.{0} : {1,-63}{2,6}", procedureIndex + 1, procedure.Name, procedure.Status.ToString());
                foreach (var reportLog in procedure.ReportLog)
                {
                    fileWriter.WriteLine(reportLog);
                }
                fileWriter.WriteLine(borderString);
            }


            fileWriter.Close();
            fileStream.Close();
        }

        public void Print(string msg, bool isError = false)
        {
            SajetConnect.SajetTransLog(msg);
            Dispatcher.Invoke(() =>
            {
                Span line = new Span();
                line.Inlines.Add(msg + "\n");
                Span.SetForeground(line, isError ? Brushes.Red : Brushes.Green);

                //uxTerminal.Inlines.Add(line);
                //uxTerminalScroller.ScrollToEnd();
            });
            Console.WriteLine(msg);
        }
        #endregion

        private bool LoadConfigBySystemID(SystemID systemID)
        {
            var result = EvseSettingConfig.TryLoad(systemID.ModelName.ToString());
            EvseSettingConfigLoadError error = result.Error;

            if (error == EvseSettingConfigLoadError.LoadConfigRootFolderNotfound)
            {
                HintDialog.ShowMessage(Resx.AppResources.LoadConfigRootFolderNotfoundAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.LoadConfigFolderNotfound)
            {
                HintDialog.ShowMessage(Resx.AppResources.LoadConfigFolderNotfoundAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.LoadConfigModelFolderNotfound)
            {
                HintDialog.ShowMessage(Resx.AppResources.LoadConfigModelFolderNotfoundAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.LoadConfigModelInitNotfound)
            {
                HintDialog.ShowMessage(Resx.AppResources.LoadConfigModelInitNotfoundAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.LoadConfigModelInitFormatError)
            {
                HintDialog.ShowMessage(Resx.AppResources.LoadConfigModelInitFormatErrorAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitModelNameEmpty)
            {
                HintDialog.ShowMessage(Resx.AppResources.InitModelNameEmptyAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitModelNameError)
            {
                HintDialog.ShowMessage(Resx.AppResources.InitModelNameErrorAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitIccidEmpty)
            {
                HintDialog.ShowMessage(Resx.AppResources.InitIccidEmptyAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitImsiEmpty)
            {
                HintDialog.ShowMessage(Resx.AppResources.InitImsiEmptyAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitFirmwareNameEmpty)
            {
                HintDialog.ShowMessage(Resx.AppResources.InitFirmwareNameEmptyAlert);
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitFirmwareVersionEmpty)
            {
                HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareVersionEmptyAlert, result.ErrorFirmware));
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitFirmwareFileEmpty)
            {
                HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareFileEmptyAlert, result.ErrorFirmware));
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitFirmwareFileMissing)
            {
                HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareFileMissingAlert, result.ErrorFirmware));
                return false;
            }

            if (error == EvseSettingConfigLoadError.InitFirmwareFileHeaderFormat)
            {
                HintDialog.ShowMessage(string.Format(Resx.AppResources.InitFirmwareFileHeaderFormatAlert, result.ErrorFirmware));
                return false;
            }

            var setting = result.Result;

            ViewModel.SystemID = systemID;
            ViewModel.ModelName = systemID.ModelName.ToString();
            ViewModel.SerialNumber = systemID.SerialNumber;

            ViewModel.SettingModelName = setting.ModelName;
            //ViewModel.SettingFileName = Path.GetFileName(modelSeettingFilePath);
            ViewModel.FourGenModuleVersion = setting.FourGenModuleVersion;
            ViewModel.SubFourGenModuleVersion = setting.SubFourGenModuleVersion;
            ViewModel.IsSimInsert = setting.IsSimInsert;
            ViewModel.SimICCID = setting.SimICCID;// string.IsNullOrEmpty(setting.ICCID) ? setting.SimICCID : setting.ICCID;
            ViewModel.SimIMSI = setting.SimIMSI;// string.IsNullOrEmpty(setting.IMSI) ? setting.SimIMSI: setting.IMSI;
            ViewModel.IsSubSimInsert = setting.IsSubSimInsert;
            ViewModel.SubSimICCID = setting.SubSimICCID;
            ViewModel.SubSimIMSI = setting.SubSimIMSI;
            ViewModel.ButtonTestMode = setting.ButtonTestMode;
            //ViewModel.SkipEmergencyButton = setting.SkipEmergencyButton;
            //ViewModel.SkipButtonTest = setting.SkipButtonTest;
            ViewModel.IpAddress = setting.IpAddress;
            ViewModel.FirmwareUpdateModels = setting.FirmwareUpdateList
                .Where(x => !string.IsNullOrEmpty(x.Module) && !string.IsNullOrEmpty(x.FirmwareFileName)
                ).ToList();

            UpdateProcedure();
            ViewModel.IsInputCheckpassed = CheckInputData();
            return true;
        }

        private void UpdateProcedure()
        {
            List<ProcedureBase> procedures = new List<ProcedureBase>();

            //init intilize procedure list

            procedures.Add(new Procedure.BasicInfoUpdate.BasicInfoUpdateProcedure());
            procedures.Add(new Procedure.FourGenModuleCheck.FourGenModuleCheckProcedure());
            procedures.Add(new Procedure.WifRssiCheck.WifRssiCheckProcedure());
            procedures.Add(new Procedure.TelcomModemImeiRecord.TelcomModemImeiRecordProcedure());
            procedures.Add(new Procedure.FirmwareBundleUpload.FirmwareBundleUploadProcedure());
            //procedures.Add(new Procedure.FirmwareBundleUpload.FirmwareFtpUploadProcedure());
            procedures.Add(new Procedure.FirmwareCheckVersion.FirmwareCheckVersionProcedure());
            procedures.Add(new Procedure.ButtonStatusCheck.ButtonStatusCheckPorcedure());
            procedures.Add(new Procedure.RestarttoIdle.RestarttoIdleProcedure());
            procedures.Add(new Procedure.VersionLog.VersionLogProcedure());
            if (AppSettingConfig.Instance.IsDisableAuthRequired)
            {
                procedures.Add(new Procedure.FactoryAssist.DsiableChargeAuthProcedure());
            }

            //procedures.Add(new Procedure.BasicInfoUpdate.BasicInfoUpdateProcedure());
            //procedures.Add(new Procedure.FourGenModuleCheck.FourGenModuleCheckProcedure());
            //procedures.Add(new Procedure.WifRssiCheck.WifRssiCheckProcedure());
            //procedures.Add(new Procedure.FirmwareBundleUpload.FirmwareBundleUploadProcedure());
            //procedures.Add(new Procedure.FirmwareCheckVersion.FirmwareCheckVersionProcedure());
            //procedures.Add(new Procedure.ButtonStatusCheck.ButtonStatusCheckPorcedure());
            //procedures.Add(new Procedure.RestarttoIdel.RestarttoIdleProcedure());
            //procedures.Add(new Procedure.VersionLog.VersionLogProcedure());

            //for (int firemwareIndex = 0; firemwareIndex < ViewModel.FirmwareUpdateModels.Count ; firemwareIndex++)
            //{
            //    //procedures.Add(new FirmwareUpdateProcedure(ViewModel.FirmwareUpdateModels[firemwareIndex]));
            //    procedures.Add(new FirmwareUploadProcedure(ViewModel.FirmwareUpdateModels[firemwareIndex]));
            //}

            ViewModel.UpdateProcedure.Clear();

            foreach (var p in procedures)
            {
                ViewModel.UpdateProcedure.Add(p);
            }

            //uxProcedureDataGrid.ItemsSource = procedures;
        }

        private void ResetLogoutTimer()
        {
            if (LogoutTimer != null)
            {
                logoutCheckCnt = 0;
                LogoutTimer.Stop();
                LogoutTimer.Start();
            }
        }

        private void DisplayLogin()
        {
            LogoutTimer?.Stop();
            ViewModel.UserID = "";
            ViewModel.WorkOrder = "";

            var signinDialog = new SigninDialog();
            try
            {
                signinDialog.Owner = this;
            }
            catch
            {

            }
            signinDialog.ShowDialog();
            this.Focus();

            //SystemID.TryLooseParse("DSYE122E0ED5P7D2212A011A0", out var systemID);
            //SystemIDScanReseived(systemID);

            if (signinDialog.DialogResult != true)
            {
                SajetConnect.SajetTransClose();
                App.Current.Shutdown();
            }
            else
            {
                ViewModel.UserID = signinDialog.UserId;
                ViewModel.WorkOrder = signinDialog.WorkOrder;
                LogoutTimer?.Start();
            }
        }

        private int logoutCheckCnt = 0;
        private void LogoutTimer_Tick(object sender, EventArgs e)
        {
            LogoutTimer.Stop();

            if (ViewModel.IsUpdating)
            {
                logoutCheckCnt = 0;
                LogoutTimer.Start();
                Console.WriteLine("LogoutTimer_Tick reset");
                return;
            }
            else if (++logoutCheckCnt > 10)
            {
                logoutCheckCnt = 0;
                DisplayLogin();

                Console.WriteLine("LogoutTimer_Tick DisplayLogin");
            }
            else
            {
                LogoutTimer.Start();

                Console.WriteLine("LogoutTimer_Tick continue");
            }
        }

        private void Logout_Click(object sender, RoutedEventArgs e)
        {
            DisplayLogin();
        }

        private void WorkOrder_TextChanged(object sender, TextChangedEventArgs e)
        {
            //ViewModel.IsInputCheckpassed = false;
        }

        private void WorkOrder_KeyDown(object sender, KeyEventArgs e)
        {
            //ViewModel.IsInputCheckpassed = true;
            if (e.Key == Key.Enter && ViewModel.SystemID != null)
            {
                SystemIDScanReseived(ViewModel.SystemID);
            }
        }

        private void SetUpdateStatus(UpdateStatus status)
        {
            if (status == UpdateStatus.Idle)
            {
                uxStatusContainer.Background = new SolidColorBrush(Colors.White);
                uxStatus.Foreground = new SolidColorBrush(Colors.Black);
                uxStatus.Content = Resx.AppResources.StatusIdel;//"Idel";
                uxStatusBar.Content = "";
            }
            else if (status == UpdateStatus.Updating)
            {
                uxStatusContainer.Background = new SolidColorBrush(Colors.SkyBlue);
                uxStatus.Foreground = new SolidColorBrush(Colors.Black);
                uxStatus.Content = Resx.AppResources.StatusUpdating;//"Updating";
            }
            else if (status == UpdateStatus.Sucess)
            {
                uxStatusContainer.Background = new SolidColorBrush(Colors.Green);
                uxStatus.Foreground = new SolidColorBrush(Colors.White);
                uxStatus.Content = Resx.AppResources.StatusSuccess;//"Success";
                uxStatusBar.Content = "";
            }
            else if (status == UpdateStatus.Fail)
            {
                uxStatusContainer.Background = new SolidColorBrush(Colors.Red);
                uxStatus.Foreground = new SolidColorBrush(Colors.White);
                uxStatus.Content = Resx.AppResources.StatusFail;//"Fail";
            }
        }

        private void CheckDisplayManulEnterSN(Key key)
        {
            if (key != Key.F1)
            {
                return;
            }

            var dialog = new ManualSn() {};
            try
            {
                dialog.Owner = Application.Current.MainWindow;
            }
            catch
            {

            }
            dialog.ShowDialog();
            var enteredSN = dialog.EnteredSn;

            if (string.IsNullOrEmpty(enteredSN)||
               !SystemID.TryLooseParse(enteredSN, out var enteredSystemID))
            {
                return;
            }

            SystemIDScanReseived(enteredSystemID);
        }
    }
}