hotline/src/Hotline/FlowEngine/Workflows/WorkflowDomainService.cs

using Hotline.FlowEngine.Definitions;
using Hotline.FlowEngine.Notifies;
using Hotline.SeedData;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Users;
using MapsterMapper;
using MediatR;
using XF.Domain.Authentications;
using XF.Domain.Dependency;
using XF.Domain.Exceptions;
using XF.Utility.SequentialId;

namespace Hotline.FlowEngine.Workflows
{
    public class WorkflowDomainService : IWorkflowDomainService, IScopeDependency
    {
        private readonly IWorkflowRepository _workflowRepository;
        private readonly IWorkflowStepRepository _workflowStepRepository;
        private readonly IWorkflowTraceRepository _workflowTraceRepository;
        private readonly IWorkflowSupplementRepository _workflowSupplementRepository;
        private readonly ISessionContext _sessionContext;
        private readonly IMapper _mapper;
        private readonly IMediator _mediator;

        public WorkflowDomainService(
            IWorkflowRepository workflowRepository,
            IWorkflowStepRepository workflowStepRepository,
            IWorkflowTraceRepository workflowTraceRepository,
            IWorkflowSupplementRepository workflowSupplementRepository,
            ISessionContext sessionContext,
            IMapper mapper,
            IMediator mediator)
        {
            _workflowRepository = workflowRepository;
            _workflowStepRepository = workflowStepRepository;
            _workflowTraceRepository = workflowTraceRepository;
            _workflowSupplementRepository = workflowSupplementRepository;

            _sessionContext = sessionContext;
            _mapper = mapper;
            _mediator = mediator;
        }

        public async Task<Workflow> CreateWorkflowAsync(Definition definition, string title, CancellationToken cancellationToken)
        {
            var workflow = new Workflow
            {
                Title = title,
                ModuleId = definition.ModuleId,
                ModuleName = definition.ModuleName,
                ModuleCode = definition.ModuleCode,
                DefinitionId = definition.Id,
                Status = EWorkflowStatus.Runnable,
                ExpiredTime = GenerateExpiredTime(definition.Code),
                StepBoxes = new(),
                Traces = new(),
                Definition = definition
            };

            await _workflowRepository.AddAsync(workflow, cancellationToken);

            return workflow;
        }

        /// <summary>
        /// 进行流程的开始节点
        /// </summary>
        /// <param name="workflow"></param>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task StartAsync(Workflow workflow, BasicWorkflowDto dto, CancellationToken cancellationToken)
        {
            var nextStepBoxDefine = GetStepBoxDefine(workflow.Definition, dto.NextStepCode);

            if (dto.Handlers.Count > 1)
            {
                //检查是否支持会签
                if (nextStepBoxDefine.CountersignMode == ECountersignMode.UnSupport)
                    throw new UserFriendlyException($"当前节点不支持会签, defineCode: {workflow.Definition.Code}", "当前节点不支持会签");
            }

            //第二节点的previousId is string.Empty
            await CreateStepAsync(workflow, nextStepBoxDefine, dto, cancellationToken: cancellationToken);

            //publish
            await _mediator.Publish(new StartWorkflowNotify(workflow, nextStepBoxDefine.GFlowAssignType(), dto), cancellationToken);
        }

        public async Task<Workflow> GetWorkflowAsync(string workflowId,
            bool withDefine = false, bool withSteps = false,
            bool withTraces = false, bool withSupplements = false,
            CancellationToken cancellationToken = default)
        {
            var query = _workflowRepository.Queryable();
            if (withDefine)
                query = query.Includes(d => d.Definition);
            if (withSupplements)
                query = query.Includes(d => d.Supplements);

            var workflow = await query.FirstAsync(d => d.Id == workflowId);
            if (workflow is null)
                throw new UserFriendlyException("无效workflowId");

            if (withSteps)
            {
                var steps = await _workflowStepRepository.Queryable()
                    .Where(d => d.WorkflowId == workflowId)
                    .OrderBy(d => d.CreationTime)
                    .ToTreeAsync(d => d.Steps, d => d.ParentId, null);
                workflow.StepBoxes = steps;
            }

            if (withTraces)
            {
                var traces = await _workflowTraceRepository.Queryable()
                    .Where(d => d.WorkflowId == workflowId)
                    .ToTreeAsync(d => d.Traces, d => d.ParentId, null);
                workflow.Traces = traces;
            }

            return workflow;
        }

        /// <summary>
        /// 受理
        /// </summary>
        public async Task AcceptAsync(Workflow workflow, CancellationToken cancellationToken)
        {
            //工单完成以后查看的场景
            if (workflow.Status is not EWorkflowStatus.Runnable) return;

            var (currentStepBox, currentStep) = GetUnCompleteStepOrDefault(workflow.StepBoxes, _sessionContext.RequiredOrgCode, _sessionContext.RequiredUserId);
            if (currentStep is null) return;
            if (currentStep.Status is EWorkflowStepStatus.Accepted) return;
            if (currentStep.HandlerType is EHandlerType.AssignUser or EHandlerType.Role)
            {
                //userId
                if (currentStep.HandlerId != _sessionContext.RequiredUserId) return;
            }
            else
            {
                //orgId
                if (currentStep.HandlerId != _sessionContext.RequiredOrgCode) return;
            }
            if (currentStep.StepType is EStepType.End)
                throw new UserFriendlyException("当前流程已流转到最终步骤");

            if (currentStepBox.Status is EWorkflowStepStatus.Assigned)
                currentStepBox.Status = EWorkflowStepStatus.Accepted;
            currentStep.Accept(_sessionContext.RequiredUserId, _sessionContext.UserName);

            await AcceptTraceAsync(workflow, currentStepBox, currentStep, cancellationToken);

            await _mediator.Publish(new AcceptWorkflowNotify(workflow), cancellationToken);
        }

        /// <summary>
        /// 办理（流转至下一节点）
        /// </summary>
        public async Task NextAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine, bool isOutOfCallCenter, CancellationToken cancellationToken)
        {
            CheckWhetherRunnable(workflow.Status);

            #region 办理当前节点

            var (currentStepBox, currentStep) = GetUnCompleteStep(workflow.StepBoxes, _sessionContext.RequiredOrgCode, _sessionContext.RequiredUserId);
            if (currentStep.Status is EWorkflowStepStatus.Assigned)
                await AcceptAsync(workflow, cancellationToken);
            if (currentStep.StepType is EStepType.End)
                throw new UserFriendlyException("当前流程已流转到最终步骤");

            //是否发起会签
            var isStartCountersign = dto.Handlers.Count > 1;
            //检查是否支持会签办理
            if (isStartCountersign && nextStepBoxDefine.CountersignMode == ECountersignMode.UnSupport)
                throw UserFriendlyException.SameMessage($"下一节点不支持会签办理, code: {currentStep.Code}");
            if (isStartCountersign)
                currentStep.StartCountersign();

            _mapper.Map(dto, currentStep);

            //step办理状态
            currentStep.StepComplete(
                _sessionContext.RequiredUserId, _sessionContext.UserName,
                _sessionContext.RequiredOrgCode, _sessionContext.OrgName,
                dto.NextStepCode);

            //stepBox办理状态
            currentStepBox.CheckStepBoxStatusAndUpdate();

            var updateSteps = new List<WorkflowStep> { currentStepBox, currentStep };
            //结束当前会签流程
            if (currentStep.StepType is EStepType.CountersignEnd && currentStep.IsInCountersign)
            {
                var countersignStartStep = FindCountersignStartStep(workflow, currentStep.CountersignStartCode, currentStep.PrevCountersignId);
                if (countersignStartStep.HasStartCountersign)
                {
                    countersignStartStep.CountersignComplete();
                    updateSteps.Add(countersignStartStep);
                }
            }

            await _workflowStepRepository.UpdateRangeAsync(updateSteps, cancellationToken);

            #endregion

            #region 处理流程

            //检查会签是否结束，并更新当前会签节点字段
            workflow.CompleteCountersign();

            //检查是否流转到流程终点
            if (nextStepBoxDefine.StepType is EStepType.End)
            {
                workflow.Complete();
                await _workflowRepository.UpdateAsync(workflow, cancellationToken);

                //todo publish workflow end
                return;
            }

            //是否从中心流转出去，重新计算expiredTime 
            if (isOutOfCallCenter)
                workflow.ExpiredTime = GenerateExpiredTime(workflow.Definition.Code);

            //创建下一节点
            var nextStepBox = await CreateStepAsync(workflow, nextStepBoxDefine, dto, currentStepBox, currentStep, cancellationToken);

            //下一节点为汇总节点时，检查下一节点是否可办理
            if (nextStepBox.StepType is EStepType.CountersignEnd)
            {
                if (currentStep.IsInCountersign)
                {
                    var stepCode = currentStep.StepType is EStepType.CountersignEnd
                        ? currentStep.CountersignStartCode
                        : currentStep.Code;

                    var countersignId = string.IsNullOrEmpty(currentStep.TopCountersignId)
                        ? currentStep.PrevCountersignId
                        : currentStep.TopCountersignId;

                    var stepBox = workflow.StepBoxes.First(d => d.Code == stepCode);
                    var countersignSteps =
                        stepBox.Steps.Where(d => d.PrevCountersignId == countersignId);

                    //check all complete or cs complete
                    var canHandle = true;
                    foreach (var countersignStep in countersignSteps)
                    {
                        if (countersignStep.Status != EWorkflowStepStatus.Completed) break;
                        if (countersignStep.HasStartCountersign && !countersignStep.IsCountersignComplete.GetValueOrDefault()) break;
                    }

                    if (canHandle)
                    {
                        await UpdateNextCountersignEndAssignedAsync(nextStepBox, currentStep, cancellationToken);
                        await _mediator.Publish(new CountersignEndAssigned(workflow), cancellationToken);
                    }

                }
                else
                {
                    await UpdateNextCountersignEndAssignedAsync(nextStepBox, currentStep, cancellationToken);
                    await _mediator.Publish(new CountersignEndAssigned(workflow), cancellationToken);
                }
            }

            //更新当前节点名称、时间、会签节点code 等字段
            workflow.SetWorkflowCurrentStepInfo(isStartCountersign, nextStepBox);

            await _workflowRepository.UpdateAsync(workflow, cancellationToken);

            #endregion

            #region 流转记录

            await NextTraceAsync(workflow, dto, currentStep, cancellationToken);

            #endregion

            await _mediator.Publish(new NextStepNotify(workflow, nextStepBoxDefine.GFlowAssignType(), dto), cancellationToken);
        }

        /// <summary>
        /// 更新下级汇总节点可办理状态
        /// </summary>
        /// <param name="nextStepBox"></param>
        /// <param name="currentStep"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        private async Task UpdateNextCountersignEndAssignedAsync(WorkflowStep nextStepBox, WorkflowStep currentStep, CancellationToken cancellationToken)
        {
            var countersignId = string.IsNullOrEmpty(currentStep.TopCountersignId)
                ? currentStep.PrevCountersignId
                : currentStep.TopCountersignId;

            var nextStep = nextStepBox.Steps.First(d => d.PrevCountersignId == countersignId);
            nextStep.SetAssigned();

            await _workflowStepRepository.UpdateAsync(nextStep, cancellationToken);
        }


        /// <summary>
        /// 退回（返回前一节点）
        /// </summary>
        /// <returns></returns>
        public async Task PreviousAsync(Workflow workflow, PreviousWorkflowDto dto, CancellationToken cancellationToken)
        {
            CheckWhetherRunnable(workflow.Status);
            var (currentStepBox, currentStep) = GetUnCompleteStep(workflow.StepBoxes, _sessionContext.RequiredOrgCode, _sessionContext.RequiredUserId);
            if (currentStepBox.StepType is EStepType.Start)
                throw UserFriendlyException.SameMessage("当前流程已退回到开始节点");
            if (currentStepBox.Steps.Count > 1)
                throw UserFriendlyException.SameMessage("会签流程不支持退回");

            //update trace
            await PreviousTraceAsync(workflow.Id, dto, currentStep, cancellationToken);

            //remove workflow.steps
            await _workflowStepRepository.RemoveRangeAsync(new List<WorkflowStep> { currentStepBox, currentStep },
                cancellationToken);

            //todo publish
        }

        /// <summary>
        /// 撤回（返回到之前任意节点）
        /// </summary>
        public async Task RecallAsync(Workflow workflow, RecallDto dto, CancellationToken cancellationToken)
        {
            CheckWhetherRunnable(workflow.Status);
            var targetStepBox = workflow.StepBoxes.FirstOrDefault(d => d.Code == dto.TargetStepCode);
            if (targetStepBox is null)
                throw UserFriendlyException.SameMessage("该流程尚未流转至该节点");

            await RecallAsync(workflow, dto, targetStepBox, cancellationToken);

            //todo publish
        }

        /// <summary>
        /// 跳转（直接将流程跳转至任意节点）
        /// </summary>
        public async Task JumpAsync(Workflow workflow, RecallDto dto, CancellationToken cancellationToken)
        {
            CheckWhetherRunnable(workflow.Status);
            //update uncompleted traces
            await JumpTraceAsync(workflow.Id, dto, cancellationToken);

            var targetStepBox = workflow.StepBoxes.FirstOrDefault(d => d.Code == dto.TargetStepCode);
            if (targetStepBox == null)
            {
                var nextStepBoxDefine = GetStepBoxDefine(workflow.Definition, dto.NextStepCode);
                var nextStepBox = await CreateStepAsync(workflow, nextStepBoxDefine, dto, cancellationToken: cancellationToken);

                await ResetWorkflowCurrentStepInfo(workflow, dto, nextStepBox, cancellationToken);

                #region 补充中间节点处理方案

                //var completeStepCodes = workflow.StepBoxes.Select(d => d.Code);
                //var uncompleteStepDefines = workflow.Definition.Steps.Where(d => !completeStepCodes.Contains(d.Code));
                //创建当前节点与目标节点中间节点
                //var jumpDto = new BasicWorkflowDto
                //{
                //    Opinion = "跳转补充"
                //};

                //foreach (var stepDefine in uncompleteStepDefines)
                //{
                //    var previousStepId = lastStepBox.Steps.Count > 1 ? lastStepBox.Id : lastStepBox.Steps.First().Id;
                //    if (dto.TargetStepCode == stepDefine.Code)
                //    {
                //        await CreateStepAsync(workflow, stepDefine, dto, lastStepBox.Id, previousStepId, cancellationToken);
                //        break;
                //    }

                //    //jump业务下，如果当前节点为会签节点，第一个补充节点的subStep.PreviousId无法确定从哪个子节点跳转过来，统一处理为当前节点的stepBox.Id
                //    lastStepBox = await CreateStepAsync(workflow, stepDefine, dto, lastStepBox.Id, previousStepId, cancellationToken);
                //} 

                #endregion
            }
            else
            {
                //返回之前节点
                await RecallAsync(workflow, dto, targetStepBox, cancellationToken);
            }

            //todo publish
        }

        private async Task ResetWorkflowCurrentStepInfo(Workflow workflow, RecallDto dto, WorkflowStep stepBox, CancellationToken cancellationToken)
        {
            //更新当前节点名称、时间、会签节点code
            workflow.CloseCountersignStatus();
            var isCountersign = dto.Handlers.Count > 1;
            workflow.SetWorkflowCurrentStepInfo(isCountersign, stepBox);
            await _workflowRepository.UpdateAsync(workflow, cancellationToken);
        }

        /// <summary>
        /// 补充
        /// </summary>
        /// <returns></returns>
        public async Task SupplementAsync(Workflow workflow, EndWorkflowDto dto, CancellationToken cancellationToken)
        {
            CheckWhetherRunnable(workflow.Status);
            //todo 检查当前办理人是否为该流程中的办理人

            var supplement = _mapper.Map<WorkflowSupplement>(dto);
            await _workflowSupplementRepository.AddAsync(supplement, cancellationToken);
        }

        /// <summary>
        /// 终止流程
        /// </summary>
        public async Task TerminateAsync(string id, CancellationToken cancellationToken)
        {
            var workflow = await _workflowRepository.GetAsync(id, cancellationToken);
            if (workflow == null)
                throw UserFriendlyException.SameMessage("无效的流程编号");
            workflow.Terminate();
            await _workflowRepository.UpdateAsync(workflow, cancellationToken);

            //todo publish
        }

        /// <summary>
        /// 根据stepCode查询流程配置中对应的节点
        /// </summary>
        public StepDefine GetStepBoxDefine(Definition definition, string stepCode)
        {
            if (definition == null) throw new ArgumentNullException(nameof(definition));
            if (string.IsNullOrEmpty(stepCode)) throw new ArgumentNullException(nameof(stepCode));
            var stepDefine = definition.FindStep(stepCode);
            if (stepDefine == null)
                throw new UserFriendlyException($"未找到流程中对应的节点，DefineCode: {definition.Code}, stepCode: {stepCode}",
                    "未查询到对应节点");
            return stepDefine;
        }

        /// <summary>
        /// 查询当前待办节点的下一级节点配置(办理参数)
        /// </summary>
        public IReadOnlyList<StepDefine> GetNextStepOptions(Workflow workflow, CancellationToken cancellationToken)
        {
            var (currentStepBox, _) = GetUnCompleteStep(workflow.StepBoxes, _sessionContext.RequiredOrgCode, _sessionContext.RequiredUserId);
            return workflow.Definition.FindSteps(currentStepBox.NextSteps);
        }


        #region private

        /// <summary>
        /// 在stepCode对应的stepBox中找到开启会签流程的节点
        /// </summary>
        private static WorkflowStep FindCountersignStartStep(Workflow workflow, string startCountersignStepCode, string startCountersignId)
        {
            var countersignStartStepBox = workflow.StepBoxes.First(d => d.Code == startCountersignStepCode);
            var countersignStartStep =
                countersignStartStepBox.Steps.First(d => d.StartCountersignId == startCountersignId);
            return countersignStartStep;
        }

        private async Task JumpTraceAsync(string workflowId, RecallDto dto, CancellationToken cancellationToken)
        {
            //未办理的traces
            var uncompleteTraces =
                await _workflowTraceRepository.QueryAsync(d =>
                    d.WorkflowId == workflowId && string.IsNullOrEmpty(d.UserId));
            foreach (var trace in uncompleteTraces)
            {
                trace.Jump(
                    _sessionContext.RequiredUserId,
                    _sessionContext.UserName,
                    _sessionContext.RequiredOrgCode,
                    _sessionContext.OrgName);
            }

            await _workflowTraceRepository.UpdateRangeAsync(uncompleteTraces, cancellationToken);
        }

        private async Task RecallTraceAsync(string workflowId, RecallDto dto, CancellationToken cancellationToken)
        {
            //未办理的traces
            var uncompleteTraces =
                await _workflowTraceRepository.QueryAsync(d =>
                    d.WorkflowId == workflowId && string.IsNullOrEmpty(d.UserId));
            foreach (var trace in uncompleteTraces)
            {
                trace.Recall(
                    _sessionContext.RequiredUserId,
                    _sessionContext.UserName,
                    _sessionContext.RequiredOrgCode,
                    _sessionContext.OrgName);
            }

            await _workflowTraceRepository.UpdateRangeAsync(uncompleteTraces, cancellationToken);
        }

        private async Task PreviousTraceAsync(string workflowId, PreviousWorkflowDto dto, WorkflowStep step, CancellationToken cancellationToken)
        {
            var trace = await GetWorkflowTraceAsync(workflowId, step.Id, cancellationToken);
            _mapper.Map(dto, trace);
            trace.Previous(
                _sessionContext.RequiredUserId,
                _sessionContext.UserName,
                _sessionContext.RequiredOrgCode,
                _sessionContext.OrgName);
            await _workflowTraceRepository.UpdateAsync(trace, cancellationToken);
        }

        private async Task NextTraceAsync(Workflow workflow, BasicWorkflowDto dto, WorkflowStep step, CancellationToken cancellationToken)
        {
            var trace = await GetWorkflowTraceAsync(workflow.Id, step.Id, cancellationToken);
            _mapper.Map(dto, trace);
            _mapper.Map(step, trace);
            trace.ExpiredTime = workflow.ExpiredTime;
            await _workflowTraceRepository.UpdateAsync(trace, cancellationToken);
        }

        private async Task AcceptTraceAsync(Workflow workflow, WorkflowStep currentStepBox, WorkflowStep currentStep, CancellationToken cancellationToken)
        {
            var trace = _mapper.Map<WorkflowTrace>(currentStep);//todo ignore parentId, map stepId
            trace.Status = EWorkflowTraceStatus.Normal;
            trace.ExpiredTime = workflow.ExpiredTime;

            if (!string.IsNullOrEmpty(currentStep.PreviousId) && currentStepBox.Steps.Count > 1)
            {
                //有会签
                var parentTrace = await GetWorkflowTraceAsync(workflow.Id, currentStep.PreviousId, cancellationToken);
                trace.ParentId = parentTrace.Id;
            }

            await _workflowTraceRepository.AddAsync(trace, cancellationToken);
        }

        private async Task<WorkflowTrace> GetWorkflowTraceAsync(string workflowId, string stepId, CancellationToken cancellationToken)
        {
            var parentTrace = await _workflowTraceRepository.GetAsync(d =>
                d.WorkflowId == workflowId && d.StepId == stepId, cancellationToken);
            if (parentTrace == null)
                throw new UserFriendlyException($"未找到对应trace, workflowId: {workflowId}, stepId: {stepId}");
            return parentTrace;
        }

        private async Task RecallAsync(Workflow workflow, RecallDto dto, WorkflowStep targetStepBox, CancellationToken cancellationToken)
        {
            //update uncompleted traces
            await RecallTraceAsync(workflow.Id, dto, cancellationToken);

            //remove completedSteps include target self
            var completeStepBoxes = workflow.StepBoxes.Where(d =>
                d.Code == dto.TargetStepCode || d.CreationTime > targetStepBox.CreationTime);
            var removeSteps = new List<WorkflowStep>();
            foreach (var stepBox in completeStepBoxes)
            {
                removeSteps.Add(stepBox);
                removeSteps.AddRange(stepBox.Steps);
            }

            await _workflowStepRepository.RemoveRangeAsync(removeSteps, cancellationToken);

            //recreate targetStep
            var nextStepBoxDefine = GetStepBoxDefine(workflow.Definition, dto.NextStepCode);
            await CreateStepAsync(workflow, nextStepBoxDefine, dto, targetStepBox, targetStepBox.Steps.First(), cancellationToken);

            //flow manage
            if (workflow.IsInCountersign())
            {
                var currentCountersignStepBox =
                    workflow.StepBoxes.First(d => d.Code == workflow.CurrentCountersignStepCode);
                //目标节点在初始会签节点之前或正好
                if (targetStepBox.Code == workflow.CurrentCountersignStepCode || targetStepBox.CreationTime < currentCountersignStepBox.CreationTime)
                    await ResetWorkflowCurrentStepInfo(workflow, dto, targetStepBox, cancellationToken);

            }
        }

        private static void CheckWhetherRunnable(EWorkflowStatus status)
        {
            if (status is not EWorkflowStatus.Runnable)
                throw new UserFriendlyException("当前流程状态不可继续流转");
        }

        private async Task<WorkflowStep> CreateStepAsync(Workflow workflow, StepDefine stepBoxDefine, BasicWorkflowDto dto,
            WorkflowStep? prevStepBox = null, WorkflowStep? prevStep = null, CancellationToken cancellationToken = default)
        {
            if (stepBoxDefine.StepType is EStepType.Start or EStepType.End)
                throw new UserFriendlyException("开始和结束节点无法创建子节点");
            var stepBox = workflow.StepBoxes.FirstOrDefault(d => d.Code == stepBoxDefine.Code);
            if (stepBox == null)
            {
                stepBox = CreateStepBox(stepBoxDefine, dto, prevStepBox?.Id ?? string.Empty);
                await _workflowStepRepository.AddAsync(stepBox, cancellationToken);
            }

            if (stepBoxDefine.StepType is EStepType.CountersignEnd)
            {
                if (prevStep is null)
                    throw new UserFriendlyException($"汇总节点的上级节点不能为空节点，workflowId: {workflow.Id}", "创建汇总节点异常");

                var countersignId = string.IsNullOrEmpty(prevStep.TopCountersignId)
                    ? prevStep.PrevCountersignId
                    : prevStep.TopCountersignId;

                var step = stepBox.Steps.FirstOrDefault(d => d.PrevCountersignId == countersignId);
                if (step != null) return stepBox;

                var countersignStartStep = FindCountersignStartStep(workflow, stepBoxDefine.CountersignStartCode, countersignId);
                string? topCountersignId = countersignStartStep.StepType is EStepType.CountersignEnd
                    ? countersignStartStep.TopCountersignId
                    : countersignStartStep.IsInCountersign
                        ? countersignStartStep.PrevCountersignId
                        : null;

                await CreateSubStepsAsync(stepBoxDefine, dto, stepBox, prevStep.Id, EWorkflowStepStatus.Created,
                    countersignId, topCountersignId, cancellationToken);
            }
            else
            {
                if (prevStep is null)
                {
                    //创建流程或特殊处理场景
                    await CreateSubStepsAsync(stepBoxDefine, dto, stepBox, string.Empty, EWorkflowStepStatus.Assigned,
                        null, null, cancellationToken);
                }
                else
                {
                    var prevCountersignId = prevStep.HasStartCountersign
                        ? prevStep.StartCountersignId
                        : prevStep.PrevCountersignId;

                    await CreateSubStepsAsync(stepBoxDefine, dto, stepBox, prevStep.Id, EWorkflowStepStatus.Assigned,
                        prevCountersignId, null, cancellationToken);
                }
            }

            return stepBox;
        }

        private async Task CreateSubStepsAsync(
            StepDefine stepBoxDefine,
            BasicWorkflowDto dto,
            WorkflowStep stepBox,
            string prevStepId,
            EWorkflowStepStatus stepStatus,
            string? prevCountersignId = null,
            string? topCountersignId = null,
            CancellationToken cancellationToken = default)
        {
            if (stepBoxDefine.HandlerType is EHandlerType.AssignUser or EHandlerType.AssignOrg)
            {
                var subSteps = CreateSubSteps(stepBox, stepBox.HandlerClassifies, dto.NextMainHandler,
                    prevStepId, prevCountersignId, topCountersignId, stepStatus);
                stepBox.Steps.AddRange(subSteps);
                await _workflowStepRepository.AddRangeAsync(subSteps, cancellationToken);
            }
            else
            {
                if (!dto.Handlers.Any())
                    throw new UserFriendlyException("未指定节点处理者");
                var subSteps = CreateSubSteps(stepBox, dto.Handlers, dto.NextMainHandler,
                    prevStepId, prevCountersignId, topCountersignId, stepStatus);
                stepBox.Steps.AddRange(subSteps);
                await _workflowStepRepository.AddRangeAsync(subSteps, cancellationToken);
            }
        }

        private (WorkflowStep stepBox, WorkflowStep step) GetStep(List<WorkflowStep> stepBoxes, string stepId)
        {
            foreach (var stepBox in stepBoxes)
            {
                foreach (var step in stepBox.Steps)
                {
                    if (step.Id == stepId)
                        return (stepBox, step);
                }
            }

            throw new UserFriendlyException("未找到对应节点");
        }

        /// <summary>
        /// 查询未完成节点
        /// </summary>
        /// <param name="stepBoxes"></param>
        /// <param name="orgCode"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        private (WorkflowStep, WorkflowStep) GetUnCompleteStep(List<WorkflowStep> stepBoxes, string orgCode, string userId)
        {
            var (stepBox, step) = GetStep(stepBoxes, orgCode, userId, d => d != EWorkflowStepStatus.Completed);
            if (step == null)
                throw new UserFriendlyException("未找到对应节点");
            return (stepBox, step);
        }

        private (WorkflowStep, WorkflowStep) GetUnCompleteStepOrDefault(List<WorkflowStep> stepBoxes, string orgCode, string userId) =>
            GetStep(stepBoxes, orgCode, userId, d => d != EWorkflowStepStatus.Completed);

        private (WorkflowStep, WorkflowStep) GetStep(List<WorkflowStep> stepBoxes, string orgCode, string userId, Func<EWorkflowStepStatus, bool> predicate)
        {
            if (!stepBoxes.Any()) throw new UserFriendlyException("该流程中暂无节点");
            foreach (var stepBox in stepBoxes)
            {
                foreach (var step in stepBox.Steps)
                {
                    if (predicate(step.Status) && (step.HandlerId == orgCode || step.HandlerId == userId))
                        return (stepBox, step);
                }
            }

            return new();
        }

        private WorkflowStep CreateStepBox(StepDefine stepBasic, BasicWorkflowDto dto, string prevStepBoxId)
        {
            var stepBox = _mapper.Map<WorkflowStep>(stepBasic);
            _mapper.Map(dto, stepBox);
            stepBox.PreviousId = prevStepBoxId;
            return stepBox;
        }

        private List<WorkflowStep> CreateSubSteps(
            WorkflowStep stepBox,
            List<string> nextHandlers,
            string nextMainHandler,
            string prevStepId,
            string? prevCountersignId,
            string? topCountersignId,
            EWorkflowStepStatus stepStatus)
        {
            return nextHandlers.Select(d =>
              {
                  var step = _mapper.Map<WorkflowStep>(stepBox);
                  step.ParentId = stepBox.Id;
                  step.HandlerId = d;
                  step.IsMain = d == nextMainHandler;
                  step.PreviousId = prevStepId;
                  step.PrevCountersignId = prevCountersignId;
                  step.TopCountersignId = topCountersignId;
                  step.Status = stepStatus;
                  return step;
              }).ToList();
        }

        /// <summary>
        /// 依据配置生成过期时间
        /// </summary>
        /// <returns></returns>
        private DateTime GenerateExpiredTime(string defineCode)
        {
            return DateTime.Now.AddDays(7); //todo 依据配置生成, Think about 工作日
        }

        #endregion

    }
}