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

using DotNetCore.CAP;
using Hotline.Article;
using Hotline.CallCenter.Tels;
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;
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.AspNetCore.Http;
using XF.Domain.Exceptions;
using XF.Domain.Repository;

namespace Hotline.Application.Handlers.FlowEngine;

public class EndWorkflowHandler : INotificationHandler<EndWorkflowNotify>
{

    private readonly IKnowledgeDomainService _knowledgeDomainService;
    private readonly IOrderDomainService _orderDomainService;
    private readonly ITelDomainService _telDomainService;
    private readonly IOrderRepository _orderRepository;
    private readonly ICapPublisher _capPublisher;
    private readonly IMapper _mapper;
    private readonly IRepository<OrderVisitDetail> _orderVisitedDetailRepository;
    private readonly IRepository<OrderScreen> _orderScreenRepository;
    private readonly IRepository<Bulletin> _bulletinRepository;
    private readonly IRepository<Circular> _circularRepository;
    private readonly IRepositorySqlSugar<CircularReadGroup> _circularReadGroupRepository;
    private readonly IRepositorySqlSugar<CircularRecord> _circularRecordRepository;
    private readonly ICircularRecordDomainService _circularRecordDomainService;
    private readonly IRepository<OrderVisit> _orderVisitRepository;
    private readonly IRepository<OrderDelay> _orderDelayRepository;
    private readonly IRepository<OrderVisitApply> _orderVisitApplyRepository;

    public EndWorkflowHandler(
        IKnowledgeDomainService knowledgeDomainService,
        IOrderDomainService orderDomainService,
        ITelDomainService telDomainService,
        IOrderRepository orderRepository,
        ICapPublisher capPublisher,
        IMapper mapper,
        IRepository<OrderVisitDetail> orderVisitedDetailRepository,
        IRepository<OrderScreen> orderScreenRepository,
        IRepository<Bulletin> bulletinRepository,
        IRepository<Circular> circularRepository,
        IRepository<CircularReadGroup> circularReadGroupRepository,
        IRepository<CircularRecord> circularRecordRepository,
        ICircularRecordDomainService circularRecordDomainService,
        IRepository<OrderDelay> orderDelayRepository,
        IRepository<OrderVisit> orderVisitRepository,
        IRepository<OrderVisitApply> orderVisitApplyRepository
        )
    {
        _knowledgeDomainService = knowledgeDomainService;
        _orderDomainService = orderDomainService;
        _telDomainService = telDomainService;
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _mapper = mapper;
        _orderScreenRepository = orderScreenRepository;
        _orderVisitedDetailRepository = orderVisitedDetailRepository;
        _bulletinRepository = bulletinRepository;
        _circularRepository = circularRepository;
        _circularReadGroupRepository = circularReadGroupRepository;
        _circularRecordRepository = circularRecordRepository;
        _circularRecordDomainService = circularRecordDomainService;
        _orderDelayRepository = orderDelayRepository;
        _orderVisitRepository = orderVisitRepository;
        _orderVisitApplyRepository = orderVisitApplyRepository;
    }

    /// <summary>Handles a notification</summary>
    /// <param name="notification">The notification</param>
    /// <param name="cancellationToken">Cancellation token</param>
    public async Task Handle(EndWorkflowNotify notification, CancellationToken cancellationToken)
    {
        var workflow = notification.Workflow;
        //审批是否通过
        var isReviewPass = workflow.IsReviewPass();

        switch (workflow.ModuleCode)
        {
            case WorkflowModuleConsts.KnowledgeAdd://新增知识库
            case WorkflowModuleConsts.KnowledgeUpdate://修改知识库
            case WorkflowModuleConsts.KnowledgeDelete://删除知识库
                await _knowledgeDomainService.EndWorkKnowledge(workflow, cancellationToken);
                break;
            case WorkflowModuleConsts.TelRestApply:
                await _telDomainService.TelRestApplyPassAsync(workflow.ExternalId, cancellationToken);
                break;
            case WorkflowModuleConsts.OrderHandle:
                var order = await _orderDomainService.GetOrderAsync(workflow.ExternalId, cancellationToken);
                order.CheckIfFiled();
                _mapper.Map(workflow, order);
                order.Filed();
                await _orderRepository.UpdateAsync(order, cancellationToken);

                await _capPublisher.PublishAsync(EventNames.HotlineOrderFiled, new OrderFlowDto
                {
                    Order = _mapper.Map<OrderDto>(order),
                    WorkflowTrace = _mapper.Map<WorkflowTraceDto>(notification.Trace)
                }, cancellationToken: cancellationToken);

                break;
            case WorkflowModuleConsts.OrderScreen:
                var screen = await _orderScreenRepository.GetAsync(workflow.ExternalId, cancellationToken);
                if (screen != null)
                {
                    if (isReviewPass)
                    {

                        screen.Status = EScreenStatus.End;
                        screen.ReplyContent = workflow.ActualOpinion;
                        await _orderScreenRepository.UpdateAsync(screen, cancellationToken);
                        var visitDetail =
                            await _orderVisitedDetailRepository.GetAsync(screen.VisitDetailId, cancellationToken);
                        if (visitDetail != null)
                        {
                            var screenSatisfy = new Kv() { Key = "6", Value = "甄别满意" };
                            visitDetail.OrgProcessingResults = screenSatisfy;
                            visitDetail.OrgHandledAttitude = screenSatisfy;
                            await _orderVisitedDetailRepository.UpdateAsync(visitDetail, cancellationToken);
							//获取回访信息
							var visit = await _orderVisitRepository.Queryable().Includes(x => x.Order)
								.Includes(x => x.OrderVisitDetails)
								.Where(x => x.Id == screen.VisitId).FirstAsync(cancellationToken);
							if (visit != null)
							{
								//获取回访明细
								var visitDe = visit.OrderVisitDetails.First(x => x.Id == screen.VisitDetailId);
								//推省上
								_capPublisher.Publish(EventNames.HotlineOrderScreenApplyed,
									new PublishVisitDto()
									{
										Order = _mapper.Map<OrderDto>(visit.Order),
										No = visit.No,
										VisitType = visit.VisitType,
										VisitName = visit.CreatorName,
										VisitTime = visit.VisitTime,
										VisitRemark = visitDe.VisitContent,
										AreaCode = visit.Order.AreaCode!,
										SubjectResultSatifyCode = visitDe.OrgProcessingResults?.Key,
										FirstSatisfactionCode = visit.Order.FirstVisitResultCode!,
										ClientGuid = ""
									});
							}
						}
                    }
                    else
                    {
                        screen.Status = EScreenStatus.Refuse;
                        screen.ReplyContent = workflow.ActualOpinion;
                        await _orderScreenRepository.UpdateAsync(screen, cancellationToken);
                    }
                }
                break;
            case WorkflowModuleConsts.BulletinApply:
                var bulletin = await _bulletinRepository.GetAsync(workflow.ExternalId, cancellationToken);
                if (bulletin != null)
                {
                    if (isReviewPass)
                    {
                        bulletin.BulletinState = Share.Enums.Article.EBulletinState.ReviewPass;
                        bulletin.BulletinTime = DateTime.Now;
                    }
                    else
                    {
                        bulletin.BulletinState = Share.Enums.Article.EBulletinState.ReviewNoPass;
                    }
                    await _bulletinRepository.UpdateAsync(bulletin, cancellationToken);
                }
                break;
            case WorkflowModuleConsts.CircularApply:
                var circular = await _circularRepository.GetAsync(workflow.ExternalId, cancellationToken);
                if (circular != null)
                {
                    if (isReviewPass)
                    {
                        //更新审核状态
                        circular.CircularState = Share.Enums.Article.ECircularState.ReviewPass;
                        circular.CircularTime = DateTime.Now;
                        await _circularRepository.UpdateAsync(circular, cancellationToken);
                        //更新阅读数量
                        if (circular.CircularType == Share.Enums.Article.ECircularType.Person)
                        {
                            //个人
                            var userlist = await _circularReadGroupRepository.Queryable()
                               .Where(x => x.CircularId == circular.Id)
                               .Select(x => x.UserId)
                               .ToListAsync(cancellationToken);
                            if (userlist != null && userlist.Count > 0)
                            {
                                await _circularRecordDomainService.RecordUserHandle(userlist, true);
                            }
                        }
                        else
                        {
                            //部门
                            var orglist = await _circularReadGroupRepository.Queryable()
                                .Where(x => x.CircularId == circular.Id)
                                .Select(x => x.OrgId)
                                .ToListAsync(cancellationToken);
                            if (orglist != null && orglist.Count > 0)
                            {
                                await _circularRecordDomainService.RecordOrgHandle(orglist, true);
                            }
                        }
                    }
                    else
                    {
                        circular.CircularState = Share.Enums.Article.ECircularState.ReviewNoPass;
                        await _circularRepository.UpdateAsync(circular, cancellationToken);
                    }
                }
                break;
            case WorkflowModuleConsts.OrderDelay:
                var delay = await _orderDelayRepository.GetAsync(workflow.ExternalId, cancellationToken);
                if (delay != null)
                {
                    if (isReviewPass)
                    {
                        delay.DelayState = isReviewPass ? EDelayState.Pass : EDelayState.NoPass;
                        await _orderDelayRepository.UpdateAsync(delay, cancellationToken);

                        //处理工单延期TODO
                    }
                    else
                    {
                        delay.DelayState = EDelayState.NoPass;
                        await _orderDelayRepository.UpdateAsync(delay, cancellationToken);
                    }
                }
                break;
            case WorkflowModuleConsts.VisitApply:
                //获取单据
                var visitApply = await _orderVisitApplyRepository.GetAsync(workflow.ExternalId, cancellationToken);
                if (visitApply!=null)
                {
                    if (isReviewPass)
                    {
                        //处理申请单
                        visitApply.VisitApplyState = EVisitApplyState.Pass;
                        await _orderVisitApplyRepository.UpdateAsync(visitApply, cancellationToken);
                        //处理原回访数据
                        var visitModel = await _orderVisitRepository.GetAsync(visitApply.OrderVisitId, cancellationToken);
                        if (visitModel != null)
                        {
                            visitModel.VisitState = EVisitState.None;
                            await _orderVisitRepository.UpdateAsync(visitModel, cancellationToken);
                            //处理新回访数据
                            //查询原回访数据子表
                            var visitModelNew = _mapper.Map<OrderVisit>(visitModel);
                            visitModelNew.InitId();
                            visitModelNew.CreationTime = DateTime.Now;
                            visitModelNew.CreatorId = string.Empty;
                            visitModelNew.CreatorName = string.Empty;
                            visitModelNew.CreatorOrgId = string.Empty;
                            visitModelNew.CreatorOrgName = string.Empty;
                            visitModelNew.CreatorOrgLevel = 0;
                            visitModelNew.AreaId = string.Empty;
                            visitModelNew.VisitState = EVisitState.WaitForVisit;

                            var id = await _orderVisitRepository.AddAsync(visitModelNew, cancellationToken);
                            var visitModelDetail = await _orderVisitedDetailRepository.Queryable().Where(x => x.VisitId == visitModel.Id).ToListAsync(cancellationToken);
                            var visitDetailListNew = new List<OrderVisitDetail>();
                            //TODO
                            foreach (var item in visitModelDetail)
                            {
                                var visitDetail = new OrderVisitDetail();
                                visitDetail.VisitId = id;
                                visitDetail.VisitOrgCode = item.VisitOrgCode;
                                visitDetail.VisitOrgName = item.VisitOrgName;
                                visitDetail.VisitTarget = item.VisitTarget;
                                visitDetailListNew.Add(visitDetail);
                            }
                            await _orderVisitedDetailRepository.AddRangeAsync(visitDetailListNew, cancellationToken);

                        }
                    }
                    else 
                    {
                        //处理申请单
                        visitApply.VisitApplyState = EVisitApplyState.NoPass;
                        await _orderVisitApplyRepository.UpdateAsync(visitApply, cancellationToken);
                    }
                }
                break;
        }
    }
}