FurnaceELK/Furnace/FurnaceUI/Views/Operations/Maintenances/N2PurgeStatusViewModel.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 MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using Caliburn.Micro;
using FurnaceUI.Client.Dialog;
using FurnaceUI.Models;
using MECF.Framework.UI.Core.ExtendedControls;

namespace FurnaceUI.Views.Operations.Maintenances
{
    public class N2PurgeStatusViewModel : FurnaceModuleUIViewModelBase
    {

        public SelectSequenceViewModel _selectSequence;
        public bool IsOutLineDetail { get; set; }
        public bool IsPMCDetail { get; set; }
        public bool IsRoBoDetail { get; set; }
        public ICommand CmdSetMfcFlow { get; set; }
        public ICommand CmdSetMfmFlow { get; set; }
        //public bool _ismanagerPermission = true;
        //public bool IsManagerPermission
        //{
        //    get
        //    {
        //        return _ismanagerPermission;
        //    }
        //    set
        //    {
        //        _ismanagerPermission = value;
        //        NotifyOfPropertyChange("IsManagerPermission");
        //    }
        //}
        public bool IsManagerPermission { get => this.Permission == 3 && SelectedGasStateType== GasPanelStateType.Manual; }
        public string SequenceSelected { get; set; }

        private bool _isRecipeEdit = false;

        private string _N2PurgeModeDisplay;
        public string N2PurgeModeDisplay { get => _N2PurgeModeDisplay; set => SetField(ref _N2PurgeModeDisplay, value, nameof(N2PurgeModeDisplay)); }

        [Subscription("PM1.N2PurgeMode")]
        public string N2PurgeMode { get; set; }
        [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; }

        #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.ValveAV52.DeviceData")]
        public AITValveData ValveAV52 { get; set; }
        [Subscription("PM1.ValveAV54.DeviceData")]
        public AITValveData ValveAV54 { 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.ValveFIMS1N2Purge.DeviceData")]
        public AITValveData ValveAV63 { get; set; }
        [Subscription("PM1.ValveFIMS2N2Purge.DeviceData")]
        public AITValveData ValveAV64 { get; set; }
        [Subscription("PM1.ValveAV65.DeviceData")]
        public AITValveData ValveAV65 { get; set; }
        [Subscription("PM1.ValveAV66.DeviceData")]
        public AITValveData ValveAV66 { get; set; }
        [Subscription("PM1.ValveAV68.DeviceData")]
        public AITValveData ValveAV68 { 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,
                    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.ValveAV77.DeviceData")]
        public AITValveData ValveAV77 { 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.ValveAV91.DeviceData")]
        public AITValveData ValveAV91 { get; set; }
        #endregion

        #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.MFC51.DeviceData")]
        public AITMfcData MFC51Data { get; set; }

        [Subscription("PM1.ConcentrationO2.Value")]
        public double ConcentrationO2Value { get; set; }

        #endregion

        [Subscription("PM1.MFM57.DeviceData")]
        public AITWaterFlowMeterData MFM57Flow { 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.Manual;

        public GasPanelStateType SelectedGasStateType
        {
            get
            {
                return _selectedGasStateType;
            }
            set
            {
                if (_selectedGasStateType != value)
                {
                    _selectedGasStateType = value;
                    NotifyOfPropertyChange("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,
                };
            }
        }
        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,
                };
            }
        }
        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,
                };
            }
        }

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

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

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

        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,
                };
            }
        }
        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,
                };
            }
        }
        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,
                };
            }
        }
        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,
                };
            }
        }
        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,
                };
            }
        }
        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,
                };
            }
        }
        public AnalogDeviceDataItem MFC51
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFC",
                    DeviceName = MFC51Data.UniqueName,
                    DeviceId = MFC51Data.DeviceSchematicId,
                    DisplayName = MFC51Data.DisplayName,
                    Scale = MFC51Data.Scale,
                    Unit = MFC51Data.Unit,
                    FeedBack = MFC51Data.FeedBack,
                    SetPoint = MFC51Data.SetPoint,
                };
            }
        }

        public AnalogDeviceDataItem MFM57
        {
            get
            {
                return new AnalogDeviceDataItem
                {
                    Type = "MFM",
                    DeviceId = MFM57Flow.DeviceSchematicId,
                    DisplayName = MFM57Flow.DisplayName,
                    DeviceName = MFM57Flow.UniqueName,
                    Scale = MFM57Flow.Scale,
                    Unit = MFM57Flow.Unit,
                    FeedBack = MFM57Flow.FeedBack,
                    SetPoint = MFM57Flow.SetPoint,
                };
            }
        }

        public string IsRfPowerOn
        {
            get
            {
                return IsPowerOn ? "On" : "Off";
            }
        }


        private bool _manualCheck;
        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 EnableServiceControl { get; set; } = true;

        private bool _enablePLCPointControl = true;

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


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

        protected override void OnActivate()
        {
            base.OnActivate();
            _selectSequence = new SelectSequenceViewModel();
            IsOutLineDetail = true;
            IsPMCDetail = false;
            IsRoBoDetail = false;

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

        }

        public void SetEditClick()
        {
            EnableServiceControl = true;

        }

        protected override void OnDeactivate(bool close)
        {
            base.OnDeactivate(close);
            //IsManagerPermission = false;
        }
        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($"{args[0]}.{args[1]}", args[2]);
            }
        }

        public void SetValveCommand(object param)
        {
            object[] args = (object[])param;
            if (args.Length == 3)
            {
                InvokeClient.Instance.Service.DoOperation($"{args[0]}.{args[1]}", args[2]);
            }
        }

        public void SwitchDetail(string detail)
        {

            switch (detail)
            {
                case "OutLine":
                    IsOutLineDetail = true;
                    IsPMCDetail = false;
                    IsRoBoDetail = false;
                    break;

                case "PMCDetail":
                    IsOutLineDetail = false;
                    IsPMCDetail = true;
                    IsRoBoDetail = false;
                    break;

                case "RoBoDetail":
                    IsOutLineDetail = false;
                    IsPMCDetail = false;
                    IsRoBoDetail = true;
                    break;

            }
        }

        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)
                            {
                                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)
                            {
                                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);
                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 System.Action(() =>
                {
                    if (result.Count != 0)
                    {
                        InvokePropertyChanged();
                    }
                    InvokeAfterUpdateProperty(result);
                }));


            }
        }

        protected override void InvokeBeforeUpdateProperty(Dictionary<string, object> data)
        {
            //List<string> aITValveDataKeys = new List<string>();
            //List<string> aITSensorDataKeys = new List<string>();
            //List<string> aITMfcDataKeys = new List<string>();
            //foreach (var item in data.Keys)
            //{
            //    try
            //    {
            //        if (data[item].GetType() == typeof(AITValveData))
            //        {
            //            var array = item.Split('.');
            //            if (array.Length > 1)
            //            {
            //                var name = array[1];
            //                var property = this.GetType().GetProperties().Where(x => x.Name == name).FirstOrDefault();
            //                object value = property.GetValue(this, null);
            //                if (value != null && ((AITValveData)value).Equals((AITValveData)data[item]))
            //                    aITValveDataKeys.Add(item);
            //            }
            //        }
            //        else if (data[item].GetType() == typeof(AITSensorData))
            //        {
            //            var array = item.Split('.');
            //            if (array.Length > 1)
            //            {
            //                var name = array[1];
            //                var property = this.GetType().GetProperties().Where(x => x.Name == name).FirstOrDefault();
            //                object value = property.GetValue(this, null);
            //                if (value != null && ((AITSensorData)value).Equals((AITSensorData)data[item]))
            //                    aITSensorDataKeys.Add(item);
            //            }
            //        }
            //        else if (data[item].GetType() == typeof(AITMfcData))
            //        {
            //            var array = item.Split('.');
            //            if (array.Length > 1)
            //            {
            //                var name = array[1];
            //                var property = this.GetType().GetProperties().Where(x => x.Name == $"{name}Data").FirstOrDefault();
            //                object value = property.GetValue(this, null);
            //                if (value != null && ((AITMfcData)value).Equals((AITMfcData)data[item]))
            //                    aITMfcDataKeys.Add(item);
            //            }
            //        }
            //    }
            //    catch (Exception ex)
            //    {
            //        Console.WriteLine(ex.Message);
            //    }
            //}
            //if (aITValveDataKeys.Count > 0)
            //{
            //    foreach (var item in aITValveDataKeys)
            //    {
            //        data.Remove(item);
            //    }
            //}
            //if (aITSensorDataKeys.Count > 0)
            //{
            //    foreach (var item in aITSensorDataKeys)
            //    {
            //        data.Remove(item);
            //    }
            //}
            //if (aITMfcDataKeys.Count > 0)
            //{
            //    foreach (var item in aITMfcDataKeys)
            //    {
            //        data.Remove(item);
            //    }
            //}
            base.InvokeBeforeUpdateProperty(data);
        }

        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);

            if (N2PurgeMode == "ManualMode")
            {
                SelectedGasStateType = GasPanelStateType.Manual;
            }
            else
            {
                SelectedGasStateType = GasPanelStateType.Monitor;
            }
        }

        public void SequenceSelect()
        {
            WindowManager wm = new WindowManager();
            bool? bret = wm.ShowDialogWithTitle(_selectSequence, null, "Sequence Select");
            if (bret.Value)
            {
                if (_selectSequence.DialogResultString != null || _selectSequence.DialogResultString != "")
                {
                    SequenceSelected = _selectSequence.DialogResultView;
                    N2PurgeModeDisplay = SequenceSelected;

                }

            }
        }
    }
}