VberAdmin_V4/SourceCode/Zero/VberYue.Zero/AppService/Workflows/WorkflowAppServiceBase.cs

using Abp.Application.Services.Dto;
using Abp.Domain.Repositories;
using Abp.Json;

using Microsoft.AspNetCore.Authorization;
using Microsoft.EntityFrameworkCore;

using VberZero.AppService.Base;
using VberZero.AppService.Base.Dto;
using VberZero.AppService.Workflows.Dto;
using VberZero.Workflow;
using VberZero.Workflow.DesignInfo;
using VberZero.Workflow.Persistence;
using VberZero.Workflow.StepBodies;

namespace VberZero.AppService.Workflows;

[Authorize]
public class WorkflowAppServiceBase : VzCrudAppServiceBase<WorkflowDefinitionInfo, WorkflowDefinitionDto, string, VzPagedRequestDto, WorkflowDefinitionCreateDto, WorkflowDefinitionUpdateDto>, IWorkflowAppServiceBase
{
    private readonly IVberWorkflowManager _workflowManager;
    private readonly IRepository<WorkflowInfo, string> _workflowRepository;

    public WorkflowAppServiceBase(IRepository<WorkflowDefinitionInfo, string> repository, IVberWorkflowManager workflowManager, IRepository<WorkflowInfo, string> workflowRepository, string keyFiledName = null) : base(repository, keyFiledName)
    {
        _workflowManager = workflowManager;
        _workflowRepository = workflowRepository;
    }

    /// <summary>
    /// 获取所有分组
    /// </summary>
    /// <returns></returns>

    public async Task<IEnumerable<string>> GetAllGroupAsync()
    {
        var data = await AsyncQueryableExecuter.ToListAsync(_workflowManager.WorkflowDefinitions.GroupBy(u => u.Group).Select(u => u.Key));
        return data.Where(u => u != null || u != "");
    }

    /// <summary>
    /// 我发起的流程
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<PagedResultDto<MyWorkflowListOutput>> GetMyWorkflowAsync(VzPagedRequestDto input)
    {
        var query = _workflowRepository.GetAll().Where(u => u.CreatorUserId == AbpSession.UserId);

        query = ApplyFilter(query, input);

        int totalCount = await query.CountAsync();
        query = query.OrderByDescending(u => u.CreationTime);
        query = query.Skip(input.SkipCount).Take(input.MaxResultCount);
        var dto = await query.Select(u => new MyWorkflowListOutput()
        {
            Title = u.WorkflowDefinitionInfo.Title,
            Version = u.Version,
            Id = u.Id,
            Status = u.Status,
            CompleteTime = u.CompleteTime,
            CreationTime = u.CreationTime,
            CurrentStepName = (u.ExecutionPointers.FirstOrDefault(i => i.EndTime == null) ?? u.ExecutionPointers.OrderBy(i => i.EndTime).Last()).StepName,
            Nodes = u.WorkflowDefinitionInfo.Nodes
        }).ToListAsync();

        return new PagedResultDto<MyWorkflowListOutput>(totalCount, dto);
    }

    // protected override IQueryable<T> KeyWordFilter<T>(IQueryable<T> query, IVzPagedRequestDto pagedInput)
    // {
    //     return base.KeyWordFilter(query, pagedInput);
    // }

    /// <summary>
    /// 获取所有的StepBody
    /// </summary>
    /// <returns></returns>
    public IEnumerable<VberWorkflowStepBody> GetAllStepBodies()
    {
        return _workflowManager.GetAllStepBodies();
    }

    /// <summary>
    /// 获取所有分组的流程
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<Dictionary<string, IEnumerable<WorkflowDefinitionDto>>> GetAllWithGroupAsync(VzPagedRequestDto input)
    {
        var list = await AsyncQueryableExecuter.ToListAsync(CreateFilteredQuery(input).Select(a => a));
        var group = list.GroupBy(a => a.Group).OrderBy(a => a.Key);
        return group.ToDictionary(a => a.Key, a => a.Select(MapToEntityDto));
    }

    public async Task<WorkflowDefinitionDto> GetByVersion(WorkflowDefinitionVersionDto input)
    {
        var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id && a.Version == input.Version);
        var dto = MapToEntityDto(entity);
        return dto;
    }

    public override async Task Create(WorkflowDefinitionCreateDto input)
    {
        //input.Id = await AppGuidManager.GetGuidFromFileAsync(AppGuidType.Workflow) + "";
        var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id && a.Version == input.Version);
        if (entity != null)
        {
            CheckErrors($"编号为{input.Id}，版本为V{input.Version}的流程已存在");
            return;
        }
        //await CreateEntity(input, false);
        entity = MapToEntity(input);
        entity.TenantId = AbpSession.TenantId;
        await _workflowManager.CreateAsync(entity);
    }

    public override async Task Update(WorkflowDefinitionUpdateDto input)
    {
        var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id && a.Version == input.Version);
        if (entity == null)
        {
            CheckErrors($"编号为{input.Id}，版本为{input.Version}的流程不存在");
            return;
        }
        MapToEntity(input, entity);
        await _workflowManager.UpdateAsync(entity);
    }

    public override async Task Delete(VzEntityDto<string> input)
    {
        await _workflowManager.DeleteAsync(input.Id);
    }

    /// <summary>
    /// 删除指定编号指定版本的
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task DeleteByVersion(WorkflowDefinitionVersionDto input)
    {
        var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id && a.Version == input.Version);
        if (entity == null)
        {
            CheckErrors($"编号为{input.Id}，版本为{input.Version}的流程不存在");
            return;
        }

        await _workflowManager.DeleteAsync(input.Id, input.Version.Value);
    }

    /// <summary>
    /// 获取执行的工作流详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<WorkflowDto> GetDetailsAsync(string id)
    {
        var workflow = await _workflowRepository.GetAll().Where(u => u.Id == id).Select(u => new
        {
            u.Id,
            u.Version,
            u.WorkflowDefinitionId,
            u.WorkflowDefinitionInfo.Title,
            u.CreateUserIdentityName,
            u.CreationTime,
            u.WorkflowDefinitionInfo.Inputs,
            u.Data,
            u.CompleteTime,
            u.Status,
            u.WorkflowDefinitionInfo.Nodes,
            ExecutionRecords = u.ExecutionPointers.OrderBy(i => i.StartTime).Select(i => new WorkflowExecutionRecord()
            {
                ExecutionPointerId = i.Id,
                EndTime = i.EndTime,
                StartTime = i.StartTime,
                StepId = i.StepId,
                StepName = i.StepName
            })
        }).FirstOrDefaultAsync();
        if (workflow == null)
        {
            CheckErrors("没有查询到工作流！");
            return null;
        }

        var dto = new WorkflowDto()
        {
            Id = workflow.Id,
            Version = workflow.Version,
            Data = workflow.Data.FromJsonString<Dictionary<string, object>>(),
            CompleteTime = workflow.CompleteTime,
            Status = workflow.Status,
            Title = workflow.Title,
            CreationTime = workflow.CreationTime,
            WorkflowDefinitionId = workflow.WorkflowDefinitionId,
            Inputs = workflow.Inputs,
            ExecutionRecords = workflow.ExecutionRecords,
            UserName = workflow.CreateUserIdentityName,
        };
        foreach (var executionRecord in dto.ExecutionRecords)
        {
            executionRecord.StepTitle = workflow.Nodes.FirstOrDefault(a => a.Key == executionRecord.StepName)?.Title;
        }

        return dto;
    }

    /// <summary>
    /// 启动工作流
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task StartAsync(StartWorkflowInput input)
    {
        await _workflowManager.StartWorkflow(input.Id, input.Version, input.Inputs);
    }

    /// <summary>
    /// 发布事件
    /// </summary>
    /// <param name="input"></param>
    public async Task PublicEvent(PublishEventInput input)
    {
        await _workflowManager.PublishEventAsync(input.EventName, input.EventKey, input.EventData);
    }
}