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

using DotNetCore.CAP;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.Track.Application.Contract.Dtos.ProvideServices;
using SJZY.Track.Application.Contract.Services.ProvideServices;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.UserCenter.HttpApi.Services;

namespace SJZY.Track.Application.Services.ProvideServices;

/// <summary>
/// 订单服务
/// </summary>
[ApiExplorerSettings(GroupName = "提供接口")]
[Route("/ProviderService")]
public partial class OrderService : ApplicationService, IOrderService
{
    private readonly IOrderOperationRecordEsRepository _orderOperationRecordEsRepository;
    private readonly IOrderRepository _orderRepository;

    public OrderService(IOrderRepository orderRepository,
        ICapPublisher capPublisher, ITrackDetailsEsRepository trackDetailsEsRepository,
        IOrderOperationRecordEsRepository orderOperationRecordEsRepository)
    {
        _orderRepository = orderRepository;
        _orderOperationRecordEsRepository = orderOperationRecordEsRepository;
        _trackDetailsEsRepository = trackDetailsEsRepository;
        _capPublisher = capPublisher;
    }

    /// <summary>
    /// 新增、更新订单（存在就更新）
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("Order/Upsert")]
    public async Task<UnifyResultDto<IdBaseDto>> UpsertAsync(UpsertOrderInput input)
    {
        // 校验订单是否已存在，存在则更新
        var order = await _orderRepository.GetFirstAsync(x =>
            x.SubSystemId == input.SubSystemId && x.OrderType == input.OrderType && x.OrderNo == input.OrderNo);
        if (order != default)
        {
            // 订单已存在则视为更新
            await UpdateOrderAsync(input, order);

            var index = new OrderOperationRecordIndex
            {
                OrderId = order.Id,
                OrderNo = input.OrderNo,
                OptionType = OptionType.修改.ToString(),
                Content = input.ToJson(),
            };

            _ = _orderOperationRecordEsRepository.AddAsync(index);

            return new UnifyResultDto<IdBaseDto>(true, new IdBaseDto
            {
                Id = order.Id
            });
        }

        order = ObjectMapper.Map<UpsertOrderInput, OrderEntity>(input);
        order.SubSystemId = input.SubSystemId;
        order.OrderFlights = ObjectMapper.Map<List<OrderFlightInfo>, List<OrderFlightEntity>>(input.FlightInfos);
        order.OrderPullStatus = BuiltOrderPullStatus(input.PullConfigInfos);

        var orderId = await _orderRepository.CreateOrderAsync(order);

        // 写入操作日志
        var indexForAdd = new OrderOperationRecordIndex
        {
            OrderId = orderId,
            OrderNo = input.OrderNo,
            OptionType = OptionType.新增.ToString(),
            Content = input.ToJson(),
            CreateUserId = CurrentUserRequest.CurrentUser.UserId,
            CreateTime = DateTime.Now
        };
        _ = _orderOperationRecordEsRepository.AddAsync(indexForAdd);


        return new UnifyResultDto<IdBaseDto>(true, new IdBaseDto
        {
            Id = orderId
        });
    }

    /// <summary>
    /// 删除订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Order/Delete")]
    public async Task<UnifyResultDto<IdBaseDto>> DeleteOrderAsync(DeleteOrderInput 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}不存在");
        }

        await _orderRepository.DeleteOrderAsync(orderId);

        return new UnifyResultDto<IdBaseDto>(true, new IdBaseDto
        {
            Id = orderId
        });
    }

    private async Task UpdateOrderAsync(UpdateOrderInput input, OrderEntity order)
    {
        order = ObjectMapper.Map(input, order);
        order.OrderFlights = ObjectMapper.Map<List<OrderFlightInfo>, List<OrderFlightEntity>>(input.FlightInfos);
        await _orderRepository.UpdateOrderAsync(order);
    }


    private List<OrderPullStatusEntity> BuiltOrderPullStatus(List<PullConfigInfo>? pullConfigInfos)
    {
        if (pullConfigInfos == null) return new List<OrderPullStatusEntity>();

        return pullConfigInfos.Select(x =>
        {
            var status = new OrderPullStatusEntity
            {
                ServiceProviderCode = x.ServiceCode,
                PullStatus = TrackPullStatus.Init,
                StartTrackCode = x.StartCode ?? GlobalConst.EmptyString,
                EndTrackCode = x.EndCode ?? GlobalConst.EmptyString,
                SilenceBeforeStart = x.SilenceTime,
                SilenceAfterEnd = x.StopTime,
                StartTime = GlobalConst.MaxDateTime,
                EndTime = GlobalConst.MaxDateTime,
            };

            // 没有开始轨迹则立即进入拉取前静默期
            if (x.StartCode == null)
            {
                status.PullStatus = TrackPullStatus.SilenceBeforeStart; // 会被定时任务扫描到并启动
                status.StartTime = DateTime.Now.AddHours(x.SilenceTime);
            }

            return status;
        }).ToList();
    }
}