track/src/SJZY.Track.Application/EventHandlers/TrackUpsertEventHandler.cs

using DotNetCore.CAP;
using SJZY.Expand.ABP.Core.Logger;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Consts;
using SJZY.Track.Domain.Queries;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.EventHandlers;

public class TrackUpsertEventHandler : ITransientDependency, ICapSubscribe
{
    private readonly IOrderRepository _orderRepository;
    private readonly IProvideQueries _provideQueries;
    private readonly ITrackDetailsRepository _trackDetailsRepository;
    private readonly ICapPublisher _capPublisher;

    public TrackUpsertEventHandler(IOrderRepository orderRepository, ICapPublisher capPublisher,
        IProvideQueries provideQueries, ITrackDetailsRepository trackDetailsRepository)
    {
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _provideQueries = provideQueries;
        _trackDetailsRepository = trackDetailsRepository;
    }

    [CapSubscribe(GlobalConst.TrackUpsertSubscribe, Group = GlobalConst.TrackUpsertSubscribe)]
    public async Task ConsumerAsync(TrackUpsertEvent @event)
    {
        if (@event.Visited.Contains(@event.OrderId))
        {
            LogHelper.Error($"轨迹订单循环依赖预警：{@event.Visited.JoinAsString(",")}");
            return;
        }

        // 不同子系统需要做内容映射
        if (@event.UpSubSystemId != 0 && @event.UpSubSystemId != @event.SubSystemId)
        {
            var mapCode = (await _provideQueries
                    .MapTrackCodesAsync(@event.UpSubSystemId, @event.SubSystemId, @event.TrackCode))
                .FirstOrDefault();

            if (mapCode == default)
            {
                // 跨子系统没做映射的轨迹不处理
                return;
            }

            @event.TrackCode = mapCode;
        }

        var track = await _trackDetailsRepository.GetFirstOrDefaultAsync(@event.OrderId, @event.TrackCode);

        if (@event.IsAdd != null)
        {
            if (track == null && !@event.IsAdd!.Value) return; // 不存在不让改
            if (track != null && @event.IsAdd!.Value) return; // 存在不让创建
        }

        // step1、upsert es轨迹
        track = await UpsertTrackAsync(track, @event);

        if (track == null) return; // 模板没配该轨迹代码，不再继续

        // step2、触发轨迹推送事件（异步）
        var trackPushEvent = new TrackPushEvent
        {
            OptionType = track.Id.IsNullOrWhiteSpace() ? OptionType.新增 : OptionType.修改,
            OrderId = track.OrderId,
            OrderNo = track.OrderNo,
            TrackStatus = track.TrackStatus,
            TrackCode = track.TrackCode,
            TrackContent = track.TrackContent,
            TrackPlace = track.TrackPlace,
            TrackTime = track.TrackTime,
            TrackTimeZone = track.TrackTimeZone,
        };

        await _capPublisher.PublishAsync(GlobalConst.TrackPushSubscribe, trackPushEvent);

        // step3、触发订单主表更新事件（异步）
        await _capPublisher.PublishAsync(GlobalConst.TrackChangeAfterUpdateOrderSubscribe,
            new TrackChangeAfterUpdateOrderEvent
            {
                OrderId = track.OrderId,
                IsCompleted = @event.IsCompleted,
                TrackCode = track.TrackCode,
                TrackContent = track.TrackContent,
                TrackEnContent = track.TrackEnContent,
                TrackPlace = track.TrackPlace,
                TrackTime = track.TrackTime,
                TrackTimeZone = track.TrackTimeZone
            });

        // step4、根据订单关联关系异步向下刷（异步）
        var linkedOrders = await _orderRepository.GetLinkedOrdersAsync(@event.OrderId);
        foreach (var linkedOrder in linkedOrders)
        {
            var nextEvent = @event.DeepCopy();
            nextEvent.Visited.Add(@event.OrderId);
            // tips：一定要重置为false，父级订单的完成不会使得关联订单完成，关联单也必须由刷新来完成或手动设置完成！！
            nextEvent.IsCompleted = false; // 能够使得轨迹IsCompleted为true的点，全局只有一个：轨迹刷新
            nextEvent.OrderId = linkedOrder.OrderId;
            nextEvent.OrderType = linkedOrder.OrderType;
            nextEvent.OrderNo = linkedOrder.OrderNo;
            nextEvent.SubSystemId = linkedOrder.SubSystemId;
            nextEvent.UpSubSystemId = @event.SubSystemId;
            await _capPublisher.PublishAsync(GlobalConst.TrackUpsertSubscribe, nextEvent);
        }
    }

    /// <summary>
    /// 不存在则新增轨迹，存在则更新
    /// </summary>
    /// <param name="track"></param>
    /// <param name="event"></param>
    private async Task<TrackDetailsIndex?> UpsertTrackAsync(TrackDetailsIndex? track, TrackUpsertEvent @event)
    {
        if (track == default)
        {
            track = new TrackDetailsIndex
            {
                IndexName = $"{GlobalConst.TrackIndex}-{DateTime.Now:yyyy.MM.dd}",
                OrderId = @event.OrderId,
                OrderNo = @event.OrderNo,
                OrderType = @event.OrderType,
                TrackCode = @event.TrackCode,
                TrackPlace = @event.TrackPlace,
                TrackTime = @event.TrackTime,
                TrackTimeZone = @event.TrackTimeZone,
                ServiceProviderName = @event.ServiceProviderName,
                IsCanDelete = false,
                CreateUser = @event.OperationMan ?? GlobalConst.SystemUser,
                CreateTime = DateTime.Now
            };

            //todo：可以优化
            // 根据轨迹code在订单模板内容中寻找匹配的
            var trackContent = await _provideQueries.MatchTrackContentAsync(@event.OrderId, @event.TrackCode);
            if (trackContent == default)
            {
                // 订单所绑定的模板，没有一条内容可以匹配发生的轨迹
                return null;
            }

            track.TrackStatus = trackContent.Status;
            track.TrackCode = trackContent.TrackCode;
            track.TrackContent = trackContent.Content;
            track.TrackEnContent = trackContent.EnContent;
            track.IsCanDelete = trackContent.IsCanDelete;
            track.ZeroTrackTime = track.TrackTime.Subtract(TimeSpan.FromHours(track.TrackTimeZone));
        }
        else
        {
            track.TrackPlace = @event.TrackPlace;
            track.TrackTime = @event.TrackTime;
            track.TrackTimeZone = @event.TrackTimeZone;
            track.UpdateUser = @event.OperationMan ?? GlobalConst.SystemUser;
            track.UpdateTime = DateTime.Now;
        }

        await _trackDetailsRepository.UpsertAsync(track);

        return track;
    }
}