hotline/src/Hotline.Application/Handlers/FlowEngine/NextStepHandler.cs

using DotNetCore.CAP;
using Hotline.Application.FlowEngine;
using Hotline.FlowEngine.Notifications;
using Hotline.FlowEngine.WorkflowModules;
using Hotline.FlowEngine.Workflows;
using Hotline.KnowledgeBase;
using Hotline.Orders;
using Hotline.Repository.SqlSugar.Orders;
using Hotline.Settings;
using Hotline.Share.Dtos.FlowEngine.Workflow;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.Order;
using Hotline.Share.Mq;
using MapsterMapper;
using MediatR;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using XF.Domain.Entities;
using XF.Domain.Exceptions;
using XF.Domain.Repository;

namespace Hotline.Application.Handlers.FlowEngine;

public class NextStepHandler : INotificationHandler<NextStepNotify>
{
    private readonly IOrderDomainService _orderDomainService;
    private readonly IKnowledgeDomainService _knowledgeDomainService;
    private readonly IOrderRepository _orderRepository;
    private readonly ICapPublisher _capPublisher;
    private readonly IMapper _mapper;
    private readonly ILogger<NextStepHandler> _logger;
    private readonly IRepository<OrderScreen> _orderScreenRepository;

	public NextStepHandler(
        IOrderDomainService orderDomainService,
        IKnowledgeDomainService knowledgeDomainService,
        IOrderRepository orderRepository,
        ICapPublisher capPublisher,
        IMapper mapper,
        ILogger<NextStepHandler> logger,
        IRepository<OrderScreen> orderScreenRepository)
    {
        _orderDomainService = orderDomainService;
        _knowledgeDomainService = knowledgeDomainService;
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _mapper = mapper;
        _logger = logger;
        _orderScreenRepository = orderScreenRepository;
	}

    /// <summary>Handles a notification</summary>
    /// <param name="notification">The notification</param>
    /// <param name="cancellationToken">Cancellation token</param>
    public async Task Handle(NextStepNotify notification, CancellationToken cancellationToken)
    {
        _logger.LogInformation($"收到{nameof(NextStepNotify)}, notification: {JsonConvert.SerializeObject(notification)}");
        var workflow = notification.Workflow;
        var data = notification.Dto;
        
        switch (workflow.ModuleCode)
        {
            case WorkflowModuleConsts.OrderHandle:
                var order = await _orderDomainService.GetOrderAsync(workflow.ExternalId, cancellationToken);
                order.CheckIfFiled();
                _mapper.Map(workflow, order);
                await _orderRepository.UpdateAsync(order, cancellationToken);

                var orderDto = _mapper.Map<OrderDto>(order);
                if (notification.IsCenterToOrg)
                    await _capPublisher.PublishAsync(EventNames.HotlineOrderExpiredTimeUpdate, orderDto, cancellationToken: cancellationToken);

                if (notification.HandlerOrgCode.CheckIfOrgLevelIs(1))
                    await _capPublisher.PublishAsync(EventNames.HotlineOrderLevelOneOrgHandled, new OrderFlowDto
                    {
                        Order = orderDto,
                        WorkflowTrace = _mapper.Map<WorkflowTraceDto>(notification.Trace)
                    }, cancellationToken: cancellationToken);

                break;
            case WorkflowModuleConsts.KnowledgeAdd:
            case WorkflowModuleConsts.KnowledgeUpdate:
            case WorkflowModuleConsts.KnowledgeDelete:
                await _knowledgeDomainService.UpdateWorkAssign(notification.FlowAssignInfo, workflow.ExternalId, cancellationToken);
                break;
            case WorkflowModuleConsts.OrderScreen:
                var screen = await _orderScreenRepository.GetAsync(workflow.ExternalId, cancellationToken);
                if (screen != null)
                {
	                screen.Status = EScreenStatus.Approval;
                    await _orderScreenRepository.UpdateAsync(screen, cancellationToken);
				}
				break;

		}
    }
}