Display_D_HP/TeamAAS-VM/ViewModels/Product/ProductParamsViewModel.cs

using MaterialDesignThemes.Wpf;
using Prism.Commands;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP.Controls;
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.Product
{
    public class ProductParamsViewModel : BindableBase, IConfirmNavigationRequest
    {
        IRegionManager _regionManager;
        IEventAggregator _eventAggregator;
        IContainerProvider _container;
        IDialogService _dialogService;
        IConfigService _configService;
        IRobotService _robotService;
        ICameraService _cameraService;
        IFeederService _feederService;
        IPlcService _plcService;
        IProductService _productService;
        ISystemDatabaseService _systemDatabaseService;

        #region 属性

        private ProductModel _SelectProduct;

        /// <summary>
        /// 选中的产品
        /// </summary>
        public ProductModel SelectProduct
        {
            get { return _SelectProduct; }
            set { SetProperty(ref _SelectProduct, value); }
        }

        private Management _management;

        public Management management
        {
            get { return _management; }
            set { SetProperty(ref _management, value); }
        }

        private ObservableCollection<ProcedureModel> _ProcedureModels;

        /// <summary>
        /// 流程集合
        /// </summary>
        public ObservableCollection<ProcedureModel> ProcedureModels
        {
            get { return _ProcedureModels; }
            set { SetProperty(ref _ProcedureModels, value); }
        }

        private ProcedureModel _FixedUpCamera1Procedure;
        /// <summary>
        /// 固定向上相机1视觉流程
        /// </summary>
        public ProcedureModel FixedUpCamera1Procedure
        {
            get { return _FixedUpCamera1Procedure; }
            set
            {
                SetProperty(ref _FixedUpCamera1Procedure, value);
                if (value != null)
                {
                    SelectProduct.FixedUpCamera1ProcedureId = value.Id;
                }
            }
        }

        private ProcedureModel _FixedUpCamera2Procedure;
        /// <summary>
        /// 固定向上相机2视觉流程
        /// </summary>
        public ProcedureModel FixedUpCamera2Procedure
        {
            get { return _FixedUpCamera2Procedure; }
            set
            {
                SetProperty(ref _FixedUpCamera2Procedure, value); 
                if (value != null)
                {
                    SelectProduct.FixedUpCamera2ProcedureId = value.Id;
                }
            }
        }

        private ProcedureModel _FixedDownCameraProcedure;
        /// <summary>
        /// 固定向下相机取料流程ID
        /// </summary>
        public ProcedureModel FixedDownCameraProcedure
        {
            get { return _FixedDownCameraProcedure; }
            set { SetProperty(ref _FixedDownCameraProcedure, value);
                if (value != null)
                {
                    SelectProduct.FixedDownCameraProcedureId = value.Id;
                }
            }
        }

        private ProcedureModel _FzCameraProcedure;
        /// <summary>
        /// 翻转相机流程ID
        /// </summary>
        public ProcedureModel FzCameraProcedure
        {
            get { return _FzCameraProcedure; }
            set
            {
                SetProperty(ref _FzCameraProcedure, value);
                if (value != null)
                {
                    SelectProduct.FzCameraProcedureId = value.Id;
                }
            }
        }

        private ProcedureModel _MoveDownCameraLockPhotoProcedure;
        /// <summary>
        /// 移动向下相机锁付拍照流程ID
        /// </summary>
        public ProcedureModel MoveDownCameraLockPhotoProcedure
        {
            get { return _MoveDownCameraLockPhotoProcedure; }
            set { SetProperty(ref _MoveDownCameraLockPhotoProcedure, value);
                if (value != null)
                {
                    SelectProduct.MoveDownCameraLockPhotoProcedureId = value.Id;
                }
            }
        }

        private bool _IsTurnOnAllLightUse = false;
        /// <summary>
        /// 打开光源
        /// </summary>
        public bool IsTurnOnAllLightUse
        {
            get { return _IsTurnOnAllLightUse; }
            set { SetProperty(ref _IsTurnOnAllLightUse, value); }
        }

        private bool _IsTurnOffAllLightUse = false;
        /// <summary>
        /// 关闭光源
        /// </summary>
        public bool IsTurnOffAllLightUse
        {
            get { return _IsTurnOffAllLightUse; }
            set { SetProperty(ref _IsTurnOffAllLightUse, value); }
        }
        #endregion

        #region 命令
        
        private DelegateCommand _NextCommand;
        public DelegateCommand NextCommand =>
            _NextCommand ?? (_NextCommand = new DelegateCommand(ExecuteNextCommand));

        private DelegateCommand _BackCommand;
        public DelegateCommand BackCommand =>
            _BackCommand ?? (_BackCommand = new DelegateCommand(ExecuteBackCommand));

        private DelegateCommand _LoadedCommand;
        public DelegateCommand LoadedCommand =>
            _LoadedCommand ?? (_LoadedCommand = new DelegateCommand(ExecuteLoadedCommand));


        #endregion

        #region 事件

        #endregion

        public ProductParamsViewModel(IRegionManager regionManager, IEventAggregator ea, IContainerProvider container, IDialogService dialogService,
            IConfigService configService, IRobotService robotService, ICameraService cameraService, IFeederService feederService, IPlcService plcService, IProductService productService,
            ISystemDatabaseService systemDatabaseService)
        {
            _regionManager = regionManager;
            _eventAggregator = ea;
            _container = container;
            
            _dialogService = dialogService;
            _configService = configService;
            _robotService = robotService;
            _cameraService = cameraService;
            _feederService = feederService;
            _plcService = plcService;
            _productService = productService;
            _systemDatabaseService = systemDatabaseService;
            //订阅权限登录事件
            _eventAggregator.GetEvent<UserLoginNotification>().Subscribe(LoginChange);
            management = _container.Resolve<Management>();
        }

        #region 方法
        
        /// <summary>
        /// 完成
        /// </summary>
        async void ExecuteNextCommand()
        {
            if (MessageBox.Show(Lang.是否保存产品.Replace("[{0}]", ""), Lang.保存产品, MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
            {
                var waiting = new WaitingControl();
                //show the dialog
                var task = DialogHost.Show(waiting, "RootDialog", null, null, null);
                await _productService.UpdateProductAsync(SelectProduct);
                var current = _productService.GetCurrentProduct();
                if (current != null && current.IsLoad)
                {
                    await management.WritePositionToPlcAsync();
                }
                if (DialogHost.IsDialogOpen("RootDialog"))
                {
                    DialogHost.Close("RootDialog");
                }
                await task;

            }
            NavigationParameters param = new NavigationParameters();
            param.Add("SelectProduct", SelectProduct);
            _regionManager.RequestNavigate("ProductRegionContext", "ProductHome", param);
        }

        /// <summary>
        /// 上一步
        /// </summary>
        void ExecuteBackCommand()
        {
            NavigationParameters param = new NavigationParameters();
            param.Add("SelectProduct", SelectProduct);
            _regionManager.RequestNavigate("ProductRegionContext", "PlcPointParams", param);
        }

        void ExecuteLoadedCommand()
        {
            if (_systemDatabaseService.GetCurrentUser().userPart == Enums.UserPart.Operator)
            {
                IsAllowEdit = false;
            }
            else
            {
                IsAllowEdit = true;
            }
            var sysConfig = _configService.GetSystemConfiguration();
            if (sysConfig.TurnOnAllLightUse == true)
            {
                IsTurnOnAllLightUse = true;
            }
            else
            {
                IsTurnOnAllLightUse = false;
            }
            if (sysConfig.TurnOffAllLightUse == true)
            {
                IsTurnOffAllLightUse = true;
            }
            else
            {
                IsTurnOffAllLightUse = false;
            }
        }

        #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)
        {
            try
            {
                SelectProduct = navigationContext.Parameters.GetValue<ProductModel>("SelectProduct");
                ProcedureModels = new ObservableCollection<ProcedureModel>();
                foreach (var item in SelectProduct.CameraProcedures)
                {
                    foreach (var item1 in item.ProcedureModels)
                    {
                        ProcedureModels.Add(item1);
                    }
                }
                if (SelectProduct.FixedUpCamera1ProcedureId!=Guid.Empty)
                {
                    FixedUpCamera1Procedure = ProcedureModels.FirstOrDefault(p => p.Id == SelectProduct.FixedUpCamera1ProcedureId);
                }
                if (SelectProduct.FixedUpCamera2ProcedureId != Guid.Empty)
                {
                    FixedUpCamera2Procedure = ProcedureModels.FirstOrDefault(p => p.Id == SelectProduct.FixedUpCamera2ProcedureId);
                }
                if (SelectProduct.FixedDownCameraProcedureId != Guid.Empty)
                {
                    FixedDownCameraProcedure = ProcedureModels.FirstOrDefault(p => p.Id == SelectProduct.FixedDownCameraProcedureId);
                }
                if (SelectProduct.FzCameraProcedureId != Guid.Empty)
                {
                    FzCameraProcedure = ProcedureModels.FirstOrDefault(p => p.Id == SelectProduct.FzCameraProcedureId);
                }
                if (SelectProduct.MoveDownCameraLockPhotoProcedureId != Guid.Empty)
                {
                    MoveDownCameraLockPhotoProcedure = ProcedureModels.FirstOrDefault(p => p.Id == SelectProduct.MoveDownCameraLockPhotoProcedureId);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("机器人点位界面进入时出错！", ex);
            }
        }

        /// <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)
        {

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