Aucma.Scada/Aucma.Scada.UI/viewModel/OutStoreInfo/OutStoreInfoViewModel.cs

using Aucma.Scada.Business;
using Aucma.Scada.Model.domain;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
using HighWayIot.Config;
using HighWayIot.Log4net;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;

namespace Aucma.Scada.UI.viewModel.OutStoreInfo
{
    public class OutStoreInfoViewModel : ViewModelBase
    {
        private LogHelper logHelper = LogHelper.Instance;
        private ObservableCollection<dynamic> listItems = new ObservableCollection<dynamic>();
        private ObservableCollection<RealTaskInfo> taskItems = new ObservableCollection<RealTaskInfo>();

        private OutStoreBusiness outStoreBusiness = OutStoreBusiness.Instance;
        private AppConfig appConfig = AppConfig.Instance;

        public OutStoreInfoViewModel()
        {
            outStoreBusiness.RefreshOutStoreTaskEvent += RefreshOutStoreTask;
            outStoreBusiness.RefreshScanMateriaCodeEvent += RefreshScanInfo;
            outStoreBusiness.RefreshLogMessageEvent += PrintMessageToListBox1;
            DeleteAllCommand = new RelayCommand(DeleteAll);
            QueryCommand = new RelayCommand(Query);
            ResetCommand = new RelayCommand(Reset);
            DeleteTaskInfoCommand = new RelayCommand<object>(obj => DeleteTaskInfo(obj));

            this.Query();
        }


        #region 参数定义
        /// <summary>
        /// 箱壳物料条码
        /// </summary>
        private string shellMaterialCode = string.Empty;
        public string ShellMaterialCode
        {
            get { return shellMaterialCode; }
            set { shellMaterialCode = value; RaisePropertyChanged(nameof(ShellMaterialCode)); }
        }

        /// <summary>
        /// 箱壳物料名称
        /// </summary>
        private string shellMaterialName = string.Empty;
        public string ShellMaterialName
        {
            get { return shellMaterialName; }
            set { shellMaterialName = value; RaisePropertyChanged(nameof(ShellMaterialName)); }
        }

        /// <summary>
        /// 箱壳入库货道
        /// </summary>
        private string shellSpaceName = string.Empty;
        public string ShellSpaceName
        {
            get { return shellSpaceName; }
            set { shellSpaceName = value; RaisePropertyChanged(nameof(ShellSpaceName)); }
        }

        /// <summary>
        /// 内胆物料条码
        /// </summary>
        private string linerMaterialCode = string.Empty;
        public string LinerMaterialCode
        {
            get { return linerMaterialCode; }
            set { linerMaterialCode = value; RaisePropertyChanged(nameof(LinerMaterialCode)); }
        }

        /// <summary>
        /// 内胆物料名称
        /// </summary>
        private string linerMaterialName = string.Empty;
        public string LinerMaterialName
        {
            get { return linerMaterialName; }
            set { linerMaterialName = value; RaisePropertyChanged(nameof(LinerMaterialName)); }
        }

        /// <summary>
        /// 内胆入库货道
        /// </summary>
        private string linerSpaceName = string.Empty;
        public string LinerSpaceName
        {
            get { return linerSpaceName; }
            set { linerSpaceName = value; RaisePropertyChanged(nameof(LinerSpaceName)); }
        }


        /// <summary>
        /// LisBox数据模板
        /// </summary>
        private IEnumerable logInfoListBox;
        public IEnumerable LogInfoListBox
        {
            get { return logInfoListBox; }
            set { logInfoListBox = value; RaisePropertyChanged(() => LogInfoListBox); }
        }

        /// <summary>
        /// 出库任务DataGrid
        /// </summary>
        private IEnumerable outstoreTask;

        public IEnumerable OutstoreTask
        {
            get { return outstoreTask; }
            set { outstoreTask = value; RaisePropertyChanged(() => OutstoreTask); }

        }

        /// <summary>
        /// 查询条件-任务编号
        /// </summary>
        private string taskCodeSearch = string.Empty;

        public string TaskCodeSearch
        {
            get { return taskCodeSearch; }
            set { taskCodeSearch = value; RaisePropertyChanged(nameof(TaskCodeSearch)); }
        }

        private string materialCodeSearch = string.Empty;

        /// <summary>
        /// 查询条件-物料编号
        /// </summary>
        public string MaterialCodeSearch
        {
            get { return materialCodeSearch; }
            set { materialCodeSearch = value; RaisePropertyChanged(nameof(MaterialCodeSearch)); }
        }

        /// <summary>
        /// 查询条件-计划编号
        /// </summary>
        private string planCodeSearch = string.Empty;

        public string PlanCodeSearch
        {
            get { return planCodeSearch; }
            set { planCodeSearch = value; RaisePropertyChanged(nameof(PlanCodeSearch)); }
        }

        #endregion

        #region 事件定义

        

        /// <summary>
        /// 查询事件
        /// </summary>
        public RelayCommand DeleteAllCommand { get; set; }
        /// <summary>
        /// 查询事件
        /// </summary>
        public RelayCommand QueryCommand { get; set; }

        /// <summary>
        /// 重置
        /// </summary>
        public RelayCommand ResetCommand { get; set; }

        /// <summary>
        /// 删除
        /// </summary>
        public RelayCommand<object> DeleteTaskInfoCommand { get; set; }
        #endregion


        private ObservableCollection<string> logMessages = new ObservableCollection<string>();
        private int maxLogEntries = 120;


        private async void PrintMessageToListBox1(string message)
        {
            await Task.Run(() =>
            {
                try
                {
                    string formattedMessage = $"{DateTime.Now.ToString("HH:mm:ss.ss")} ==> {message}";

                    lock (listItems)
                    {
                        listItems.Add(formattedMessage);

                        while (listItems.Count > 120)
                        {
                            listItems.RemoveAt(0);
                        }

                        var orderedList = listItems.OrderByDescending(x => x).ToList();  // 排序后转为 List
                        Application.Current.Dispatcher.Invoke(() =>
                        {
                            LogInfoListBox = orderedList;  // 更新 UI
                        });
                    }
                }
                catch (Exception ex)
                {
                    logHelper.Error("日志数据绑定异常", ex);
                }
            });
        }

        /// <summary>
        /// listBox绑定日志
        /// </summary>
        /// <param name="message"></param>
        private void PrintMessageToListBox(string message)
        {

            try
            {
                //   string formattedMessage = $"{DateTime.Now.ToString("HH:mm:ss.ss")} ==> {message}";

                listItems.Add($"{DateTime.Now.ToString("HH:mm:ss.ss")}==>{message}");

                while (listItems.Count > 120)
                {
                    listItems.RemoveAt(0);
                }

                LogInfoListBox = listItems.OrderByDescending(x => x);


            }
            catch (Exception ex)
            {
                logHelper.Error("日志数据绑定异常", ex);
            }
        }

        /// <summary>
        /// 刷新出库任务列表
        /// </summary>
        /// <param name="taskInfo"></param>
        private void RefreshOutStoreTask(RealTaskInfo taskInfo)
        {
            try
            {
                App.Current.Dispatcher.Invoke((Action)(() =>
                {
                    taskInfo.materialType = outStoreBusiness.GetMaterialName(taskInfo.materialType);
                    taskItems.Add(taskInfo);
                    OutstoreTask = taskItems;
                }));
            }
            catch (Exception ex)
            {
                logHelper.Error("入库任务列表刷新异常", ex);
            }
        }

        /// <summary>
        /// 刷新扫码信息
        /// </summary>
        /// <param name="materialCode"></param>
        /// <param name="materialName"></param>
        /// <param name="spaceName"></param>
        /// <param name="storeCode"></param>
        private void RefreshScanInfo(string materialCode, string materialName, string spaceName, string storeCode)
        {
            if (storeCode == appConfig.shellStoreCode)
            {
                ShellMaterialCode = materialCode;
                ShellMaterialName = materialName;
                ShellSpaceName = spaceName;
            }
            else if (storeCode == appConfig.linerStoreCode)
            {
                LinerMaterialCode = materialCode;
                LinerMaterialName = materialName;
                LinerSpaceName = spaceName;
            }
            Query();
        }

        private async void DeleteAll()
        {
            await Task.Run(() =>
            {
                try
                {
                    List<RealTaskInfo> list = outStoreBusiness.GetOutStoreTask();

                    if (list != null)
                    {
                        foreach (RealTaskInfo task in list)
                        {
                            outStoreBusiness.DeleteTaskInfoByTaskCode(task.taskCode, task.taskStatus == 2);
                        }

                    }
                }
                catch (Exception ex)
                {
                    logHelper.Error("OutStoreViewModel初始化异常", ex);
                }
                Query() ;
            });
        }

        /// <summary>
        /// 初始化
        /// </summary>
        private async void Query()
        {
            await Task.Run(() =>
            {
                try
                {
                    var info = outStoreBusiness.GetOutStoreTask();



                    if (info != null)
                    {
                        if (!string.IsNullOrEmpty(taskCodeSearch))
                        {
                            info = info.Where(x => x.taskCode.Contains(taskCodeSearch)).ToList();
                        }
                        else if (!string.IsNullOrEmpty(materialCodeSearch))
                        {
                            info = info.Where(x => x.materialCode.Contains(materialCodeSearch)).ToList();
                        }
                        else if (!string.IsNullOrEmpty(planCodeSearch))
                        {
                            info = info.Where(x => x.planCode.Contains(planCodeSearch)).ToList();
                        }
                        App.Current.Dispatcher.Invoke((Action)(() =>
                        {
                            taskItems = new ObservableCollection<RealTaskInfo>();
                            foreach (var item in info)
                            {
                                item.materialType = outStoreBusiness.GetMaterialName(item.materialType);
                                taskItems.Add(item);
                            }
                            OutstoreTask = taskItems.OrderBy(x => x.createTime);
                        }));
                    }
                }
                catch (Exception ex)
                {
                    logHelper.Error("OutStoreViewModel初始化异常", ex);
                }
            });
        }

        /// <summary>
        /// 重置
        /// </summary>
        private void Reset()
        {
            this.TaskCodeSearch = string.Empty;
            this.MaterialCodeSearch = string.Empty;
            this.PlanCodeSearch = string.Empty;
            this.Query();
        }

        /// <summary>
        /// 删除任务
        /// </summary>
        /// <param name="obj"></param>
        private void DeleteTaskInfo(object obj)
        {
            string taskCode = obj as string;
            MessageBoxResult result = MessageBox.Show("货物是否已出库?", "出库确认", MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result == MessageBoxResult.Yes)
            {
                if (outStoreBusiness.DeleteTaskInfoByTaskCode(taskCode, true))
                {
                    MessageBox.Show("任务删除成功", "提示", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
                    Query();
                }
                else
                {
                    MessageBox.Show("任务删除失败", "提示", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
                }
            }
            else
            {
                if (outStoreBusiness.DeleteTaskInfoByTaskCode(taskCode, false))
                {
                    MessageBox.Show("任务删除成功", "提示", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
                    Query();
                }
                else
                {
                    MessageBox.Show("任务删除失败", "提示", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);
                }
            }

        }


    }
}