hotline/src/Hotline.Application/FlowEngine/WorkflowApplication.cs

using Hotline.FlowEngine;
using Hotline.FlowEngine.Definitions;
using Hotline.FlowEngine.Workflows;
using Hotline.Identity.Accounts;
using Hotline.Identity.Roles;
using Hotline.Orders;
using Hotline.SeedData;
using Hotline.Settings;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Share.Enums.Identity;
using Hotline.Users;
using SqlSugar;
using XF.Domain.Authentications;
using XF.Domain.Dependency;
using XF.Domain.Entities;
using XF.Domain.Exceptions;

namespace Hotline.Application.FlowEngine;

public class WorkflowApplication : IWorkflowApplication, IScopeDependency
{
    private readonly IDefinitionDomainService _definitionDomainService;
    private readonly IWorkflowDomainService _workflowDomainService;
    private readonly IOrderDomainService _orderDomainService;
    private readonly IWorkflowRepository _workflowRepository;
    private readonly IWorkflowAssignRepository _workflowAssignRepository;
    private readonly IUserRepository _userRepository;
    private readonly IAccountRepository _accountRepository;
    private readonly ISystemOrganizeRepository _organizeRepository;
    private readonly IRoleRepository _roleRepository;
    private readonly IUserDomainService _userDomainService;
    private readonly IAccountDomainService _accountDomainService;
    private readonly ISessionContext _sessionContext;

    public WorkflowApplication(
        IDefinitionDomainService definitionDomainService,
        IWorkflowDomainService workflowDomainService,
        IOrderDomainService orderDomainService,
        IWorkflowRepository workflowRepository,
        IWorkflowAssignRepository workflowAssignRepository,
        IUserRepository userRepository,
        IAccountRepository accountRepository,
        ISystemOrganizeRepository organizeRepository,
        IRoleRepository roleRepository,
        ISessionContext sessionContext)
    {
        _definitionDomainService = definitionDomainService;
        _workflowDomainService = workflowDomainService;
        _orderDomainService = orderDomainService;
        _workflowRepository = workflowRepository;
        _workflowAssignRepository = workflowAssignRepository;
        _userRepository = userRepository;
        _accountRepository = accountRepository;
        _organizeRepository = organizeRepository;
        _roleRepository = roleRepository;
        _sessionContext = sessionContext;
    }

    public async Task StartWorkflowAsync(StartWorkflowDto dto, string? externalId = null, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrEmpty(dto.DefinitionCode) && string.IsNullOrEmpty(dto.DefinitionModuleCode))
            throw new UserFriendlyException("非法参数");

        var definition = string.IsNullOrEmpty(dto.DefinitionCode)
            ? await _definitionDomainService.GetLastVersionByModuleCodeAsync(dto.DefinitionModuleCode, cancellationToken)
            : await _definitionDomainService.GetLastVersionAsync(dto.DefinitionCode, cancellationToken);
        if (definition == null)
            throw new UserFriendlyException("无效模板名称");
        if (definition.Status is EDefinitionStatus.Temporary or EDefinitionStatus.Disable)
            throw new UserFriendlyException("该模板不可用");

        var nextStepBoxDefine = _workflowDomainService.GetStepBoxDefine(definition, dto.NextStepCode);
        var workflow = await _workflowDomainService.CreateWorkflowAsync(definition, dto.Title,
            _sessionContext.RequiredUserId, _sessionContext.RequiredOrgCode, externalId, cancellationToken);

        var isStartCountersign = nextStepBoxDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);

        var flowAssignMode = await GetFlowAssignModeAsync(nextStepBoxDefine, isStartCountersign, dto.NextHandlers, cancellationToken);

        await _workflowDomainService.StartAsync(workflow, dto, nextStepBoxDefine, isStartCountersign, flowAssignMode, cancellationToken);

        //更新接办部门(详情页面展示)
        await AddOrUpdateAssignAsync(workflow, dto, nextStepBoxDefine, cancellationToken);
    }

    /// <summary>
    /// 流转至下一节点（节点办理）
    /// </summary>
    /// <param name="dto"></param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    public async Task NextAsync(NextWorkflowDto dto, CancellationToken cancellationToken)
    {
        var workflow = await _workflowDomainService.GetWorkflowAsync(dto.WorkflowId, true, true, withCountersigns: true, cancellationToken: cancellationToken);
        var nextStepBoxDefine = _workflowDomainService.GetStepBoxDefine(workflow.Definition, dto.NextStepCode);

        //需求：按角色选择办理人可以不选，表示该角色下所有人都可以办理，同时依据配置：是否本部门人办理显示待选办理人。角色下只要一人办理即可（即:角色下不发起会签）
        if (nextStepBoxDefine.HandlerType != EHandlerType.Role && !dto.NextHandlers.Any())
            throw new UserFriendlyException("未指定节点处理者");

        //下一节点为结束节点时，无办理人等参数，只有办理意见即可
        var isFromCenterToOrg = nextStepBoxDefine.StepType is not EStepType.End
                                && await CheckIfFlowOutFromCallCenterAsync(nextStepBoxDefine, dto.NextMainHandler, cancellationToken);
        if (isFromCenterToOrg)
            await _orderDomainService.FlowFromCenterToOrgAsync(workflow.Id, cancellationToken);

        var isStartCountersign = nextStepBoxDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);

        var flowAssignMode = await GetFlowAssignModeAsync(nextStepBoxDefine, isStartCountersign, dto.NextHandlers, cancellationToken);

        await _workflowDomainService.NextAsync(workflow, dto, nextStepBoxDefine, isFromCenterToOrg, isStartCountersign, flowAssignMode, cancellationToken);

        //更新接办部门(详情页面展示)
        await AddOrUpdateAssignAsync(workflow, dto, nextStepBoxDefine, cancellationToken);
    }

    /// <summary>
    /// 撤回至任意节点
    /// </summary>
    public async Task RecallAsync(NextWorkflowDto dto, CancellationToken cancellationToken)
    {
        var workflow = await _workflowDomainService.GetWorkflowAsync(dto.WorkflowId, true, true, cancellationToken: cancellationToken);
        var targetStepDefine = _workflowDomainService.GetStepBoxDefine(workflow.Definition, dto.NextStepCode);
        var isStartCountersign = targetStepDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);
        var flowAssignMode = await GetFlowAssignModeAsync(targetStepDefine, isStartCountersign, dto.NextHandlers, cancellationToken);
        await _workflowDomainService.RecallAsync(workflow, dto, targetStepDefine, isStartCountersign, flowAssignMode, cancellationToken);
    }

    /// <summary>
    /// 跳转至任意节点
    /// </summary>
    public async Task JumpAsync(NextWorkflowDto dto, CancellationToken cancellationToken)
    {
        var workflow = await _workflowDomainService.GetWorkflowAsync(dto.WorkflowId, true, true, cancellationToken: cancellationToken);
        var targetStepDefine = _workflowDomainService.GetStepBoxDefine(workflow.Definition, dto.NextStepCode);
        var isStartCountersign = targetStepDefine.CouldPrevStartCountersign(dto.NextHandlers.Count);
        var flowAssignMode = await GetFlowAssignModeAsync(targetStepDefine, isStartCountersign, dto.NextHandlers, cancellationToken);
        await _workflowDomainService.JumpAsync(workflow, dto, targetStepDefine, isStartCountersign, flowAssignMode, cancellationToken);
    }

    public async Task<DefineWithSelectionStepsDto> GetStartOptionsAsync(string moduleCode, CancellationToken cancellationToken)
    {
        var definition =
            await _definitionDomainService.GetLastVersionByModuleCodeAsync(moduleCode, cancellationToken);
        if (definition == null)
            throw new UserFriendlyException($"无效模块编码, modeuleCode: {moduleCode}", "无效模块编码");
        if (definition.Status is EDefinitionStatus.Temporary or EDefinitionStatus.Disable)
            throw new UserFriendlyException("该模板不可用");

        var startStep = definition.Steps.FirstOrDefault(d => d.StepType == EStepType.Start);
        if (startStep == null)
            throw new UserFriendlyException("未正确配置开始节点");
        var nextStepDefines = definition.FindSteps(startStep.NextSteps.Select(d => d.Code));

        return new DefineWithSelectionStepsDto
        {
            Id = definition.Id,
            Steps = nextStepDefines.Select(d => new KeyValuePair<string, string>(d.Code, d.Name)).ToList()
        };
    }

    /// <summary>
    /// 根据节点配置查询待选参数
    /// </summary>
    /// <param name="stepDefine"></param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentOutOfRangeException"></exception>
    public async Task<IReadOnlyList<KeyValuePair<string, string>>> GetNextStepOptionsAsync(StepDefine stepDefine, CancellationToken cancellationToken)
    {
        if (stepDefine.StepType == EStepType.End) return new List<KeyValuePair<string, string>>();

        switch (stepDefine.HandlerType)
        {
            case EHandlerType.AssignUser:
                var users = await _userRepository.QueryAsync(d =>
                    !d.IsDeleted &&
                    stepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.Id));
                return users.Select(d => new KeyValuePair<string, string>(d.Id, d.Name)).ToList();
            case EHandlerType.AssignOrg:
                var orgs = await _organizeRepository.QueryAsync(d =>
                    d.IsEnable &&
                    stepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.OrgCode));
                return orgs.Select(d => new KeyValuePair<string, string>(d.OrgCode, d.OrgName))
                    .ToList();
            case EHandlerType.Role:
                var roles = await _roleRepository.Queryable()
                    .Includes(d => d.Accounts.Where(x => !x.IsDeleted && x.Status == EAccountStatus.Normal).ToList(), x => x.User)
                    .Where(d => stepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.Name))
                    .ToListAsync();
                var users1 = roles.SelectMany(d => d.Accounts).Select(d => d.User);
                if (stepDefine.OnlySelfOrg ?? false)
                    users1 = users1.Where(d => d.OrgCode == _sessionContext.RequiredOrgCode);
                return users1.Select(d => new KeyValuePair<string, string>(d.Id, d.Name)).ToList();
            case EHandlerType.OrgLevel:
                //当前操作人所属部门的下级部门并且属于配置orgLevel的部门
                var levels = stepDefine.HandlerClassifies.Select(d => d.Id).Select(d => int.Parse(d));
                var orgs1 = await _organizeRepository.QueryAsync(d =>
                    d.IsEnable && d.OrgCode.StartsWith(_sessionContext.RequiredOrgCode) &&
                    levels.Contains(d.OrgLevel));
                return orgs1.Select(d => new KeyValuePair<string, string>(d.OrgCode, d.OrgName))
                    .ToList();
            case EHandlerType.OrgType:
                var types = stepDefine.HandlerClassifies.Select(d => d.Id)
                    .Select(d => Enum.Parse<EOrgType>(d));
                var org2 = await _organizeRepository.QueryAsync(d =>
                    d.IsEnable && d.OrgCode.StartsWith(_sessionContext.RequiredOrgCode) &&
                    types.Contains(d.OrgType));
                return org2.Select(d => new KeyValuePair<string, string>(d.OrgCode, d.OrgName))
                    .ToList();

            default:
                throw new ArgumentOutOfRangeException();
        }
    }


    /// <summary>
    /// 查询指派办理人的处理方式及实际办理人
    /// </summary>
    public async Task<FlowAssignMode> GetFlowAssignModeAsync(StepDefine stepDefine, bool isStartCountersign, List<IdName> handlers, CancellationToken cancellationToken)
    {
        if (stepDefine.StepType is EStepType.Start or EStepType.End) return new();
        switch (stepDefine.HandlerType)
        {
            case EHandlerType.Role:
                if (!handlers.Any())
                {
                    var roles = await _roleRepository.Queryable()
                        .Includes(d => d.Accounts, x => x.User)
                        .Where(d => stepDefine.HandlerClassifies.Select(d => d.Id).Contains(d.Name))
                        .ToListAsync();
                    handlers = roles.SelectMany(d => d.Accounts).Distinct().Select(d => new IdName(d.Id, d.User.Name)).ToList();
                }

                return FlowAssignMode.Create(EFlowAssignType.User, handlers, isStartCountersign);

            case EHandlerType.OrgLevel:
            case EHandlerType.OrgType:
            case EHandlerType.AssignOrg:
                return FlowAssignMode.Create(EFlowAssignType.Org, handlers, isStartCountersign);

            case EHandlerType.AssignUser:
                return FlowAssignMode.Create(EFlowAssignType.User, handlers, isStartCountersign);

            default:
                throw new ArgumentOutOfRangeException();
        }
    }


    #region private

    /// <summary>
    /// 更新接办部门
    /// </summary>
    private async Task AddOrUpdateAssignAsync(Workflow workflow, BasicWorkflowDto dto, StepDefine nextStepBoxDefine, CancellationToken cancellationToken)
    {
        if (nextStepBoxDefine.StepType is EStepType.Normal)
        {
            await _workflowAssignRepository.RemoveAsync(d =>
                    d.WorkflowId == workflow.Id && d.OrgCode == _sessionContext.RequiredOrgCode,
                cancellationToken: cancellationToken);

            var assigns = new List<WorkflowAssign>();
            switch (nextStepBoxDefine.HandlerType)
            {
                case EHandlerType.Role:
                    if (dto.NextHandlers.Any())
                    {
                        //选了handler，handler为userId 
                        var users1 = await _userRepository.Queryable()
                            .Includes(d => d.Organization)
                            .Where(d => dto.NextHandlers.Select(x => x.Id).Contains(d.Id))
                            .ToListAsync();
                        assigns = users1.Select(d => WorkflowAssign.Create(workflow.Id, d.OrgCode, d.Organization.OrgName))
                            .ToList();
                    }
                    else
                    {
                        //如果模板配置为本部门办理，则为当前办理人orgCode，非本部门办理:属于该角色的所有用户所属部门
                        if (nextStepBoxDefine.OnlySelfOrg.HasValue && nextStepBoxDefine.OnlySelfOrg.Value)
                        {
                            assigns = new List<WorkflowAssign>
                            {
                                WorkflowAssign.Create(workflow.Id, _sessionContext.RequiredOrgCode, _sessionContext.OrgName)
                            };
                        }
                        else
                        {
                            var accounts = await _accountRepository.Queryable()
                                .Includes(d => d.User, d => d.Organization)
                                .Where(d => dto.NextHandlers.Select(d => d.Id).Contains(d.Name))
                                .ToListAsync();
                            assigns = accounts.Select(d => d.User.Organization).Select(d =>
                                WorkflowAssign.Create(workflow.Id, d.OrgCode, d.OrgName)).ToList();
                        }
                    }

                    break;

                case EHandlerType.OrgLevel:
                case EHandlerType.OrgType:
                case EHandlerType.AssignOrg:
                    assigns = dto.NextHandlers.Select(d => WorkflowAssign.Create(workflow.Id, d.Id, d.Name)).ToList();
                    break;

                case EHandlerType.AssignUser:
                    //指定人所属部门
                    var users = await _userRepository.Queryable()
                        .Includes(d => d.Organization)
                        .Where(d => dto.NextHandlers.Select(d => d.Id).Contains(d.Id))
                        .ToListAsync();
                    assigns = users.Select(d => WorkflowAssign.Create(workflow.Id, d.OrgCode, d.Organization.OrgName))
                        .ToList();
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }

            if (assigns.Any())
                await _workflowAssignRepository.AddRangeAsync(assigns, cancellationToken);
        }
    }

    private async Task<bool> CheckIfFlowOutFromCallCenterAsync(StepDefine nextStepBoxDefine, string mainHandler, CancellationToken CancellationToken)
    {
        //current is center & next is not center return true
        var isFromCallCenter = IsOrgFromCallCenter(_sessionContext.RequiredOrgCode);
        if (!isFromCallCenter) return false;

        var isOutCallCenter = await CheckNextStepHandlerIsOutCallCenterAsync(nextStepBoxDefine, mainHandler, CancellationToken);
        return isFromCallCenter && isOutCallCenter;
    }

    private async Task<bool> CheckNextStepHandlerIsOutCallCenterAsync(StepDefine nextStepBoxDefine, string mainHandler, CancellationToken cancellationToken)
    {
        if (nextStepBoxDefine.HandlerType is EHandlerType.AssignUser or EHandlerType.Role)
        {
            //mainHandler is userId
            var handler = await _userRepository.GetAsync(mainHandler, cancellationToken);
            if (handler == null)
                throw new UserFriendlyException($"mainHandler未找到对应User, handler: {mainHandler}");
            if (string.IsNullOrEmpty(handler.OrgCode))
                throw UserFriendlyException.SameMessage($"该用户未配置所属部门, userId: {mainHandler}");
            return !IsOrgFromCallCenter(handler.OrgCode);
        }
        else
        {
            //mainHandler is orgCode
            return !IsOrgFromCallCenter(mainHandler);
        }
    }

    /// <summary>
    /// 是否为呼叫中心
    /// </summary>
    /// <returns></returns>
    private bool IsOrgFromCallCenter(string orgCode) =>
        string.CompareOrdinal(orgCode, OrgSeedData.CallCenterCode) == 0;



    #endregion
}