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 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(2);
            CleanInputTimer.Tick += CleanInputTimer_Tick;

            Loaded += MainWindow_Loaded;
            PreviewKeyDown += MainWindow_PreviewKeyDown;

            //this.DataContext = new MainViewModel();
            this.DataContext = new MainViewModel() {
                //ModelName = "DSYE601E0ED2PH",
                //SerialNumber = "NeedSetupSN",
                //FourGenModuleVersion = "EC25AFFAR07A08M4G",
                //IsSimInsert = false,
                //ICCID = "12345678901234567890",
                //IMSI = "123456789012345",
                //CSUVersion = "V1.01.01.0601.00",
                //MCUVersion = "D0.52.40.1770.P0"
            };
            this.DataContextChanged += MainWindow_DataContextChanged;
        }

        private void MainWindow_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
        {

        }

        private void CleanInputTimer_Tick(object sender, EventArgs e)
        {
            CleanInputTimer.Stop();
            barCode = string.Empty;
        }

        private void MainWindow_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            barCode += e.Key;

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

            if (SystemID.TryParse(barCode,out SystemID systemID))
            {
                inputSystemID = systemID;
                uxModelName.Text = systemID.ModelName.ToString();
                uxSerialNumber.Text = systemID.SerialNumber;

                if(ViewModel!=null && !string.IsNullOrEmpty(ViewModel.ModelName))
                {
                    if (systemID.ModelName.ToString() != ViewModel.ModelName)
                    {
                        MessageBox.Show("Model Name Mismatch");
                    }
                }
            }
        }

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

            //uxProcedureDataGrid.ItemsSource = procedures;
        }

        private void StartInit_Click(object sender, RoutedEventArgs e)
        {
            if(CheckInputData())
            {
                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();

            ViewModel.IsUdatIng = true;
            var procedureList = ViewModel.UpdateProcedure.Where(x => x.IsActivated).ToList();
            int procedureIndex;
            for (procedureIndex = 0; procedureIndex < procedureList.Count; procedureIndex++)
            {
                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();
                if (!result)
                    break;
            }

            if (procedureIndex == procedureList.Count)
            {
                uxProgress.Value = 100;
                uxProgressRate.Content = "100%";
            }
            CreateLogFile();
            ViewModel.IsUdatIng = false;
        }

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

            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)
        {
            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 SettingFileSelect_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "Setting file|*.ini";
            openFileDialog.Multiselect = false;
            if (openFileDialog.ShowDialog() == true)
            {
                //check format
                var filePath = openFileDialog.FileName;
                if (!string.IsNullOrEmpty(filePath) &&
                    File.Exists(filePath))
                {
                    var settingString = File.ReadAllText(filePath);
                    SettingConfig setting;
                    try
                    {
                         setting = JsonConvert.DeserializeObject<SettingConfig>(settingString);
                    }
                    catch
                    {
                        MessageBox.Show("Setting file ERROR");
                        return;
                    }

                    if(CheckSettingConfig(System.IO.Path.GetDirectoryName(filePath),ref setting))
                    {
                        ViewModel.SettingModelName = setting.ModelName;
                        ViewModel.SettingFileName = Path.GetFileName(filePath);
                        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();
                    }
                }
            }
        }

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

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

            procedures.Add(new ButtonStatusCheckPorcedure());
            procedures.Add(new RestarttoIdelProcedure());

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