hotline/src/Hotline.Api/Controllers/WorkflowController.cs

using Hotline.Application.FlowEngine;
using Hotline.FlowEngine.Definitions;
using Hotline.FlowEngine.Workflows;
using Hotline.Identity.Roles;
using Hotline.Permissions;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Settings;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Users;
using MapsterMapper;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Hotline.FlowEngine.WorkflowModules;
using Microsoft.AspNetCore.Authorization;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;
using XF.Domain.Extensions;
using XF.Utility.EnumExtensions;
using XF.Domain.Repository;
using Hotline.Share.Dtos.FlowEngine.Workflow;

namespace Hotline.Api.Controllers;

/// <summary>
/// 工作流管理
/// </summary>
public class WorkflowController : BaseController
{
    private readonly IDefinitionDomainService _definitionDomainService;
    private readonly IRepository<WorkflowDefinition> _definitionRepository;
    private readonly IWorkflowApplication _workflowApplication;
    private readonly IWorkflowDomainService _workflowDomainService;
    private readonly IWorkflowRepository _workflowRepository;
    private readonly IRepository<User> _userRepository;
    private readonly ISystemOrganizeRepository _organizeRepository;
    private readonly IRepository<Role> _roleRepository;
    private readonly ISystemDomainService _systemDomainService;
    private readonly IWfModuleDomainService _wfModuleDomainService;
    private readonly IRepository<WorkflowModule> _wfModuleRepository;
    private readonly ISessionContext _sessionContext;
    private IRepository<WorkflowTrace> _workflowTraceRepository;
    private readonly IMapper _mapper;

    public WorkflowController(
        IDefinitionDomainService definitionDomainService,
        IRepository<WorkflowDefinition> definitionRepository,
        IWorkflowApplication workflowApplication,
        IWorkflowDomainService workflowDomainService,
        IWorkflowRepository workflowRepository,
        IRepository<User> userRepository,
        ISystemOrganizeRepository organizeRepository,
        IRepository<Role> roleRepository,
        ISystemDomainService systemDomainService,
        IWfModuleDomainService wfModuleDomainService,
        IRepository<WorkflowModule> wfModuleRepository,
        ISessionContext sessionContext,
        IRepository<WorkflowTrace> workflowTraceRepository,
        IMapper mapper
        )
    {
        _definitionDomainService = definitionDomainService;
        _definitionRepository = definitionRepository;
        _workflowApplication = workflowApplication;
        _workflowDomainService = workflowDomainService;
        _workflowRepository = workflowRepository;
        _userRepository = userRepository;
        _organizeRepository = organizeRepository;
        _roleRepository = roleRepository;
        _systemDomainService = systemDomainService;
        _wfModuleDomainService = wfModuleDomainService;
        _wfModuleRepository = wfModuleRepository;
        _sessionContext = sessionContext;
        _mapper = mapper;
        _workflowTraceRepository = workflowTraceRepository;
    }

    /// <summary>
    /// 分页查询最新版本号的模板
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("definition/latest")]
    public async Task<PagedDto<DefinitionDto>> QueryDefinitionLatest([FromQuery] QueryDefinitionDto dto)
    {
        var query2 = await _definitionRepository.Queryable()
            .WhereIF(dto.Status.HasValue, d => d.Status == dto.Status)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.Code.Contains(dto.Keyword) || d.Name.Contains(dto.Keyword))
            .Select(d => new { i = SqlFunc.RowNumber($"{d.Version} desc", d.Code), d })
            .MergeTable()
            .Where(d => d.i == 1)
            .ToListAsync();

        var items = query2.Select(d => d.d).ToList();

        return new PagedDto<DefinitionDto>(query2.Count, _mapper.Map<IReadOnlyList<DefinitionDto>>(items));
    }

    /// <summary>
    /// 分页查询流程模板
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowDefinitionQuery)]
    [HttpGet("definition")]
    public async Task<PagedDto<DefinitionDto>> QueryDefinitions([FromQuery] QueryDefinitionDto dto)
    {
        #region old version:只查询草稿、禁用以及已启用模板的最新版本

        ////todo 数据量大需重构
        //var query1 = await _definitionRepository.Queryable()
        //    .Where(d => d.Status == EDefinitionStatus.Temporary)
        //    .ToListAsync();
        //var query2 = await _definitionRepository.Queryable()
        //    .Where(d => d.Status != EDefinitionStatus.Temporary)
        //    .Select(d => new { i = SqlFunc.RowNumber($"{d.Version} desc", d.Code), d })
        //    .MergeTable()
        //    .Where(d => d.i == 1)
        //    .ToListAsync();

        //var query = query1.Union(query2.Select(d => d.d));
        //var total = query.Count();
        //var items = query
        //    .OrderBy(d => d.Status)
        //    .ThenByDescending(d => d.CreationTime)
        //    .Skip(dto.Skip())
        //    .Take(dto.PageSize)
        //    .ToList();

        #endregion

        var (total, items) = await _definitionRepository.Queryable()
            .WhereIF(dto.Status.HasValue, d => d.Status == dto.Status)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.Code.Contains(dto.Keyword!) || d.Name.Contains(dto.Keyword!))
            .OrderBy(d => d.Status)
            .OrderBy(d => d.Code)
            .OrderByDescending(d => d.Version)
            .ToPagedListAsync(dto, HttpContext.RequestAborted);

        return new PagedDto<DefinitionDto>(total, _mapper.Map<IReadOnlyList<DefinitionDto>>(items));
    }

    /// <summary>
    /// 查询流程模板
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.GetFlow)]
    [HttpGet("definition/{id}")]
    public async Task<DefinitionDto> GetDefinition(string id)
    {
        var definition = await _definitionRepository.GetAsync(id, HttpContext.RequestAborted);
        if (definition == null) return new();
        return _mapper.Map<DefinitionDto>(definition);
    }

    /// <summary>
    /// 新增流程模板草稿
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowDefinitionAdd)]
    [HttpPost("definition")]
    public async Task<string> AddDefinition([FromBody] AddDefinitionDto dto)
    {
        return await _definitionDomainService.AddAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 更新流程模板草稿
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowDefinitionUpdate)]
    [HttpPut("definition")]
    public async Task UpdateDefinition([FromBody] UpdateDefinitionDto dto)
    {
        var definition = await _definitionRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (definition == null)
            throw UserFriendlyException.SameMessage("无效模板编号");
        if (definition.Status == EDefinitionStatus.Temporary)
        {
            _mapper.Map(dto, definition);
            await _definitionRepository.UpdateAsync(definition, HttpContext.RequestAborted);
        }
        else
        {
            var newDefinition = _mapper.Map<WorkflowDefinition>(dto);
            await _definitionRepository.AddAsync(newDefinition, HttpContext.RequestAborted);
        }
    }

    /// <summary>
    /// 删除草稿
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    [Permission(EPermission.FlowDefinitionRemove)]
    [HttpDelete("definition/{id}")]
    public async Task RemoveDefinition(string id)
    {
        var definition = await _definitionRepository.GetAsync(id, HttpContext.RequestAborted);
        if (definition == null) return;
        if (definition.Status != EDefinitionStatus.Temporary)
            throw new UserFriendlyException("已发布模板不能删除");
        await _definitionRepository.RemoveAsync(id, false, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 发布（列表操作）
    /// </summary>
    /// <returns></returns>
    [Permission(EPermission.FlowDefinitionPublish)]
    [HttpPost("definition/{id}/publish")]
    public async Task Publish(string id)
    {
        await _definitionDomainService.PublishAsync(id, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 发布（保存并发布）
    /// </summary>
    /// <returns></returns>
    [Obsolete]
    [Permission(EPermission.FlowDefinitionPublish)]
    [HttpPost("definition/publish")]
    public async Task Publish([FromBody] AddDefinitionDto dto)
    {
        await _definitionDomainService.PublishAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 分页查询流程
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowQuery)]
    [HttpGet]
    public async Task<PagedDto<WorkflowDto>> QueryPaged([FromQuery] QueryWorkflowPagedDto dto)
    {
        var (total, items) = await _workflowRepository.Queryable()
            .WhereIF(!string.IsNullOrEmpty(dto.ModuleCode), d => d.ModuleCode == dto.ModuleCode)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.Id.Contains(dto.Keyword!) || d.Title.Contains(dto.Keyword!))
            .OrderByDescending(d => d.CreationTime)
            .ToPagedListAsync(dto, HttpContext.RequestAborted);

        return new PagedDto<WorkflowDto>(total, _mapper.Map<IReadOnlyList<WorkflowDto>>(items));
    }

    /// <summary>
    /// 查询流程办理下一步可选节点
    /// </summary>
    [HttpGet("{workflowId}/nextsteps")]
    public async Task<NextStepsDto> GetNextStepDefine(string workflowId)
    {
        //var workflow = await _workflowDomainService.GetWorkflowAsync(workflowId, true, true,
        //    cancellationToken: HttpContext.RequestAborted);
        //var current = _workflowDomainService.FindCurrentStep(workflow);
        //var nextStepDefines = workflow.WorkflowDefinition.FindStepDefines(current.StepBox.NextSteps.Select(d => d.Code));

        //if (current.StepBox.PathPolicy is not EPathPolicy.None && current.StepBox.NextSteps.Count > 1)
        //    _workflowDomainService.NextStepDefineFilter(current.StepBox.PathPolicy, nextStepDefines);

        //return new DefinedStepDto
        //{
        //    DefinitionId = workflow.DefinitionId,
        //    Steps = _mapper.Map<IReadOnlyList<StepBasicDto>>(nextStepDefines),//nextStepDefines.Select(d => new KeyValuePair<string, string>(d.Code, d.Name)).ToList(),
        //    ExpiredTime = workflow.ExpiredTime,
        //    Components = current.StepBox.Components,
        //};

        return await _workflowApplication.GetNextStepsAsync(workflowId, HttpContext.RequestAborted);
    }

    ///// <summary>
    ///// 查询流程下一节点待选配置
    ///// </summary>
    //[HttpGet("step-options")]
    //public async Task<NextStepOptionDto> GetNextStepOptions([FromQuery] QueryNextStepOptionDto dto)
    //{
    //    var definition = await _definitionRepository.GetAsync(dto.DefineId, HttpContext.RequestAborted);
    //    if (definition == null)
    //        throw new UserFriendlyException("无效DefineId");

    //    var defineStep = definition.FindStepDefine(dto.Code);
    //    if (defineStep is null)
    //        throw UserFriendlyException.SameMessage("未查询到对应节点配置");
    //    return await _workflowApplication.GetNextStepOptionsAsync(defineStep, HttpContext.RequestAborted);
    //}

    /// <summary>
    /// 办理节点
    /// </summary>
    [Permission(EPermission.FlowNext)]
    [HttpPost("next")]
    public async Task Next([FromBody] NextWorkflowDto dto)
    {
        await _workflowApplication.NextAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 退回（返回前一节点）
    /// </summary>
    [Permission(EPermission.FlowPrevious)]
    [HttpPost("previous")]
    public async Task Previous([FromBody] PreviousWorkflowDto dto)
    {
        var workflow = await _workflowDomainService.GetWorkflowAsync(dto.WorkflowId, withSteps: true,
            cancellationToken: HttpContext.RequestAborted);
        await _workflowDomainService.PreviousAsync(workflow, dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 获取撤回可选节点
    /// </summary>
    /// <param name="workflowId"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowRecall)]
    [HttpGet("{workflowId}/recall")]
    public async Task<NextStepsDto> GetRecallSteps(string workflowId)
    {
        return await _workflowApplication.GetRecallStepsAsync(workflowId, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 撤回至任意节点
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowRecall)]
    [HttpPost("recall")]
    public async Task Recall([FromBody] RecallDto dto)
    {
        await _workflowApplication.RecallAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 获取跳转可选节点
    /// </summary>
    /// <param name="workflowId"></param>
    /// <returns></returns>
    [HttpGet("{workflowId}/jump")]
    public async Task<NextStepsDto> GetJumpSteps(string workflowId)
    {
        return await _workflowApplication.GetJumpStepsAsync(workflowId, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 跳转至任意节点
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowJump)]
    [HttpPost("jump")]
    public async Task Jump([FromBody] RecallDto dto)
    {
        await _workflowApplication.JumpAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 获取重办可选节点
    /// </summary>
    /// <param name="workflowId"></param>
    /// <returns></returns>
    [HttpGet("{workflowId}/redo")]
    public async Task<NextStepsDto> GetRedoSteps(string workflowId)
    {
        return await _workflowApplication.GetRedoStepsAsync(workflowId, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 终止流程
    /// </summary>
    [Permission(EPermission.FlowTerminate)]
    [HttpPost("terminate")]
    public async Task Terminate([FromBody] TerminateDto dto)
    {
        await _workflowDomainService.TerminateAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 撤销流程
    /// </summary>
    [HttpPost("cancel")]
    public async Task Cancel([FromBody] CancelDto dto)
    {
        await _workflowDomainService.CancelAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 补充
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.FlowSupplement)]
    [HttpPost("supplement")]
    public async Task Supplement([FromBody] SupplementDto dto)
    {
        var workflow = await _workflowDomainService.GetWorkflowAsync(dto.WorkflowId);
        await _workflowDomainService.SupplementAsync(workflow, dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 查询办理类型参数
    /// </summary>
    [HttpGet("handlerclassify/{handlerType}")]
    public async Task<List<KeyValuePair<string, string>>> GetHandlerClassifies(EHandlerType handlerType)
    {
        switch (handlerType)
        {
            case EHandlerType.Role:
                var roles = await _roleRepository.QueryAsync();
                return roles.Select(d => new KeyValuePair<string, string>(d.Name, d.DisplayName)).ToList();
            case EHandlerType.OrgLevel:
                var orgs1 = await _systemDomainService.QueryOrgLevelStringOptionsAsync(HttpContext.RequestAborted);
                return orgs1.ToList();
            case EHandlerType.OrgType:
                return EnumExts.GetDescriptions<EOrgType>().Select(d => new KeyValuePair<string, string>(d.Key.ToString(), d.Value)).ToList();
            case EHandlerType.AssignedOrg:
                var orgs = await _organizeRepository.GetOrgJson();
                return orgs.Select(d => new KeyValuePair<string, string>(d.Id, d.Name)).ToList();
            case EHandlerType.AssignedUser:
            default:
                throw new ArgumentOutOfRangeException(nameof(handlerType), handlerType, null);
        }
    }

    /// <summary>
    /// 查询流程流转记录
    /// </summary>
    /// <param name="workflowId"></param>
    /// <returns></returns>
    [HttpGet("{workflowId}/traces")]
    public async Task<WorkflowDto> GetWorkflowTraces(string workflowId)
    {
        var workflow = await _workflowDomainService.GetWorkflowAsync(workflowId, cancellationToken: HttpContext.RequestAborted);
        workflow.Traces = await _workflowTraceRepository.Queryable()
                .Where(d => d.WorkflowId == workflow.Id && !string.IsNullOrEmpty(d.AcceptorId))
                .OrderBy(d => d.CreationTime)
                .ToTreeAsync(d => d.Traces, d => d.ParentId, null);

        return _mapper.Map<WorkflowDto>(workflow);
    }

    /// <summary>
    /// 查询被督办/催办部门
    /// </summary>
    /// <param name="workflowId"></param>
    /// <returns></returns>
    [HttpGet("{workflowId}/urge")]
    public async Task<IReadOnlyList<Kv>> GetUrgeOrgs(string workflowId)
    {
        /*
         * 非会签：当前部门上至一级部门
         * 中心会签：一级部门下至所有当前办理部门（遍历所有会签分支）
         */
        //var workflow = await _workflowDomainService.GetWorkflowAsync(workflowId, withSteps: true, cancellationToken: HttpContext.RequestAborted);
        //var steps = workflow.Steps.Where(d => d.StepType is not EStepType.Start and not EStepType.End).ToList();
        //if (workflow.CounterSignType is ECounterSignType.Center)
        //{
        //   var steps = workflow.Steps.Where(d=> d.StepType is not EStepType.Start and not EStepType.End)
        //        .SelectMany(d=>d.Handlers)
        //        .ToList();
        //}
        //else
        //{

        //}

        //
        var workflow = await _workflowDomainService.GetWorkflowAsync(workflowId, withSteps: true, cancellationToken: HttpContext.RequestAborted);
        var stepBoxes = workflow.Steps.Where(d => d.StepType != EStepType.Start && d.StepType != EStepType.End).ToList();
        var steps = stepBoxes.SelectMany(d => d.Steps);

        var orgs = new List<Kv>();
        foreach (var step in steps)
        {
            var orgCode = step.HandlerOrgId ?? step.AcceptorOrgId;
            var orgName = step.HandlerOrgName ?? step.AcceptorOrgName;
            if (string.IsNullOrEmpty(orgCode))
            {
                switch (step.HandlerType)
                {
                    case EHandlerType.Role:
                    case EHandlerType.AssignedUser:
                        //todo
                        var users = await _userRepository.Queryable()
                            .Includes(d => d.Organization)
                            .Where(d => step.Handlers.Select(x => x.Key).Contains(d.Id))
                            .ToListAsync(HttpContext.RequestAborted);
                        orgs.AddRange(users.Select(d => new Kv(d.OrgId, d.Organization.Name)));
                        break;
                    case EHandlerType.OrgLevel:
                    case EHandlerType.OrgType:
                    case EHandlerType.AssignedOrg:
                        orgs.AddRange(step.Handlers);
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
            else
            {
                orgs.Add(new Kv(orgCode, orgName));
            }
        }
        return orgs.DistinctBy(d => d.Key).ToList();
    }

    [HttpGet("base-data")]
    public async Task<dynamic> BaseData()
    {
        var levels = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        var orgs = levels.Select(d => new KeyValuePair<string, string>(d.ToString(), $"{d.ToChinese()}级部门办理")).ToList();
        var center = new KeyValuePair<string, string>("0", "中心办理");
        var centerIsTop = new List<KeyValuePair<string, string>> { center };
        centerIsTop.AddRange(orgs);
        return new
        {
            ModuleOptions = WorkflowModuleConsts.AllModules.Select(d => new KeyValuePair<string, string>(d.Code, d.Name)),
            HandlerTypeOptions = EnumExts.GetDescriptions<EHandlerType>(),
            BusinessTypeOptions = EnumExts.GetDescriptions<EBusinessType>(),
            StepPropertiesOptions = await _systemDomainService.GetSysDicDataByCodeAsync(SysDicTypeConsts.WorkflowStepComponent, HttpContext.RequestAborted),
            //PathPolicyOptions = EnumExts.GetDescriptions<EPathPolicy>(),
            ExecuteModeOptions = EnumExts.GetDescriptions<EExecuteMode>(),
            InstanceModeOptions = EnumExts.GetDescriptions<EInstanceMode>(),
            StepTypeOptions = EnumExts.GetDescriptions<EStepType>().Where(d => d.Key != 1 && d.Key != 2),
            DynamicPolicyOptions = EnumExts.GetDescriptions<EDynamicPolicy>()
                .Select(d => new
                {
                    Key = d.Key,
                    Value = d.Value,
                    Items = d.Key == 0 || d.Key == 2 ? centerIsTop : orgs
                }),//todo thk

        };
    }

    /// <summary>
    /// 持久化新增工作流业务
    /// </summary>
    /// <returns></returns>
    [AllowAnonymous]
    [HttpGet("wfmodule/persistence")]
    public async Task PersistenceWfModule()
    {
        await _wfModuleDomainService.PersistenceModulesAsync(HttpContext.RequestAborted);
    }

    /// <summary>
    /// 查询所有工作流模块
    /// </summary>
    /// <returns></returns>
    [HttpGet("wfmodules")]
    public async Task<IReadOnlyList<WorkflowModule>> QueryWfModules()
    {
        return await _wfModuleRepository.Queryable()
            .Includes(d => d.Definition)
            .ToListAsync();
    }

    /// <summary>
    /// 为工作流业务匹配或取消流程模板
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPut("wfmodule/match")]
    public async Task MatchDefinition([FromBody] MatchDefinitionDto dto)
    {
        if (string.IsNullOrEmpty(dto.DefinitionId))
        {
            //取消当前已配置模板
            await _wfModuleDomainService.MatchDefinitionAsync(dto, HttpContext.RequestAborted);
        }
        else
        {
            var definition = await _definitionRepository.GetAsync(dto.DefinitionId);
            if (definition == null)
                throw UserFriendlyException.SameMessage("无效模板编号");
            if (definition.Status != EDefinitionStatus.Enable)
                throw UserFriendlyException.SameMessage("该模板未发布");
            await _wfModuleDomainService.MatchDefinitionAsync(dto, HttpContext.RequestAborted);
        }
    }
}