track/src/SJZY.Track.Repository/Queries/ProvideQueries.cs

using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackStatusAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.Order;
using SJZY.Track.Domain.Dtos.TrackContents;
using SJZY.Track.Domain.Dtos.TrackDetails;
using SJZY.Track.Domain.Dtos.TrackTemplate;
using SJZY.Track.Domain.Queries;
using SJZY.Track.Domain.VEntities;

namespace SJZY.Track.Repository.Queries;

public class ProvideQueries : ISugarRepository, IProvideQueries,
    ITransientDependency
{
    public ISqlSugarClient Context { get; set; }

    public ProvideQueries()
    {
        Context = SqlsugarScopeBasic.GetContextSafely("default");
    }

    public async Task<List<OrderTemplateLinkDto>> GetOrderTemplateLinksAsync(int orderType, List<string> orderNumbers)
    {
        return await Context.Queryable<OrderEntity>()
            .LeftJoin<OrderTemplateEntity>((a, b) => a.Id == b.OrderId)
            .Where(a => a.OrderType == orderType && orderNumbers.Contains(a.OrderNo))
            .Select((a, b) => new OrderTemplateLinkDto
            {
                OrderNo = a.OrderNo,
                TemplateId = b.TrackTemplateId
            })
            .ToListAsync();
    }

    public async Task<List<OrderedTrackCodeDto>> GetOrderedTrackCodesAsync(List<int> templateIds)
    {
        return await Context.Queryable<TrackTemplateEntity>()
            .LeftJoin<TrackTemplateContentEntity>((a, b) => a.Id == b.TrackTemplateId)
            .LeftJoin<TrackContentEntity>((a, b, c) => b.TrackContentId == c.Id)
            .Where(a => templateIds.Contains(a.Id))
            .OrderBy((a, b) => b.Sort)
            .Select((a, b, c) => new OrderedTrackCodeDto
            {
                TemplateId = a.Id,
                ShowOrigin = a.ShowOrigin,
                Code = c.Code,
                IsExternal = b.IsExternal
            })
            .ToListAsync();
    }

    public async Task<List<MatchTrackContentDto>> MatchTrackContentAsync(int[] orderIds, string code)
    {
        if (orderIds.Length == 0) return new List<MatchTrackContentDto>();
        return await Context.Queryable<OrderTemplateEntity>()
            .LeftJoin<TrackTemplateContentEntity>((x, a) => x.TrackTemplateId == a.TrackTemplateId)
            .LeftJoin<TrackContentEntity>((x, a, b) => a.TrackContentId == b.Id)
            .LeftJoin<TrackStatusEntity>((x, a, b, c) => b.TrackStatusId == c.Id)
            .Where((x, a, b) => orderIds.Contains(x.OrderId) && b.Code == code)
            .Select((x, a, b, c) => new MatchTrackContentDto
            {
                OrderId = x.OrderId,
                TrackCode = b.Code,
                Content = b.Content,
                EnContent = b.EnContent,
                Status = c.Status,
                IsCanDelete = a.IsCanDelete
            })
            .ToListAsync();
    }

    public async Task<List<CanDeleteTrackCodeVO>> GetCanDeleteTrackCodesAsync(List<int> orderIds,
        List<string> trackCodes)
    {
        return await Context.Queryable<OrderTemplateEntity>()
            .LeftJoin<TrackTemplateContentEntity>((x, a) => x.TrackTemplateId == a.TrackTemplateId && a.IsCanDelete)
            .LeftJoin<TrackContentEntity>((x, a, b) => a.TrackContentId == b.Id)
            .Where((x, a, b) => orderIds.Contains(x.OrderId)
                                && trackCodes.Contains(b.Code) && a.IsCanDelete)
            .Select((x, a, b) => new CanDeleteTrackCodeVO
            {
                OrderId = x.OrderId,
                TrackCode = b.Code
            })
            .ToListAsync();
    }

    public async Task<List<string>> MapTrackCodesAsync(int upSubSystemId, int subSystemId, params string[] trackCodes)
    {
        // 根据上游code得到下游code
        return await Context.Queryable<TrackContentMapEntity>()
            .Where(x => x.SubSystemId == subSystemId && x.MapSubSystemId == upSubSystemId &&
                        trackCodes.Contains(x.MapTrackContentCode))
            .Select(x => x.TrackContentCode)
            .ToListAsync();
    }


    public async Task<List<OrderWithServiceProviderVO>> FindOrderWithServiceProviderAsync(List<string> orderNos)
    {
        return await Context.Queryable<OrderEntity>()
            .LeftJoin<OrderTemplateEntity>((a, b) => a.Id == b.OrderId)
            .LeftJoin<VServiceProviderEntity>((a, b, c) => b.ServiceProviderId == c.Id)
            .Where(a => !a.IsCompleted && orderNos.Contains(a.OrderNo))
            .Select((a, b, c) => new OrderWithServiceProviderVO
            {
                OrderNo = a.OrderNo,
                OrderType = a.OrderType,
                ServiceProviderId = b.ServiceProviderId,
                ServiceProviderCode = c.Code,
                ServiceProviderName = c.Name,
                SubSystemId = a.SubSystemId
            })
            .ToListAsync();
    }

    public async Task<List<OrderWithServiceProviderVO>> FindOrderWithServiceProviderAsync(int serviceProvider,
        int pageIndex, int pageSize = 1000)
    {
        return await Context.Queryable<OrderEntity>()
            .RightJoin<OrderTemplateEntity>((a, b) => a.Id == b.OrderId)
            .LeftJoin<VServiceProviderEntity>((a, b, c) => b.ServiceProviderId == c.Id)
            .Where((a, b) => b.ServiceProviderId == serviceProvider && !a.IsCompleted)
            .Select((a, b, c) => new OrderWithServiceProviderVO
            {
                OrderNo = a.OrderNo,
                OrderType = a.OrderType,
                ServiceProviderId = b.ServiceProviderId,
                ServiceProviderCode = c.Code,
                ServiceProviderName = c.Name,
                SubSystemId = a.SubSystemId
            })
            .Skip((pageIndex - 1) * pageSize)
            .Take(pageSize)
            .ToListAsync();
    }

    public async Task<TrackContentVO?> GetTrackContentAsync(int subSystemId, string trackCode)
    {
        return await Context.Queryable<TrackContentEntity>()
            .LeftJoin<TrackStatusEntity>((x, y) => x.TrackStatusId == y.Id)
            .Where(x => x.SubSystemId == subSystemId && x.Code == trackCode)
            .Select((x, y) => new TrackContentVO
            {
                TrackStatus = y.Status,
                TrackContent = x.Content,
                TrackEnContent = x.EnContent
            })
            .FirstAsync();
    }
}