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

using AutoMapper;
using AutoMapper.Internal;
using BBWY.Client.APIServices;
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 Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection.Metadata.Ecma335;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;

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




        public ICommand AddPackServiceCommand { get; set; }

        public ICommand AddIncreateServiceCommand { get; set; }

        public ICommand AddConsumableCommand { get; set; }

        public ICommand UpLoadPackCommand { get; set; }

        public ICommand SetAllCountCommand { get; set; }

        readonly PackTaskService packTaskService;
        readonly ConsumableService consumableService;
        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); } } //



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


        readonly WorkProcessService workProcessService;
        readonly IncreateServiceService increateService;
        public PackServiceViewModel(PackTaskService packTaskService, ConsumableService consumableService, WorkProcessService workProcessService, IncreateServiceService increateService)//, long taskId
        {
            //TaskId = taskId;
            this.consumableService = consumableService;
            this.packTaskService = packTaskService;
            this.workProcessService = workProcessService;
            this.increateService = increateService;




            var increateRes = this.increateService.SearchAll();
            if (increateRes.Success)
            {
                if (increateRes.Data != null && increateRes.Data.Count() > 0)
                {
                    foreach (var workProcess in increateRes.Data)
                    {
                        App.Current.Dispatcher.Invoke(() =>
                        {
                            IncreateServiceList.Add(workProcess);//加载增值服务列表
                        });

                    }
                }
            }

            var result = this.workProcessService.SearchAll();
            if (result.Success)
            {
                if (result.Data != null && result.Data.Count() > 0)
                {
                    foreach (var workProcess in result.Data)
                    {
                        App.Current.Dispatcher.Invoke(() =>
                        {
                            PackServiceList.Add(workProcess);//加载工序服务列表
                        });

                    }
                }
            }

            var res = this.packTaskService.GetPackMembers();
            if (res.Success)
            {
                foreach (var item in res.Data)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {
                        MemberList.Add(item);
                    });

                }

            }



            var conRes = this.consumableService.SearchAll();
            if (conRes.Success)
            {
                foreach (var item in conRes.Data)
                {
                    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
                        });
                    });
                }

            }



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



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

        }
        
        /// <summary>
        /// 加载任务数据
        /// </summary>
        public void LoadPackDatas()
        {
            Task task = Task.Factory.StartNew(() =>
            {
                var res = this.packTaskService.GetTaskService(TaskId);
                if (res.Success)
                {
                    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.PackList != null)
                    {
                        PackList = new ObservableCollection<PackItemModel>();
                        foreach (var item in res.Data.PackList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                PackList.Add(new PackItemModel()
                                {
                                    PackServiceList= PackServiceList,
                                    MemberList =MemberList,
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,
                                    SelectUserId = item.SelectUserId,
                                    MemberName = item.MemberName

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

                                });
                            });
                        }
                    }
                }

            });
        }

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

        //private string selectBox;
        ///// <summary>
        ///// 箱子类型
        ///// </summary>
        //public string SelectBox { get => selectBox; set { Set(ref selectBox, value); } }


        //private int boxCount;
        ///// <summary>
        ///// 箱子数
        ///// </summary>
        //public int BoxCount { get => boxCount; set { Set(ref boxCount, value); } }
        //private int airPaperWidth;
        ///// <summary>
        ///// 气泡宽
        ///// </summary>
        //public int AirPaperWidth { get => airPaperWidth; set { Set(ref airPaperWidth, value); } }

        //private decimal airPaperHeigth;
        ///// <summary>
        ///// 气泡长
        ///// </summary>
        //public decimal AirPaperHeigth { get => airPaperHeigth; set { Set(ref airPaperHeigth, value); } }

        //private string selectMemberId;
        //public string SelectMemberId { get => selectMemberId; set { Set(ref selectMemberId, value); } }

        //private decimal jiaoDai;
        //public decimal JiaoDai { get => jiaoDai; set { Set(ref jiaoDai, value); } }

        /// <summary>
        /// 上传数据   (判断是否超量)  统一上传
        /// </summary>
        private void UpLoadPack(object obj)
        {
            UploadServiceRequest uploadService = new UploadServiceRequest();
            uploadService.TaskId = TaskId;
            List<IncreateMemberModel> increateMembers = new List<IncreateMemberModel>();
            List<ProcessMemberModel> processMembers = new List<ProcessMemberModel>();
            //  List<ConsumableTaskModel> consumableTasks = new List<ConsumableTaskModel>();

            List<PersonTaskModel> PersonTaskModels = new List<PersonTaskModel>();

            List<IncreateMemberModel> allIncreateMembers = new List<IncreateMemberModel>();//所有数据数量不能超过总数据
            List<ProcessMemberModel> allProcessMembers = new List<ProcessMemberModel>();
            List<ConsumableTaskModel> allConsumableTasks = new List<ConsumableTaskModel>();
            FeesItemResponse feesItem = new FeesItemResponse(); ;

            //获取打包人员
            List<string> packUsers = new List<string>();

            decimal singleFees = 0;
            decimal AllFees = 0;
            decimal price = 0;
            foreach (var item in IncreateList)//增值服务上传
            {
                if (item.SelectId <= 0 || string.IsNullOrEmpty(item.SelectUserId) || item.ItemCount <= 0)
                {
                    new TipsWindow($"数据输入有误").Show();
                    return;
                }
                var member = MemberList.SingleOrDefault(m => m.Id == item.SelectUserId);
                if (member != null && !packUsers.Contains(member.UserName))
                {
                    packUsers.Add(member.UserName);
                }

                if (item.ItemCount > TaskCount)
                {
                    new TipsWindow($"{item.ItemName}:{item.ItemCount}超出任务量{TaskCount}").Show();
                    return;
                }
                price = IncreateServiceList.First(i => i.Id == item.SelectId).ServicePrice;
                singleFees += price;
                AllFees += item.ItemCount * price;




                if (allIncreateMembers.Select(a => a.IncreateId).Contains(item.SelectId))//相同服务 存在累加
                {
                    var inMembers = increateMembers.SingleOrDefault(a => a.UserId == item.SelectUserId && a.IncreateId == item.SelectId);
                    if (inMembers != null)
                        inMembers.IncreateCount += item.ItemCount;



                    var data = allIncreateMembers.SingleOrDefault(a => a.IncreateId == item.SelectId);
                    var feeItem = feesItem.ServiceList.SingleOrDefault(f => f.ItemName == item.ItemName);
                    if (data != null) data.IncreateCount += item.ItemCount;
                    if (feeItem != null) feeItem.ItemCount += item.ItemCount;
                    if (data.IncreateCount > TaskCount)//累积超出任务量
                    {
                        new TipsWindow($"{item.ItemName}:{data.IncreateCount}超出任务量{TaskCount}").Show();
                        return;
                    }

                    continue;
                }

                increateMembers.Add(new IncreateMemberModel
                {
                    UserId = item.SelectUserId,
                    IncreateCount = item.ItemCount,
                    IncreateId = item.SelectId,
                    Price = price
                });


                feesItem.ServiceList.Add(new ServiceItemResponse
                {
                    ServiceType = ServiceType.增值服务,
                    ItemCount = item.ItemCount,
                    ItemName = item.ItemName,
                    ItemPrice = price
                });
                allIncreateMembers.Add(new IncreateMemberModel
                {
                    UserId = item.SelectUserId,
                    IncreateCount = item.ItemCount,
                    IncreateId = item.SelectId
                });
            }

            foreach (var item in PackList)//打包服务
            {
                if (item.SelectId <= 0 || string.IsNullOrEmpty(item.SelectUserId) || item.ItemCount <= 0)
                {
                    new TipsWindow($"数据输入有误").Show();
                    return;
                }
                if (item.ItemCount > TaskCount)
                {
                    new TipsWindow($"{item.ItemName}:{item.ItemCount}超出任务量{TaskCount}").Show();
                    return;
                }
                var member = MemberList.SingleOrDefault(m => m.Id == item.SelectUserId);
                if (member != null && !packUsers.Contains(member.UserName))
                {
                    packUsers.Add(member.UserName);
                }


                price = PackServiceList.First(i => i.Id == item.SelectId).ProcessPrice;
                singleFees += price;
                AllFees += item.ItemCount * price;

                if (allProcessMembers.Select(a => a.ProcessId).Contains(item.SelectId))//存在累加
                {
                    var inMembers = processMembers.SingleOrDefault(a => a.UserId == item.SelectUserId && a.ProcessId == item.SelectId);
                    if (inMembers != null)
                        inMembers.ProcessCount += item.ItemCount;


                    var data = allProcessMembers.SingleOrDefault(a => a.ProcessId == item.SelectId);
                    var feeItem = feesItem.ServiceList.SingleOrDefault(f => f.ItemName == item.ItemName);
                    feeItem.ItemCount += item.ItemCount;
                    data.ProcessCount += item.ItemCount;
                    if (data.ProcessCount > TaskCount)//累积超出任务量
                    {
                        new TipsWindow($"{item.ItemName}:{data.ProcessCount}超出任务量{TaskCount}").Show();
                        return;
                    }
                    continue;
                }
                processMembers.Add(new ProcessMemberModel
                {
                    UserId = item.SelectUserId,
                    ProcessCount = item.ItemCount,
                    ProcessId = item.SelectId,
                    Price = price
                });
                feesItem.ServiceList.Add(new ServiceItemResponse
                {
                    ServiceType = ServiceType.打包服务,
                    ItemCount = item.ItemCount,
                    ItemName = item.ItemName,
                    ItemPrice = price
                });
                allProcessMembers.Add(new ProcessMemberModel
                {
                    UserId = item.SelectUserId,
                    ProcessCount = item.ItemCount,
                    ProcessId = item.SelectId
                });


            }

            foreach (var item in ConsumableServiceList)
            {
                if (item.SelectId <= 0 || item.ItemCount <= 0)
                {
                    new TipsWindow($"数据输入有误").Show();
                    return;
                }
                if (item.ItemCount > TaskCount)
                {
                    new TipsWindow($"{item.ItemName}:{item.ItemCount}超出任务量{TaskCount}").Show();
                    return;
                }
                price = ConsumableList.First(i => i.Id == item.SelectId).Price.Value;
                singleFees += price;
                AllFees += item.ItemCount * price;
                if (allConsumableTasks.Select(a => a.ConsumableId).Contains(item.SelectId))//存在累加
                {
                    var data = allConsumableTasks.SingleOrDefault(a => a.ConsumableId == item.SelectId);
                    var feeItem = feesItem.ServiceList.SingleOrDefault(f => f.ItemName == item.ItemName);
                    feeItem.ItemCount += item.ItemCount;
                    data.ConsumableCount += item.ItemCount;
                    if (data.ConsumableCount > TaskCount)//累积超出任务量
                    {
                        new TipsWindow($"{item.ItemName}:{data.ConsumableCount}超出任务量{TaskCount}").Show();
                        return;
                    }
                    continue;
                }
                feesItem.ServiceList.Add(new ServiceItemResponse
                {
                    ServiceType = ServiceType.耗材服务,
                    ItemCount = item.ItemCount,
                    ItemName = item.ItemName,
                    ItemPrice = price
                });
                allConsumableTasks.Add(new ConsumableTaskModel
                {
                    ConsumableCount = item.ItemCount,
                    ConsumableId = item.SelectId
                });
            }
            uploadService.ConsumableIds = string.Join(",", allConsumableTasks.Select(a => a.ConsumableId));
            uploadService.ConsumableNos = string.Join(",", allConsumableTasks.Select(a => a.ConsumableCount));
            uploadService.WorkProcessIds = string.Join(",", allProcessMembers.Select(a => a.ProcessId));
            uploadService.WorkProcessNos = string.Join(",", allProcessMembers.Select(a => a.ProcessCount));
            uploadService.IncreateServiceIds = string.Join(",", allIncreateMembers.Select(a => a.IncreateId));
            uploadService.IncreateServiceNos = string.Join(",", allIncreateMembers.Select(a => a.IncreateCount));

            //List<IncreateMemberModel> increateMembers = new List<IncreateMemberModel>();
            //List<ProcessMemberModel> processMembers = new List<ProcessMemberModel>();
            foreach (var item in increateMembers)
            {
                var allFees = item.Price * item.IncreateCount;
                var person = PersonTaskModels.SingleOrDefault(p => p.PackUserId == item.UserId);
                if (person != null)
                {
                    person.AllFees += allFees;
                    person.IncreateServiceIds += $",{item.IncreateId}";
                    person.IncreateServiceNos += $",{item.IncreateCount}";
                    continue;
                }

                var inMember = new PersonTaskModel();
                inMember.IncreateServiceIds = item.IncreateId.ToString();
                inMember.IncreateServiceNos = item.IncreateCount.ToString();
                inMember.AllFees += allFees;
                inMember.TaskId = TaskId; inMember.PackUserId = item.UserId;

                PersonTaskModels.Add(inMember);


            }
            foreach (var item in processMembers)
            {
                var allFees = item.Price * item.ProcessCount;
                var person = PersonTaskModels.SingleOrDefault(p => p.PackUserId == item.UserId);
                if (person != null)
                {
                    person.AllFees += allFees;
                    if (string.IsNullOrEmpty(person.WorkProcessIds))
                    {
                        person.WorkProcessIds += $"{item.ProcessId}";
                        person.WorkProcessNos += $"{item.ProcessCount}";
                        continue;
                    }


                    person.WorkProcessIds += $",{item.ProcessId}";
                    person.WorkProcessNos += $",{item.ProcessCount}";

                    continue;
                }

                var inMember = new PersonTaskModel();
                inMember.WorkProcessNos = item.ProcessCount.ToString();
                inMember.WorkProcessIds = item.ProcessId.ToString();
                inMember.AllFees += allFees;
                inMember.TaskId = TaskId; inMember.PackUserId = item.UserId;
                PersonTaskModels.Add(inMember);


            }
            uploadService.PersonTaskModels = PersonTaskModels.ToArray();

            uploadService.AllFees = AllFees;
            uploadService.SingleFees = singleFees;
            var res = packTaskService.UploadService(uploadService);
            if (res != null && res.Success)
            {
               // new TipsWindow("上传成功!").Show();
                var win = obj as System.Windows.Window;
                feesItem.AllFees = AllFees;
                feesItem.SingleFees = singleFees;
                feesItem.TaskId = TaskId;


                SetAllFees(feesItem, packUsers);

                win.Close();
            }

        }
        /// <summary>
        /// 更新 打包员 和费用数据
        /// </summary>
        public Action<FeesItemResponse, List<string>> SetAllFees { get; set; }

        private void AddPackService()
        {
            PackList.Add(new PackItemModel()
            {
                ItemCount = TaskCount,
                MemberList = MemberList,
                PackServiceList = PackServiceList
            });
        }

        private void AddIncreateService()
        {
            IncreateList.Add(new PackItemModel()
            {
                ItemCount = TaskCount,
                IncreateServiceList = IncreateServiceList,
                MemberList = MemberList,
            });
        }

        private void AddConsumable()
        {
            ConsumableServiceList.Add(new PackItemModel()
            {
                ItemCount = TaskCount,
                 ConsumableList = ConsumableList
            });
        }
    }
}