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

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.SCCore;
using ExcelLibrary.BinaryFileFormat;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Venus_MainPages.Unity;
using Venus_Themes.CustomControls;

namespace Venus_MainPages.ViewModels
{
    public class SETMOperationViewModel : BindableBase
    {
        #region 私有变量
        private bool m_TMValveN2IsOpen;
        private bool m_TMSoftPumpIsOpen;
        private bool m_TMSoftVentIsOpen;
        private bool m_TMFastPumpIsOpen;
        private bool m_TMFastVentIsOpen;
        private bool m_VCESoftPumpIsOpen;
        private bool m_VCESoftVentIsOpen;
        private bool m_VCEFastPumpIsOpen;
        private bool m_VCEFastVentIsOpen;
        private bool m_PMAIsInstalled;
        private bool m_PMBIsInstalled;
        private bool m_PMCIsInstalled;
        private bool m_VCEIsInstalled;
        private bool m_VCEDoorIsOpen;
        private bool m_PMADoorIsOpen;
        private bool m_PMBDoorIsOpen;
        private bool m_PMCDoorIsOpen;
        private bool m_VCEOutDoorIsOpen;
        private bool m_TMIsVAC;
        private bool m_TMIsATM;
        private bool m_VCEIsVAC;
        private bool m_VCEIsATM;
        private int m_GoToSlotNumber;
        private bool m_TMIsOnline;

        private Dictionary<string, object> m_RtDataValues = new Dictionary<string, object>();

        private List<string> m_RtDataKeys = new List<string>();
        #endregion
        #region 暴露变量
        public bool TMValveN2IsOpen
        {
            get => m_TMValveN2IsOpen;
            set => SetProperty(ref m_TMValveN2IsOpen, value);
        }

        public bool TMSoftPumpIsOpen { get => m_TMSoftPumpIsOpen; set => SetProperty(ref m_TMSoftPumpIsOpen, value); }
        public bool TMSoftVentIsOpen { get => m_TMSoftVentIsOpen; set => SetProperty(ref m_TMSoftVentIsOpen, value); }
        public bool TMFastPumpIsOpen { get => m_TMFastPumpIsOpen; set => SetProperty(ref m_TMFastPumpIsOpen, value); }
        public bool TMFastVentIsOpen { get => m_TMFastVentIsOpen; set => SetProperty(ref m_TMFastVentIsOpen, value); }
        public bool VCESoftPumpIsOpen { get => m_VCESoftPumpIsOpen; set => SetProperty(ref m_VCESoftPumpIsOpen, value); }
        public bool VCESoftVentIsOpen { get => m_VCESoftVentIsOpen; set => SetProperty(ref m_VCESoftVentIsOpen, value); }
        public bool VCEFastPumpIsOpen { get => m_VCEFastPumpIsOpen; set => SetProperty(ref m_VCEFastPumpIsOpen, value); }
        public bool VCEFastVentIsOpen { get => m_VCEFastVentIsOpen; set => SetProperty(ref m_VCEFastVentIsOpen, value); }

        public bool TMIsVAC { get => m_TMIsVAC; set => SetProperty(ref m_TMIsVAC, value); }
        public bool TMIsATM { get => m_TMIsATM; set => SetProperty(ref m_TMIsATM, value); }
        public bool VCEIsVAC { get => m_VCEIsVAC; set => SetProperty(ref m_VCEIsVAC, value); }
        public bool VCEIsATM { get => m_VCEIsATM; set => SetProperty(ref m_VCEIsATM, value); }
        public bool PMAIsInstalled { get => m_PMAIsInstalled; set => SetProperty(ref m_PMAIsInstalled, value); }
        public bool PMBIsInstalled { get => m_PMBIsInstalled; set => SetProperty(ref m_PMBIsInstalled, value); }
        public bool PMCIsInstalled { get => m_PMCIsInstalled; set => SetProperty(ref m_PMCIsInstalled, value); }
        public bool VCEIsInstalled { get => m_VCEIsInstalled; set => SetProperty(ref m_VCEIsInstalled, value); }
        //public bool TMIsOnline { get => m_TMIsOnline; set => SetProperty(ref m_TMIsOnline, value); }


        public int GoToSlotNumber { get => m_GoToSlotNumber; set => SetProperty(ref m_GoToSlotNumber, value); }
        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }

        //public bool TMIsOFFline => !TMIsOnline;

        public bool VCEDoorIsOpen { get => m_VCEDoorIsOpen; set => SetProperty(ref m_VCEDoorIsOpen, value); }
        public bool PMADoorIsOpen { get => m_PMADoorIsOpen; set => SetProperty(ref m_PMADoorIsOpen, value); }
        public bool PMBDoorIsOpen { get => m_PMBDoorIsOpen; set => SetProperty(ref m_PMBDoorIsOpen, value); }
        public bool PMCDoorIsOpen { get => m_PMCDoorIsOpen; set => SetProperty(ref m_PMCDoorIsOpen, value); }
        public bool VCEOutDoorIsOpen { get => m_VCEOutDoorIsOpen; set => SetProperty(ref m_VCEOutDoorIsOpen, value); }

        #endregion

        #region 构造函数
        public SETMOperationViewModel()
        {

            addDataKeys();
            string[] allModules = QueryDataClient.Instance.Service.GetConfig($"System.InstalledModules").ToString().Split(',');
            PMAIsInstalled = allModules.Contains("PMA");
            PMBIsInstalled = allModules.Contains("PMB");
            PMCIsInstalled = allModules.Contains("PMC");
            VCEIsInstalled = allModules.Contains("VCE1");

            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);

            //2023/10/20 朱永吉 郭治川 取消N2 valve 动画保持流的状态
            TMValveN2IsOpen = true;
            TMSoftPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMSoftPumpValve.IsOpen");
            TMSoftVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMSoftVentValve.IsOpen");
            TMFastPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMFastPumpValve.IsOpen");
            TMFastVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMFastVentValve.IsOpen");
            VCESoftPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESoftPumpValve.IsOpen");
            VCESoftVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESoftVentValve.IsOpen");
            VCEFastPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCEFastPumpValve.IsOpen");
            VCEFastVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCEFastVentValve.IsOpen");

            TMIsVAC = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMVACSensor.Value");
            TMIsATM = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMIsATM");
            VCEIsVAC = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCEVACSensor.Value");
            VCEIsATM = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCEIsATM");
            VCEDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESlitDoorClosed");
            PMADoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMASlitDoorClosed");
            PMBDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMBSlitDoorClosed");
            PMCDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMCSlitDoorClosed");

            VCEOutDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "VCE1.VCEOutDoorClosed");

            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(0.5);
            timer.Tick += timer_Tick;
            timer.Start();
        }
        #endregion
        #region 公共方法

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

        private DelegateCommand<object> _ControlSlitDoorCommand;
        public DelegateCommand<object> ControlSlitDoorCommand =>
            _ControlSlitDoorCommand ?? (_ControlSlitDoorCommand = new DelegateCommand<object>(OnControlSlitDoor));
        private DelegateCommand<object> _MapCommand;
        public DelegateCommand<object> MapCommand =>
            _MapCommand ?? (_MapCommand = new DelegateCommand<object>(OnMap));
        private DelegateCommand<object> _GoToLoadCommand;
        public DelegateCommand<object> GoToLoadCommand =>
            _GoToLoadCommand ?? (_GoToLoadCommand = new DelegateCommand<object>(OnGoToLoad));
        private DelegateCommand<object> _GoToSlotCommand;
        public DelegateCommand<object> GoToSlotCommand =>
            _GoToSlotCommand ?? (_GoToSlotCommand = new DelegateCommand<object>(OnGoToSlot));

        private DelegateCommand<object> _OpenDoorCommand;
        public DelegateCommand<object> OpenDoorCommand =>
            _OpenDoorCommand ?? (_OpenDoorCommand = new DelegateCommand<object>(OnOpenDoor));

        private DelegateCommand<object> _CloseDoorCommand;
        public DelegateCommand<object> CloseDoorCommand =>
            _CloseDoorCommand ?? (_CloseDoorCommand = new DelegateCommand<object>(OnCloseDoor));

        private DelegateCommand<object> _HOMECommand;
        public DelegateCommand<object> HOMECommand =>
            _HOMECommand ?? (_HOMECommand = new DelegateCommand<object>(OnHome));

        private DelegateCommand<object> _SETMPumpCommand;
        public DelegateCommand<object> SETMPumpCommand =>
            _SETMPumpCommand ?? (_SETMPumpCommand = new DelegateCommand<object>(OnSetSEPump));

        private DelegateCommand<object> _PumpDown;
        public DelegateCommand<object> PumpDown =>
            _PumpDown ?? (_PumpDown = new DelegateCommand<object>(OnPumpDown));

        private DelegateCommand<object> _Vent;
        public DelegateCommand<object> Vent =>
            _Vent ?? (_Vent = new DelegateCommand<object>(OnVent));

        private DelegateCommand _tmhome;
        public DelegateCommand TmHome =>
            _tmhome ?? (_tmhome = new DelegateCommand(tmhome));

        private DelegateCommand _abort;
        public DelegateCommand Abort =>
            _abort ?? (_abort = new DelegateCommand(abort));

        private DelegateCommand _TMSetOnline;
        public DelegateCommand TMSetOnline =>
            _TMSetOnline ?? (_TMSetOnline = new DelegateCommand(TmSetOnline));

        private DelegateCommand _TMSetOffline;
        public DelegateCommand TMSetOffline =>
            _TMSetOffline ?? (_TMSetOffline = new DelegateCommand(TmSetOffline));


        private DelegateCommand _VCEHome;
        public DelegateCommand VCEHome => _VCEHome ?? (_VCEHome = new DelegateCommand(vceHome));
        private DelegateCommand _VCEClear;
        public DelegateCommand VCEClear => _VCEClear ?? (_VCEClear = new DelegateCommand(vceClear));
        private DelegateCommand _VCEAbort;
        public DelegateCommand VCEAbort => _VCEAbort ?? (_VCEAbort = new DelegateCommand(vceAbort));

        #endregion
        #region 私有方法
        private void addDataKeys()
        {
            //m_RtDataKeys.Add($"SETM.TMValveN2.IsOpen");
            m_RtDataKeys.Add($"SETM.TMSoftPumpValve.IsOpen");
            m_RtDataKeys.Add($"SETM.TMSoftVentValve.IsOpen");
            m_RtDataKeys.Add($"SETM.TMFastPumpValve.IsOpen");
            m_RtDataKeys.Add($"SETM.TMFastVentValve.IsOpen");
            m_RtDataKeys.Add($"SETM.VCESoftPumpValve.IsOpen");
            m_RtDataKeys.Add($"SETM.VCESoftVentValve.IsOpen");
            m_RtDataKeys.Add($"SETM.VCEFastPumpValve.IsOpen");
            m_RtDataKeys.Add($"SETM.VCEFastVentValve.IsOpen");
            m_RtDataKeys.Add($"SETM.VCESlitDoorClosed");
            m_RtDataKeys.Add($"SETM.PMASlitDoorClosed");
            m_RtDataKeys.Add($"SETM.PMBSlitDoorClosed");
            m_RtDataKeys.Add($"SETM.PMCSlitDoorClosed");
            m_RtDataKeys.Add($"SETM.TMVACSensor.Value");
            m_RtDataKeys.Add($"SETM.VCEVACSensor.Value");

            m_RtDataKeys.Add($"SETM.TMIsATM");
            m_RtDataKeys.Add($"SETM.VCEIsATM");
            m_RtDataKeys.Add($"SETM.IsOnline");
            m_RtDataKeys.Add($"SETM.IsOffline");

            m_RtDataKeys.Add($"SETM.PumpIsRunning");
            //m_RtDataKeys.Add($"SETM.VCEPipelinePressure.Value");
            m_RtDataKeys.Add($"SETM.TMPipelinePressure.Value");
            m_RtDataKeys.Add($"SETM.TMPressure.Value");
            m_RtDataKeys.Add($"SETM.VCEPressure.Value");
            m_RtDataKeys.Add($"VCE1.VCEOutDoorClosed");
            m_RtDataKeys.Add($"SETM.TM_MFC1.FeedBack");
            m_RtDataKeys.Add($"SETM.TM_MFC1.SetPoint");
           
        }
        private void timer_Tick(object sender, EventArgs e)
        {
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);

            //TMValveN2IsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMValveN2.IsOpen");
            TMSoftPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMSoftPumpValve.IsOpen");
            TMSoftVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMSoftVentValve.IsOpen");
            TMFastPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMFastPumpValve.IsOpen");
            TMFastVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMFastVentValve.IsOpen");
            VCESoftPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESoftPumpValve.IsOpen");
            VCESoftVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESoftVentValve.IsOpen");
            VCEFastPumpIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCEFastPumpValve.IsOpen");
            VCEFastVentIsOpen = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCEFastVentValve.IsOpen");
            VCEDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCESlitDoorClosed");
            PMADoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMASlitDoorClosed");
            PMBDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMBSlitDoorClosed");
            PMCDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMCSlitDoorClosed");
            VCEOutDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "VCE1.VCEOutDoorClosed");

            TMIsVAC = (CommonFunction.GetValue<int>(RtDataValues, "SETM.TMPressure.Value") < Convert.ToInt32(QueryDataClient.Instance.Service.GetConfig($"SETM.VACTargetPressure"))) ;
            TMIsATM =  CommonFunction.GetValue<bool>(RtDataValues, "SETM.TMIsATM");
            VCEIsVAC = (CommonFunction.GetValue<int>(RtDataValues, "SETM.VCEPressure.Value") < Convert.ToInt32(QueryDataClient.Instance.Service.GetConfig($"VCE1.VACTargetPressure")));
            VCEIsATM = CommonFunction.GetValue<bool>(RtDataValues, "SETM.VCEIsATM");
            //TMIsOnline = CommonFunction.GetValue<bool>(RtDataValues, "SETM.IsOnline");
        }

        private void TmSetOnline()
        {
            InvokeClient.Instance.Service.DoOperation("SETM.SetOnline");
        }

        private void TmSetOffline()
        {
            InvokeClient.Instance.Service.DoOperation("SETM.SetOffline");
        }

        private void vceHome()
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.HOME");
        }

        private void vceClear()
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.ClearError");
        }

        private void vceAbort()
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.Abort");
        }
        private void tmhome()
        {
            InvokeClient.Instance.Service.DoOperation("SETM.Home");
        }
        private void abort()
        {
            InvokeClient.Instance.Service.DoOperation("SETM.Abort");
        }
        private void OnVent(object obj)
        {
            switch (obj.ToString())
            {
                case "VCE1":
                    InvokeClient.Instance.Service.DoOperation("VCE1.Vent");
                    break;
                case "SETM":
                    InvokeClient.Instance.Service.DoOperation("SETM.Vent");
                    break;
            }

        }

        private void OnPumpDown(object obj)
        {
            switch(obj.ToString())
            {
                case "VCE1":
                    InvokeClient.Instance.Service.DoOperation("VCE1.PumpDown");
                    break;
                case "SETM":
                    InvokeClient.Instance.Service.DoOperation("SETM.PumpDown");
                    break;
            }
        }
        private void OnSetSEPump(object obj)
        {
            bool.TryParse(obj.ToString(), out bool Open);
            InvokeClient.Instance.Service.DoOperation("SETM.ControlPump", Open);
        }
        private void OnHome(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.HOME");
        }
        private void OnOpenDoor(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.DoorOpen");
        }
        private void OnCloseDoor(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.DoorClose");
        }
        private void OnMap(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.Map");
        }
        private void OnGoToLoad(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.GotoLP");
        }
        private void OnGoToSlot(object obj)
        {
            InvokeClient.Instance.Service.DoOperation("VCE1.Goto", GoToSlotNumber);
        }
        private void OnControlValve(object obj)
        {
            CommonValveControl commonValveControl = (CommonValveControl)obj;
            if (commonValveControl.IsCanEdit == true)
            {
                InvokeClient.Instance.Service.DoOperation($"SETM.{commonValveControl.Tag}Valve.{AITValveOperation.GVTurnValve}", !commonValveControl.Status);
            }
        }

        private void OnControlSlitDoor(object obj)
        {
            string Module = obj.ToString().Split(',')[0];
            bool.TryParse(obj.ToString().Split(',')[1],out bool Open);
            InvokeClient.Instance.Service.DoOperation($"SETM.SetSlitDoor", Module, Open);
        }

        #endregion
    }
}