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

using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackFlagAggregate;
using SJZY.Track.Domain.Aggregates.TrackStatusAggregate;
using SJZY.Track.Domain.Dtos.TrackContents;
using SJZY.Track.Domain.VEntities;

namespace SJZY.Track.Repository.Repositories;

public class TrackContentRepository : BasicRepository<TrackContentEntity>, ITrackContentRepository, IScopedDependency
{
    public TrackContentRepository()
    {
    }

    /// <summary>
    /// 获取轨迹内容明细
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<GetTrackContentDetailVO?> GetDetailAsync(int id)
    {
        var detail = await Context.Queryable<TrackContentEntity>()
            .LeftJoin<TrackStatusEntity>((a, b) => a.TrackStatusId == b.Id && b.IsDeleted == false)
            .LeftJoin<TrackFlagEntity>((a, b, c) => a.TrackFlagId == c.Id && c.IsDeleted == false)
            .LeftJoin<VSystemEntity>((a, b, c, d) => a.SubSystemId == d.Id && d.IsDeleted == false)
            .Where((a, b, c, d) => a.Id == id)
            .Select((a, b, c, d) => new GetTrackContentDetailVO
            {
                Id = a.Id,
                SubSystemId = a.SubSystemId,
                SubSystem = d.CnName,
                TrackStatusId = a.TrackStatusId,
                TrackStatus = b.Status,
                Code = a.Code,
                Content = a.Content,
                EnContent = a.EnContent,
                TrackFlagId = a.TrackFlagId,
                TrackFlag = c.Name
            })
            .FirstAsync();
        return detail;
    }

    /// <summary>
    /// 分页获取轨迹内容
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<UnifyPageResultDto<GetTrackContentListVO>> GetPageTrackContent(GetPageTrackContentVO input)
    {
        UnifyPageResultDto<GetTrackContentListVO> pagedList = new UnifyPageResultDto<GetTrackContentListVO>();
        pagedList = await Context.Queryable<TrackContentEntity>()
            .LeftJoin<TrackStatusEntity>((a, b) => a.TrackStatusId == b.Id && b.IsDeleted == false)
            .LeftJoin<TrackFlagEntity>((a, b, c) => a.TrackFlagId == c.Id && c.IsDeleted == false)
            .LeftJoin<VSystemEntity>((a, b, c, d) => a.SubSystemId == d.Id && d.IsDeleted == false)
            .LeftJoin<VUserEntity>((a, b, c, d, e) => a.CreateUserId == e.Id && e.IsDeleted == false)
            .LeftJoin<VUserEntity>((a, b, c, d, e, f) => a.UpdateUserId == f.Id && f.IsDeleted == false)
            .WhereIF(input.SubSystemId > 0, (a, b, c, d, e, f) => a.SubSystemId == input.SubSystemId)
            .WhereIF(!input.Keywords.IsNullOrWhiteSpace(),
                (a, b, c, d, e, f) => a.Code.Contains(input.Keywords) || a.Content.Contains(input.Keywords)
                || a.EnContent.Contains(input.Keywords)
                                )
            .OrderByIF(input.SelectIds.IsNullOrEmpty(), (a, b, c, d, e, f) => a.CreateTime, OrderByType.Desc)
            .OrderByIF(!input.SelectIds.IsNullOrEmpty(), (a, b, c, d, e, f) => SqlFunc.IIF(input.SelectIds.Contains(a.Id), SqlFunc.DateAdd(SqlFunc.GetDate(), 1), a.CreateTime), OrderByType.Desc)
            .Select((a, b, c, d, e, f) => new GetTrackContentListVO
            {
                Id = a.Id,
                SubSystem = d.CnName,
                Code = a.Code,
                Content = a.Content,
                EnContent = a.EnContent,
                TrackStatus = b.Status,
                Node = SqlFunc.IF(b.Node == 1).Return("揽收").ElseIF(b.Node == 2).Return("干线").ElseIF(b.Node == 3).Return("清关")
                .ElseIF(b.Node == 4).Return("中转").ElseIF(b.Node == 5).Return("派送")
                .End(""),
                TrackFlag = c.Name,
                CreateTime = a.CreateTime,
                CreateUser = e.Name,
                UpdateTime = a.UpdateTime,
                UpdateUser = f.Name
            })
            .ToPagedListAsync(input.PageIndex, input.PageSize);

        var ff = await Context.Queryable<TrackContentEntity>().Where(a => 1 == 1).ToListAsync();

        return pagedList;
    }

    public async Task<UnifyPageResultDto<GetTrackContentMapPageOutputVO>> GetMapPageAsync(GetTrackContentMapPageInputVO input)
    {
        return await Context.Queryable<TrackContentMapEntity>()
            .InnerJoin<TrackContentEntity>((contentMap, sourceContent) => contentMap.TrackContentId == sourceContent.Id && !sourceContent.IsDeleted)
            .InnerJoin<TrackContentEntity>((contentMap, sourceContent, targetContent) => contentMap.MapTrackContentId == targetContent.Id && !targetContent.IsDeleted)
            .LeftJoin<VSystemEntity>((contentMap, sourceContent, targetContent, sourceSystem) => contentMap.SubSystemId == sourceSystem.Id && !sourceSystem.IsDeleted)
            .LeftJoin<VSystemEntity>((contentMap, sourceContent, targetContent, sourceSystem, targetSystem) => contentMap.MapSubSystemId == targetSystem.Id && !targetSystem.IsDeleted)
            .LeftJoin<TrackStatusEntity>((contentMap, sourceContent, targetContent, sourceSystem, targetSystem, sourceStatus) => sourceContent.TrackStatusId == sourceStatus.Id && !sourceStatus.IsDeleted)
            .LeftJoin<TrackStatusEntity>((contentMap, sourceContent, targetContent, sourceSystem, targetSystem, sourceStatus, targetStatus) => targetContent.TrackStatusId == targetStatus.Id && !targetStatus.IsDeleted)
            .Filter(null, true)
            .Where(contentMap => !contentMap.IsDeleted)
            .WhereIF(input.SubSystemId.HasValue, contentMap => contentMap.SubSystemId == input.SubSystemId)
            .WhereIF(input.MapSubSystemId.HasValue, contentMap => contentMap.MapSubSystemId == input.MapSubSystemId)
            .WhereIF(!input.Keywords.IsNullOrWhiteSpace(), (contentMap, sourceContent) => sourceContent.Code.Contains(input.Keywords) || sourceContent.Content.Contains(input.Keywords) || sourceContent.EnContent.Contains(input.Keywords))
            .OrderByDescending(contentMap => contentMap.CreateTime)
            .Select((contentMap, sourceContent, targetContent, sourceSystem, targetSystem, sourceStatus, targetStatus) => new GetTrackContentMapPageOutputVO
            {
                Id = contentMap.Id,
                SubSystem = sourceSystem.CnName,
                Code = contentMap.TrackContentCode,
                TrackStatus = sourceStatus.Status,
                Content = sourceContent.Content,
                EnContent = sourceContent.EnContent,
                MapSubSystem = targetSystem.CnName,
                MapCode = contentMap.MapTrackContentCode,
                MapTrackStatus = targetStatus.Status,
                MapContent = targetContent.Content,
                MapEnContent = targetContent.EnContent
            })
            .ToPagedListAsync(input.PageIndex, input.PageSize);
    }

    public async Task<GetTrackContentMapDetailOutputVO> GetMapDetailAsync(int id)
    {
        return await Context.Queryable<TrackContentMapEntity>()
            .InnerJoin<TrackContentEntity>((contentMap, sourceContent) => contentMap.TrackContentId == sourceContent.Id && !sourceContent.IsDeleted)
            .InnerJoin<TrackContentEntity>((contentMap, sourceContent, targetContent) => contentMap.MapTrackContentId == targetContent.Id && !targetContent.IsDeleted)
            .LeftJoin<VSystemEntity>((contentMap, sourceContent, targetContent, sourceSystem) => contentMap.SubSystemId == sourceSystem.Id && !sourceSystem.IsDeleted)
            .LeftJoin<VSystemEntity>((contentMap, sourceContent, targetContent, sourceSystem, targetSystem) => contentMap.MapSubSystemId == targetSystem.Id && !targetSystem.IsDeleted)
            .Filter(null, true)
            .Where(contentMap => !contentMap.IsDeleted)
            .Select((contentMap, sourceContent, targetContent, sourceSystem, targetSystem) => new GetTrackContentMapDetailOutputVO
            {
                Id = contentMap.Id,
                SubSystemId = contentMap.SubSystemId,
                SubSystem = sourceSystem.CnName,
                TrackContent = contentMap.TrackContentCode + "-" + sourceContent.Content,
                MapSubSystem = targetSystem.CnName,
                MapTrackContent = contentMap.MapTrackContentCode + "-" + targetContent.Content
            }, true)
            .SingleAsync();
    }
}