bbwy/BBWY.Client/ViewModels/PackTask/PackServiceViewModel.cs

using AutoMapper;
using AutoMapper.Internal;
using BBWY.Client.APIServices;
using BBWY.Client.Helpers;
using BBWY.Client.Models;
using BBWY.Client.Models.APIModel.Request;
using BBWY.Client.Models.APIModel.Response.PackTask;
using BBWY.Client.Models.PackTask;
using BBWY.Client.Views.PackTask;
using BBWY.Common.Models;
using GalaSoft.MvvmLight.Command;
using HandyControl.Controls;
using Microsoft.Extensions.Logging;
using NPOI.Util;
using Org.BouncyCastle.Asn1.Crmf;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Drawing.Printing;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Metadata.Ecma335;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media.Imaging;

namespace BBWY.Client.ViewModels.PackTask
{
    public class PackServiceViewModel : BaseVM, IDenpendency
    {

        private int? floorDragNumber;
        public int? FloorDragNumber { get => floorDragNumber; set { Set(ref floorDragNumber, value); } }

        private string packUserName;
        /// <summary>
        /// 打包人
        /// </summary>
        public string PackUserName { get => packUserName; set { Set(ref packUserName, value); } }


        private int incrementPartTaskCount;
        /// <summary>
        /// 配件任务数量
        /// </summary>
        public int IncrementPartTaskCount { get => incrementPartTaskCount; set { Set(ref incrementPartTaskCount, value); } }



        //public ObservableCollection<string> incrementPartCountList = new ObservableCollection<string>() {
        //"0","1","2","3","4件以上"
        //};

        //public ObservableCollection<string> IncrementPartCountList { get => incrementPartCountList; set { Set(ref incrementPartCountList, value); } }

        private int incrementPartCount;
        /// <summary>
        /// 配件数量
        /// </summary>
        public int IncrementPartCount { get => incrementPartCount; set { Set(ref incrementPartCount, value); } }

        private string directionalFees;
        /// <summary>
        /// 定向费用
        /// </summary>
        public string DirectionalFees { get => directionalFees; set { Set(ref directionalFees, value); } }


        private BitmapImage barcodeImage;
        /// <summary>
        /// 任务Id条形码
        /// </summary>
        public BitmapImage BarcodeImage { get => barcodeImage; set { Set(ref barcodeImage, value); } }

        private BitmapImage taskImage;
        /// <summary>
        /// 任务Id条形码
        /// </summary>
        public BitmapImage TaskImage { get => taskImage; set { Set(ref taskImage, value); } }

        private string printName;

        public string PrintName { get => printName; set { Set(ref printName, value); } }

        private ObservableCollection<string> printList;
        /// <summary>
        /// 打印机列表
        /// </summary>
        public ObservableCollection<string> PrintList { get => printList; set { Set(ref printList, value); } }

        private ObservableCollection<PackTaskModel> packTaskList;
        /// <summary>
        /// 动态数据表
        /// </summary>
        public ObservableCollection<PackTaskModel> PackTaskList { get => packTaskList; set { Set(ref packTaskList, value); } }


        private PackTaskModel packTaskModel;

        public PackTaskModel PackTaskModel { get => packTaskModel; set { Set(ref packTaskModel, value); } } //


        public ICommand AddPackServiceCommand { get; set; }

        public ICommand AddBasicPackServiceCommand { get; set; }

        public ICommand AddIncreateServiceCommand { get; set; }

        public ICommand AddConsumableCommand { get; set; }

        public ICommand UpLoadPackCommand { get; set; }

        public ICommand SetAllCountCommand { get; set; }


        public ICommand PrintCommand { get; set; }

        readonly PackTaskService packTaskService;
        readonly ConsumableService consumableService;
        readonly PackDetailService packDetailService;
        readonly BatchPurchaseService batchPurchaseService;
        private ObservableCollection<PackItemModel> increateList = new ObservableCollection<PackItemModel>();
        public ObservableCollection<PackItemModel> IncreateList { get => increateList; set { Set(ref increateList, value); } } //

        //private ObservableCollection<PackItemModel>
        // packList = new ObservableCollection<PackItemModel>();
        //public ObservableCollection<PackItemModel> PackList { get => packList; set { Set(ref packList, value); } } //

        private ObservableCollection<PackItemModel>
            consumableServiceList = new ObservableCollection<PackItemModel>();
        public ObservableCollection<PackItemModel> ConsumableServiceList { get => consumableServiceList; set { Set(ref consumableServiceList, value); } } //




        private ObservableCollection<PackItemModel> basicPackProcessList = new ObservableCollection<PackItemModel>();
        private ObservableCollection<PackItemModel> incrementProcessList = new ObservableCollection<PackItemModel>();
        /// <summary>
        ///增量工序
        /// </summary>
        public ObservableCollection<PackItemModel> IncrementProcessList { get => incrementProcessList; set { Set(ref incrementProcessList, value); } } //
        /// <summary>
        /// 基础包装工序
        /// </summary>
        public ObservableCollection<PackItemModel> BasicPackProcessList { get => basicPackProcessList; set { Set(ref basicPackProcessList, value); } }





        private string discount = "1";
        /// <summary>
        /// 折扣
        /// </summary>
        public string Discount { get => discount; set { Set(ref discount, value); } } //


        public ObservableCollection<PackServiceDTO> IncreateServiceList { get; set; } = new ObservableCollection<PackServiceDTO>();
        public ObservableCollection<PackUser> MemberList { get; set; } = new ObservableCollection<PackUser>();
        public ObservableCollection<ConsumableModel> ConsumableList { get; set; } = new ObservableCollection<ConsumableModel>();
        public ObservableCollection<PackServiceDTO> PackServiceList { get; set; } = new ObservableCollection<PackServiceDTO>();

        /// <summary>
        /// 基础包装服务项目列表
        /// </summary>
        public ObservableCollection<PackServiceDTO> BasicPackServiceList { get; set; } = new ObservableCollection<PackServiceDTO>();

        private readonly PackServiceService packServiceService;

        /// <summary>
        /// 加载原数据
        /// </summary>
        public List<PackItemModel> LoadList = new List<PackItemModel>();



        public void InitPrintList()
        {



            TaskImage = MyPrintHelper.GetBarcodeImage(TaskId.ToString(), 300, 60);

            BarcodeImage = MyPrintHelper.GetBarcodeImage(SkuId, 300, 60);


            PrintList = new ObservableCollection<string>();
            var printingNames = PrinterSettings.InstalledPrinters;//获取本机的打印机数据
            int index = -1;
            int selectIndex = 0;
            foreach (string name in printingNames)
            {
                if (name == "Microsoft XPS Document Writer" || name == "Microsoft Print to PDF" || name == "Fax")
                {
                    continue;
                }
                index++;
                if (name.Contains("Deli"))
                {
                    selectIndex = index;
                }
                PrintList.Add(name);
            }
            try
            {
                var applicationPath = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
                string printNames = Path.Combine(applicationPath, "printName.init");
                if (File.Exists(printNames))
                {
                    PrintName = File.ReadAllText(printNames);
                }
                else
                {
                    if (PrintList.Count > 0)
                    {
                        PrintName = PrintList[0].ToString();
                    }
                }
            }
            catch (Exception)
            {


            }

        }

        public PackServiceViewModel(PackTaskService packTaskService, ConsumableService consumableService, PackServiceService packServiceService, PackDetailService packDetailService, BatchPurchaseService batchPurchaseService)//, long taskId
        {
            //TaskId = taskId;
            this.consumableService = consumableService;
            this.packTaskService = packTaskService;
            this.packServiceService = packServiceService;
            this.packDetailService = packDetailService;
            this.batchPurchaseService = batchPurchaseService;


            AddIncreateServiceCommand = new RelayCommand(AddIncreateService);
            AddPackServiceCommand = new RelayCommand(AddPackService);
            AddBasicPackServiceCommand = new RelayCommand(AddBasicPackService);
            AddConsumableCommand = new RelayCommand(AddConsumable);
            UpLoadPackCommand = new RelayCommand<object>(UpLoadPack);
            SetAllCountCommand = new RelayCommand<object>(SetAllCount);

            //加载数据
            //LoadPackDatas();

        }

        /// <summary>
        /// 加载任务数据
        /// </summary>
        public void LoadPackDatas()
        {
            IncrementPartTaskCount = TaskCount;
            try
            {
                InitPrintList();
            }
            catch (Exception)
            {


            }

            LoadList = new List<PackItemModel>();
            Task task = Task.Factory.StartNew(() =>
            {
                var resMember = this.packTaskService.GetPackMembers();//成员表
                if (resMember.Success)
                {
                    MemberList = new ObservableCollection<PackUser>();
                    foreach (var item in resMember.Data)
                    {
                        App.Current.Dispatcher.Invoke(() =>
                        {
                            MemberList.Add(item);
                        });
                    }
                }
                var res = this.packDetailService.GetPackTaskDetail(TaskId);



                if (res.Success)
                {
                    IncrementPartCount = res.Data.IncrementPartCount == null ? 0 : res.Data.IncrementPartCount.Value;

                    if (res.Data != null && res.Data.IncrementItemList.Count() > 0)
                    {
                        IncreateServiceList = new ObservableCollection<PackServiceDTO>();
                        foreach (var packService in res.Data.IncrementItemList)
                        {
                            if (packService.ServiceType == ServiceType.增值服务)
                                App.Current.Dispatcher.Invoke(() =>
                                {
                                    IncreateServiceList.Add(packService);//加载增值服务列表
                                });

                        }
                    }

                    if (res.Data != null && res.Data.ProcessItemList.Count() > 0)
                    {
                        PackServiceList = new ObservableCollection<PackServiceDTO>();
                        BasicPackServiceList = new ObservableCollection<PackServiceDTO>();
                        foreach (var packService in res.Data.ProcessItemList)
                        {
                            if (packService.ServiceType == ServiceType.打包服务)

                                App.Current.Dispatcher.Invoke(() =>
                                {
                                    BasicPackServiceList.Add(packService);
                                    if (packService.Name != "贴条码")
                                        PackServiceList.Add(packService);//加载工序服务列表
                                  
                                });
                        }
                    }

                    if (res.Data != null && res.Data.ConsumableItemList.Count() > 0)
                    {
                        ConsumableList = new ObservableCollection<ConsumableModel>();
                        foreach (var item in res.Data.ConsumableItemList)
                        {

                            App.Current.Dispatcher.Invoke(() =>
                            {

                                ConsumableList.Add(new ConsumableModel(consumableService)
                                {
                                    Width = item.Width,
                                    Weigth = item.Weigth,
                                    Remark = item.Remark,
                                    Price = item.Price,
                                    Name = item.Name,
                                    Length = item.Length,
                                    Heigth = item.Heigth,
                                    Id = item.Id
                                });
                            });
                        }
                    }


                    if (res.Data.IncreateList != null)
                    {
                        IncreateList = new ObservableCollection<PackItemModel>();

                        foreach (var item in res.Data.IncreateList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                IncreateList.Add(new PackItemModel()
                                {
                                    MemberList = MemberList,
                                    IncreateServiceList = IncreateServiceList,
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,
                                    SelectUserId = item.SelectUserId,
                                    MemberName = item.MemberName

                                });
                            });
                        }

                    }
                    if (res.Data.ConsumableList != null)
                    {
                        ConsumableServiceList = new ObservableCollection<PackItemModel>();
                        foreach (var item in res.Data.ConsumableList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                ConsumableServiceList.Add(new PackItemModel()
                                {
                                    MemberList = MemberList,
                                    ConsumableList = ConsumableList,
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,


                                });
                            });
                        }
                    }


                    if (res.Data.IncrementProcessList != null)
                    {
                        IncrementProcessList = new ObservableCollection<PackItemModel>();
                        foreach (var item in res.Data.IncrementProcessList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                IncrementProcessList.Add(new PackItemModel()
                                {
                                    MemberList = MemberList,
                                    PackServiceList = PackServiceList.Copy(),
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,
                                    SelectUserId = item.SelectUserId,
                                    MemberName = item.MemberName

                                });
                            });
                        }
                    }

                    if (res.Data.BasicPackProcessList != null)
                    {
                        BasicPackProcessList = new ObservableCollection<PackItemModel>();
                        foreach (var item in res.Data.BasicPackProcessList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                BasicPackProcessList.Add(new PackItemModel()
                                {
                                    MemberList = MemberList,
                                    PackServiceList = BasicPackServiceList.Copy(),
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,
                                    SelectUserId = item.SelectUserId,
                                    MemberName = item.MemberName

                                });
                            });
                        }
                    }


                    LoadList.AddRange(IncreateList);
                    LoadList.AddRange(IncrementProcessList);
                    DirectionalFees = res.Data.DirectionalFees?.ToString();
                }
            });
        }

        /// <summary>
        /// 批量设置耗材数量
        /// </summary>
        /// <param name="obj"></param>
        private void SetAllCount(object obj)
        {

            SetCountWindow set = new SetCountWindow();
            set.SetCount = new Action<int>((s) =>
            {
                var lbox = obj as ListBox;
                var serviceList = lbox.ItemsSource as ObservableCollection<PackItemModel>;
                foreach (var item in serviceList)
                {
                    if (item.ItemName == null)
                    {
                        item.ItemName = ConsumableList.SingleOrDefault(c => c.Id == item.SelectId).Name;
                    }

                    item.ItemCount = s;
                }
                lbox.ItemsSource = serviceList;
            });
            set.Show();
        }

        private long taskId;
        public long TaskId { get => taskId; set { Set(ref taskId, value); } } //


        private int taskCount;
        public int TaskCount { get => taskCount; set { Set(ref taskCount, value); } } //
        public string OrderId { get; set; }
        public string SkuId { get; set; }



        private List<PackItemModel> IsOverCount(ObservableCollection<PackItemModel> packItemModels, bool needUserId = true)
        {


            List<PackItemModel> disItems = new List<PackItemModel>();

            foreach (var packItem in packItemModels)//增值服务上传
            {
                var item = new PackItemModel
                {
                    ItemCount = packItem.ItemCount,
                    SelectId = packItem.SelectId,
                    SelectUserId = packItem.SelectUserId,
                    ItemName = packItem.ItemName,
                    MemberName = packItem.MemberName
                };
                if (needUserId)
                    if (item.SelectId <= 0 || string.IsNullOrEmpty(item.SelectUserId) || item.ItemCount <= 0)
                    {
                        System.Windows.MessageBox.Show($"数据输入有误");
                        return null;
                    }
                    else
                 if (item.SelectId <= 0 || item.ItemCount <= 0)
                    {
                        System.Windows.MessageBox.Show($"数据输入有误");
                        return null;
                    }

                if (item.ItemCount > TaskCount)
                {
                    System.Windows.MessageBox.Show($"{item.ItemName}:{item.ItemCount}超出任务量{TaskCount}");
                    return null;
                }



                if (disItems.Select(a => a.SelectId).Contains(item.SelectId))//相同服务 存在累加
                {

                    var data = disItems.SingleOrDefault(a => a.SelectId == item.SelectId);

                    if (data != null) data.ItemCount += item.ItemCount;

                    if (data.ItemCount > TaskCount)//累积超出任务量
                    {
                        System.Windows.MessageBox.Show($"{item.ItemName}:{data.ItemCount}超出任务量{TaskCount}");
                        return null;
                    }

                    continue;
                }
                disItems.Add(item);
            }



            return disItems;
        }


        /// <summary>
        /// 上传数据   (判断是否超量)  统一上传
        /// </summary>
        private void UpLoadPack(object obj)
        {
            decimal? directFees = null;
            if (!string.IsNullOrEmpty(DirectionalFees))
            {
                try
                {
                    directFees = decimal.Parse(DirectionalFees);
                }
                catch (Exception)
                {

                    directFees = null;
                }

            }


            PackTaskDetailRequest packTaskDetail = new PackTaskDetailRequest();
            packTaskDetail.DirectionalFees = directFees;
            packTaskDetail.IncrementPartCount = IncrementPartCount;
            packTaskDetail.IncrementPartTaskCount = IncrementPartTaskCount;
            packTaskDetail.TaskId = TaskId;

            decimal IncreateFees = 0, PackFees = 0, ConsumableFees = 0, DiscountPrice = 0;

            var disIncreateList = IsOverCount(IncreateList);
            if (disIncreateList == null) return;

            var disBasicPackProcessList = IsOverCount(BasicPackProcessList);
            if (disBasicPackProcessList == null) return;

            if (disBasicPackProcessList.Select(d => d.SelectId).Distinct().Count() > 2)
            {
                System.Windows.MessageBox.Show("基础包装工序不能超过两道");
                return;
            }

            var disIncrementProcessList = IsOverCount(IncrementProcessList);
            if (disIncrementProcessList == null) return;


            if (disBasicPackProcessList.Select(d=>d.ItemName).Distinct().Count()==1&& disBasicPackProcessList.Select(d => d.ItemName).Contains("贴条码")
                && disIncrementProcessList.Count>0)
            {
                System.Windows.MessageBox.Show("只有一道贴码工序,无法添加增值包装工序");
                return;
            }





            var disConsumableServiceList = IsOverCount(ConsumableServiceList, false);
            if (disConsumableServiceList == null) return;

            packTaskDetail.IncreateList = IncreateList.ToList();
            packTaskDetail.BasicPackProcessList = BasicPackProcessList.ToList();
            packTaskDetail.IncrementProcessList = IncrementProcessList.ToList();
            packTaskDetail.ConsumableList = disConsumableServiceList;

            var res = packDetailService.SetPackTaskDetail(packTaskDetail);
            if (res != null && res.Success)
            {
                // new TipsWindow("上传成功!").Show();
                var win = obj as System.Windows.Window;
                if (SetAllFees != null)
                    SetAllFees();
                win.Close();
            }
        }
        /// <summary>
        /// 更新 打包员 和费用数据
        /// </summary>
        public Action SetAllFees { get; set; }

        private void AddPackService()
        {
            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                IncrementProcessList.Add(new PackItemModel()
                {
                    ItemCount = TaskCount,
                    MemberList = MemberList,
                    PackServiceList = PackServiceList,
                });
            }));

        }


        private void AddBasicPackService()
        {
            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                BasicPackProcessList.Add(new PackItemModel()
                {
                    ItemCount = TaskCount,
                    MemberList = MemberList,
                    PackServiceList = BasicPackServiceList,
                });
            }));

        }

        private void AddIncreateService()
        {
            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                IncreateList.Add(new PackItemModel()
                {
                    ItemCount = TaskCount,
                    IncreateServiceList = IncreateServiceList,
                    MemberList = MemberList,
                });
            }));


        }

        private void AddConsumable()
        {
            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                ConsumableServiceList.Add(new PackItemModel()
                {
                    ItemCount = TaskCount,
                    ConsumableList = ConsumableList
                });
            }));

        }
    }
}