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

using BBWY.Client.APIServices.QiKu;
using BBWY.Client.APIServices;
using BBWY.Client.Helpers;
using BBWY.Client.Models.APIModel.Response.PackTask;
using BBWY.Client.Models.PackTask;
using BBWY.Client.Models;
using BBWY.Client.Views.PackTask;
using GalaSoft.MvvmLight.Command;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing.Printing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using WebSocketSharp;
using System.IO;
using BBWY.Client.Models.APIModel;
using Org.BouncyCastle.Bcpg;
using System.Threading;

namespace BBWY.Client.ViewModels.PackTask
{
    public class PackDetailViewModel : BaseVM
    {

        private PackProcessType packProcessType;
        /// <summary>
        /// 推荐工序=0,自定义工序=1
        /// </summary>
        public PackProcessType PackProcessType { get => packProcessType; set { Set(ref packProcessType, value); } }

        private decimal allFees;
        /// <summary>
        /// 任务总费用
        /// </summary>
        public decimal AllFees { get => allFees; set { Set(ref allFees, value); } }


        private decimal processPrice;
        /// <summary>
        /// 工序单价
        /// </summary>
        public decimal ProcessPrice { get => processPrice; set { Set(ref processPrice, value); } }

        private decimal consumableFees;
        /// <summary>
        /// 耗材费用
        /// </summary>
        public decimal ConsumableFees { get => consumableFees; set { Set(ref consumableFees, value); } }

        public ObservableCollection<PackUserModel> packUserModelList;
        public ObservableCollection<PackUserModel> PackUserModelList { get => packUserModelList; set { Set(ref packUserModelList, value); } }



        // private decimal? customProcessSinglePrice;
        /// <summary>
        /// 定制工序单价
        /// </summary>
        public decimal? CustomProcessSinglePrice
        {
            get; set;
        }

        private string directionalSingleFees;

        public string DirectionalSingleFees
        {
            get => directionalSingleFees; set
            {

                Set(ref directionalSingleFees, value);
                try
                {
                    CustomProcessSinglePrice = decimal.Parse(DirectionalSingleFees);
                }
                catch
                {
                    CustomProcessSinglePrice = null;
                }

            }
        }



        private decimal packFees;
        /// <summary>
        /// 打包原价
        /// </summary>
        public decimal PackFees { get => packFees; set { Set(ref packFees, value); } }

        private decimal discountFactory;
        /// <summary>
        /// 折扣系数
        /// </summary>
        public decimal DiscountFactory { get => discountFactory; set { Set(ref discountFactory, value); } }

        private decimal packDiscountFees;
        /// <summary>
        /// 打包折后价价
        /// </summary>
        public decimal PackDiscountFees { get => packDiscountFees; set { Set(ref packDiscountFees, value); } }



        private int processTaskCount;
        /// <summary>
        /// 工序任务量
        /// </summary>
        public int ProcessTaskCount
        {
            get => processTaskCount; set
            {
                Set(ref processTaskCount, value);
                OnProcessTypeChanged(SelectProcessType, 1);
            }
        }

        void OnProcessTaskCountChanged()
        {
            PackFees = decimal.Parse((ProcessTaskCount * ProcessPrice).ToString("0.00")); ;
            PackDiscountFees = decimal.Parse((PackFees * DiscountFactory).ToString("0.00"));
        }


        private List<ProcessComboModel> processComboList;
        /// <summary>
        /// 套餐类型列表
        /// </summary>
        public List<ProcessComboModel> ProcessComboList { get => processComboList; set { Set(ref processComboList, value); } }



        private long selectProcessComboId;
        /// <summary>
        /// 选中套餐类型
        /// </summary>
        public long SelectProcessComboId
        {
            get => selectProcessComboId; set
            {
                Set(ref selectProcessComboId, value);

                OnProcessComboChanged(SelectProcessComboId);
            }
        }
        public bool isConsumableTypeListEnable;
        public bool IsConsumableTypeListEnable { get => isConsumableTypeListEnable; set { Set(ref isConsumableTypeListEnable, value); } }
        private void OnProcessComboChanged(long SelectProcessComboId)
        {
            if (SelectProcessComboId <= 0)
            {
                return;
            }

            var selectProcessComboData = ProcessTypeResponseList.SingleOrDefault(p => p.ProcessTypeName == SelectProcessType).ProcessComboList.
                 SingleOrDefault(p => p.ProcessComboId == SelectProcessComboId);
            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                ConsumableServiceList.Clear();
            }));
            IsConsumableTypeListEnable = false;
            if (SelectProcessType == "定制")
            {
                IsConsumableTypeListEnable = true;

                ConsumableServiceList = new ObservableCollection<PackItemModel>();


            }
            ConsumableFees = 0;
            AllFees = ConsumableFees + PackDiscountFees;
            if (selectProcessComboData != null && selectProcessComboData.ConsumableTypeList != null && selectProcessComboData.ConsumableTypeList.Count > 0)//自动添加列表
            {

                foreach (var item in selectProcessComboData.ConsumableTypeList)
                {
                    App.Current.Dispatcher.Invoke(new Action(() =>
                    {

                        ConsumableServiceList.Add(new PackItemModel
                        {
                            ConsumableTypeList = new ObservableCollection<string> { item.ConsumableTypeName },
                            ConsumableType = item.ConsumableTypeName,
                            ConsumableItemList = item.ConsumableList,
                            //ConsumableItem = item.ConsumableList.FirstOrDefault()?.ConsumableName,
                            //ConsumablePrice = item.ConsumableList.FirstOrDefault().ConsumablePrice,
                            TaskCount = ProcessTaskCount,
                            TotalConsumableFees = ToTalConsumableFees,
                        }); ;
                    }));
                }

            }


        }

        private List<string> processTypeList;
        /// <summary>
        /// 工序类型列表
        /// </summary>
        public List<string> ProcessTypeList { get => processTypeList; set { Set(ref processTypeList, value); } }


        private string selectProcessType;
        /// <summary>
        /// 选中工序类型
        /// </summary>
        public string SelectProcessType
        {
            get => selectProcessType; set
            {
                Set(ref selectProcessType, value);
                OnProcessTypeChanged(SelectProcessType);
            }
        }
        private void OnProcessTypeChanged(string SelectProcessType, int isTaskCount = 0)
        {
            if (isTaskCount == 0)
            {
                if (ProcessTypeResponseList == null || ProcessTypeResponseList.Count <= 0 || SelectProcessType == null) return;
                var processTypeData = ProcessTypeResponseList.SingleOrDefault(p => p.ProcessTypeName == SelectProcessType);
                App.Current.Dispatcher.Invoke(new Action(() =>
                {
                    ProcessPrice = processTypeData.ProcessTypePrice;
                    ProcessComboList = processTypeData.ProcessComboList.Select(p => new ProcessComboModel { ProcessComboId = p.ProcessComboId, ProcessComboName = p.ProcessComboName }).ToList();
                }));

            }

            var discountRes = processService.GetDiscountFactory(SelectProcessType, ProcessTaskCount);
            if (!discountRes.Success)
            {
                System.Windows.MessageBox.Show(discountRes.Msg);
                return;
            }

            if (discountRes.Success && discountRes.Data != null)
            {
                DiscountFactory = discountRes.Data.DiscountFactory;
                if (FeesMode == FeesMode.定向收费 && CustomProcessSinglePrice != null)
                {
                    PackFees = decimal.Parse((ProcessTaskCount * CustomProcessSinglePrice.Value).ToString("0.00"));
                }
                else
                {
                    FeesMode = discountRes.Data.FeesMode;
                    PackFees = decimal.Parse((ProcessTaskCount * ProcessPrice).ToString("0.00"));
                }



                PackDiscountFees = decimal.Parse((PackFees * DiscountFactory).ToString("0.00"));
                AllFees = ConsumableFees + PackDiscountFees;
            }
            //统计打包费用
        }

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

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


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


        /// <summary>
        /// 添加打包人
        /// </summary>
        public ICommand AddPackUserCommand { get; set; }

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

        public ICommand SetCustomProcessPriceCommand { get; set; }
        readonly PackTaskService packTaskService;
        readonly PackDetailService packDetailService;
        readonly ProcessService processService;
        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>();



        /// <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 PackDetailViewModel(PackTaskService packTaskService,  PackDetailService packDetailService, ProcessService processService)//, long taskId
        {
            this.processService = processService;
            this.packTaskService = packTaskService;
            this.packDetailService = packDetailService;
            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);
            SetCustomProcessPriceCommand = new RelayCommand(SetCustomProcessPrice);
            AddPackUserCommand = new RelayCommand(AddPackUser);
            PackUserModelList = new ObservableCollection<PackUserModel>();
        }

        private void AddPackUser()
        {

            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                PackUserModelList.Add(new PackUserModel()
                {
                    TaskCount = ProcessTaskCount,
                    MemberList = MemberList,
                });
            }));
        }

        /// <summary>
        /// 所有的耗材类型
        /// </summary>
        public List<ConsumableTypeResponse> ConsumableTypeList { get; set; }
        /// <summary>
        /// 设置定制工序单价
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void SetCustomProcessPrice()
        {
            if (CustomProcessSinglePrice == null)
            {
                OnProcessTypeChanged(SelectProcessType, 1);
                return;
            }
            if (SelectProcessType != "定制")
            {
                SelectProcessType = "定制";
                SelectProcessComboId = ProcessComboList.FirstOrDefault().ProcessComboId;
            }
            FeesMode = FeesMode.定向收费;
            PackFees = decimal.Parse((ProcessTaskCount * CustomProcessSinglePrice.Value).ToString("0.00")); ;
            PackDiscountFees = decimal.Parse((PackFees * DiscountFactory).ToString("0.00"));
            AllFees = ConsumableFees + PackDiscountFees;


        }
        private List<ProcessTypeResponse> ProcessTypeResponseList { get; set; }
        /// <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.processService.GetProcessTypeList();
                if (!res.Success)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {

                        MessageBox.Show(res.Msg);
                    });
                }
                ProcessTaskCount = TaskCount;
                if (res.Success && res.Data != null)
                {
                    ProcessTypeResponseList = res.Data.ProcessTypeList;
                    ConsumableTypeList = res.Data.ConsumableTypeList;
                    App.Current.Dispatcher.Invoke(() =>
                    {
                        ProcessTypeList = ProcessTypeResponseList.Select(p => p.ProcessTypeName).Distinct().ToList();
                    });

                }

                var packDetailRes = packDetailService.GetPackDetail(TaskId);

                if (!packDetailRes.Success)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {
                        MessageBox.Show(packDetailRes.Msg);
                    });
                }
                if (packDetailRes.Success && packDetailRes.Data != null)
                {
                    var resData = packDetailRes.Data;

                    SuggestPackUserName = resData.SuggestPackUserName;
                    SelectProcessType = resData.ProcessTypeName;
                    SelectProcessComboId = resData.ProcessComboId;
                    TaskCount = resData.ProcessTaskCount;
                    DirectionalSingleFees = resData.DirectionalSingleFees?.ToString();
                    if (resData.DirectionalSingleFees>0)
                    {
                        SetCustomProcessPrice();
                    }
                    if (resData.PackUserList != null && resData.PackUserList.Count > 0)
                    {
                        foreach (var packuser in resData.PackUserList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                PackUserModelList.Add(new PackUserModel
                                {
                                    MemberList = MemberList,
                                    SelectUserId = packuser.UserId,
                                    TaskCount = packuser.TaskCount
                                });
                            });

                        }

                    }
                    if (resData.ConsumableList != null && resData.ConsumableList.Count > 0)
                    {

                        if (ConsumableServiceList != null && ConsumableServiceList.Count > 0)
                        {
                            foreach (var con in resData.ConsumableList)
                            {
                                var condate = ConsumableServiceList.FirstOrDefault(c => c.ConsumableItem.IsNullOrEmpty() && c.ConsumableType == con.ConsumableTypeName);
                                App.Current.Dispatcher.Invoke(() =>
                                {
                                    condate.ConsumablePrice = con.ConsumablePrice;
                                    condate.SelectId = con.ConsumableId;
                                    condate.TaskCount = con.TaskCount;

                                });

                            }
                        }
                        else
                        {
                            ObservableCollection<string> consumableTypeList = new ObservableCollection<string>();

                            foreach (var item in ConsumableTypeList)
                            {
                                consumableTypeList.Add(item.ConsumableTypeName);
                            }


                            foreach (var con in resData.ConsumableList)
                            {


                                App.Current.Dispatcher.Invoke(new Action(() =>
                                {
                                    ConsumableServiceList.Add(new PackItemModel()
                                    {
                                        ItemCount = TaskCount,
                                        ConsumableList = ConsumableList,
                                        ConsumableTypeList = consumableTypeList,
                                        AllConsumableTypeList = ConsumableTypeList,
                                        ConsumableType = con.ConsumableTypeName,
                                        ConsumablePrice = con.ConsumablePrice,
                                        SelectId = con.ConsumableId,
                                        TaskCount = con.TaskCount,
                                        TotalConsumableFees = ToTalConsumableFees


                                    });
                                }));

                            }


                        }



                    }
                }


            });
        }

        private void ToTalConsumableFees()
        {

            App.Current.Dispatcher.Invoke(new Action(() =>
            {
                ConsumableFees = ConsumableServiceList.Select(c => c.ConsumablePrice * c.TaskCount).Sum();
                AllFees = ConsumableFees + PackDiscountFees;
            }));

        }

        /// <summary>
        /// 批量设置耗材数量
        /// </summary>
        /// <param name="obj"></param>
        private void SetAllCount(object obj)
        {
            if (ConsumableServiceList == null || ConsumableServiceList.Count <= 0)
            {
                return;
            }

            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.ConsumableItem == null)
                    {
                        item.ConsumableItem = ConsumableServiceList.Select(c => c.ConsumableList).FirstOrDefault()?.Where(c => c.Id == item.SelectId).FirstOrDefault()?.Name;
                    }

                    item.TaskCount = 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>
        public FeesMode FeesMode { get; set; }
        /// <summary>
        /// 上传数据   (判断是否超量)  统一上传
        /// </summary>
        private void UpLoadPack(object obj)
        {
            if (ProcessTaskCount > TaskCount)
            {
                System.Windows.MessageBox.Show($"工序任务数:{ProcessTaskCount}不能超过打包总任务数:{TaskCount}");
                return;
            }

            if (PackUserModelList != null && PackUserModelList.Count > 0)
            {
                if (PackUserModelList.Any(p => p.SelectUserId.IsNullOrEmpty() || p.TaskCount <= 0))
                {
                    System.Windows.MessageBox.Show("信息不完整,打包人设置有误");
                    return;
                }

                var totalPackTaskCount = PackUserModelList.Select(p => p.TaskCount).Sum();
                if (totalPackTaskCount != ProcessTaskCount)
                {
                    System.Windows.MessageBox.Show($"工序任务总量:{ProcessTaskCount},与打包人任务总量:{totalPackTaskCount} 不相等.");
                    return;
                }

                if (PackUserModelList.Select(p => p.SelectUserId).Distinct().Count() != PackUserModelList.Count())
                {
                    System.Windows.MessageBox.Show($"请勿重复设置打包人任务.");
                    return;
                }

            }


            if (ConsumableServiceList != null && ConsumableServiceList.Count > 0)
            {
                if (ConsumableServiceList.Any(p => p.SelectId == null || p.TaskCount <= 0))
                {
                    System.Windows.MessageBox.Show("信息不完整,耗材设置有误");
                    return;
                }
                foreach (var item in ConsumableServiceList)
                {
                    if (item.TaskCount > ProcessTaskCount)
                    {
                        System.Windows.MessageBox.Show($"耗材分类:{item.ConsumableType}下,任务量:{item.TaskCount} 不能超过工序任务总量:{ProcessTaskCount}.");
                        return;
                    }
                }



            }
            if (CustomProcessSinglePrice != null)
            {
                FeesMode = FeesMode.定向收费;
            }

            SetPackDetailRequest setPackDetailRequest = new SetPackDetailRequest()
            {
                DirectionalSingleFees = CustomProcessSinglePrice,
                FeesMode = FeesMode,
                AllFees = AllFees,
                ConsumableFees = ConsumableFees,
                TaskId = TaskId,
                PackUserList = PackUserModelList?.Select(p => new PackUserModelRequest { TaskCount = p.TaskCount, UserId = p.SelectUserId }).ToList(),
                ConsumableList = ConsumableServiceList?.Select(c => new ConsumableRequest { ConsumableId = c.SelectId.Value, TaskCount = c.TaskCount, ConsumableTypeName = c.ConsumableType, ConsumablePrice = c.ConsumablePrice }).ToList(),
                DiscountFactory = DiscountFactory,
                PackDiscountPrice = PackDiscountFees,
                PackPrice = PackFees,
                ProcessComboCount = ProcessTaskCount,
                ProcessComboId = SelectProcessComboId,
                ProcessTypeName = SelectProcessType

            };
            var res = packDetailService.SetPackDetail(setPackDetailRequest);

            if (res == null)
            {
                System.Windows.MessageBox.Show("网络异常!");
                return;
            }
            if (!res.Success)
            {
                System.Windows.MessageBox.Show(res.Msg);
                return;
            }


            // new TipsWindow("上传成功!").Show();
            var win = obj as System.Windows.Window;
            if (ReflashWindow != null)
                ReflashWindow();
            win.Close();

        }
        /// <summary>
        /// 刷新界面
        /// </summary>
        public Action ReflashWindow { 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()
        {

            ObservableCollection<string> consumableTypeList = new ObservableCollection<string>();

            foreach (var item in ConsumableTypeList)
            {
                consumableTypeList.Add(item.ConsumableTypeName);
            }

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




                ConsumableServiceList.Add(new PackItemModel()
                {
                    TaskCount = ProcessTaskCount,
                    ConsumableTypeList = consumableTypeList,
                    AllConsumableTypeList = ConsumableTypeList,
                     TotalConsumableFees=ToTalConsumableFees


                });
            }));

        }
    }
}