fixed:

1. 下级节点决定当前节点能否发起会签
2. 当前办理人分组存储

src/Hotline.Application/FlowEngine/IWorkflowApplication.cs

@@ -24,10 +24,10 @@ namespace Hotline.Application.FlowEngine
         Task<IReadOnlyList<NextStepOptions>> GetNextStepOptionsAsync(Workflow workflow, CancellationToken cancellationToken);
         Task<IReadOnlyList<NextStepOptions>> GetStartOptionsAsync(string moduleCode, CancellationToken cancellationToken);
 
-        /// <summary>
-        /// 查询指派办理人的处理方式及实际办理人
-        /// </summary>
-        Task<FlowAssignMode> GetFlowAssignModeAsync(StepDefine stepDefine, List<IdName> handlers,
-            CancellationToken cancellationToken);
+        ///// <summary>
+        ///// 查询指派办理人的处理方式及实际办理人
+        ///// </summary>
+        //Task<FlowAssignMode> GetFlowAssignModeAsync(StepDefine stepDefine, List<IdName> handlers,
+        //    CancellationToken cancellationToken);
     }
 }

src/Hotline.Application/FlowEngine/WorkflowApplication.cs

@@ -69,9 +69,11 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
         var nextStepBoxDefine = _workflowDomainService.GetStepBoxDefine(definition, dto.NextStepCode);
         var workflow = await _workflowDomainService.CreateWorkflowAsync(definition, dto.Title, externalId, cancellationToken);
 
-        var flowAssignMode = await GetFlowAssignModeAsync(nextStepBoxDefine, dto.NextHandlers, cancellationToken);
+        var isStartCountersign = nextStepBoxDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);
 
-        await _workflowDomainService.StartAsync(workflow, dto, nextStepBoxDefine, flowAssignMode, cancellationToken);
+        var flowAssignMode = await GetFlowAssignModeAsync(nextStepBoxDefine, isStartCountersign, dto.NextHandlers, cancellationToken);
+
+        await _workflowDomainService.StartAsync(workflow, dto, nextStepBoxDefine, isStartCountersign, flowAssignMode, cancellationToken);
 
         //更新接办部门(详情页面展示)
         await AddOrUpdateAssignAsync(workflow, dto, nextStepBoxDefine, cancellationToken);
@@ -96,13 +98,11 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
         var isOutOfCallCenter = nextStepBoxDefine.StepType is not EStepType.End
                                 && await CheckIfFlowOutOfCallCenterAsync(nextStepBoxDefine, dto.NextMainHandler, cancellationToken);
 
-        //var isStartCountersign = nextStepBoxDefine.IsStartCountersign(dto.NextHandlers.Count);
-        //if (isStartCountersign && nextStepBoxDefine.StepType is EStepType.CountersignEnd)
-        //    throw UserFriendlyException.SameMessage("汇总节点不允许发起会签");
+        var isStartCountersign = nextStepBoxDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);
 
-        var flowAssignMode = await GetFlowAssignModeAsync(nextStepBoxDefine, dto.NextHandlers, cancellationToken);
+        var flowAssignMode = await GetFlowAssignModeAsync(nextStepBoxDefine, isStartCountersign, dto.NextHandlers, cancellationToken);
 
-        await _workflowDomainService.NextAsync(workflow, dto, nextStepBoxDefine, isOutOfCallCenter, flowAssignMode, cancellationToken);
+        await _workflowDomainService.NextAsync(workflow, dto, nextStepBoxDefine, isOutOfCallCenter, isStartCountersign, flowAssignMode, cancellationToken);
 
         //更新接办部门(详情页面展示)
         await AddOrUpdateAssignAsync(workflow, dto, nextStepBoxDefine, cancellationToken);
@@ -134,7 +134,7 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
     /// <summary>
     /// 查询指派办理人的处理方式及实际办理人
     /// </summary>
-    public async Task<FlowAssignMode> GetFlowAssignModeAsync(StepDefine stepDefine, List<IdName> handlers, CancellationToken cancellationToken)
+    public async Task<FlowAssignMode> GetFlowAssignModeAsync(StepDefine stepDefine, bool isStartCountersign, List<IdName> handlers, CancellationToken cancellationToken)
     {
         if (stepDefine.StepType is EStepType.Start or EStepType.End) return default;
         switch (stepDefine.HandlerType)
@@ -149,31 +149,16 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
                     handlers = roles.SelectMany(d => d.Accounts).Distinct().Select(d => new IdName(d.Id, d.User.Name)).ToList();
                 }
 
-                return new FlowAssignMode(EFlowAssignType.User, new HandlerObjects
-                {
-                    UserGroups = new List<HandlerUserGroup>
-                    {
-                        new HandlerUserGroup{ HandlerUsers = handlers }
-                    }
-                });
+                return FlowAssignMode.Create(EFlowAssignType.User, handlers, isStartCountersign);
+
             case EHandlerType.OrgLevel:
             case EHandlerType.OrgType:
             case EHandlerType.AssignOrg:
-                return new FlowAssignMode(EFlowAssignType.Org, new HandlerObjects
-                {
-                    OrgGroups = new List<HandlerOrgGroup>
-                    {
-                        new HandlerOrgGroup{ HandlerOrgs = handlers }
-                    }
-                });
+                return FlowAssignMode.Create(EFlowAssignType.Org, handlers, isStartCountersign);
+
             case EHandlerType.AssignUser:
-                return new FlowAssignMode(EFlowAssignType.User, new HandlerObjects
-                {
-                    UserGroups = new List<HandlerUserGroup>
-                    {
-                        new HandlerUserGroup{ HandlerUsers = handlers }
-                    }
-                });
+                return FlowAssignMode.Create(EFlowAssignType.User, handlers, isStartCountersign);
+
             default:
                 throw new ArgumentOutOfRangeException();
         }

src/Hotline.Share/Enums/FlowEngine/ECountersignMode.cs

@@ -8,20 +8,26 @@ namespace Hotline.Share.Enums.FlowEngine;
 public enum ECountersignMode
 {
     /// <summary>
-    /// 不支持发起会签
+    /// 不支持办理会签
     /// </summary>
-    [Description("不支持发起会签")]
+    [Description("不支持办理会签")]
     UnSupport = 0,
 
-    /// <summary>
-    /// 立即汇总（在发起会签的当前节点进行汇总才会继续下一节点，无需另行配置汇总节点）
-    /// </summary>
-    [Description("立即汇总")]
-    GatherImmediately = 1,
+    ///// <summary>
+    ///// 立即汇总（在发起会签的当前节点进行汇总才会继续下一节点，无需另行配置汇总节点）
+    ///// </summary>
+    //[Description("立即汇总")]
+    //GatherImmediately = 1,
+
+    ///// <summary>
+    ///// 稍后汇总，延迟汇总（不会在会签发起节点进行汇总，汇总节点需单独配置）
+    ///// </summary>
+    //[Description("支持办理会签")]
+    //GatherLater = 2
 
     /// <summary>
-    /// 稍后汇总，延迟汇总（不会在会签发起节点进行汇总，汇总节点需单独配置）
+    /// 支持办理会签
     /// </summary>
-    [Description("支持发起会签")]
-    GatherLater = 2
+    [Description("支持办理会签")]
+    Support = 2
 }

src/Hotline/FlowEngine/Definitions/StepDefine.cs

@@ -12,17 +12,18 @@ public class StepDefine : StepBasic
     public List<NextStepDefine> NextSteps { get; set; }
 
     /// <summary>
-    /// 是否发起会签
+    /// 判断上级节点是否能发起会签
+    /// <remarks>下级节点配置决定当前办理节点能否发起会签</remarks>
     /// </summary>
     /// <param name="handlerCount">下一节点办理人数量</param>
     /// <returns></returns>
-    public bool IsStartCountersign11(int handlerCount)
+    public bool CouldPrevStartCountersign(int handlerCount)
     {
-        if (StepType is EStepType.End) return false;
+        if (StepType is EStepType.End or EStepType.CountersignEnd) return false;
 
         //需求：按角色指派默认不发起会签
         if (HandlerType is EHandlerType.Role) return false;
 
-        return handlerCount > 1;
+        return CountersignMode == ECountersignMode.Support && handlerCount > 1;
     }
 }

src/Hotline/FlowEngine/FlowAssignMode.cs

@@ -6,41 +6,64 @@ namespace Hotline.FlowEngine;
 
 public class FlowAssignMode
 {
-    public FlowAssignMode(EFlowAssignType flowAssignType, HandlerObjects handlerObjects)
-    {
-        FlowAssignType = flowAssignType;
-        HandlerObjects = handlerObjects;
-    }
+    //public FlowAssignMode(EFlowAssignType flowAssignType, List<HandlerGroupItem> handlerObjects)
+    //{
+    //    FlowAssignType = flowAssignType;
+    //    HandlerObjects = handlerObjects;
+    //}
 
     /// <summary>
     /// 流程指派类型
     /// </summary>
     public EFlowAssignType FlowAssignType { get; set; }
 
-    ///// <summary>
-    ///// 办理人/办理部门（UserIds/OrgCodes）
-    ///// </summary>
-    //public List<IdName> Handlers { get; set; }
-
     /// <summary>
-    /// 办理对象
+    /// 办理对象（UserIds/OrgCodes）
     /// </summary>
-    public HandlerObjects HandlerObjects { get; set; }
+    public List<HandlerGroupItem> HandlerObjects { get; set; }
 
     /// <summary>
-    /// 办理人/办理部门（UserIds/OrgCodes）
+    /// 创建mode对象实例，自动生成一个groupId
     /// </summary>
+    /// <param name="flowAssignType"></param>
+    /// <param name="handlers"></param>
     /// <returns></returns>
-    public List<string> GetHandlers()
+    public static FlowAssignMode Create(EFlowAssignType flowAssignType, List<IdName> handlers, bool multiGroups = false)
     {
-        switch (FlowAssignType)
+        if (handlers == null || !handlers.Any())
+            return new();
+        List<HandlerGroupItem> handlerObjects;
+        if (multiGroups)
         {
-            case EFlowAssignType.Org:
-                return HandlerObjects.OrgGroups.SelectMany(d => d.HandlerOrgs.Select(x => x.Id)).ToList();
-            case EFlowAssignType.User:
-                return HandlerObjects.UserGroups.SelectMany(d => d.HandlerUsers.Select(x => x.Id)).ToList();
-            default:
-                throw new ArgumentOutOfRangeException();
+            handlerObjects = handlers.Select(d => new HandlerGroupItem
+            {
+                Id = d.Id,
+                Name = d.Name,
+                GroupId = Guid.NewGuid().ToString(),
+            }).ToList();
         }
+        else
+        {
+            var groupId = Guid.NewGuid().ToString();
+            handlerObjects = handlers.Select(d => new HandlerGroupItem
+            {
+                Id = d.Id,
+                Name = d.Name,
+                GroupId = groupId
+            }).ToList();
+        }
+
+        return new FlowAssignMode
+        {
+            FlowAssignType = flowAssignType,
+            HandlerObjects = handlerObjects,
+        };
     }
+
+    /// <summary>
+    /// 办理人/办理部门（UserIds/OrgCodes）
+    /// </summary>
+    /// <returns></returns>
+    public List<string> GetHandlers() =>
+        HandlerObjects.Select(d => d.Id).ToList();
 }

src/Hotline/FlowEngine/Workflows/IWorkflowDomainService.cs

@@ -12,7 +12,8 @@ namespace Hotline.FlowEngine.Workflows
         /// <summary>
         /// 进行流程的开始节点
         /// </summary>
-        Task StartAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine, FlowAssignMode flowAssignMode, CancellationToken cancellationToken);
+        Task StartAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine,
+            bool isStartCountersign, FlowAssignMode flowAssignMode, CancellationToken cancellationToken);
 
         /// <summary>
         /// 查询工作流
@@ -28,7 +29,8 @@ namespace Hotline.FlowEngine.Workflows
         /// <summary>
         /// 办理（流转至下一节点）
         /// </summary>
-        Task NextAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine, bool isOutOfCallCenter, FlowAssignMode flowAssignMode, CancellationToken cancellationToken);
+        Task NextAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine,
+            bool isOutOfCallCenter, bool isStartCountersign, FlowAssignMode flowAssignMode, CancellationToken cancellationToken);
 
         /// <summary>
         /// 退回（返回前一节点）

src/Hotline/FlowEngine/Workflows/Workflow.cs

@@ -81,19 +81,13 @@ public class Workflow : CreationEntity
     /// 办理人id
     /// </summary>
     [SugarColumn(ColumnDataType = "json", IsJson = true)]
-    public List<string> HandlerUsers { get; set; } = new();
+    public List<HandlerGroupItem> HandlerUsers { get; set; } = new();
 
     /// <summary>
     /// 办理部门code
     /// </summary>
     [SugarColumn(ColumnDataType = "json", IsJson = true)]
-    public List<string> HandlerOrgs { get; set; } = new();
-
-    /// <summary>
-    /// 当前办理对象
-    /// </summary>
-    [SugarColumn(ColumnDataType = "json", IsJson = true)]
-    public HandlerObjects CurrentHandlers { get; set; } = new();
+    public List<HandlerGroupItem> HandlerOrgs { get; set; } = new();
 
     /// <summary>
     /// 外部业务唯一标识
@@ -212,23 +206,19 @@ public class Workflow : CreationEntity
     /// <summary>
     /// 更新当前办理人(代办人或部门)
     /// </summary>
-    public void UpdateHandlers(string handlerId, string handlerOrg, EFlowAssignType assignType, HandlerObjects handlerObjects)
+    public void UpdateHandlers(string handlerId, string handlerOrg, EFlowAssignType assignType, List<HandlerGroupItem> handlerObjects)
     {
         RemoveCurrentHandleGroup(handlerId, handlerOrg);
 
         switch (assignType)
         {
             case EFlowAssignType.Org:
-                if (handlerObjects?.OrgGroups == null || !handlerObjects.OrgGroups.Any())
-                    throw new UserFriendlyException("未指派办理人");
-                CurrentHandlers.OrgGroups.AddRange(handlerObjects.OrgGroups);
-                CurrentHandlers.OrgGroups = CurrentHandlers.OrgGroups.Distinct().ToList();
+                HandlerOrgs.AddRange(handlerObjects);
+                HandlerOrgs = HandlerOrgs.Distinct().ToList();
                 break;
             case EFlowAssignType.User:
-                if (CurrentHandlers?.UserGroups == null || !CurrentHandlers.UserGroups.Any())
-                    throw new UserFriendlyException("未指派办理部门");
-                CurrentHandlers.UserGroups.AddRange(handlerObjects.UserGroups);
-                CurrentHandlers.UserGroups = CurrentHandlers.UserGroups.Distinct().ToList();
+                HandlerUsers.AddRange(handlerObjects);
+                HandlerUsers = HandlerUsers.Distinct().ToList();
                 break;
             default:
                 throw new ArgumentOutOfRangeException(nameof(assignType), assignType, null);
@@ -237,11 +227,19 @@ public class Workflow : CreationEntity
 
     private void RemoveCurrentHandleGroup(string handlerId, string handlerOrg)
     {
-        if ((CurrentHandlers?.UserGroups == null || !CurrentHandlers.UserGroups.Any())
-           && (CurrentHandlers?.OrgGroups == null || !CurrentHandlers.OrgGroups.Any()))
-            return;
-        CurrentHandlers.UserGroups.RemoveAll(d => d.HandlerUsers.Any(x => x.Id == handlerId));
-        CurrentHandlers.OrgGroups.RemoveAll(d => d.HandlerOrgs.Any(x => x.Id == handlerOrg));
+        if (string.IsNullOrEmpty(handlerId) && string.IsNullOrEmpty(handlerOrg))
+            throw new UserFriendlyException($"{nameof(RemoveCurrentHandleGroup)}, 办理对象参数为空");
+        var groupOrg = HandlerOrgs.FirstOrDefault(d => d.Id == handlerOrg);
+        if (groupOrg != null)
+        {
+            HandlerOrgs.RemoveAll(d => d.GroupId == groupOrg.GroupId);
+        }
+
+        var groupUser = HandlerUsers.FirstOrDefault(d => d.Id == handlerId);
+        if (groupUser != null)
+        {
+            HandlerUsers.RemoveAll(d => d.GroupId == groupUser.GroupId);
+        }
     }
 
     /// <summary>
@@ -250,38 +248,15 @@ public class Workflow : CreationEntity
     /// <returns></returns>
     public bool CanHandle(string userId, string orgCode) =>
         Status is EWorkflowStatus.Runnable
-        && (HandlerUsers.Contains(userId) || HandlerOrgs.Contains(orgCode));
+        && (HandlerUsers.Any(d => d.Id == userId) || HandlerOrgs.Any(d => d.Id == orgCode));
 
     #endregion
 }
 
 /// <summary>
-/// 办理对象
+/// 办理对象分组（以办理step分组，多人办理一个step为一组）
 /// </summary>
-public class HandlerObjects
+public class HandlerGroupItem : IdName
 {
-    public List<HandlerUserGroup> UserGroups { get; set; }
-    public List<HandlerOrgGroup> OrgGroups { get; set; }
-}
-
-/// <summary>
-/// 办理用户分组
-/// </summary>
-public class HandlerUserGroup
-{
-    /// <summary>
-    /// 用户id，name
-    /// </summary>
-    public List<IdName> HandlerUsers { get; set; }
-}
-
-/// <summary>
-/// 办理部门分组
-/// </summary>
-public class HandlerOrgGroup
-{
-    /// <summary>
-    /// 部门code，name
-    /// </summary>
-    public List<IdName> HandlerOrgs { get; set; }
+    public string GroupId { get; set; }
 }

src/Hotline/FlowEngine/Workflows/WorkflowDomainService.cs

@@ -85,7 +85,7 @@ namespace Hotline.FlowEngine.Workflows
         /// <param name="dto"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task StartAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine, FlowAssignMode flowAssignMode, CancellationToken cancellationToken)
+        public async Task StartAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine, bool isStartCountersign, FlowAssignMode flowAssignMode, CancellationToken cancellationToken)
         {
             //var nextStepBoxDefine = GetStepBoxDefine(workflow.Definition, dto.NextStepCode);
 
@@ -96,7 +96,7 @@ namespace Hotline.FlowEngine.Workflows
             //开始节点
             var (startStepBox, startStep) = await CreateStartStepAsync(workflow, dto, cancellationToken);
 
-            var isStartCountersign = startStep.ShouldStartCountersign(dto.NextHandlers.Count);
+            //var isStartCountersign = startStep.ShouldStartCountersign(dto.NextHandlers.Count);
             //检查是否支持会签
             if (isStartCountersign && startStep.CountersignMode == ECountersignMode.UnSupport)
                 throw new UserFriendlyException($"当前节点不支持发起会签, stepId: {startStep.Id}", "当前节点不支持发起会签");
@@ -228,7 +228,7 @@ namespace Hotline.FlowEngine.Workflows
         /// 办理（流转至下一节点）
         /// </summary>
         public async Task NextAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine,
-            bool isOutOfCallCenter, FlowAssignMode flowAssignMode, CancellationToken cancellationToken)
+            bool isOutOfCallCenter, bool isStartCountersign, FlowAssignMode flowAssignMode, CancellationToken cancellationToken)
         {
             ValidatePermission(workflow);
             CheckWhetherRunnable(workflow.Status);
@@ -239,7 +239,7 @@ namespace Hotline.FlowEngine.Workflows
             if (currentStep.Status is EWorkflowStepStatus.Completed or EWorkflowStepStatus.Created)
                 throw UserFriendlyException.SameMessage("当前节点状态无法办理");
 
-            var isStartCountersign = currentStep.ShouldStartCountersign(dto.NextHandlers.Count);
+            //var isStartCountersign = currentStep.ShouldStartCountersign(dto.NextHandlers.Count);
             //检查是否支持发起会签
             if (isStartCountersign && currentStep.CountersignMode == ECountersignMode.UnSupport)
                 throw new UserFriendlyException($"当前节点不支持发起会签, stepId: {currentStep.Id}", "当前节点不支持发起会签");
@@ -445,14 +445,17 @@ namespace Hotline.FlowEngine.Workflows
             if (currentStepBox.StepType is EStepType.Start)
                 throw UserFriendlyException.SameMessage("当前流程已退回到开始节点");
 
-            var isStartCountersign = currentStep.ShouldStartCountersign(dto.NextHandlers.Count);
-            //检查是否支持会签
-            if (isStartCountersign && currentStep.CountersignMode == ECountersignMode.UnSupport)
-                throw new UserFriendlyException($"当前节点不支持发起会签, stepId: {currentStep.Id}", "当前节点不支持发起会签");
+            //var isStartCountersign = currentStep.ShouldStartCountersign(dto.NextHandlers.Count);
+            ////检查是否支持会签
+            //if (isStartCountersign && currentStep.CountersignMode == ECountersignMode.UnSupport)
+            //    throw new UserFriendlyException($"当前节点不支持发起会签, stepId: {currentStep.Id}", "当前节点不支持发起会签");
 
             var targetStepBox = workflow.StepBoxes.FirstOrDefault(d => d.Code == dto.TargetStepCode);
             if (targetStepBox is null)
                 throw UserFriendlyException.SameMessage("该流程尚未流转至该节点");
+            
+            var targetStepDefine = GetStepBoxDefine(workflow.Definition, dto.TargetStepCode);
+            var isStartCountersign = targetStepDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);
 
             await RecallAsync(workflow, dto, targetStepBox, isStartCountersign, cancellationToken);
 
@@ -472,10 +475,13 @@ namespace Hotline.FlowEngine.Workflows
             if (currentStepBox.StepType is EStepType.End)
                 throw UserFriendlyException.SameMessage("当前流程已流转到结束节点");
 
-            var isStartCountersign = currentStep.ShouldStartCountersign(dto.NextHandlers.Count);
-            //检查是否支持会签
-            if (isStartCountersign && currentStep.CountersignMode == ECountersignMode.UnSupport)
-                throw new UserFriendlyException($"当前节点不支持发起会签, stepId: {currentStep.Id}", "当前节点不支持发起会签");
+            //var isStartCountersign = currentStep.ShouldStartCountersign(dto.NextHandlers.Count);
+            ////检查是否支持会签
+            //if (isStartCountersign && currentStep.CountersignMode == ECountersignMode.UnSupport)
+            //    throw new UserFriendlyException($"当前节点不支持发起会签, stepId: {currentStep.Id}", "当前节点不支持发起会签");
+
+            var targetStepDefine = GetStepBoxDefine(workflow.Definition, dto.TargetStepCode);
+            var isStartCountersign = targetStepDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);
 
             var targetStepBox = workflow.StepBoxes.FirstOrDefault(d => d.Code == dto.TargetStepCode);
             if (targetStepBox == null)

src/Hotline/FlowEngine/Workflows/WorkflowStep.cs

@@ -171,19 +171,20 @@ public class WorkflowStep : StepBasicEntity
         return IsInCountersign ? EStepCountersignStatus.OuterCountersign : EStepCountersignStatus.None;
     }
 
-    /// <summary>
-    /// 检查该节点是否应该发起会签(办理时确认是否应该作为发起会签节点处理)
-    /// </summary>
-    /// <returns></returns>
-    public bool ShouldStartCountersign(int handlerCount)
-    {
-        if (StepType is EStepType.End) return false;
-
-        //需求：按角色指派默认不发起会签
-        if (HandlerType is EHandlerType.Role) return false;
-
-        return handlerCount > 1;
-    }
+    //过期：业务调整为由下级节点配置决定当前办理节点能否发起会签
+    ///// <summary>
+    ///// 检查该节点是否应该发起会签(办理时确认是否应该作为发起会签节点处理)
+    ///// </summary>
+    ///// <returns></returns>
+    //public bool ShouldStartCountersign(int handlerCount)
+    //{
+    //    if (StepType is EStepType.End) return false;
+
+    //    //需求：按角色指派默认不发起会签
+    //    if (HandlerType is EHandlerType.Role) return false;
+
+    //    return handlerCount > 1;
+    //}
 
     #endregion