Display_D_HP/TeamAAS-VM/ViewModels/HomeViewModel.cs

using MahApps.Metro.Controls;
using MaterialDesignThemes.Wpf;
using NPOI.SS.Formula.Functions;
using OxyPlot;
using OxyPlot.Axes;
using OxyPlot.Legends;
using OxyPlot.Series;
using OxyPlot.Wpf;
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.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using TeamAAS_VP;
using TeamAAS_VP.Controls;
using TeamAAS_VP.Core;
using TeamAAS_VP.Data;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;
using TeamAAS_VP.Services;
using TeamAAS_VP.ViewModels.DebugMod;
using TeamAAS_VP.Views.DebugMod;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.StartPanel;

namespace TeamAAS_VP.ViewModels
{
    public class HomeViewModel : BindableBase, IConfirmNavigationRequest
    {
        IEventAggregator _eventAggregator;
        IContainerProvider _container;
        IProductService _productService;
        IConfigService _configService;
        IRemoteCommandService _remoteCommandService;
        ISystemDatabaseService _systemDatabaseService;
        IDialogService _dialogService;

        #region 属性

        private ObservableCollection<TaskMessage> messageQueue=new ObservableCollection<TaskMessage>();

        /// <summary>
        /// 运行信息队列
        /// </summary>
        public ObservableCollection<TaskMessage> MessageQueue
        {
            get { return messageQueue; }
            set { SetProperty(ref messageQueue,value); }
        }

        private ObservableCollection<ProductModel> _ProductList;
        public ObservableCollection<ProductModel> ProductList
        {
            get { return _ProductList; }
            set { SetProperty(ref _ProductList, value); }
        }

        private Management _management;

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

        private double _CTTotalSeconds;

        public double CTTotalSeconds
        {
            get { return _CTTotalSeconds; }
            set { SetProperty(ref _CTTotalSeconds, value); }
        }

        private ProductModel _SelectProduct;

        public ProductModel SelectProduct
        {
            get { return _SelectProduct; }
            set { SetProperty(ref _SelectProduct,value); }
        }

        private bool CanLoad
        {
            get
            {
                if (SelectProduct!=null && IsLoadProduct)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }


        private bool _IsLoadProduct = true;

        public bool IsLoadProduct
        {
            get { return _IsLoadProduct; }
            set { SetProperty(ref _IsLoadProduct, value); }
        }

        private bool _isCanExecute = true;

        public bool isCanExecute
        {
            get { return _isCanExecute; }
            set { SetProperty(ref _isCanExecute, value); }
        }

        private ProductModel _CurrentProduct;
        public ProductModel CurrentProduct
        {
            get { return _CurrentProduct; }
            set { SetProperty(ref _CurrentProduct, value); }
        }

        private PlotModel _LockCurvePlotModel;
        /// <summary>
        /// 锁付曲线
        /// </summary>
        public PlotModel LockCurvePlotModel
        {
            get { return _LockCurvePlotModel; }
            set { SetProperty(ref _LockCurvePlotModel, value); }
        }

        private ObservableCollection<LockResult> _LockResults = new ObservableCollection<LockResult>();

        /// <summary>
        /// 锁付结果列表
        /// </summary>
        public ObservableCollection<LockResult> LockResults
        {
            get { return _LockResults; }
            set { SetProperty(ref _LockResults, value); }
        }

        private bool _IsAllowEdit = false;
        public bool IsAllowEdit
        {
            get { return _IsAllowEdit; }
            set { SetProperty(ref _IsAllowEdit, value); }
        }
        #endregion

        #region 命令
        public DelegateCommand LoadedCommand { get; set; }
        private DelegateCommand<ProductModel> _LoadProductCommand;
        public DelegateCommand<ProductModel> LoadProductCommand =>
            _LoadProductCommand ?? (_LoadProductCommand = new DelegateCommand<ProductModel>(ExecuteLoadProductCommand).ObservesCanExecute(()=> CanLoad).ObservesProperty(()=> SelectProduct).ObservesProperty(()=> IsLoadProduct));

        private DelegateCommand _ResetCounterCommand;
        public DelegateCommand ResetCounterCommand =>
            _ResetCounterCommand ?? (_ResetCounterCommand = new DelegateCommand(ExecuteResetCounterCommand).ObservesCanExecute(() => DoCondition).ObservesProperty(()=>isCanExecute));

        private bool DoCondition
        {
            get { return isCanExecute; }
        }

        private DelegateCommand<string> _CopyCommand;
        public DelegateCommand<string> CopyCommand =>
            _CopyCommand ?? (_CopyCommand = new DelegateCommand<string>(ExecuteCopyCommand));

        private DelegateCommand _TorqueInspectionCommand;
        public DelegateCommand TorqueInspectionCommand =>
            _TorqueInspectionCommand ?? (_TorqueInspectionCommand = new DelegateCommand(ExecuteTorqueInspectionCommand));

        private DelegateCommand _NozzleCounterResetCommand;
        public DelegateCommand NozzleCounterResetCommand =>
            _NozzleCounterResetCommand ?? (_NozzleCounterResetCommand = new DelegateCommand(ExecuteNozzleCounterResetCommand));

        private DelegateCommand _SetAlarmValueCommand;
        public DelegateCommand SetAlarmValueCommand =>
            _SetAlarmValueCommand ?? (_SetAlarmValueCommand = new DelegateCommand(ExecuteSetAlarmValueCommand));

        #endregion

        #region 事件

        #endregion

        public HomeViewModel(IEventAggregator ea, IContainerProvider container, IProductService productService, IConfigService configService, IRemoteCommandService remoteCommandService
            , ISystemDatabaseService systemDatabaseService,IDialogService dialogService)
        {
            _eventAggregator = ea;
            _container = container;
            _dialogService = dialogService;
            _productService = productService;
            LoadedCommand = new DelegateCommand(OnLoad);
            _eventAggregator.GetEvent<TaskMessageNotification>().Subscribe(AddMessageInvoke);
            //订阅权限登录事件
            _eventAggregator.GetEvent<UserLoginNotification>().Subscribe(LoginChange);
            management = _container.Resolve<Management>();
            _configService = configService;
            _productService.OnProductChanged += _productService_OnProductChanged;
            _remoteCommandService = remoteCommandService;
            _remoteCommandService.CycleTimingTicked += _remoteCommandService_CycleTimingTicked;
            _systemDatabaseService = systemDatabaseService;
            _eventAggregator.GetEvent<LockFinishNotification>().Subscribe(OnLockFinish);
        }

        private void _remoteCommandService_CycleTimingTicked(object sender, TimeSpan e)
        {
            try
            {
                if (App.Current!=null)
                {
                    App.Current.Invoke(() =>
                    {
                        CTTotalSeconds = e.TotalSeconds;
                    });
                }
            }
            catch (Exception)
            {

            }
        }

        #region 方法
        bool isFirst=true;
        private void OnLoad()
        {
            if (!isFirst)
            {
                return;
            }
            InitLockCurvePlotModel();
            isFirst = false;

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

        async void ExecuteLoadProductCommand(ProductModel product)
        {
            if (product == null) return;
            var view = new ShowMessage(Lang.是否加载产品, $"{Lang.加载产品}:{product.Name}?");
            //show the dialog
            var result = await DialogHost.Show(view, "RootDialog", null, null, null);
            if (result != null && result is bool)
            {
                if (((bool)result))
                {
                    IsLoadProduct = false;
                    var waiting = new WaitingControl();
                    //show the dialog
                    var task = DialogHost.Show(waiting, "RootDialog", null, null, null);
                    await _productService.LoadProductAsync(product.ID);
                    _productService.SetCurrentProduct(product.ID);
                    await management.WritePositionToPlcAsync();
                    if (DialogHost.IsDialogOpen("RootDialog"))
                    {
                        DialogHost.Close("RootDialog");
                    }
                    await task;
                    //DatabaseHelper.AddLoadProductRecord(product.ID, product.Name, false);
                    IsLoadProduct = true;
                }
            }
        }

        void ExecuteCopyCommand(string textToCopy)
        {
            Clipboard.SetText(textToCopy);
        }

        void ExecuteTorqueInspectionCommand()
        {
            _dialogService.ShowDialog("TorqueCheck", rst =>
            {
                //对话框关闭之后的回调函数，可以在这解析结果。
                ButtonResult result1 = rst.Result;

                if (result1 == ButtonResult.OK)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.完成, Duration = 1 });
                }
            });
        }

        /// <summary>
        /// 添加消息至消息队列
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="color"></param>
        public void AddMessage(string msg, Color color)
        {
            App.Current.Dispatcher.BeginInvoke(new Action(() => {
                try
                {
                    MessageQueue.Add(new TaskMessage()
                    {
                        DT = DateTime.Now,
                        Message = msg,
                        FontColol = new SolidColorBrush(color)
                    });
                    LogHelper.WriteLogInfo(msg);
                }
                catch (Exception)
                {

                }
            }));
        }

        /// <summary>
        /// 添加消息至消息队列
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="color"></param>
        public void AddMessage(string msg, MessageLevel level)
        {
            MessageStruct messageStruct = new MessageStruct() { Message = msg, level = level };
            App.Current.Dispatcher.BeginInvoke(new Action(() => {
                AddMessage(messageStruct);
            }));
        }

        /// <summary>
        /// 添加消息至消息队列
        /// </summary>
        /// <param name="messageStruct"></param>
        public void AddMessage(MessageStruct messageStruct)
        {
            try
            {
                if (MessageQueue.Count >= 20)
                {
                    MessageQueue.RemoveAt(0);// 从队列头部移除最早的消息
                }
                Color color = Colors.Black;
                switch (messageStruct.level)
                {
                    case MessageLevel.Info:
                        color = Colors.Black;
                        break;
                    case MessageLevel.Debug:
                        color = Colors.Green;
                        break;
                    case MessageLevel.Alarm:
                        color = Colors.Orange;
                        break;
                    case MessageLevel.Error:
                        color = Colors.Red;
                        break;
                }
                MessageQueue.Add(new TaskMessage()
                {
                    DT = DateTime.Now,
                    Message = messageStruct.Message,
                    FontColol = new SolidColorBrush(color)
                });
                LogHelper.WriteLogInfo(messageStruct.Message);
            }
            catch (Exception)
            {

            }
        }

        public void AddMessageInvoke(MessageStruct messageStruct)
        {
            App.Current.Dispatcher.BeginInvoke(new Action(() => {
                AddMessage(messageStruct);
            }));
        }

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

        /// <summary>
        /// 重置计数
        /// </summary>
        async void ExecuteResetCounterCommand()
        {
            if (management.CurrentProduct == null) return;
            var view = new ShowMessage(Lang.计数清零, Lang.是否重置当前产品的计数);
            //show the dialog
            var result = await DialogHost.Show(view, "RootDialog", null, null, null);
            if (result != null && result is bool)
            {
                if (((bool)result))
                {
                    isCanExecute = false;
                    await _systemDatabaseService.ResetProductionAsync(management.CurrentProduct.Name);
                    isCanExecute = true;
                }
            }
        }

        //初始化曲线图
        private void InitLockCurvePlotModel()
        {
            var model = new PlotModel { Title = "锁付曲线", TitleFontSize = 16};
            // 设置图例
            var legend = new Legend
            {
                LegendPosition = LegendPosition.TopRight,
                LegendPlacement = LegendPlacement.Outside,
                LegendOrientation = LegendOrientation.Vertical,
                LegendBorderThickness = 0
            };
            model.Legends.Add(legend);
            // 设置X轴
            var xAxis = new LinearAxis
            {
                Key="X",
                Position = AxisPosition.Bottom,
                Title = "角度 (°)",
                Minimum = 0,
                MajorGridlineStyle = LineStyle.Solid,
                MinorGridlineStyle = LineStyle.Dot
            };
            model.Axes.Add(xAxis);
            // 设置Y轴
            var yAxis = new LinearAxis
            {
                Key = "Y",
                Position = AxisPosition.Left,
                Title = "力矩 (kgf)",
                MajorGridlineStyle = LineStyle.Solid,
                MinorGridlineStyle = LineStyle.Dot
            };
            model.Axes.Add(yAxis);
            // 添加示例数据系列
            var series = new LineSeries
            {
                Title = "锁付力矩曲线",
                StrokeThickness = 2,
                MarkerSize = 3,
                MarkerType = MarkerType.Circle,
                CanTrackerInterpolatePoints = false,
            };
            model.Series.Add(series);
            LockCurvePlotModel = model;
        }

        /// <summary>
        /// 螺丝锁付完成时调用
        /// </summary>
        /// <param name="result"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void OnLockFinish(LockResult result)
        {
            //如果当前螺丝编号为1，则清除之前的结果
            if (result.Number == 1)
            {
                LockResults.Clear();
            }
            LockResults.Add(result);

            //更新曲线图
            App.Current.Dispatcher.BeginInvoke(new Action(() => {
                var series = LockCurvePlotModel.Series[0] as LineSeries;
                //var yaxis = LockCurvePlotModel.Axes.FirstOrDefault(p=>p.Key=="Y");
                //yaxis.Maximum = result.TargetTorque;
                series.Points.Clear();
                foreach (var waveData in result.WaveDatas)
                {
                    series.Points.Add(new OxyPlot.DataPoint(waveData.LockAngle, waveData.Torque));
                }
                LockCurvePlotModel.InvalidatePlot(true);
            }));

        }
        private void SaveAsPng(PlotModel LockCurvePlotModel)
        {
            string savePath = $"E:\\Data\\螺丝锁付曲线图\\{DateTime.Now:yyyyMMdd_HHmmss}.png";

            Application.Current.Dispatcher.Invoke(() =>
            {
                try
                {
                    var exporter = new PngExporter { Width = 1200, Height = 800 };
                    exporter.ExportToFile(LockCurvePlotModel, savePath);
                    //SaveStatus = $"已保存到：{savePath}";
                }
                catch (Exception ex)
                {
                    //SaveStatus = $"保存失败：{ex.Message}";
                }
            });
        }

        void ExecuteSetAlarmValueCommand()
        {
            _dialogService.ShowDialog("SetAlarmValue", rst =>
            {
                //对话框关闭之后的回调函数，可以在这解析结果。
                ButtonResult result1 = rst.Result;

                if (result1 == ButtonResult.OK)
                {
                    _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.完成, Duration = 1 });
                }
            });
        }
        void ExecuteNozzleCounterResetCommand()
        {
            management.NumStatistics.NozzleNum = 0;
            management.NumStatistics.HeaderNum = 0;
            FileHelper.WriteJsonFile(management.NumStatistics, FilePath.NumberStatisticsPath);
            _eventAggregator.GetEvent<SnackbarMessageNotification>().Publish(new MessageParameter() { Msg = Lang.完成, 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)
        {

            try
            {
                ProductList = new ObservableCollection<ProductModel>(_productService.GetAllProducts());
            }
            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 void _productService_OnProductChanged(ProductModel obj)
        {
            App.Current.Dispatcher.BeginInvoke(new Action(() => {
                CurrentProduct = obj;
            }));
        }
    }
}