29WxOrder/29WxOrderWpf/Ctrls/OrderCtrls/OrderListCtrl.xaml.cs

using _29WxOrderWpf.BaseWindows;
using WxOrder.Framework.Commons;
using WxOrder.Framework.Commons;
using _29WxOrderWpf.Ctrls.BuyerCtrls;
using _29WxOrderWpf.Ctrls.Statistics;
using _29WxOrderWpf.Services;
using _29WxOrderWpf.Utils;
using _29WxOrderWpf.ViewModels;
using _29WxOrderWpf.Views;
using _29WxOrderWpf.Windows.OrderWindows;
using AllBase;
using AllBase.Extension;
using AllBase.Helper;
using AllBase.Model;
using AllBase.Model.DBModel;
using AllBase.Model.MvvmBaseClasses;
using AllBase.Model.Result;
using AllBase.Util;
using CefSharp.DevTools.Accessibility;
using CefSharp.DevTools.Autofill;
using CefSharp.DevTools.FedCm;
using NaiBa.Util;
using NaiBa.Util.Extension;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Security.Policy;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Xml;
using System.Xml.Linq;
using Work;
using Work._29Tools.BLL;
using Work.BaseForms;
using Work.BuyUsers;
using Work.KJDServer.API.Models;
using WPFCommon.Helpers;
using static _29WxOrderWpf.Services.ShipGiftService;
using static System.Net.Mime.MediaTypeNames;

namespace _29WxOrderWpf.Ctrls.OrderCtrls
{
	/// <summary>
	/// OrderListCtrl.xaml 的交互逻辑
	/// </summary>
	public partial class OrderListCtrl : UserControl, INotifyPropertyChanged
	{
		private static readonly object locker = new object();

		public static bool IsAutoBuy { get; set; } = false;
		public CheckBox chkSelectAll = null;
		OrderFilterConfig _orderFilterConfig;
		public OrderFilterConfig orderFilterConfig
		{
			get { return _orderFilterConfig; }
			set
			{
				if (_orderFilterConfig != value)
					_orderFilterConfig = value;
				OnPropertyChanged(new PropertyChangedEventArgs("orderFilterConfig"));
			}
		}
		private string _columnHeaderTitle = "交易时间 ▼";
		public string ColumnHeaderTitle
		{
			get => _columnHeaderTitle;
			set
			{
				_columnHeaderTitle = value;
				OnPropertyChanged(new PropertyChangedEventArgs("ColumnHeaderTitle"));
			}
		}

		string cmbReturnOrderBuyerStatusText = string.Empty;
		string cmbReturnPackageStatusText = string.Empty;
		string cmbReturnOrderStatusText = "";
		string cmbRejectStatusText = "";
		bool chkAftersaleWarehouseIsPickupIsChecked, chkAftersaleWarehouseIsNotPickupIsChecked;
		bool chkAftersaleBuyerIsBuyIsChecked;
		bool chkUpShopAddressAnalyseFailedIsChecked;
		bool chkEmergencyReturnIsChecked, chkEmergencyRefundIsChecked;
		bool chkEmergencyWaitSupplierReceiveIsChecked, chkEmergencyWaitSupplierAcceptIsChecked, chkEmergencyShopAfterSaleSuccessIsChecked, chkEmergencyShopInAfterSaleIsChecked;
		bool chkEmergencyShopCustomRefundHasWaybillIsChecked, chkEmergencyShopCustomRefundNoWaybillIsChecked;
		bool chkEmergencyBuyerWaitAfterSaleIsChecked, chkEmergencyBuyerWaitSendBackIsChecked, chkEmergencyBuyerWaitSupplierRefundIsChecked, chkEmergencyBuyerRefundFailIsChecked;
		bool chk48HourNoWaybillIsChecked, chk72HourNoWaybillIsChecked;
		bool chkWaitReceiveWarehouseIsNotPickupIsChecked, chkWaitReceiveWarehouseIsPickupIsChecked, chkWaitReceiveWarehouseIsSendOutIsChecked;
		bool chkWaitReceiveBuyerIsSendIsChecked = false, chkWaitReceiveBuyerIsNotSendIsChecked = false, chkWaitReceiveBuyerIsInWarehouseIsChecked = false;
		bool chkAftersaleIsSendIsChecked = false, chkAftersaleIsNotSendIsChecked = false;
		bool chkShopIsNotRefundIsChecked = false, chkShopIsRefundIsChecked = false;
		bool chkNeedCheckExpressIsChecked = false;
		bool chkWaitSend72HourNoWaybillIsChecked = false, chkWaitSend48HourNoWaybillIsChecked = false;
		bool chkDirectSendFailedIsChecked = false;
		bool chkNoMapProdIsChecked = false, chkMapProdIsChecked = false, chkMapSkuIsChecked = false;
		public string OrderTimeFilterType { get; set; } = "更新时间";
		public bool IsEndDate { get; set; } = false;
		DateTime _dateStart;
		public DateTime DateStart
		{
			get { return _dateStart; }
			set
			{
				if (_dateStart != value)
					_dateStart = value;
				OnPropertyChanged(new PropertyChangedEventArgs("DateStart"));
			}
		}
		DateTime _dateEnd;
		public DateTime DateEnd
		{
			get { return _dateEnd; }
			set
			{
				if (_dateEnd != value)
					_dateEnd = value;
				OnPropertyChanged(new PropertyChangedEventArgs("DateEnd"));
			}
		}

		string waitBuyTabTxt = "待采购";
		public string WaitBuyTabTxt
		{
			get { return waitBuyTabTxt; }
			set
			{
				if (waitBuyTabTxt != value)
				{
					waitBuyTabTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("WaitBuyTabTxt"));
				}
			}
		}
		string waitSendTabTxt = "待发货";
		public string WaitSendTabTxt
		{
			get { return waitSendTabTxt; }
			set
			{
				if (waitSendTabTxt != value)
				{
					waitSendTabTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("waitSendTabTxt"));
				}
			}
		}
		string waitReceiveTabTxt = "待收货";
		public string WaitReceiveTabTxt
		{
			get { return waitReceiveTabTxt; }
			set
			{
				if (waitReceiveTabTxt != value)
				{
					waitReceiveTabTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("WaitReceiveTabTxt"));
				}
			}
		}
		string refundTabTxt = "售后完成但";
		public string RefundTabTxt
		{
			get { return refundTabTxt; }
			set
			{
				if (refundTabTxt != value)
				{
					refundTabTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("RefundTabTxt"));
				}
			}
		}
		string emergencyManualReturnOrderTxt = "需处理售后单";
		public string EmergencyManualReturnOrderTabTxt
		{
			get { return emergencyManualReturnOrderTxt; }
			set
			{
				if (emergencyManualReturnOrderTxt != value)
				{
					emergencyManualReturnOrderTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("EmergencyManualReturnOrderTabTxt"));
				}
			}
		}
		string emergencyDistribReturnOrderTxt = "退货仓自动售后单";
		public string EmergencyDistribReturnOrderTabTxt
		{
			get { return emergencyDistribReturnOrderTxt; }
			set
			{
				if (emergencyDistribReturnOrderTxt != value)
				{
					emergencyDistribReturnOrderTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("EmergencyDistribReturnOrderTabTxt"));
				}
			}
		}
		string abnormalTabTxt = "异常需重拍";

		public string AbnormalTabTxt
		{
			get { return abnormalTabTxt; }
			set
			{
				if (abnormalTabTxt != value)
				{
					abnormalTabTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("AbnormalTabTxt"));
				}
			}
		}
		string allOrderTabTxt = "全部订单";
		public string AllOrderTabTxt
		{
			get { return allOrderTabTxt; }
			set
			{
				if (allOrderTabTxt != value)
				{
					allOrderTabTxt = value;
					OnPropertyChanged(new PropertyChangedEventArgs("AllOrderTabTxt"));
				}
			}
		}


		public bool IsAutoReadOrder = true;
		public DateTime nextGetOrderTime = DateTime.MinValue;

		public string strSearchAll { get; set; } = "";
		public bool chkNoPickupNumOrderIsChecked { get; set; } = false;
		public ShipGiftService _shipGiftService { get; }
		public OrderListCtrl()
		{
			InitializeComponent();
			DataContext = this;
			_shipGiftService = ShipGiftService.Instance;
		}

		private void Window_Loaded(object sender, RoutedEventArgs e)
		{
			lbxOrder.ItemsSource = GlobalConfig.lstFilterOrder;

			orderFilterConfig = NaiBa.Util.Helper.ConfigHelper.LoadConfig<OrderFilterConfig>("wx_order_filter_config");
			if (orderFilterConfig == null)
				orderFilterConfig = new OrderFilterConfig();
			this.txtFilterGoodsName.Text = string.Join(";", orderFilterConfig.lstFilterGoodsName);
			this.cmbFilterGoodsNameType.SelectedItem = cmbFilterGoodsNameType.Items.Cast<ComboBoxItem>().FirstOrDefault(tb => (tb.Content as TextBlock)?.Text == orderFilterConfig.FilterGoodsNameType);
			orderFilterConfig.chkHideGreenFlagIsChecked = true; // 隐藏标记
			orderFilterConfig.chkNoMultiOrderIsChecked = true; // 多子订单不显示
			orderFilterConfig.chkOnlyWarehouseOrderIsChecked = true; // 过滤非本系统订单
			orderFilterConfig.chkTransitOrderIsChecked = true; // 云仓
			orderFilterConfig.chkDirectOrderIsChecked = true; // 直发
			orderFilterConfig.chkTransitChangeDirectOrderIsChecked = true; // 云改直
			orderFilterConfig.lstFilterOrderIds = new ConcurrentList<string>();
			orderFilterConfig.lstFilterRemarkText = new ConcurrentList<string>();
			orderFilterConfig.txtFilterShopNameText = "";

			chkSyncDirectOrderWaybill.IsChecked = GlobalConfig.BuyConfig?.IsSyncDirectBuyOrderWaybill;

			dateStart.SelectedDate = DateTime.Now.Date.AddDays(-7);
			dateEnd.SelectedDate = DateTime.Now.Date.AddDays(1).AddSeconds(-1);

			borderFilterRemarkSelect.Visibility = Visibility.Collapsed;

			AutoGetOrder();

			TaskService.Instance.Start();
			TaskService.Instance.TaskChanged += Instance_TaskChanged;
		}



		//public void GetOrderTest()
		//{
		//	for (int i = 0; i < 10000; i++)
		//	{
		//		//lstOrder.Add(new oms_wei_order_info() { id = 1, IsSelect = false, order_id = ("3737033423685556736".ParseToLong() + Randomx.GetId(0,100)).ParseToString(), shop_name = "媛卡曦工厂优选" });
		//		GlobalConfig.lstOrder.Add(new oms_wei_order_info() { id = 1, IsSelect = false, order_id = Randomx.GetId(1000, 10000).ParseToString(), shop_name = "媛卡曦工厂优选" });
		//	}
		//	//GlobalConfig.lstOrder.SortDesc(o => o.order_id.ParseToLong());
		//}

		public void AutoGetOrder()
		{
			Task.Run(() =>
			{
				//Thread.Sleep(5000);
				while (true)
				{
					if (!IsAutoReadOrder)
					{
						Thread.Sleep(1000);
						Dispatcher.Invoke(new Action(() =>
						{
							btnSearch.Content = "自动读单暂停中";
							imgLoading.Visibility = Visibility.Collapsed;
						}));
						continue;
					}

					if (DateTime.Now > nextGetOrderTime)
					{
						Dispatcher.Invoke(new Action(() =>
						{
							btnSearch.Content = "读单";
						}));
						GetOrder();
						nextGetOrderTime = DateTime.Now.AddMinutes(25);
					}
					Thread.Sleep(1000);
					Dispatcher.Invoke(new Action(() =>
					{
						var ticks = nextGetOrderTime - DateTime.Now;
						btnSearch.Content = "读单 " + ticks.Minutes.ToString("00") + ":" + ticks.Seconds.ToString("00");
					}));
				}
			});
		}


		public bool hasReadOrder = false;
		/// <summary>
		/// 批量拉取订单
		/// </summary>
		/// <param name="filterGetCondition">按过滤条件读取读取服务端订单，已废弃</param>
		public void GetOrder(string orderIds = "", bool filterGetCondition = false)
		{
			while (!MainWindow.Instance.hasReadShop)
			{
				Thread.Sleep(100);
			}

			BottomMsg = "开始读取订单...";
			StartProgress();
			Dispatcher.Invoke(new Action(() =>
			{
				imgLoading.Visibility = Visibility.Visible;
				btnSearch.IsEnabled = false;
			}));
			int page = 0;
			int totalPage = 1;
			int pageSize = 50;
#if DEBUG
			pageSize = 200;
#endif

			while (true && (IsAutoReadOrder || !string.IsNullOrEmpty(orderIds)))
			{
				BottomMsg = "当前正在读取订单...，第" + (page + 1) + "页";
				if (page >= totalPage)
				{
					break;
				}
				Dispatcher.Invoke(new Action(() =>
				{
					imgLoading.Visibility = Visibility.Visible;
					btnSearch.IsEnabled = false;
				}));

				page++;
				var url = BaseClass.Build29WxObjString("order/get_erp_order_list");
				var data = UserLogin.GetSignaturex() + "&page=" + page;
				if (!string.IsNullOrEmpty(orderIds))
					data += "&erp_order_id_in=" + orderIds;
				if (page > 1)
					data += "&is_not_count=true";
				data += "&page_size=" + pageSize;
				var shop_id = string.Join(",", GlobalConfig.ShopLoginList.Select(s => s.ErpShopId).Where(s => !s.IsNullOrEmpty()));
				//指定订单id的查询，不再查询店铺id
				if (string.IsNullOrEmpty(orderIds))
					data += "&erp_shop_id_in=" + shop_id;
				 
				// 按过滤条件读取 已废弃
				//if (filterGetCondition)
				//{
				//	if (!string.IsNullOrEmpty(orderFilterConfig.txtFilterShopNameText))
				//	{
				//		var shopNames = orderFilterConfig.txtFilterShopNameText.Split(';').Where(s => !s.IsNullOrEmpty()).ToList();
				//		shop_id = string.Join(",", GlobalConfig.ShopLoginList.Where(s => shopNames.Contains(s.ShopAccount)).Select(s => s.ErpShopId).Where(s => !s.IsNullOrEmpty()));
				//	}
				//}
				var startTime = BaseClass.DateTimeToTimestampSeconds(DateStart);
				var endTime = BaseClass.DateTimeToTimestampSeconds(DateEnd.AddDays(1));
				if (!IsEndDate)
					endTime = BaseClass.DateTimeToTimestampSeconds(DateTime.Now.Date.AddDays(1));
				// 查询单一订单号订单，不按时间范围搜索
				if (string.IsNullOrEmpty(orderIds) || orderIds.Split(new string[] { ";", "；", ",", "，" }, StringSplitOptions.RemoveEmptyEntries).ToList().Count != 1)
				{
					data += "&start_time=" + startTime;
					data += "&end_time=" + endTime;
				}
				Thread.Sleep(200);

				var html = GetHtml.PostUtf8(url, data);
				if (string.IsNullOrEmpty(html) || !html.Contains("\"code\":200"))
					html = GetHtml.PostUtf8(url, data);
				if (string.IsNullOrEmpty(html) || !html.Contains("\"code\":200"))
				{
					BaseMsgWindow.ShowError("订单读取失败 " + BaseRegex.GetStringJson(ref html, "msg"));
					break;
				}

				var totalCount = BaseRegex.GetIntJson(ref html, "count");
				if (totalCount > 0)
					totalPage = Math.Ceiling(1m * totalCount / pageSize).ParseToInt();
				else
				{
				}

				if (html.Contains("3738686976228742912"))
				{ 
				}
				var seconds = BaseRegex.GetDecimalJson(ref html, "seconds");

				var jArr = JObject.Parse(html)["data"];
				if (jArr.Count() == 0)
					break;

				var order_ids = string.Join(",", jArr.Select(a => a["order_id"].ParseToString()));

				// 读取订单详情
				if (string.IsNullOrEmpty(order_ids))
					Thread.Sleep(100);
				List<oms_wei_order_item_info> orderItems = GetOrderItemInfo(order_ids);

				// 读取售后单
				if (string.IsNullOrEmpty(order_ids))
					Thread.Sleep(100);
				List<oms_wei_refund_info> refunds = GetOrderRefundInfo(order_ids);

				// 读订单扩展
				if (string.IsNullOrEmpty(order_ids))
					Thread.Sleep(100);
				List<order_item_ext> orderItemExts = GetOrderItemExts(order_ids);
				if (string.IsNullOrEmpty(order_ids))
				{
					foreach (var oie in orderItemExts)
					{
						// 移除订单物流异常信息，每次批量读单最后要去微信获取
						// 改为后台模拟读取不存在则设置为 ""
						//oie.abnormal_text = "";
					}
				}

				// 读取中转仓拍单订单
				var transitOrderList = GetTransitWarehouseList(order_ids);

				// 额外订单包裹补发
				var transitExtraPackageList = GetTransitExtraPackageList(order_ids);

				// 读取中转仓拍单订单售后状态
				var transitAfterSaleList = GetTransitWarehouseAfterSaleList(order_ids);

				// 读取分销退货（中转仓退货）订单
				var transitReturnOrderList = GetTransitReturnOrderList(order_ids);

				// 读取暂时记录的买手订单，后面想办法放到中转订单库里去
				var pddBuyerOrders = GetPddBuyerOrders(order_ids);
				// 读取暂时记录的淘宝买手订单（格式与拼多多的一致，存在不同的表中），后面想办法放到中转订单库里去
				pddBuyerOrders.AddRange(GetTbBuyerOrders(order_ids));

				// 读取暂时记录的买手售后单，后面想办法放到中转订单库里去
				var pddBuyerAfterSales = GetPddBuyerAfterSales(order_ids);
				// 读取暂时记录的淘宝买手售后单（格式与拼多多的一致，存在不同的表中），后面想办法放到中转订单库里去
				pddBuyerAfterSales.AddRange(GetTbBuyerAfterSales(order_ids));

				// 同步单
				var buyerIds = string.Join(",",  pddBuyerOrders.Select(o => o.order_sn));
				var syncLogistics = GetSyncLogistics(buyerIds);

				// 读取关联拍单商品
				var buyMapList = GetBuyProdMap(orderItems);

				// 读取关联拍单的所有sku
				var buyMapSkusList = GetBuyProdMapSkus(orderItems);

				// 读取物流轨迹
				var ewaybillLst = GetEWaybillPath(order_ids);

				// 装载订单
				foreach (JObject jObj in jArr)
				{
					try
					{
						oms_wei_order_info order = null;
						order = JsonHelper.DeserializeJsonToObject<oms_wei_order_info>(JsonHelper.SerializeObject(jObj));

						//装载订单商品详情
						order.orderItems = new ObservableCollection<oms_wei_order_item_info>();
						foreach (var item in orderItems.Where(oi => oi.order_id == order.order_id))
						{
							// 订单商品
							item.ItemOrder = order;
							order.orderItems.Add(item);

							item.OrderItemExt = orderItemExts.FirstOrDefault(ext => ext.order_id == item.order_id && item.sku_id == item.sku_id);

							// 已放到赋值函数中处理
							// 更新店铺是否加入代发情况
							//item.Shop = GlobalConfig.ShopLoginList.FirstOrDefault(s => s.ErpShopId == item.order_id);
							//Dispatcher.Invoke(new Action(() => { item.UpdateOrderItemBuyButton(); }));

							// 关联拍单关系  // 危险物品禁止拍单，仅关联安全商品
							//if (!GlobalConfig.lstDangerItemWord.Any(d => (item.title).ParseToString().Contains(d)))
							{
								var pddBuyMapLst = buyMapList.Where(m => m.platform == "pdd").ToList();
								item.PddBuyMap = pddBuyMapLst.FirstOrDefault(b => b.sku_code == item.out_sku_id && b.spu_code == item.out_product_id);
								if (item.PddBuyMap == null)
									item.PddBuyMap = pddBuyMapLst.FirstOrDefault(b => b.sku_code == item.SkuAttrStr && b.spu_code == item.out_product_id); 
								if (item.PddBuyMap == null)
									item.PddBuyMap = pddBuyMapLst.FirstOrDefault(b => b.sku_code == item.out_sku_id && b.spu_code == item.product_id);
								if (item.PddBuyMap == null)
									item.PddBuyMap = pddBuyMapLst.FirstOrDefault(b => b.sku_code == item.SkuAttrStr && b.spu_code == item.product_id);
							}
							item.PddBuyMapSkus = buyMapSkusList.Where(s => s.spu_code == item.out_product_id || s.spu_code == item.product_id).OrderByDescending(s => s.mdy_time)
								.Where(s => s.platform == "pdd").ToList();

							{
								var tbBuyMapLst = buyMapList.Where(m => m.platform == "tb").ToList();
								item.TbBuyMap = tbBuyMapLst.FirstOrDefault(b => b.sku_code == item.out_sku_id && b.spu_code == item.out_product_id);
								if (item.TbBuyMap == null)
									item.TbBuyMap = tbBuyMapLst.FirstOrDefault(b => b.sku_code == item.SkuAttrStr && b.spu_code == item.out_product_id);
								if (item.TbBuyMap == null)
									item.TbBuyMap = tbBuyMapLst.FirstOrDefault(b => b.sku_code == item.out_sku_id && b.spu_code == item.product_id);
								if (item.TbBuyMap == null)
									item.TbBuyMap = tbBuyMapLst.FirstOrDefault(b => b.sku_code == item.SkuAttrStr && b.spu_code == item.product_id);
							}
							item.TbBuyMapSkus = buyMapSkusList.Where(s => s.spu_code == item.out_product_id || s.spu_code == item.product_id).OrderByDescending(s => s.mdy_time)
								.Where(s => s.platform == "tb").ToList();



							// 中转仓订单
							if (item.ItemOrder.orderItems.Count > 1)
								item.ItemTransitOrders.AddRange(transitOrderList.Where(t => t.order_no == item.order_id && t.order_sku_id == item.sku_id));
							else
								item.ItemTransitOrders.AddRange(transitOrderList.Where(t => t.order_no == item.order_id));
							// 中转仓退货包裹订单
							if (item.order_id == "3739241588056569856")
							{

							}
							item.ItemTransitOrderAfterSales = transitAfterSaleList.Where(a => item.ItemTransitOrders.Any(t => t.out_order_no == a.order_code || t.order_code == a.order_code)).ToList();
							item.DistribReturnOrderInfos = transitReturnOrderList.Where(tr => tr.order_code_source == item.order_id).ToList();
							item.ItemTransitExtraOrders = transitExtraPackageList.Where(p => item.ItemTransitOrders.Any(t => t.order_code == p.order_code)).ToList();

							// 中转仓买手订单(wx_send_type等于0)
							item.PddBuyerOrders = pddBuyerOrders.Where(po => po.wx_order_id == item.order_id && po.wx_sku_id == item.sku_id && po.wx_send_type == 0).ToList();
							// 中转仓买手退货订单(wx_send_type等于0)
							item.PddBuyerAfterSales = pddBuyerAfterSales.Where(po => po.wx_order_id == item.order_id && po.wx_sku_id == item.sku_id && po.wx_send_type == 0).ToList();
							// 直发买手订单(wx_send_type等于1)
							item.DirectPddBuyerOrders = pddBuyerOrders.Where(po => po.wx_order_id == item.order_id && po.wx_sku_id == item.sku_id && po.wx_send_type == 1).ToList();
							// 直发买手退款订单(wx_send_type等于1)
							item.DirectPddBuyerAfterSales = pddBuyerAfterSales.Where(po => po.wx_order_id == item.order_id && po.wx_sku_id == item.sku_id && po.wx_send_type == 1).ToList();
						}

						// 装载订单售后详情
						order.refundItems = new ObservableCollection<oms_wei_refund_info>(refunds.Where(of => of.order_id == order.order_id));

						// 装载同步单
						order.SyncLogisticsList = [.. syncLogistics.Where(os => order.orderItems.Any(oi => oi.DirectPddBuyerOrders.Any(od => od.order_sn == os.order_id))),];
						if (order.SyncLogisticsList.Count > 0)
						{

						}


						if (order.order_id.Contains("3738794693820307200"))
						{

						}

						// 装载订单物流最后一条信息
						order.latestEWaybills = [.. ewaybillLst.Where(ew => ew.order_id == order.order_id.ParseToLong())];

						// 读取订单后立即赋值，防止滚动时实时赋值造成卡顿
						InitOrderObservableProp(order);

						// 删除再添加，触发更新。 todo: 如果已存在相同订单，则直接修改更新
						var orderExist = GlobalConfig.lstOrder.FirstOrDefault(o => o.order_id == order.order_id);
						while (orderExist != null)
						{
							GlobalConfig.lstOrder.Remove(orderExist);
							orderExist = GlobalConfig.lstOrder.FirstOrDefault(o => o.order_id == order.order_id);
						}
						GlobalConfig.lstOrder.Add(order);
						FilterOneOrder(order);
					}
					catch (Exception ex)
					{
					}
				}

				disPlayOrderTabOrderCount();
			}

			// 处理店铺后台物流异常单
			BottomMsg = "当前正在读取物流异常单...";
			if (string.IsNullOrEmpty(orderIds))
				GetShopWaybillExceptionOrder();

			// 处理拒收单
			BottomMsg = "当前正在处理拒收单...";
			if (string.IsNullOrEmpty(orderIds))
				Task.Run(async () =>
				{
					await AutoUpdateTransitRejectedToPddShop();
				});

			// 处理中转仓退货包裹
			BottomMsg = "当前正在处理拦截退回总店...";
			if (string.IsNullOrEmpty(orderIds))
				AutoUpdateTransitPackageToPddShop();

			// 处理退货仓分销退货
			BottomMsg = "当前正在处理分销退货...";
			if (string.IsNullOrEmpty(orderIds))
				Task.Run(async () =>
				{
					await DoReturnOrderBuyerRefendSlient();
					await DoReturnOrderTransitCreateSlient();
					await AutoUpdateTransitReturnOrderToPddShop();
				});

			if (string.IsNullOrEmpty(orderIds))
				hasReadOrder = true;

			CompleteProgress();
			BottomMsg = "订单读取完成";
			Dispatcher.Invoke(new Action(() =>
			{
				imgLoading.Visibility = Visibility.Collapsed;
				btnSearch.IsEnabled = true;
			}));
		}

		public static void InitOrderObservableProp(oms_wei_order_info order)
		{
			if (order != null && order.orderItems != null)
			{
				foreach (var orderItem in order.orderItems)
				{
					if (orderItem != null)
						orderItem.SetOrderItemTextProperty();
				}
				order.SetOrderTextProperty();
			}
		}
		public static void InitOrderItemObservableProp(oms_wei_order_item_info orderItem)
		{
			if (orderItem != null)
			{
				orderItem.SetOrderItemTextProperty();
				if (orderItem.ItemOrder != null)
					orderItem.ItemOrder.SetOrderTextProperty();
			}
		}

		/// <summary>
		/// 读取订单详情信息
		/// </summary>
		/// <param name="order_ids"></param>
		/// <returns></returns>
		public static List<oms_wei_order_item_info> GetOrderItemInfo(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<oms_wei_order_item_info>();
			var url = BaseClass.Build29WxObjString("order/get_erp_order_item_list");
			var data = UserLogin.GetSignaturex();
			data += "&erp_order_id_in=" + order_ids;
			data += "&page_size=" + 2500;
			var html = GetHtml.PostUtf8(url, data);
			if (string.IsNullOrEmpty(html) || !html.Contains("\"code\":200"))
				html = GetHtml.PostUtf8(url, data);
			if (string.IsNullOrEmpty(html) || !html.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("订单详情读取失败 " + BaseRegex.GetStringJson(ref html, "msg"), "Error", 5);
			}
			List<oms_wei_order_item_info> orderItems = new List<oms_wei_order_item_info>();
			try
			{
				orderItems = JsonHelper.DeserializeJsonToList<oms_wei_order_item_info>(JObject.Parse(html)["data"].ParseToString());
				if (orderItems == null)
					orderItems = new List<oms_wei_order_item_info>();
			}
			catch (Exception ex)
			{
				orderItems = new List<oms_wei_order_item_info>();
				BaseMsgWindow.ShowAnimateMessage("订单详情读取失败 " + ex.Message, "Error", 5);
			}
			return orderItems;
		}

		public static List<order_item_ext> GetOrderItemExts(string order_ids)
		{
			List<order_item_ext> existOrderExtList = new List<order_item_ext>();
			if (!string.IsNullOrEmpty(order_ids))
			{
				var url = BaseClass.Build29WxObjString("order/wx_get_order_item_ext_info");
				var data = UserLogin.GetSignaturex();
				data += "&wx_order_id_in=" + order_ids;
				var html = GetHtml.PostUtf8(url, data);
				if (!html.Contains("\"code\":200"))
					html = GetHtml.PostUtf8(url, data);
				if (!html.Contains("\"code\":200"))
				{
					BaseMsgWindow.ShowAnimateMessage("订单扩展信息查询失败 " + BaseRegex.GetStringJson(ref html, "msg"), "Error", 5);
				}
				try
				{
					existOrderExtList = JsonHelper.DeserializeJsonToList<order_item_ext>(JsonHelper.JObjectParse(html)["data"].ParseToString());
				}
				catch
				{
				}
			}
			return existOrderExtList;
		}

		/// <summary>
		/// 读取售后单
		/// </summary>
		/// <param name="order_ids"></param>
		/// <returns></returns>
		public static List<oms_wei_refund_info> GetOrderRefundInfo(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<oms_wei_refund_info>();
			Thread.Sleep(100);
			var url2 = BaseClass.Build29WxObjString("order/get_erp_refund_list");
			var data2 = UserLogin.GetSignaturex();
			data2 += "&erp_order_id_in=" + order_ids;
			var html2 = GetHtml.PostUtf8(url2, data2);
			if (string.IsNullOrEmpty(html2) || !html2.Contains("\"code\":200"))
				html2 = GetHtml.PostUtf8(url2, data2);
			if (string.IsNullOrEmpty(html2) || !html2.Contains("\"code\":200"))
			{
				//BaseMsgWindow.ShowError(MainWindow.Instance, "订单读取失败 " + BaseRegex.GetStringJson(ref html, "msg"));
				//break;
			}
			List<oms_wei_refund_info> refunds = new List<oms_wei_refund_info>();
			try { refunds = JsonHelper.DeserializeJsonToList<oms_wei_refund_info>(JObject.Parse(html2)["data"].ParseToString()); } catch { }
			return refunds;
		}

		public static List<oms_wei_external_procurement_log_info> GetTransitWarehouseList(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<oms_wei_external_procurement_log_info>();

			var url3 = BaseClass.Build29WxObjString("order/wx_get_transit_order");
			var data3 = UserLogin.GetSignaturex();
			data3 += "&order_no=" + order_ids;
			data3 += "&page_size=5000";
			var html3 = GetHtml.PostUtf8(url3, data3);
			if (string.IsNullOrEmpty(html3) || !html3.Contains("\"code\":200"))
				html3 = GetHtml.PostUtf8(url3, data3);
			if (string.IsNullOrEmpty(html3) || !html3.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("订单读取失败 " + BaseRegex.GetStringJson(ref html3, "msg"), "Error", 5);
			}
			List<oms_wei_external_procurement_log_info> transitOrderList = new List<oms_wei_external_procurement_log_info>();
			try
			{
				transitOrderList = JsonHelper.DeserializeJsonToList<oms_wei_external_procurement_log_info>(JObject.Parse(html3)["data"].ParseToString());
				return transitOrderList;
			}
			catch
			{
			}
			return new List<oms_wei_external_procurement_log_info>();
		}

		public static List<oms_wei_transfer_extra_package> GetTransitExtraPackageList(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<oms_wei_transfer_extra_package>();

			var url3 = BaseClass.Build29WxObjString("order/wx_get_transfer_extra_package");
			var data3 = UserLogin.GetSignaturex();
			data3 += "&order_no=" + order_ids;
			var html3 = GetHtml.PostUtf8(url3, data3);
			if (string.IsNullOrEmpty(html3) || !html3.Contains("\"code\":200"))
				html3 = GetHtml.PostUtf8(url3, data3);
			if (string.IsNullOrEmpty(html3) || !html3.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("订单读取失败 " + BaseRegex.GetStringJson(ref html3, "msg"), "Error", 5);
			}
			List<oms_wei_transfer_extra_package> transitExtraPackageList = new List<oms_wei_transfer_extra_package>();
			try
			{
				transitExtraPackageList = JsonHelper.DeserializeJsonToList<oms_wei_transfer_extra_package>(JObject.Parse(html3)["data"].ParseToString());
				return transitExtraPackageList;
			}
			catch
			{
			}
			return new List<oms_wei_transfer_extra_package>();
		}

		public static List<oms_wei_external_procurement_after_sale_info> GetTransitWarehouseAfterSaleList(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<oms_wei_external_procurement_after_sale_info>();

			// 读取中转仓处理售后单
			var url5 = BaseClass.Build29WxObjString("order/wx_get_transit_warehouse_aftersale_list");
			var data5 = UserLogin.GetSignaturex();
			data5 += "&wx_order_id_in=" + order_ids;
			var html5 = GetHtml.PostUtf8(url5, data5);
			if (string.IsNullOrEmpty(html5) || !html5.Contains("\"code\":200"))
				html5 = GetHtml.PostUtf8(url5, data5);
			if (string.IsNullOrEmpty(html5) || !html5.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("云仓售后订单读取失败 " + BaseRegex.GetStringJson(ref html5, "msg"), "Error", 5);
			}
			List<oms_wei_external_procurement_after_sale_info> transitAfterSaleList = new List<oms_wei_external_procurement_after_sale_info>();
			try
			{
				transitAfterSaleList = JsonHelper.DeserializeJsonToList<oms_wei_external_procurement_after_sale_info>(JObject.Parse(html5)["data"].ParseToString())
					.OrderByDescending(p => p.created_time).ToList();
				if (transitAfterSaleList != null)
					return transitAfterSaleList;
			}
			catch
			{
			}
			return new List<oms_wei_external_procurement_after_sale_info>();
		}

		public static List<distrib_return_order_info> GetTransitReturnOrderList(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<distrib_return_order_info>();

			// 读取中转仓处理售后单
			var url5 = BaseClass.Build29WxObjString("order/wx_get_erp_return_order_list");
			var data5 = UserLogin.GetSignaturex();
			data5 += "&erp_order_id_in=" + order_ids;
			var html5 = GetHtml.PostUtf8(url5, data5);
			if (string.IsNullOrEmpty(html5) || !html5.Contains("\"code\":200"))
				html5 = GetHtml.PostUtf8(url5, data5);
			if (string.IsNullOrEmpty(html5) || !html5.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("云仓分销退货订单读取失败 " + BaseRegex.GetStringJson(ref html5, "msg"), "Error", 5);
			}
			List<distrib_return_order_info> transitAfterSaleList = new List<distrib_return_order_info>();
			try
			{
				transitAfterSaleList = JsonHelper.DeserializeJsonToList<distrib_return_order_info>(JObject.Parse(html5)["data"].ParseToString())
					.OrderByDescending(p => p.created_at).ToList();
				if (transitAfterSaleList != null)
					return transitAfterSaleList;
			}
			catch
			{
			}
			return new List<distrib_return_order_info>();
		}

		public static List<order_pdd_buyer_order> GetPddBuyerOrders(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<order_pdd_buyer_order>();

			var url4 = BaseClass.Build29WxObjString("order/wx_get_buyer_order_list");
			var data4 = UserLogin.GetSignaturex();
			data4 += "&wx_order_id_in=" + order_ids;
			var html4 = GetHtml.PostUtf8(url4, data4);
			if (string.IsNullOrEmpty(html4) || !html4.Contains("\"code\":200"))
				html4 = GetHtml.PostUtf8(url4, data4);
			if (string.IsNullOrEmpty(html4) || !html4.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("订单读取失败(买手) " + BaseRegex.GetStringJson(ref html4, "msg"), "Error", 5);
			}
			List<order_pdd_buyer_order> pddBuyerOrders = new List<order_pdd_buyer_order>();
			try
			{
				pddBuyerOrders = JsonHelper.DeserializeJsonToList<order_pdd_buyer_order>(JObject.Parse(html4)["data"].ParseToString())
					.OrderByDescending(p => p.TransitCreateTime).ToList();
				return pddBuyerOrders;
			}
			catch
			{
			}
			return new List<order_pdd_buyer_order>();
		}

		public static List<order_pdd_buyer_order> GetTbBuyerOrders(string order_ids)
		{
			if (string.IsNullOrEmpty(order_ids))
				return new List<order_pdd_buyer_order>();

			var url4 = BaseClass.Build29WxObjString("order/wx_get_tb_buyer_order_list");
			var data4 = UserLogin.GetSignaturex();
			data4 += "&wx_order_id_in=" + order_ids;
			var html4 = GetHtml.PostUtf8(url4, data4);
			if (string.IsNullOrEmpty(html4) || !html4.Contains("\"code\":200"))
				html4 = GetHtml.PostUtf8(url4, data4);
			if (string.IsNullOrEmpty(html4) || !html4.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("订单读取失败(买手) " + BaseRegex.GetStringJson(ref html4, "msg"), "Error", 5);
			}
			List<order_pdd_buyer_order> pddBuyerOrders = new List<order_pdd_buyer_order>();
			try
			{
				pddBuyerOrders = JsonHelper.DeserializeJsonToList<order_pdd_buyer_order>(JObject.Parse(html4)["data"].ParseToString())
					.OrderByDescending(p => p.TransitCreateTime).ToList();
				return pddBuyerOrders;
			}
			catch
			{
			}
			return new List<order_pdd_buyer_order>();
		}

		public static List<order_pdd_buyer_after_sale> GetPddBuyerAfterSales(string order_ids)
		{
			var url6 = BaseClass.Build29WxObjString("order/wx_get_buyer_after_sale_list");
			var data6 = UserLogin.GetSignaturex();
			data6 += "&wx_order_id_in=" + order_ids;
			List<order_pdd_buyer_after_sale> pddBuyerAfterSales = new List<order_pdd_buyer_after_sale>();
			if (!string.IsNullOrEmpty(order_ids))
			{
				var html6 = GetHtml.PostUtf8(url6, data6);
				if (string.IsNullOrEmpty(html6) || !html6.Contains("\"code\":200"))
					html6 = GetHtml.PostUtf8(url6, data6);
				if (string.IsNullOrEmpty(html6) || !html6.Contains("\"code\":200"))
				{
					BaseMsgWindow.ShowAnimateMessage("订单读取失败(买手售后) " + BaseRegex.GetStringJson(ref html6, "msg"), "Error", 6);
					return new List<order_pdd_buyer_after_sale>();
				}
				try
				{
					pddBuyerAfterSales = JsonHelper.DeserializeJsonToList<order_pdd_buyer_after_sale>(JObject.Parse(html6)["data"].ParseToString()).OrderByDescending(p => p.TransitCreateTime).ToList();
					return pddBuyerAfterSales;
				}
				catch
				{
				}
			}
			return new List<order_pdd_buyer_after_sale>();
		}

		public static List<order_pdd_buyer_after_sale> GetTbBuyerAfterSales(string order_ids)
		{
			var url6 = BaseClass.Build29WxObjString("order/wx_get_tb_buyer_after_sale_list");
			var data6 = UserLogin.GetSignaturex();
			data6 += "&wx_order_id_in=" + order_ids;
			List<order_pdd_buyer_after_sale> pddBuyerAfterSales = new List<order_pdd_buyer_after_sale>();
			if (!string.IsNullOrEmpty(order_ids))
			{
				var html6 = GetHtml.PostUtf8(url6, data6);
				if (string.IsNullOrEmpty(html6) || !html6.Contains("\"code\":200"))
					html6 = GetHtml.PostUtf8(url6, data6);
				if (string.IsNullOrEmpty(html6) || !html6.Contains("\"code\":200"))
				{
					BaseMsgWindow.ShowAnimateMessage("订单读取失败(买手售后) " + BaseRegex.GetStringJson(ref html6, "msg"), "Error", 6);
					return new List<order_pdd_buyer_after_sale>();
				}
				try
				{
					pddBuyerAfterSales = JsonHelper.DeserializeJsonToList<order_pdd_buyer_after_sale>(JObject.Parse(html6)["data"].ParseToString()).OrderByDescending(p => p.TransitCreateTime).ToList();
					return pddBuyerAfterSales;
				}
				catch
				{
				}
			}
			return new List<order_pdd_buyer_after_sale>();
		}

		public static List<yh_sync_logistics> GetSyncLogistics(string buyer_order_ids, int? not_upload_pickup_status = null)
		{
			var url6 = BaseClass.Build29WxObjString("order/wx_get_sync_waybill");
			var data6 = UserLogin.GetSignaturex();
			data6 += "&order_id=" + buyer_order_ids;
			if (not_upload_pickup_status != null)
				data6 += "&not_upload_pickup_status=" + not_upload_pickup_status;
			List<yh_sync_logistics> pddBuyerAfterSales = new List<yh_sync_logistics>();
			if (!string.IsNullOrEmpty(buyer_order_ids))
			{
				var html6 = GetHtml.PostUtf8(url6, data6);
				if (string.IsNullOrEmpty(html6) || !html6.Contains("\"code\":200"))
					html6 = GetHtml.PostUtf8(url6, data6);
				if (string.IsNullOrEmpty(html6) || !html6.Contains("\"code\":200"))
				{
					BaseMsgWindow.ShowAnimateMessage("订单读取失败(买手售后) " + BaseRegex.GetStringJson(ref html6, "msg"), "Error", 6);
					return new List<yh_sync_logistics>();
				}
				try
				{
					pddBuyerAfterSales = JsonHelper.DeserializeJsonToList<yh_sync_logistics>(JObject.Parse(html6)["data"].ParseToString()).OrderByDescending(p => p.id).ToList();
					return pddBuyerAfterSales;
				}
				catch
				{
				}
			}
			return new List<yh_sync_logistics>();
		}

		public static List<oms_wei_ewaybill_path> GetEWaybillPath(string order_ids)
		{
			List<oms_wei_ewaybill_path> oms_wei_ewaybill_path_list = null;
			if (!string.IsNullOrEmpty(order_ids))
			{
				try
				{
					var url = BaseClass.Build29WxObjString("order/wx_get_erp_ewaybill_path_latest_list");
					var data = UserLogin.GetSignaturex();
					data += "&erp_order_id_in=" + order_ids;
					var html = GetHtml.PostUtf8(url, data);
					if (string.IsNullOrEmpty(html) || !html.Contains("\"code\":200"))
						html = GetHtml.PostUtf8(url, data);
					if (string.IsNullOrEmpty(html) || !html.Contains("\"code\":200"))
					{
						BaseMsgWindow.ShowAnimateMessage("物流查询失败 " + BaseRegex.GetStringJson(ref html, "msg"), "Error", 6);
					}
					else
					{
						oms_wei_ewaybill_path_list = JsonHelper.DeserializeJsonToList<oms_wei_ewaybill_path>(JObject.Parse(html)["data"].ParseToString()).OrderByDescending(p => p.update_time).ToList();
						return oms_wei_ewaybill_path_list;
					}
				}
				catch
				{
				}
			}
			return new List<oms_wei_ewaybill_path>();
		}

		public static List<WXBuyMapInfo> GetBuyProdMap(List<oms_wei_order_item_info> orderItems)
		{
			//foreach (var item in orderItems.ToList())
			//{
			//	var buyMap = GlobalConfig.BuyMapList.FirstOrDefault(b => b.sku_code == item.out_sku_id && b.spu_code == item.out_product_id);
			//	if (buyMap == null)
			//		buyMap = GlobalConfig.BuyMapList.FirstOrDefault(b => b.sku_code == item.SkuAttrStr && b.spu_code == item.out_product_id);
			//	if (buyMap == null)
			//		buyMap = GlobalConfig.BuyMapList.FirstOrDefault(b => b.sku_code == item.out_sku_id && b.spu_code == item.product_id);
			//	if (buyMap == null)
			//		buyMap = GlobalConfig.BuyMapList.FirstOrDefault(b => b.sku_code == item.SkuAttrStr && b.spu_code == item.product_id);

			//	if (buyMap != null)
			//		orderItems.Remove(item);
			//}
			if (orderItems == null || orderItems.Count == 0)
			{
				return GlobalConfig.BuyMapList.Where(m => orderItems.Any(oi => m.spu_code == oi.out_product_id || m.spu_code == oi.product_id)).ToList();
			}

			var urlMap = BaseClass.Build29WxObjString("order/wx_get_buy_prod_map");
			var dataMap = UserLogin.GetSignaturex()
				+ "&spu_codes=" + string.Join(",", orderItems.Select(oi => GetHtml.UrlEncodeUtf8(oi.out_product_id))) + "," + string.Join(",", orderItems.Select(oi => oi.product_id));
			dataMap += "&main_user_name=" + BaseClass.MainUserName;
			var resultMap = GetHtml.PostUtf8(urlMap, dataMap);
			if (string.IsNullOrEmpty(resultMap) || !resultMap.Contains("\"code\":200"))
				resultMap = GetHtml.PostUtf8(urlMap, dataMap);
			if (string.IsNullOrEmpty(resultMap) || !resultMap.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("订单关联读取失败 " + BaseRegex.GetStringJson(ref resultMap, "msg"), "Error", 5);
			}
			else
			{
				try
				{
					var buyMapList = JsonHelper.DeserializeJsonToList<WXBuyMapInfo>(JObject.Parse(resultMap)["data"].ParseToString());
					buyMapList = buyMapList.Where(b => !GlobalConfig.BuyMapList.Any(m => m.sku_code == b.sku_code && m.spu_code == b.spu_code)).ToList();
					GlobalConfig.BuyMapList.AddRange(buyMapList);
					if (buyMapList.Count > 0)
					{

					}
				}
				catch
				{
					return new List<WXBuyMapInfo>();
				}
			}
			return GlobalConfig.BuyMapList.Where(m => orderItems.Any(oi => m.spu_code == oi.out_product_id || m.spu_code == oi.product_id)).ToList();
		}

		public static List<WXBuyMapSkusInfo> GetBuyProdMapSkus(List<oms_wei_order_item_info> orderItems)
		{
			//orderItems.RemoveAll(oi => GlobalConfig.BuyMapSkusList.Any(m => m.spu_code == oi.out_product_id || m.spu_code == oi.product_id));
			if (orderItems == null || orderItems.Count == 0)
			{
				return GlobalConfig.BuyMapSkusList.Where(m => orderItems.Any(oi => m.spu_code == oi.out_product_id || m.spu_code == oi.product_id)).ToList();
			}

			var url = BaseClass.Build29WxObjString("order/wx_get_buy_pord_map_skus");
			var dataMap = UserLogin.GetSignaturex()
				+ "&spu_codes=" + string.Join(",", orderItems.Select(oi => GetHtml.UrlEncodeUtf8(oi.out_product_id))) + "," + string.Join(",", orderItems.Select(oi => oi.product_id));
			dataMap += "&main_user_name=" + BaseClass.MainUserName;
			var resultSkusMap = GetHtml.PostUtf8(url, dataMap);
			if (string.IsNullOrEmpty(resultSkusMap) || !resultSkusMap.Contains("\"code\":200"))
			{
				resultSkusMap = GetHtml.PostUtf8(url, dataMap);
			}
			if (string.IsNullOrEmpty(resultSkusMap) || !resultSkusMap.Contains("\"code\":200"))
			{
				BaseMsgWindow.ShowAnimateMessage("订单关联列表读取失败 " + BaseRegex.GetStringJson(ref resultSkusMap, "msg"), "Error", 5);
				return new List<WXBuyMapSkusInfo>();
			}
			try
			{
				var buyMapSkusList = JsonHelper.DeserializeJsonToList<WXBuyMapSkusInfo>(JObject.Parse(resultSkusMap)["data"].ParseToString());
				buyMapSkusList = buyMapSkusList.Where(b => !GlobalConfig.BuyMapSkusList.Any(m => m.map_goods_id == b.map_goods_id)).ToList();
				GlobalConfig.BuyMapSkusList.AddRange(buyMapSkusList);
			}
			catch
			{
				return new List<WXBuyMapSkusInfo>();
			}
			return GlobalConfig.BuyMapSkusList.Where(m => orderItems.Any(oi => m.spu_code == oi.out_product_id || m.spu_code == oi.product_id)).ToList();
		}

		public void GetShopWaybillExceptionOrder()
		{
			foreach (var shop in GlobalConfig.ShopLoginList)
			{
				if (shop.LoginStatus == "登录成功")
					ShopBLL.CheckShopLogin(shop);
				if (shop.LoginStatus != "登录成功")
					continue;

				var rst = WxSimAbnormalOrderSeach(shop, 100);
				//Thread.Sleep(Randomx.GetId(50, 150));
				if (rst.Contains("\"code\":0"))
				{
					try
					{
						JObject jObj = JsonHelper.JObjectParse(rst);
						var wxOrderIdIn = string.Join(",", jObj["orderList"].Select(j => j["commonInfo"]["orderId"].ParseToString()));
						var wxSkuIdIn = string.Join(",", jObj["orderList"].Select(j => (j["orderProductInfo"].FirstOrDefault()?["skuId"]).ParseToString()));

						// 异常单 异常需重拍
						List<order_item_ext> existOrderExtList = new List<order_item_ext>();
						if (!string.IsNullOrEmpty(wxOrderIdIn) && !string.IsNullOrEmpty(wxSkuIdIn))
						{
							var url = BaseClass.Build29WxObjString("order/wx_get_order_item_ext_info");
							var data = UserLogin.GetSignaturex();
							data += "&wx_order_id_in=" + wxOrderIdIn;
							data += "&wx_sku_id_in=" + wxSkuIdIn;
							var html = GetHtml.PostUtf8(url, data);
							if (!html.Contains("\"code\":200"))
								html = GetHtml.PostUtf8(url, data);
							if (!html.Contains("\"code\":200"))
							{
								BaseMsgWindow.ShowAnimateMessage("订单扩展信息查询失败 " + BaseRegex.GetStringJson(ref html, "msg"), "Error", 5);
								continue;
							}
							existOrderExtList = JsonHelper.DeserializeJsonToList<order_item_ext>(JsonHelper.JObjectParse(html)["data"].ParseToString());
						}

						// 先把已经物流异常但未查询到的订单改为正常
						var waybillExceptionOrders = GlobalConfig.lstOrder.Where(o => o.shop_id.ParseToString() == shop.ErpShopId && o.orderItems.Any(oi => oi.ShopWaybillExceptionStr == "物流异常")).ToList();
						foreach (var waybillExceptionOrder in waybillExceptionOrders)
						{
							if (!existOrderExtList.Any(oExt => oExt.order_id == waybillExceptionOrder.order_id))
							{
								foreach (var orderItem in waybillExceptionOrder.orderItems)
								{
									if (orderItem.OrderItemExt != null)
									{
										orderItem.OrderItemExt.abnormal_text = "";
										orderItem.ShopWaybillExceptionStr = "";
									}
								}

								// 更新显示
								InitOrderObservableProp(waybillExceptionOrder);
								MainWindow.Instance.orderListCtrl.FilterOneOrder(waybillExceptionOrder, true);

								var orderId = waybillExceptionOrder.order_id;
								order_item_ext orderExt = new order_item_ext() { order_id = orderId, shop_app_id = shop.ShopId, shop_name = shop.ShopAccount, abnormal_text = "物流异常" };

								var url1 = BaseClass.Build29WxObjString("order/wx_mdy_order_item_ext_info");
								var data1 = UserLogin.GetSignaturex();
								data1 += "&wx_order_id=" + orderExt.order_id;
								data1 += "&abnormal_text=";
								var html1 = GetHtml.PostUtf8(url1, data1);
								if (string.IsNullOrEmpty(html1) || !html1.Contains("\"code\":200"))
									html1 = GetHtml.PostUtf8(url1, data1);
							}
						}

						foreach (var od in jObj["orderList"])
						{
							var oStr = JsonHelper.SerializeObject(od);

							//var orderId = o["commonInfo"]["orderId"].ParseToString();
							var orderId = BaseRegex.GetStringJson(ref oStr, "orderId");

							if (orderId == "3737914129536416512")
							{

							}
							var skuId = BaseRegex.GetStringJson(ref oStr, "skuId");

							// 存在状态完全一样的订单异常信息就跳过
							order_item_ext orderExt = new order_item_ext() { order_id = orderId, sku_id = skuId, shop_app_id = shop.ShopId, shop_name = shop.ShopAccount, abnormal_text = "物流异常" };

							if (!existOrderExtList.Any(eoe => eoe.order_id == orderExt.order_id && eoe.sku_id == orderExt.sku_id && eoe.abnormal_text == orderExt.abnormal_text))
							{
								var url1 = BaseClass.Build29WxObjString("order/wx_add_order_item_ext_info");
								if (existOrderExtList.Any(eoe => eoe.order_id == orderExt.order_id && eoe.sku_id == orderExt.sku_id))
									url1 = BaseClass.Build29WxObjString("order/wx_mdy_order_item_ext_info");
								var data1 = UserLogin.GetSignaturex();
								data1 += "&wx_order_id=" + orderExt.order_id;
								data1 += "&wx_sku_id=" + orderExt.sku_id;
								data1 += "&shop_app_id=" + orderExt.shop_app_id;
								data1 += "&shop_name=" + orderExt.shop_name;
								data1 += "&abnormal_text=" + orderExt.abnormal_text;
								var html1 = GetHtml.PostUtf8(url1, data1);
								if (string.IsNullOrEmpty(html1) || !html1.Contains("\"code\":200"))
								{
									BaseMsgWindow.ShowAnimateMessage("订单扩展信息写入失败 " + BaseRegex.GetStringJson(ref html1, "msg"), "Error", 5);
									break;
								}
							}
							else
							{
								orderExt = existOrderExtList.FirstOrDefault(eoe => eoe.order_id == orderExt.order_id && eoe.sku_id == orderExt.sku_id && eoe.abnormal_text == orderExt.abnormal_text);
							}

							// 更新订单附加信息
							if (orderExt.order_id == "3737845591459133952")
							{

							}
							var order = GlobalConfig.lstOrder.ToList().FirstOrDefault(o => o.order_id == orderExt.order_id);
							if (order != null)
							{
								var orderItem = order.orderItems.ToList().FirstOrDefault(oi => oi.sku_id == orderExt.sku_id);
								if (orderItem != null)
								{
									orderItem.OrderItemExt = orderExt;

									InitOrderObservableProp(order);
									MainWindow.Instance.orderListCtrl.FilterOneOrder(order, true);
								}
							}
						}
					}
					catch (Exception ex)
					{
						BaseMsgWindow.ShowAnimateMessage("订单扩展信息查询失败 " + ex.Message, "Error", 5);
					}
				}
			}
		}

		/// <summary>
		/// 中转仓拒收去总店填写退货拒收信息
		/// </summary>
		public async Task AutoUpdateTransitRejectedToPddShop()
		{
			foreach (var order in GlobalConfig.lstOrder)
			{
				foreach (var orderItem in order.orderItems)
				{
					if (orderItem.order_id == "3738552208766960384")
					{

					}
					if (orderItem.TransitRefundStatusStr.ParseToString().Contains("需手动申请售后") &&
						orderItem.ItemTransitOrderWithVoid?.has_reject == 3 /*&& orderItem.ItemTransitOrderWithVoid?.platform != "XDYYWC"*/) // 义乌仓不支持拒收，等于3也是失败
					{
						// 拒收后24小时才去总店填拒收退货
						if (orderItem.ItemTransitOrderWithVoid?.rejected_time > DateTime.Now.AddHours(-24))
							break;

						await OrderListRowItemCtrl.PddRefundTransitRejectOrder(orderItem);

						// 赋值显示订单元素
						InitOrderItemObservableProp(orderItem);
						MainWindow.Instance.orderListCtrl.FilterOneOrder(order);

						// 第一个订单多个商品暂不支持，只操作一条记录
						break;
					}
				}
			}
		}

		/// <summary>
		/// 中转仓拦截去总店填写退货物流信息（申请拦截退回总店以后回填退货物流）
		/// </summary>
		public void AutoUpdateTransitPackageToPddShop()
		{
			Task.Run(() =>
			{
				foreach (var order in GlobalConfig.lstOrder)
				{
					foreach (var orderItem in order.orderItems)
					{
						//// 测试写死
						//if (orderItem.ItemOrder?.order_id == "3738160750339728384")
						//{
						//    orderItem.ItemTransitOrderAfterSale = new oms_wei_external_procurement_after_sale_info()
						//    {
						//        downstream_waybill = "315090716621027",
						//    };
						//}
						// 260801-439070256640980 260801-439070256640980
						// string url = "https://mobile.yangkeduo.com/complaint.html?mode=128&after_sales_id=22059412840967&order_sn=260801-439070256640980"
						if (orderItem.TransitRefundStatusStr.Contains("待用户发货") && !(orderItem.ItemTransitOrderAfterSale?.downstream_waybill).IsNullOrEmpty())
						{
							string orderSn = orderItem.ItemTransitOrderWithVoid.out_order_no;
							if (orderSn.IsNullOrEmpty())
								continue;
							string buyerNickName = orderItem.ItemTransitOrderWithVoid.buyer_account;
							if (buyerNickName.IsNullOrEmpty())
								continue;
							var buyer = GlobalConfig.PDDBuyerLoginList.ToList().FirstOrDefault(b => b.buyer_nick == buyerNickName);
							if (buyer == null)
								continue;
							var afterSalesId = orderItem.PddBuyerAfterSale?.afterSalesId;
							if (string.IsNullOrEmpty(afterSalesId))
								continue;
							var waybillId = orderItem.ItemTransitOrderAfterSale.downstream_waybill;

							var chkRst = AddReturnPddShopPackageInfocheck(buyer, orderSn, afterSalesId, waybillId);
							var type = 4;
							if (chkRst.Contains("\"interactType\":0"))
								type = 2;
							var result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", type.ToString());
							if (!result.Contains("\"result\":\"ok\""))
							{
								type = type == 4 ? 2 : 4;
								result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", type.ToString());
							}
							if (!result.Contains("\"result\":\"ok\""))
							{
								result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", "5");
							}

							if (result.Contains("\"result\":\"ok\""))
							{
								orderItem.ItemTransitOrderWithVoid.refund_status = "商家处理中";
							}
							else
							{
								orderItem.ItemTransitOrderWithVoid.refund_status = "待用户发货 自动退货失败";
							}
							var pddBuyerOrderLiteInfo = new PddBuyerOrderLiteInfo()
							{
								ShopOrderIdStr = orderItem.order_id,
								order_sn = orderSn,
							};
							// 更新中转仓退货信息
							var e57Rst = PDDBuyerOrderReadCtrl.SendTransitAfterSaleE57(pddBuyerOrderLiteInfo, orderItem.ItemTransitOrderWithVoid.refund_status);
							if (e57Rst.Contains("<code>0</code>") || e57Rst.Contains("<code>200</code>"))
							{
								BaseMsgWindow.ShowAnimateMessage("买手退款信息更新成功", "Msg", 5);
							}
							else
							{
								var msg = BaseRegex.GetStringXml(ref e57Rst, "msg");
								BaseMsgWindow.ShowAnimateMessage("买手退款信息更新失败，服务端返回 " + msg, "Error", 5);
							}
							// 赋值显示订单元素
							InitOrderItemObservableProp(orderItem);
							MainWindow.Instance.orderListCtrl.FilterOneOrder(order);
						}
					}
				}
			});
		}

		/// <summary>
		/// 退货仓去总店填写退货物流信息
		/// </summary>
		public async Task AutoUpdateTransitReturnOrderToPddShop()
		{
			await Task.Run(() =>
			{
				foreach (var order in GlobalConfig.lstOrder)
				{
					foreach (var orderItem in order.orderItems)
					{
						if (orderItem.order_id == "3739105285145538816")
						{
						}
						if (order.OrderBuyType == "直发" || order.OrderBuyType == "云改直")
						{
							if (order.out_after_sale_status.ParseToString().Contains("待用户发货") && !(orderItem.DistribReturnOrderInfo?.real_logistics_express_code).IsNullOrEmpty())
							{
								string orderSn = order.out_order_no;
								if (orderSn.IsNullOrEmpty() || orderSn.StartsWith("tb_")) // 无外采或淘宝外采直接退出
									continue;
								string buyerNickName = order.out_account;
								if (buyerNickName.IsNullOrEmpty())
									continue;
								var buyer = GlobalConfig.PDDBuyerLoginList.ToList().FirstOrDefault(b => b.buyer_nick == buyerNickName);
								if (buyer == null)
									continue;
								var afterSalesId = orderItem.DirectPddBuyerAfterSale?.afterSalesId;
								if (string.IsNullOrEmpty(afterSalesId))
									continue;
								var waybillId = orderItem.DistribReturnOrderInfo?.real_logistics_express_code;

								var chkRst = AddReturnPddShopPackageInfocheck(buyer, orderSn, afterSalesId, waybillId);
								var type = 4;
								if (chkRst.Contains("\"interactType\":0"))
									type = 2;
								var result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", type.ToString());
								if (!result.Contains("\"result\":\"ok\""))
								{
									type = type == 4 ? 2 : 4;
									result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", type.ToString());
								}
								if (!result.Contains("\"result\":\"ok\""))
								{
									result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", "5");
								}

								if (result.Contains("\"result\":\"ok\""))
								{
									orderItem.DirectPddBuyerAfterSale.statusText = "商家处理中";
									order.out_after_sale_status = "商家处理中";
								}
								else
								{
									orderItem.DirectPddBuyerAfterSale.statusText = "待用户发货 自动退货失败";
									order.out_after_sale_status = "待用户发货 自动退货失败";
								}
								var pddBuyerOrderLiteInfo = new PddBuyerOrderLiteInfo()
								{
									ShopOrderIdStr = orderItem.order_id,
									order_sn = orderSn,
								};
								// 更新退货信息
								var e57Rst = PDDBuyerOrderReadCtrl.SendAfterSaleE57NeedManual(pddBuyerOrderLiteInfo, order.out_after_sale_status);
								if (e57Rst.Contains("<code>0</code>") || e57Rst.Contains("<code>200</code>"))
								{
									var url3 = BaseClass.Build29WxObjString("order/wx_add_mdy_buyer_after_sale");
									var data3 = UserLogin.GetSignaturex();
									data3 += "&wx_order_id=" + orderItem.DirectPddBuyerAfterSale.wx_order_id;
									data3 += "&wx_sku_id=" + orderItem.DirectPddBuyerAfterSale.wx_sku_id;
									data3 += "&buyerId=" + orderItem.DirectPddBuyerAfterSale.buyerId;
									data3 += "&buyerName=" + orderItem.DirectPddBuyerAfterSale.buyerName;
									data3 += "&orderAmount=" + orderItem.DirectPddBuyerAfterSale?.orderAmount;
									data3 += "&orderSn=" + orderItem.DirectPddBuyerAfterSale.orderSn;
									data3 += "&afterSalesId=" + orderItem.DirectPddBuyerAfterSale.afterSalesId;
									data3 += "&orderDate=" + orderItem.DirectPddBuyerAfterSale.orderDate;
									data3 += "&refundAmount=" + orderItem.DirectPddBuyerAfterSale.refundAmount;
									data3 += "&statusText=" + orderItem.DirectPddBuyerAfterSale.statusText;
									data3 += "&wx_send_type=" + orderItem.DirectPddBuyerAfterSale.wx_send_type;

									var html3 = GetHtml.PostUtf8(url3, data3);
									if (string.IsNullOrEmpty(html3) || !html3.Contains("\"code\":200"))
										html3 = GetHtml.PostUtf8(url3, data3);

									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新成功", "Msg", 3);
									Thread.Sleep(Randomx.GetId(10000, 12001));
								}
								else
								{
									var msg = BaseRegex.GetStringXml(ref e57Rst, "msg");
									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新失败，服务端返回 " + msg, "Error", 5);
								}
							}
						}
						else
						{
							if (orderItem.TransitRefundStatusStr.ParseToString().Contains("待用户发货") && !(orderItem.DistribReturnOrderInfo?.real_logistics_express_code).IsNullOrEmpty())
							{
								string orderSn = orderItem.ItemTransitOrderWithVoid.out_order_no;
								if (orderSn.IsNullOrEmpty())
									continue;
								string buyerNickName = orderItem.ItemTransitOrderWithVoid.buyer_account;
								if (buyerNickName.IsNullOrEmpty())
									continue;
								var buyer = GlobalConfig.PDDBuyerLoginList.ToList().FirstOrDefault(b => b.buyer_nick == buyerNickName);
								if (buyer == null)
									continue;
								if (buyer.status == "掉线")
								{
									BaseMsgWindow.ShowAnimateMessage("买手号 " + buyer.buyer_nick + " 掉线，跳过自动退货", "Msg", 5);
									continue;
								}
								var afterSalesId = orderItem.PddBuyerAfterSale?.afterSalesId;
								if (string.IsNullOrEmpty(afterSalesId))
									continue;
								var waybillId = orderItem.DistribReturnOrderInfo?.real_logistics_express_code;

								var chkRst = AddReturnPddShopPackageInfocheck(buyer, orderSn, afterSalesId, waybillId);
								var type = 4;
								if (chkRst.Contains("\"interactType\":0"))
									type = 2;
								var result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", type.ToString());
								if (!result.Contains("\"result\":\"ok\""))
								{
									type = type == 4 ? 2 : 4;
									result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", type.ToString());
								}
								if (!result.Contains("\"result\":\"ok\""))
								{
									result = AddReturnPddShopPackageInfo(buyer, orderSn, afterSalesId, waybillId, "韵达快递", "121", "5");
								}

								if (result.Contains("\"result\":\"ok\""))
								{
									orderItem.ItemTransitOrderWithVoid.refund_status = "商家处理中";
								}
								else
								{
									orderItem.ItemTransitOrderWithVoid.refund_status = "待用户发货 自动退货失败";
								}
								var pddBuyerOrderLiteInfo = new PddBuyerOrderLiteInfo()
								{
									ShopOrderIdStr = orderItem.order_id,
									order_sn = orderSn,
								};
								// 更新中转仓退货信息
								var e57Rst = PDDBuyerOrderReadCtrl.SendTransitAfterSaleE57(pddBuyerOrderLiteInfo, orderItem.ItemTransitOrderWithVoid.refund_status);
								if (e57Rst.Contains("<code>0</code>") || e57Rst.Contains("<code>200</code>"))
								{
									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新成功", "Msg", 5);
								}
								else
								{
									var msg = BaseRegex.GetStringXml(ref e57Rst, "msg");
									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新失败，服务端返回 " + msg, "Error", 5);
								}
							}
						}
						// 赋值显示订单元素
						InitOrderItemObservableProp(orderItem);
						MainWindow.Instance.orderListCtrl.FilterOneOrder(order);
					}
				}
			});
		}


		public void disPlayOrderTabOrderCount()
		{
			//var orders = string.Join("','", GlobalConfig.lstFilterOrder.Select(o => o.order_id));
			//var orders1 = string.Join(",", GlobalConfig.lstFilterOrder.Select(o => o.order_id));
			var userOrderLst = GlobalConfig.lstOrder.Where(o => GlobalConfig.ShopLoginList.Any(s => s.ErpShopId.ParseToLong() == o.shop_id)).ToList();

			//TabItem tabItem = null;
			//List<TabItem> tabItems = this.tabOrderType.Items.Cast<TabItem>().ToList();
			{
				var lstCount = userOrderLst.Where(r => r.IsWaitBuy).Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "待采购")).Count();
				WaitBuyTabTxt = "待采购(" + lstCount + "|" + filteLstTmpCount + ")";
			}
			{
				var lstCount = userOrderLst.Where(r => r.IsWaitSend).Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "待发货")).Count();
				WaitSendTabTxt = "待发货(" + lstCount + "|" + filteLstTmpCount + ")";
			}
			{
				var lstCount = userOrderLst.Where(r => r.IsWaitReceive).Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "待收货")).Count();
				WaitReceiveTabTxt = "待收货(" + lstCount + "|" + filteLstTmpCount + ")";
			}
			{
				var lstCount = userOrderLst.Where(r => r.IsRefund).Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "售后完成单")).Count();
				RefundTabTxt = "售后完成单(" + lstCount + "|" + filteLstTmpCount + ")";
			}
			{
				var lstCount = userOrderLst.Where(r => r.IsEmergencyManualReturnOrder).Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "需处理售后单")).Count();
				EmergencyManualReturnOrderTabTxt = "需处理售后单(" + lstCount + "|" + filteLstTmpCount + ")";
			}
			{
				var lstCount = userOrderLst.Where(r => r.IsEmergencyDistribReturnOrder).Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "退货仓自动售后单")).Count();
				EmergencyDistribReturnOrderTabTxt = "退货仓自动售后单(" + lstCount + "|" + filteLstTmpCount + ")";
			}
			{
				var lstCount = userOrderLst.Where(r => r.IsAbnormal).Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "异常需重拍")).Count();
				AbnormalTabTxt = "异常需重拍(" + lstCount + "|" + filteLstTmpCount + ")";
			}
			{
				var lstCount = userOrderLst.Count();
				var filteLstTmpCount = userOrderLst.Where(o => !GetOrderIsFilter(o, "全部订单")).Count();
				AllOrderTabTxt = "全部订单(" + lstCount + "|" + filteLstTmpCount + ")";
			}
		}

		CancellationTokenSource TokenSource = null;
		public void FilterOrders()
		{
			if (TokenSource != null)
				TokenSource.Cancel();
			TokenSource = new CancellationTokenSource();

			Task.Run(() =>
			{
				var token = TokenSource.Token;
				try
				{
					if (this.lbxOrder == null)
						return;

					if (token.IsCancellationRequested)
						return;
					Dispatcher.Invoke(new Action(() =>
					{
						GlobalConfig.lstFilterOrder.Clear();
						//GlobalConfig.lstFilterOrder = new ObservableCollection<oms_wei_order_info>(orderLstTmp);
						GlobalConfig.lstFilterOrder = new ObservableCollection<oms_wei_order_info>();
						this.lbxOrder.ItemsSource = GlobalConfig.lstFilterOrder;
					}));

					if (token.IsCancellationRequested)
						return;
					var orderLstTmp = new List<oms_wei_order_info>();
					if (GlobalConfig.OrderTabHeaderStr.StartsWith("需处理售后单") || GlobalConfig.OrderTabHeaderStr.StartsWith("退货仓自动售后单"))
						orderLstTmp = GlobalConfig.lstOrder.Where(o => !GetOrderIsFilter(o)).OrderByDescending(o => o.RefundDatetime).ToList();
					else if (GlobalConfig.OrderTabHeaderStr.StartsWith("异常需重拍"))
						orderLstTmp = GlobalConfig.lstOrder.Where(o => !GetOrderIsFilter(o)).OrderByDescending(o => o.update_time).ToList();
					else
						orderLstTmp = GlobalConfig.lstOrder.Where(o => !GetOrderIsFilter(o)).OrderByDescending(o => o.create_time).ToList();

					if (token.IsCancellationRequested)
						return;
					disPlayOrderTabOrderCount();

					int n = 0;
					foreach (var order in orderLstTmp)
					{
						//if (n++ % 10 == 0)
						Thread.Sleep(1);

						if (token.IsCancellationRequested)
							break;

						var orders = GlobalConfig.lstFilterOrder.ToList();
						if (!orders.Any(o => o.order_id == order.order_id))
						{
							Dispatcher.InvokeAsync(() =>
							{
								lock (MainWindow._orderLock)
								{
									GlobalConfig.lstFilterOrder.Add(order);
								}
							});
						}
					}
				}
				catch (Exception ex)
				{
				}
			});
		}

		public void FilterOneOrder(string orderId, bool updateTabCount = false)
		{
			var orderExist = GlobalConfig.lstFilterOrder.ToList().FirstOrDefault(o => o.order_id == orderId);
			FilterOneOrder(orderExist, updateTabCount);
		}

		public void FilterOneOrder(oms_wei_order_info order, bool updateTabCount = false)
		{
			if (order == null)
				return;

			oms_wei_order_info orderExist = null;
			
			lock (MainWindow._orderLock)
			{
				orderExist = GlobalConfig.lstFilterOrder.ToList().FirstOrDefault(o => o.order_id == order.order_id);
			}
			while (orderExist != null)
			{
				Dispatcher.Invoke(() =>
				{
					GlobalConfig.lstFilterOrder.Remove(orderExist);
				});
				orderExist = GlobalConfig.lstFilterOrder.ToList().FirstOrDefault(o => o.order_id == order.order_id);
			}

			if (!GetOrderIsFilter(order))
			{
				var index = -1;
				oms_wei_order_info nextOrder = null;
				lock (MainWindow._orderLock)
				{
					if (GlobalConfig.OrderTabHeaderStr.StartsWith("需处理售后单") || GlobalConfig.OrderTabHeaderStr.StartsWith("退货仓自动售后单"))
						nextOrder = GlobalConfig.lstFilterOrder.ToList().FirstOrDefault(o => o.RefundDatetime < order.RefundDatetime);
					else if (GlobalConfig.OrderTabHeaderStr.StartsWith("异常需重拍"))
						nextOrder = GlobalConfig.lstFilterOrder.ToList().FirstOrDefault(o => o.update_time < order.update_time);
					else
						nextOrder = GlobalConfig.lstFilterOrder.ToList().FirstOrDefault(o => o.create_time < order.create_time);
				}
				if (nextOrder != null)
					index = GlobalConfig.lstFilterOrder.IndexOf(nextOrder);
				Dispatcher.InvokeAsync(() =>
				{
					lock (MainWindow._orderLock)
					{
						if (nextOrder != null && index >= 0 && GlobalConfig.lstFilterOrder.Count > index)
						{
							GlobalConfig.lstFilterOrder.Insert(index, order);
						}
						else
						{
							GlobalConfig.lstFilterOrder.Add(order);
						}
					}
				});
				Thread.Sleep(1);
			}

			if (updateTabCount)
			{
				disPlayOrderTabOrderCount();
			}
		}

		bool GetOrderIsFilter(oms_wei_order_info order, string filterHeadStr = null)
		{
			if (order == null)
				return true;

			if (order.order_id == "3738687160199289344")
			{

			}

			// 过滤id
			if (orderFilterConfig.lstFilterOrderIds.Count > 0)
			{
				if (!orderFilterConfig.lstFilterOrderIds.Contains(order.order_id))
					return true;
			}
			// 其他一级过滤选项
			else
			{
				if (orderFilterConfig.chkHideGreenFlagIsChecked == true && order.colour_flag == 4)
					return true;

				if (!GlobalConfig.ShopLoginList.Any(s => s.ErpShopId.ParseToLong() == order.shop_id))
					return true;

				if (!string.IsNullOrEmpty(strSearchAll))
				{
					bool isFilter = true;
					// 买手物流
					if (order.orderItems.Any(oi => oi.ItemTransitOrders.Any(t => t.express_1_waybill.ParseToString().Contains(strSearchAll))))
						isFilter = false;
					// 仓库物流
					else if (order.orderItems.Any(oi => oi.ItemTransitOrders.Any(t => t.express_2_waybill.ParseToString().Contains(strSearchAll))))
						isFilter = false;
					// 退货物流
					else if (order.refundItems.Any(ri => ri.return_waybill_id.ParseToString().Contains(strSearchAll)))
						isFilter = false;
					// 退货单号
					else if (order.refundItems.Any(ri => ri.after_sale_order_id.ParseToString().Contains(strSearchAll)))
						isFilter = false;
					// 仓库采购单号
					else if (order.orderItems.Any(oi => oi.ItemTransitOrders.Any(t => t.out_order_no.ParseToString().Contains(strSearchAll))))
						isFilter = false;
					// 仓库退款单号
					else if (order.orderItems.Any(oi => oi.ItemTransitOrderAfterSales.Any(t => t.refund_waybill.ParseToString().Contains(strSearchAll))))
						isFilter = false;
					// 直发订单号
					else if (order.out_order_no.Contains(strSearchAll))
						isFilter = false;
					// 直发物流单号
					else if (order.out_express_no.Contains(strSearchAll))
						isFilter = false;
					if (isFilter)
						return true;
				}

				// 过滤店铺名称
				if (!string.IsNullOrWhiteSpace(orderFilterConfig?.txtFilterShopNameText) && !(";" + orderFilterConfig?.txtFilterShopNameText + ";").Contains(";" + order.shop_name + ";"))
				{
					return true;
				}
				// 过滤商品名称
				if (orderFilterConfig.lstFilterGoodsName != null && orderFilterConfig.lstFilterGoodsName.Count > 0)
				{
					if (orderFilterConfig.FilterGoodsNameType == "标题包含" && !orderFilterConfig.lstFilterGoodsName.Any(name => order.orderItems.Any(it => it.title.Contains(name))))
						return true;
					else if (orderFilterConfig.FilterGoodsNameType == "标题不含" && orderFilterConfig.lstFilterGoodsName.Any(name => order.orderItems.Any(it => it.title.Contains(name))))
						return true;
				}
				// 过滤多子单订单
				if (orderFilterConfig.chkNoMultiOrderIsChecked && order.orderItems.Count() > 1)
				{
					return true;
				}
				// 过滤非中转仓订单
				if (orderFilterConfig.chkOnlyWarehouseOrderIsChecked && !order.IsWaitBuy &&
					order.orderItems.All(oi => oi.ItemTransitOrderWithVoid == null) && order.orderItems.All(oi => oi.OrderItemExt?.buy_type != "直发"))
				{
					return true;
				}
				// 过滤备注
				if (orderFilterConfig.chkFilterRemarkIsChecked && orderFilterConfig.lstFilterRemarkText != null && orderFilterConfig.lstFilterRemarkText.Count > 0)
				{
					if (orderFilterConfig.FilterRemarkType == "店铺备注包含" && !orderFilterConfig.lstFilterRemarkText.Contains(order.shop_remark))
						return true;
					else if (orderFilterConfig.FilterRemarkType == "软件备注包含" && !orderFilterConfig.lstFilterRemarkText.Contains(order.soft_remark))
						return true;
					else if (orderFilterConfig.FilterRemarkType == "店铺备注不含" && orderFilterConfig.lstFilterRemarkText.Contains(order.shop_remark))
						return true;
					else if (orderFilterConfig.FilterRemarkType == "软件备注不含" && orderFilterConfig.lstFilterRemarkText.Contains(order.soft_remark))
						return true;
				}
				if (!orderFilterConfig.chkDirectOrderIsChecked == true && order.OrderBuyType == "直发")
					return true;
				if (!orderFilterConfig.chkTransitOrderIsChecked == true && order.OrderBuyType == "云仓")
					return true;
				if (!orderFilterConfig.chkTransitChangeDirectOrderIsChecked == true && order.OrderBuyType == "云改直")
					return true;

				if (chkNoPickupNumOrderIsChecked == true)
				{
					if (order.SyncWaybillIdInfo.IsNullOrEmpty())
						return true;
					if (!order.SyncWaybillPickNo.IsNullOrEmpty())
						return true;
				}

				// 过滤时间范围 
				if (OrderTimeFilterType == "更新时间")
				{
					if (order.UpdateDateTime < DateStart)
					{
						return true;
					}
					if (IsEndDate == true && order.UpdateDateTime > DateEnd.AddDays(1))
					{
						return true;
					}
				}
				else if (OrderTimeFilterType == "成交时间")
				{
					if (order.CreateDateTime < DateStart)
					{
						return true;
					}
					else if (IsEndDate == true && order.CreateDateTime > DateEnd.AddDays(1))
					{
						return true;
					}
				}
			}

			try
			{
				return FilterTabPage(order, filterHeadStr);
			}
			catch (Exception ex)
			{
				BaseMsgWindow.ShowAnimateMessage("订单 " + order.order_id + " 子筛选发生错误：" + ex.Message);
				return false;
			}
		}

		/// <summary>
		/// 过滤标签页
		/// </summary>
		/// <param name="order"></param>
		/// <param name="filterHeadStr"></param>
		/// <returns></returns>
		private bool FilterTabPage(oms_wei_order_info order, string filterHeadStr)
		{
			// 过滤标签页
			if (filterHeadStr.IsNullOrEmpty())
				filterHeadStr = GlobalConfig.OrderTabHeaderStr;

			if (filterHeadStr.StartsWith("全部订单"))
			{
				return false;
			}
			if (filterHeadStr.StartsWith("待采购"))
			{
				if (order.order_id == "3739161507780018688")
				{

				}
				if (!order.IsWaitBuy)
					return true;
				if (chkMapSkuIsChecked == true && order.orderItems.Any(oi => oi.PddBuyMap == null))
					return true;
				if (chkMapProdIsChecked == true && order.orderItems.All(oi => oi.PddBuyMapSkus == null || oi.PddBuyMapSkus.Count == 0 || oi.PddBuyMap != null))
					return true;
				if (chkNoMapProdIsChecked == true && (order.orderItems.All(oi => oi.PddBuyMap != null) || order.orderItems.All(oi => oi.PddBuyMapSkus != null && oi.PddBuyMapSkus.Count > 0)))
					return true;
			}
			if (filterHeadStr.StartsWith("待发货"))
			{
				if (!order.IsWaitSend)
					return true;

				// 直拍发货失败
				if (chkDirectSendFailedIsChecked == true)
				{
					var rst2 = order.out_shipped == 2 && !string.IsNullOrEmpty(order.out_express_no);
					if (!rst2)
						return true;
				}

				if (chkWaitSend72HourNoWaybillIsChecked == true)
				{
					if (order.orderItems.Any(oi => oi.DirectPddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && bOrder?.order_time <= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72))))
					{ }
					// 直发没有单号正常发货才判断中转仓总店是否超时发货
					else if (order.orderItems.Any(oi => (oi.DirectPddBuyerOrders?.Count).IsNullOrZero() && 
					    oi.PddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && bOrder?.order_time <= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72))))
					{ }
					else
						return true;
				}
				else if (chkWaitSend48HourNoWaybillIsChecked == true)
				{
					if (order.orderItems.Any(oi => oi.DirectPddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && (bOrder?.order_time < BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-48)) &&
						bOrder.order_time >= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72)))))
					{ }
					// 直发没有单号才判断中转仓总店是否超时发货
					else if (order.orderItems.Any(oi => (oi.DirectPddBuyerOrders?.Count).IsNullOrZero() && 
					    oi.PddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && (bOrder?.order_time < BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-48)) &&
						bOrder.order_time >= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72)))))
					{ }
					else
						return true;
				}
			}
			if (filterHeadStr.StartsWith("待收货"))
			{
				if (!order.IsWaitReceive)
					return true;

				// 需核对物流
				if (chkNeedCheckExpressIsChecked == true)
				{
					var rst1 = order.orderItems.Any(oi => !oi.TransitRefundStatusStr.IsNullOrEmpty() && !oi.TransitRefundStatusStr.Contains("退款成功"));
					var rst2 = order.out_shipped == 2 && !string.IsNullOrEmpty(order.out_express_no);
					if (!rst1 && !rst2)
						return true;
				}

				if (chkWaitReceiveBuyerIsNotSendIsChecked == true && order.orderItems.All(oi => oi.BuyerTransitWaybillStatusStr != "买手未发货"))
					return true;
				if (chkWaitReceiveBuyerIsSendIsChecked == true && order.orderItems.All(oi => oi.BuyerTransitWaybillStatusStr != "买手已发货"))
					return true;
				if (chkWaitReceiveBuyerIsInWarehouseIsChecked == true && order.orderItems.All(oi => oi.BuyerTransitWaybillStatusStr != "买手已送达"))
					return true;

				if (chkWaitReceiveWarehouseIsNotPickupIsChecked == true && order.orderItems.All(oi => oi.WarehouseWaybillStatusStr != "中转待取号"))
					return true;
				if (chkWaitReceiveWarehouseIsPickupIsChecked == true && order.orderItems.All(oi => oi.WarehouseWaybillStatusStr != "中转提前取号" && oi.WarehouseWaybillStatusStr != "中转已取号" && oi.WarehouseWaybillStatusStr != "中转已入库"))
					return true;
				if (chkWaitReceiveWarehouseIsSendOutIsChecked == true && order.orderItems.All(oi => oi.WarehouseWaybillStatusStr != "中转已出库"))
					return true;

				if (chk72HourNoWaybillIsChecked == true)
				{
					// 直发没有单号才判断中转仓总店是否超时发货
					if (order.orderItems.Any(oi => oi.DirectPddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && bOrder?.order_time <= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72))))
					{ }
					else if (order.orderItems.Any(oi => (oi.DirectPddBuyerOrders?.Count).IsNullOrZero() && 
						oi.PddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && bOrder?.order_time <= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72))))
					{  }
					else
						return true;
				}
				else if (chk48HourNoWaybillIsChecked == true)
				{
					// 直发没有单号才判断中转仓总店是否超时发货
					if (order.orderItems.Any(oi => oi.DirectPddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && (bOrder?.order_time < BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-48)) &&
						bOrder.order_time >= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72)))))
					{ }
					else if (order.orderItems.Any(oi =>(oi.DirectPddBuyerOrders?.Count).IsNullOrZero() && 
					    oi.PddBuyerOrders.OrderByDescending(bo => bo.order_time).FirstOrDefault() is order_pdd_buyer_order bOrder &&
						(bOrder?.tracking_number).IsNullOrEmpty() && (bOrder?.order_time < BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-48)) &&
						bOrder.order_time >= BaseClass.DateTimeToTimestampSeconds(DateTime.Now.AddHours(-72)))))
					{ }
					else
						return true;
				}
			}
			if (filterHeadStr.StartsWith("异常需重拍") && !order.IsAbnormal)
			{
				return true;
			}
			if (filterHeadStr.StartsWith("需处理售后单"))
			{
				if (!order.IsEmergencyManualReturnOrder)
					return true;

				if (cmbRejectStatusText == "未申请" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseRejectStr == "未申请"))
					return true;
				if (cmbRejectStatusText == "申请中" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseRejectStr == "已申请拒收"))
					return true;
				if (cmbRejectStatusText == "申请成功" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseRejectStr.StartsWith("申请成功")))
					return true;
				if (cmbRejectStatusText == "申请失败" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseRejectStr.StartsWith("申请失败")))
					return true;
				if (cmbRejectStatusText == "拒收成功" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseRejectStr.StartsWith("拒收成功")))
					return true;

				if (order.order_id == "3739296914665288192")
				{

				}
				if (cmbReturnPackageStatusText == "未拦截" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseAfterSaleStr == "未添加"))
					return true;
				if (cmbReturnPackageStatusText == "拦截中" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseAfterSaleStr == "已添加"))
					return true;
				if (cmbReturnPackageStatusText == "拦截成功" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseAfterSaleStr.StartsWith("拦截成功")))
					return true;
				if (cmbReturnPackageStatusText == "拦截失败" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseAfterSaleStr.StartsWith("拦截失败")))
					return true;


				if (chkEmergencyBuyerWaitAfterSaleIsChecked == true && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("需手动申请售后")))
					return true;
				else if (chkEmergencyBuyerWaitSendBackIsChecked == true && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("待用户发货")))
					return true;
				else if (chkEmergencyBuyerWaitSupplierRefundIsChecked == true && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("商家处理中")))
					return true;
				else if (chkEmergencyBuyerRefundFailIsChecked == true && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("退款失败")))
					return true;

				if (chkEmergencyShopCustomRefundHasWaybillIsChecked == true && order.orderItems.Any(oi => oi.ReturnWaybillIdStr.IsNullOrEmpty()))
					return true;
				else if (chkEmergencyShopCustomRefundNoWaybillIsChecked == true && order.orderItems.All(oi => !oi.ReturnWaybillIdStr.IsNullOrEmpty()))
					return true;

				//// 退货仓
				//if (chkReturnOrderAddressIsChecked == true && order.orderItems.Any(oi => oi.ItemRefund?.return_detail != GlobalConfig.TransitReturnOrderReturnAddress))
				//	return true;
				//// 非退货仓
				//else if (chkNotReturnOrderAddressIsChecked == true && order.orderItems?.Any(oi => oi.ItemRefund?.return_detail == GlobalConfig.TransitReturnOrderReturnAddress))
				//	return true;

				// 商家受理中
				if (chkEmergencyWaitSupplierAcceptIsChecked == true && !order.orderItems.Any(oi => oi.ItemRefund?.RefundStatusStr == "商家受理中"))
					return true;
				// 待商家收货
				if (chkEmergencyWaitSupplierReceiveIsChecked == true && !order.orderItems.Any(oi => oi.ItemRefund?.RefundStatusStr == "待商家收货"))
					return true;
				// 退款完成(但买手没退)
				if (chkEmergencyShopAfterSaleSuccessIsChecked == true && order.DeliveryDeadlineStatusStr != "退款完成")
					return true;
				// 退款中
				else if (chkEmergencyShopInAfterSaleIsChecked == true && (order.DeliveryDeadlineStatusStr != "退款中"))
					return true;

				// 退货退款
				if (chkEmergencyReturnIsChecked == true && !(order.refundItems?.OrderByDescending(or => or.create_time).FirstOrDefault()?.type).ParseToString().Contains("RETURN"))
					return true;
				// 仅退款
				else if (chkEmergencyRefundIsChecked == true && !(order.refundItems?.OrderByDescending(or => or.create_time).FirstOrDefault()?.type).ParseToString().Contains("REFUND"))
					return true;
			}
			if (filterHeadStr.StartsWith("退货仓自动售后单"))
			{
				if (!order.IsEmergencyDistribReturnOrder)
					return true;
				// 退款完成(但买手没退)
				if (chkShopIsRefundIsChecked == true && order.DeliveryDeadlineStatusStr != "退款完成")
					return true;
				// 退款中
				else if (chkShopIsNotRefundIsChecked == true && (order.DeliveryDeadlineStatusStr != "退款中"))
					return true;

				// 地址解析失败
				if (chkUpShopAddressAnalyseFailedIsChecked == true)
				{
					if (order.OrderBuyType == "云仓")
					{
						if (order.orderItems.Any(oi => string.IsNullOrEmpty(oi.PddBuyerAfterSale?.afterSaleAddress)))
							return true;

						foreach (var orderItem in order.orderItems)
						{
							var receiver = TransitReturnOrderWindow.PddAddressAnalysis(orderItem.PddBuyerAfterSale?.afterSaleAddress);
							if (!receiver.receiver_address.IsNullOrEmpty() && receiver.receiver_name.Length <= 15)
								return true;
						}
					}
					else
					{
						if (order.orderItems.Any(oi => string.IsNullOrEmpty(oi.DirectPddBuyerAfterSale?.afterSaleAddress)))
							return true;

						foreach (var orderItem in order.orderItems)
						{
							var receiver = TransitReturnOrderWindow.PddAddressAnalysis(orderItem.DirectPddBuyerAfterSale?.afterSaleAddress);
							if (!receiver.receiver_address.IsNullOrEmpty() && receiver.receiver_name.Length <= 15)
								return true;
						}
					}
				}

				if (cmbReturnOrderStatusText == "未创建" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseReturnOrderStr == "未创建"))
					return true;
				if (cmbReturnOrderStatusText == "创建失败" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseReturnOrderStr == "创建失败"))
					return true;
				if (cmbReturnOrderStatusText == "已创建未到仓" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseReturnOrderStr.StartsWith("已创建未到仓")))
					return true;
				if (cmbReturnOrderStatusText == "已到仓" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseReturnOrderStr.StartsWith("已到仓")))
					return true;
				if (cmbReturnOrderStatusText == "已发回" && !order.orderItems.Any(oi => oi.AddEditTransitWarehouseReturnOrderStr.StartsWith("已发回")))
					return true;

				if (cmbReturnOrderBuyerStatusText == "买手待申请售后" && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("需手动申请售后")))
					return true;
				else if (cmbReturnOrderBuyerStatusText == "买手待退货" && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("待用户发货")))
					return true;
				else if (cmbReturnOrderBuyerStatusText == "买手已寄出待商家退款" && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("商家处理中")))
					return true;
				else if (cmbReturnOrderBuyerStatusText == "买手退货失败" && order.orderItems.All(oi => !oi.TransitRefundStatusStr.Contains("退款失败")))
					return true;
			}
			if (filterHeadStr.StartsWith("售后完成单"))
			{
				if (!order.IsRefund)
					return true;

				if (chkAftersaleIsSendIsChecked == true && !order.DeliveryDeadlineStr.Contains("已发货"))
					return true;
				else if (chkAftersaleIsNotSendIsChecked == true && !order.DeliveryDeadlineStr.Contains("未发货"))
					return true;

				if (chkAftersaleBuyerIsBuyIsChecked == true && order.orderItems.All(oi => oi.BuyerTransitWaybillStatusStr.IsNullOrEmpty()))
					return true;
				if (chkAftersaleWarehouseIsNotPickupIsChecked == true && order.orderItems.All(oi => oi.WarehouseWaybillStatusStr != "中转待取号" && !oi.WarehouseWaybillStatusStr.Contains("取号异常")))
					return true;
				if (chkAftersaleWarehouseIsPickupIsChecked == true && order.orderItems.All(oi => oi.WarehouseWaybillStatusStr != "中转提前取号" && oi.WarehouseWaybillStatusStr != "中转已取号" &&
																								  oi.WarehouseWaybillStatusStr != "中转已入库" && oi.WarehouseWaybillStatusStr != "中转已出库"))
					return true;
			}
			return false;
		}

		private void btnMultiShopChoice_Click(object sender, RoutedEventArgs e)
		{
			MainWindow.Instance.shopListCtrl.IsVisibleChanged -= ShopListCtrl_IsVisibleChanged;
			MainWindow.Instance.shopListCtrl.Visibility = Visibility.Visible;
			MainWindow.Instance.shopListCtrl.IsVisibleChanged += ShopListCtrl_IsVisibleChanged;
		}

		private void ShopListCtrl_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
		{
			if (!MainWindow.Instance.shopListCtrl.IsVisible && MainWindow.Instance.shopListCtrl.IsAcceptChoiceShop == true)
			{
				var list = MainWindow.Instance.shopListCtrl.lbxShop.ItemsSource as ObservableCollection<ShopLoginInfo>;
				if (list != null)
					this.txtShopName.Text = string.Join(";", list.Where(s => s.IsSelect == true).Select(s => s.ShopAccount));

				FilterOrders();
			}
			MainWindow.Instance.shopListCtrl.IsVisibleChanged -= ShopListCtrl_IsVisibleChanged;
		}

		private void btnSearch_Click(object sender, RoutedEventArgs e)
		{
			this.btnSearch.IsEnabled = false;

			Task.Run(() =>
			{
				Thread.Sleep(5000);
				Dispatcher.Invoke(new Action(() => { this.btnSearch.IsEnabled = true; }));
			});
			//Task.Run(() =>
			//{
			//	GetOrder();
			//	nextGetOrderTime = DateTime.Now.AddMinutes(25);
			//});
			nextGetOrderTime = DateTime.Now;
		}

		private async void btnFilter_Click(object sender, RoutedEventArgs e)
		{
			CheckVirtualizationStatus(this.lbxOrder);

			if (orderFilterConfig.lstFilterOrderIds.Count == 1 && !GlobalConfig.lstOrder.Any(o => o.order_id == orderFilterConfig.lstFilterOrderIds.FirstOrDefault()))
			{
				await Task.Run(() => { this.GetOrder(orderFilterConfig.lstFilterOrderIds.FirstOrDefault()); });
			}
			FilterOrders();
		}

		private void dgOrderHeader_ColumnDisplayIndexChanged(object sender, DataGridColumnEventArgs e)
		{
		}

		private async void dgOrderHeader_LayoutUpdated(object sender, EventArgs e)
		{
			//await Task.Run(() => { });

			foreach (var item in lbxOrder.Items)
			{
				ListBoxItem container = (ListBoxItem)lbxOrder.ItemContainerGenerator.ContainerFromIndex(lbxOrder.Items.IndexOf(item));
				if (container != null)
				{
					// 找到grid控件并修改列大小
					var grids = UiCtrlUtils.FindVisualChildAll<Grid>(container, "gridListItem");
					foreach (var grid in grids)
					{
						for (int i = 0; i < grid.ColumnDefinitions.Count; i++)
						{
							if (dgOrderHeader.Columns.Count > i)
							{
								// 最后一列因滚动条变窄，已在表头补偿
								if (i == grid.ColumnDefinitions.Count - 1)
									grid.ColumnDefinitions[i].Width = new GridLength(Math.Max(0, dgOrderHeader.Columns[i].ActualWidth - 0));
								else
									grid.ColumnDefinitions[i].Width = new GridLength(dgOrderHeader.Columns[i].ActualWidth);
							}
						}
					}
				}
			}
		}

		private void ChkSelectAll_Checked(object sender, RoutedEventArgs e)
		{
			foreach (var order in GlobalConfig.lstOrder.ToList())
			{
				order.IsSelect = true;
			}
		}

		private void ChkSelectAll_Unchecked(object sender, RoutedEventArgs e)
		{
			foreach (var order in GlobalConfig.lstOrder.ToList())
			{
				order.IsSelect = false;
			}
		}

		private void ChkSelectAll_Loaded(object sender, RoutedEventArgs e)
		{
			chkSelectAll = sender as CheckBox;
		}

		public void UpdateChkAllBox()
		{
			chkSelectAll.Checked -= ChkSelectAll_Checked;
			chkSelectAll.Unchecked -= ChkSelectAll_Unchecked;
			if (GlobalConfig.lstFilterOrder.All(s => s.IsSelect))
				chkSelectAll.IsChecked = true;
			else if (GlobalConfig.lstFilterOrder.All(s => !s.IsSelect))
				chkSelectAll.IsChecked = false;
			else
				chkSelectAll.IsChecked = null;
			chkSelectAll.Checked += ChkSelectAll_Checked;
			chkSelectAll.Unchecked += ChkSelectAll_Unchecked;
		}

		private void txtSearchAll_TextChanged(object sender, TextChangedEventArgs e)
		{
			strSearchAll = txtSearchAll.Text.Trim();
		}

		private void tabOrderType_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (this.IsLoaded)
			{
				GlobalConfig.lstFilterOrder.Clear();
				GlobalConfig.lstFilterOrder = new ObservableCollection<oms_wei_order_info>();
				this.lbxOrder.ItemsSource = GlobalConfig.lstFilterOrder;

				dgHeaderTime.Header = ColumnHeaderTitle = "交易时间 ▼";
			}
			GlobalConfig.OrderTabHeaderStr = ((tabOrderType.SelectedItem as TabItem)?.Header).ParseToString();
			FilterOrders();
		}
		
		private void chkMapProd_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkNoMapProd.IsChecked = chkMapProd.IsChecked = chkMapSku.IsChecked = false;
				chk.IsChecked = !isCheck;
				chkNoMapProdIsChecked = chkNoMapProd.IsChecked.ParseToBool();
				chkMapProdIsChecked = chkMapProd.IsChecked.ParseToBool();
				chkMapSkuIsChecked = chkMapSku.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		public static string addNotes(ShopLoginInfo shop, string orderId, string notes, int tagColor = -1)
		{
			string url = "https://store.weixin.qq.com/shop-faas/mmchannelstradeorder/common/cgi/batchMerchantNotes?token=&lang=zh_CN";
			string body = @"{""items"":[{""orderId"":""" + orderId + @""",""merchantNotes"":""" + notes + @""",""merchantNotesTagColor"":" + tagColor + @"}]}";
			if (tagColor == -1)
				body = @"{""items"":[{""orderId"":""" + orderId + @""",""merchantNotes"":""" + notes + @"""}]}";

			string refere = "https://store.weixin.qq.com/shop/order/list";
			var result = HttpResponseWXBLL.WeiXinPostResponse(shop, url, body, refere);
			return result;
		}
		public static string addNotesFlag(ShopLoginInfo shop, string orderId, string notes, int tagColor = 0)
		{
			string url = "https://store.weixin.qq.com/shop-faas/mmchannelstradeorder/common/cgi/batchMerchantNotes?token=&lang=zh_CN";
			string body = @"{""items"":[{""orderId"":""" + orderId + @""",""merchantNotesTagColor"":" + tagColor + @"}]}";

			string refere = "https://store.weixin.qq.com/shop/order/list";
			var result = HttpResponseWXBLL.WeiXinPostResponse(shop, url, body, refere);
			return result;
		}

		private void chkAutoReadBuyerOrder_CheckedChanged(object sender, RoutedEventArgs e)
		{
			IsAutoReadOrder = chkAutoReadOrder.IsChecked == true;
		}

		private void TabItem_SizeChanged(object sender, SizeChangedEventArgs e)
		{
			var tabItems = this.tabOrderType.Items.Cast<TabItem>();

			Point position1 = txtFilterRemark.TranslatePoint(new Point(0, 0), gridOrderListCtrl);
			Point position2 = txtFilterRemark.TranslatePoint(new Point(0, 0), wpFilter);
			borderFilterRemarkSelect.Margin = new Thickness(tabItems.Sum(t => t.ActualWidth) + 16 + position2.X, position1.Y + txtFilterRemark.ActualHeight + 3, 0, 0);
		}

		private void chkSubFilterSonditions_Checked(object sender, RoutedEventArgs e)
		{
			FilterOrders();
		}

		/// <summary>
		/// 待处理订单买手售后状态过滤
		/// </summary>
		private void chkEmergencyBuyerAfterSale_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkEmergencyBuyerWaitAfterSale.IsChecked = chkEmergencyBuyerWaitSendBack.IsChecked = chkEmergencyBuyerWaitSupplierRefund.IsChecked = chkEmergencyBuyerRefundFail.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkEmergencyBuyerWaitAfterSaleIsChecked        = chkEmergencyBuyerWaitAfterSale.IsChecked.ParseToBool();
				chkEmergencyBuyerWaitSendBackIsChecked         = chkEmergencyBuyerWaitSendBack.IsChecked.ParseToBool();
				chkEmergencyBuyerWaitSupplierRefundIsChecked   = chkEmergencyBuyerWaitSupplierRefund.IsChecked.ParseToBool();
				chkEmergencyBuyerRefundFailIsChecked           = chkEmergencyBuyerRefundFail.IsChecked.ParseToBool();
			}
			FilterOrders();
		}
		/// <summary>
		/// 待处理订单店铺买家售后物流状态过滤
		/// </summary>
		private void chkEmergencyShopCustomRefundWaybill_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkEmergencyShopCustomRefundHasWaybill.IsChecked = chkEmergencyShopCustomRefundNoWaybill.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkEmergencyShopCustomRefundHasWaybillIsChecked = chkEmergencyShopCustomRefundHasWaybill.IsChecked.ParseToBool();
				chkEmergencyShopCustomRefundNoWaybillIsChecked = chkEmergencyShopCustomRefundNoWaybill.IsChecked.ParseToBool();
			}
			FilterOrders();
		}
		/// <summary>
		/// 待处理订单店铺售后状态过滤
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void chkEmergencyShopAfterSale_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkEmergencyWaitSupplierReceive.IsChecked = chkEmergencyWaitSupplierAccept.IsChecked = chkEmergencyShopAfterSaleSuccess.IsChecked = chkEmergencyShopInAfterSale.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkEmergencyWaitSupplierReceiveIsChecked   = chkEmergencyWaitSupplierReceive.IsChecked.ParseToBool();
				chkEmergencyWaitSupplierAcceptIsChecked   = chkEmergencyWaitSupplierAccept.IsChecked.ParseToBool();
				chkEmergencyShopAfterSaleSuccessIsChecked = chkEmergencyShopAfterSaleSuccess.IsChecked.ParseToBool();
				chkEmergencyShopInAfterSaleIsChecked       = chkEmergencyShopInAfterSale.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		/// <summary>
		/// 待收货 买手发货状态
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void chkWaitReceiveBuyerStatus_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkWaitReceiveBuyerIsSend.IsChecked = chkWaitReceiveBuyerIsNotSend.IsChecked = chkWaitReceiveBuyerIsInWarehouse.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkWaitReceiveBuyerIsSendIsChecked = chkWaitReceiveBuyerIsSend.IsChecked.ParseToBool();
				chkWaitReceiveBuyerIsNotSendIsChecked = chkWaitReceiveBuyerIsNotSend.IsChecked.ParseToBool();
				chkWaitReceiveBuyerIsInWarehouseIsChecked = chkWaitReceiveBuyerIsInWarehouse.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkWaitReceiveWarehouseStatus_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkWaitReceiveWarehouseIsNotPickup.IsChecked = chkWaitReceiveWarehouseIsPickup.IsChecked = chkWaitReceiveWarehouseIsSendOut.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkWaitReceiveWarehouseIsNotPickupIsChecked = chkWaitReceiveWarehouseIsNotPickup.IsChecked.ParseToBool();
				chkWaitReceiveWarehouseIsPickupIsChecked    = chkWaitReceiveWarehouseIsPickup.IsChecked.ParseToBool();
				chkWaitReceiveWarehouseIsSendOutIsChecked   = chkWaitReceiveWarehouseIsSendOut.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkAftersaleSendStatus_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkAftersaleIsSend.IsChecked = chkAftersaleIsNotSend.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkAftersaleIsSendIsChecked = chkAftersaleIsSend.IsChecked.ParseToBool();
				chkAftersaleIsNotSendIsChecked = chkAftersaleIsNotSend.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkAftersaleBuyerStatus_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkAftersaleBuyerIsBuy.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkAftersaleBuyerIsBuyIsChecked = chkAftersaleBuyerIsBuy.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkAftersaleWarehouseStatus_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkAftersaleWarehouseIsPickup.IsChecked = chkAftersaleWarehouseIsNotPickup.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkAftersaleWarehouseIsPickupIsChecked = chkAftersaleWarehouseIsPickup.IsChecked.ParseToBool();
				chkAftersaleWarehouseIsNotPickupIsChecked = chkAftersaleWarehouseIsNotPickup.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private async void btnBatchRefund_Click(object sender, RoutedEventArgs e)
		{
			var orders = GlobalConfig.lstFilterOrder.Where(o => o.IsSelect == true && o.IsEmergency);
			List<oms_wei_order_item_info> tmpOrderItems = new List<oms_wei_order_item_info>();
			foreach (var order in orders)
			{
				foreach (var orderItem in order.orderItems)
				{
					if (orderItem?.ItemOrder?.OrderBuyType == "云仓")
					{
						if (!string.IsNullOrEmpty(orderItem.ItemTransitOrderWithVoid?.out_order_no) && orderItem.PddBuyerAfterSaleAddressStr.IsNullOrEmpty() &&
							(orderItem.TransitRefundStatusStr.Contains("需手动申请售后") || orderItem.TransitRefundStatusStr.Contains("待用户发货")))
							tmpOrderItems.Add(orderItem);
					}

					if (orderItem?.ItemOrder?.OrderBuyType == "直发")
					{
						if (orderItem != null && !string.IsNullOrEmpty(orderItem.ItemOrder?.out_order_no) && orderItem.DirectPddBuyerAfterSaleAddressStr.IsNullOrEmpty() &&
							((orderItem.ItemOrder?.out_after_sale_status).ParseToString().Contains("需手动申请售后") || (orderItem.ItemOrder?.out_after_sale_status).ParseToString().Contains("待用户发货")))
							tmpOrderItems.Add(orderItem);
					}
					// 云改直有两个买手单，暂时只处理直发的，云仓默认已退款
					if (orderItem?.ItemOrder?.OrderBuyType == "云改直")
					{
						if (orderItem != null && !string.IsNullOrEmpty(orderItem.ItemOrder?.out_order_no) && orderItem.DirectPddBuyerAfterSaleAddressStr.IsNullOrEmpty() &&
							((orderItem.ItemOrder?.out_after_sale_status).ParseToString().Contains("需手动申请售后") || (orderItem.ItemOrder?.out_after_sale_status).ParseToString().Contains("待用户发货")))
							tmpOrderItems.Add(orderItem);
					}
				}
			}
			if (tmpOrderItems.Count == 0)
			{
				BaseMsgWindow.ShowAnimateMessage("未选中需要需手动申请售后的订单", "Error", 3);
				return;
			}

			await DoBuyerRefend(tmpOrderItems);
		}

		/// <summary>
		/// 自动拒收 小兰做，维护数据库，软件负责展示
		/// </summary>
		/// <returns></returns>
		public async Task DoRejectSlient()
		{

		}

		/// <summary>
		/// 中转仓拦截退货包裹申请买手退货退款并获取总店地址，暂时不使用此功能防止需交涉或者可拒收的订单被自动申请退货退款
		/// </summary>
		/// <returns></returns>
		public async Task DoReturnPackageBuyerRefendSlient()
		{
			List<oms_wei_order_info> emergencyRefundOrders = new List<oms_wei_order_info>();
			Dispatcher.Invoke(new Action(() =>
			{
				emergencyRefundOrders = GlobalConfig.lstOrder.Where(o => o.IsEmergency).ToList();
			}));
			List<oms_wei_order_item_info> tmpOrderItems = new List<oms_wei_order_item_info>();
			foreach (var order in emergencyRefundOrders)
			{
				foreach (var orderItem in order.orderItems)
				{
					// 用户仅退款的，拦截并退回总店，已到仓后自动去拼多多申请退货退款
					if (orderItem.ItemRefund?.type != "REFUND")
						continue;
					if (orderItem.ItemTransitOrder?.warehouse_status != 3)
						continue;

					if (orderItem?.ItemOrder?.OrderBuyType == "云仓")
					{
						if (!string.IsNullOrEmpty(orderItem.ItemTransitOrderWithVoid?.out_order_no) && orderItem.PddBuyerAfterSaleAddressStr.IsNullOrEmpty() &&
							(orderItem.TransitRefundStatusStr.Contains("需手动申请售后") || orderItem.TransitRefundStatusStr.Contains("待用户发货")))
							tmpOrderItems.Add(orderItem);
					}
				}
			}
			if (tmpOrderItems.Count > 0)
				await DoBuyerRefend(tmpOrderItems);
		}

		/// <summary>
		/// 退货仓创建退货单
		/// </summary>
		/// <returns></returns>
		public async Task DoReturnOrderTransitCreateSlient()
		{
			List<oms_wei_order_info> emergencyRefundOrders = new List<oms_wei_order_info>();
			Dispatcher.Invoke(new Action(() =>
			{
				emergencyRefundOrders = GlobalConfig.lstOrder.Where(o => o.IsEmergency).ToList();
			}));
			List<oms_wei_order_item_info> tmpOrderItems = new List<oms_wei_order_item_info>();
			foreach (var order in emergencyRefundOrders)
			{
				foreach (var orderItem in order.orderItems)
				{
					if (order.order_id == "3739296914665288192")
					{

					}

					// 退货地址不是退货仓，跳过
					if (orderItem.ItemRefund?.return_detail?.ToUpper().Contains(GlobalConfig.TransitReturnOrderReturnAddressLite) != true)
						continue;

					if (orderItem.DistribReturnOrderInfo == null || orderItem.DistribReturnOrderInfo.warehouse_status == 0)
					{
						if (!tmpOrderItems.Any(oi => oi.order_id == orderItem.order_id))
							tmpOrderItems.Add(orderItem);
					}
				}
			}

			if (tmpOrderItems.Count > 0)
			{
				foreach (var orderItem in tmpOrderItems)
				{
					if (orderItem.order_id == "3739296914665288192")
					{

					}
					// 10元余额才允许自动创建退货仓分销退货
					if (BaseClass.Balance > 5)
					{
						await Task.Run(() => { TransitReturnOrderWindow.AddReturnOrder(orderItem); });
					}
				}
			}
		}

		/// <summary>
		/// 退货仓买手申请退货退款获取总店地址
		/// </summary>
		/// <returns></returns>
		public async Task DoReturnOrderBuyerRefendSlient()
		{
			List<oms_wei_order_info> emergencyRefundOrders = new List<oms_wei_order_info>();
			Dispatcher.Invoke(new Action(() =>
			{
				emergencyRefundOrders = GlobalConfig.lstOrder.Where(o => o.IsEmergency).ToList();
			}));
			List<oms_wei_order_item_info> tmpOrderItems = new List<oms_wei_order_item_info>();
			foreach (var order in emergencyRefundOrders)
			{
				foreach (var orderItem in order.orderItems)
				{
					if (order.order_id == "3739296914665288192")
					{

					}

					// 退货地址不是退货仓，跳过
					if (orderItem.ItemRefund?.return_detail?.ToUpper().Contains(GlobalConfig.TransitReturnOrderReturnAddressLite) != true)
						continue;
					// 退货包裹未发货，跳过（仅退货退款已发货的才自动去申请拼多多退货退款）
					if ((orderItem.ItemRefund?.return_waybill_id).IsNullOrEmpty())
						continue;

					// 退货地址是退货仓的，直接申请退货退款，取到地址后直接去填写退货仓退货信息
					if (orderItem?.ItemOrder?.OrderBuyType == "云仓")
					{
						if (!string.IsNullOrEmpty(orderItem.ItemTransitOrderWithVoid?.out_order_no) && orderItem.PddBuyerAfterSaleAddressStr.IsNullOrEmpty() && GetNeedBuyerAfterSale(orderItem.TransitRefundStatusStr))
							tmpOrderItems.Add(orderItem);
						if (!string.IsNullOrEmpty(orderItem.ItemTransitOrderWithVoid?.out_order_no) && GetNeedBuyerNewAfterSale(orderItem.TransitRefundStatusStr))
							tmpOrderItems.Add(orderItem);
					}

					if (orderItem?.ItemOrder?.OrderBuyType == "直发")
					{
						if (orderItem != null && !string.IsNullOrEmpty(orderItem.ItemOrder?.out_order_no) && orderItem.DirectPddBuyerAfterSaleAddressStr.IsNullOrEmpty() &&
								GetNeedBuyerAfterSale(orderItem.ItemOrder?.out_after_sale_status))
							tmpOrderItems.Add(orderItem);
						if (orderItem != null && !string.IsNullOrEmpty(orderItem.ItemOrder?.out_order_no) && GetNeedBuyerNewAfterSale(orderItem.ItemOrder?.out_after_sale_status))
							tmpOrderItems.Add(orderItem);
					}

					// 云改直有两个买手单，暂时只处理直发的，云仓默认已退款
					if (orderItem?.ItemOrder?.OrderBuyType == "云改直")
					{
						if (orderItem != null && !string.IsNullOrEmpty(orderItem.ItemOrder?.out_order_no) && orderItem.DirectPddBuyerAfterSaleAddressStr.IsNullOrEmpty() &&
								GetNeedBuyerAfterSale(orderItem.ItemOrder?.out_after_sale_status))
							tmpOrderItems.Add(orderItem);
						if (orderItem != null && !string.IsNullOrEmpty(orderItem.ItemOrder?.out_order_no) && GetNeedBuyerNewAfterSale(orderItem.ItemOrder?.out_after_sale_status))
							tmpOrderItems.Add(orderItem);
					}
				}
			}
			if (tmpOrderItems.Count > 0)
				await DoBuyerRefend(tmpOrderItems);
		}

		/// <summary>
		/// 退货仓买手退货
		/// </summary>
		/// <returns></returns>
		public async Task DoBuyerRefend(List<oms_wei_order_item_info> tmpOrderItems)
		{
			if (tmpOrderItems == null)
				return;

			int index = 0;
			foreach (var tmpOrderItem in tmpOrderItems)
			{
				if (tmpOrderItem.order_id == "3739296914665288192")
				{
				}

				Dispatcher.Invoke(new Action(() => { BottomMsg = "正在处理买手退货，总计：" + tmpOrderItems.Count + "，已处理：" + index++; }));

				var outOrderSn = "";
				if (tmpOrderItem.ItemOrder?.OrderBuyType == "云仓")
					outOrderSn = tmpOrderItem.ItemTransitOrderWithVoid?.out_order_no;
				else if (tmpOrderItem.ItemOrder?.OrderBuyType == "直发" || tmpOrderItem.ItemOrder?.OrderBuyType == "云改直")
					outOrderSn = tmpOrderItem.ItemOrder?.out_order_no;

				if (outOrderSn.StartsWith("tb_"))
				{ 
					// todo 淘宝退货暂时不处理
				}
				else
				{
					#region 拼多多外采退货

					var pddOrderSn = outOrderSn;

					BuyerLoginInfo buyer = null;
					if (tmpOrderItem.ItemOrder?.OrderBuyType == "云仓")
						Dispatcher.Invoke(() => { buyer = GlobalConfig.PDDBuyerLoginList.FirstOrDefault(b => b.buyer_nick == tmpOrderItem.ItemTransitOrderWithVoid.buyer_account); });
					else if (tmpOrderItem.ItemOrder?.OrderBuyType == "直发" || tmpOrderItem.ItemOrder?.OrderBuyType == "云改直")
						Dispatcher.Invoke(() => { buyer = GlobalConfig.PDDBuyerLoginList.FirstOrDefault(b => b.buyer_nick == tmpOrderItem.ItemOrder?.out_account); });
					if (buyer == null)
					{
						BaseMsgWindow.ShowAnimateMessage("买手单：" + pddOrderSn + " 买手不在当前账户下，跳过", "Error", 3);
						continue;
					}

					// 检测一下买手号
					if (buyer.status == "在线")
					{
						PddMobileLoginViewModel.CheckBuyerLogin(buyer);
					}
					if (buyer.status != "在线")
					{
						BaseMsgWindow.ShowAnimateMessage("买手单：" + pddOrderSn + " 买手号掉线，跳过", "Error", 3);
						continue;
					}

					await Task.Run(() => { MainWindow.Instance.orderListCtrl.GetOrder(tmpOrderItem.order_id); });


					oms_wei_order_info order = null;
					Dispatcher.Invoke(new Action(() => { order = GlobalConfig.lstOrder.FirstOrDefault(oi => oi.order_id == tmpOrderItem.order_id); }));
					if (order == null)
						continue;
					oms_wei_order_item_info orderItem = null;
					Dispatcher.Invoke(new Action(() => { orderItem = order.orderItems.FirstOrDefault(oi => oi.order_id == tmpOrderItem.order_id && oi.sku_id == tmpOrderItem.sku_id); }));
					if (orderItem == null)
						continue;

					string refundStatusStr = "";
					string outOrderNo = "";
					string AfterSaleAddressStr = "";
					if (order.OrderBuyType == "云仓")
					{
						outOrderNo = (orderItem.ItemTransitOrderWithVoid?.out_order_no).ParseToString();
						refundStatusStr = (orderItem?.TransitRefundStatusStr).ParseToString();
						AfterSaleAddressStr = orderItem.PddBuyerAfterSaleAddressStr;
					}
					else if (order.OrderBuyType == "直发" || order.OrderBuyType == "云改直")
					{
						outOrderNo = (order.out_order_no).ParseToString();
						refundStatusStr = (order.out_after_sale_status).ParseToString();
						AfterSaleAddressStr = orderItem.DirectPddBuyerAfterSaleAddressStr;
					}
					if (string.IsNullOrEmpty(outOrderNo) || !(AfterSaleAddressStr.IsNullOrEmpty() || GetNeedBuyerNewAfterSale(refundStatusStr)) || !GetNeedBuyerAfterSale(refundStatusStr))
						continue;

					PddBuyerOrderLiteInfo pddBuyerOrderLiteInfo = new PddBuyerOrderLiteInfo();
					pddBuyerOrderLiteInfo.ShopOrderIdStr = orderItem.order_id;
					pddBuyerOrderLiteInfo.order_sn = pddOrderSn;

					if (order.OrderBuyType == "云仓")
						pddBuyerOrderLiteInfo.order_amount = orderItem.ItemTransitOrderWithVoid?.out_amount;
					else if (order.OrderBuyType == "直发" || order.OrderBuyType == "云改直")
						pddBuyerOrderLiteInfo.order_amount = order.out_amount;

					order_pdd_buyer_after_sale pddBuyerAfterSale = new order_pdd_buyer_after_sale()
					{
						wx_order_id = orderItem.order_id,
						wx_sku_id = orderItem.sku_id,
						TransitCreateTime = orderItem.ItemTransitOrderWithVoid?.created_time == null ? DateTime.MinValue : orderItem.ItemTransitOrderWithVoid.created_time,
						pre_allocated_order_no = orderItem.ItemTransitOrderWithVoid?.pre_allocated_order_no,
						buyerId = buyer.buyer_id,
						buyerName = buyer.buyer_name,
						orderSn = pddOrderSn,
						orderAmount = pddBuyerOrderLiteInfo.order_amount,
						refundAmount = pddBuyerOrderLiteInfo.order_amount,
						orderDate = pddOrderSn.ParseToString().Split('-').FirstOrDefault().ParseToInt(),
					};
					// 根据云仓还是直发判断是哪个买手单
					if (tmpOrderItem.ItemOrder?.OrderBuyType == "云仓" && orderItem.PddBuyerAfterSale != null)
						pddBuyerAfterSale = orderItem.PddBuyerAfterSale;
					if (tmpOrderItem.ItemOrder?.OrderBuyType != "云仓" && orderItem.DirectPddBuyerAfterSale != null)
						pddBuyerAfterSale = orderItem.DirectPddBuyerAfterSale;

					bool isSimPddAfterSaleSuccess = true;
					if (GetNeedBuyerNewAfterSale(refundStatusStr))
					{
						isSimPddAfterSaleSuccess = false;
						// pddBuyerAfterSale作为参数传入，获取退货退款金额
						var rst = PDDBuyerOrderReadCtrl.SimPddAfterSaleWithReturnGoods(buyer, pddBuyerOrderLiteInfo, pddBuyerAfterSale);

						var afterSalesStatus = BaseRegex.GetIntJson(ref rst, "after_sales_status");
						var afterSalesId = BaseRegex.GetLongJson(ref rst, "after_sales_id");
						pddBuyerAfterSale.afterSalesId = afterSalesId.ToString();
						pddBuyerAfterSale.statusText = "待用户发货";

						if (afterSalesStatus == 0)
						{
							var msg = BaseRegex.GetStringJsonByRegs(ref rst, rst, "msg", "err_msg", "error_msg", "errorMsg", "errMsg");
							BaseMsgWindow.ShowAnimateMessage(msg, "Error", 5);
							Thread.Sleep(5000);
							if (msg == "已超过可申请售后的时间")
							{
								if (order.OrderBuyType == "云仓")
								{
									var e57Rst = PDDBuyerOrderReadCtrl.SendTransitAfterSaleE57(pddBuyerOrderLiteInfo, "已超过可申请售后的时间");
									if (e57Rst.Contains("<code>0</code>") || e57Rst.Contains("<code>200</code>"))
									{
										BaseMsgWindow.ShowAnimateMessage("买手退款信息更新成功", "Msg", 3);
										Thread.Sleep(Randomx.GetId(10000, 12001));
									}
									else
									{
										msg = BaseRegex.GetStringXml(ref e57Rst, "msg");
										BaseMsgWindow.ShowAnimateMessage("买手退款信息更新失败，服务端返回 " + msg, "Error", 3);
									}
								}
								else if (order.OrderBuyType == "直发" || order.OrderBuyType == "云改直")
								{
									var e57Rst = PDDBuyerOrderReadCtrl.SendAfterSaleE57NeedManual(pddBuyerOrderLiteInfo, "已超过可申请售后的时间");
									if (e57Rst.Contains("<code>0</code>") || e57Rst.Contains("<code>200</code>"))
									{
										BaseMsgWindow.ShowAnimateMessage("买手退款信息更新成功", "Msg", 3);
										Thread.Sleep(Randomx.GetId(10000, 12001));
									}
									else
									{
										msg = BaseRegex.GetStringXml(ref e57Rst, "msg");
										BaseMsgWindow.ShowAnimateMessage("买手退款信息更新失败，服务端返回 " + msg, "Error", 3);
									}
								}
							}
						}
						else
						{
							if (order.OrderBuyType == "云仓")
							{
								var e57Rst = PDDBuyerOrderReadCtrl.SendTransitAfterSaleE57(pddBuyerOrderLiteInfo, "待用户发货");
								if (e57Rst.Contains("<code>0</code>") || e57Rst.Contains("<code>200</code>"))
								{
									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新成功" + orderItem.order_id, "Msg", 3);
									isSimPddAfterSaleSuccess = true;
									await Task.Run(() => { Thread.Sleep(Randomx.GetId(10000, 12001)); });
								}
								else
								{
									var msg = BaseRegex.GetStringXml(ref e57Rst, "msg");
									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新失败，服务端返回 " + msg, "Error", 3);
								}
							}
							else if (order.OrderBuyType == "直发" || order.OrderBuyType == "云改直")
							{
								var e57Rst = PDDBuyerOrderReadCtrl.SendAfterSaleE57NeedManual(pddBuyerOrderLiteInfo, "待用户发货");
								if (e57Rst.Contains("<code>0</code>") || e57Rst.Contains("<code>200</code>"))
								{
									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新成功", "Msg", 3);
									isSimPddAfterSaleSuccess = true;
									await Task.Run(() => { Thread.Sleep(Randomx.GetId(10000, 12001)); });
								}
								else
								{
									var msg = BaseRegex.GetStringXml(ref e57Rst, "msg");
									BaseMsgWindow.ShowAnimateMessage("买手退款信息更新失败，服务端返回 " + msg, "Error", 3);
								}
							}
						}
					}
					// 更新Pdd总店退货地址
					if (isSimPddAfterSaleSuccess)
					{
						var addressRst = YkdBuyerOrder.GetAfterSaleAddress(buyer, pddOrderSn, pddBuyerAfterSale.afterSalesId.ParseToString());
						var merchantReceiverInfo = BaseRegex.GetOneJsonObjStrJson(ref addressRst, "merchantReceiverInfo");
						string address = "";
						if (merchantReceiverInfo != null)
						{
							address = BaseRegex.GetStringJson(ref merchantReceiverInfo, "copyValue");
						}
						if (addressRst.Contains("网络异常，请稍后重试"))
						{
							BaseMsgWindow.ShowAnimateMessage("买手 " + buyer.buyer_nick + " 网络异常，请手动获取总店退货地址并填写", "Msg", 5);
						}

						var url3 = BaseClass.Build29WxObjString("order/wx_add_mdy_buyer_after_sale");
						var data3 = UserLogin.GetSignaturex();
						data3 += "&wx_order_id=" + pddBuyerAfterSale.wx_order_id;
						data3 += "&wx_sku_id=" + pddBuyerAfterSale.wx_sku_id;
						if (pddBuyerAfterSale.TransitCreateTime != DateTime.MinValue)
							data3 += "&TransitCreateTime=" + pddBuyerAfterSale.TransitCreateTime.ToString("yyyy-MM-dd HH:mm:ss");
						data3 += "&pre_allocated_order_no=" + pddBuyerAfterSale.pre_allocated_order_no;
						data3 += "&buyerId=" + pddBuyerAfterSale.buyerId;
						data3 += "&buyerName=" + pddBuyerAfterSale.buyerName;
						data3 += "&orderAmount=" + pddBuyerAfterSale.orderAmount;
						data3 += "&orderSn=" + pddBuyerAfterSale.orderSn;
						data3 += "&afterSalesId=" + pddBuyerAfterSale.afterSalesId;
						data3 += "&orderDate=" + pddBuyerAfterSale.orderDate;
						//data3 += "&TransitPickupTime=" + pddBuyerOrder.TransitPickupTime.ToString("yyyy-MM-dd HH:mm:ss");
						data3 += "&refundAmount=" + pddBuyerAfterSale.refundAmount;
						data3 += "&statusText=" + pddBuyerAfterSale.statusText;
						if (!string.IsNullOrEmpty(address))
							data3 += "&afterSaleAddress=" + address;
						if (order.OrderBuyType == "直发" || order.OrderBuyType == "云改直") // 云仓 0  直发 1
							data3 += "&wx_send_type=1";
						//data3 += "&is_mdy=true";
						var html3 = await GetHtml.PostUtf8Async(url3, data3);
						if (string.IsNullOrEmpty(html3) || !html3.Contains("\"code\":200"))
							html3 = await GetHtml.PostUtf8Async(url3, data3);
					}
					MainWindow.Instance.orderListCtrl.GetOrder(tmpOrderItem.order_id);
					Dispatcher.Invoke(new Action(() => { BottomMsg = "正在处理买手退货，总计：" + tmpOrderItems.Count + "，已处理：" + index; }));
					#endregion
				}
			}

			Dispatcher.Invoke(new Action(() => { BottomMsg = "买手退货处理完成，总计：" + tmpOrderItems.Count + "，已处理：" + index; }));
		}


		public static string WxSimAbnormalOrderSeach(ShopLoginInfo shop, int page = 1)
		{
			string url = "https://store.weixin.qq.com/shop-faas/mmchannelstradeorder/list/cgi/orderSearch?token=&lang=zh_CN";
			string referer = "https://store.weixin.qq.com/shop/order/list";
			string body = @"{""isSearch"":false,""pageSize"":100,""overTime"":0,""pengingShipOneDay"":0,""pengingShipSixHour"":0,""expediteDelivery"":0," +
				@"""stockoutPunishAlert"":0,""appointmentInstall"":0,""waybillStatus"":3,""isUserBookingDelivery"":0,""pageNum"":" + page + @",""onAftersaleOrderExist"":0,""orderStatus"":30}";
			var result = HttpResponseWXBLL.WeiXinPostResponse(shop, url, body, referer);
			return result;
		}

		private void btnMultiRemark_Click(object sender, RoutedEventArgs e)
		{
			wpFilterRemarkSelect.Children.Clear();
			List<string> txts = txtFilterRemark.Text.Trim().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries).ToList();
			var remarks = GlobalConfig.lstOrder.Select(o => o.shop_remark).Distinct().ToList();
			remarks.AddRange(GlobalConfig.lstOrder.Select(o => o.soft_remark).Distinct().ToList());
			remarks = remarks.Distinct().ToList();
			foreach (var remark in remarks)
			{
				if (string.IsNullOrWhiteSpace(remark))
					continue;
				wpFilterRemarkSelect.Children.Add(new CheckBox() { Content = remark, IsChecked = txts.Contains(remark), Margin = new Thickness(2) });
			}

			Point position = txtFilterRemark.TranslatePoint(new Point(0, 0), gridOrderListCtrl);
			borderFilterRemarkSelect.Margin = new Thickness(position.X - 2, position.Y + txtFilterRemark.ActualHeight + 3, 0, 0);

			if (borderFilterRemarkSelect.Visibility == Visibility.Visible)
				borderFilterRemarkSelect.Visibility = Visibility.Collapsed;
			else
				borderFilterRemarkSelect.Visibility = Visibility.Visible;
		}

		private void btnCancelFilterRemark_Click(object sender, RoutedEventArgs e)
		{
			borderFilterRemarkSelect.Visibility = Visibility.Collapsed;
		}

		private void btnApplyFilterRemark_Click(object sender, RoutedEventArgs e)
		{
			string txt = "";
			foreach (UIElement element in wpFilterRemarkSelect.Children)
			{
				if (element is CheckBox box && box.IsChecked == true)
				{
					txt += box.Content.ParseToString() + ";";
				}
			}
			txtFilterRemark.Text = txt.TrimEnd(';');
			borderFilterRemarkSelect.Visibility = Visibility.Collapsed;
		}

		private void btnFilterRemarkSelectAll_Click(object sender, RoutedEventArgs e)
		{
			foreach (UIElement element in wpFilterRemarkSelect.Children)
			{
				if (element is CheckBox box)
				{
					box.IsChecked = true;
				}
			}
		}

		private void btnFilterRemarkUnSelectAll_Click(object sender, RoutedEventArgs e)
		{
			foreach (UIElement element in wpFilterRemarkSelect.Children)
			{
				if (element is CheckBox box)
				{
					box.IsChecked = false;
				}
			}
		}

		private void txtFilterRemark_TextChanged(object sender, TextChangedEventArgs e)
		{
			orderFilterConfig.lstFilterRemarkText = [.. txtFilterRemark.Text.Trim().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries).Distinct().ToList(),];
		}

		private void txtOrderId_TextChanged(object arg1, TextChangedEventArgs arg2)
		{
			orderFilterConfig.lstFilterOrderIds = [.. txtFilterOrderId.Text.Trim().Split(new string[] { ";", "；", ",", "，" }, StringSplitOptions.RemoveEmptyEntries).Distinct().ToList(),];
		}

		private void chkEmergencyReturnOrRefund_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkEmergencyReturn.IsChecked = chkEmergencyRefund.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkEmergencyReturnIsChecked = chkEmergencyReturn.IsChecked.ParseToBool();
				chkEmergencyRefundIsChecked = chkEmergencyRefund.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkEmergencyReturnOrder_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkReturnOrderAddress.IsChecked = chkNotReturnOrderAddress.IsChecked = false;
				chk.IsChecked = !isCheck;
			}
			FilterOrders();
		}



		/// <summary>
		/// 
		/// </summary>
		/// <param name="buyer"></param>
		/// <param name="after_sales_id"></param>
		/// <param name="shipping_name"></param>
		/// <param name="shipping_id">121韵达快递 384极兔速递 115中通快递</param>
		/// <param name="tracking_number"></param>
		/// <returns></returns>
		public string MdyReturnShippingINfo(BuyerLoginInfo buyer, string order_sn, string after_sales_id, string shipping_name, string shipping_id, string tracking_number)
		{
			// 物流版本 version 中通2 韵达4 极兔5
			//https://mobile.yangkeduo.com/proxy/api/api/asm/modify_return_shipping_info?pdduid=5746442372052
			//修改{"after_sales_id":"21943158712295","question_desc":"已发极兔速递(JT3172520393785)","version":5,"images":[],"shipping_id":384,"shipping_name":"极兔速递","tracking_number":"JT3172520393785","can_merge_tracking_number":false,"remark_shipping_name":"","id":"21943158712295"}
			//{"success":true,"errorCode":1000000,"errorMsg":null,"result":null}
			//修改{"after_sales_id":"21944843820487","question_desc":"已发韵达快递(315091268379268)","version":4,"images":[],"shipping_id":121,"shipping_name":"韵达快递","tracking_number":"315091268379268","can_merge_tracking_number":false,"remark_shipping_name":"","id":"21944843820487"}
			//{"success":true,"errorCode":1000000,"errorMsg":null,"result":null}
			//新增{"after_sales_id":"22051692661447","question_desc":"已发中通快递(73719278250925)","version":2,"images":[],"shipping_id":115,"shipping_name":"中通快递","tracking_number":"73719278250925","can_merge_tracking_number":false,"remark_shipping_name":"","express_fee":0}
			//{"after_sales_status":11,"result":"ok"}

			string url = "https://mobile.yangkeduo.com/proxy/api/api/asm/modify_return_shipping_info?pdduid=" + buyer.buyer_id;
			string data = "{\"after_sales_id\":\"" + after_sales_id + "\",\"question_desc\":\"已发" + shipping_name + "(" + tracking_number + ")\",\"version\":4,\"images\":[],\"shipping_id\":" +
				shipping_id + "," + "\"shipping_name\":\"" + shipping_name + "\",\"tracking_number\":\"" + tracking_number +
				"\",\"can_merge_tracking_number\":false,\"remark_shipping_name\":\"\",\"id\":\"" + after_sales_id + "\"}";
			string referer = "https://mobile.yangkeduo.com/complaint.html?mode=1024&after_sales_id=" + after_sales_id +
				"&order_sn=" + order_sn + "&refer_page_name=complaints_new_detail";
			return HttpResponseYkdBLL.YangkeduoPostResponse(buyer, url, data, referer);
		}

		public string AddReturnPddShopPackageInfo(BuyerLoginInfo buyer, string order_sn, string after_sales_id, string tracking_number,
			string shipping_name = "韵达快递", string shipping_id = "121", string version = "4")
		{
			//https://mobile.yangkeduo.com/proxy/api/after_sales/confirm_delivery/22051692661447?pdduid=5746442372052
			//修改{"after_sales_id":"21943158712295","question_desc":"已发极兔速递(JT3172520393785)","version":5,"images":[],"shipping_id":384,"shipping_name":"极兔速递","tracking_number":"JT3172520393785","can_merge_tracking_number":false,"remark_shipping_name":"","id":"21943158712295"}
			//{"success":true,"errorCode":1000000,"errorMsg":null,"result":null}
			//修改{"after_sales_id":"21944843820487","question_desc":"已发韵达快递(315091268379268)","version":4,"images":[],"shipping_id":121,"shipping_name":"韵达快递","tracking_number":"315091268379268","can_merge_tracking_number":false,"remark_shipping_name":"","id":"21944843820487"}
			//{"success":true,"errorCode":1000000,"errorMsg":null,"result":null}
			//新增{"after_sales_id":"22051692661447","question_desc":"已发中通快递(73719278250925)","version":2,"images":[],"shipping_id":115,"shipping_name":"中通快递","tracking_number":"73719278250925","can_merge_tracking_number":false,"remark_shipping_name":"","express_fee":0}
			//{"after_sales_status":11,"result":"ok"}

			string url = "https://mobile.yangkeduo.com/proxy/api/after_sales/confirm_delivery/" + after_sales_id + "?pdduid=" + buyer.buyer_id;
			string data = "{\"after_sales_id\":\"" + after_sales_id + "\",\"question_desc\":\"已发" + shipping_name + "(" + tracking_number + ")\",\"version\":" + version +
				",\"images\":[],\"shipping_id\":" + shipping_id + "," + "\"shipping_name\":\"" + shipping_name + "\",\"tracking_number\":\"" + tracking_number +
				"\",\"can_merge_tracking_number\":false,\"remark_shipping_name\":\"\",\"express_fee\":0}";
			string referer = "https://mobile.yangkeduo.com/complaint.html?mode=128&after_sales_id=" + after_sales_id +
				"&order_sn=" + order_sn + "&refer_page_name=complaints_new_detail";

			return HttpResponseYkdBLL.YangkeduoPostResponse(buyer, url, data, referer);
		}

		public string AddReturnPddShopPackageInfocheck(BuyerLoginInfo buyer, string order_sn, string after_sales_id, string tracking_number,
			string shipping_name = "韵达快递", string shipping_id = "121")
		{
			string url = "https://mobile.yangkeduo.com/proxy/api/api/asm/express/tracking_number/check?pdduid=" + buyer.buyer_id;
			string body = @"{""orderSn"":""" + order_sn + @""",""afterSalesId"":""" + after_sales_id + @""",""shippingId"":121,""trackingNumber"":""" + tracking_number + @"""}";
			string referer = "https://mobile.yangkeduo.com/complaint.html?mode=128&after_sales_id=" + after_sales_id +
				"&order_sn=" + order_sn + "";

			return HttpResponseYkdBLL.YangkeduoPostResponse(buyer, url, body, referer);
		}

		private void txtGoodsNameFilter_TextChanged(object sender, TextChangedEventArgs e)
		{
			if (IsLoaded)
			{
				if (string.Join(";", orderFilterConfig.lstFilterGoodsName) != txtFilterGoodsName.Text)
				{
					orderFilterConfig.lstFilterGoodsName = txtFilterGoodsName.Text.Split(new string[] { ";", "；", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries).ToList();
					NaiBa.Util.Helper.ConfigHelper.SaveConfig("wx_order_filter_config", orderFilterConfig);
				}
			}
		}

		private void txtShopName_TextChanged(object arg1, TextChangedEventArgs arg2)
		{
			if (IsLoaded)
			{
				//if (string.Join(";", orderFilterConfig.FilterGoodsName) != txtFilterGoodsName.Text)
				//{
				//	orderFilterConfig.FilterGoodsName = txtFilterGoodsName.Text.Split(new string[] { ";", "；", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries).ToList();
				//	NaiBa.Util.Helper.ConfigHelper.SaveConfig("wx_order_filter_config", orderFilterConfig);
				//}
				orderFilterConfig.txtFilterShopNameText = txtShopName.Text.Trim();
			}
		}

		private void cmbFilterGoodsNameType_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (IsLoaded)
			{
				if (orderFilterConfig.FilterGoodsNameType != ((cmbFilterGoodsNameType.SelectedItem as ComboBoxItem)?.Content as TextBlock)?.Text)
				{
					orderFilterConfig.FilterGoodsNameType = ((cmbFilterGoodsNameType.SelectedItem as ComboBoxItem)?.Content as TextBlock)?.Text;
					NaiBa.Util.Helper.ConfigHelper.SaveConfig("wx_order_filter_config", orderFilterConfig);
				}
			}
		}

		private void chkHideGreenFlag_Click(object sender, RoutedEventArgs e)
		{
			FilterOrders();
		}

		private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			e.Handled = true;
		}

		//private bool _IsShipGift;
		//public bool IsShipGift
		//{
		//	get => _IsShipGift;
		//	set => SetProperty(ref _IsShipGift, value);
		//}

		private void Instance_TaskChanged(object sender, IEnumerable<Work.KJDServer.API.Models.TaskItem> data)
		{
			var giftTaks = data.Where(a => a.TaskType == Work.KJDServer.API.Models.TaskType.Gifts && a.SubTasks != null)
					   .SelectMany(a => a.SubTasks)
				   .GroupBy(a => a.ObjectId)
			   .Select(a => a.OrderByDescending(b => b.CreateTime).First())
				   .ToList();

			foreach (TaskSubItem item in giftTaks)
			{
				oms_wei_order_info order = GlobalConfig.lstOrder.FirstOrDefault(a => a.order_id == item.ObjectId);
				if (order != null)
				{
					order.GiftSuccessed = item.Status == 1;
					if (order.GiftSuccessed == false)
					{
						order.GiftErrorMsg = item.SysMsg;
					}
				}
			}
		}

		private void dgOrderHeader_Sorting(object sender, DataGridSortingEventArgs e)
		{
			if (e.Column.Header.ParseToString().StartsWith("交易时间"))
			{
				if (e.Column.Header.ParseToString() == "交易时间 ▲")
				{
					if (GlobalConfig.OrderTabHeaderStr.StartsWith("需处理售后单") || GlobalConfig.OrderTabHeaderStr.StartsWith("退货仓自动售后单"))
						GlobalConfig.lstFilterOrder.SortDesc(o => o.RefundDatetime);
					else if (GlobalConfig.OrderTabHeaderStr.StartsWith("异常需重拍"))
						GlobalConfig.lstFilterOrder.SortDesc(o => o.update_time);
					else
						GlobalConfig.lstFilterOrder.SortDesc(o => o.create_time);
					e.Column.Header = ColumnHeaderTitle = "交易时间 ▼";
				}
				else
				{
					if (GlobalConfig.OrderTabHeaderStr.StartsWith("需处理售后单") || GlobalConfig.OrderTabHeaderStr.StartsWith("退货仓自动售后单"))
						GlobalConfig.lstFilterOrder.Sort(o => o.RefundDatetime);
					else if (GlobalConfig.OrderTabHeaderStr.StartsWith("异常需重拍"))
						GlobalConfig.lstFilterOrder.Sort(o => o.update_time);
					else
						GlobalConfig.lstFilterOrder.Sort(o => o.create_time);
					e.Column.Header = ColumnHeaderTitle = "交易时间 ▲";
				}
			}
			
		}

		private void cmbFilterRemark_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (cmbFilterRemark.SelectedItem is ComboBoxItem comboBoxItem)
			{
				if (comboBoxItem.Content is TextBlock tb)
				{
					if (orderFilterConfig != null)
						orderFilterConfig.FilterRemarkType = tb.Text;
				}
			}
		}

		private void cmbRejectOrReturnStatus_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (this.IsLoaded)
			{
				//"System.Windows.Controls.ComboBoxItem: 未申请";
				this.cmbRejectStatusText = cmbRejectStatus.SelectedItem.ParseToString().Replace("System.Windows.Controls.ComboBoxItem: ", "");
				this.cmbReturnPackageStatusText = cmbReturnPackageStatus.SelectedItem.ParseToString().Replace("System.Windows.Controls.ComboBoxItem: ", "");
				FilterOrders();
			}
		}

		private void chkNeedCheckExpress_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkNeedCheckExpress.IsChecked = false;
				chk.IsChecked = !isCheck;
				chkNeedCheckExpressIsChecked = chkNeedCheckExpress.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkShopIsRefund_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkShopIsRefund.IsChecked = chkShopIsNotRefund.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkShopIsRefundIsChecked = chkShopIsRefund.IsChecked.ParseToBool();
				chkShopIsNotRefundIsChecked = chkShopIsNotRefund.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkDirectSendFailed_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkDirectSendFailed.IsChecked = false;
				chk.IsChecked = !isCheck;
				chkDirectSendFailedIsChecked = chkDirectSendFailed.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkUpShopAddressAnalyseFailed_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkUpShopAddressAnalyseFailed.IsChecked = false;
				chk.IsChecked = !isCheck;

				chkUpShopAddressAnalyseFailedIsChecked = chkUpShopAddressAnalyseFailed.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private async void btnAutoBuy_Click(object sender, RoutedEventArgs e)
		{
			var buyOrders = GlobalConfig.lstFilterOrder.Where(o => o.IsWaitBuy && o.orderItems?.Count == 1 && o.orderItems.FirstOrDefault()?.PddBuyMap != null && o.IsSelect == true).ToList();
			if (buyOrders.Count == 0)
			{
				BaseMsgWindow.ShowError("未勾选符合条件的订单！");
				return;
			}

			IsAutoBuy = true;
			foreach (var order in buyOrders)
			{
				var orderItem = order.orderItems.FirstOrDefault();
				await OrderListRowItemCtrl.BuyOrder(orderItem, true);
				if (IsAutoBuy == false)
					break;
			}
			IsAutoBuy = false;
			BaseMsgWindow.ShowInfo("自动拍单结束！");
		}

		private void btnAutoBuyIntroduction_Click(object sender, RoutedEventArgs e)
		{
			AutoBuyIntroductionView autoBuyIntroForm = new AutoBuyIntroductionView();
			new DialogWindow()
			{
				Title = "自动拍单设置说明",
				Content = autoBuyIntroForm,
			}.ShowDialog();
		}

		private void chkNoWaybill_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chk48HourNoWaybill.IsChecked = chk72HourNoWaybill.IsChecked = false;
				chk.IsChecked = !isCheck;

				chk48HourNoWaybillIsChecked = chk48HourNoWaybill.IsChecked.ParseToBool();
				chk72HourNoWaybillIsChecked = chk72HourNoWaybill.IsChecked.ParseToBool();
			}
			FilterOrders();
		}

		private void chkWaitSendNoWaybill_Click(object sender, RoutedEventArgs e)
		{
			if (sender is CheckBox chk)
			{
				var isCheck = !chk.IsChecked.ParseToBool();
				chkWaitSend48HourNoWaybill.IsChecked = chkWaitSend72HourNoWaybill.IsChecked = false;
				chk.IsChecked = !isCheck;
				chkWaitSend48HourNoWaybillIsChecked = chkWaitSend48HourNoWaybill.IsChecked.Value;
				chkWaitSend72HourNoWaybillIsChecked = chkWaitSend72HourNoWaybill.IsChecked.Value;
			}
			FilterOrders();
		}

		private void cmbReturnOrderStatus_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (this.IsLoaded)
			{
				cmbReturnOrderStatusText = cmbReturnOrderStatus.SelectedItem.ParseToString().Replace("System.Windows.Controls.ComboBoxItem: ", "");
				FilterOrders();
			}
		}

		private void cmbReturnOrderBuyerStatus_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (this.IsLoaded)
			{
				cmbReturnOrderBuyerStatusText = cmbReturnOrderBuyerStatus.SelectedItem.ParseToString().Replace("System.Windows.Controls.ComboBoxItem: ", "");
				FilterOrders();
			}
		}

		private void chkSyncDirectOrderWaybill_Click(object sender, RoutedEventArgs e)
		{
			if (chkSyncDirectOrderWaybill.IsChecked == true)
			{
				if (BaseMsgWindow.ShowConfirm("外部单号无法直填，电子面单同步上家物流信息发货。").DialogResult != true)
				{
					chkSyncDirectOrderWaybill.IsChecked = false;
					return;
				}
			}

			GlobalConfig.BuyConfig.IsSyncDirectBuyOrderWaybill = chkSyncDirectOrderWaybill.IsChecked.ParseToBool();
			StartUp.SaveBuyConfig();
		}

		private void chkNoPickupNumOrder_Click(object sender, RoutedEventArgs e)
		{
			chkNoPickupNumOrderIsChecked = chkNoPickupNumOrder.IsChecked.ParseToBool();
			FilterOrders();
		}

		public static bool GetNeedBuyerAfterSale(string buyerAfterSaleStatus)
		{
			if (buyerAfterSaleStatus == null)
				return false;

			if (buyerAfterSaleStatus.Contains("待用户发货") || GetNeedBuyerNewAfterSale(buyerAfterSaleStatus))
				return true;
			return false;
		}

		public static bool GetNeedBuyerNewAfterSale(string buyerAfterSaleStatus)
		{
			if (buyerAfterSaleStatus == null)
				return false;

			if (buyerAfterSaleStatus.Contains("需手动申请售后") || buyerAfterSaleStatus.Contains("已申请售后 退款失败") || buyerAfterSaleStatus.Contains("已取消申请") || string.IsNullOrEmpty(buyerAfterSaleStatus))
				return true;
			return false;
		}

		private void cmbTimeType_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (cmbTimeType.SelectedItem is ComboBoxItem cbi)
			{
				if (cbi.Content is TextBlock tb)
				{
					OrderTimeFilterType = tb.Text;
				}
			}
		}

		private void chkEndDate_Click(object sender, RoutedEventArgs e)
		{
			IsEndDate = chkEndDate.IsChecked.ParseToBool();
		}


		// 假设 listBox 是你的列表控件
		private void CheckVirtualizationStatus(ListBox listBox)
		{
			// 获取 ItemsPresenter 或直接获取 Panel
			var itemsPresenter = VisualTreeHelper.GetChild(listBox, 0) as ItemsPresenter;
			if (itemsPresenter != null)
			{
				var panel = VisualTreeHelper.GetChild(itemsPresenter, 0) as VirtualizingStackPanel;
				if (panel != null)
				{
					// 关键指标：子元素数量应远小于 ItemsSource.Count
					int visibleItemCount = panel.Children.Count;
					int totalDataCount = listBox.Items.Count;
					System.Diagnostics.Debug.WriteLine($"总数据: {totalDataCount}, 当前UI容器数: {visibleItemCount}");

					// 如果 visibleItemCount 接近 totalDataCount，说明虚拟化未生效或已失效
					bool isEffectivelyVirtualizing = visibleItemCount < totalDataCount / 2;
					// 也可以通过附加属性API检查配置状态（注意：这仅检查配置值，不保证运行时行为）
					bool configValue = VirtualizingStackPanel.GetIsVirtualizing(listBox);
					System.Diagnostics.Debug.WriteLine($"配置值 IsVirtualizing: {configValue}");
				}
			}
		}
	}

	public class OrderFilterConfig : PropertyNotifyObject
	{
		public string FilterGoodsNameType { get; set; } = "标题包含";
		public string FilterRemarkType { get; set; } = "店铺备注包含";
		public List<string> lstFilterGoodsName { get; set; } = new List<string>();
		/// <summary>
		/// 隐藏标记
		/// </summary>
		public bool chkHideGreenFlagIsChecked
		{
			get { return this.GetValue(x => x.chkHideGreenFlagIsChecked); }
			set { this.SetValue(x => x.chkHideGreenFlagIsChecked, value); }
		}
		/// <summary>
		/// 过滤非本系统订单
		/// </summary>
		public bool chkOnlyWarehouseOrderIsChecked
		{
			get { return this.GetValue(x => x.chkOnlyWarehouseOrderIsChecked); }
			set { this.SetValue(x => x.chkOnlyWarehouseOrderIsChecked, value); }
		}
		/// <summary>
		/// 过滤多子单订单
		/// </summary>
		public bool chkNoMultiOrderIsChecked
		{
			get { return this.GetValue(x => x.chkNoMultiOrderIsChecked); }
			set { this.SetValue(x => x.chkNoMultiOrderIsChecked, value); }
		}
		/// <summary>
		/// 云仓
		/// </summary>
		public bool chkTransitOrderIsChecked
		{
			get { return this.GetValue(x => x.chkTransitOrderIsChecked); }
			set { this.SetValue(x => x.chkTransitOrderIsChecked, value); }
		}
		/// <summary>
		/// 直发
		/// </summary>
		public bool chkDirectOrderIsChecked
		{
			get { return this.GetValue(x => x.chkDirectOrderIsChecked); }
			set { this.SetValue(x => x.chkDirectOrderIsChecked, value); }
		}
		/// <summary>
		/// 云改直
		/// </summary>
		public bool chkTransitChangeDirectOrderIsChecked
		{
			get { return this.GetValue(x => x.chkTransitChangeDirectOrderIsChecked); }
			set { this.SetValue(x => x.chkTransitChangeDirectOrderIsChecked, value); }
		}
		/// <summary>
		/// 过滤备注
		/// </summary>
		public bool chkFilterRemarkIsChecked
		{
			get { return this.GetValue(x => x.chkFilterRemarkIsChecked); }
			set { this.SetValue(x => x.chkFilterRemarkIsChecked, value); }
		}
		public ConcurrentList<string> lstFilterOrderIds
		{
			get { return this.GetValue(x => x.lstFilterOrderIds); }
			set { this.SetValue(x => x.lstFilterOrderIds, value); }
		}
		public ConcurrentList<string> lstFilterRemarkText
		{
			get { return this.GetValue(x => x.lstFilterRemarkText); }
			set { this.SetValue(x => x.lstFilterRemarkText, value); }
		}
		public string txtFilterShopNameText
		{
			get { return this.GetValue(x => x.txtFilterShopNameText); }
			set { this.SetValue(x => x.txtFilterShopNameText, value); }
		}
	}
}