CyberX8/CyberX8_MainPages/ViewModels/LoaderCycleViewModel.cs

using Aitex.Core.Common;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Util;
using Aitex.Core.Utilities;
using LiveCharts;
using MECF.Framework.Common.Beckhoff.AxisProvider;
using MECF.Framework.Common.Beckhoff.Station;
using MECF.Framework.Common.CommonData.PUF;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Utilities;
using CyberX8_MainPages.Unity;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using System.Windows.Input;
using System.Windows.Threading;

namespace CyberX8_MainPages.ViewModels
{
    public class LoaderCycleViewModel : BindableBase
    {

        #region 常量 

        #endregion

        #region 内部变量
        /// <summary>
        /// 模块名称
        /// </summary>
        private string _module = "";
        /// <summary>
        /// 定时器
        /// </summary>
        private DispatcherTimer _timer;
        /// <summary>
        /// RT查询key集合
        /// </summary>
        private List<string> _rtDataKeys = new List<string>();
        /// <summary>
        /// rt查询key数值字典
        /// </summary>
        private Dictionary<string, object> _rtDataValueDic = new Dictionary<string, object>();
        /// <summary>
        /// A面循环次数
        /// </summary>
        private string _sideACurrentCycle;
        /// <summary>
        /// A面当前状态
        /// </summary>
        private string _sideAState;
        /// <summary>
        /// A面总共循环次数
        /// </summary>
        private int _sideATotalCycle;
        /// <summary>
        /// A面当前步骤
        /// </summary>
        private string _sideACurrentStep;
        /// <summary>
        /// A面忽略LeakTest
        /// </summary>
        private bool _sideAIgnoreLeakTest;
        /// <summary>
        /// B面循环次数
        /// </summary>
        private string _sideBCurrentCycle;
        /// <summary>
        /// B面当前状态
        /// </summary>
        private string _sideBState;
        /// <summary>
        /// B面总共循环次数
        /// </summary>
        private int _sideBTotalCycle;
        /// <summary>
        /// B面当前步聚
        /// </summary>
        private string _sideBCurrentStep;
        /// <summary>
        /// B面忽略LeakTest
        /// </summary>
        private bool _sideBIgnoreLeakTest;
        #endregion

        #region 属性
        /// <summary>
        /// 模块名称
        /// </summary>
        public string Module
        {
            get { return _module; }
            set { SetProperty(ref _module, value); }
        }
        /// <summary>
        /// A面当前循环次数
        /// </summary>
        public string SideACurrentCycle
        {
            get { return _sideACurrentCycle; }
            set { SetProperty(ref _sideACurrentCycle, value);}
        }
        /// <summary>
        /// A面当前状态
        /// </summary>
        public string SideAState
        {
            get { return _sideAState; }
            set { SetProperty(ref _sideAState, value); }
        }
        /// <summary>
        /// A面总共循环次数
        /// </summary>
        public int SideATotalCycle
        {
            get { return _sideATotalCycle; }
            set { SetProperty(ref _sideATotalCycle, value); }
        }
        /// <summary>
        /// A面当前步骤
        /// </summary>
        public string SideACurrentStep
        {
            get { return _sideACurrentStep; }
            set { SetProperty(ref _sideACurrentStep, value); }
        }

        /// <summary>
        /// A面忽略LeakTest
        /// </summary>
        public bool SideAIgnoreLeakTest
        {
            get { return _sideAIgnoreLeakTest; }
            set { SetProperty(ref _sideAIgnoreLeakTest, value); }
        }
        /// <summary>
        /// B面当前循环次数
        /// </summary>
        public string SideBCurrentCycle
        {
            get { return _sideBCurrentCycle; }
            set { SetProperty(ref _sideBCurrentCycle, value); }
        }
        /// <summary>
        /// B面当前状态
        /// </summary>
        public string SideBState
        {
            get { return _sideBState; }
            set { SetProperty(ref _sideBState, value); }
        }
        /// <summary>
        /// B面总共循环次数
        /// </summary>
        public int SideBTotalCycle
        {
            get { return _sideBTotalCycle; }
            set { SetProperty(ref _sideBTotalCycle, value); }
        }
        /// <summary>
        /// B面当前步骤
        /// </summary>
        public string SideBCurrentStep
        {
            get { return _sideBCurrentStep; }
            set { SetProperty(ref _sideBCurrentStep, value); }
        }
        /// <summary>
        /// B面忽略LeakTest
        /// </summary>
        public bool SideBIgnoreLeakTest
        {
            get { return _sideBIgnoreLeakTest; }
            set { SetProperty(ref _sideBIgnoreLeakTest, value);}
        }
        #endregion

        #region 指令 
        /// <summary>
        /// A面启动循环Command
        /// </summary>
        public ICommand SideAStartCycleCommand { get;private set; }
        /// <summary>
        /// A面启动循环Command
        /// </summary>
        public ICommand SideAStopCycleCommand { get; private set; }
        /// <summary>
        /// B面启动循环Command
        /// </summary>
        public ICommand SideBStartCycleCommand { get; private set; }
        /// <summary>
        /// B面启动循环Command
        /// </summary>
        public ICommand SideBStopCycleCommand { get; private set; }
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public LoaderCycleViewModel()
        {
            SideAStartCycleCommand = new DelegateCommand<object>(SideAStartCycleAction);
            SideAStopCycleCommand = new DelegateCommand<object>(SideAStopCycleAction);
            SideBStartCycleCommand = new DelegateCommand<object>(SideBStartCycleAction);
            SideBStopCycleCommand = new DelegateCommand<object>(SideBStopCycleAction);
        }
        /// <summary>
        /// 加载数据
        /// </summary>
        public void LoadData(string systemName)
        {
            Module = systemName;
            if (_timer == null)
            {
                _timer = new DispatcherTimer();
                _timer.Interval = TimeSpan.FromMilliseconds(100);
                _timer.Tick += Timer_Tick; ;
            }
            _rtDataKeys.Add($"{Module}.SideA.CurrentCycle");
            _rtDataKeys.Add($"{Module}.SideA.CurrentCycleStep");
            _rtDataKeys.Add($"{Module}.SideB.CurrentCycle");
            _rtDataKeys.Add($"{Module}.SideB.CurrentCycleStep");
            _timer.Start();
        }
        /// <summary>
        /// 定时器执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Tick(object sender, EventArgs e)
        {
            if (_rtDataKeys.Count != 0)
            {
                _rtDataValueDic = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                if (_rtDataValueDic != null)
                {
                    SideACurrentCycle = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.SideA.CurrentCycle");
                    SideBCurrentCycle = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.SideB.CurrentCycle");
                    SideACurrentStep = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.SideA.CurrentCycleStep");
                    SideBCurrentStep = CommonFunction.GetValue<string>(_rtDataValueDic, $"{Module}.SideB.CurrentCycleStep");
                }
            }
        }

        /// <summary>
        /// 隐藏
        /// </summary>
        public void Hide()
        {
            if (_timer != null)
            {
                _timer.Stop();
            }
        }

        #region Action
        private void SideAStartCycleAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{Module}.SideA.StartCycle",SideATotalCycle, SideAIgnoreLeakTest);
        }
        private void SideAStopCycleAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{Module}.SideA.StopCycle");
        }
        private void SideBStartCycleAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{Module}.SideB.StartCycle",SideBTotalCycle, SideBIgnoreLeakTest);
        }
        private void SideBStopCycleAction(object param)
        {
            InvokeClient.Instance.Service.DoOperation($"{Module}.SideB.StopCycle");
        }

        #endregion
    }
}