src/Hotline.Api/Controllers/OrderController.cs

@@ -75,10 +75,10 @@ public class OrderController : BaseController
     private readonly IRepository<OrderWord> _orderWrodRepository;
     private readonly IRepository<OrderObserve> _orderObserveRepository;
     private readonly IRepository<OrderFinality> _orderFinalityRepository;
-	
 
 
-	public OrderController(
+
+    public OrderController(
         IOrderDomainService orderDomainService,
         IOrderRepository orderRepository,
         IWorkflowApplication workflowApplication,
@@ -113,7 +113,7 @@ public class OrderController : BaseController
         IRepository<OrderWord> orderWrodRepository,
         IRepository<OrderObserve> orderObserveRepository,
         IRepository<OrderFinality> orderFinalityRepository
-	)
+    )
     {
         _orderDomainService = orderDomainService;
         _orderRepository = orderRepository;
@@ -151,7 +151,7 @@ public class OrderController : BaseController
         _orderFinalityRepository = orderFinalityRepository;
 
 
-	}
+    }
 
     #region 工单发布
 
@@ -953,7 +953,7 @@ public class OrderController : BaseController
             .WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.Visit.Order.Title.Contains(dto.Keyword!) || d.Visit.Order.No.Contains(dto.Keyword!))
             .WhereIF(dto.Status.HasValue && dto.Status != EScreenStatus.MyHandle, x => x.Status == dto.Status)
             .WhereIF(dto.Status.HasValue && dto.Status == EScreenStatus.MyHandle, x => x.Status != EScreenStatus.Apply && x.CreatorId == _sessionContext.UserId)
-			.WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
+            .WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
             .WhereIF(dto.CreationTimeEnd.HasValue, d => d.CreationTime <= dto.CreationTimeEnd)
             .WhereIF(!string.IsNullOrEmpty(dto.OrderId), x => x.OrderId == dto.OrderId)
             .OrderByDescending(x => x.CreationTime)
@@ -969,7 +969,7 @@ public class OrderController : BaseController
     [HttpPost("screen/startflow")]
     public async Task StartFlow([FromBody] ScreenStartFlowDto dto)
     {
-        var  screenAny = await _orderScreenRepository.AnyAsync(x => x.VisitDetailId == dto.Data.VisitDetailId && (x.Status == EScreenStatus.Apply || x.Status == EScreenStatus.Approval));
+        var screenAny = await _orderScreenRepository.AnyAsync(x => x.VisitDetailId == dto.Data.VisitDetailId && (x.Status == EScreenStatus.Apply || x.Status == EScreenStatus.Approval));
         if (screenAny)
             throw UserFriendlyException.SameMessage("该工单已提起甄别申请，正在审批过程中，不能申请");
 
@@ -1195,7 +1195,7 @@ public class OrderController : BaseController
         if (supervise is null)
             throw UserFriendlyException.SameMessage("无效督办");
         supervise.State = 2;
-		supervise.SignTime = DateTime.Now;
+        supervise.SignTime = DateTime.Now;
         supervise.SignUser = _sessionContext.UserName;
         await _orderSuperviseRepository.UpdateAsync(supervise, HttpContext.RequestAborted);
         var order = await _orderRepository.GetAsync(supervise.OrderId, HttpContext.RequestAborted);
@@ -1397,7 +1397,7 @@ public class OrderController : BaseController
             .WhereIF(dto.ExpiredTimeStart.HasValue, d => d.ExpiredTime >= dto.ExpiredTimeStart)
             .WhereIF(dto.ExpiredTimeEnd.HasValue, d => d.ExpiredTime <= dto.ExpiredTimeEnd)
             .WhereIF(dto.Statuses.Any(), d => dto.Statuses.Contains(d.Status))
-            .WhereIF(dto.Statuses.Any(d=>d== EOrderStatus.BackToUnAccept), d => d.Status <= EOrderStatus.BackToUnAccept)
+            .WhereIF(dto.Statuses.Any(d => d == EOrderStatus.BackToUnAccept), d => d.Status <= EOrderStatus.BackToUnAccept)
             .OrderByDescending(d => d.CreationTime)
             .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
 
@@ -1608,7 +1608,7 @@ public class OrderController : BaseController
         var isAdd = string.IsNullOrEmpty(dto.Data.Id);
         if (isAdd)
         {
-            id = await Add(_mapper.Map<AddOrderDto>(dto.Data));
+            id = await Add(dto.Data);
         }
         else
         {
@@ -2207,79 +2207,79 @@ public class OrderController : BaseController
         return await _orderObserveRepository.Queryable()
             .FirstAsync(x => x.Id == id);
     }
-	#endregion
-
-	#region 工单终结
-	/// <summary>
-	/// 新增工单终结
-	/// </summary>
-	/// <param name="dtos"></param>
-	/// <returns></returns>
-	[Permission(EPermission.AddOrderFinality)]
-	[HttpPost("order_finality")]
-	public async Task Add([FromBody] OrderFinalityAddDto dto)
-	{
-		var observe = _mapper.Map<OrderFinality>(dto);
-		await _orderFinalityRepository.AddAsync(observe, HttpContext.RequestAborted);
-	}
-
-	/// <summary>
-	/// 删除工单终结
-	/// </summary>
-	/// <param name="dto"></param>
-	/// <returns></returns>
-	[Permission(EPermission.DeleteOrderFinality)]
-	[HttpDelete("order_finality")]
-	public async Task Delete([FromBody] OrderFinalityDeleteDto dto)
-	{
-		await _orderRepository.RemoveOrderFinalityBatchAsync(dto.Ids, HttpContext.RequestAborted);
-	}
-
-	/// <summary>
-	/// 更新工单终结
-	/// </summary>
-	/// <param name="dto"></param>
-	/// <returns></returns>
-	[Permission(EPermission.UpdateOrderFinality)]
-	[HttpPut("order_finality")]
-	public async Task Update([FromBody] OrderFinalityUpdateDto dto)
-	{
-		var word = await _orderFinalityRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
-		if (word is null)
-			throw UserFriendlyException.SameMessage("无效工单观察");
-		_mapper.Map(dto, word);
-		await _orderFinalityRepository.UpdateAsync(word, HttpContext.RequestAborted);
-	}
-
-	/// <summary>
-	/// 获取工单终结列表
-	/// </summary>
-	/// <param name="dto"></param>
-	/// <returns></returns>
-	[Permission(EPermission.OrderFinalityList)]
-	[HttpGet("order_finality/list")]
-	public async Task<PagedDto<OrderFinalityDto>> List([FromQuery] OrderFinalityListDto dto)
-	{
-		var (total, items) = await _orderFinalityRepository.Queryable()
-			.Includes(x => x.Order)
-			.WhereIF(dto.IsProvince.HasValue, x => x.Order.IsProvince == dto.IsProvince)
-			.WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Order.Title.Contains(dto.Title!))
-			.WhereIF(!string.IsNullOrEmpty(dto.No), x => x.Order.No.Contains(dto.No!))
-			.OrderByDescending(x => x.CreationTime)
-			.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
-		return new PagedDto<OrderFinalityDto>(total, _mapper.Map<IReadOnlyList<OrderFinalityDto>>(items));
-	}
-
-	/// <summary>
-	/// 获取工单终结
-	/// </summary>
-	/// <param name="id"></param>
-	/// <returns></returns>
-	[HttpGet("order_finality/{id}")]
-	public async Task<OrderFinality> OrderFinalityEntity(string id)
-	{
-		return await _orderFinalityRepository.Queryable()
-			.FirstAsync(x => x.Id == id);
-	}
-	#endregion
+    #endregion
+
+    #region 工单终结
+    /// <summary>
+    /// 新增工单终结
+    /// </summary>
+    /// <param name="dtos"></param>
+    /// <returns></returns>
+    [Permission(EPermission.AddOrderFinality)]
+    [HttpPost("order_finality")]
+    public async Task Add([FromBody] OrderFinalityAddDto dto)
+    {
+        var observe = _mapper.Map<OrderFinality>(dto);
+        await _orderFinalityRepository.AddAsync(observe, HttpContext.RequestAborted);
+    }
+
+    /// <summary>
+    /// 删除工单终结
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [Permission(EPermission.DeleteOrderFinality)]
+    [HttpDelete("order_finality")]
+    public async Task Delete([FromBody] OrderFinalityDeleteDto dto)
+    {
+        await _orderRepository.RemoveOrderFinalityBatchAsync(dto.Ids, HttpContext.RequestAborted);
+    }
+
+    /// <summary>
+    /// 更新工单终结
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [Permission(EPermission.UpdateOrderFinality)]
+    [HttpPut("order_finality")]
+    public async Task Update([FromBody] OrderFinalityUpdateDto dto)
+    {
+        var word = await _orderFinalityRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
+        if (word is null)
+            throw UserFriendlyException.SameMessage("无效工单观察");
+        _mapper.Map(dto, word);
+        await _orderFinalityRepository.UpdateAsync(word, HttpContext.RequestAborted);
+    }
+
+    /// <summary>
+    /// 获取工单终结列表
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [Permission(EPermission.OrderFinalityList)]
+    [HttpGet("order_finality/list")]
+    public async Task<PagedDto<OrderFinalityDto>> List([FromQuery] OrderFinalityListDto dto)
+    {
+        var (total, items) = await _orderFinalityRepository.Queryable()
+            .Includes(x => x.Order)
+            .WhereIF(dto.IsProvince.HasValue, x => x.Order.IsProvince == dto.IsProvince)
+            .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Order.Title.Contains(dto.Title!))
+            .WhereIF(!string.IsNullOrEmpty(dto.No), x => x.Order.No.Contains(dto.No!))
+            .OrderByDescending(x => x.CreationTime)
+            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
+        return new PagedDto<OrderFinalityDto>(total, _mapper.Map<IReadOnlyList<OrderFinalityDto>>(items));
+    }
+
+    /// <summary>
+    /// 获取工单终结
+    /// </summary>
+    /// <param name="id"></param>
+    /// <returns></returns>
+    [HttpGet("order_finality/{id}")]
+    public async Task<OrderFinality> OrderFinalityEntity(string id)
+    {
+        return await _orderFinalityRepository.Queryable()
+            .FirstAsync(x => x.Id == id);
+    }
+    #endregion
 }

src/Hotline.Api/Controllers/WorkflowController.cs

@@ -355,12 +355,13 @@ public class WorkflowController : BaseController
     }
 
     /// <summary>
-    /// 跳转至任意节点
+    /// 跳转至任意节点(暂无需求设计)
     /// </summary>
     /// <param name="dto"></param>
     /// <returns></returns>
     [Permission(EPermission.FlowJump)]
     [HttpPost("jump")]
+    [Obsolete]
     public async Task Jump([FromBody] RecallDto dto)
     {
         await _workflowApplication.JumpAsync(dto, HttpContext.RequestAborted);

src/Hotline.Application/Handlers/FlowEngine/NextStepHandler.cs

@@ -85,20 +85,6 @@ public class NextStepHandler : INotificationHandler<NextStepNotify>
                 order.CheckIfFiled();
                 _mapper.Map(workflow, order);
 
-
-                ////todo publish province
-                //var orderDto = _mapper.Map<OrderDto>(order);
-                //if (notification.IsCenterToOrg)
-                //    await _capPublisher.PublishAsync(EventNames.HotlineOrderExpiredTimeUpdate, orderDto, cancellationToken: cancellationToken);
-
-                //if (notification.HandlerOrgCode.CheckIfOrgLevelIs(1))
-                //    await _capPublisher.PublishAsync(EventNames.HotlineOrderLevelOneOrgHandled, new OrderFlowDto
-                //    {
-                //        Order = orderDto,
-                //        WorkflowTrace = _mapper.Map<WorkflowTraceDto>(notification.Trace)
-                //    }, cancellationToken: cancellationToken);
-
-                //
                 var expiredTimeChanged = false;
                 if (data.FlowDirection.HasValue && data.External.TimeLimit.HasValue && data.External.TimeLimitUnit.HasValue)
                 {

src/Hotline.Application/Handlers/FlowEngine/RecallStepHandler.cs

@@ -1,8 +1,10 @@
 using DotNetCore.CAP;
 using Hotline.FlowEngine.Notifications;
 using Hotline.FlowEngine.WorkflowModules;
+using Hotline.FlowEngine.Workflows;
 using Hotline.Orders;
 using Hotline.Repository.SqlSugar.Orders;
+using Hotline.Settings.TimeLimits;
 using Hotline.Share.Dtos.Order;
 using Hotline.Share.Enums.FlowEngine;
 using Hotline.Share.Enums.Order;
@@ -16,17 +18,23 @@ public class RecallStepHandler : INotificationHandler<RecallNotify>
 {
     private readonly IOrderDomainService _orderDomainService;
     private readonly IOrderRepository _orderRepository;
+    private readonly IWorkflowDomainService _workflowDomainService;
+    private readonly ITimeLimitDomainService _timeLimitDomainService;
     private readonly ICapPublisher _capPublisher;
     private readonly IMapper _mapper;
 
     public RecallStepHandler(
         IOrderDomainService orderDomainService,
         IOrderRepository orderRepository,
+        IWorkflowDomainService workflowDomainService,
+        ITimeLimitDomainService timeLimitDomainService,
         ICapPublisher capPublisher,
         IMapper mapper)
     {
         _orderDomainService = orderDomainService;
         _orderRepository = orderRepository;
+        _workflowDomainService = workflowDomainService;
+        _timeLimitDomainService = timeLimitDomainService;
         _capPublisher = capPublisher;
         _mapper = mapper;
     }
@@ -50,10 +58,16 @@ public class RecallStepHandler : INotificationHandler<RecallNotify>
 
                 if (data.FlowDirection.HasValue && data.External.TimeLimit.HasValue && data.External.TimeLimitUnit.HasValue)
                 {
+                    var expiredTime = _timeLimitDomainService.CalcEndTime(DateTime.Now, data.External.TimeLimitUnit.Value,
+                        data.External.TimeLimit.Value, data.FlowDirection is EFlowDirection.OrgToCenter);
+
+                    await _workflowDomainService.UpdateExpiredTimeAsync(workflow, expiredTime.EndTime,
+                        expiredTime.RuleStr, data.External.TimeLimit, data.External.TimeLimitUnit, cancellationToken);
+
                     var dto = _mapper.Map<OrderDto>(order);
                     await _capPublisher.PublishAsync(EventNames.HotlineOrderFlowRecalled, dto, cancellationToken: cancellationToken);
                 }
-                
+
                 break;
             case WorkflowModuleConsts.KnowledgeAdd:
             case WorkflowModuleConsts.KnowledgeUpdate: