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

using Aitex.Core.Common.DeviceData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Threading;
using Venus_Core;
using Venus_MainPages.Unity;
using Venus_Themes.CustomControls;

namespace Venus_MainPages.ViewModels
{
    public class TMOperationViewModel : BindableBase
    {
        #region 私有字段
        private bool m_TMIsOFFline;
        private bool m_LLIsOFFline;

        private bool m_PMADoorIsOpen;
        private bool m_PMBDoorIsOpen;
        private bool m_PMCDoorIsOpen;
        private bool m_PMDDoorIsOpen;
        private bool m_LLADoorIsOpen;


        private bool m_PMAIsInstalled;
        private bool m_PMBIsInstalled;
        private bool m_PMCIsInstalled;
        private bool m_PMDIsInstalled;
        private bool m_LLAIsInstalled;
        private bool m_LLBIsInstalled;

        private Dictionary<string, object> m_RtDataValues;

        private string m_ModuleCheckedName = "TM";

        private bool m_TMValveN2IsOpen;
        private bool m_TMSoftPumpValveIsOpen;
        private bool m_TMFastPumpValveIsOpen;
        private bool m_TMPurgeValveIsOpen;
        private bool m_TMSoftVentValveIsOpen;
        private bool m_TMFastVentValveIsOpen;
        private bool m_LLASoftPumpValveIsOpen;
        private bool m_LLAFastPumpValveIsOpen;
        private bool m_LLAPurgeValveIsOpen;
        private bool m_LLAVentValveIsOpen;
        private bool m_LLBSoftPumpValveIsOpen;
        private bool m_LLBFastPumpValveIsOpen;
        private bool m_LLBPurgeValveIsOpen;
        private bool m_LLBVentValveIsOpen;
        private List<string> m_RtDataKeys=new List<string> ();


        public bool TMValveN2IsOpen
        {
            get { return m_TMValveN2IsOpen; }
            set { SetProperty(ref m_TMValveN2IsOpen, value); }
        }
        public bool TMSoftPumpValveIsOpen
        {
            get { return m_TMSoftPumpValveIsOpen; }
            set { SetProperty(ref m_TMSoftPumpValveIsOpen, value); }
        }
        public bool TMFastPumpValveIsOpen
        {
            get { return m_TMFastPumpValveIsOpen; }
            set { SetProperty(ref m_TMFastPumpValveIsOpen, value); }
        }
        public bool TMPurgeValveIsOpen
        {
            get { return m_TMPurgeValveIsOpen; }
            set { SetProperty(ref m_TMPurgeValveIsOpen, value); }
        }
        public bool TMSoftVentValveIsOpen
        {
            get { return m_TMSoftVentValveIsOpen; }
            set { SetProperty(ref m_TMSoftVentValveIsOpen, value); }
        }
        public bool TMFastVentValveIsOpen
        {
            get { return m_TMFastVentValveIsOpen; }
            set { SetProperty(ref m_TMFastVentValveIsOpen, value); }
        }
        public bool LLAFastPumpValveIsOpen
        {
            get { return m_LLAFastPumpValveIsOpen; }
            set { SetProperty(ref m_LLAFastPumpValveIsOpen, value); }
        }
        public bool LLASoftPumpValveIsOpen
        {
            get { return m_LLASoftPumpValveIsOpen; }
            set { SetProperty(ref m_LLASoftPumpValveIsOpen, value); }
        }
        public bool LLAPurgeValveIsOpen
        {
            get { return m_LLAPurgeValveIsOpen; }
            set { SetProperty(ref m_LLAPurgeValveIsOpen, value); }
        }
        public bool LLAVentValveIsOpen
        {
            get { return m_LLAVentValveIsOpen; }
            set { SetProperty(ref m_LLAVentValveIsOpen, value); }
        }
        public bool LLBSoftPumpValveIsOpen
        {
            get { return m_LLBSoftPumpValveIsOpen; }
            set { SetProperty(ref m_LLBSoftPumpValveIsOpen, value); }
        }
        public bool LLBFastPumpValveIsOpen
        {
            get { return m_LLBFastPumpValveIsOpen; }
            set { SetProperty(ref m_LLBFastPumpValveIsOpen, value); }
        }
        public bool LLBPurgeValveIsOpen
        {
            get { return m_LLBPurgeValveIsOpen; }
            set { SetProperty(ref m_LLBPurgeValveIsOpen, value); }
        }
        public bool LLBVentValveIsOpen
        {
            get { return m_LLBVentValveIsOpen; }
            set { SetProperty(ref m_LLBVentValveIsOpen, value); }
        }
        #endregion

        #region 属性
        public bool TMIsOFFline
        {
            get { return m_TMIsOFFline; }
            set { SetProperty(ref m_TMIsOFFline, value); }
        }
        public bool LLIsOFFline
        {
            get { return m_LLIsOFFline; }
            set { SetProperty(ref m_LLIsOFFline, value); }
        }
        public bool PMADoorIsOpen
        {
            get { return m_PMADoorIsOpen; }
            set { SetProperty(ref m_PMADoorIsOpen, value); }
        }
        public bool LLADoorIsOpen
        {
            get { return m_LLADoorIsOpen; }
            set { SetProperty(ref m_LLADoorIsOpen, value); }
        }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }
        public bool PMAIsInstalled
        {
            get { return m_PMAIsInstalled; }
            set { SetProperty(ref m_PMAIsInstalled, value); }
        }
        public bool PMBIsInstalled
        {
            get { return m_PMBIsInstalled; }
            set { SetProperty(ref m_PMBIsInstalled, value); }
        }
        public bool PMCIsInstalled
        {
            get { return m_PMCIsInstalled; }
            set { SetProperty(ref m_PMCIsInstalled, value); }
        }
        public bool PMDIsInstalled
        {
            get { return m_PMDIsInstalled; }
            set { SetProperty(ref m_PMDIsInstalled, value); }
        }
        public bool LLAIsInstalled
        {
            get { return m_LLAIsInstalled; }
            set { SetProperty(ref m_LLAIsInstalled, value); }
        }
        public bool LLBIsInstalled
        {
            get { return m_LLBIsInstalled; }
            set { SetProperty(ref m_LLBIsInstalled, value); }
        }
        #endregion

        #region 命令
       

        private DelegateCommand _HomeCommand;
        public DelegateCommand HomeCommand =>
            _HomeCommand ?? (_HomeCommand = new DelegateCommand(OnHome));

        private DelegateCommand _VentCommand;
        public DelegateCommand VentCommand =>
            _VentCommand ?? (_VentCommand = new DelegateCommand(OnVent));

        private DelegateCommand _PumpCommand;
        public DelegateCommand PumpCommand =>
            _PumpCommand ?? (_PumpCommand = new DelegateCommand(OnPump));

        private DelegateCommand _PurgeCommand;
        public DelegateCommand PurgeCommand =>
            _PurgeCommand ?? (_PurgeCommand = new DelegateCommand(OnPurge));
   

        private DelegateCommand _AbortCommand;
        public DelegateCommand AbortCommand =>
            _AbortCommand ?? (_AbortCommand = new DelegateCommand(OnAbort));
        private DelegateCommand<object> _ModuleCheckedCommand;
        public DelegateCommand<object> ModuleCheckedCommand =>
            _ModuleCheckedCommand ?? (_ModuleCheckedCommand = new DelegateCommand<object>(OnModuleChecked));

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

        private DelegateCommand _CloseLLPumpCommand;
        public DelegateCommand CloseLLPumpCommand =>
            _CloseLLPumpCommand ?? (_CloseLLPumpCommand = new DelegateCommand(OnCloseLLPump));

        private DelegateCommand _OpenTMPumpCommand;
        public DelegateCommand OpenTMPumpCommand =>
            _OpenTMPumpCommand ?? (_OpenTMPumpCommand = new DelegateCommand(OnOpenTMPump));

        private DelegateCommand _CloseTMPumpCommand;
        public DelegateCommand CloseTMPumpCommand =>
            _CloseTMPumpCommand ?? (_CloseTMPumpCommand = new DelegateCommand(OnCloseTMPump));

        #endregion

        #region 构造函数
        public TMOperationViewModel()
        {
            addDataKeys();

            string[] allModules = QueryDataClient.Instance.Service.GetConfig($"System.InstalledModules").ToString().Split(',');
            PMAIsInstalled = allModules.Contains("PMA");
            PMBIsInstalled = allModules.Contains("PMB");
            PMCIsInstalled = allModules.Contains("PMC");
            PMDIsInstalled = allModules.Contains("PMD");
            LLAIsInstalled = allModules.Contains("LLA");
            LLBIsInstalled = allModules.Contains("LLB");

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

        #region 命令方法
 

        private void OnHome()
        {
            InvokeClient.Instance.Service.DoOperation($"{m_ModuleCheckedName}.Home");
        }
        private void OnVent()
        {
            InvokeClient.Instance.Service.DoOperation($"{m_ModuleCheckedName}.{RtOperation.Vent}");
        }
        private void OnPump()
        {
            InvokeClient.Instance.Service.DoOperation($"{m_ModuleCheckedName}.{RtOperation.Pump}");
        }
        private void OnPurge()
        {
            InvokeClient.Instance.Service.DoOperation($"{m_ModuleCheckedName}.{RtOperation.Purge}");
        }

        private void OnAbort()
        {
            InvokeClient.Instance.Service.DoOperation($"{m_ModuleCheckedName}.{RtOperation.Abort}");
        }
        private void OnModuleChecked(object obj)
        {
            m_ModuleCheckedName = obj.ToString();
        }

        private void OnControlValve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"TM.{commonValveControl.Tag.ToString()}.{AITValveOperation.GVTurnValve}", !commonValveControl.Status);
            }
        }
        private void OnOpenTMPump()
        {
            InvokeClient.Instance.Service.DoOperation("TM.ControlPump",true);
        }
        private void OnCloseTMPump()
        {
            InvokeClient.Instance.Service.DoOperation("TM.ControlPump", false);

        }
        private void OnOpenLLPump()
        {
            InvokeClient.Instance.Service.DoOperation("LL.ControlPump",true);
        }
        private void OnCloseLLPump()
        {
            InvokeClient.Instance.Service.DoOperation("LL.ControlPump", false);

        }
        #endregion

        #region 私有方法
        void timer_Tick(object sender, EventArgs e)
        {
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);

            if (RtDataValues == null)
            {
                return;
            }

            TMValveN2IsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.TMValveN2.IsOpen");
            TMSoftPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.TMSoftPumpValve.IsOpen"); ;
            TMFastPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.TMFastPumpValve.IsOpen"); ;
            //TMPurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.TMPurgeValve.IsOpen"); ;
            TMSoftVentValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.TMSoftVentValve.IsOpen"); ;
            TMFastVentValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.TMFastVentValve.IsOpen"); ;
            LLASoftPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLASoftPumpValve.IsOpen");
            LLAFastPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLAFastPumpValve.IsOpen");
            //LLAPurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLAPurgeValve.IsOpen");
            LLAVentValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLAVentValve.IsOpen");
            LLBSoftPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLBSoftPumpValve.IsOpen");
            LLBFastPumpValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLBFastPumpValve.IsOpen");
            //LLBPurgeValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLBPurgeValve.IsOpen");
            LLBVentValveIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "TM.LLBVentValve.IsOpen");
        }
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"TM.TMValveN2.IsOpen");
            m_RtDataKeys.Add($"TM.TMSoftPumpValve.IsOpen");
            m_RtDataKeys.Add($"TM.TMFastPumpValve.IsOpen");
            //m_RtDataKeys.Add($"TM.TMPurgeValve.IsOpen");
            m_RtDataKeys.Add($"TM.TMSoftVentValve.IsOpen");
            m_RtDataKeys.Add($"TM.TMFastVentValve.IsOpen");
            m_RtDataKeys.Add($"TM.LLASoftPumpValve.IsOpen");
            m_RtDataKeys.Add($"TM.LLAFastPumpValve.IsOpen");
            //m_RtDataKeys.Add($"TM.LLAPurgeValve.IsOpen");
            m_RtDataKeys.Add($"TM.LLAVentValve.IsOpen");
            m_RtDataKeys.Add($"TM.LLBVentValve.IsOpen");

            m_RtDataKeys.Add($"TM.LLBSoftPumpValve.IsOpen");
            m_RtDataKeys.Add($"TM.LLBFastPumpValve.IsOpen");

            m_RtDataKeys.Add($"TM.TMVacSwitch.Value");
            m_RtDataKeys.Add($"TM.LLAVacSwitch.Value");
            m_RtDataKeys.Add($"TM.LLBVacSwitch.Value");
            m_RtDataKeys.Add($"TM.TMATMSwitch.Value");
            m_RtDataKeys.Add($"TM.LLAATMSwitch.Value");
            m_RtDataKeys.Add($"TM.LLBATMSwitch.Value");
            m_RtDataKeys.Add($"TM.TMProcessGauge.Value");
            m_RtDataKeys.Add($"TM.TMForelineGauge.Value");
            m_RtDataKeys.Add($"TM.LLAPressureGauge.Value");
            m_RtDataKeys.Add($"TM.LLBPressureGauge.Value");
            m_RtDataKeys.Add($"TM.LoadlockForelineGauge.Value");
            m_RtDataKeys.Add($"TM.PumpIsRunning");
            m_RtDataKeys.Add($"LL.PumpIsRunning");
        }

        #endregion
    }
}