查询流程开启参数

src/Hotline.Api/Controllers/PbxController.cs

@@ -212,6 +212,17 @@ namespace Hotline.Api.Controllers
 
         #region 话机设备操作
 
+        /// <summary>
+        /// 查询小修流程开启参数
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet("flow-start")]
+        public async Task<IReadOnlyList<NextStepOptions>> GetFlowStartOptionsAsync()
+        {
+            return await _workflowApplication.GetStartOptionsAsync(WorkflowModuleConsts.TelRestApply,
+                HttpContext.RequestAborted);
+        }
+
         /// <summary>
         /// 分机休息
         /// </summary>

src/Hotline.Application/FlowEngine/IWorkflowApplication.cs

@@ -22,6 +22,7 @@ namespace Hotline.Application.FlowEngine
         /// 查询流程下一节点配置参数
         /// </summary>
         Task<IReadOnlyList<NextStepOptions>> GetNextStepOptionsAsync(Workflow workflow, CancellationToken cancellationToken);
+        Task<IReadOnlyList<NextStepOptions>> GetStartOptionsAsync(string moduleCode, CancellationToken cancellationToken);
 
         /// <summary>
         /// 查询指派办理人的处理方式及实际办理人

src/Hotline.Application/FlowEngine/WorkflowApplication.cs

@@ -54,7 +54,12 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
 
     public async Task<string> StartWorkflowAsync(StartWorkflowDto dto, CancellationToken cancellationToken = default)
     {
-        var definition = await _definitionDomainService.GetLastVersionDefinitionAsync(dto.DefinitionCode, cancellationToken);
+        if (string.IsNullOrEmpty(dto.DefinitionCode) && string.IsNullOrEmpty(dto.DefinitionModuleCode))
+            throw new UserFriendlyException("非法参数");
+
+        var definition = string.IsNullOrEmpty(dto.DefinitionCode)
+            ? await _definitionDomainService.GetLastVersionDefinitionByModuleCodeAsync(dto.DefinitionModuleCode, cancellationToken)
+            : await _definitionDomainService.GetLastVersionDefinitionAsync(dto.DefinitionCode, cancellationToken);
         if (definition == null)
             throw new UserFriendlyException("无效模板名称");
         if (definition.Status != EDefinitionStatus.Enable)
@@ -96,7 +101,54 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
     public async Task<IReadOnlyList<NextStepOptions>> GetNextStepOptionsAsync(Workflow workflow, CancellationToken cancellationToken)
     {
         var nextStepDefines = _workflowDomainService.GetNextStepOptions(workflow, cancellationToken);
+        return await GetNextStepOptionsAsync(nextStepDefines);
+    }
+
+    public async Task<IReadOnlyList<NextStepOptions>> GetStartOptionsAsync(string moduleCode, CancellationToken cancellationToken)
+    {
+        var definition =
+            await _definitionDomainService.GetLastVersionDefinitionByModuleCodeAsync(moduleCode, cancellationToken);
+        if (definition == null)
+            throw new UserFriendlyException($"无效模块编码, modeuleCode: {moduleCode}", "无效模块编码");
+        var startStep = definition.Steps.FirstOrDefault(d => d.StepType == EStepType.Start);
+        var nextStepDefines = definition.FindSteps(startStep.NextSteps);
+        return await GetNextStepOptionsAsync(nextStepDefines);
+    }
+
+    /// <summary>
+    /// 查询指派办理人的处理方式及实际办理人
+    /// </summary>
+    public async Task<FlowAssignMode> GetFlowAssignModeAsync(StepDefine stepDefine, List<string> handlers, CancellationToken cancellationToken)
+    {
+        switch (stepDefine.HandlerType)
+        {
+            case EHandlerType.Role:
+                if (!handlers.Any())
+                {
+                    var roles = await _roleRepository.Queryable()
+                        .Includes(d => d.Accounts)
+                        .Where(d => stepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.Name))
+                        .ToListAsync();
+                    handlers = roles.SelectMany(d => d.Accounts).Select(d => d.Id).ToList();
+                }
+
+                return new FlowAssignMode(EFlowAssignType.User, handlers);
+            case EHandlerType.OrgLevel:
+            case EHandlerType.OrgType:
+            case EHandlerType.AssignOrg:
+                return new FlowAssignMode(EFlowAssignType.Org, handlers);
+            case EHandlerType.AssignUser:
+                return new FlowAssignMode(EFlowAssignType.User, handlers);
+            default:
+                throw new ArgumentOutOfRangeException();
+        }
+    }
 
+
+    #region private
+
+    private async Task<IReadOnlyList<NextStepOptions>> GetNextStepOptionsAsync(IReadOnlyList<StepDefine> nextStepDefines)
+    {
         //todo 性能问题
         var items = new List<NextStepOptions>();
         foreach (var nextStepDefine in nextStepDefines)
@@ -110,11 +162,13 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
             switch (nextStepDefine.HandlerType)
             {
                 case EHandlerType.AssignUser:
-                    var users = await _userRepository.QueryAsync(d => nextStepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.Id));
+                    var users = await _userRepository.QueryAsync(d =>
+                        nextStepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.Id));
                     options.NextSteps = users.Select(d => new KeyValuePair<string, string>(d.Id, d.Name)).ToList();
                     break;
                 case EHandlerType.AssignOrg:
-                    var orgs = await _organizeRepository.QueryAsync(d => nextStepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.OrgCode));
+                    var orgs = await _organizeRepository.QueryAsync(d =>
+                        nextStepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.OrgCode));
                     options.NextSteps = orgs.Select(d => new KeyValuePair<string, string>(d.OrgCode, d.OrgName)).ToList();
                     break;
                 case EHandlerType.Role:
@@ -151,37 +205,6 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
         return items;
     }
 
-    /// <summary>
-    /// 查询指派办理人的处理方式及实际办理人
-    /// </summary>
-    public async Task<FlowAssignMode> GetFlowAssignModeAsync(StepDefine stepDefine, List<string> handlers, CancellationToken cancellationToken)
-    {
-        switch (stepDefine.HandlerType)
-        {
-            case EHandlerType.Role:
-                if (!handlers.Any())
-                {
-                    var roles = await _roleRepository.Queryable()
-                        .Includes(d => d.Accounts)
-                        .Where(d => stepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.Name))
-                        .ToListAsync();
-                    handlers = roles.SelectMany(d => d.Accounts).Select(d => d.Id).ToList();
-                }
-
-                return new FlowAssignMode(EFlowAssignType.User, handlers);
-            case EHandlerType.OrgLevel:
-            case EHandlerType.OrgType:
-            case EHandlerType.AssignOrg:
-                return new FlowAssignMode(EFlowAssignType.Org, handlers);
-            case EHandlerType.AssignUser:
-                return new FlowAssignMode(EFlowAssignType.User, handlers);
-            default:
-                throw new ArgumentOutOfRangeException();
-        }
-    }
-
-
-    #region private
 
     /// <summary>
     /// 更新接办部门

src/Hotline.Share/Dtos/FlowEngine/StartWorkflowDto.cs

@@ -5,7 +5,8 @@
         /// <summary>
         /// 模板编码
         /// </summary>
-        public string DefinitionCode { get; set; }
+        public string? DefinitionCode { get; set; }
+        public string? DefinitionModuleCode { get; set; }
 
         /// <summary>
         /// 流程title

src/Hotline/FlowEngine/Definitions/DefinitionDomainService.cs

@@ -34,7 +34,7 @@ public class DefinitionDomainService : IDefinitionDomainService, IScopeDependenc
         var definitionTemp = await _definitionRepository.GetAsync(id, cancellationToken);
         if (definitionTemp == null)
             throw UserFriendlyException.SameMessage("无效模板编号");
-        if(definitionTemp.Status != EDefinitionStatus.Temporary)
+        if (definitionTemp.Status != EDefinitionStatus.Temporary)
             throw UserFriendlyException.SameMessage("非草稿模板不允许发布");
 
         ValidateDefinition(definitionTemp);
@@ -70,6 +70,15 @@ public class DefinitionDomainService : IDefinitionDomainService, IScopeDependenc
             .FirstAsync();
     }
 
+    public async Task<Definition?> GetLastVersionDefinitionByModuleCodeAsync(string moduleCode, CancellationToken cancellationToken)
+    {
+        return await _definitionRepository.Queryable()
+            .Where(d => d.ModuleCode == moduleCode)
+            .OrderByDescending(d => d.Version)
+            .Take(1)
+            .FirstAsync();
+    }
+
     /// <summary>
     /// 未开启的流程，查找第2个节点的模板配置信息，用作开始流程的时候传参
     /// </summary>

src/Hotline/FlowEngine/Definitions/IDefinitionDomainService.cs

@@ -18,6 +18,7 @@ namespace Hotline.FlowEngine.Definitions
 
         Task<int> GetLastVersionAsync(string code, CancellationToken cancellationToken);
         Task<Definition?> GetLastVersionDefinitionAsync(string code, CancellationToken cancellationToken);
+        Task<Definition?> GetLastVersionDefinitionByModuleCodeAsync(string moduleCode, CancellationToken cancellationToken);
 
         /// <summary>
         /// 未开启的流程，查找start节点配置的nextSteps信息，用作开启流程的传参