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

using Cognex.VisionPro;
using Cognex.VisionPro.ToolBlock;
using MahApps.Metro.Controls;
using MaterialDesignThemes.Wpf;
using NPOI.SS.Formula.Functions;
using Prism.Commands;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP;
using TeamAAS_VP.Controls;
using TeamAAS_VP.Core;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Models.Product;
using TeamAAS_VP.Models.Robot;
using TeamAAS_VP.Resources.Languages;
using TeamAAS_VP.Services;
using TeamAAS_VP.Views.Product;
using TouchSocket.Core;
using static MaterialDesignThemes.Wpf.Theme.ToolBar;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.StartPanel;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.Window;

namespace TeamAAS_VP.ViewModels.Product
{
    public class ProductHomeViewModel : 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 ObservableCollection<ProductModel> _Products;

        /// <summary>
        /// 产品列表
        /// </summary>
        public ObservableCollection<ProductModel> Products
        {
            get { return _Products; }
            set { SetProperty(ref _Products, value); }
        }

        private ProductModel _SelectProduct;

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

        #region 命令
        private DelegateCommand _CreateCommand;
        public DelegateCommand CreateCommand =>
            _CreateCommand ?? (_CreateCommand = new DelegateCommand(ExecuteCreateCommand));

        private DelegateCommand<object> _RemoveCommand;
        public DelegateCommand<object> RemoveCommand =>
            _RemoveCommand ?? (_RemoveCommand = new DelegateCommand<object>(ExecuteRemoveCommand, CanExt).ObservesProperty(() => SelectProduct));

        private DelegateCommand<object> _EditCommand;
        public DelegateCommand<object> EditCommand =>
            _EditCommand ?? (_EditCommand = new DelegateCommand<object>(ExecuteEditCommand, CanExt).ObservesProperty(() => SelectProduct));

        private DelegateCommand<object> _CopyCommand;
        public DelegateCommand<object> CopyCommand =>
            _CopyCommand ?? (_CopyCommand = new DelegateCommand<object>(ExecuteCopyCommand).ObservesProperty(() => SelectProduct));

        private DelegateCommand<object> _EditNameCommand;
        public DelegateCommand<object> EditNameCommand =>
            _EditNameCommand ?? (_EditNameCommand = new DelegateCommand<object>(ExecuteEditNameCommand, CanExt).ObservesProperty(() => SelectProduct));

        private DelegateCommand<object> _SaveCommand;
        public DelegateCommand<object> SaveCommand =>
            _SaveCommand ?? (_SaveCommand = new DelegateCommand<object>(ExecuteSaveCommand, CanExt).ObservesProperty(() => SelectProduct));

        private DelegateCommand<object> _SaveTemplateCommand;
        public DelegateCommand<object> SaveTemplateCommand =>
            _SaveTemplateCommand ?? (_SaveTemplateCommand = new DelegateCommand<object>(ExecuteSaveTemplateCommand, CanExt).ObservesProperty(() => SelectProduct));

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

        #region 事件

        #endregion

        public ProductHomeViewModel(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);
        }

        #region 方法

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

        /// <summary>
        /// 新建产品
        /// </summary>
        async void ExecuteCreateCommand()
        {
            try
            {
                var view = new CreateProductPage();

                //show the dialog
                var result = await DialogHost.Show(view, "RootDialog", ExtendedOpenedEventHandler, ExtendedClosingEventHandler, ExtendedClosedEventHandler);
                if (result != null)
                {
                    string productname = ((CreateProductPageViewModel)result).ProductName;
                    string template = ((CreateProductPageViewModel)result).SelectTemplate;
                    if (!FileHelper.CheckFileName(productname))
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.输入的名称不符合文件名命名规则, Duration = 1 });
                        return;
                    }
                    if (Products.FirstOrDefault(p => p.Name == productname) != null)
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.已存在同名产品, Duration = 1 });
                        return;
                    }

                    if (template != "空白" && !string.IsNullOrEmpty(template))
                    {
                        //通过模板创建产品
                        var product1 = _productService.CreateProductByTemplateName(template, productname);
                        var products = _productService.GetAllProducts();
                        Products=new ObservableCollection<ProductModel>(products);
                        SelectProduct=Products.FirstOrDefault(p => p.ID == product1.ID);
                        _regionManager.RequestNavigate("ProductRegionContext", "ProductDescription");
                        return;
                    }

                    //创建新产品
                    var newproduct = new ProductModel()
                    {
                        Name = productname,
                        ID = Guid.NewGuid(),
                        DateTime = DateTime.Now,
                        CameraProcedures = new ObservableCollection<CameraProcedure>(),
                        RobotPoint = new RobotPoint(_configService.GetAllRobots().ToArray()),
                        IsLoad = false,
                        IsCreate = true,
                        Speed = 20,
                        Accel = 50,
                        Speeds = 500,
                        Accels = 10000,
                        Power = false,
                        IsUserUpCamera = false,
                        GlobalParamListCollection = new ObservableCollection<ProductGlobalParam>(),
                        PickCameraPoints = new ObservableCollection<Models.PLC.PlcPoint>(),
                        PickPoints = new ObservableCollection<Models.PLC.PlcPoint>(),
                        SecPosCameraPoints=new ObservableCollection<Models.PLC.PlcPoint>(),
                        ScrewCameraPoints=new ObservableCollection<Models.PLC.PlcPoint>(),
                        ScrewPoints=new ObservableCollection<Models.PLC.PlcPoint>(),
                        CheckCameraPoints=new ObservableCollection<Models.PLC.PlcPoint>(),
                        RemovePoints = new ObservableCollection<Models.PLC.PlcPoint>(),
                        PressurePlacePoints = new ObservableCollection<Models.PLC.PlcPoint>(),
                        IndependentCamerPoints = new ObservableCollection<Models.PLC.PlcPoint>(),
                    };

                    var cameras = _configService.GetAllCameras();
                    foreach (var item in cameras)
                    {
                        newproduct.CameraProcedures.Add(new CameraProcedure() { Camera = item.CameraName, ID = item.Id, ProcedureModels = new ObservableCollection<ProcedureModel>() });
                    }
                    _productService.CreateProduct(newproduct);
                    Products = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                    SelectProduct = Products.FirstOrDefault(p => p.ID == newproduct.ID);
                    NavigationParameters param = new NavigationParameters();
                    param.Add("SelectProduct", SelectProduct);
                    _regionManager.RequestNavigate("ProductRegionContext", "ProductDescription", param);
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("产品界面-新建产品时出错", ex);
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 移除产品
        /// </summary>
        void ExecuteRemoveCommand(object product)
        {
            try
            {
                if (!(product is ProductModel))
                    return;
                if (MessageBox.Show($"{Lang.移除}[{((ProductModel)product).Name}]?", Lang.移除产品, MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
                {
                    _productService.DeleteProduct(((ProductModel)product).ID);
                    Products = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                    SelectProduct = null;
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("产品界面-移除产品时出错", ex);
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 编辑产品
        /// </summary>
        void ExecuteEditCommand(object product)
        {

            if (!(product is ProductModel))
                return;
            NavigationParameters parameters = new NavigationParameters();
            parameters.Add("SelectProduct", SelectProduct);
            _regionManager.RequestNavigate("ProductRegionContext", "ProductDescription", parameters);
        }

        /// <summary>
        /// 复制产品
        /// </summary>
        async void ExecuteCopyCommand(object product)
        {

            if (!(product is ProductModel))
                return;

            try
            {
                var view = new AddProduct() { Title = $"{Lang.复制产品}:", Item = "Name" };

                //show the dialog
                var result = await DialogHost.Show(view, "RootDialog", ExtendedOpenedEventHandler, ExtendedClosingEventHandler, ExtendedClosedEventHandler);
                if (result != null && !string.IsNullOrEmpty(result.ToString()))
                {
                    if (!FileHelper.CheckFileName(result.ToString()))
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.输入的名称不符合文件名命名规则, Duration = 1 });
                        return;
                    }
                    if (Products.FirstOrDefault(pr => pr.Name == result.ToString()) != null)
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.已存在同名产品, Duration = 1 });
                        return;
                    }

                    Guid id = _productService.CopyProduct(((ProductModel)product).ID, result.ToString().Trim());
                    Products = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                    SelectProduct = Products.FirstOrDefault(p => p.ID == id);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.复制完成, Duration = 1 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("产品界面-复制产品时出错", ex);
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 修改产品名称
        /// </summary>
        async void ExecuteEditNameCommand(object product)
        {
            try
            {
                if (!(product is ProductModel))
                    return;
                var view = new AddProduct() { Title = $"{Lang.修改产品名称}:", Item = "Name" };

                //show the dialog
                var result = await DialogHost.Show(view, "RootDialog", ExtendedOpenedEventHandler, ExtendedClosingEventHandler, ExtendedClosedEventHandler);
                if (result != null && !string.IsNullOrEmpty(result.ToString()))
                {
                    if (!FileHelper.CheckFileName(result.ToString()))
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.输入的名称不符合文件名命名规则, Duration = 1 });
                        return;
                    }
                    if (Products.FirstOrDefault(pr => pr.Name == result.ToString()) != null)
                    {
                        _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.已存在同名产品, Duration = 1 });
                        return;
                    }

                    _productService.RenameProduct(((ProductModel)product).ID, result.ToString().Trim());
                    Products = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
                    SelectProduct = Products.FirstOrDefault(p => p.ID == ((ProductModel)product).ID);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.修改完成, Duration = 1 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("产品界面-修改产品名称时出错", ex);
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 保存产品
        /// </summary>
        /// <param name="product"></param>
        void ExecuteSaveCommand(object product)
        {
            try
            {
                if (!(product is ProductModel))
                    return;
                if (MessageBox.Show(Lang.是否保存产品.Replace("{0}", ((ProductModel)product).Name), Lang.保存产品, MessageBoxButton.OKCancel, MessageBoxImage.Question) == MessageBoxResult.OK)
                {
                    _productService.UpdateProduct((ProductModel)product);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}！", Duration = 1 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("产品界面-保存产品时出错", ex);
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 保存产品模板
        /// </summary>
        /// <param name="product"></param>
        void ExecuteSaveTemplateCommand(object product)
        {
            try
            {
                if (!(product is ProductModel))
                    return;
                if (MessageBox.Show(Lang.是否保存产品为模板.Replace("{0}", ((ProductModel)product).Name), Lang.保存产品模板, MessageBoxButton.OKCancel, MessageBoxImage.Question) == MessageBoxResult.OK)
                {
                    string templatePath = FilePath.ProductTemplatePath + "//" + ((ProductModel)product).Name;
                    _productService.SaveProduct(((ProductModel)product).ID, templatePath);
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = $"{Lang.完成}！", Duration = 1 });
                }
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("产品界面-保存产品至模板时出错", ex);
                MessageBox.Show(ex.Message);
            }
        }

        private void ExtendedOpenedEventHandler(object sender, DialogOpenedEventArgs eventArgs)
        {

        }

        private void ExtendedClosingEventHandler(object sender, DialogClosingEventArgs eventArgs)
        {

        }

        private void ExtendedClosedEventHandler(object sender, DialogClosedEventArgs eventArgs)
        {

        }

        private bool CanExt(object obg)
        {
            return SelectProduct != null ? true : 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)
        {
            if (Products==null)
            {
                var products = _productService.GetAllProducts();
                Products = new ObservableCollection<ProductModel>(products);

            }
        }

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