track/src/SJZY.Track.Application/Services/ProvideServices/TrackQueryService.cs

using SJZY.Track.Application.Contract.Dtos.ProvideServices;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Dtos.Order;
using SJZY.Track.Domain.Queries;

namespace SJZY.Track.Application.Services.ProvideServices;

/// <summary>
/// 轨迹查询服务
/// </summary>
[ApiExplorerSettings(GroupName = "提供接口")]
[Route("/ProviderService")]
public class TrackQueryService : ApplicationService
{
    private readonly ITrackDetailsRepository _trackDetailsRepository;
    private readonly IOrderRepository _orderRepository;
    private readonly IProvideQueries _provideQueries;

    public TrackQueryService(ITrackDetailsRepository trackDetailsRepository,
        IOrderRepository orderRepository,
        IProvideQueries provideQueries)
    {
        _trackDetailsRepository = trackDetailsRepository;
        _orderRepository = orderRepository;
        _provideQueries = provideQueries;
    }

    /// <summary>
    /// 根据订单号获取轨迹
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Track/Query")]
    public async Task<List<GetTrackOutput>> QueryAsync(GetTrackInput input)
    {
        if (input.OrderNos.Count > 500)
        {
            throw new BusinessException(message: "最多只能查询500单");
        }

        var res = new List<GetTrackOutput>();
        input.OrderNos = input.OrderNos.Distinct().ToList(); // 单号去重
        var details = await _trackDetailsRepository.GetListAsync(input.OrderType, input.OrderNos);

        foreach (var group in details.GroupBy(x => x.OrderId))
        {
            var item = new GetTrackOutput();
            var trackDetails = group.ToList();
            item.OrderNo = trackDetails.First().OrderNo;

            item.TrackDetails = trackDetails.Select(x => new TrackDetail
            {
                Code = x.TrackCode,
                Status = x.TrackStatus,
                Content = x.TrackContent,
                Location = x.TrackPlace,
                Time = x.TrackTime.AddHours(input.TimeZone!.Value - x.TraceTimeZone),
                TimeZone = input.TimeZone!.Value
            }).ToList();

            res.Add(item);
        }

        await TrackDetailSort(res, input);

        return res;
    }

    #region 轨迹订单明细列表

    /// <summary>
    /// 根据轨迹订单id获取轨迹订单明细列表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("/Track/GetDetails")]
    public async Task<List<TrackOrderDetailDto>> GetOrderDetails(GetOrderDetailsInput input)
    {
        var trackDetails = await _trackDetailsRepository.GetListAsync(input.OrderId);
        if (!trackDetails.IsNullOrEmpty())
        {
            var list = ObjectMapper.Map<List<TrackDetailsIndex>, List<TrackOrderDetailDto>>(trackDetails);
            return list;
        }

        return new List<TrackOrderDetailDto>();
    }

    #endregion

    #region 轨迹订单分页

    /// <summary>
    /// 获取分页的轨迹订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("/Track/GetTrackOrderList")]
    public async Task<UnifyPageResultDto<TrackOrderDto>> GetPageTrackOrder(GetPageTrackOrderInput input)
    {
        var vo = ObjectMapper.Map<GetPageTrackOrderInput, GetPageTrackOrderInputVO>(input);
        var pageList = await _orderRepository.GetPageTrackOrder(vo);
        var pageResultDto =
            ObjectMapper.Map<UnifyPageResultDto<TrackOrderVO>, UnifyPageResultDto<TrackOrderDto>>(pageList);
        return pageResultDto;
    }

    #endregion

    private async Task TrackDetailSort(List<GetTrackOutput> list, GetTrackInput input)
    {
        switch (input.SortMethod)
        {
            case SortMethod.ByTrackTime:
                // tips：quick-sort 直接修改原list
                list.ForEach(item => item.TrackDetails.Sort((a, b) => a.Time.CompareTo(b.Time)));
                break;
            case SortMethod.ByTrackTimeDesc:
                list.ForEach(item => item.TrackDetails.Sort((a, b) => b.Time.CompareTo(a.Time)));
                break;
            case SortMethod.ByTemplate:
                var orderTemplates = await _provideQueries
                    .GetOrderTemplateLinksAsync(input.OrderType, input.OrderNos);
                var distinctTemplateIds = orderTemplates.Select(x => x.TemplateId).Distinct().ToList();
                var templateContent = await _provideQueries.GetOrderedTrackCodesAsync(distinctTemplateIds);
                list.ForEach(item =>
                {
                    var codes = new List<string>();
                    // 多模板拼接显示
                    foreach (var orderTemplate in orderTemplates.Where(x => x.OrderNo == item.OrderNo))
                    {
                        codes.AddRange(templateContent
                            .Where(t => t.TemplateId == orderTemplate.TemplateId)
                            .Select(t => t.Code));
                    }

                    item.TrackDetails = item.TrackDetails
                        .Where(x => codes.Contains(x.Code)) // 剔除不在模板内容中的元素
                        .OrderBy(x => codes.IndexOf(x.Code)) // 按照在模板内容的位置排序
                        .ToList();
                });
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(input.SortMethod), input.SortMethod, "不支持的排序方式");
        }
    }
}