CyberX8/CyberX8_MainPages/ViewModels/SystemFacilitiesViewModel.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Log;
using Aitex.Core.UI.Dialog;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.Utilities;
using CyberX8_Core;
using CyberX8_MainPages.PMs;
using CyberX8_Themes.UserControls;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;

namespace CyberX8_MainPages.ViewModels
{
    public class SystemFacilitiesViewModel : BindableBase
    {
        #region 常量
        private const string FACILITIES = "Facilities";
        private const string FACILITIES_DATA = "Facilities_Data";
        private const string N2_ENABLE = "N2Enable";
        private const string CDA_ENABLE = "CDAEnable";
        private const string EXTERNAL_CDA_ENABLE = "ExternalCDAEnable";
        private const string DI_WATER_ENABLE = "DiWaterEnable";
        private const string HOUSE_CHILLED_WATER_ENABLE="HouseChilledWaterEnable";
        private const string DI_REPLEN_ENABLE = "DiReplenEnable";
        private const string DI_FILL_ENABLE = "DiFillEnable";
        private const string LOADER_DI_ENABLE = "LoaderDiEnable";
        private const string FILTER_PURGE_ENABLE = "FilterPurgeEnable";
        private const string N2_BLANKET_PRESSURE_VALUE = "N2BlanketPressure";
        private const string SAMPLE_ENABLE = "SampleEnable";
        private const string SAMPLE_FLOW_1_ENABLE = "SampleFlow1Enable";
        private const string SAMPLE_FLOW_2_ENABLE = "SampleFlow2Enable";
        private const string SAMPLE_FLOW_3_ENABLE = "SampleFlow3Enable";
        private const string SAMPLE_FLOW_4_ENABLE = "SampleFlow4Enable";
        private const string FFU_LOADER_ERROR = "FFULoaderError";
        private const string FFU_PROCESS_ERROR = "FFUProcessError";
        private const string FFU_LOADER_PRESSURE = "FFULoaderPressure";
        private const string FFU_PROCESS_PRESSURE = "FFUProcessPressure";
        private const string ARS_FLUID_DETECT = "ArsFluidDetect";
        private const string PROCESS_FLUID_DETECT= "ProcessFluidDetect";
        private const string SAMPLE_FLUID_DETECT = "SampleFluidDetect";
        #endregion

        #region 内部变量
        private CommonLimitData _nitrogen1AData = new CommonLimitData();
        private CommonLimitData _nitrogen1BData = new CommonLimitData();
        private CommonLimitData _nitrogen2AData = new CommonLimitData();
        private CommonLimitData _nitrogen2BData = new CommonLimitData();
        private CommonLimitData _vacuumData = new CommonLimitData();
        private CommonLimitData _cda1Data = new CommonLimitData();
        private CommonLimitData _cda2Data = new CommonLimitData();
        private CommonLimitData _extendCdaData = new CommonLimitData();
        private CommonLimitData _exhaustData = new CommonLimitData();
        private CommonLimitData _diWaterPressureData = new CommonLimitData();
        private CommonLimitData _houseChilledWaterFlowData = new CommonLimitData();
        private bool _nitrogenOn;
        private bool _cdaOn;
        private bool _extendCdaOn;
        private bool _diWaterPressureOn;
        private bool _houseChilledWaterFlowOn;
        private bool _diFillEnable;
        private bool _diReplenEnable;
        private bool _loaderDiEnable;
        private bool _slipstreamEnable;
        private bool _filterPurgeEnable;
        private double _n2BlanketPressure;
        private int _allStatus;
        private bool _processFluidDetect;
        private bool _sampleFluidDetect;
        private bool _arsFluidDetect;
        private bool _crsWashBoxFluidDetect;
        private bool _processFFUError;
        private bool _loaderFFUError;
        private double _processFFUPressure;
        private double _loaderFFUPressure;
        private bool _sampleEnable;
        private bool _sampleFlow1Enable;
        private bool _sampleFlow2Enable;
        private bool _sampleFlow3Enable;
        private bool _sampleFlow4Enable;
        private bool _startEnable;
        /// <summary>
        /// 定时器
        /// </summary>
        DispatcherTimer _timer;

        /// <summary>
        /// 查询后台数据集合
        /// </summary>
        private List<string> _rtDataKeys = new List<string>();
        /// <summary>
        /// rt查询key数值字典
        /// </summary>
        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();

        #region Home
        private bool _homeAllOn;
        private bool _homeLoaderTransporterOn;
        private bool _homeEfemOn;
        private bool _homeProcessTransporterOn;
        private bool _homeLoaderOn;
        private bool _homePufOn;
        private bool _homeSrdOn;
        #endregion

        #endregion
        #region 属性

        public CommonLimitData Nitrogen1AData{ get { return _nitrogen1AData; } set { SetProperty(ref _nitrogen1AData, value); } }

        public CommonLimitData Nitrogen1BData { get { return _nitrogen1BData; } set { SetProperty(ref _nitrogen1BData, value); }}

        public CommonLimitData Nitrogen2AData { get { return _nitrogen2AData; } set { SetProperty(ref _nitrogen2AData, value); } }
        public CommonLimitData Nitrogen2BData { get { return _nitrogen2BData; } set { SetProperty(ref _nitrogen2BData, value); } }

        public CommonLimitData VacuumData { get { return _vacuumData; } set { SetProperty(ref _vacuumData, value); } }

        public CommonLimitData Cda1Data { get { return _cda1Data; }set { SetProperty(ref _cda1Data, value); } }

        public CommonLimitData Cda2Data{ get { return _cda2Data; } set { SetProperty(ref _cda2Data, value); }}

        public CommonLimitData ExtendCdaData{ get { return _extendCdaData; } set { SetProperty(ref _extendCdaData, value); }}

        public CommonLimitData ExhaustData{ get { return _exhaustData; } set { SetProperty(ref _exhaustData, value); } }

        public CommonLimitData DiWaterPressureData { get { return _diWaterPressureData; } set { SetProperty(ref _diWaterPressureData, value); }}

        public CommonLimitData HouseChilledWaterFlowData{ get { return _houseChilledWaterFlowData; } set { SetProperty(ref _houseChilledWaterFlowData, value); }}

        public bool NitrogenOn { get { return _nitrogenOn; } set { SetProperty(ref _nitrogenOn, value); }}

        public bool CdaOn { get { return _cdaOn; } set { SetProperty(ref _cdaOn, value); } }

        public bool ExtendCdaOn { get { return _extendCdaOn; } set { SetProperty(ref _extendCdaOn, value); } }

        public bool DiWaterPressureOn{ get { return _diWaterPressureOn; } set { SetProperty(ref _diWaterPressureOn, value); } }

        public bool HouseChilledWaterFlowOn { get { return _houseChilledWaterFlowOn; } set { SetProperty(ref _houseChilledWaterFlowOn, value); } }

        public bool DiFillEnable{ get { return _diFillEnable; } set { SetProperty(ref _diFillEnable, value); }}

        public bool DiReplenEnable{get { return _diReplenEnable; }set { SetProperty(ref _diReplenEnable, value); } }

        public bool LoaderDiEnable{ get { return _loaderDiEnable; } set { SetProperty(ref _loaderDiEnable, value); }}

        public bool SlipstreamEnable { get { return _slipstreamEnable; } set { SetProperty(ref _slipstreamEnable, value); }}

        public bool FilterPurgeEnable{ get { return _filterPurgeEnable; } set { SetProperty(ref _filterPurgeEnable, value);} }

        public double N2BlanketPressure{ get { return _n2BlanketPressure; } set { SetProperty(ref _n2BlanketPressure, value); }}

        public int AllStatus { get { return _allStatus; } set { SetProperty(ref _allStatus, value); } }

        #region Fluid Detect

        public bool ProcessFluidDetect { get { return _processFluidDetect; } set { SetProperty(ref _processFluidDetect, value); }}

        public bool SampleFluidDetect { get { return _sampleFluidDetect; } set { SetProperty(ref _sampleFluidDetect, value); } }

        public bool ArsFluidDetect{ get { return _arsFluidDetect; } set { SetProperty(ref _arsFluidDetect, value); }}

        public bool CRSWashBoxFluidDetect { get { return _crsWashBoxFluidDetect; } set { SetProperty(ref _crsWashBoxFluidDetect, value); } }
        #endregion

        #region FFU
        public bool ProcessFFUError { get { return _processFFUError; } set { SetProperty(ref _processFFUError, value); } }

        public bool LoaderFFUError { get { return _loaderFFUError; } set { SetProperty(ref _loaderFFUError, value); } }

        public double ProcessFFUPressure { get { return _processFFUPressure; } set { SetProperty(ref _processFFUPressure, value); } }

        public double LoaderFFUPressure { get { return _loaderFFUPressure; } set { SetProperty(ref _loaderFFUPressure, value); } }  
        #endregion

        #region Home
        public bool HomeAllOn { get { return _homeAllOn; } set { SetProperty(ref _homeAllOn, value); } }

        public bool HomeLoaderTransporterOn { get { return _homeLoaderTransporterOn; } set { SetProperty(ref _homeLoaderTransporterOn, value); }}

        public bool HomeEfemOn { get { return _homeEfemOn; } set { SetProperty(ref _homeEfemOn, value); }}


        public bool HomeProcessTransporterOn{ get { return _homeProcessTransporterOn; } set { SetProperty(ref _homeProcessTransporterOn, value); } }

        public bool HomeLoaderOn { get { return _homeLoaderOn; } set { SetProperty(ref _homeLoaderOn, value); }}

        public bool HomePufOn { get { return _homePufOn; } set { SetProperty(ref _homePufOn, value); }}

        public bool HomeSrdOn { get { return _homeSrdOn; } set { SetProperty(ref _homeSrdOn, value); } }
        #endregion

        public bool SampleEnable { get { return _sampleEnable; } set { SetProperty(ref _sampleEnable, value); } }

        public bool SampleFlow1Enable { get { return _sampleFlow1Enable; } set { SetProperty(ref _sampleFlow1Enable, value); } }
        public bool SampleFlow2Enable { get { return _sampleFlow2Enable; } set { SetProperty(ref _sampleFlow2Enable, value); } }
        public bool SampleFlow3Enable { get { return _sampleFlow3Enable; } set { SetProperty(ref _sampleFlow3Enable, value); } }
        public bool SampleFlow4Enable { get { return _sampleFlow4Enable; } set { SetProperty(ref _sampleFlow4Enable, value); } }

        public bool StartEnable { get { return _startEnable; } set { SetProperty(ref _startEnable, value); } }

        #endregion

        #region 指令
        public ICommand HomeLoaderCommand { get; private set;}
        public ICommand HomePufCommand { get; private set;}
        public ICommand HomeEfemCommand { get; private set; }

        public ICommand HomeLoaderTransporterCommand { get;private set; }

        public ICommand HomeProcessTransporterCommand{get;private set;}

        public ICommand HomeSRDCommand { get; private set; }

        public ICommand NitrogenOnCommand{get;private set;}
        public ICommand NitrogenOffCommand{ get;private set;}

        public ICommand CDAOnCommand { get; private set; }

        public ICommand CDAOffCommand { get; private set; }

        public ICommand ExternalCDAOnCommand { get;private set; }

        public ICommand ExternalCDAOffCommand { get;private set; }

        public ICommand DiWaterPressureOnCommand { get; private set; }

        public ICommand DiWaterPressureOffCommand { get; private set; }

        public ICommand HouseChilledWaferFlowOnCommand {  get; private set; }   

        public ICommand HouseChilledWaferFlowOffCommand { get; private set; }

        public ICommand DiFillEnableCommand { get; private set; }   

        public ICommand DiFillDisableCommand { get; private set; }

        public ICommand DiReplenEnableCommand { get; private set; }

        public ICommand DiReplenDisableCommand { get; private set; }

        public ICommand LoaderDIEnableCommand { get; private set; } 

        public ICommand LoaderDIDisableCommand {  get; private set; }

        public ICommand FilterPurgeEnableCommand { get; private set; }

        public ICommand FilterPurgeDisableCommand { get; private set; }

        public ICommand AllOnCommand { get; private set; }

        public ICommand AllOffCommand { get; private set; }

        public ICommand SampleEnableCommand { get; private set; }

        public ICommand SampleDisableCommand { get; private set; }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public SystemFacilitiesViewModel()
        {
            HomeLoaderCommand = new DelegateCommand<object>(HomeLoaderAction);
            HomePufCommand=new DelegateCommand<object>(HomePufAction);
            HomeEfemCommand = new DelegateCommand<object>(HomeEfemAction);
            HomeLoaderTransporterCommand = new DelegateCommand<object>(HomeLoaderTransporterAction);
            HomeProcessTransporterCommand = new DelegateCommand<object>(HomeProcessTransporterAction);
            HomeSRDCommand = new DelegateCommand<object>(HomeSRDsAction);
            NitrogenOnCommand = new DelegateCommand<object>(NitrogenOnAction);
            NitrogenOffCommand = new DelegateCommand<object>(NitrogenOffAction);
            CDAOnCommand=new DelegateCommand<object>(CDAOnAction);
            CDAOffCommand=new DelegateCommand<object>(CDAOffAction);
            ExternalCDAOnCommand = new DelegateCommand<object>(ExternalCDAOnAction);
            ExternalCDAOffCommand = new DelegateCommand<object>(ExternalCDAOffAction);
            DiWaterPressureOnCommand = new DelegateCommand<object>(DiWaterOnAction);
            DiWaterPressureOffCommand = new DelegateCommand<object>(DiWaterOffAction);
            HouseChilledWaferFlowOnCommand = new DelegateCommand<object>(HouseChilledWaterOnAction);
            HouseChilledWaferFlowOffCommand = new DelegateCommand<object>(HouseChilledWaterOffAction);
            DiFillEnableCommand = new DelegateCommand<object>(DiFillEnableAction);
            DiFillDisableCommand=new DelegateCommand<object>(DiFillDisableAction);
            DiReplenEnableCommand = new DelegateCommand<object>(DiReplenEnableAction);
            DiReplenDisableCommand = new DelegateCommand<object>(DiReplenDisableAction);
            LoaderDIEnableCommand = new DelegateCommand<object>(LoaderDiEnableAction);
            LoaderDIDisableCommand = new DelegateCommand<object>(LoaderDiDisableAction);
            FilterPurgeEnableCommand = new DelegateCommand<object>(FilterPurgeEnableAction);
            FilterPurgeDisableCommand = new DelegateCommand<object>(FilterPurgeDisableAction);
            AllOnCommand=new DelegateCommand<object>(AllOnAction);
            AllOffCommand=new DelegateCommand<object>(AllOffAction);
            SampleEnableCommand = new DelegateCommand<object>(SampleEnableAction);
            SampleDisableCommand = new DelegateCommand<object>(SampleDisableAction);
        }
        /// <summary>
        /// 加载数据
        /// </summary>
        public void LoadData(string systemName)
        {
            InitialKeys(); 
            if (_timer == null)
            {
                _timer = new DispatcherTimer();
                _timer.Interval = TimeSpan.FromMilliseconds(200) ;
                _timer.Tick += Timer_Tick; ;
            }
            _timer.Start();
        }
        /// <summary>
        /// 定时器执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Timer_Tick(object sender, EventArgs e)
        {
            if (_rtDataKeys.Count != 0)
            {
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    HomeEfemOn = CommonFunction.GetValue<bool>(_rtDataValueDic, $"{ModuleName.EFEM}.IsHomed");
                    bool puf1 = CommonFunction.GetValue<bool>(_rtDataValueDic, $"{ModuleName.PUF1}.IsHomed");
                    bool puf2 = CommonFunction.GetValue<bool>(_rtDataValueDic, $"{ModuleName.PUF2}.IsHomed");
                    HomePufOn = puf1 && puf2;
                    HomeLoaderOn = CommonFunction.GetValue<bool>(_rtDataValueDic, $"{ModuleName.Loader1}.IsHomed");
                    List<CommonLimitData> facilitiesDatas = CommonFunction.GetValue<List<CommonLimitData>>(_rtDataValueDic, $"System.{FACILITIES}.{FACILITIES_DATA}");
                    if (facilitiesDatas != null)
                    {
                        Cda1Data = facilitiesDatas[0];
                        Cda2Data = facilitiesDatas[1];
                        Nitrogen1AData = facilitiesDatas[2];
                        Nitrogen1BData = facilitiesDatas[3];
                        Nitrogen2AData = facilitiesDatas[4];
                        Nitrogen2BData = facilitiesDatas[5];
                        DiWaterPressureData = facilitiesDatas[6];
                        HouseChilledWaterFlowData = facilitiesDatas[7];
                        ExtendCdaData = facilitiesDatas[8];
                        VacuumData = facilitiesDatas[9];
                        ExhaustData = facilitiesDatas[10];
                    }
                    NitrogenOn = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{N2_ENABLE}");
                    CdaOn = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{CDA_ENABLE}");
                    ExtendCdaOn = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{EXTERNAL_CDA_ENABLE}");
                    DiWaterPressureOn = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{DI_WATER_ENABLE}");
                    HouseChilledWaterFlowOn = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{HOUSE_CHILLED_WATER_ENABLE}");
                    DiFillEnable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{DI_FILL_ENABLE}");
                    DiReplenEnable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{DI_REPLEN_ENABLE}");
                    LoaderDiEnable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{LOADER_DI_ENABLE}");
                    FilterPurgeEnable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{FILTER_PURGE_ENABLE}");
                    N2BlanketPressure = CommonFunction.GetValue<double>(_rtDataValueDic, $"System.{FACILITIES}.{N2_BLANKET_PRESSURE_VALUE}");
                    SampleEnable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{SAMPLE_ENABLE}");
                    SampleFlow1Enable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{SAMPLE_FLOW_1_ENABLE}");
                    SampleFlow2Enable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{SAMPLE_FLOW_2_ENABLE}");
                    SampleFlow3Enable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{SAMPLE_FLOW_3_ENABLE}");
                    SampleFlow4Enable = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{SAMPLE_FLOW_4_ENABLE}");
                    LoaderFFUError = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{FFU_LOADER_ERROR}");
                    ProcessFFUError = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{FFU_PROCESS_ERROR}");
                    LoaderFFUPressure = CommonFunction.GetValue<double>(_rtDataValueDic, $"System.{FACILITIES}.{FFU_LOADER_PRESSURE}");
                    ProcessFFUPressure = CommonFunction.GetValue<double>(_rtDataValueDic, $"System.{FACILITIES}.{FFU_PROCESS_PRESSURE}");
                    ArsFluidDetect = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{ARS_FLUID_DETECT}");
                    ProcessFluidDetect = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{PROCESS_FLUID_DETECT}");
                    SampleFluidDetect = CommonFunction.GetValue<bool>(_rtDataValueDic, $"System.{FACILITIES}.{SAMPLE_FLUID_DETECT}");
                    AllStatus = (NitrogenOn && CdaOn && DiWaterPressureOn && HouseChilledWaterFlowOn && DiFillEnable && DiReplenEnable && LoaderDiEnable) ? 1 :
                        (!NitrogenOn && !CdaOn && !DiWaterPressureOn && !HouseChilledWaterFlowOn && !DiFillEnable && !DiReplenEnable && !LoaderDiEnable) ? 0 : -1;
                }
            }
        }

        /// <summary>
        /// 隐藏
        /// </summary>
        public void Hide()
        {
            if (_timer != null)
            {
                _timer.Stop();
            }
        }
        /// <summary>
        /// 初始化Keys
        /// </summary>
        private void InitialKeys()
        {
            _rtDataKeys.Clear();
            _rtDataKeys.Add($"{ModuleName.EFEM}.IsHomed");
            _rtDataKeys.Add($"{ModuleName.Loader1}.IsHomed");
            _rtDataKeys.Add($"{ModuleName.PUF1}.IsHomed");
            _rtDataKeys.Add($"{ModuleName.PUF2}.IsHomed");
            _rtDataKeys.Add($"System.{FACILITIES}.{FACILITIES_DATA}");
            _rtDataKeys.Add($"System.{FACILITIES}.{N2_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{CDA_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{EXTERNAL_CDA_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{DI_WATER_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{HOUSE_CHILLED_WATER_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{DI_FILL_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{DI_REPLEN_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{LOADER_DI_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{FILTER_PURGE_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{N2_BLANKET_PRESSURE_VALUE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{SAMPLE_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{SAMPLE_FLOW_1_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{SAMPLE_FLOW_2_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{SAMPLE_FLOW_3_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{SAMPLE_FLOW_4_ENABLE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{FFU_LOADER_ERROR}");
            _rtDataKeys.Add($"System.{FACILITIES}.{FFU_PROCESS_ERROR}");
            _rtDataKeys.Add($"System.{FACILITIES}.{FFU_LOADER_PRESSURE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{FFU_PROCESS_PRESSURE}");
            _rtDataKeys.Add($"System.{FACILITIES}.{ARS_FLUID_DETECT}");
            _rtDataKeys.Add($"System.{FACILITIES}.{PROCESS_FLUID_DETECT}");
            _rtDataKeys.Add($"System.{FACILITIES}.{SAMPLE_FLUID_DETECT}");
        }

        #region 指令Action
        /// <summary>
        /// Loader Home
        /// </summary>
        /// <param name="param"></param>
        private void HomeLoaderAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.Loader1}.Common.HomeAll");
        }
        /// <summary>
        /// PUF Home
        /// </summary>
        /// <param name="param"></param>
        private void HomePufAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.PUF1}.HomeAll");
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.PUF2}.HomeAll");
        }
        /// <summary>
        /// EFEM Home
        /// </summary>
        /// <param name="param"></param>
        private void HomeEfemAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.EFEM}.Home");
        }
        /// <summary>
        /// Process Transporter Home
        /// </summary>
        /// <param name="param"></param>
        private void HomeProcessTransporterAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.Transporter1}.HomeAll");
        }
        /// <summary>
        /// Loader Transporter Home
        /// </summary>
        /// <param name="param"></param>
        private void HomeLoaderTransporterAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.Transporter2}.HomeAll");
        }

        /// <summary>
        /// Loader Transporter Home
        /// </summary>
        /// <param name="param"></param>
        private void HomeSRDsAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.SRD1}.HomeAll");
            InvokeClient.Instance.Service.DoOperation($"{ModuleName.SRD2}.HomeAll");
        }
        /// <summary>
        /// N2 Enable
        /// </summary>
        /// <param name="param"></param>
        private void NitrogenOnAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.N2Enable");
        }
        /// <summary>
        /// N2 Disable
        /// </summary>
        /// <param name="param"></param>
        private void NitrogenOffAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.N2Disable");
        }
        /// <summary>
        /// CDA Enable
        /// </summary>
        /// <param name="param"></param>
        private void CDAOnAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.CDAEnable");
        }
        /// <summary>
        /// CDA Disable
        /// </summary>
        /// <param name="param"></param>
        private void CDAOffAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.CDADisable");
        }
        /// <summary>
        /// External CDA Enable
        /// </summary>
        /// <param name="param"></param>
        private void ExternalCDAOnAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.ExternalCDAEnable");
        }
        /// <summary>
        /// External CDA Disable
        /// </summary>
        /// <param name="param"></param>
        private void ExternalCDAOffAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.ExternalCDADisable");
        }
        /// <summary>
        /// DI Water Enable
        /// </summary>
        /// <param name="param"></param>
        private void DiWaterOnAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.DiWaterEnable");
        }
        /// <summary>
        /// DI Water Disable
        /// </summary>
        /// <param name="param"></param>
        private void DiWaterOffAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.DiWaterDisable");
        }
        /// <summary>
        /// House Chilled Water Enable
        /// </summary>
        /// <param name="param"></param>
        private void HouseChilledWaterOnAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.HouseChilledWaterEnable");
        }
        /// <summary>
        /// House Chilled Water Disable
        /// </summary>
        /// <param name="param"></param>
        private void HouseChilledWaterOffAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.HouseChilledWaterDisable");
        }
        /// <summary>
        /// DI Fill Enable
        /// </summary>
        /// <param name="param"></param>
        private void DiFillEnableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.DiFillEnable");
        }
        /// <summary>
        /// DI Fill Disable
        /// </summary>
        /// <param name="param"></param>
        private void DiFillDisableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.DiFillDisable");
        }
        /// <summary>
        /// DI Replen Enable
        /// </summary>
        /// <param name="param"></param>
        private void DiReplenEnableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.DiReplenEnable");
        }
        /// <summary>
        /// DI Replen Disable
        /// </summary>
        /// <param name="param"></param>
        private void DiReplenDisableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.DiReplenDisable");
        }
        /// <summary>
        /// Loader DI Enable
        /// </summary>
        /// <param name="param"></param>
        private void LoaderDiEnableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.LoaderDiEnable");
        }
        /// <summary>
        /// Loader DI Disable
        /// </summary>
        /// <param name="param"></param>
        private void LoaderDiDisableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.LoaderDiDisable");
        }
        /// <summary>
        /// Filter Purge Enable
        /// </summary>
        /// <param name="param"></param>
        private void FilterPurgeEnableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.FilterPurgeEnable");
        }
        /// <summary>
        /// Filter Purge Disable
        /// </summary>
        /// <param name="param"></param>
        private void FilterPurgeDisableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.FilterPurgeDisable");
        }
        /// <summary>
        /// All On
        /// </summary>
        /// <param name="param"></param>
        private void AllOnAction(object param)
        {
            NitrogenOnAction(param);
            CDAOnAction(param);
            DiWaterOnAction(param);
            HouseChilledWaterOnAction(param);
            DiFillEnableAction(param);
            DiReplenEnableAction(param);
            LoaderDiEnableAction(param);
        }
        /// <summary>
        /// All Off
        /// </summary>
        /// <param name="param"></param>
        private void AllOffAction(object param)
        {
            NitrogenOffAction(param);
            CDAOffAction(param);
            DiWaterOffAction(param);
            HouseChilledWaterOffAction(param);
            DiFillDisableAction(param);
            DiReplenDisableAction(param);
            LoaderDiDisableAction(param);
        }
        /// <summary>
        /// Sample Enable
        /// </summary>
        /// <param name="param"></param>
        private void SampleEnableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.SampleEnable");
        }
        /// <summary>
        /// Sample Disable
        /// </summary>
        /// <param name="param"></param>
        private void SampleDisableAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"System.{FACILITIES}.SampleDisable");
        }
        #endregion
    }
}