Kepler-Release/Venus/Venus_MainPages/ViewModels/GasLeakCheckViewModel.cs

using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Microsoft.Win32;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Venus_Core;
using Venus_Themes.CustomControls;
using Venus_Unity;

namespace Venus_MainPages.ViewModels
{
    internal class GasLeakCheckViewModel : BindableBase
    {
        #region 私有字段
        private List<string> m_LeakCheckMode;
        private int m_LeakCheckModeSelectedIndex;
        private int m_VentTime;
        private int m_CheckTime;
        private double m_LeakRateUpperLimit;
        private int m_BasePressure;

        private bool[] m_GasIsCheck=new bool[9];
        private string ModuleName="PMA";

        private AITMfcData m_MFC1Data;
        private AITMfcData m_MFC2Data;
        private AITMfcData m_MFC3Data;
        private AITMfcData m_MFC4Data;
        private AITMfcData m_MFC5Data;
        private AITMfcData m_MFC6Data;
        private AITMfcData m_MFC7Data;
        private AITMfcData m_MFC8Data;
        private ObservableCollection<PMLeakCheckResult> m_LeakCheckResultList=new ObservableCollection<PMLeakCheckResult>();    

        #region 阀
        private bool m_PVN21ValveIsOpen;
        private bool m_PVN22ValveIsOpen;
        private bool m_N2ValveIsOpen;
        private bool m_PV11ValveIsOpen;
        private bool m_PV12ValveIsOpen;
        private bool m_PV21ValveIsOpen;
        private bool m_PV22ValveIsOpen;
        private bool m_PV31ValveIsOpen;
        private bool m_PV32ValveIsOpen;
        private bool m_PV41ValveIsOpen;
        private bool m_PV42ValveIsOpen;
        private bool m_MFC1ValveIsOpen;
        private bool m_MFC2ValveIsOpen;
        private bool m_MFC3ValveIsOpen;
        private bool m_MFC4ValveIsOpen;
        private bool m_MFC5ValveIsOpen;
        private bool m_MFC6ValveIsOpen;
        private bool m_MFC7ValveIsOpen;
        private bool m_MFC8ValveIsOpen;
        private bool m_GasFinalValveIsOpen;
        private bool m_SoftPumpValveIsOpen;
        private bool m_FastPumpValveIsOpen;
        private bool m_PVHe1ValveIsOpen;
        private bool m_PVHe2ValveIsOpen;
        private bool m_TurboPumpPumpingValveIsOpen;
        private bool m_TurboPumpPurgeValveIsOpen;
        private bool m_GuageValveIsOpen;
        #endregion


        private List<string> m_RtDataKeys=new List<string> ();
        private Dictionary<string, object> m_RtDataValues=new Dictionary<string, object> ();
        #endregion

        #region  属性
        public ObservableCollection<PMLeakCheckResult> LeakCheckResultList
        {
            get { return m_LeakCheckResultList; }
            set { SetProperty(ref m_LeakCheckResultList, value); }
        }
        public List<string> LeakCheckMode
        {
            get { return m_LeakCheckMode; }
            set { SetProperty(ref m_LeakCheckMode, value); }
        }

        public int LeakCheckModeSelectedIndex
        {
            get { return m_LeakCheckModeSelectedIndex; }
            set { SetProperty(ref m_LeakCheckModeSelectedIndex, value); }
        }

        public int VentTime
        {
            get { return m_VentTime; }
            set { SetProperty(ref m_VentTime, value); }
        }

        public int CheckTime
        {
            get { return m_CheckTime; }
            set { SetProperty(ref m_CheckTime, value); }
        }
        public int BasePressure
        {
            get { return m_BasePressure; }
            set { SetProperty(ref m_BasePressure, value); }
        }
        public double LeakRateUpperLimit
        {
            get { return m_LeakRateUpperLimit; }
            set { SetProperty(ref m_LeakRateUpperLimit, value); }
        }
        public bool[] GasIsCheck
        {
            get { return m_GasIsCheck; }
            set { SetProperty(ref m_GasIsCheck, value); }
        }
        public AITMfcData MFC1Data
        {
            get { return m_MFC1Data; }
            set { SetProperty(ref m_MFC1Data, value); }
        }
        public AITMfcData MFC2Data
        {
            get { return m_MFC2Data; }
            set { SetProperty(ref m_MFC2Data, value); }
        }
        public AITMfcData MFC3Data
        {
            get { return m_MFC3Data; }
            set { SetProperty(ref m_MFC3Data, value); }
        }
        public AITMfcData MFC4Data
        {
            get { return m_MFC4Data; }
            set { SetProperty(ref m_MFC4Data, value); }
        }
        public AITMfcData MFC5Data
        {
            get { return m_MFC5Data; }
            set { SetProperty(ref m_MFC5Data, value); }
        }
        public AITMfcData MFC6Data
        {
            get { return m_MFC6Data; }
            set { SetProperty(ref m_MFC6Data, value); }
        }
        public AITMfcData MFC7Data
        {
            get { return m_MFC7Data; }
            set { SetProperty(ref m_MFC7Data, value); }
        }
        public AITMfcData MFC8Data
        {
            get { return m_MFC8Data; }
            set { SetProperty(ref m_MFC8Data, value); }
        }
       
        #region 阀
        public bool GasFinalValveIsOpen
        {
            get { return m_GasFinalValveIsOpen; }
            set { SetProperty(ref m_GasFinalValveIsOpen, value); }
        }
        public bool PVN21ValveIsOpen
        {
            get { return m_PVN21ValveIsOpen; }
            set { SetProperty(ref m_PVN21ValveIsOpen, value); }
        }
        public bool PVN22ValveIsOpen
        {
            get { return m_PVN22ValveIsOpen; }
            set { SetProperty(ref m_PVN22ValveIsOpen, value); }
        }
        public bool N2ValveIsOpen
        {
            get { return m_N2ValveIsOpen; }
            set { SetProperty(ref m_N2ValveIsOpen, value); }
        }
        public bool PV11ValveIsOpen
        {
            get { return m_PV11ValveIsOpen; }
            set { SetProperty(ref m_PV11ValveIsOpen, value); }
        }
        public bool PV12ValveIsOpen
        {
            get { return m_PV12ValveIsOpen; }
            set { SetProperty(ref m_PV12ValveIsOpen, value); }
        }
        public bool MFC1ValveIsOpen
        {
            get { return m_MFC1ValveIsOpen; }
            set { SetProperty(ref m_MFC1ValveIsOpen, value); }
        }
        public bool PV21ValveIsOpen
        {
            get { return m_PV21ValveIsOpen; }
            set { SetProperty(ref m_PV21ValveIsOpen, value); }
        }
        public bool PV22ValveIsOpen
        {
            get { return m_PV22ValveIsOpen; }
            set { SetProperty(ref m_PV22ValveIsOpen, value); }
        }
        public bool MFC2ValveIsOpen
        {
            get { return m_MFC2ValveIsOpen; }
            set { SetProperty(ref m_MFC2ValveIsOpen, value); }
        }
        public bool PV31ValveIsOpen
        {
            get { return m_PV31ValveIsOpen; }
            set { SetProperty(ref m_PV31ValveIsOpen, value); }
        }
        public bool PV32ValveIsOpen
        {
            get { return m_PV32ValveIsOpen; }
            set { SetProperty(ref m_PV32ValveIsOpen, value); }
        }
        public bool MFC3ValveIsOpen
        {
            get { return m_MFC3ValveIsOpen; }
            set { SetProperty(ref m_MFC3ValveIsOpen, value); }
        }
        public bool PV41ValveIsOpen
        {
            get { return m_PV41ValveIsOpen; }
            set { SetProperty(ref m_PV41ValveIsOpen, value); }
        }
        public bool PV42ValveIsOpen
        {
            get { return m_PV42ValveIsOpen; }
            set { SetProperty(ref m_PV42ValveIsOpen, value); }
        }
        public bool MFC4ValveIsOpen
        {
            get { return m_MFC4ValveIsOpen; }
            set { SetProperty(ref m_MFC4ValveIsOpen, value); }
        }
        public bool MFC5ValveIsOpen
        {
            get { return m_MFC5ValveIsOpen; }
            set { SetProperty(ref m_MFC5ValveIsOpen, value); }
        }
        public bool MFC6ValveIsOpen
        {
            get { return m_MFC6ValveIsOpen; }
            set { SetProperty(ref m_MFC6ValveIsOpen, value); }
        }
        public bool MFC7ValveIsOpen
        {
            get { return m_MFC7ValveIsOpen; }
            set { SetProperty(ref m_MFC7ValveIsOpen, value); }
        }
        public bool MFC8ValveIsOpen
        {
            get { return m_MFC8ValveIsOpen; }
            set { SetProperty(ref m_MFC8ValveIsOpen, value); }
        }
        public bool PVHe1ValveIsOpen
        {
            get { return m_PVHe1ValveIsOpen; }
            set { SetProperty(ref m_PVHe1ValveIsOpen, value); }
        }
        public bool PVHe2ValveIsOpen
        {
            get { return m_PVHe2ValveIsOpen; }
            set { SetProperty(ref m_PVHe2ValveIsOpen, value); }
        }
        public bool TurboPumpPumpingValveIsOpen
        {
            get { return m_TurboPumpPumpingValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPumpingValveIsOpen, value); }
        }
        public bool TurboPumpPurgeValveIsOpen
        {
            get { return m_TurboPumpPurgeValveIsOpen; }
            set { SetProperty(ref m_TurboPumpPurgeValveIsOpen, value); }
        }
        public bool SoftPumpValveIsOpen
        {
            get { return m_SoftPumpValveIsOpen; }
            set { SetProperty(ref m_SoftPumpValveIsOpen, value); }
        }
        public bool FastPumpValveIsOpen
        {
            get { return m_FastPumpValveIsOpen; }
            set { SetProperty(ref m_FastPumpValveIsOpen, value); }
        }
        public bool GuageValveIsOpen
        {
            get { return m_GuageValveIsOpen; }
            set { SetProperty(ref m_GuageValveIsOpen, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        #endregion
        #endregion

        #region 命令
        private DelegateCommand _CheckCommand;
        public DelegateCommand CheckCommand =>
            _CheckCommand ?? (_CheckCommand = new DelegateCommand(OnCheck));


        private DelegateCommand _AbortCommand;
        public DelegateCommand AbortCommand =>
            _AbortCommand ?? (_AbortCommand = new DelegateCommand(OnAbort));

        private DelegateCommand _ExportCommand;
        public DelegateCommand ExportCommand =>
            _ExportCommand ?? (_ExportCommand = new DelegateCommand(OnExport));


        private DelegateCommand<object> _ControlValveCommand;
        public DelegateCommand<object> ControlValveCommand =>
            _ControlValveCommand ?? (_ControlValveCommand = new DelegateCommand<object>(OnControlValve));

        private DelegateCommand _GasPurgeCommand;
        public DelegateCommand GasPurgeCommand =>
            _GasPurgeCommand ?? (_GasPurgeCommand = new DelegateCommand(OnGasPurge));
        #endregion

        #region 构造函数
        public GasLeakCheckViewModel()
        {
            m_LeakCheckMode = new List<string>() { "ChamberOnly", "ChamberAndGasLine", "ChamberAndGasLineAndFAC" };
            m_LeakCheckModeSelectedIndex = 0;
            m_VentTime = 120;
            m_CheckTime = 180;
            m_LeakRateUpperLimit = 10;
            BasePressure = 100;

            addDataKeys();

            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            timer.Tick += timer_Tick;
            timer.Start();
        }
        #endregion

        #region 命令方法
        private void OnCheck()
        {
            if (LeakCheckModeSelectedIndex == 0)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.LeakCheck", VentTime, CheckTime, LeakRateUpperLimit);

            }
            else if (LeakCheckModeSelectedIndex == 1 || LeakCheckModeSelectedIndex == 2)
            {
                StringBuilder stringBuilder = new StringBuilder();
                for (int i = 1; i < 9; i++)
                {
                    if (GasIsCheck[i] == true)
                    {
                        var value = i.ToString();
                        stringBuilder.Append(value);
                        stringBuilder.Append(',');
                    }
                }
                if (stringBuilder.Length > 1)
                {
                    stringBuilder.Remove(stringBuilder.Length - 1, 1);
                    InvokeClient.Instance.Service.DoOperation($"{ModuleName}.GasLeakCheck", VentTime, CheckTime, LeakRateUpperLimit, stringBuilder.ToString(), GasIsCheck[0], LeakCheckMode[LeakCheckModeSelectedIndex]);
                }
               
            }
        }
        private void OnAbort()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.{RtOperation.Abort}");
        }
        private void OnExport()
        {
            OpenFileDialog dialog = new OpenFileDialog();
            dialog.Filter = ".json|*.json";
            dialog.InitialDirectory = Path.Combine(QueryDataClient.Instance.Service.GetData("GetRTPath").ToString(), "LeakCheck");
            if (dialog.ShowDialog() == true)
            {
                string SelectedPath = dialog.FileName;
                LeakCheckResultList.Add (SerializeHelper.Instance.ReadFromJsonFile<PMLeakCheckResult>(SelectedPath));
            }
        }
        
        private void OnControlValve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.ControlValve", Convert.ToInt32(commonValveControl.Tag.ToString()), !commonValveControl.Status);
            }
        }
        private void OnGasPurge()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.GasLinePurge");
        }
        #endregion

        #region 私有方法
        void timer_Tick(object sender, EventArgs e)
        {
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
            PVN21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN21.IsOpen"];
            GasFinalValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveGasFinal.IsOpen"];
            PV11ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV11.IsOpen"];
            PV12ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV12.IsOpen"];
            PV21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV21.IsOpen"];
            PV22ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV22.IsOpen"];
            PV31ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV31.IsOpen"];
            PV32ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV32.IsOpen"];
            PV41ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV41.IsOpen"];
            PV42ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePV42.IsOpen"];
            MFC1ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc1.IsOpen"];
            MFC2ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc2.IsOpen"];
            MFC3ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc3.IsOpen"];
            MFC4ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc4.IsOpen"];
            MFC5ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc5.IsOpen"];
            MFC6ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc6.IsOpen"];
            MFC7ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc7.IsOpen"];
            MFC8ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValveMfc8.IsOpen"];
            PVN21ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN21.IsOpen"];
            PVN22ValveIsOpen = (bool)RtDataValues[$"{ModuleName}.ValvePVN22.IsOpen"];
            MFC1Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas1"];
            MFC2Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas2"];
            MFC3Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas3"];
            MFC4Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas4"];
            MFC5Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas5"];
            MFC6Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas6"];
            MFC7Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas7"];
            MFC8Data = (AITMfcData)RtDataValues[$"{ModuleName}.MfcGas8"];

        }
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"{ModuleName}.MfcGas1");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas2");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas3");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas4");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas5");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas6");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas7");
            m_RtDataKeys.Add($"{ModuleName}.MfcGas8");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN21.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN22.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV11.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV12.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV21.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV22.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV31.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV32.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV41.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePV42.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc1.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc3.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc4.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc5.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc6.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc7.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveMfc8.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveGasFinal.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveSoftPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveFastPump.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveN2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe1.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVHe2.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPumping.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveTurboPumpPurge.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN21.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValvePVN22.IsOpen");
            m_RtDataKeys.Add($"{ModuleName}.ValveGuage.IsOpen");
        }
        #endregion
    }
}