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

using BBWY.Client.APIServices;
using BBWY.Client.Helpers;
using BBWY.Client.Models;
using BBWY.Client.Views.Order;
using BBWY.Common.Models;
using BBWY.Controls;
using GalaSoft.MvvmLight.Command;
using GalaSoft.MvvmLight.Messaging;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Input;
using System.Windows;
using BBWY.Common.Extensions;
using System.Threading.Tasks;
using BBWY.Client.Views.PackTask;
using HandyControl.Tools.Extension;
using Newtonsoft.Json;
using BBWY.Client.Models.APIModel.Response.PackTask;
using BBWY.Client.Models.PackTask;
using WebSocketSharp;

namespace BBWY.Client.ViewModels.PackTask
{
    /// <summary>
    /// 
    /// </summary>
    public partial class TaskListViewModel : BaseVM, IDenpendency//注入服务
    {

        #region 属性绑定
        /// <summary>
        /// 查询时间段
        /// </summary>
        private DateTime startTime;
        public DateTime StartTime { get => startTime; set { Set(ref startTime, value); } }

        private DateTime endTime;
        public DateTime EndTime { get => endTime; set { Set(ref endTime, value); } }

        /// <summary>
        /// 查询任务id
        /// </summary>
        private string searchTaskId;
        public string SearchTaskId
        {
            get => searchTaskId; set
            {
                Set(ref searchTaskId, value);
            }
        }

        /// <summary>
        /// 查询Sku
        /// </summary>
        private string searchSkuId;
        public string SearchSkuId { get => searchSkuId; set { Set(ref searchSkuId, value); } }

        public TaskState? taskState;
        /// <summary>
        /// 任务状态
        /// </summary>
        public TaskState? TaskState
        {
            get => taskState; private set
            {
                Set(ref taskState, value);
            }
        }

        private int pageIndex = 1;
        private int pageSize = 10;

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

        public int PageSize { get => pageSize; set { Set(ref pageSize, value); } }
        private int orderCount;//总数量
        public int OrderCount { get => orderCount; set { Set(ref orderCount, value); } }


        /// <summary>
        /// 未到货数量
        /// </summary>
        public string NoArrivedCount { get => noArrivedCount; set { Set(ref noArrivedCount, value); } }
        private string noArrivedCount;
        private string someArrivedCount;
        /// <summary>
        /// 部分到货数量
        /// </summary>
        public string SomeArrivedCount { get => someArrivedCount; set { Set(ref someArrivedCount, value); } }

        private string arrivedCount;
        /// <summary>
        /// 已到货数量
        /// </summary>
        public string ArrivedCount { get => arrivedCount; set { Set(ref arrivedCount, value); } }

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


        private string waitPackCount;
        /// <summary>
        /// 待打包任务数
        /// </summary>
        public string WaitPackCount { get => waitPackCount; set { Set(ref waitPackCount, value); } }
        private string waitSealBoxCount;
        /// <summary>
        /// 带封箱任务数
        /// </summary>
        public string WaitSealBoxCount { get => waitSealBoxCount; set { Set(ref waitSealBoxCount, value); } }



        private string waitFallWareCount;
        /// <summary>
        /// 待落仓任务数
        /// </summary>
        public string WaitFallWareCount { get => waitFallWareCount; set { Set(ref waitFallWareCount, value); } }

        private string waitOutbound;
        /// <summary>
        /// 待出库任务数
        /// </summary>
        public string WaitOutbound { get => waitOutbound; set { Set(ref waitOutbound, value); } }


        private string waitCompleted;
        /// <summary>
        /// 待完成任务数
        /// </summary>
        public string WaitCompleted { get => waitCompleted; set { Set(ref waitCompleted, value); } }




        private readonly PackTaskService packTaskService;
        WorkProcessService workProcessService;
        public int? taskStatus { get; set; }
        private ObservableCollection<PackTaskModel> packTaskList;
        /// <summary>
        /// 动态数据表
        /// </summary>
        public ObservableCollection<PackTaskModel> PackTaskList { get => packTaskList; set { Set(ref packTaskList, value); } }


        #endregion



        public TaskListViewModel(PackTaskService packTaskService, GlobalContext globalContext, ProductService productService, ConsumableService consumableService, WorkProcessService workProcessService, IncreateServiceService increateServiceService)
        {
            this.globalContext = globalContext;
            this.productService = productService;
            this.consumableService = consumableService;
            this.workProcessService = workProcessService;
            this.increateServiceService = increateServiceService;
            this.packTaskService = packTaskService;
            PackTaskList = new ObservableCollection<PackTaskModel>();//初始化数据

            SetTaskStateCommand = new RelayCommand<TaskState?>(SetTaskState);
            CreateTaskCommand = new RelayCommand(CreateTask);
            SearchTaskCommand = new RelayCommand(() =>
            {
                PageIndex = 1;
                Task.Factory.StartNew(() => SearchTaskList());  //手动点击查询订单
            });
            TaskPageIndexChangedCommand = new RelayCommand<PageArgs>(p =>
            {
                LoadIndex(p.PageIndex);
            });

            OpenSkuDetailCommand = new RelayCommand<object>(OpenSkuDetail);
            DeletedTaskCommand = new RelayCommand<object>(DeletedTask);

            StartTime = DateTime.Now.Date;
            EndTime = DateTime.Now.Date;
            IsLoading = false;
            //加载数据
            SetTaskState(null);

        }


        private void DeletedTask(object obj)
        {
            var packTaskmodel = (PackTaskModel)obj;
            if (!packTaskmodel.OrderId.IsNullOrEmpty())
            {
                System.Windows.MessageBox.Show("暂不支持删除采购组的任务");
                return;
            }
            MessageBoxResult result = MessageBox.Show("确定取消任务?", "提示",
                                           MessageBoxButton.YesNo,
                                           MessageBoxImage.Warning);
          



          




            if (result != MessageBoxResult.Yes) return;
            packTaskService.DeletedTask(packTaskmodel.TaskId);
            Task.Factory.StartNew(() => SearchTaskList());
        }


        private void IsLoadCount()
        {
            var packTaskResult = packTaskService.GetTaskAllCount(globalContext.User.Shop.ShopId.ToString());
            if (packTaskResult != null && packTaskResult.Success && packTaskResult.Data != null)
            {
                App.Current.Dispatcher.Invoke(new Action(() =>
                {
                    ArrivedCount = packTaskResult.Data.ArrivedCount.ToString();
                    NoArrivedCount = packTaskResult.Data.NoArrivedCount.ToString();
                    SomeArrivedCount = packTaskResult.Data.SomeArrivedCount.ToString();
                    //WorryCount = packTaskResult.Data.WorryCount.ToString();
                    WaitOutbound = packTaskResult.Data.WaitOutbound?.ToString();
                    WaitPackCount = packTaskResult.Data.WaitPackCount?.ToString();
                    WaitSealBoxCount = packTaskResult.Data.WaitSealBox?.ToString();
                    WaitFallWareCount = packTaskResult.Data.WaitFallWareCount?.ToString();
                    WaitCompleted = packTaskResult.Data.WaitCompleted?.ToString();
                }));
            }
        }

        private void LoadIndex(int pageIndex)
        {
            PageIndex = pageIndex;//
            SearchTaskList();
        }




        #region 事件绑定
        /// <summary>
        /// 筛选数据 
        /// </summary>
        public ICommand SetTaskStateCommand { get; set; }
        /// <summary>
        /// 搜索数据
        /// </summary>
        public ICommand SearchTaskCommand { get; set; }

        /// <summary>
        /// 创建任务
        /// </summary>
        public ICommand CreateTaskCommand { get; set; }

        /// <summary>
        /// 页面改变事件
        /// </summary>
        public ICommand TaskPageIndexChangedCommand { get; set; }

        /// <summary>
        /// 打开图片链接
        /// </summary>
        public ICommand OpenSkuDetailCommand { get; set; }


        /// <summary>
        /// 删除任务
        /// </summary>
        public ICommand DeletedTaskCommand { get; set; }

        public void SetTaskState(TaskState? taskState)
        {
            PageIndex = 1;
            TaskState = taskState;
            SearchTaskList();

        }

        private ConsumableService consumableService;
        private IncreateServiceService increateServiceService;


        public void ReflashTask()//刷新界面
        {
            SearchTaskList();
        }


        /// <summary>
        /// 搜索任务列表
        /// </summary>
        public void SearchTaskList()
        {
            try
            {
                if (SearchTaskId != null && !string.IsNullOrEmpty(SearchTaskId.Trim()))
                    Convert.ToInt64(SearchTaskId);
            }
            catch
            {
                System.Windows.MessageBox.Show("任务id必须为数字");
                return;

            }

            IsLoading = true;
            Task.Factory.StartNew(() =>
            {

                try
                {
                    PackTaskList = new ObservableCollection<PackTaskModel>();//初始化数据
                    var datas = packTaskService.GetTaskList(SearchSkuId, SearchTaskId, StartTime, EndTime, (this.TaskState),
                        PageIndex, PageSize);
                    if (datas != null && datas.Data != null && datas.Success)
                    {
                        var dataModel = datas.Data;
                        OrderCount = dataModel.TotalCount;
                        foreach (var item in dataModel.Items)
                        {

                            var data = new PackTaskModel()
                            {
                                Brand = item.Brand,
                                SkuId = item.SkuId,
                                AcceptName = item.UserName,
                                Availability = (Availability)item.Availability,
                                BasicPack = (BasicPack)item.BasicPack,
                                DepartmentName = item.DepartmentName,
                                CertificatePosition = (CertificatePosition)item.CertificatePosition,
                                GoodsNumber = item.GoodsNumber,
                                Increment1 = item.Increment1,
                                ItemList = new List<SkuMessage>() { new SkuMessage
                            {    BrandName = item.BrandName,
                                 GoodsNo = item.ProductItemNum, Logo= item.Logo,
                                 ShopName = item.ShopName, SkuName = item.SkuName,
                                  Id = item.SkuId

                            } },
                                MarkMessage = item.MarkMessage,
                                PackType = (PackType)item.PackType,

                                PositionType = item.PositionType,
                                SkuCount = item.SkuCount,
                                SkuTitle = item.SkuGoodsTitle,
                                TaskId = item.TaskId,
                              
                                EndTime = item.CreateTime,
                                 BrandName = item.BrandName,
                                  OrderId = item.OrderId,
                                   TaskState = item.TaskState,
                                    
                               // IsWorry = (Worry)item.IsWorry,
                            };
                            if (item.BarCodeDTO != null && item.BarCodeDTO.Id > 0)
                            {
                                data.BarCodeModel = item.BarCodeDTO;
                            }
                            if (item.Cers != null)
                            {
                                data.CertificateModel = item.Cers;
                            }
                            if (item.FeesItemResponse != null)
                            {
                                data.FeesItemResponse = item.FeesItemResponse;
                                data.FeesMoney = item.FeesItemResponse.SingleFees;
                                data.IsShowFees = data.FeesMoney > 0 ? true : false;
                                data.FeesItemResponse.DiscountSingleFees = item.FeesItemResponse.SingleFees * item.FeesItemResponse.disCount;
                                data.FeesItemResponse.DiscountAllFees = item.FeesItemResponse.AllFees * item.FeesItemResponse.disCount;

                            }
                            else
                            {
                                data.IsShowFees = false;
                            }
                            if (item.PackUserName != null && item.PackUserName.Count() > 0)
                            {
                                data.PackUser = string.Join("\r\n", item.PackUserName);
                            }

                            data.ReflashTask = ReflashTask;

                            App.Current.Dispatcher.BeginInvoke(new Action(() =>
                            {
                                PackTaskList.Add(data);
                            }));

                        }



                    }
                    else
                    {
                        MessageBox.Show("查不到数据");


                    }
                    IsLoadCount();

                }
                catch (Exception ex)
                {


                }
                IsLoading = false;
            });



        }

        GlobalContext globalContext;
        ProductService productService;




        /// <summary>
        /// 展示发布任务页面
        /// </summary>
        public void CreateTask()
        {
            ViewModelLocator viewModel = new ViewModelLocator();
            var publicTaskViewModel = viewModel.PublishTask;

            if (publicTaskViewModel.ReflashWindow == null)

                publicTaskViewModel.ReflashWindow = ReflashTask;

            publicTaskViewModel.InitData();
            PublishTaskWindow publish = new PublishTaskWindow();
            publish.Show();
        }






        /// <summary>
        /// 弹出条形码可视化界面
        /// </summary>
        public void ShowBarCodeWindow()
        {

        }


        /// <summary>
        /// 弹出合格证 可视化页面
        /// </summary>
        public void ShowCertificateWindow()
        {
        }
        /// <summary>
        /// 筛选任务状态数据(根据TaskList数据)
        /// </summary>
        public void SelectTaskStatus() { }
        #endregion
        private void OpenSkuDetail(object param)
        {
            var paramList = (object[])param;
            // var orderId = paramList[0].ToString();
            var skuId = paramList[1].ToString();


            var url = $"https://item.jd.com/{skuId}.html";
            try
            {
                System.Diagnostics.Process.Start("explorer.exe", url);
            }
            catch (Exception ex)
            {
                Clipboard.SetText(url);
                MessageBox.Show($"{ex.Message}\r\n调用浏览器失败,网页链接已复制到剪切板,请手动打开浏览器访问", "提示");
            }

        }









    }
}