bbwy/BBWY.Client/ViewModels/Order/OrderListViewModel.cs

using BBWY.Client.APIServices;
using BBWY.Client.Models;
using BBWY.Client.Views.Order;
using BBWY.Common.Extensions;
using BBWY.Common.Models;
using BBWY.Controls;
using GalaSoft.MvvmLight.Command;
using GalaSoft.MvvmLight.Messaging;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace BBWY.Client.ViewModels
{
    public class OrderListViewModel : BaseVM, IDenpendency
    {
        private OrderService orderService;
        private StatisticsService statisticsService;
        private ChoosePurchaseSchemeViewModel choosePurchaseSchemeViewModel;

        private bool isLoading;

        private string searchOrderId;
        private DateTime startDate;
        private DateTime endDate;
        private int pageIndex = 1;
        private int pageSize = 10;
        private int orderCount;
        private OrderState? orderState;
        private string searchSku;
        private string searchProductNo;
        private string searchContactName;
        private string searchWaybill;
        private bool onlyDF;
        private bool excludeSD;
        private bool excludeCanceled;
        private Random random;

        private GlobalContext globalContext;

        public IList<Order> OrderList { get; set; }

        public bool IsLoading { get => isLoading; set { Set(ref isLoading, value); } }

        public string SearchOrderId { get => searchOrderId; set { Set(ref searchOrderId, value); } }

        public DateTime StartDate { get => startDate; set { Set(ref startDate, value); } }

        public DateTime EndDate { get => endDate; set { Set(ref endDate, value); } }

        public int PageIndex { get => pageIndex; set { Set(ref pageIndex, value); } }

        public int PageSize { get => pageSize; set { Set(ref pageSize, value); } }

        public int OrderCount { get => orderCount; set { Set(ref orderCount, value); } }

        public OrderState? OrderState { get => orderState; private set { Set(ref orderState, value); } }

        public string SearchSku { get => searchSku; set { Set(ref searchSku, value); } }
        public string SearchProductNo { get => searchProductNo; set { Set(ref searchProductNo, value); } }
        public string SearchContactName { get => searchContactName; set { Set(ref searchContactName, value); } }
        public string SearchWaybill { get => searchWaybill; set { Set(ref searchWaybill, value); } }

        public bool OnlyDF { get => onlyDF; set { Set(ref onlyDF, value); } }
        public bool ExcludeSD { get => excludeSD; set { Set(ref excludeSD, value); } }
        public bool ExcludeCanceled { get => excludeCanceled; set { Set(ref excludeCanceled, value); } }

        public ToDayOrderAchievement ToDayOrderAchievement { get; set; }

        public ICommand SetOrderStateCommand { get; set; }

        public ICommand SearchOrderCommand { get; set; }

        public ICommand CopyTextCommand { get; set; }

        public ICommand CopyOrderWaybillCommand { get; set; }

        public ICommand SetSearchDateCommand { get; set; }

        public ICommand OrderPageIndexChangedCommand { get; set; }

        public ICommand DecodeConsigneeCommand { get; set; }

        public ICommand ChooseStorageTypeCommand { get; set; }

        public ICommand EditCostCommand { get; set; }

        public ICommand OutStockCommand { get; set; }

        public OrderListViewModel(OrderService orderService, StatisticsService statisticsService, GlobalContext globalContext, ChoosePurchaseSchemeViewModel choosePurchaseSchemeViewModel)
        {
            random = new Random();
            this.globalContext = globalContext;
            this.orderService = orderService;
            this.statisticsService = statisticsService;
            this.choosePurchaseSchemeViewModel = choosePurchaseSchemeViewModel;
            OrderList = new ObservableCollection<Order>();
            EndDate = DateTime.Now;
            StartDate = DateTime.Now.Date.AddDays(-29);
            ToDayOrderAchievement = new ToDayOrderAchievement();
            SetOrderStateCommand = new RelayCommand<OrderState?>(SetOrderState);
            SearchOrderCommand = new RelayCommand(() =>
            {
                PageIndex = 1;
                Task.Factory.StartNew(() => LoadOrder(1));
                Task.Factory.StartNew(LoadTodayAchievement);
            });
            CopyTextCommand = new RelayCommand<string>(s => Clipboard.SetText(s));
            CopyOrderWaybillCommand = new RelayCommand<Order>(o => Clipboard.SetText(o.WaybillNo));
            SetSearchDateCommand = new RelayCommand<int>(d =>
            {
                EndDate = d == 1 ? DateTime.Now.Date.AddDays(-1) : DateTime.Now;
                StartDate = DateTime.Now.Date.AddDays(d * -1);
                PageIndex = 1;
                Task.Factory.StartNew(() => LoadOrder(1));
                Task.Factory.StartNew(LoadTodayAchievement);
            });
            OrderPageIndexChangedCommand = new RelayCommand<PageArgs>(p =>
            {
                Task.Factory.StartNew(() => LoadOrder(p.PageIndex));
                Task.Factory.StartNew(LoadTodayAchievement);
            });
            DecodeConsigneeCommand = new RelayCommand<Order>(DecodeConsignee);
            ChooseStorageTypeCommand = new RelayCommand<object>(ChooseStorageType);
            EditCostCommand = new RelayCommand<Order>(EditCost);
            OutStockCommand = new RelayCommand<Order>((o) => OutStock(o));
            SearchOrderCommand.Execute(null);
        }

        public void SetOrderState(OrderState? orderState)
        {
            this.OrderState = orderState;
            SearchOrderId = String.Empty;
            SearchContactName = String.Empty;
            SearchProductNo = String.Empty;
            SearchSku = String.Empty;
            SearchWaybill = String.Empty;
            EndDate = DateTime.Now;
            StartDate = DateTime.Now.Date.AddDays(-29);
            PageIndex = 1;
            Task.Factory.StartNew(() => LoadOrder(1));
        }

        private void LoadOrder(int pageIndex)
        {
            IsLoading = true;
            Thread.Sleep(random.Next(500, 2000));
            var response = orderService.GetOrderList(SearchOrderId,
                                                     StartDate,
                                                     EndDate,
                                                     OrderState,
                                                     SearchSku,
                                                     SearchProductNo,
                                                     SearchWaybill,
                                                     SearchContactName,
                                                     pageIndex,
                                                     pageSize,
                                                     globalContext.User.Shop.ShopId,
                                                     OnlyDF,
                                                     ExcludeSD,
                                                     ExcludeCanceled);
            if (!response.Success)
            {
                IsLoading = false;
                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "提示"));
                return;
            }
            OrderCount = response.Data.Count;
            var orderList = response.Data.Items.Map<IList<Order>>();
            App.Current.Dispatcher.Invoke(() =>
            {
                OrderList.Clear();
                foreach (var order in orderList)
                {
                    if (order.OrderCostDetailList.Count > 0)
                        order.ConvertOrderCostDetailToGroup();
                    OrderList.Add(order);
                }

                Messenger.Default.Send(string.Empty, "OrderList_OrderListScrollToTop");
            });
            IsLoading = false;
        }

        private void LoadTodayAchievement()
        {
            var response = statisticsService.GetTodayAchievementStatistics();
            if (!response.Success)
                return;
            _ = response.Data.Map(ToDayOrderAchievement);
        }

        private void DecodeConsignee(Order order)
        {
            IsLoading = true;
            Task.Factory.StartNew(() => orderService.DecodeConsignee(order.Id)).ContinueWith(t =>
            {
                var response = t.Result;
                IsLoading = false;
                if (!response.Success)
                {
                    App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "解密失败"));
                    return;
                }
                order.Consignee.ContactName = response.Data.ContactName;
                order.Consignee.Address = response.Data.Address;
                order.Consignee.Mobile = response.Data.Mobile;
                order.Consignee.IsDecode = true;
            });
        }

        private void ChooseStorageType(object param)
        {
            var paramList = (object[])param;
            var orderId = paramList[0].ToString();
            var storageType = (StorageType)paramList[1];

            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
            if (order.StorageType == storageType)
                return;//忽略相同的仓储类型

            if (storageType == StorageType.本地自发)
            {
                var calculationCostType = new ChooseCalculationCostType(orderId, storageType, true);
                calculationCostType.Closed += ChooseCalculationCostType_Closed;
                calculationCostType.ShowDialog();
            }
            else if (storageType == StorageType.SD)
            {
                var sd = new SD(orderId, true);
                sd.Closed += Sd_Closed;
                sd.ShowDialog();
            }
            else if (storageType == StorageType.代发)
            {
                var chooseDFType = new ChooseDFType(order.ItemList.Count > 1);
                if (chooseDFType.ShowDialog() != true)
                    return;

                if (chooseDFType.DFType == DFType.关联订单)
                {
                    var relationPurchaseOrder = new RelationPurchaseOrder(orderId, null, order.ItemList.Select(osku => new RelationPurchaseOrderSku()
                    {
                        Logo = osku.Logo,
                        ProductId = osku.ProductId,
                        SkuId = osku.Id,
                        Quantity = osku.ItemTotal,
                        Title = osku.Title
                    }).ToList());
                    relationPurchaseOrder.Closed += RelationPurchaseOrder_Closed;
                    relationPurchaseOrder.ShowDialog();
                }
                else if (chooseDFType.DFType == DFType.在线采购)
                {
                    choosePurchaseSchemeViewModel.SetData(order.Id, order.ItemList[0].Id, order.ItemList[0].Title);
                    var choosePurchaseScheme = new ChoosePurchaseScheme();
                    choosePurchaseScheme.ShowDialog();
                }
            }
        }

        private void RelationPurchaseOrder_Closed(object sender, EventArgs e)
        {
            var relationPurchaseOrder = sender as RelationPurchaseOrder;
            if (relationPurchaseOrder.DialogResult != true)
                return;
            var orderDropShipping = relationPurchaseOrder.OrderDropShipping;
            var relationPurchaseOrderSkuList = relationPurchaseOrder.RelationPurchaseOrderSkuList;
            IsLoading = true;
            Task.Factory.StartNew(() => orderService.RelationPurchaseOrder(orderDropShipping, relationPurchaseOrderSkuList))
                        .ContinueWith(r =>
                        {
                            var response = r.Result;
                            if (!response.Success)
                            {
                                IsLoading = false;
                                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "关联采购订单"));
                                return;
                            }
                            LoadOrder(PageIndex); //手动计算成功刷新订单列表
                        });
        }

        private void Sd_Closed(object sender, EventArgs e)
        {
            var sd = sender as SD;
            if (sd.DialogResult != true)
                return;
            var orderId = sd.OrderId;
            var isSetStorageType = sd.IsSetStorageType;
            var sdCommissionAmount = sd.SDCommissionAmount;
            var deliveryExpressFreight = sd.DeliveryExpressFreight;
            var sdType = sd.SDType;
            var flag = sd.Flag;
            var venderRemark = sd.VenderRemark;

            IsLoading = true;
            Task.Factory.StartNew(() => orderService.SDCalculationCost(orderId,
                                                                       isSetStorageType,
                                                                       sdCommissionAmount,
                                                                       deliveryExpressFreight,
                                                                       sdType.Value,
                                                                       flag,
                                                                       venderRemark))
                        .ContinueWith(r =>
                        {
                            var response = r.Result;
                            if (!response.Success)
                            {
                                IsLoading = false;
                                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "设置刷单成本"));
                                return;
                            }
                            LoadOrder(PageIndex); //手动计算成功刷新订单列表
                        });
        }

        private void EditCost(Order order)
        {
            if (order.StorageType == null)
                return;
            if (order.StorageType == StorageType.代发)
            {
                var relationPurchaseOrder = new RelationPurchaseOrder(order.Id, order.OrderDropShipping, order.ItemList.Select(osku => new RelationPurchaseOrderSku()
                {
                    Logo = osku.Logo,
                    ProductId = osku.ProductId,
                    SkuId = osku.Id,
                    Quantity = osku.ItemTotal,
                    Title = osku.Title,
                    SingleSkuAmount = (order.OrderCostDetailList.FirstOrDefault(ocd => ocd.SkuId == osku.Id)?.SkuAmount / osku.ItemTotal) ?? 0
                }).ToList());
                relationPurchaseOrder.Closed += RelationPurchaseOrder_Closed;
                relationPurchaseOrder.ShowDialog();
            }
            else if (order.StorageType == StorageType.SD)
            {
                var sd = new SD(order.Id, false);
                sd.Closed += Sd_Closed;
                sd.ShowDialog();
            }
            else
            {
                var calculationCostType = new ChooseCalculationCostType(order.Id, order.StorageType.Value, false);
                calculationCostType.Closed += ChooseCalculationCostType_Closed;
                calculationCostType.ShowDialog();
            }
        }

        private void ChooseCalculationCostType_Closed(object sender, EventArgs e)
        {
            var chooseCalculationCostType = sender as ChooseCalculationCostType;
            chooseCalculationCostType.Closed -= ChooseCalculationCostType_Closed;
            if (chooseCalculationCostType.DialogResult != true)
                return;

            var orderId = chooseCalculationCostType.OrderId;
            var storageType = chooseCalculationCostType.StorageType;
            var isSetStorageType = chooseCalculationCostType.IsSetStorageType;
            var isAutoCalculation = chooseCalculationCostType.IsAutoCalculation;

            if (isAutoCalculation)
            {
                IsLoading = true;
                Task.Factory.StartNew(() => orderService.AutoCalculationCost(orderId, isSetStorageType, storageType)).ContinueWith(r =>
                {
                    var response = r.Result;
                    if (!response.Success)
                    {
                        IsLoading = false;
                        App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "自动计算成本"));
                        return;
                    }

                    LoadOrder(PageIndex); //自动计算成功刷新订单列表
                });
            }
            else
            {
                var manualCalculationCost = new ManualCalculationCost(orderId, isSetStorageType, storageType);
                manualCalculationCost.Closed += ManualCalculationCost_Closed;
                manualCalculationCost.ShowDialog();
            }
        }

        private void ManualCalculationCost_Closed(object sender, EventArgs e)
        {
            var manualCalculationCost = sender as ManualCalculationCost;
            manualCalculationCost.Closed -= ManualCalculationCost_Closed;
            if (manualCalculationCost.DialogResult != true)
                return;

            var orderId = manualCalculationCost.OrderId;
            var storageType = manualCalculationCost.StorageType;
            var isSetStorageType = manualCalculationCost.IsSetStorageType;
            var purchaseCost = manualCalculationCost.PurchaseCost;
            var deliveryExpressFreight = manualCalculationCost.DeliveryExpressFreight;

            IsLoading = true;
            Task.Factory.StartNew(() => orderService.ManualCalculationCost(orderId, isSetStorageType, storageType, purchaseCost, deliveryExpressFreight)).ContinueWith(r =>
            {
                var response = r.Result;
                if (!response.Success)
                {
                    IsLoading = false;
                    App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "手动计算成本"));
                    return;
                }
                LoadOrder(PageIndex); //手动计算成功刷新订单列表
            });
        }

        private void OutStock(Order o)
        {
            var outStock = new OutStock(o.Id, globalContext.LogisticsResponseList);
            outStock.Closed += OutStock_Closed;
            outStock.ShowDialog();
        }

        private void OutStock_Closed(object sender, EventArgs e)
        {
            var outStock = sender as OutStock;
            if (outStock.DialogResult != true)
                return;
            var orderId = outStock.OrderId;
            var waybillNo = outStock.WaybillNo;
            var logistics = outStock.SelectedLogistics;
            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
            IsLoading = true;
            Task.Factory.StartNew(() => orderService.OutStock(orderId, waybillNo, logistics.Id))
                        .ContinueWith(r =>
                        {
                            IsLoading = false;
                            var response = r.Result;
                            if (!response.Success)
                            {
                                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "出库"));
                                return;
                            }
                            if (order != null)
                            {
                                order.OrderState = Models.OrderState.待收货;
                                order.WaybillNo = waybillNo;
                            }

                            //LoadOrder(PageIndex);
                        });
        }
    }
}