3.根据条件创建待核算任务

4.核算接口增加核算任务完成逻辑
5.订单搜索条件新增
  5.1 待配置-仅显示需修改
  5.2 待配置-仅显示配置超时(合格证拟定或补充超时)
  5.3 待核算-仅显示超时
  5.4 优化查询逻辑
6.订单查询返回sku的合格证拟定或合格证补充任务(如果有)
7.绩效考核增加合格证拟定任务和合格证补充任务

BBWYB.Server.Business/Order/OrderBusiness.cs

@@ -31,6 +31,8 @@ namespace BBWYB.Server.Business
         private RestApiService restApiService => restApiServiceLazy.Value;
         private QiKuManager qikuManager => qikuManagerLazy.Value;
 
+        private List<Enums.TimeLimitTaskType?> hgzTaskTypeList;
+
         public OrderBusiness(IFreeSql fsql, NLogManager nLogManager, IIdGenerator idGenerator, IServiceProvider serviceProvider) : base(fsql, nLogManager, idGenerator)
         {
             qikuManagerLazy = new Lazy<QiKuManager>(() => serviceProvider.GetService<QiKuManager>());
@@ -38,6 +40,12 @@ namespace BBWYB.Server.Business
             restApiServiceLazy = new Lazy<RestApiService>(() => serviceProvider.GetService<RestApiService>());
 
             waitConfigStateList = new List<Enums.PackConfigState?>() { Enums.PackConfigState.待配置, Enums.PackConfigState.需修改 };
+
+            hgzTaskTypeList = new List<Enums.TimeLimitTaskType?>()
+            {
+                Enums.TimeLimitTaskType.合格证拟定任务,
+                Enums.TimeLimitTaskType.合格证补充任务
+            };
         }
 
         private ISelect<Order, OrderConsignee, OrderCost> GetOrderListQueryConditions(QueryOrderRequest request)
@@ -60,11 +68,21 @@ namespace BBWYB.Server.Business
                                           .WhereIf(!string.IsNullOrEmpty(request.Sku), osku => osku.SkuId == request.Sku)
                                           .WhereIf(!string.IsNullOrEmpty(request.SourceSku), osku => osku.BelongSkuId == request.SourceSku)
                                           .WhereIf(!string.IsNullOrEmpty(request.ProductId), osku => osku.ProductId == request.ProductId)
-                                          .WhereIf(request.IsWaitConfig, osku => waitConfigStateList.Contains(osku.PackConfigState) || osku.PackConfigState == null);
+                                          .WhereIf(request.IsWaitConfig && request.IsOnlyDisplayPackConfigEditState != 1, osku => waitConfigStateList.Contains(osku.PackConfigState) || osku.PackConfigState == null)
+                                          .WhereIf(request.IsWaitConfig && request.IsOnlyDisplayPackConfigEditState == 1, osku => osku.PackConfigState == Enums.PackConfigState.需修改);
                     select = select.WhereIf(request.IsWaitConfig, (o, ocs, oct) => o.OrderState != Enums.OrderState.已取消)
                                    .WhereIf(request.IsWaitConfig, (o, ocs, oct) => o.IntoStoreType == Enums.IntoStoreType.发回齐越)
                                    .WhereIf(request.IsWaitConfig, (o, ocs, oct) => o.IsPurchased == true)
                                    .Where((o, ocs, oct) => childSelect.Where(osku => osku.OrderId == o.Id).Any());
+
+                    if (request.IsWaitConfig && request.IsOnlyDisplayCerConfigTimeOut == 1)
+                    {
+                        var configTimeOutChildSelect = fsql.Select<TimeLimitTask>().As("t")
+                                                           .Where(t => t.ShopId == request.ShopId)
+                                                           .Where(t => hgzTaskTypeList.Contains(t.TaskType))
+                                                           .Where(t => t.IsTimely == false);
+                        select = select.Where((o, ocs, oct) => configTimeOutChildSelect.Where(t => t.OrderId == o.Id).Any());
+                    }
                 }
 
                 if (request.IsOnlyDisplayPurchaseTimeOut == 1 && (request.OrderState == Enums.OrderState.等待采购 || request.OrderState == Enums.OrderState.部分采购))
@@ -75,22 +93,34 @@ namespace BBWYB.Server.Business
                                           .Where(t => t.IsTimely == false);
                     select = select.Where((o, ocs, oct) => childSelect.Where(t => t.OrderId == o.Id).Any());
                 }
-                if (request.IsOnlyDisplayDeliveryTimeout == 1 && (request.OrderState == Enums.OrderState.待发货 || request.OrderState == Enums.OrderState.部分发货))
+
+                if (request.IsOnlyDisplayCheckComputationTimeOut == 1 && request.OrderState == Enums.OrderState.待核算)
                 {
-                    var before24hTime = DateTime.Now.AddHours(-24);
-                    var childSelect = fsql.Select<OrderPurchaseInfo>().As("opi2")
-                                          .Where(opi2 => opi2.ShopId == request.ShopId &&
-                                                         (opi2.OrderState == Enums.PurchaseOrderState.待发货 || opi2.OrderState == Enums.PurchaseOrderState.部分发货) &&
-                                                         opi2.CreateTime < before24hTime);
-                    select = select.Where((o, ocs, oct) => childSelect.Where(opi2 => opi2.OrderId == o.Id).Any());
+                    var childSelect = fsql.Select<TimeLimitTask>().As("t")
+                                          .Where(t => t.ShopId == request.ShopId)
+                                          .Where(t => t.TaskType == Enums.TimeLimitTaskType.待核算任务)
+                                          .Where(t => t.IsTimely == false);
+                    select = select.Where((o, ocs, oct) => childSelect.Where(t => t.OrderId == o.Id).Any());
                 }
 
-                if (!string.IsNullOrEmpty(request.PurchaseOrderId))
+                var isDeliveryTimeout = request.IsOnlyDisplayDeliveryTimeout == 1 && (request.OrderState == Enums.OrderState.待发货 || request.OrderState == Enums.OrderState.部分发货);
+                if (isDeliveryTimeout || !string.IsNullOrEmpty(request.PurchaseOrderId))
                 {
-                    var childSelect = fsql.Select<OrderPurchaseInfo>().As("opi")
-                                          .Where(opi => opi.PurchaseOrderId == request.PurchaseOrderId);
+                    var childSelect = fsql.Select<OrderPurchaseInfo>().As("opi");
+                    if (isDeliveryTimeout)
+                    {
+                        var before24hTime = DateTime.Now.AddHours(-24);
+                        childSelect = childSelect.Where(opi => opi.ShopId == request.ShopId &&
+                                                               (opi.OrderState == Enums.PurchaseOrderState.待发货 || opi.OrderState == Enums.PurchaseOrderState.部分发货) &&
+                                                               opi.CreateTime < before24hTime);
+                    }
+                    if (!string.IsNullOrEmpty(request.PurchaseOrderId))
+                    {
+                        childSelect = childSelect.Where(opi => opi.PurchaseOrderId == request.PurchaseOrderId);
+                    }
                     select = select.Where((o, ocs, oct) => childSelect.Where(opi => opi.OrderId == o.Id).Any());
                 }
+
                 select = select.WhereIf(request.OrderState == Enums.OrderState.待付款 ||
                                         request.OrderState == Enums.OrderState.待验收 ||
                                         request.OrderState == Enums.OrderState.待核算 ||
@@ -275,26 +305,34 @@ namespace BBWYB.Server.Business
                 #endregion
 
                 #region 限时任务
-
-                #region 需要订单关联的任务 (采购任务)
                 var orderTimeLimitTaskList = fsql.Select<TimeLimitTask>().Where(t => orderIdList.Contains(t.OrderId))
                                                                          .ToList<TimeLimitTaskResponse>();
 
-                #endregion
-
-                #region 不需要订单关联的任务 (合格证任务)
-
-                #endregion
-
                 foreach (var order in orderList)
                 {
                     foreach (var orderSku in order.ItemList)
                     {
-                        #region 寻找sku的限时任务
-                        var purchaseTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(x => x.OrderId == order.Id && x.SkuId == orderSku.SkuId);
-                        if (purchaseTimeLimitTask != null)
-                            orderSku.TimeLimitTaskList.Add(purchaseTimeLimitTask);
-                        orderSku.PurchaseTimeLimitTask = orderSku.TimeLimitTaskList.FirstOrDefault(t => t.TaskType == Enums.TimeLimitTaskType.采购任务);
+                        #region 采购限时任务
+                        orderSku.PurchaseTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
+                                                                                                    t.SkuId == orderSku.SkuId &&
+                                                                                                    t.TaskType == Enums.TimeLimitTaskType.采购任务);
+                        #endregion
+
+                        #region 合格证拟定任务
+                        orderSku.CerConfigTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
+                                                                                                     t.SkuId == orderSku.SkuId &&
+                                                                                                     t.TaskType == Enums.TimeLimitTaskType.合格证拟定任务);
+                        #endregion
+
+                        #region 合格证补充任务
+                        orderSku.CerEditTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
+                                                                                                   t.SkuId == orderSku.SkuId &&
+                                                                                                   t.TaskType == Enums.TimeLimitTaskType.合格证补充任务);
+                        #endregion
+
+                        #region 待核算任务
+                        orderSku.CheckComputationTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
+                                                                                                            t.TaskType == Enums.TimeLimitTaskType.待核算任务);
                         #endregion
 
                         #region 判断sku的发货状态
@@ -617,7 +655,16 @@ namespace BBWYB.Server.Business
             if (Math.Abs(orderCost.Profit ?? 0) > 1M)
                 throw new BusinessException("订单利润绝对值不能大于1");
 
-            fsql.Update<Order>(orderId).Set(o => o.OrderState, Enums.OrderState.已完成).ExecuteAffrows();
+            fsql.Transaction(() =>
+            {
+                fsql.Update<Order>(orderId).Set(o => o.OrderState, Enums.OrderState.已完成).ExecuteAffrows();
+                fsql.Update<TimeLimitTask>().Set(t => t.CompletionTime, DateTime.Now)
+                                            .Set(t => t.IsTimely == (DateTime.Now < t.ExpirationTime ? true : false))
+                                            .Where(t => t.OrderId == orderId)
+                                            .Where(t => t.CompletionTime == null)
+                                            .Where(t => t.TaskType == Enums.TimeLimitTaskType.待核算任务).ExecuteAffrows();
+            });
+
             SendPurchaseOrderStateToC(orderId, Enums.OrderState.已完成);
         }
 

BBWYB.Server.Business/PurchaseOrder/PurchaseOrderBusiness.cs

@@ -2481,6 +2481,7 @@ namespace BBWYB.Server.Business
                 IUpdate<PurchaseExpressOrder> updatePurchaseExpressOrder = null;
                 List<IUpdate<OrderPurchaseInfo>> updateOrderPurchaseList = new List<IUpdate<OrderPurchaseInfo>>();
                 List<IUpdate<Order>> updateOrderList = new List<IUpdate<Order>>();
+                List<TimeLimitTask> insertTimeLimitTaskList = new List<TimeLimitTask>();
 
                 #region 查询该笔快递单
                 var tpeo = fsql.Select<PurchaseExpressOrder>(wayBillNo).ToOne();
@@ -2701,6 +2702,29 @@ namespace BBWYB.Server.Business
                         #region 通知C端状态
                         Task.Factory.StartNew(() => SendPurchaseOrderStateToC(order.Id, order.OrderState.Value), CancellationToken.None, TaskCreationOptions.None, taskSchedulerManager.PurchaseOrderCallbackTaskScheduler);
                         #endregion
+
+                        #region 创建待核算任务
+                        if (order.OrderState == Enums.OrderState.待核算)
+                        {
+                            var isExists = fsql.Select<TimeLimitTask>().Where(t => t.OrderId == order.Id && t.TaskType == Enums.TimeLimitTaskType.待核算任务).Any();
+                            if (!isExists)
+                            {
+                                //创建合格证拟定任务
+                                var t = new TimeLimitTask()
+                                {
+                                    CreateTme = DateTime.Now,
+                                    Id = idGenerator.NewLong(),
+                                    OrderId = order.Id,
+                                    //SkuId = orderSku.SkuId,
+                                    OrderSn = order.OrderSn,
+                                    ShopId = order.ShopId,
+                                    TaskType = Enums.TimeLimitTaskType.待核算任务,
+                                    ExpirationTime = DateTime.Now.AddDays(1)
+                                };
+                                insertTimeLimitTaskList.Add(t);
+                            }
+                        }
+                        #endregion
                     }
                 }
                 #endregion
@@ -2719,6 +2743,8 @@ namespace BBWYB.Server.Business
                         foreach (var update in updateOrderList)
                             update.ExecuteAffrows();
                     }
+                    if (insertTimeLimitTaskList.Count() > 0)
+                        fsql.Insert(insertTimeLimitTaskList).ExecuteAffrows();
                 });
                 #endregion
             }

BBWYB.Server.Business/QiKuManager.cs

@@ -15,10 +15,16 @@ namespace BBWYB.Server.Business
         private RestApiService restApiService;
         private IFreeSql fsql;
         private NLogManager nLogManager;
+        private List<Enums.TimeLimitTaskType?> hgzTaskTypeList;
 
         public QiKuManager(RestApiService restApiService, IFreeSql fsql, NLogManager nLogManager, IIdGenerator idGenerator) : base(fsql, nLogManager, idGenerator)
         {
             this.restApiService = restApiService;
+            hgzTaskTypeList = new List<Enums.TimeLimitTaskType?>()
+            {
+                Enums.TimeLimitTaskType.合格证拟定任务,
+                Enums.TimeLimitTaskType.合格证补充任务
+            };
         }
 
         /// <summary>
@@ -149,6 +155,9 @@ namespace BBWYB.Server.Business
                 {
                     IList<IUpdate<OrderSku>> updateOrderSkuList = new List<IUpdate<OrderSku>>();
                     List<TimeLimitTask> insertTimeLimitTaskList = new List<TimeLimitTask>();
+
+                    var dbTimeLimitTaskList = fsql.Select<TimeLimitTask>().Where(t => t.OrderId == order.Id && 
+                                                                                      t.TaskType == Enums.TimeLimitTaskType.合格证拟定任务).ToList();
                     foreach (var skuConfigured in response.Data.PackTaskSkuPurchaseSchemeIdList)
                     {
                         var orderSku = orderSkuList.FirstOrDefault(osku => osku.BelongSkuId == skuConfigured.SkuId);
@@ -163,7 +172,7 @@ namespace BBWYB.Server.Business
                             updateOrderSkuList.Add(update);
                         }
 
-                        if (qiKuPackState == Enums.PackConfigState.待配置 && order.ShopId != 9)
+                        if (qiKuPackState == Enums.PackConfigState.待配置 && order.ShopId != 9 && !dbTimeLimitTaskList.Any(t=>t.SkuId == orderSku.SkuId))
                         {
                             //创建合格证拟定任务
                             var t = new TimeLimitTask()
@@ -229,6 +238,7 @@ namespace BBWYB.Server.Business
             {
                 var isExists = fsql.Select<TimeLimitTask>().Where(t => t.OrderId == request.OrderId &&
                                                                        t.SkuId == orderSku.SkuId &&
+                                                                       t.CompletionTime == null &&
                                                                        t.TaskType == Enums.TimeLimitTaskType.合格证补充任务)
                                                            .Any();
                 if (!isExists)
@@ -252,17 +262,13 @@ namespace BBWYB.Server.Business
             }
             else if (request.PackConfigState == Enums.PackConfigState.已配置)
             {
-                var taskTypeList = new List<Enums.TimeLimitTaskType?>()
-                {
-                    Enums.TimeLimitTaskType.合格证拟定任务,
-                    Enums.TimeLimitTaskType.合格证补充任务
-                };
+
                 updateTimeLimitTask = fsql.Update<TimeLimitTask>().Set(t => t.CompletionTime, DateTime.Now)
                                                                   .Set(t => t.IsTimely == (DateTime.Now < t.ExpirationTime ? true : false))
                                                                   .Where(t => t.OrderId == request.OrderId)
                                                                   .Where(t => t.SkuId == orderSku.SkuId)
                                                                   .Where(t => t.CompletionTime == null)
-                                                                  .Where(t => taskTypeList.Contains(t.TaskType));
+                                                                  .Where(t => hgzTaskTypeList.Contains(t.TaskType));
             }
 
             fsql.Transaction(() =>

BBWYB.Server.Business/TimeLimitTask/TimeLimitTaskBusiness.cs

@@ -1,5 +1,6 @@
 using BBWYB.Common.Log;
 using BBWYB.Common.Models;
+using BBWYB.Server.Model;
 using BBWYB.Server.Model.Db;
 using BBWYB.Server.Model.Dto;
 using Yitter.IdGenerator;
@@ -9,9 +10,15 @@ namespace BBWYB.Server.Business
     public class TimeLimitTaskBusiness : BaseBusiness, IDenpendency
     {
         private VenderBusiness venderBusiness;
+        private List<Enums.TimeLimitTaskType?> hgzTaskTypeList;
         public TimeLimitTaskBusiness(IFreeSql fsql, NLogManager nLogManager, IIdGenerator idGenerator, VenderBusiness venderBusiness) : base(fsql, nLogManager, idGenerator)
         {
             this.venderBusiness = venderBusiness;
+            hgzTaskTypeList = new List<Enums.TimeLimitTaskType?>()
+            {
+                Enums.TimeLimitTaskType.合格证拟定任务,
+                Enums.TimeLimitTaskType.合格证补充任务
+            };
         }
         public void CheckTask()
         {
@@ -69,6 +76,7 @@ namespace BBWYB.Server.Business
             #region 采购超时率
             var purchaseTaskCountGroups = fsql.Select<TimeLimitTask>().WhereIf(request.ShopId != null, t => t.ShopId == request.ShopId)
                                                                       .Where(t => t.CreateTme >= request.StartDate && t.CreateTme <= request.EndDate)
+                                                                      .Where(t => t.TaskType == Model.Enums.TimeLimitTaskType.采购任务)
                                                                       .GroupBy(t => t.ShopId)
                                                                       .ToList(g => new
                                                                       {
@@ -79,6 +87,7 @@ namespace BBWYB.Server.Business
             var purchaseTaskTimOutCountGroups = fsql.Select<TimeLimitTask>().WhereIf(request.ShopId != null, t => t.ShopId == request.ShopId)
                                                                             .Where(t => t.CreateTme >= request.StartDate && t.CreateTme <= request.EndDate)
                                                                             .Where(t => t.IsTimely == false)
+                                                                            .Where(t => t.TaskType == Model.Enums.TimeLimitTaskType.采购任务)
                                                                             .GroupBy(t => t.ShopId)
                                                                             .ToList(g => new
                                                                             {
@@ -87,6 +96,20 @@ namespace BBWYB.Server.Business
                                                                             });
             #endregion
 
+            #region 合格证补充/拟定超时量
+            var cerTimeOutCountGroups = fsql.Select<TimeLimitTask>().WhereIf(request.ShopId != null, t => t.ShopId == request.ShopId)
+                                                                    .Where(t => t.CreateTme >= request.StartDate && t.CreateTme <= request.EndDate)
+                                                                    .Where(t => t.IsTimely == false)
+                                                                    .Where(t => hgzTaskTypeList.Contains(t.TaskType))
+                                                                    .GroupBy(t => new { t.ShopId, t.TaskType })
+                                                                    .ToList(g => new
+                                                                    {
+                                                                        ShopId = g.Key.ShopId,
+                                                                        TaskType = g.Key.TaskType,
+                                                                        TaskCount = g.Count()
+                                                                    });
+            #endregion
+
             shopIdList.AddRange(purchaseTaskCountGroups.Select(g => g.ShopId.Value).ToList());
 
             foreach (var shopId in shopIdList)
@@ -99,7 +122,10 @@ namespace BBWYB.Server.Business
                 var purchaseTaskTimeOutCount = purchaseTaskTimOutCountGroups.FirstOrDefault(x => x.ShopId == response.ShopId)?.TaskCount ?? 0;
 
                 response.PurchaseTimeOutPercent = purchaseTaskCount == 0 ? 0 : Math.Round(1.0 * purchaseTaskTimeOutCount / purchaseTaskCount * 100, 2);
-
+                response.CerEditTimeOutCount = cerTimeOutCountGroups.FirstOrDefault(x => x.ShopId == response.ShopId && 
+                                                                                         x.TaskType == Enums.TimeLimitTaskType.合格证补充任务)?.TaskCount ?? 0;
+                response.CerConfigTimeOutCount = cerTimeOutCountGroups.FirstOrDefault(x => x.ShopId == response.ShopId && 
+                                                                                           x.TaskType == Enums.TimeLimitTaskType.合格证拟定任务)?.TaskCount ?? 0;
                 list.Add(response);
             }
 

BBWYB.Server.Model/Dto/Request/Order/QueryOrderRequest.cs

@@ -84,5 +84,20 @@
         /// 是否仅显示待发货超时,是=1否=0,只在订单状态为【待发货和部分发货】时生效
         /// </summary>
         public int? IsOnlyDisplayDeliveryTimeout { get; set; }
+
+        /// <summary>
+        /// 是否仅显示待配置-需修改,是=1否=0,只在【IsWaitConfig=true】时生效
+        /// </summary>
+        public int? IsOnlyDisplayPackConfigEditState { get; set; }
+
+        /// <summary>
+        /// 是否仅显示配置超时,是=1否=0,只在【IsWaitConfig=true】时生效(优先)
+        /// </summary>
+        public int? IsOnlyDisplayCerConfigTimeOut { get; set; }
+
+        /// <summary>
+        /// 是否仅显示核算超时,是=1否=0,只在订单状态为【待核算】时生效
+        /// </summary>
+        public int? IsOnlyDisplayCheckComputationTimeOut { get; set; }
     }
 }

BBWYB.Server.Model/Dto/Response/Order/OrderSkuResponse.cs

@@ -7,7 +7,7 @@ namespace BBWYB.Server.Model.Dto
         public OrderSkuResponse()
         {
             PurchaseExpressOrderList = new List<PurchaseExpressOrderResponse>();
-            TimeLimitTaskList = new List<TimeLimitTaskResponse>();
+            //TimeLimitTaskList = new List<TimeLimitTaskResponse>();
         }
 
         /// <summary>
@@ -20,14 +20,29 @@ namespace BBWYB.Server.Model.Dto
         /// </summary>
         public IList<PurchaseExpressOrderResponse> PurchaseExpressOrderList { get; set; }
 
-        /// <summary>
-        /// 限时任务列表
-        /// </summary>
-        public IList<TimeLimitTaskResponse> TimeLimitTaskList { get; set; }
+        ///// <summary>
+        ///// 限时任务列表
+        ///// </summary>
+        //public IList<TimeLimitTaskResponse> TimeLimitTaskList { get; set; }
 
         /// <summary>
         /// 采购限时任务
         /// </summary>
         public TimeLimitTaskResponse? PurchaseTimeLimitTask { get; set; }
+
+        /// <summary>
+        /// 合格证拟定任务
+        /// </summary>
+        public TimeLimitTaskResponse? CerConfigTimeLimitTask { get; set; }
+
+        /// <summary>
+        /// 合格证补充任务
+        /// </summary>
+        public TimeLimitTaskResponse? CerEditTimeLimitTask { get; set; }
+
+        /// <summary>
+        /// 待核算任务
+        /// </summary>
+        public TimeLimitTaskResponse? CheckComputationTimeLimitTask { get; set; }
     }
 }

BBWYB.Server.Model/Dto/Response/TimeLimitTask/TimeLimitTaskStatisticsResponse.cs

@@ -11,14 +11,15 @@
         /// </summary>
         public double PurchaseTimeOutPercent { get; set; }
 
+
         /// <summary>
-        /// 合格证拟定超时量
+        /// 合格证补充超时量
         /// </summary>
-        public double CertificatesTimeOutCount { get; set; }
+        public int? CerEditTimeOutCount { get; set; }
 
         /// <summary>
-        /// 合格证补充超时量
+        /// 合格证拟定超时量
         /// </summary>
-        public double CertificatesSupplementTimeOutCount { get; set; }
+        public int? CerConfigTimeOutCount { get; set; }
     }
 }