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.TrackFlagAggregate;
using SJZY.Track.Domain.Aggregates.TrackPullAggregate;
using SJZY.Track.Domain.Aggregates.TrackStatusAggregate;
using SJZY.Track.Domain.Dtos.Order;
using SJZY.Track.Domain.Dtos.TrackContents;
using SJZY.Track.Domain.Dtos.TrackPull;
using SJZY.Track.Domain.Queries;
using SJZY.Track.Domain.VEntities;

namespace SJZY.Track.Repository.Queries;

/// <summary>
/// 提供服务相关查询
/// </summary>
public class ProvideQueries : ISugarRepository, IProvideQueries, ITransientDependency
{
    /// <summary>
    /// ctor
    /// </summary>
    public ProvideQueries()
    {
        Context = SqlsugarScopeBasic.GetContextSafely("default");
    }

    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<TrackCodeMapVO>> GetTrackCodeMapsAsync(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 => new TrackCodeMapVO()
            {
                SubSystemId = x.SubSystemId,
                TrackContentCode = x.TrackContentCode,
                MapSubSystemId = x.MapSubSystemId,
                MapTrackContentCode = x.MapTrackContentCode
            })
            .ToListAsync();
    }

    /// <inheritdoc />
    public async Task<List<OrderWithServiceProviderVO>> FindOrderWithServiceProviderAsync(int subSystemId,
        List<string> orderNos)
    {
        return await Context.Queryable<OrderEntity>()
            .InnerJoin<OrderPullStatusEntity>((a, b) => a.Id == b.OrderId)
            .LeftJoin<VSystemEntity>((a, b, c) => a.SubSystemId == c.Id)
            .WhereIF(subSystemId > 0, a => a.SubSystemId == subSystemId)
            .Where((a, b) => !a.IsCompleted && orderNos.Contains(a.OrderNo)
                                            && b.StartTime <= DateTime.Now && b.EndTime >= DateTime.Now)
            .Select((a, b, c) => new OrderWithServiceProviderVO
            {
                //优先使用第三方的订单号,为空时才使用主单号
                OrderNo = b.OrderNo ?? a.OrderNo,
                OrderType = a.OrderType,
                SubSystemId = a.SubSystemId,
                ServiceProviderCode = b.ServiceProviderCode,
                SubSystemCode = c.Key
            })
            .ToListAsync();
    }

    public async Task<List<OrderWithServiceProviderVO>> FindOrderWithServiceProviderAsync(
        string serviceProviderCode,
        int pageIndex, int pageSize = 1000)
    {
        return await Context.Queryable<OrderEntity>()
            .InnerJoin<OrderPullStatusEntity>((a, b) => a.Id == b.OrderId)
            .Where((a, b) => b.ServiceProviderCode == serviceProviderCode && !a.IsCompleted
                                                                          && b.StartTime <= DateTime.Now &&
                                                                          b.EndTime >= DateTime.Now)
            .Select((a, b) => new OrderWithServiceProviderVO
            {
                //优先使用第三方的订单号,为空时才使用主单号
                OrderNo = b.OrderNo ?? a.OrderNo,
                OrderType = a.OrderType,
                SubSystemId = a.SubSystemId,
                ServiceProviderCode = b.ServiceProviderCode
            })
            .Skip((pageIndex - 1) * pageSize)
            .Take(pageSize)
            .ToListAsync();
    }

    /// <inheritdoc />
    public async Task<TrackContentVO?> GetTrackContentAsync(int subSystemId, string trackCode)
    {
        return await Context.Queryable<TrackContentEntity>()
            .LeftJoin<TrackStatusEntity>((x, y) => x.TrackStatusId == y.Id)
            .LeftJoin<VSystemEntity>((x, y, z) => x.SubSystemId == z.Id)
            .LeftJoin<TrackFlagEntity>((x, y, z, k) => x.SubSystemId == k.SubSystemId && k.Code == x.Code)
            .Where(x => x.SubSystemId == subSystemId && x.Code == trackCode)
            .Select((x, y, z, k) => new TrackContentVO
            {
                SubSystemId = x.SubSystemId,
                SubSystemCode = z.Key,
                TrackStatusId = x.TrackStatusId,
                TrackStatus = y.Status,
                TrackStatusCode = y.Code,
                TrackContentCode = x.Code,
                TrackContentId = x.Id,
                TrackContent = x.Content,
                TrackEnContent = x.EnContent,
                IsCompleted = y.IsCompleted,
                IsRepeatable = x.IsRepeatable,
                IsExternal = x.IsExternal,
                IsAllowManuallyUpdate = x.IsAllowManuallyUpdate,
                IsAllowManuallyCreate = x.IsAllowManuallyCreate,
                IsToMq = y.IsToMq || k.IsToMq,
            })
            .FirstAsync();
    }

    public async Task<List<TrackContentVO>> GetTrackContentsAsync(int[] subSystemIds, string[] trackCodes)
    {
        return await Context.Queryable<TrackContentEntity>()
            .LeftJoin<TrackStatusEntity>((x, y) => x.TrackStatusId == y.Id)
            .LeftJoin<VSystemEntity>((x, y, z) => x.SubSystemId == z.Id)
            .LeftJoin<TrackFlagEntity>((x, y, z, k) => x.SubSystemId == k.SubSystemId && k.Code == x.Code)
            .Where(x => subSystemIds.Contains(x.SubSystemId) && trackCodes.Contains(x.Code))
            .Select((x, y, z, k) => new TrackContentVO
            {
                SubSystemId = x.SubSystemId,
                SubSystemCode = z.Key,
                TrackStatusId = x.TrackStatusId,
                TrackStatus = y.Status,
                TrackStatusCode = y.Code,
                TrackContentCode = x.Code,
                TrackContentId = x.Id,
                TrackContent = x.Content,
                TrackEnContent = x.EnContent,
                IsCompleted = y.IsCompleted,
                IsRepeatable = x.IsRepeatable,
                IsExternal = x.IsExternal,
                IsAllowManuallyUpdate = x.IsAllowManuallyUpdate,
                IsAllowManuallyCreate = x.IsAllowManuallyCreate,
                IsToMq = y.IsToMq || k.IsToMq,
            })
            .ToListAsync();
    }

    public async Task<List<TrackPullConfigVo>> GetAllPullConfigsAsync()
    {
        return await Context.Queryable<TrackPullConfigEntity>()
            .LeftJoin<VServiceProviderEntity>((a, b) => a.ServiceProviderId == b.Id)
            .LeftJoin<VSystemEntity>((a, b, c) => a.SubSystemId == c.Id)
            .Select((a, b, c) => new TrackPullConfigVo
            {
                PullInterval = a.PullInterval,
                ServiceProviderId = a.ServiceProviderId,
                ServiceProviderCode = b.Code,
                SubSystemCode = c.Key,
                SubSystemId = c.Id
            })
            .ToListAsync();
    }

    public async Task<string> SubSystemId2CodeAsync(int subSystemId)
    {
        return await Context.Queryable<VSystemEntity>()
            .Where(x => x.Id == subSystemId)
            .Select(x => x.Key)
            .FirstAsync();
    }

    /// <summary>
    /// db context
    /// </summary>
    public ISqlSugarClient Context { get; set; }
}