track/src/SJZY.Track.Repository/Repositories/OrderRepository.cs

using SJZY.Track.Domain;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.Order;
using SJZY.Track.Domain.VEntities;
using SJZY.Track.Repository.VData.Entitys;

namespace SJZY.Track.Repository.Repositories;

public class OrderRepository : BasicRepository<OrderEntity>, IOrderRepository, ITransientDependency
{
    public async Task<bool> CreateOrderAsync(OrderEntity order)
    {
        return await Context.InsertNav(order)
            .Include(x => x.OrderFlights)
            .Include(x => x.OrderTemplates)
            .ExecuteCommandAsync();
    }

    public async Task UpdateOrderAsync(OrderEntity order)
    {
        using var tran = TransactionHelper.GetReadCommitted();

        // 更新订单主表
        await UpdateAsync(order, x => new { x.CustomId, x.SubSystemId });

        // 更新订单模板
        await Context.Deleteable<OrderTemplateEntity>().Where(x => x.OrderId == order.Id).ExecuteCommandAsync();
        order.OrderTemplates.ForEach(x => x.OrderId = order.Id);
        await Context.Insertable(order.OrderTemplates).ExecuteCommandAsync();

        // 更新订单航班
        await Context.Deleteable<OrderFlightEntity>().Where(x => x.OrderId == order.Id).ExecuteCommandAsync();
        order.OrderFlights.ForEach(x => x.OrderId = order.Id);
        await Context.Insertable(order.OrderFlights).ExecuteCommandAsync();

        tran.Complete();
    }

    public async Task DeleteOrderAsync(int orderId)
    {
        using var tran = TransactionHelper.GetReadCommitted();

        // 软删订单主表
        await SoftDeleteAsync(x => x.Id == orderId);

        // 软删订单模板
        // 软删订单航班
        // 软删订单关联关系

        tran.Complete();
    }

    #region 订单关联

    public async Task<List<LinkedOrderVO>> GetLinkedOrdersAsync(int orderId)
    {
        return await Context.Queryable<OrderEntity>()
            .LeftJoin<OrderLinkEntity>((a, b) => a.Id == b.OrderId)
            .Where(a => a.Id == orderId)
            .Select((a, b) => new LinkedOrderVO
            {
                OrderId = b.LinkOrderId,
                SubSystemId = a.SubSystemId
            })
            .ToListAsync();
    }

    public async Task LinkOrderAsync(List<OrderLinkEntity> orderLinkEntities)
    {
        await Context.Insertable(orderLinkEntities).ExecuteCommandAsync();
    }

    public async Task UnLinkByIdsAsync(List<int> linkIds)
    {
        await Context.Deleteable(linkIds).ExecuteCommandAsync();
    }

    #endregion

    #region 轨迹订单明细

    ///// <summary>
    ///// 根据轨迹订单id获取轨迹明细列表
    ///// </summary>
    ///// <param name="input"></param>
    ///// <returns></returns>
    //public async Task<List<TrackOrderDetailVO>> GetOrderDetails(GetOrderDetailsInputVO input)
    //{
    //    return null;
    //}

    #endregion

    #region 轨迹订单分页

    /// <summary>
    /// 获取分页的轨迹订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<UnifyPageResultDto<TrackOrderVO>> GetPageTrackOrder(GetPageTrackOrderInputVO input)
    {
        var pageList = await Context.Queryable<OrderEntity>()
            .LeftJoin<VExternalSubjectEntity>((a, b) => a.CustomId == b.Id && b.IsDeleted == false)
            .LeftJoin<VSystemEntity>((a, b, c) => a.SubSystemId == c.Id && c.IsDeleted == false)
            .WhereIF(input.SubSystemId > 0, (a, b, c) => a.SubSystemId == input.SubSystemId)
            .WhereIF(!input.OrderNos.IsNullOrEmpty(), (a, b, c) => input.OrderNos.Contains(a.OrderNo))
            .WhereIF(input.CreateTimeStart.HasValue && input.CreateTimeEnd.HasValue,
                (a, b, c) => a.CreateTime >= input.CreateTimeStart && a.CreateTime <= input.CreateTimeEnd)
            .WhereIF(input.CreateTimeStart.HasValue && (!input.CreateTimeEnd.HasValue),
                (a, b, c) => a.CreateTime >= input.CreateTimeStart)
            .WhereIF((!input.CreateTimeStart.HasValue) && input.CreateTimeEnd.HasValue,
                (a, b, c) => a.CreateTime <= input.CreateTimeEnd)
            .Select((a, b, c) => new TrackOrderVO
            {
                Id = a.Id,
                OrderNumber = a.OrderNo,
                OrderType = a.OrderType,
                OrderTypeName = SqlFunc.IF(a.OrderType == 1).Return("干线提单").ElseIF(a.OrderType == 2).Return("小包运单").ElseIF(a.OrderType == 3)
                    .Return("箱/袋单").ElseIF(a.OrderType == 4).Return("FBA订单").End(""),
                CustomerShortName = b.Abbreviation,
                CustomerCode = b.Code,
                TrackTemplateNames = SqlFunc.Subqueryable<OrderTemplateEntity>()
                    .LeftJoin<TrackTemplateEntity>((aa, bb) => aa.TrackTemplateId == bb.Id)
                    .Where((aa, bb) => a.Id == aa.OrderId).SelectStringJoin((aa, bb) => bb.Name, ","),
                NewestTrackContent = a.LatestTrackContent,
                NewestTrackEnContent = a.LatestTrackEnContent,
                NewestTrackPlace = a.LatestTrackPlace,
                NewestTrackTime = a.LatestTrackTime,
                IsFinish = a.IsCompleted,
                CreateTime = a.CreateTime,
                SubSystem = c.CnName
            })
            .ToPagedListAsync(input.PageIndex, input.PageSize);

        #region 暂时注释

        //if (pageList.List.Any())
        //{
        //    var orderIds = pageList.List.Select(a => a.Id);
        //    //查询轨迹模版


        //    var trackTemplateList = await Context.Queryable<OrderTemplateEntity>()
        //         .LeftJoin<TrackTemplateEntity>((a, b) => a.TrackTemplateId==b.Id)
        //         .Where((a, b) => orderIds.Contains(a.OrderId))
        //         .Select((a, b) => new { OrderId = a.OrderId, Name = b.Name })
        //         .ToListAsync();

        //    pageList.List.ForEach(a =>
        //    {
        //        var templateListOfOrderId = trackTemplateList.Where(b => b.OrderId== a.Id);
        //        a.TrackTemplateNames  = templateListOfOrderId.Select(c => c.Name).JoinAsString(",");
        //    });
        //}

        #endregion

        return pageList;
    }

    #endregion
}