track/src/SJZY.Track.Application/CAP/EventHandlers/TrackChangeAfterUpdateOrderEventHandler.cs

using DotNetCore.CAP;
using SJZY.Track.Application.Contract.Dtos.Forewarning;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Application.Contract.Services;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Consts;
using SJZY.Track.Domain.Queries;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.CAP.EventHandlers;

public class TrackChangeAfterUpdateOrderEventHandler : ITransientDependency, ICapSubscribe
{
    private readonly IForewarningNotifyService _forewarningNotifyService;
    private readonly IOrderRepository _orderRepository;
    private readonly IProvideQueries _provideQueries;
    private readonly ITrackPullCacheService _trackPullCacheService;

    public TrackChangeAfterUpdateOrderEventHandler(IOrderRepository orderRepository,
        IForewarningNotifyService forewarningNotifyService, ITrackPullCacheService trackPullCacheService,
        IProvideQueries provideQueries)
    {
        _orderRepository = orderRepository;
        _forewarningNotifyService = forewarningNotifyService;
        _trackPullCacheService = trackPullCacheService;
        _provideQueries = provideQueries;
    }

    [CapSubscribe(GlobalConst.TrackChangeAfterUpdateOrderSubscribe)]
    public async Task ConsumerAsync(TrackChangeAfterUpdateOrderEvent @event)
    {
        var orders = await GetOrdersAsync(@event.OrderIds);

        if (orders.Count == 0) return;

        var updateOrders = new List<OrderEntity>();
        foreach (var order in orders)
        {
            if (order.LatestTrackContent != @event.TrackContent)
            {
                if (order.LatestTrackTime != null &&
                    @event.TrackTime.Subtract(TimeSpan.FromHours(@event.TrackTimeZone)) <
                    order.LatestTrackTime.Value.Subtract(TimeSpan.FromHours(order.LatestTrackTimeZone ?? 0)))
                {
                    continue;
                }
            }

            // 执行轨迹兜底时 时区缺失和发生地缺失标记，1表示时区，2表示发生地，3表示两种
            if (@event.DeficiencyTagValue > 0 && @event.DeficiencyTagValue <= 3)
            {
                order.DeficiencyTag = @event.DeficiencyTagValue;
            }

            if (!order.IsCompleted)
            {
                order.IsCompleted = @event.IsCompleted;
            }

            order.LatestTrackContent = @event.TrackContent;
            order.LatestTrackEnContent = @event.TrackEnContent;
            order.LatestTrackPlace = @event.TrackPlace;
            order.LatestTrackTime = @event.TrackTime;
            order.LatestTrackTimeZone = @event.TrackTimeZone;
            updateOrders.Add(order);
        }

        await _orderRepository.UpdateRangeAsync(updateOrders,
            x => new
            {
                x.IsCompleted,
                x.LatestTrackContent,
                x.LatestTrackEnContent,
                x.LatestTrackPlace,
                x.LatestTrackTime,
                x.LatestTrackTimeZone,
                x.DeficiencyTag
            });

        // 预警计算
        await _forewarningNotifyService.WarningCalculateAsync(BuiltWarningDto(orders, @event));
    }

    private async Task<List<OrderEntity>> GetOrdersAsync(int[] orderIds)
    {
        return await _orderRepository.GetListAsync(order => orderIds.Contains(order.Id), order => new OrderEntity
        {
            Id = order.Id,

            // 轨迹
            IsCompleted = order.IsCompleted,
            LatestTrackContent = order.LatestTrackContent,
            LatestTrackEnContent = order.LatestTrackEnContent,
            LatestTrackPlace = order.LatestTrackPlace,
            LatestTrackTime = order.LatestTrackTime,
            LatestTrackTimeZone = order.LatestTrackTimeZone,

            // 因素
            CargoType = order.CargoType,
            CreateTime = order.CreateTime,
            ArrivalCountry = order.ArrivalCountry,
            ArrivalProvince = order.ArrivalProvince,
            ArrivalCity = order.ArrivalCity,
            ArrivalPostCode = order.ArrivalPostCode,
            IsTransit = order.IsTransit,
            LeavePort = order.LeavePort,
            ProductCode = order.ProductCode,
        });
    }

    private WarningDto BuiltWarningDto(List<OrderEntity> orders, TrackChangeAfterUpdateOrderEvent @event)
    {
        return new WarningDto
        {
            TrackStatusId = @event.TrackStatusId,
            SubSystemId = @event.SubSystemId,
            CustomerId = @event.CustomId,
            Orders = orders.Select(order => new WarningOrderDto
            {
                Id = order.Id,
                TrackTime = @event.TrackTime,
                CargoType = order.CargoType,
                Month = order.CreateTime.Month,
                IsTransit = order.IsTransit,
                LeavePort = order.LeavePort,
                ProductCode = order.ProductCode,
                ArrivalCountry = order.ArrivalCountry,
                ArrivalProvince = order.ArrivalProvince,
                ArrivalCity = order.ArrivalCity,
                ArrivalPostCode = order.ArrivalPostCode,
            }).ToList()
        };
    }
}