DC_Initlizer/AwInitilizer/MainWindow.xaml.cs

using AwInitilizer.Model;
using AwInitilizer.Procedure;
using Microsoft.Win32;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
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.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Threading;

namespace AwInitilizer
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window, Interface.IIogger
    {
        private string barCode = string.Empty;
        private DispatcherTimer CleanInputTimer;
        private DispatcherTimer LogoutTimer;

        private bool IsInitilizing = false;

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

        private MainViewModel ViewModel => DataContext as MainViewModel;

        public MainWindow()
        {
            InitializeComponent();

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

            CleanInputTimer = new DispatcherTimer();
            CleanInputTimer.Interval = TimeSpan.FromSeconds(1);
            CleanInputTimer.Tick += CleanInputTimer_Tick;

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

            Loaded += MainWindow_Loaded;
            PreviewKeyDown += MainWindow_PreviewKeyDown;
            PreviewKeyUp += MainWindow_PreviewKeyUp;

            SystemID.TryParse("AWLU770001W1P0D2045A001A0", out var systemID);
            //this.DataContext = new MainViewModel();
            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>(),

            };
            this.DataContextChanged += MainWindow_DataContextChanged;
        }

        private void MainWindow_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
        {

        }

        private void CleanInputTimer_Tick(object sender, EventArgs e)
        {
            CleanInputTimer.Stop();

            Console.WriteLine(barCode);

            if (SystemID.TryParse(barCode, out SystemID systemID))
            {
                SystemIDScanReseived(systemID);
            }

            barCode = string.Empty;
        }

        bool shiftPressed = false;
        private void MainWindow_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            ResetLogoutTimer();

            if (e.Key == Key.LeftShift || e.Key == Key.RightShift)
            {
                shiftPressed = true;
                return;
            }
            else if (e.Key == Key.Enter)
            {
                e.Handled = true;
                return;
            }
            else
            {
                if (e.Key >= Key.D0 && e.Key <= Key.D9)
                {
                    // Number keys pressed so need to so special processing
                    // also check if shift pressed
                    var input = e.Key.ToString();
                    input = input.Remove(0, 1);
                    barCode += input;
                }
                else if (e.Key == Key.OemMinus)
                {
                    barCode += "-";
                }
                else if (e.Key == Key.Return)
                {
                    return;
                }
                else
                {
                    var input = e.Key.ToString();
                    if (shiftPressed)
                        input = input.ToUpper();
                    barCode += input;
                }
            }

            CleanInputTimer.Stop();
            CleanInputTimer.Start();
        }

        private void SystemIDScanReseived(SystemID systemID)
        {
            ViewModel.IsInputCheckpassed = false;
            inputSystemID = systemID;
            var serialNumber = inputSystemID.SerialNumber;
            if (!DLL.SajetConnect.SajetTransSnCheck(ref serialNumber))
            {
                MessageBox.Show("Serial Number or WorkOrder Error");
                return;
            }

            LoadConfigBySystemID(systemID);
        }

        private void MainWindow_PreviewKeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.LeftShift || e.Key == Key.RightShift)
            {
                shiftPressed = false;
            }
        }

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

            //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 RestarttoIdelProcedure());

            //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();
        }

        private void StartInit_Click(object sender, RoutedEventArgs e)
        {
            //check again
            ViewModel.IsInputCheckpassed = false;
            inputSystemID = ViewModel.SystemID;
            var serialNumber = inputSystemID.SerialNumber;
            if (!DLL.SajetConnect.SajetTransSnCheck(ref serialNumber))
            {
                MessageBox.Show("Serial Number or WorkOrder Error");
                return;
            }

            ViewModel.IsInputCheckpassed = CheckInputData();
            if (ViewModel.IsInputCheckpassed)
            {
                ViewModel.IsUdatIng = true;
                _ = 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";
                isAvaliable = false;
            }
            else if (ViewModel.SettingModelName != updateData.ModelName)
            {
                alertMsg += "Model Name setting is Mismathed\n";
                isAvaliable = false;
            }

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

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

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

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

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

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

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

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

            if (!isAvaliable)
            {
                MessageBox.Show(alertMsg);
            }
            return isAvaliable;
        }

        private async Task UpdateTask()
        {
            ProcedureBase.UpdateData = ViewModel;
            ProcedureBase.Logger = this;
            uxTerminal.Inlines.Clear();

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

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

            for (procedureIndex = 0; procedureIndex < procedureList.Count; procedureIndex++)
            {
                uxProgress.Value = (procedureIndex * 100 / procedureList.Count);
                uxProgressRate.Content = ((int)(procedureIndex * 100 / procedureList.Count)) + "%";
                var result = await procedureList[procedureIndex].DoWork();

                foreach(var procedureLog in procedureList[procedureIndex].LogPair)
                {
                    if (logPairs.ContainsKey(procedureLog.Key))
                    {
                        logPairs[procedureLog.Key] = procedureLog.Value;
                    }
                    else
                    {
                        logPairs.Add(procedureLog.Key, procedureLog.Value);
                    }
                }

                if (!result)
                    break;
            }


            //report MES result
            ReportMESLog(logPairs);

            if (procedureIndex == procedureList.Count)
            {
                uxProgress.Value = 100;
                uxProgressRate.Content = "100%";
                //report Success
                DLL.SajetConnect.SajetTranFinish(true);
            }
            CreateLogFile();
            ViewModel.IsUdatIng = false;
        }

        private void ReportMESLog(Dictionary<string, string> logPairs)
        {
            //build header
            Dictionary<string, int> valuePairs = new Dictionary<string, int>();
            foreach (var pair in logPairs)
            {
                if(int.TryParse(pair.Value,out int val))
                {
                    valuePairs.Add(pair.Key,val);
                }
                else
                {
                    valuePairs.Add(string.Format("{0}:{1}", pair.Key, pair.Value),1);
                }
            }
            //register Header
            var codePair = new Dictionary<string, string>();
            var model = ViewModel.SystemID.ModelName.ToString();
            foreach(var key in valuePairs.Keys)
            {
                var code = DLL.SajetConnect.SajetTransRegisterHeader(model,key);
                if (string.IsNullOrEmpty(code))
                    continue;
                codePair.Add(key, code);
            }
            //report value
            var reportResult = DLL.SajetConnect.SajetTransReport(valuePairs, codePair);
        }

        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.ICCID}");
            fileWriter.WriteLine($"sim IMSI:{ ViewModel.IMSI}");

            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();
        }

        public void Print(string msg, bool isError = false)
        {
            DLL.SajetConnect.SajetTransLog(msg, isError);
            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();
            });
        }
        #endregion

        private void LoadConfigBySystemID(SystemID systemID)
        {
            string settingRootFolder;
            try
            {
                var defaultPath = Properties.Settings.Default.FirmwareRoot;
                if(string.IsNullOrEmpty(defaultPath))
                {
                    defaultPath = ".\\";
                }
                settingRootFolder = Path.GetFullPath(defaultPath);
            }
            catch
            {
                MessageBox.Show("Firmware root path ERROR");
                return;
            }

            if (!Directory.Exists(settingRootFolder))
            {
                MessageBox.Show("Firmware root path not exist");
                return;
            }

            string modelDirectoy = Path.Combine(settingRootFolder, systemID.ModelName.ToString());
            if (!Directory.Exists(modelDirectoy))
            {
                MessageBox.Show("Model firmware root path not exist");
                return;
            }

            string modelSeettingFilePath = Path.Combine(modelDirectoy, systemID.ModelName.ToString() + ".ini");
            if (!File.Exists(modelSeettingFilePath))
            {
                MessageBox.Show("Model firmware setting not exist");
                return;
            }

            //check format
            var settingString = File.ReadAllText(modelSeettingFilePath);
            SettingConfig setting;
            try
            {
                setting = JsonConvert.DeserializeObject<SettingConfig>(settingString);
            }
            catch
            {
                MessageBox.Show("Setting file ERROR");
                return;
            }

            if (CheckSettingConfig(System.IO.Path.GetDirectoryName(modelSeettingFilePath), ref setting))
            {
                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.IsSimInsert = setting.IsSimInsert;
                ViewModel.ICCID = setting.ICCID;
                ViewModel.IMSI = setting.IMSI;
                ViewModel.FirmwareUpdateModels = setting.FirmwareUpdateList
                    .Where(x => !string.IsNullOrEmpty(x.Module) && !string.IsNullOrEmpty(x.Version) && !string.IsNullOrEmpty(x.FirmwareFileName)
                    ).ToList();

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

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

            //init intilize procedure list
            
            procedures.Add(new BasicInfoUpdateProcedure());
            procedures.Add(new ButtonStatusCheckPorcedure());
            procedures.Add(new FourGenModuleCheckProcedure());
            for (int firemwareIndex = 0; firemwareIndex < ViewModel.FirmwareUpdateModels.Count ; firemwareIndex++)
            {
                procedures.Add(new FirmwareUpdateProcedure(ViewModel.FirmwareUpdateModels[firemwareIndex]));
            }
            procedures.Add(new RestarttoIdelProcedure());
            procedures.Add(new VersionLogProcedure());

            ViewModel.UpdateProcedure.Clear();

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

            //uxProcedureDataGrid.ItemsSource = procedures;
        }

        private bool CheckSettingConfig(string folderPath, ref SettingConfig setting)
        {
            if (setting == null)
                return false;
            bool isCheckPassed = true;

            if (string.IsNullOrEmpty(setting.ModelName))
            {
                MessageBox.Show("ModelName is requred");
                isCheckPassed = false;
            }
            else if(!ModelName.TryParse(setting.ModelName,out _))
            {
                MessageBox.Show("ModelName format Error");
                isCheckPassed = false;
            }

            if (setting.IsSimInsert)
            {
                if (string.IsNullOrEmpty(setting.ICCID))
                {
                    MessageBox.Show("ICCID should not empty while IsSimInsert is set");
                    isCheckPassed = false;
                }

                if (string.IsNullOrEmpty(setting.IMSI))
                {
                    MessageBox.Show("IMSI should not empty while IsSimInsert is set");
                    isCheckPassed = false;
                }
            }

            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)
                    {
                        MessageBox.Show("Firmware module name should not empty");
                        isCheckPassed = false;
                    }
                    if (isVersionVaild || isFileNameVaild)
                    {
                        if (!isVersionVaild)
                        {
                            MessageBox.Show($"Version should not empty while {model.Module} firmware is set");
                            isCheckPassed = false;
                        }

                        if (!isFileNameVaild)
                        {
                            MessageBox.Show($"File name should not empty while {model.Module} version is set");
                            isCheckPassed = false;
                        }

                        if (isVersionVaild && isFileNameVaild)
                        {
                            var filePath = System.IO.Path.Combine(folderPath, model.FirmwareFileName);
                            //check file exist
                            if (!File.Exists(filePath))
                            {
                                MessageBox.Show($"{model.Module} Firemware file is missing");
                                isCheckPassed = false;
                            }
                            else
                            {
                                try
                                {
                                    using (var fs = File.OpenRead(filePath))
                                    {
                                        byte[] systemIDBytes = new byte[16];
                                        if (fs.Read(systemIDBytes, 0, 16) == 16)
                                        {
                                            if (systemIDBytes.ToList().Contains(0x00))
                                            {
                                                int endIndex = Array.FindIndex(systemIDBytes, (x) => { return x == 0x00; });
                                                //int endIndex = parameter.FindIndex((x) => { return x == 0x00; });
                                                if (endIndex != default && endIndex != -1)
                                                {
                                                    systemIDBytes = systemIDBytes.Take(endIndex).ToArray();
                                                }
                                            }

                                            if (ModelName.TryParse(systemIDBytes, out var modelName))
                                            {
                                                if (modelName.ToString() != setting.ModelName)
                                                {
                                                    MessageBox.Show($"{model.Module} Firemware and ModelName is Mismatched");
                                                    isCheckPassed = false;
                                                }
                                            }
                                            else
                                            {
                                                MessageBox.Show($"{model.Module} Firemware header ERROR");
                                                isCheckPassed = false;
                                            }
                                        }
                                        else
                                        {
                                            MessageBox.Show($"{model.Module} Firemware header ERROR");
                                            isCheckPassed = false;
                                        }

                                        //byte[] imgType = new byte[4];
                                        //if (fs.Read(imgType, 0, 4) == 4)
                                        //{
                                        //    if (!imgType.SequenceEqual(new byte[] { 0x10, 0x00, 0x00, 0x04, }))
                                        //    {
                                        //        MessageBox.Show($"{model.Module} Firemware type ERROR");
                                        //        isCheckPassed = false;
                                        //    }
                                        //}
                                        //else
                                        //{
                                        //    MessageBox.Show($"{model.Module} Firemware header ERROR");
                                        //    isCheckPassed = false;
                                        //}
                                    }
                                }
                                catch
                                {
                                    MessageBox.Show($"{model.Module} Firemware header ERROR");
                                    isCheckPassed = false;
                                }

                                model.FirmwareFileName = filePath;
                            }
                        }
                    }
                }
            }

            return isCheckPassed;
        }

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

        private void DisplayLogin()
        {
            LogoutTimer?.Stop();
            var signinDialog = new SigninDialog();
            signinDialog.Owner = this;
            signinDialog.ShowDialog();
            if (signinDialog.DialogResult != true)
            {
                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.IsUdatIng)
            {
                logoutCheckCnt = 0;
                return;
            }
            if (++logoutCheckCnt > 10)
            {
                logoutCheckCnt = 0;
                DisplayLogin();
            }
            else
            {
                LogoutTimer.Start();
            }
        }

        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);
            }
        }
    }
}