TFT_PlcItemAutoTest/BlankApp1/BlankApp1/ViewModels/BasicConfigViewModel/DeviceKindViewModel.cs

using AutoMapper;
using BizService;
using BlankApp1.Events;
using Microsoft.Extensions.Logging;
using MiniExcelLibs;
using Model.Dto;
using Model.Entities;
using PLCTool.Common;
using PLCTool.Events;
using PLCTool.Models;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace PLCTool.ViewModels.BasicConfigViewModel
{
  

    public class DeviceKindViewModel : BindableBase
    {
        private readonly IBasicDeviceKindService _iBasicDeviceKindService;
        private readonly IMapper _mapper;
        private readonly IDialogService _dialog;
        private readonly ILogger _logger;
        private readonly IEventAggregator _aggregator;
        private List<BasDeviceKindDto> allDeviceKindList = new List<BasDeviceKindDto>();//所有方案
        private List<BasDeviceKindDto> conditionDeviceKind = new List<BasDeviceKindDto>();//符合条件的方案
        private List<CrumbViewModel> breadCrumbs = new List<CrumbViewModel>();
        public DeviceKindViewModel(IBasicDeviceKindService iBasicDeviceKindService, IMapper mapper,  IEventAggregator aggregator, IDialogService dialog, ILogger logger)
        {
            _iBasicDeviceKindService = iBasicDeviceKindService;
            _mapper = mapper;
            _dialog = dialog;
            _logger = logger;
            _aggregator=aggregator;
            QueryCommand = new DelegateCommand<object>(Query);
            AddCommand = new DelegateCommand<object>(Add);
            ExportCommand = new DelegateCommand<string>(Export);
            EditCommand = new DelegateCommand<object>(Edit);
            DeleteCommand = new DelegateCommand<object>(Delete);
            ResetCommand = new DelegateCommand<object>(Reset);
            OnLoadCommand = new DelegateCommand(OnLoad);
            GetPprojectConfig();
          
        }






        #region 私有方法
        private void OnLoad()
        {
            DeviceKindNameList.Clear();
            DeviceKindNameList.Add("---");
            var kinds = _iBasicDeviceKindService.FindAllDeviceKind();
            foreach(var kind in kinds)
            {
                DeviceKindNameList.Add(kind);
            }

            DeviceKindName = "---";
            //发布面包靴
            breadCrumbs.Clear();
            breadCrumbs.Add(new CrumbViewModel { Name = "基础设置" });
            breadCrumbs.Add(new CrumbViewModel { Name = "设备类型管理" });
            _aggregator.GetEvent<BreadEvent>().Publish(breadCrumbs);
            // DeviceKindNameList= _iBasicDeviceKindService.FindAllDeviceKind();
        }
        private void Reset(object obj)
        {
            DeviceKindNo = string.Empty;
            DeviceKindName = "---";
            StartTime = string.Empty;
            EndTime = string.Empty;

        }
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="obj"></param>
        private void Edit(object obj)
        {
            int id = Convert.ToInt32(obj);
            var finrProject = allDeviceKindList.FirstOrDefault(x => (x.DeviceKindId == id));
            DialogParameters parm = new DialogParameters();
            parm.Add("Key", finrProject);
            //蒙层显示
            _aggregator.GetEvent<MaskEvent>().Publish(true);
            //弹出详情对话框
            _dialog.ShowDialog("AddOrEditDeviceKindView", parm, async callback =>
            {
                if (callback.Result == ButtonResult.OK)
                {
                    BasDeviceKindDto returnValue = callback.Parameters.GetValue<BasDeviceKindDto>("ReturnValue");

                    if (returnValue != null)
                    {
                        //更新时间
                        returnValue.UpdateTime = DateTime.Now;
                        returnValue.UpdateBy = Appsession.UserName;
                        //创建时间
                        returnValue.CreateTime = finrProject.CreateTime;
                        returnValue.CreateBy = finrProject?.CreateBy;

                        var deviceKindCon = _mapper.Map<BasDeviceKindDto, bas_device_kind>(returnValue);
                        var findPlcs = allDeviceKindList.FindAll(x => (x.DeviceKindName == returnValue.DeviceKindName) || (x.DeviceKindNo == returnValue.DeviceKindNo));
                        foreach (var item in findPlcs)
                        {
                            if (item.DeviceKindId != id)
                            {
                                MessageBox.Show("已有此设备类型或编号，请更改名称！", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Warning);
                                return;
                            }
                        }

                        //修改
                        deviceKindCon.devicekind_id = id;
                        bool isSucc = _iBasicDeviceKindService.Edit(deviceKindCon);
                        if (isSucc)
                        {
                            //重新读取PLC
                            GetPprojectConfig();
                            _logger.LogInformation($"修改设备类型成功,类型为{deviceKindCon}");
                            SendLogToDis($"修改设备类型成功,类型为{deviceKindCon}");
                            MessageBox.Show("修改设备类型成功", "确认", MessageBoxButton.OK, MessageBoxImage.Information);
                        }
                    }
                }

            });
            //蒙层显示
            _aggregator.GetEvent<MaskEvent>().Publish(false);
        }

        private void Delete(object obj)
        {
            int id = Convert.ToInt32(obj);
            MessageBoxResult boxResult = MessageBox.Show("确认删除此条数据?", "确认", MessageBoxButton.OKCancel, MessageBoxImage.Question);
            if (boxResult == MessageBoxResult.OK)
            {
                var del = _iBasicDeviceKindService.Delete(id);
                if (del)
                {
                    SendLogToDis($"删除设备类型成功,id为{id}");
                    MessageBox.Show("删除成功!", "确认", MessageBoxButton.OK, MessageBoxImage.Information);
                    GetPprojectConfig();
                }

            }
        }

        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="obj"></param>
        private void Query(object obj)
        {
            if ((!string.IsNullOrEmpty(StartTime)) && (!string.IsNullOrEmpty(EndTime)))
            {
                if (Convert.ToDateTime(StartTime) > Convert.ToDateTime(EndTime))
                {
                    MessageBox.Show("起始时间大于结束时间，请重新输入", "确认", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }

            }
            conditionDeviceKind = (from a in allDeviceKindList
                                where ((DeviceKindName== "---") ? true : (a.DeviceKindName == DeviceKindName))
                                && (string.IsNullOrEmpty(DeviceKindNo) ? true : (a.DeviceKindNo == DeviceKindNo))
                                && (EndTime == string.Empty ? true : (a.CreateTime < Convert.ToDateTime(EndTime)) && (Convert.ToDateTime(StartTime) < a.CreateTime))
                                   select a).ToList();
            //默认显示的第一页
            conditionDeviceKind = conditionDeviceKind.OrderBy(x => x.DeviceKindId).ToList();
            Getpage();
        }

        private void Export(string obj)
        {
            using (System.Windows.Forms.SaveFileDialog saveFileDialog = new System.Windows.Forms.SaveFileDialog()
            {
                //设置文件类型
                //书写规则例如：txt files(*.txt)|*.txt
                Filter = "Excel files(*.xlsx)|*.xlsx|All files(*.*)|*.*",
                //设置默认文件名（可以不设置）
                FileName = "项目配置表",

                //获取或设置一个值，该值指示如果用户省略扩展名，文件对话框是否自动在文件名中添加扩展名。（可以不设置）
                AddExtension = true,

                //保存对话框是否记忆上次打开的目录
                RestoreDirectory = true
            })
            {
                // Show save file dialog box

                //点了保存按钮进入
                if (saveFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    try
                    {
                        //获得文件路径
                        string localFilePath = saveFileDialog.FileName.ToString();

                        //获取文件内容
                        MiniExcel.SaveAs(localFilePath, DeviceKindItemList);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex.ToString());
                    }


                }

            }
        }
        /// <summary>
        /// 添加PLC变量
        /// </summary>
        /// <param name="obj"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Add(object obj)
        {
            //蒙层显示
            _aggregator.GetEvent<MaskEvent>().Publish(true);
            //弹出详情对话框
            _dialog.ShowDialog("AddOrEditDeviceKindView", async callback =>
            {
                if (callback.Result == ButtonResult.OK)
                {
                    BasDeviceKindDto returnValue = callback.Parameters.GetValue<BasDeviceKindDto>("ReturnValue");
                    if (returnValue != null)
                    {
                        returnValue.CreateTime = DateTime.Now;
                        returnValue.CreateBy = Appsession.UserName;
                        returnValue.UpdateTime = DateTime.Now;
                        returnValue.UpdateBy = Appsession.UserName;
                        var deviceKindCon = _mapper.Map<BasDeviceKindDto, bas_device_kind>(returnValue);
                        var findPlc = allDeviceKindList.FirstOrDefault(x => (x.DeviceKindName == returnValue.DeviceKindName) || (x.DeviceKindNo == returnValue.DeviceKindNo));
                        if (findPlc != null)
                        {
                            MessageBox.Show("已有此设备类型名称或编号，请更改！", "提示", MessageBoxButton.OKCancel, MessageBoxImage.Warning);
                            return;
                        }
                        bool isSucc = _iBasicDeviceKindService.Add(deviceKindCon);
                        if (isSucc)
                        {
                            //重新读取PLC
                            GetPprojectConfig();
                            _logger.LogInformation($"添加设备类型成功,类型为{deviceKindCon}");
                            SendLogToDis($"添加设备类型成功,类型为{deviceKindCon}");
                            MessageBox.Show("添加设备类型成功！", "确认", MessageBoxButton.OK, MessageBoxImage.Information);
                        }
                    }
                }

            });
            //蒙层显示
            _aggregator.GetEvent<MaskEvent>().Publish(false);
        }
        /// <summary>
        /// 获取所有项目
        /// </summary>
        private void GetPprojectConfig()
        {
            allDeviceKindList.Clear();
            conditionDeviceKind.Clear();
            var projectlist = _iBasicDeviceKindService.QueryList();
            var allDeviceKinds = _mapper.Map<List<bas_device_kind>, List<BasDeviceKindDto>>(projectlist);
            foreach (var plc in allDeviceKinds)
            {
                allDeviceKindList.Add(plc);
                conditionDeviceKind.Add(plc);
            }
            conditionDeviceKind = conditionDeviceKind.OrderBy(x => x.DeviceKindId).ToList();
            Getpage();
        }
        /// <summary>
        /// 获取页面
        /// </summary>
        private void Getpage()
        {
            CurrentPage = 1;
            TotalCount = conditionDeviceKind.Count;
            CurrentPageChanged();


        }
        /// <summary>
        /// 页面变化
        /// </summary>
        private void CurrentPageChanged()
        {

            DeviceKindItemList.Clear();

            foreach (var i in conditionDeviceKind.Skip((CurrentPage - 1) * CountPerPage).Take(CountPerPage))
            {
                DeviceKindItemList.Add(i);
            }
        }
        /// <summary>
        /// 发送log之界面显示
        /// </summary>
        /// <param name="msg"></param>
        private void SendLogToDis(string msg)
        {
            _aggregator.GetEvent<LogEvent>().Publish(new LogMessage
            {
                LogTime = DateTime.Now,
                LogMsg = msg
            });
        }

        #endregion
        #region 命令绑定

        public DelegateCommand<object> QueryCommand { set; get; }
        public DelegateCommand<object> AddCommand { set; get; }
        public DelegateCommand<string> ExportCommand { set; get; }

        /// <summary>
        /// 表格删除
        /// </summary>
        public DelegateCommand<Object> DeleteCommand { set; get; }
        /// <summary>
        /// 表格编辑按钮
        /// </summary>
        public DelegateCommand<Object> EditCommand { set; get; }
        public DelegateCommand<object> ResetCommand { set; get; }

        public DelegateCommand OnLoadCommand { set; get; }
        #endregion

        #region 数据绑定
        private ObservableCollection<BasDeviceKindDto> deviceKindItemList = new ObservableCollection<BasDeviceKindDto>();
        public ObservableCollection<BasDeviceKindDto> DeviceKindItemList
        {
            get { return deviceKindItemList; }
            set { deviceKindItemList = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 设备类型编号
        /// </summary>
        private string deviceKindNo;
        public string DeviceKindNo
        {
            get { return deviceKindNo; }
            set { deviceKindNo = value; RaisePropertyChanged(); }
        }

        /// <summary>
        /// 设备类型名称
        /// </summary>
        private string deviceKindName;
        public string DeviceKindName
        {
            get { return deviceKindName; }
            set { deviceKindName = value; RaisePropertyChanged(); }
        }
        /// <summary>
        /// 设备类型
        /// </summary>
        private ObservableCollection<string> deviceKindNameList=new ObservableCollection<string>();
        public ObservableCollection<string> DeviceKindNameList
        {
            get { return deviceKindNameList; }
            set { deviceKindNameList = value; RaisePropertyChanged(); }
        }
  
        /// <summary>
        /// 开始时间
        /// </summary>
        private string startTime = DateTime.Now.AddDays(-1).ToString();
        public string StartTime
        {
            get { return startTime; }
            set { startTime = value; RaisePropertyChanged(); }
        }
        private string endTime = DateTime.Now.ToString();
        public string EndTime
        {
            get { return endTime; }
            set { endTime = value; RaisePropertyChanged(); }
        }
        /// <summary>
        /// 总条数
        /// </summary>
        private int totalCount;
        public int TotalCount
        {
            get { return totalCount; }
            set { totalCount = value; RaisePropertyChanged(); CurrentPageChanged(); }
        }
        /// <summary>
        /// 每页数量
        /// </summary>
        private int countPerPage = 15;
        public int CountPerPage
        {
            get { return countPerPage; }
            set { countPerPage = value; RaisePropertyChanged(); CurrentPageChanged(); }
        }
        /// <summary>
        /// 单前页
        /// </summary>
        private int currentPage = 1;
        public int CurrentPage
        {
            get { return currentPage; }
            set { currentPage = value; RaisePropertyChanged(); CurrentPageChanged(); }
        }

        #endregion
    }
}