FurnaceELK/Furnace/FurnaceUI/Views/Maintenances/BufferRobotViewModel.cs

using Aitex.Core.Util;
using Caliburn.Micro.Core;
using Caliburn.Micro;
using FurnaceUI.Models;
using FurnaceUI.Views.Operations;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.OperationCenter;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Controls;
using OpenSEMI.ClientBase;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using System.Collections.ObjectModel;
using System.Windows;
using MECF.Framework.Common.CommonData;


namespace FurnaceUI.Views.Maintenances
{
    public class BufferRobotViewModel : FurnaceUIViewModelBase
    {
        #region Buffer Data
        [Subscription("PM1.BufferServo.CurrentPosition")]
        public float BufferCurrentPosition { get; set; }
        [Subscription("PM1.BufferServo.CurrentSpeed")]
        public float BufferCurrentSpeed { get; set; }
        [Subscription("PM1.BufferServo.IsServoOn")]
        public bool BufferIsServoOn { get; set; }
        [Subscription("PM1.BufferServo.IsReady")]
        public bool BufferIsReady { get; set; }
        [Subscription("PM1.BufferServo.Status")]
        public string BufferStatus { get; set; }
        [Subscription("PM1.BufferServo.IsMotorRun")]
        public bool BufferIsMotorRun { get; set; }
        #endregion
        [Subscription("Rt.Status")]
        public string RtStatus { get; set; }
        public bool IsSystemStaus => (RtStatus != "AutoRunning");
        //public bool IsPermission { get => this.Permission >= 3 && ClientApp.Instance.UserContext.RoleName == "Service"; }
        public bool IsPermission { get => this.Permission >= 3; }
        private List<string> _targetPosition = new List<string>();
        public List<string> TargetPosition
        {
            get => _targetPosition;
            set 
            { 
                _targetPosition = value; 
                NotifyOfPropertyChange(nameof(TargetPosition)); 
            }
        }

        public double BufferAxisMoveSpeed { get; set; }
        public double BufferAxisLimitSpeed { get; set; }
        private string _selectedTargetPosition;
        public string SelectedTargetPosition
        {
            get => _selectedTargetPosition;
            set
            {
                _selectedTargetPosition = value;
                NotifyOfPropertyChange(nameof(SelectedTargetPosition));
            }
        }
        public ObservableCollection<PurgeParameter> PurgeParameters { get; set; }
        private Visibility _purgeVisibilty;

        public Visibility PurgeVisibilty
        {
            get { return _purgeVisibilty; }
            set 
            { 
                _purgeVisibilty = value;
                NotifyOfPropertyChange(nameof(PurgeVisibilty));
            }
        }

        private BufferRobotView _view;
        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            _view = view as BufferRobotView;
            
            BufferAxisLimitSpeed = (double)QueryDataClient.Instance.Service.GetConfig($"BufferServo.BufferAxisLimitSpeed");
           
        }
        protected override void OnActivate()
        {
            #region BufferPurge
            var isEnable = (bool)QueryDataClient.Instance.Service.GetConfig("BufferPurge.IsEnable");
            PurgeVisibilty = isEnable ? Visibility.Visible : Visibility.Collapsed;
            if (isEnable)
            {
                List<string> keys = new List<string> { "BufferPurge.NameList", "BufferPurge.Operation", "BufferPurge.FinishCondition", "BufferPurge.OperationOrder" };
                var dic = QueryDataClient.Instance.Service.PollConfig(keys);
                string[] names = $"{dic["BufferPurge.NameList"]}".Split(';');
                string[] operation = $"{dic["BufferPurge.Operation"]}".Split(';');
                string[] sequence = $"{dic["BufferPurge.OperationOrder"]}".Split(';');
                PurgeParameters = new ObservableCollection<PurgeParameter>();
                foreach (string p in sequence)
                {
                    if (string.IsNullOrWhiteSpace(p)) continue;//Purge1,0,Time(10),Open;
                    var step = p.Trim().Split(',');
                    if (step.Length == 4)
                    {
                        if (string.IsNullOrEmpty(step[0])) continue;//name
                        if (names.Contains(step[0]))
                        {
                            var index = step[2].IndexOf('(') + 1;
                            int.TryParse(step[2].Substring(index, step[2].Length - index - 1), out int time);//仅考虑时间
                            PurgeParameters.Add(
                            new PurgeParameter() { Name = step[0], TimeString = $"{time / 3600:00}:{time % 3600 / 60:00}:{time % 60:00}", IsClose = step[3].ToLower() == "close", IsOpen = step[3].ToLower() == "open" });
                        }
                    }
                }
            }
            #endregion
            base.OnActivate();
        }
        private void InitData()
        {
            BufferAxisMoveSpeed = (double)QueryDataClient.Instance.Service.GetConfig($"BufferServo.MoveSpeed");
        }
        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            InitData();
            if (_view != null)
            {
                var rsetValueBool = double.TryParse(_view?.tbMoveSpeed.Text, out double setZValue);
                if (!rsetValueBool)
                    _view.tbMoveSpeed.Text = "0";


                if (!string.IsNullOrEmpty(_view?.tbMoveSpeed.Text) && rsetValueBool && setZValue > BufferAxisLimitSpeed)
                {
                    _view.tbMoveSpeed.Text = "0";
                    DialogBox.ShowWarning($"Max Move Speed is {BufferAxisLimitSpeed}");
                }
             
            }
        }

        private Dictionary<string, string> _targetPositionDic = new Dictionary<string, string>()
        {
            { "1-A", "1" },
            { "1-B", "2" },
            { "1-C", "3" },
            { "1-D", "4" },
            { "2-A", "5" },
            { "2-B", "6" },
            { "2-C", "7" },
            { "2-D", "8" },
            { "3-A", "9" },
            { "3-B", "10" },
            { "3-C", "11" },
            { "3-D", "12" },
            { "4-A", "13" },
            { "4-B", "14" },
            { "4-C", "15" },
            { "4-D", "16" },
        };

        public BufferRobotViewModel()
        {
            foreach(var target in _targetPositionDic.Keys)
            {
                _targetPosition.Add(target);
            }
        }

        public void SetValue()
        {
            if (string.IsNullOrEmpty(SelectedTargetPosition))
                return;

            if (!DialogBox.Confirm($"Are you sure  want to buffer Set {SelectedTargetPosition}?"))
                return;

            var target = _targetPositionDic.ContainsKey(SelectedTargetPosition) ? _targetPositionDic[SelectedTargetPosition] : SelectedTargetPosition;
            InvokeClient.Instance.Service.DoOperation($"PM1.BufferServo.ServoTargetPosition", target);
        }

        public void MoveTo()
        {
            if (!DialogBox.Confirm($"Are you sure  want to move?"))
                return;

            InvokeClient.Instance.Service.DoOperation($"PM1.BufferServo.ServoMoveTo", "");
        }

        public void SetServoOn(object target, object isOn)
        {
            var str = bool.Parse(isOn.ToString()) ? "On" : "Off";
            if (!DialogBox.Confirm($"Are you sure  want to buffer  Servo {str}?"))
                return;

            InvokeClient.Instance.Service.DoOperation($"{target}", $"{isOn}");
        }
        public void BufferSaveValue(object obj, object tb)
        {
            if (!DialogBox.Confirm($"Are you sure  want to SaveValue?"))
                return;


            switch (obj)
            {
             
                case "MoveSpeed":
                    var setValue = double.Parse((tb as TextBox)?.Text);
                    if (setValue > BufferAxisLimitSpeed)
                    {
                        DialogBox.ShowWarning($"Max MoveSpeed is {BufferAxisLimitSpeed}");
                        break;
                    }
                    InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"BufferServo.{obj}", (tb as TextBox)?.Text);
                    break;
            }

        }
        public void Stop(object target)
        {
            if (!DialogBox.Confirm($"Are you sure  want to Stop?"))
                return;

            InvokeClient.Instance.Service.DoOperation($"{target}.ServoStop");
        }
        public void Reset(object target)
        {
            if (!DialogBox.Confirm($"Are you sure  want to Reset?"))
                return;

            InvokeClient.Instance.Service.DoOperation($"{target}.ServoResetAlarm");
        }

        public void TimeEdit(PurgeParameter purge)
        {
            RecipeStepTimeViewModel recipeStepTimeViewModel = new RecipeStepTimeViewModel("ControlTime");
            recipeStepTimeViewModel.SelectTime =purge.TimeString;
            recipeStepTimeViewModel.SelectValueTime = purge.TimeString;
            (IoC.Get<IWindowManager>() as WindowManager)?.ShowDialogWithTitle(recipeStepTimeViewModel, null, "Control Time Set");
            if (recipeStepTimeViewModel.IsSave)
            {
                purge.TimeString = recipeStepTimeViewModel.SelectValueTime;
            }
        }
        public void SetBufferPurge()
        {
            if (PurgeParameters?.Count > 0&&PurgeParameters.Any(r=>r.IsClose||r.IsOpen))
            {
                if(DialogBox.Confirm("Do you want to operating BufferPurge?"))
                {
                    InvokeClient.Instance.Service.DoOperation("PM1.SetBufferPurge", PurgeParameters.ToList());      
                }
            }
            else
            {
                DialogBox.ShowWarning("No Parameter to Set!");
            }
        }
    }
}