Display_D_HP/TeamAAS-VM/ViewModels/DebugMod/RobotManualStepViewModel.cs

using Prism.Commands;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Security.Cryptography;
using System.Windows;
using Team.FFFeederService;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP.Core;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;
using TeamAAS_VP.Services;

namespace TeamAAS_VP.ViewModels.DebugMod
{
    public class RobotManualStepViewModel : BindableBase, IConfirmNavigationRequest
    {
        IContainerProvider _container;
        IEventAggregator _eventAggregator;
        IRobotService _robotService;
        ISystemDatabaseService _systemDatabaseService;
        IConfigService _configService;

        #region 属性

        public Management management { get; set; }

        private IRobot _Robot;

        public IRobot Robot
        {
            get { return _Robot; }
            set
            {
                SetProperty(ref _Robot, value);
                try
                {
                    if (value != null)
                    {
                        this.Distance = _configService.GetRobotStepDistance(value.Id);
                    }
                }
                catch (Exception)
                {

                }
            }
        }

        private double _Distance = 1;

        public double Distance
        {
            get { return _Distance; }
            set
            {
                SetProperty(ref _Distance, value);
                try
                {
                    if (Robot == null)
                    {
                        return;
                    }
                    _configService.UpdateRobotStepDistance(Robot.Id, value);
                }
                catch (Exception)
                {

                }
            }
        }

        private bool CanExecute
        {
            get
            {
                if (Robot==null)
                    return false;
                else return Robot.CanExecute;
            }
        }
        #endregion

        #region 命令
        private DelegateCommand _LoadedCommand;
        public DelegateCommand LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand(ExecuteLoadedCommand));

        private DelegateCommand _ConnectCommand;
        public DelegateCommand ConnectCommand =>
            _ConnectCommand ?? (_ConnectCommand = new DelegateCommand(ExecuteConnectCommand));

        

        private DelegateCommand _DisConnectCommand;
        public DelegateCommand DisConnectCommand =>
            _DisConnectCommand ?? (_DisConnectCommand = new DelegateCommand(ExecuteDisConnectCommand));

        

        private DelegateCommand<string> _MotorCommand;
        public DelegateCommand<string> MotorCommand =>
            _MotorCommand ?? (_MotorCommand = new DelegateCommand<string>(ExecuteMotorCommand).ObservesCanExecute(()=> CanExecute).ObservesProperty(()=> Robot).ObservesProperty(()=> Robot.CanExecute));

        private DelegateCommand _ResetCommand;
        public DelegateCommand ResetCommand =>
            _ResetCommand ?? (_ResetCommand = new DelegateCommand(ExecuteResetCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand<object> _JogCommand;
        public DelegateCommand<object> JogCommand =>
            _JogCommand ?? (_JogCommand = new DelegateCommand<object>(ExecuteJogCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand _sFreeCommand;
        public DelegateCommand sFreeCommand =>
            _sFreeCommand ?? (_sFreeCommand = new DelegateCommand(ExecutesFreeCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        private DelegateCommand _SLockCommand;
        public DelegateCommand SLockCommand =>
            _SLockCommand ?? (_SLockCommand = new DelegateCommand(ExecuteSLockCommand).ObservesCanExecute(() => CanExecute).ObservesProperty(() => Robot).ObservesProperty(() => Robot.CanExecute));

        
        #endregion

        #region 事件

        #endregion

        public RobotManualStepViewModel(IContainerProvider container, IEventAggregator ea, IRobotService robotService, ISystemDatabaseService systemDatabaseService, IConfigService configService)
        {
            _container = container;
            _eventAggregator = ea;
            _robotService = robotService;
            _systemDatabaseService = systemDatabaseService;
            _configService = configService;
            //订阅权限登录事件
            _eventAggregator.GetEvent<UserLoginNotification>().Subscribe(LoginChange);
        }

        #region 方法
        void ExecuteLoadedCommand()
        {
            if (_systemDatabaseService.GetCurrentUser().userPart == Enums.UserPart.Operator)
            {
                IsAllowEdit = false;
            }
            else
            {
                IsAllowEdit = true;
            }
        }

        /// <summary>
        /// 连接机器人
        /// </summary>
        private async void ExecuteConnectCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                await Robot.ConnectAsync();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.连接成功}!", Duration = 1 });
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 断开机器人
        /// </summary>
        private void ExecuteDisConnectCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                Robot.Disconnect();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.已断开}!", Duration = 1 });
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 电机
        /// </summary>
        /// <param name="obj"></param>
        private async void ExecuteMotorCommand(string obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                
                await Robot.MotorAsync(Convert.ToBoolean(obj));
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.成功}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 重置
        /// </summary>
        private async void ExecuteResetCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {

                await Robot.ResetAsync();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.成功}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 点动
        /// </summary>
        /// <param name="obj"></param>
        private async void ExecuteJogCommand(object obj)
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {
                Robot.Timeout = 6000000;
                var items = ((string)obj).Split(':');
                switch (items[0])
                {
                    case "X+":
                        await Robot.JogAsync("X", double.Parse(items[1]));
                        break;
                    case "X-":
                        await Robot.JogAsync("X", -double.Parse(items[1]));
                        break;
                    case "Y+":
                        await Robot.JogAsync("Y", double.Parse(items[1]));
                        break;
                    case "Y-":
                        await Robot.JogAsync("Y", -double.Parse(items[1]));
                        break;
                    case "Z+":
                        await Robot.JogAsync("Z", double.Parse(items[1]));
                        break;
                    case "Z-":
                        await Robot.JogAsync("Z", -double.Parse(items[1]));
                        break;
                    case "U+":
                        await Robot.JogAsync("U", double.Parse(items[1]));
                        break;
                    case "U-":
                        await Robot.JogAsync("U", -double.Parse(items[1]));
                        break;
                    case "V+":
                        await Robot.JogAsync("V", double.Parse(items[1]));
                        break;
                    case "V-":
                        await Robot.JogAsync("V", -double.Parse(items[1]));
                        break;
                    case "W+":
                        await Robot.JogAsync("W", double.Parse(items[1]));
                        break;
                    case "W-":
                        await Robot.JogAsync("W", -double.Parse(items[1]));
                        break;
                    default:
                        break;
                }
                Robot.Timeout = 5000;
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.成功}!", Duration = 0.4 });
                
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 锁定刹车
        /// </summary>
        private async void ExecuteSLockCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {

                await Robot.SLockAsync();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.成功}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }

        /// <summary>
        /// 释放刹车
        /// </summary>
        private async void ExecutesFreeCommand()
        {
            if (Robot == null || !Robot.IsConnected) return;
            try
            {

                await Robot.SFreeAsync();
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.成功}!", Duration = 0.4 });
            }
            catch (Exception ex)
            {
                _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = ex.Message, Duration = 1 });
            }
        }
        #endregion

        #region 继承
        /// <summary>
        /// 确认导航请求时调用。此方法允许您在导航之前执行一些操作。
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <param name="continuationCallback"></param>
        public void ConfirmNavigationRequest(NavigationContext navigationContext, Action<bool> continuationCallback)
        {
            continuationCallback(true);
        }

        /// <summary>
        /// 接收导航请求时调用。传入导航参数，包含有关导航目标的信息。
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <exception cref="NotImplementedException"></exception>
        public async void OnNavigatedTo(NavigationContext navigationContext)
        {
            var robotInfo = navigationContext.Parameters["RobotInfo"] as Models.RobotInfo;
            if (robotInfo != null)
            {
                Robot = _robotService.GetRobot(robotInfo.Id);
                Robot.EnterDebugMode= true;
            }

            if (_systemDatabaseService.GetCurrentUser().userPart == Enums.UserPart.Operator)
            {
                IsAllowEdit = false;
            }
            else
            {
                IsAllowEdit = true;
            }
        }

        /// <summary>
        /// 是否允许导航到此视图模型。
        /// </summary>
        /// <param name="navigationContext"></param>
        /// <returns></returns>
        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return true;
        }

        /// <summary>
        /// 导航离开此视图模型时调用。您可以在此处执行清理操作或保存状态。
        /// </summary>
        /// <param name="navigationContext"></param>
        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
            if (Robot != null)
                Robot.EnterDebugMode = false;
        }
        #endregion

        private bool _IsAllowEdit = false;

        public bool IsAllowEdit
        {
            get { return _IsAllowEdit; }
            set { SetProperty(ref _IsAllowEdit, value); }
        }

        private void LoginChange(Models.User user)
        {
            if (user.userPart == Enums.UserPart.Operator)
            {
                IsAllowEdit = false;
            }
            else
            {
                IsAllowEdit = true;
            }
        }
    }
}