track/src/SJZY.Track.Application/Services/TrackOrders/TrackOrderService.cs

using SJZY.Track.Application.Contract.Dtos.ProvideServices;
using SJZY.Track.Application.Contract.Dtos.TrackOrder;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Aggregates.TrackPushAggregate;
using SJZY.Track.Domain.Consts;
using SJZY.Track.Domain.Dtos.Order;
using SJZY.Track.Domain.Enums;
using SJZY.Track.Domain.Queries;

namespace SJZY.Track.Application.Services.TrackOrders;

[ApiExplorerSettings(GroupName = "轨迹订单")]
[Route("/Track/Order")]
public class TrackOrderService : ApplicationService
{
    private readonly IOrderOperationRecordRepository _orderOperationRecordRepository;
    private readonly IOrderRepository _orderRepository;
    private readonly ITrackContentRepository _trackContentRepository;
    private readonly ITrackDetailsRepository _trackDetailsRepository;
    private readonly ITrackOrderQueries _trackOrderQueries;
    private readonly ITrackPushRecordsRepository _trackPushRecordsRepository;

    public TrackOrderService(
        IOrderRepository orderRepository,
        ITrackOrderQueries trackOrderQueries,
        ITrackDetailsRepository trackDetailsRepository,
        ITrackContentRepository trackContentRepository,
        ITrackPushRecordsRepository trackPushRecordsRepository,
        IOrderOperationRecordRepository orderOperationRecordRepository)
    {
        _orderRepository = orderRepository;
        _trackOrderQueries = trackOrderQueries;
        _trackDetailsRepository = trackDetailsRepository;
        _trackContentRepository = trackContentRepository;
        _trackPushRecordsRepository = trackPushRecordsRepository;
        _orderOperationRecordRepository = orderOperationRecordRepository;
    }

    #region 轨迹订单列表

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

    #endregion

    [HttpPost("UpdateOrderStatus")]
    public async Task<bool> UpdateOrderStatus(UpdateOrderStatusInput input)
    {
        var order = await _orderRepository.GetFirstAsync(x => x.Id == input.OrderId);

        if (order == default) throw new BusinessException(message: "订单不存在");

        order.IsCompleted = input.IsCompleted;

        return await _orderRepository.UpdateColumnAsync(order, x => new
        {
            x.IsCompleted
        });
    }

    /// <summary>
    /// 获取轨迹计数器
    /// </summary>
    /// <returns></returns>
    [HttpGet("GetTrackCounter")]
    public async Task<GetTrackCounterOutput> GetTrackCounterAsync()
    {
        var counts = await _trackOrderQueries.GetTrackProblemCountsAsync();

        return new GetTrackCounterOutput
        {
            TotalCount = counts.Sum(x => x.Count),
            ErrorCount = counts.FirstOrDefault(x => x.ProblemType == (int) TrackProblemType.Error)?.Count ?? 0,
            WarnCount = counts.FirstOrDefault(x => x.ProblemType == (int) TrackProblemType.Warn)?.Count ?? 0,
        };
    }

    /// <summary>
    /// 获取轨迹推送记录
    /// </summary>
    /// <returns></returns>
    /// <param name="orderId">订单id</param>
    [HttpGet("GetTrackPushRecords")]
    public async Task<List<TrackPushRecordOutput>> GetTrackPushRecordsAsync(int orderId)
    {
        var records = await _trackPushRecordsRepository.GetTrackPushRecordsAsync(orderId);

        var res = ObjectMapper.Map<List<TrackPushRecordIndex>, List<TrackPushRecordOutput>>(records);

        res.ForEach(x =>
        {
            int hours = (int) x.TrackTimeZone; // 提取整数部分作为小时
            int minutes = (int) ((x.TrackTimeZone - hours) * 60); // 将小数部分乘以 60 转换为分钟
            x.TrackGTMTimeZone =
                $"GTM {(x.TrackTimeZone >= 0 ? "+" : "-")}{new TimeSpan(hours, minutes, 0).ToString().RemovePostFix(":00")}";
        });

        return res;
    }

    /// <summary>
    /// 根据订单id获取轨迹明细列表
    /// </summary>
    /// <param name="orderId"></param>
    /// <returns></returns>
    [HttpPost("GetDetails")]
    public async Task<List<TrackOrderDetailDto>> GetTracksAsync(int orderId)
    {
        var subSystemId = await _orderRepository.GetFirstAsync(x => x.Id == orderId, x => x.SubSystemId);
        if (subSystemId == default)
        {
            throw new BusinessException(message: "订单不存在");
        }

        var trackDetails = await _trackDetailsRepository.GetListAsync(orderId);
        if (trackDetails.IsNullOrEmpty())
        {
            return new List<TrackOrderDetailDto>();
        }

        var list = ObjectMapper.Map<List<TrackDetailsIndex>, List<TrackOrderDetailDto>>(trackDetails);

        var trackCodes = list.Select(x => x.Code)
            .Where(x => x != GlobalConst.EmptyString)
            .Distinct()
            .ToList();

        // 是否对外
        if (!trackCodes.IsNullOrEmpty())
        {
            var trackContents = await _trackContentRepository.GetListAsync(x =>
                x.SubSystemId == subSystemId && trackCodes.Contains(x.Code), x => new
            {
                x.Code,
                x.IsExternal
            });

            list.ForEach(x => x.IsExternal = trackContents.FirstOrDefault(y => y.Code == x.Code)?.IsExternal ?? false);
        }

        // 计算时区
        list.ForEach(a =>
        {
            if (a.TrackTimeZoneValue == 0f)
            {
                a.TrackTimeZone = "GTM +00:00";
            }
            else if (Math.Abs(a.TrackTimeZoneValue - GlobalConst.NoneTrackTimeZone) < 1)
            {
                a.TrackTimeZone = "--";
            }
            else
            {
                // 将小数形式的小时转换为时区偏移量
                var hours = (int) a.TrackTimeZoneValue; // 提取整数部分作为小时
                var minutes = (int) ((a.TrackTimeZoneValue - hours) * 60); // 将小数部分乘以 60 转换为分钟
                var offset = new TimeSpan(hours, minutes, 0);
                var timeZoneStr = offset.ToString();
                var flag = a.TrackTimeZoneValue > 0f ? "+" : "";
                a.TrackTimeZone = $"GTM {flag}{timeZoneStr.RemovePostFix(":00")}";
            }
        });
        return list;
    }

    /// <summary>
    /// 根据轨迹id删除单条轨迹
    /// </summary>
    /// <param name="trackId">轨迹id</param>
    /// <returns></returns>
    [HttpPost("DeleteTrackById")]
    public async Task<bool> DeleteTrackByIdAsync(string trackId)
    {
        var track = await _trackDetailsRepository.GetByIdAsync(trackId);

        // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
        if (track == null)
        {
            throw new BusinessException(message: "轨迹不存在！");
        }

        await _trackDetailsRepository.DeleteTrackByIdAsync(trackId, track.IndexName);
        return true;
    }

    /// <summary>
    /// 根据订单id查询订单操作记录
    /// </summary>
    /// <param name="orderId">订单id</param>
    /// <returns></returns>
    [HttpGet("GetOrderOperationsById")]
    public async Task<List<OrderOperationRecordIndex>> GetOrderOperationsByIdAsync(int orderId)
    {
        // todo：分页？dto？
        return await _orderOperationRecordRepository.GetOrderOperationsByIdAsync(orderId);
        ;
    }
}