FurnaceELK/Furnace/FurnaceGasPanelUI/Views/Maintenances/ELK/GasPanelViewModel.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.Log;
using Aitex.Core.UI.ControlDataContext;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Util;
using FurnaceGasPanelUI.Models;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Core.Control;
using MECF.Framework.UI.Core.ExtendedControls;
using OpenSEMI.ClientBase;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Windows;
using System.Windows.Input;
namespace FurnaceGasPanelUI.Views.Maintenances.ELK
{
    public class GasPanelViewModel : ThermalGasPanelUIViewModelBase
    {
        public ICommand CmdSetMfcFlow { get; set; }
        public ICommand CmdSetMfmFlow { get; set; }
        public bool _ismanagerPermission = true;

        public Window WinOwner { get; set; }
        public bool IsManagerPermission
        {
            get
            {
                return _ismanagerPermission;
            }
            set
            {
                _ismanagerPermission = value;
                NotifyOfPropertyChange("IsManagerPermission");
            }
        }

        private bool _isRecipeEdit = false;
        private string backGroundStr = "#FFB0D1F1";

        public bool ManualEnable { get; set; } = true;

        public string ManualEnableColor
        {
            get
            {

                if (ManualEnable)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }

        public void SwichManualEnable()
        {
            ManualEnable = true;
        }

        public void SwichMonitor()
        {
            ManualEnable = false;
        }

        public void SwichRecipe()
        {
            IsRecipeEdit = true;
        }

        public bool MonitorChecked { get; set; } = true;
        public bool ManualChecked { get; set; } = false;

        public bool IsRecipeEdit
        {
            get
            {
                return _isRecipeEdit;
            }
            set
            {
                _isRecipeEdit = value;
                NotifyOfPropertyChange("IsRecipeEdit");
            }
        }

        public bool EditTrue { get; set; } = false;

        [Subscription("PM1.SensorRecipeOK")]
        public AITSensorData SensorRecipeOK { get; set; }
        [Subscription("PM1.SensorPROCManualOK")]
        public AITSensorData SensorPROCManualOK { get; set; }
        [Subscription("System.VentValve.DeviceData")]
        public AITValveData VentValveData { get; set; }
        [Subscription("System.PumpValve.DeviceData")]
        public AITValveData PumpValveData { get; set; }
        [Subscription("PM1.SensorTubeATMPressure.DeviceData")]
        public AITSensorData SensorTubeATMPressure { get; set; }
        [Subscription("System.TubePressure.DeviceData")]
        public AITPressureMeterData TubePressureData { get; set; }
        [Subscription("PM1.SensorVAC1.Value")]
        public bool VAC1 { get; set; }
        [Subscription("PM1.SensorVAC2.Value")]
        public bool VAC2 { get; set; }
        [Subscription("PM1.SensorVAC3.Value")]
        public bool VAC3 { get; set; }
        [Subscription("PM1.SensorVAC4.Value")]
        public bool VAC4 { get; set; }
        [Subscription("PM1.SensorVAC5.Value")]
        public bool VAC5 { get; set; }
        [Subscription("PM1.SensorVAC6.Value")]
        public bool VAC6 { get; set; }
        [Subscription("PM1.SensorVAC7.Value")]
        public bool VAC7 { get; set; }
        [Subscription("PM1.SensorVAC8.Value")]
        public bool VAC8 { get; set; }
        [Subscription("PM1.SensorPS13LStatus.Value")]
        public bool VACATM { get; set; }

        [Subscription("PM1.SensorVACDEPOOK.Value")]
        public bool DEPOOK { get; set; }
        [Subscription("PM1.SensorVACHFOK.Value")]
        public bool HFClnOK { get; set; }
        [Subscription("PM1.SensorVACF2OK.Value")]
        public bool F2ClnOK { get; set; }

        [Subscription("PM1.SensorHCDTANKHH.Value")]
        public bool HCDTANKHH { get; set; }

        [Subscription("PM1.SensorHCDTANKH.Value")]
        public bool HCDTANKH { get; set; }

        [Subscription("PM1.SensorHCDTANKM.Value")]
        public bool HCDTANKM { get; set; }

        [Subscription("PM1.SensorHCDTANKL.Value")]
        public bool HCDTANKL { get; set; }

        [Subscription("PM1.SensorCSOURCETANKHH.Value")]
        public bool CSOURCETANKHH { get; set; }

        [Subscription("PM1.SensorCSOURCETANKH.Value")]
        public bool CSOURCETANKH { get; set; }

        [Subscription("PM1.SensorCSOURCETANKM.Value")]
        public bool CSOURCETANKM { get; set; }

        [Subscription("PM1.SensorCSOURCETANKL.Value")]
        public bool CSOURCETANKL { get; set; }

        [Subscription("PM1.SensorLDS1SystemReady.Value")]
        public bool LDS1SystemReady { get; set; }

        [Subscription("PM1.SensorLDS2SystemReady.Value")]
        public bool LDS2SystemReady { get; set; }


        [Subscription("PM1.SensorDEPOOKILK.Value")]
        public bool SensorDEPOOKILK { get; set; }

        [Subscription("PM1.SensorCLNOKILK.Value")]
        public bool SensorCLNOKILK { get; set; }

        [Subscription("PM1.SensorNVAC.Value")]
        public bool SensorNVAC { get; set; }


        [Subscription("PM1.SensorHREFILK.Value")]
        public bool SensorHREFILK { get; set; }

        [Subscription("PM1.SensorCREFILK.Value")]
        public bool SensorCREFILK { get; set; }

        #region Valves
        [Subscription("PM1.ValveAV1.DeviceData")] public AITValveData ValveAV1 { get; set; }
        [Subscription("PM1.ValveAV2.DeviceData")] public AITValveData ValveAV2 { get; set; }
        [Subscription("PM1.ValveAV3.DeviceData")] public AITValveData ValveAV3 { get; set; }
        [Subscription("PM1.ValveAV4.DeviceData")] public AITValveData ValveAV4 { get; set; }
        [Subscription("PM1.ValveAV5.DeviceData")] public AITValveData ValveAV5 { get; set; }
        [Subscription("PM1.ValveAV6.DeviceData")] public AITValveData ValveAV6 { get; set; }
        [Subscription("PM1.ValveAV7.DeviceData")] public AITValveData ValveAV7 { get; set; }
        [Subscription("PM1.ValveAV8.DeviceData")] public AITValveData ValveAV8 { get; set; }
        [Subscription("PM1.ValveAV9.DeviceData")] public AITValveData ValveAV9 { get; set; }

        [Subscription("PM1.ValveAV10.DeviceData")] public AITValveData ValveAV10 { get; set; }
        [Subscription("PM1.ValveAV11.DeviceData")] public AITValveData ValveAV11 { get; set; }
        [Subscription("PM1.ValveAV12.DeviceData")] public AITValveData ValveAV12 { get; set; }
        [Subscription("PM1.ValveAV13.DeviceData")] public AITValveData ValveAV13 { get; set; }
        [Subscription("PM1.ValveAV14.DeviceData")] public AITValveData ValveAV14 { get; set; }
        [Subscription("PM1.ValveAV15.DeviceData")] public AITValveData ValveAV15 { get; set; }
        [Subscription("PM1.ValveAV16.DeviceData")] public AITValveData ValveAV16 { get; set; }
        [Subscription("PM1.ValveAV17.DeviceData")] public AITValveData ValveAV17 { get; set; }
        [Subscription("PM1.ValveAV18.DeviceData")] public AITValveData ValveAV18 { get; set; }
        [Subscription("PM1.ValveAV19.DeviceData")] public AITValveData ValveAV19 { get; set; }

        [Subscription("PM1.ValveAV20.DeviceData")] public AITValveData ValveAV20 { get; set; }
        [Subscription("PM1.ValveAV21.DeviceData")] public AITValveData ValveAV21 { get; set; }
        [Subscription("PM1.ValveAV22.DeviceData")] public AITValveData ValveAV22 { get; set; }
        [Subscription("PM1.ValveAV23.DeviceData")] public AITValveData ValveAV23 { get; set; }
        [Subscription("PM1.ValveAV24.DeviceData")] public AITValveData ValveAV24 { get; set; }
        [Subscription("PM1.ValveAV25.DeviceData")] public AITValveData ValveAV25 { get; set; }
        [Subscription("PM1.ValveAV26.DeviceData")] public AITValveData ValveAV26 { get; set; }
        [Subscription("PM1.ValveAV27.DeviceData")] public AITValveData ValveAV27 { get; set; }
        [Subscription("PM1.ValveAV28.DeviceData")] public AITValveData ValveAV28 { get; set; }
        [Subscription("PM1.ValveAV29.DeviceData")] public AITValveData ValveAV29 { get; set; }

        [Subscription("PM1.ValveAV30.DeviceData")] public AITValveData ValveAV30 { get; set; }
        [Subscription("PM1.ValveAV31.DeviceData")] public AITValveData ValveAV31 { get; set; }
        [Subscription("PM1.ValveAV32.DeviceData")] public AITValveData ValveAV32 { get; set; }
        [Subscription("PM1.ValveAV33.DeviceData")] public AITValveData ValveAV33 { get; set; }
        [Subscription("PM1.ValveAV34.DeviceData")] public AITValveData ValveAV34 { get; set; }
        [Subscription("PM1.ValveAV35.DeviceData")] public AITValveData ValveAV35 { get; set; }
        [Subscription("PM1.ValveAV36.DeviceData")] public AITValveData ValveAV36 { get; set; }
        [Subscription("PM1.ValveAV37.DeviceData")] public AITValveData ValveAV37 { get; set; }
        [Subscription("PM1.ValveAV38.DeviceData")] public AITValveData ValveAV38 { get; set; }
        [Subscription("PM1.ValveAV39.DeviceData")] public AITValveData ValveAV39 { get; set; }

        [Subscription("PM1.ValveAV40.DeviceData")] public AITValveData ValveAV40 { get; set; }
        [Subscription("PM1.ValveAV41.DeviceData")] public AITValveData ValveAV41 { get; set; }
        [Subscription("PM1.ValveAV42.DeviceData")] public AITValveData ValveAV42 { get; set; }
        [Subscription("PM1.ValveAV43.DeviceData")] public AITValveData ValveAV43 { get; set; }
        [Subscription("PM1.ValveAV44.DeviceData")] public AITValveData ValveAV44 { get; set; }
        [Subscription("PM1.ValveAV45.DeviceData")] public AITValveData ValveAV45 { get; set; }
        [Subscription("PM1.ValveAV46.DeviceData")] public AITValveData ValveAV46 { get; set; }
        [Subscription("PM1.ValveAV47.DeviceData")] public AITValveData ValveAV47 { get; set; }
        [Subscription("PM1.ValveAV48.DeviceData")] public AITValveData ValveAV48 { get; set; }
        [Subscription("PM1.ValveAV49.DeviceData")] public AITValveData ValveAV49 { get; set; }

        [Subscription("PM1.ValveAV50.DeviceData")] public AITValveData ValveAV50 { get; set; }
        [Subscription("PM1.ValveAV51.DeviceData")] public AITValveData ValveAV51 { get; set; }
        [Subscription("PM1.ValveAV52.DeviceData")] public AITValveData ValveAV52 { get; set; }
        [Subscription("PM1.ValveAV53.DeviceData")] public AITValveData ValveAV53 { get; set; }
        [Subscription("PM1.ValveAV54.DeviceData")] public AITValveData ValveAV54 { get; set; }
        [Subscription("PM1.ValveAV55.DeviceData")] public AITValveData ValveAV55 { get; set; }
        [Subscription("PM1.ValveAV56.DeviceData")] public AITValveData ValveAV56 { get; set; }
        [Subscription("PM1.ValveAV57.DeviceData")] public AITValveData ValveAV57 { get; set; }
        [Subscription("PM1.ValveAV58.DeviceData")] public AITValveData ValveAV58 { get; set; }
        [Subscription("PM1.ValveAV59.DeviceData")] public AITValveData ValveAV59 { get; set; }

        [Subscription("PM1.ValveAV60.DeviceData")] public AITValveData ValveAV60 { get; set; }
        [Subscription("PM1.ValveAV61.DeviceData")] public AITValveData ValveAV61 { get; set; }
        [Subscription("PM1.ValveAV62.DeviceData")] public AITValveData ValveAV62 { get; set; }

        [Subscription("PM1.ValveAV65.DeviceData")] public AITValveData ValveAV65 { get; set; }
        [Subscription("PM1.ValveAV66.DeviceData")] public AITValveData ValveAV66 { get; set; }
        [Subscription("PM1.ValveAV67.DeviceData")] public AITValveData ValveAV67 { get; set; }
        [Subscription("PM1.ValveAV68.DeviceData")] public AITValveData ValveAV68 { get; set; }
        [Subscription("PM1.ValveAV69.DeviceData")] public AITValveData ValveAV69 { get; set; }

        [Subscription("PM1.ValveAV70.DeviceData")] public AITValveData ValveAV70 { get; set; }
        [Subscription("PM1.APC.ModeFeedback")]
        public int APCModeFeedback { get; set; }
        [Subscription("PM1.ValveAV71.DeviceData")] public AITValveData ValveAV71Data { get; set; }
        public AITValveData ValveAV71
        {
            get
            {
                return new AITValveData()
                {
                    DeviceName = ValveAV71Data.DeviceName,
                    DisplayName = ValveAV71Data.DisplayName,
                    UniqueName = ValveAV71Data.UniqueName,
                    DefaultValue = ValveAV71Data.DefaultValue,
                    SetPoint = ValveAV71Data.SetPoint,
                    Feedback = APCModeFeedback != 5,
                    ILKDiValue = ValveAV71Data.ILKDiValue,
                    IsILKOK = true,
                    VirtualFeedback = ValveAV71Data.VirtualFeedback
                };
            }
        }
        [Subscription("PM1.ValveAV72.DeviceData")] public AITValveData ValveAV72 { get; set; }
        [Subscription("PM1.ValveAV73.DeviceData")] public AITValveData ValveAV73 { get; set; }
        [Subscription("PM1.ValveAV74.DeviceData")] public AITValveData ValveAV74 { get; set; }
        [Subscription("PM1.ValveAV75.DeviceData")] public AITValveData ValveAV75 { get; set; }
        [Subscription("PM1.ValveAV76.DeviceData")] public AITValveData ValveAV76 { get; set; }
        [Subscription("PM1.ValveAV77.DeviceData")] public AITValveData ValveAV77 { get; set; }
        [Subscription("PM1.ValveAV78.DeviceData")] public AITValveData ValveAV78 { get; set; }
        [Subscription("PM1.ValveAV79.DeviceData")] public AITValveData ValveAV79 { get; set; }

        [Subscription("PM1.ValveAV80.DeviceData")] public AITValveData ValveAV80 { get; set; }
        [Subscription("PM1.ValveAV81.DeviceData")] public AITValveData ValveAV81 { get; set; }
        [Subscription("PM1.ValveAV82.DeviceData")] public AITValveData ValveAV82 { get; set; }
        [Subscription("PM1.ValveAV83.DeviceData")] public AITValveData ValveAV83 { get; set; }
        [Subscription("PM1.ValveAV84.DeviceData")] public AITValveData ValveAV84 { get; set; }
        [Subscription("PM1.ValveAV85.DeviceData")] public AITValveData ValveAV85 { get; set; }
        [Subscription("PM1.ValveAV86.DeviceData")] public AITValveData ValveAV86 { get; set; }
        [Subscription("PM1.ValveAV87.DeviceData")] public AITValveData ValveAV87 { get; set; }
        [Subscription("PM1.ValveAV88.DeviceData")] public AITValveData ValveAV88 { get; set; }
        [Subscription("PM1.ValveAV89.DeviceData")] public AITValveData ValveAV89 { get; set; }

        [Subscription("PM1.ValveAV90.DeviceData")] public AITValveData ValveAV90 { get; set; }
        [Subscription("PM1.ValveAV91.DeviceData")] public AITValveData ValveAV91 { get; set; }
        [Subscription("PM1.ValveAV92.DeviceData")] public AITValveData ValveAV92 { get; set; }
        [Subscription("PM1.ValveAV93.DeviceData")] public AITValveData ValveAV93 { get; set; }
        [Subscription("PM1.ValveAV94.DeviceData")] public AITValveData ValveAV94 { get; set; }
        [Subscription("PM1.ValveAV95.DeviceData")] public AITValveData ValveAV95 { get; set; }
        [Subscription("PM1.ValveAV96.DeviceData")] public AITValveData ValveAV96 { get; set; }
        [Subscription("PM1.ValveAV97.DeviceData")] public AITValveData ValveAV97 { get; set; }
        [Subscription("PM1.ValveAV98.DeviceData")] public AITValveData ValveAV98 { get; set; }
        [Subscription("PM1.ValveAV99.DeviceData")] public AITValveData ValveAV99 { get; set; }

        [Subscription("PM1.ValveAV100.DeviceData")] public AITValveData ValveAV100 { get; set; }
        [Subscription("PM1.ValveAV101.DeviceData")] public AITValveData ValveAV101 { get; set; }
        [Subscription("PM1.ValveAV102.DeviceData")] public AITValveData ValveAV102 { get; set; }
        [Subscription("PM1.ValveAV103.DeviceData")] public AITValveData ValveAV103 { get; set; }
        [Subscription("PM1.ValveAV104.DeviceData")] public AITValveData ValveAV104 { get; set; }
        [Subscription("PM1.ValveAV105.DeviceData")] public AITValveData ValveAV105 { get; set; }
        [Subscription("PM1.ValveAV106.DeviceData")] public AITValveData ValveAV106 { get; set; }
        [Subscription("PM1.ValveAV107.DeviceData")] public AITValveData ValveAV107 { get; set; }
        [Subscription("PM1.ValveAV108.DeviceData")] public AITValveData ValveAV108 { get; set; }
        [Subscription("PM1.ValveAV109.DeviceData")] public AITValveData ValveAV109 { get; set; }

        [Subscription("PM1.ValveAV110.DeviceData")] public AITValveData ValveAV110 { get; set; }
        [Subscription("PM1.ValveAV111.DeviceData")] public AITValveData ValveAV111 { get; set; }
        [Subscription("PM1.ValveAV112.DeviceData")] public AITValveData ValveAV112 { get; set; }
        [Subscription("PM1.ValveAV113.DeviceData")] public AITValveData ValveAV113 { get; set; }
        [Subscription("PM1.ValveAV114.DeviceData")] public AITValveData ValveAV114 { get; set; }
        [Subscription("PM1.ValveAV115.DeviceData")] public AITValveData ValveAV115 { get; set; }
        [Subscription("PM1.ValveAV116.DeviceData")] public AITValveData ValveAV116 { get; set; }
        [Subscription("PM1.ValveAV117.DeviceData")] public AITValveData ValveAV117 { get; set; }
        [Subscription("PM1.ValveAV118.DeviceData")] public AITValveData ValveAV118 { get; set; }
        [Subscription("PM1.ValveAV119.DeviceData")] public AITValveData ValveAV119 { get; set; }

        [Subscription("PM1.ValveAV120.DeviceData")] public AITValveData ValveAV120 { get; set; }
        [Subscription("PM1.ValveAV121.DeviceData")] public AITValveData ValveAV121 { get; set; }
        [Subscription("PM1.ValveAV122.DeviceData")] public AITValveData ValveAV122 { get; set; }
        [Subscription("PM1.ValveAV123.DeviceData")] public AITValveData ValveAV123 { get; set; }
        [Subscription("PM1.ValveAV124.DeviceData")] public AITValveData ValveAV124 { get; set; }
        [Subscription("PM1.ValveAV125.DeviceData")] public AITValveData ValveAV125 { get; set; }
        [Subscription("PM1.ValveAV126.DeviceData")] public AITValveData ValveAV126 { get; set; }
        [Subscription("PM1.ValveAV127.DeviceData")] public AITValveData ValveAV127 { get; set; }
        [Subscription("PM1.ValveAV128.DeviceData")] public AITValveData ValveAV128 { get; set; }
        [Subscription("PM1.ValveAV129.DeviceData")] public AITValveData ValveAV129 { get; set; }

        [Subscription("PM1.ValveAV130.DeviceData")] public AITValveData ValveAV130 { get; set; }
        [Subscription("PM1.ValveAV131.DeviceData")] public AITValveData ValveAV131 { get; set; }
        [Subscription("PM1.ValveAV132.DeviceData")] public AITValveData ValveAV132 { get; set; }
        [Subscription("PM1.ValveAV133.DeviceData")] public AITValveData ValveAV133 { get; set; }
        [Subscription("PM1.ValveAV134.DeviceData")] public AITValveData ValveAV134 { get; set; }
        [Subscription("PM1.ValveAV135.DeviceData")] public AITValveData ValveAV135 { get; set; }
        [Subscription("PM1.ValveAV136.DeviceData")] public AITValveData ValveAV136 { get; set; }




        [Subscription("PM1.ValveAV91.DeviceData")]
        public AITValveData ValveDPR { get; set; }
        public string ValveDPRBrush
        {
            get
            {
                if (ValveDPR != null && ValveDPR.Feedback)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }


        [Subscription("PM1.ValveBlowerPowerOn.DeviceData")]
        public AITValveData ValveBWR { get; set; }
        public string ValveBWRBrush
        {
            get
            {
                if (ValveBWR != null && ValveBWR.Feedback)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.IsCEXHOn")]
        public bool IsCEXHOn { get; set; }
        public string CEXHBrush
        {
            get
            {
                if (IsCEXHOn)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.IsF2ClnOn")]
        public bool IsF2ClnOn { get; set; }
        public string F2ClnBrush
        {
            get
            {
                if (IsF2ClnOn)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.IsHFClnOn")]
        public bool IsHFClnOn { get; set; }
        public string HFClnBrush
        {
            get
            {
                if (IsHFClnOn)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.IsDEPOOn")]
        public bool IsDEPOOn { get; set; }
        public string DEPOBrush
        {
            get
            {
                if (IsDEPOOn)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.HTR1Enable")]
        public bool IsHTR1Enable { get; set; }
        public string HTR1Brush
        {
            get
            {
                if (IsHTR1Enable)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.HTR2Enable")]
        public bool IsHTR2Enable { get; set; }
        public string HTR2Brush
        {
            get
            {
                if (IsHTR2Enable)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.HTR3Enable")]
        public bool IsHTR3Enable { get; set; }
        public string HTR3Brush
        {
            get
            {
                if (IsHTR3Enable)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }
        [Subscription("PM1.AUCPump.DeviceData")]
        public AITValveData AUCPump { get; set; }
        public string AUCPumpBrush
        {
            get
            {
                if (AUCPump != null && AUCPump.Feedback)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }

        [Subscription("PM1.BothPump1.DeviceData")]
        public AITValveData BothPump1 { get; set; }
        public string BothPump1Brush
        {
            get
            {
                if (BothPump1 != null && BothPump1.Feedback)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }

        [Subscription("PM1.BothPump2.DeviceData")]
        public AITValveData BothPump2 { get; set; }
        public string BothPump2Brush
        {
            get
            {
                if (BothPump2 != null && BothPump2.Feedback)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }

        [Subscription("PM1.AGVPump.DeviceData")]
        public AITValveData AGVPump { get; set; }
        public string AGVPumpBrush
        {
            get
            {
                if (AGVPump != null && AGVPump.Feedback)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }

        [Subscription("PM1.AGV2Pump.DeviceData")]
        public AITValveData AGV2Pump { get; set; }
        public string AGV2PumpBrush
        {
            get
            {
                if (AGV2Pump != null && AGV2Pump.Feedback)
                {
                    return "Green";
                }
                return backGroundStr;
            }
        }

        [Subscription("PM1.HMNT.DeviceData")]
        public AITValveData HMNT { get; set; }
        public string HMNTBrush
        {
            get
            {
                if (HMNT != null && HMNT.Feedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }


        [Subscription("PM1.HZERO.DeviceData")]
        public AITValveData HZERO { get; set; }

        public string HZEROBrush
        {
            get
            {
                if (HZERO != null && HZERO.Feedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.CMNT.DeviceData")]
        public AITValveData CMNT { get; set; }
        public string CMNTBrush
        {
            get
            {
                if (CMNT != null && CMNT.Feedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }


        [Subscription("PM1.CZERO.DeviceData")]
        public AITValveData CZERO { get; set; }

        public string CZEROBrush
        {
            get
            {
                if (CZERO != null && CZERO.Feedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }


        [Subscription("PM1.HREF.DeviceData")]
        public AITValveData HREF { get; set; }

        public string HREFBrush
        {
            get
            {
                if (HREF != null && HREF.Feedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.CREF.DeviceData")]
        public AITValveData CREF2 { get; set; }
  
        public string CREF2Brush
        {
            get
            {
                if (CREF2 != null && CREF2.Feedback)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

       

      


        [Subscription("PM1.IsCREFOn")]
        public bool IsCREFOn { get; set; }

        public string CREFBrush
        {
            get
            {
                if (IsCREFOn)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }

        [Subscription("PM1.IsSIREFOn")]
        public bool IsSIREFOn { get; set; }
      
        public string SIREFBrush
        {
            get
            {
                if (IsSIREFOn)
                {
                    return "Green";
                }
                return "#FFB0D1F1";
            }
        }



        #endregion
        private Dictionary<string, bool> DictValveIsILKOK = new Dictionary<string, bool>();
        #region MFCs
        [Subscription("PM1.MFC1.DeviceData")]
        public AITMfcData MFC1Data { get; set; }
        [Subscription("PM1.MFC2.DeviceData")]
        public AITMfcData MFC2Data { get; set; }
        [Subscription("PM1.MFC3.DeviceData")]
        public AITMfcData MFC3Data { get; set; }
        [Subscription("PM1.MFC4.DeviceData")]
        public AITMfcData MFC4Data { get; set; }
        [Subscription("PM1.MFC5.DeviceData")]
        public AITMfcData MFC5Data { get; set; }
        [Subscription("PM1.MFC6.DeviceData")]
        public AITMfcData MFC6Data { get; set; }
        [Subscription("PM1.MFC7.DeviceData")]
        public AITMfcData MFC7Data { get; set; }
        [Subscription("PM1.MFC8.DeviceData")]
        public AITMfcData MFC8Data { get; set; }
        [Subscription("PM1.MFC9.DeviceData")]
        public AITMfcData MFC9Data { get; set; }
        [Subscription("PM1.MFC10.DeviceData")]
        public AITMfcData MFC10Data { get; set; }
        [Subscription("PM1.MFC11.DeviceData")]
        public AITMfcData MFC11Data { get; set; }
        [Subscription("PM1.MFC12.DeviceData")]
        public AITMfcData MFC12Data { get; set; }
        [Subscription("PM1.MFC13.DeviceData")]
        public AITMfcData MFC13Data { get; set; }
        [Subscription("PM1.MFC16.DeviceData")]
        public AITMfcData MFC16Data { get; set; }
        [Subscription("PM1.MFC17.DeviceData")]
        public AITMfcData MFC17Data { get; set; }

        [Subscription("PM1.MFC31.DeviceData")]
        public AITMfcData MFC31Data { get; set; }

        [Subscription("PM1.MFC32.DeviceData")]
        public AITMfcData MFC32Data { get; set; }

        #endregion


        [Subscription("PM1.MFM6.DeviceData")] 
        public AITWaterFlowMeterData MFM6Flow { get; set; }
        [Subscription("PM1.MFM7.DeviceData")]
        public AITWaterFlowMeterData MFM7Flow { get; set; }
        [Subscription("PM1.MFM8.DeviceData")]
        public AITWaterFlowMeterData MFM8Flow { get; set; }
        [Subscription("PM1.MFM9.DeviceData")] 
        public AITWaterFlowMeterData MFM9Flow { get; set; }
        [Subscription("PM1.MFM11.DeviceData")] 
        public AITWaterFlowMeterData MFM11Flow { get; set; }
        [Subscription("PM1.MFM12.DeviceData")]
        public AITWaterFlowMeterData MFM12Flow { get; set; }
        [Subscription("PM1.MFM13.DeviceData")]
        public AITWaterFlowMeterData MFM13Flow { get; set; }
        [Subscription("PM1.MFM16.DeviceData")] 
        public AITWaterFlowMeterData MFM16Flow { get; set; }

        [Subscription("PM1.RfPower.IsPowerOn")]
        public bool IsPowerOn { get; set; }
        [Subscription("PM1.RfPower.PowerSetPoint")]
        public float PowerSetPoint { get; set; }
        [Subscription("PM1.RfPower.ForwardPower")]
        public float ForwardPower { get; set; }
        [Subscription("PM1.RfMatch.Capacitance1PositionFeedBack")]
        public float Capacitance1PositionFeedBack { get; set; }
        [Subscription("PM1.RfMatch.Capacitance2PositionFeedBack")]
        public float Capacitance2PositionFeedBack { get; set; }
        [Subscription("PM1.RfMatch.VppFeedBack")]
        public float VppFeedBack { get; set; }

        public ICommand CmdSetValve { get; set; }

        private GasPanelStateType _selectedGasStateType = GasPanelStateType.Monitor;

        public GasPanelStateType SelectedGasStateType
        {
            get
            {
                return _selectedGasStateType;
            }
            set
            {
                _selectedGasStateType = value;
                NotifyOfPropertyChange(nameof(SelectedGasStateType));
            }
        }

        public AnalogDeviceDataItem MFC1
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC1Data.UniqueName,
                    DeviceId = MFC1Data.DeviceSchematicId,
                    DisplayName = MFC1Data.DisplayName,
                    Scale = MFC1Data.Scale,
                    Unit = MFC1Data.Unit,
                    FeedBack = MFC1Data.FeedBack,
                    SetPoint = MFC1Data.SetPoint,
                    VirtualFeedBack = MFC1Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC2
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC2Data.UniqueName,
                    DeviceId = MFC2Data.DeviceSchematicId,
                    DisplayName = MFC2Data.DisplayName,
                    Scale = MFC2Data.Scale,
                    Unit = MFC2Data.Unit,
                    FeedBack = MFC2Data.FeedBack,
                    SetPoint = MFC2Data.SetPoint,
                    VirtualFeedBack = MFC2Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC3
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC3Data.UniqueName,
                    DeviceId = MFC3Data.DeviceSchematicId,
                    DisplayName = MFC3Data.DisplayName,
                    Scale = MFC3Data.Scale,
                    Unit = MFC3Data.Unit,
                    FeedBack = MFC3Data.FeedBack,
                    SetPoint = MFC3Data.SetPoint,
                    VirtualFeedBack = MFC3Data.VirtualFeedBack
                };
            }
        }

        public AnalogDeviceDataItem MFC4
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC4Data.UniqueName,
                    DeviceId = MFC4Data.DeviceSchematicId,
                    DisplayName = MFC4Data.DisplayName,
                    Scale = MFC4Data.Scale,
                    Unit = MFC4Data.Unit,
                    FeedBack = MFC4Data.FeedBack,
                    SetPoint = MFC4Data.SetPoint,
                    VirtualFeedBack = MFC4Data.VirtualFeedBack
                };
            }
        }

        public AnalogDeviceDataItem MFC5
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC5Data.UniqueName,
                    DeviceId = MFC5Data.DeviceSchematicId,
                    DisplayName = MFC5Data.DisplayName,
                    Scale = MFC5Data.Scale,
                    Unit = MFC5Data.Unit,
                    FeedBack = MFC5Data.FeedBack,
                    SetPoint = MFC5Data.SetPoint,
                    VirtualFeedBack = MFC5Data.VirtualFeedBack
                };
            }
        }

        public AnalogDeviceDataItem MFC6
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC6Data.UniqueName,
                    DeviceId = MFC6Data.DeviceSchematicId,
                    DisplayName = MFC6Data.DisplayName,
                    Scale = MFC6Data.Scale,
                    Unit = MFC6Data.Unit,
                    FeedBack = MFC6Data.FeedBack,
                    SetPoint = MFC6Data.SetPoint,
                    VirtualFeedBack = MFC6Data.VirtualFeedBack
                };
            }
        }

        public AnalogDeviceDataItem MFC7
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC7Data.UniqueName,
                    DeviceId = MFC7Data.DeviceSchematicId,
                    DisplayName = MFC7Data.DisplayName,
                    Scale = MFC7Data.Scale,
                    Unit = MFC7Data.Unit,
                    FeedBack = MFC7Data.FeedBack,
                    SetPoint = MFC7Data.SetPoint,
                    VirtualFeedBack = MFC7Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC8
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC8Data.UniqueName,
                    DeviceId = MFC8Data.DeviceSchematicId,
                    DisplayName = MFC8Data.DisplayName,
                    Scale = MFC8Data.Scale,
                    Unit = MFC8Data.Unit,
                    FeedBack = MFC8Data.FeedBack,
                    SetPoint = MFC8Data.SetPoint,
                    VirtualFeedBack = MFC8Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC9
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC9Data.UniqueName,
                    DeviceId = MFC9Data.DeviceSchematicId,
                    DisplayName = MFC9Data.DisplayName,
                    Scale = MFC9Data.Scale,
                    Unit = MFC9Data.Unit,
                    FeedBack = MFC9Data.FeedBack,
                    SetPoint = MFC9Data.SetPoint,
                    VirtualFeedBack = MFC9Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC10
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC10Data.UniqueName,
                    DeviceId = MFC10Data.DeviceSchematicId,
                    DisplayName = MFC10Data.DisplayName,
                    Scale = MFC10Data.Scale,
                    Unit = MFC10Data.Unit,
                    FeedBack = MFC10Data.FeedBack,
                    SetPoint = MFC10Data.SetPoint,
                    VirtualFeedBack = MFC10Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC11
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC11Data.UniqueName,
                    DeviceId = MFC11Data.DeviceSchematicId,
                    DisplayName = MFC11Data.DisplayName,
                    Scale = MFC11Data.Scale,
                    Unit = MFC11Data.Unit,
                    FeedBack = MFC11Data.FeedBack,
                    SetPoint = MFC11Data.SetPoint,
                    VirtualFeedBack = MFC11Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC12
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC12Data.UniqueName,
                    DeviceId = MFC12Data.DeviceSchematicId,
                    DisplayName = MFC12Data.DisplayName,
                    Scale = MFC12Data.Scale,
                    Unit = MFC12Data.Unit,
                    FeedBack = MFC12Data.FeedBack,
                    SetPoint = MFC12Data.SetPoint,
                    VirtualFeedBack = MFC12Data.VirtualFeedBack
                };
            }
        }
        public AnalogDeviceDataItem MFC13
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC13Data.UniqueName,
                    DeviceId = MFC13Data.DeviceSchematicId,
                    DisplayName = MFC13Data.DisplayName,
                    Scale = MFC13Data.Scale,
                    Unit = MFC13Data.Unit,
                    FeedBack = MFC13Data.FeedBack,
                    SetPoint = MFC13Data.SetPoint,
                    VirtualFeedBack = MFC13Data.VirtualFeedBack
                };
            }
        }
    
        public AnalogDeviceDataItem MFC16
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC16Data.UniqueName,
                    DeviceId = MFC16Data.DeviceSchematicId,
                    DisplayName = MFC16Data.DisplayName,
                    Scale = MFC16Data.Scale,
                    Unit = MFC16Data.Unit,
                    FeedBack = MFC16Data.FeedBack,
                    SetPoint = MFC16Data.SetPoint,
                    VirtualFeedBack = MFC16Data.VirtualFeedBack
                };
            }
        }

        public AnalogDeviceDataItem MFC17
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC17Data.UniqueName,
                    DeviceId = MFC17Data.DeviceSchematicId,
                    DisplayName = MFC17Data.DisplayName,
                    Scale = MFC17Data.Scale,
                    Unit = MFC17Data.Unit,
                    FeedBack = MFC17Data.FeedBack,
                    SetPoint = MFC17Data.SetPoint,
                    VirtualFeedBack = MFC17Data.VirtualFeedBack
                };
            }
        }

        public AnalogDeviceDataItem MFC31
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC31Data.UniqueName,
                    DeviceId = MFC31Data.DeviceSchematicId,
                    DisplayName = MFC31Data.DisplayName,
                    Scale = MFC31Data.Scale,
                    Unit = MFC31Data.Unit,
                    FeedBack = MFC31Data.FeedBack,
                    SetPoint = MFC31Data.SetPoint,
                    VirtualFeedBack = MFC31Data.VirtualFeedBack
                };
            }
        }


        public AnalogDeviceDataItem MFC32
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC32Data.UniqueName,
                    DeviceId = MFC32Data.DeviceSchematicId,
                    DisplayName = MFC32Data.DisplayName,
                    Scale = MFC32Data.Scale,
                    Unit = MFC32Data.Unit,
                    FeedBack = MFC32Data.FeedBack,
                    SetPoint = MFC32Data.SetPoint,
                    VirtualFeedBack = MFC32Data.VirtualFeedBack
                };
            }
        }



        public AnalogDeviceDataItem MFM6
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM6Flow.DisplayName,
                    DeviceId = MFM6Flow.DeviceSchematicId,
                    DisplayName = MFM6Flow.DisplayName,
                    Scale = MFM6Flow.Scale,
                    Unit = MFM6Flow.Unit,
                    FeedBack = MFM6Flow.FeedBack,
                    SetPoint = MFM6Flow.SetPoint,
                };
            }
        }
        public AnalogDeviceDataItem MFM7
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM7Flow.DisplayName,
                    DeviceId = MFM7Flow.DeviceSchematicId,
                    DisplayName = MFM7Flow.DisplayName,
                    Scale = MFM7Flow.Scale,
                    Unit = MFM7Flow.Unit,
                    FeedBack = MFM7Flow.FeedBack,
                    SetPoint = MFM7Flow.SetPoint,
                };
            }
        }
        public AnalogDeviceDataItem MFM8
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM8Flow.DisplayName,
                    DeviceId = MFM8Flow.DeviceSchematicId,
                    DisplayName = MFM8Flow.DisplayName,
                    Scale = MFM8Flow.Scale,
                    Unit = MFM8Flow.Unit,
                    FeedBack = MFM8Flow.FeedBack,
                    SetPoint = MFM8Flow.SetPoint,
                };
            }
        }
        public AnalogDeviceDataItem MFM9
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM9Flow.DisplayName,
                    DeviceId = MFM9Flow.DeviceSchematicId,
                    DisplayName = MFM9Flow.DisplayName,
                    Scale = MFM9Flow.Scale,
                    Unit = MFM9Flow.Unit,
                    FeedBack = MFM9Flow.FeedBack,
                    SetPoint = MFM9Flow.SetPoint,
                };
            }
        }
        public AnalogDeviceDataItem MFM11
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM11Flow.DisplayName,
                    DeviceId = MFM11Flow.DeviceSchematicId,
                    DisplayName = MFM11Flow.DisplayName,
                    Scale = MFM11Flow.Scale,
                    Unit = MFM11Flow.Unit,
                    FeedBack = MFM11Flow.FeedBack,
                    SetPoint = MFM11Flow.SetPoint,
                };
            }
        }
        public AnalogDeviceDataItem MFM12
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM12Flow.DisplayName,
                    DeviceId = MFM12Flow.DeviceSchematicId,
                    DisplayName = MFM12Flow.DisplayName,
                    Scale = MFM12Flow.Scale,
                    Unit = MFM12Flow.Unit,
                    FeedBack = MFM12Flow.FeedBack,
                    SetPoint = MFM12Flow.SetPoint,
                };
            }
        }
        public AnalogDeviceDataItem MFM13
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM13Flow.DisplayName,
                    DeviceId = MFM13Flow.DeviceSchematicId,
                    DisplayName = MFM13Flow.DisplayName,
                    Scale = MFM13Flow.Scale,
                    Unit = MFM13Flow.Unit,
                    FeedBack = MFM13Flow.FeedBack,
                    SetPoint = MFM13Flow.SetPoint,
                };
            }
        }
        public AnalogDeviceDataItem MFM16
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceName = MFM16Flow.DisplayName,
                    DeviceId = MFM16Flow.DeviceSchematicId,
                    DisplayName = MFM16Flow.DisplayName,
                    Scale = MFM16Flow.Scale,
                    Unit = MFM16Flow.Unit,
                    FeedBack = MFM16Flow.FeedBack,
                    SetPoint = MFM16Flow.SetPoint,
                };
            }
        }
        public string IsRfPowerOn
        {
            get
            {
                return IsPowerOn ? "On" : "Off";
            }
        }

        private bool _manualCheckSelect = false;

        private bool _manualCheck = true;
        public bool ManualCheck
        {
            get => _manualCheck;
            set
            {
                _manualCheck = value;
                NotifyOfPropertyChange(nameof(ManualCheck));
            }
        }

        private bool _manualCheckHide;
        public bool ManumalCheckHide
        {
            get => _manualCheckHide;
            set
            {
                _manualCheckHide = value;
                NotifyOfPropertyChange(nameof(ManumalCheckHide));
            }
        }

        public bool ValveTrue { get; set; } = true;
        public bool ValveFalse { get; set; } = false;

        private bool _enablePLCPointControl = false;

        public bool EnablePLCPointControl
        {
            get => _enablePLCPointControl;
            set
            {
                _enablePLCPointControl = value;
                NotifyOfPropertyChange(nameof(EnablePLCPointControl));
            }
        }


        public GasPanelViewModel()
        {
            CmdSetMfcFlow = new DelegateCommand<object>(PerformCmdSetMfcFlow);
            CmdSetMfmFlow = new DelegateCommand<object>(PerformCmdSetMfmFlow);
        }

        public void SelectedGasStateTypeCmd(string cmd)
        {
            switch (cmd)
            {
                case "Manual":
                    SelectedGasStateType = GasPanelStateType.Manual;
                    ManualEnable = true;
                    break;
                case "Monitor":
                    SelectedGasStateType = GasPanelStateType.Monitor;
                    ManualEnable = true;
                    break;
                case "Recipe":
                    SelectedGasStateType = GasPanelStateType.Recipe;
                    ManualEnable = false;
                    break;
                default:
                    break;
            }
        }

        protected override void OnActivate()
        {
            base.OnActivate();

            //  EnableServiceControl = (bool)QueryDataClient.Instance.Service.GetConfig("System.IsServiceControlMode");
            //   IsMfcNRInstalled = (bool)QueryDataClient.Instance.Service.GetConfig("PM1.MFC.MfcNR.IsMFCInstalled");

        }

        public void SetEditClick()
        {
            IsRecipeEdit = true;
            //  EnableServiceControl = false;
        }

        protected override void OnDeactivate(bool close)
        {
            base.OnDeactivate(close);
            //IsManagerPermission = false;
        }
        public void SetManual()
        {
            if (!_manualCheckSelect)
            {
                _manualCheckSelect = !_manualCheckSelect;
                IsManagerPermission = true;
                EnablePLCPointControl = false;
            }
            else
            {
                IsManagerPermission = true;
                ManualCheck = false;
                ManumalCheckHide = true;
                _manualCheckSelect = !_manualCheckSelect;
                EnablePLCPointControl = true;
            }
        }
        public void OpenAll()
        {
            if (!VentValveData.IsOpen)
                InvokeClient.Instance.Service.DoOperation($"{VentValveData.UniqueName}.{AITValveOperation.GVTurnValve}", true);
            if (!PumpValveData.IsOpen)
                InvokeClient.Instance.Service.DoOperation($"{PumpValveData.UniqueName}.{AITValveOperation.GVTurnValve}", true);
        }

        public void CloseAll()
        {
            if (PumpValveData.IsOpen)
                InvokeClient.Instance.Service.DoOperation($"{PumpValveData.UniqueName}.{AITValveOperation.GVTurnValve}", false);
            if (VentValveData.IsOpen)
                InvokeClient.Instance.Service.DoOperation($"{VentValveData.UniqueName}.{AITValveOperation.GVTurnValve}", false);
        }
        private void PerformCmdSetMfcFlow(object param)
        {
            object[] args = (object[])param; //0:devicename, 1:operation, 2:args
            if (args.Length == 3)
            {
                InvokeClient.Instance.Service.DoOperation($"{args[0]}.{args[1]}", args[2]);
            }
        }
        private void PerformCmdSetMfmFlow(object param)
        {
            //object[] args = (object[])param; //0:devicename, 1:operation, 2:args
            //if (args.Length == 3)
            //{
            //    InvokeClient.Instance.Service.DoOperation($"PM1.{args[0]}.{args[1]}", args[2]);
            //}
        }
        bool isSensorRecipeOK = false;

        Dictionary<string, object> oldresult;
        private Dictionary<string, object> ClearNotChangedValue(Dictionary<string, object> result)
        {
            Dictionary<string, object> temp = result;
            if (oldresult == null)
            {
                oldresult = result;
            }
            else
            {
                try
                {
                    List<string> strkeys = new List<string>();
                    foreach (var key in result.Keys)
                    {

                        if (_subscribedKeys.Contains(key) && oldresult.ContainsKey(key) && result.ContainsKey(key))
                        {
                            if (result[key].GetType() == typeof(AITValveData) && (((AITValveData)oldresult[key]).Feedback != ((AITValveData)result[key]).Feedback
                                || ((AITValveData)oldresult[key]).VirtualFeedback != ((AITValveData)result[key]).VirtualFeedback))
                            {
                                strkeys.Add(key);
                            }
                            else if (result[key].GetType() == typeof(AITSensorData) && ((AITSensorData)oldresult[key]).Value != ((AITSensorData)result[key]).Value)
                            {
                                strkeys.Add(key);
                            }
                            else if (result[key].GetType() == typeof(AITMfcData) && (((AITMfcData)oldresult[key]).FeedBack != ((AITMfcData)result[key]).FeedBack ||
                               ((AITMfcData)oldresult[key]).VirtualFeedBack != ((AITMfcData)result[key]).VirtualFeedBack))
                            {
                                strkeys.Add(key);
                            }
                            else if (result[key].GetType() == typeof(float) && (float)oldresult[key] == (float)result[key])
                            {
                                strkeys.Add(key);
                            }
                            else if (result[key].GetType() == typeof(int) && (int)oldresult[key] == (int)result[key])
                            {
                                strkeys.Add(key);
                            }
                            else if (result[key].GetType() == typeof(bool) && (bool)oldresult[key] == (bool)result[key])
                            {
                                strkeys.Add(key);
                            }
                        }
                    }
                    for (int i = 0; i < strkeys.Count; i++)

                    {

                        temp.Remove(strkeys[i]);

                    }
                }
                catch (Exception ex)
                {
                    LOG.Error("由RT返回的数据更新失败" + "ClearNotChangedValue", ex);
                }
            }
            return temp;
        }

        protected override void Poll()
        {
            if (_subscribedKeys.Count > 0)
            {
                Dictionary<string, object> result = QueryDataClient.Instance.Service.PollData(_subscribedKeys);
                Dictionary<string, object> Tempresult = new Dictionary<string, object>(result);
                if (SelectedGasStateType != GasPanelStateType.Monitor)
                {
                    result = ClearNotChangedValue(result);

                }
                oldresult = Tempresult;
                if (result == null)
                {
                    LOG.Error("获取RT数据失败");
                    return;
                }

                if (result.Count != _subscribedKeys.Count)
                {
                    string unknowKeys = string.Empty;
                    foreach (string key in _subscribedKeys)
                    {
                        if (!result.ContainsKey(key))
                        {
                            unknowKeys += key + "\r\n";
                        }
                    }
                }

                InvokeBeforeUpdateProperty(result);

                UpdateValue(result);

                Application.Current?.Dispatcher.Invoke(new Action(() =>
                {
                    if (result.Count != 0)
                    {
                        InvokePropertyChanged();
                    }
                    InvokeAfterUpdateProperty(result);
                }));


            }
        }

        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
        {

            base.InvokeBeforeUpdateProperty(data);
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            if (SensorRecipeOK != null && SensorRecipeOK.Value)
            {
                if (isSensorRecipeOK != SensorRecipeOK.Value)
                {
                    _manualCheckSelect = false;
                    IsManagerPermission = true;
                    IsRecipeEdit = true;
                    //  EnableServiceControl = false;
                }
                isSensorRecipeOK = SensorRecipeOK.Value;
                var properties = GetType().GetProperties();
                if (SelectedGasStateType == GasPanelStateType.Monitor )
                {
                    foreach (var item in properties)
                    {
                        var tempObj = item.GetValue(this);
                        if (tempObj is AITValveData)
                        {
                            var aitTempObj = (AITValveData)tempObj;
                            if (DictValveIsILKOK.ContainsKey(aitTempObj.DeviceName) && DictValveIsILKOK[aitTempObj.DeviceName] != aitTempObj.IsILKOK)
                            {
                                DictValveIsILKOK[aitTempObj.DeviceName] = aitTempObj.IsILKOK;
                                NotifyOfPropertyChange(aitTempObj.DeviceName);
                            }
                        }
                    }
                }
            }
            if (SelectedGasStateType == GasPanelStateType.Monitor)
            {
                PropertyInfo[] tempProperties = GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
                foreach (PropertyInfo property in tempProperties)
                {
                    if (property.Name.Contains("MFC"))
                    {
                        // 触发属性更改通知
                        NotifyOfPropertyChange(property.Name);
                    }
                }
            }
        }

        public void SwichValue(string name)
        {
            if (SelectedGasStateType == GasPanelStateType.Monitor || SelectedGasStateType == GasPanelStateType.Recipe) return;
            var dialog = new SwitchValueDialog { };
            dialog.IsOpen = true;
            switch (name.ToUpper())
            {
                case "BWR":
                    dialog.IsOpen = ValveBWR.Feedback;
                    break;
                case "DPR":
                    dialog.IsOpen = ValveDPR.Feedback;
                    break;
                case "CEXH":
                    dialog.IsOpen = IsCEXHOn;
                    break;
                case "F2":
                    dialog.IsOpen = IsF2ClnOn;
                    break;
                case "HF":
                    dialog.IsOpen = IsHFClnOn;
                    break;
                case "DEPO":
                    dialog.IsOpen = IsDEPOOn;
                    break;
            }

            dialog.Owner = WinOwner;
            dialog.Topmost = true;
            dialog.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            dialog.DeviceName = $"Swich {name}";

            dialog.ShowDialog();

            if ((bool)dialog.IsSave)
            {
                switch (name.ToUpper())
                {
                    case "BWR":
                        InvokeClient.Instance.Service.DoOperation($"{ValveBWR.UniqueName}.{AITValveOperation.GVTurnValve}", dialog.IsOpen);
                        break;
                    case "DPR":
                        InvokeClient.Instance.Service.DoOperation($"{ValveDPR.UniqueName}.{AITValveOperation.GVTurnValve}", dialog.IsOpen);
                        break;
                    case "CEXH":
                        InvokeClient.Instance.Service.DoOperation($"PM1.SetCEXHEnable", dialog.IsOpen);
                        break;
                    case "F2":
                        InvokeClient.Instance.Service.DoOperation($"PM1.SetF2ClnEnable", dialog.IsOpen);
                        break;
                    case "HF":
                        InvokeClient.Instance.Service.DoOperation($"PM1.SetHFClnEnable", dialog.IsOpen);
                        break;
                    case "DEPO":
                        InvokeClient.Instance.Service.DoOperation($"PM1.SetDEPOEnable", dialog.IsOpen);
                        break;
                }
            }
        }
        public void SetEnable(string name)
        {
            if (SelectedGasStateType == GasPanelStateType.Monitor || SelectedGasStateType == GasPanelStateType.Recipe) return;
            var dialog = new SwitchValueDialog2 { };
            dialog.IsOpen = true;
            switch (name.ToUpper())
            {
                case "HTR1":
                    dialog.IsOpen = IsHTR1Enable;
                    break;
                case "HTR2":
                    dialog.IsOpen = IsHTR2Enable;
                    break;
                case "HTR3":
                    dialog.IsOpen = IsHTR3Enable;
                    break;
            }

            dialog.Owner = WinOwner;
            dialog.Topmost = true;
            dialog.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            dialog.DeviceName = $"Swich {name}";

            dialog.ShowDialog();

            if ((bool)dialog.IsSave)
            {
                switch (name.ToUpper())
                {
                    case "HTR1":
                        InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR1Enable", dialog.IsOpen);
                        break;
                    case "HTR2":
                        InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR2Enable", dialog.IsOpen);
                        break;
                    case "HTR3":
                        InvokeClient.Instance.Service.DoOperation($"PM1.SetHTR3Enable", dialog.IsOpen);
                        break;
                }
            }
        }
        public void SelectPump(string _pumpname)
        {
            if (SelectedGasStateType == GasPanelStateType.Monitor || SelectedGasStateType == GasPanelStateType.Recipe) return;
            if (!DialogBox.Confirm($"Are you sure change {_pumpname} status?"))
                return;

            if (_pumpname == "AUC")
            {
                InvokeClient.Instance.Service.DoOperation($"{AUCPump.UniqueName}.{AITValveOperation.GVTurnValve}", !AUCPump.Feedback);
            }
            if (_pumpname == "AGV1")
            {
                InvokeClient.Instance.Service.DoOperation($"{AGVPump.UniqueName}.{AITValveOperation.GVTurnValve}", !AGVPump.Feedback);
            }
            if (_pumpname == "AGV2")
            {
                InvokeClient.Instance.Service.DoOperation($"{AGV2Pump.UniqueName}.{AITValveOperation.GVTurnValve}", !AGV2Pump.Feedback);
            }
            if (_pumpname == "Both")
            {
                InvokeClient.Instance.Service.DoOperation($"{BothPump1.UniqueName}.{AITValveOperation.GVTurnValve}", !BothPump1.Feedback);
            }

        }



    }
}