track/src/SJZY.Track.Application/Services/ProvideServices/OrderService.Link.cs

using DotNetCore.CAP;
using SJZY.Track.Application.Contract.Dtos.ProvideServices;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;

namespace SJZY.Track.Application.Services.ProvideServices;

/// <summary>
/// 订单关联服务
/// </summary>
public partial class OrderService
{
    private readonly ICapPublisher _capPublisher;
    private readonly ITrackDetailsEsRepository _trackDetailsEsRepository;

    /// <summary>
    /// 关联、解除关联订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Order/Link")]
    public async Task<UnifyResultDto> LinkOrderAsync(LinkOrderInput input)
    {
        var orderId = await _orderRepository.GetFirstAsync(x =>
                x.SubSystemId == input.SubSystemId && x.OrderType == input.OrderType && x.OrderNo == input.OrderNo,
            x => x.Id);
        if (orderId == default)
        {
            throw new BusinessException(message: $"订单：{input.OrderNo}不存在");
        }

        // tips：循环关联问题再消费时解决
        if (input.OrderType == input.LinkOrderType)
        {
            throw new BusinessException(message: "不能同级关联");
        }

        if (input.LinkOrderNos.Count < 1 || input.LinkOrderType == 0) return new UnifyResultDto(true);

        // 单号去重，去空，去自己
        input.LinkOrderNos = input.LinkOrderNos
            .Where(x => !x.IsNullOrWhiteSpace() && x != input.OrderNo)
            .Distinct().ToList();

        if (!input.IsLink)
        {
            // 解绑
            await UnLinkOrderAsync(input, orderId);
        }
        else
        {
            // 关联订单
            await DoLinkOrderAsync(input, orderId);
        }

        return new UnifyResultDto(true, true);
    }

    private async Task DoLinkOrderAsync(LinkOrderInput input, int orderId)
    {
        // 获取已关联的订单
        var linkOrderNos =
            await _orderRepository.GetLinkedOrdersAsync(orderId, input.LinkSubSystemId, input.LinkOrderType);

        // 计算出未关联的订单
        var noLinkOrderNos = input.LinkOrderNos.Except(linkOrderNos).ToList();

        // 查询存在的订单
        var existedOrders = await _orderRepository.GetListAsync(x =>
                x.SubSystemId == input.LinkSubSystemId && x.OrderType == input.LinkOrderType &&
                noLinkOrderNos.Contains(x.OrderNo),
            x => new
            {
                x.Id,
                x.OrderNo,
                x.OrderType,
                x.SubSystemId,
                x.CustomId
            });

        // 如果有不存在的单，需要抛异常
        if (existedOrders.Count != noLinkOrderNos.Count)
        {
            throw new BusinessException(
                message: $"关联单：{noLinkOrderNos.Except(existedOrders.Select(x => x.OrderNo)).JoinAsString(", ")}不存在");
        }

        await _orderRepository.LinkOrderAsync(existedOrders.Select(x => new OrderLinkEntity
        {
            OrderId = orderId,
            LinkOrderId = x.Id,
        }).ToList());

        var tracks = await _trackDetailsEsRepository.GetListAsync(orderId);

        // 补轨迹（按子系统、按客户分，同样是为了方便轨迹upsert和push）
        foreach (var group in existedOrders.GroupBy(x => new
        {
            x.SubSystemId,
            x.CustomId
        }))
        {
            foreach (var track in tracks)
            {
                var fillTrackEvent = new TrackUpsertEvent
                {
                    SubSystemId = group.Key.SubSystemId,
                    CustomId = group.Key.CustomId,
                    OrderIdentifiers =
                        group.Select(x =>
                                new OrderIdentifier
                                {
                                    OrderId = x.Id,
                                    OrderNo = x.OrderNo,
                                    OrderType = x.OrderType,
                                })
                            .ToArray(),
                    TrackCode = track.TrackCode,
                    TrackPlace = track.TrackPlace,
                    TrackTime = track.TrackTime,
                    TrackTimeZone = track.TrackTimeZone,
                    IsAdd = true // 存在则不新增
                };

                await _capPublisher.PublishAsync(GlobalConst.TrackUpsertSubscribe, fillTrackEvent);
            }
        }
    }

    private async Task UnLinkOrderAsync(LinkOrderInput input, int orderId)
    {
        var unLinkIds = await _orderRepository.GetLinkedOrdersAsync(orderId, input.LinkSubSystemId, input.LinkOrderType,
            input.LinkOrderNos);

        // real del
        await _orderRepository.UnLinkByIdsAsync(unLinkIds);
    }
}