252 lines
11 KiB
C#
252 lines
11 KiB
C#
using System.Linq.Expressions;
|
|
using SJZY.Expand.ABP.Core.PublicMethords;
|
|
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
|
|
using SJZY.Track.Domain.Aggregates.TrackFlagAggregate;
|
|
using SJZY.Track.Domain.Aggregates.TrackNodeAggregate;
|
|
using SJZY.Track.Domain.Aggregates.TrackStatusAggregate;
|
|
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
|
|
using SJZY.Track.Domain.Dtos.TrackTemplate;
|
|
using SJZY.Track.Domain.Enums;
|
|
using SJZY.Track.Domain.VEntities;
|
|
using SJZY.Expand.ABP.Core.SqlSugar.Tools;
|
|
|
|
namespace SJZY.Track.Repository.Repositories;
|
|
|
|
public class TrackTemplateRepository : BasicRepository<TrackTemplateEntity>, ITrackTemplateRepository, IScopedDependency
|
|
{
|
|
/// <summary>
|
|
/// 获取轨迹模版明细
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public async Task<GetTrackTemplateDetailVO?> GetDetailAsync(int id)
|
|
{
|
|
var detail = await Context.Queryable<TrackTemplateEntity>()
|
|
.LeftJoin<VSystemEntity>((a, b) => a.SubSystemId == b.Id && b.IsDeleted == false)
|
|
.Where((a, b) => a.Id == id)
|
|
.Select((a, b) => new GetTrackTemplateDetailVO
|
|
{
|
|
Id = a.Id,
|
|
Code = a.Code,
|
|
Name = a.Name,
|
|
SubSystemId = a.SubSystemId,
|
|
SubSystem = b.CnName,
|
|
CustomerId = a.CustomerId,
|
|
CategoryId = a.CategoryId,
|
|
}).FirstAsync();
|
|
|
|
return detail;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 分页获取轨迹模版
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
public async Task<UnifyPageResultDto<GetTrackTemplateListVO>> GetPageTrackTemplate(GetPageTrackTemplateVO input)
|
|
{
|
|
var pagedList = await Context.Queryable<TrackTemplateEntity>()
|
|
.LeftJoin<VSystemEntity>((a, b) => a.SubSystemId == b.Id && b.IsDeleted == false)
|
|
.WhereIF(input.SubSystemId > 0, (a, b) => a.SubSystemId == input.SubSystemId)
|
|
.WhereIF(!input.Keywords.IsNullOrWhiteSpace(),
|
|
(a, b) => a.Name.Contains(input.Keywords!) || a.Code.Contains(input.Keywords!))
|
|
.OrderByIF(input.SelectIds.IsNullOrEmpty(), (a, b) => a.CreateTime, OrderByType.Desc)
|
|
.OrderByIF(!input.SelectIds.IsNullOrEmpty(),
|
|
(a, b) => SqlFunc.IIF(input.SelectIds!.Contains(a.Id), SqlFunc.DateAdd(SqlFunc.GetDate(), 1),
|
|
a.CreateTime), OrderByType.Desc)
|
|
.Select((a, b) => new GetTrackTemplateListVO
|
|
{
|
|
Id = a.Id,
|
|
Code = a.Code,
|
|
CreateTime = a.CreateTime,
|
|
Name = a.Name,
|
|
SubSystem = b.CnName,
|
|
SubSystemId = b.Id
|
|
})
|
|
.ToPagedListAsync(input.PageIndex, input.PageSize);
|
|
//.OrderByIF(input.TrackTemplateId > 0,
|
|
// (a, b) => SqlFunc.IIF(a.Id == input.TrackTemplateId, SqlFunc.DateAdd(SqlFunc.GetDate(), 1),
|
|
//a.CreateTime), OrderByType.Desc)
|
|
return pagedList;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task<UnifyPageResultDto<GetTrackTemplateContentPageOutputVO>> GetContentPageAsync(
|
|
GetTrackTemplateContentPageInputVO input)
|
|
{
|
|
return await Context.Queryable<TrackTemplateContentEntity>()
|
|
.InnerJoin<TrackContentEntity>((templateContent, trackContent) =>
|
|
templateContent.TrackContentId == trackContent.Id && !trackContent.IsDeleted)
|
|
.LeftJoin<TrackStatusEntity>((templateContent, trackContent, trackStatus) =>
|
|
trackContent.TrackStatusId == trackStatus.Id && !trackStatus.IsDeleted)
|
|
.LeftJoin<VEnumValueInfoEntity>((templateContent, trackContent, trackStatus, enumValue) =>
|
|
enumValue.Property == EnumPropertyEnums.节点.GetDescription() && trackStatus.Node == enumValue.Enumkey &&
|
|
!enumValue.IsDeleted)
|
|
.LeftJoin<VUserEntity>((templateContent, trackContent, trackStatus, enumValue, createUser) =>
|
|
templateContent.CreateUserId == createUser.Id && !createUser.IsDeleted)
|
|
.LeftJoin<VUserEntity>(
|
|
(templateContent, trackContent, trackStatus, enumValue, createUser, updateUser) =>
|
|
templateContent.UpdateUserId == updateUser.Id && !updateUser.IsDeleted)
|
|
.Filter(null, true)
|
|
.Where(templateContent => input.TrackTemplateIds.Contains(templateContent.TrackTemplateId) &&
|
|
!templateContent.IsDeleted)
|
|
.Select((templateContent, trackContent, trackStatus, enumValue, createUser, updateUser) =>
|
|
new GetTrackTemplateContentPageOutputVO
|
|
{
|
|
Id = templateContent.Id,
|
|
TrackStatus = trackStatus.Status,
|
|
Node = enumValue.Disp,
|
|
TrackFlag = SqlFunc.Subqueryable<TrackFlagEntity>()
|
|
.Where(x => SqlFunc.SplitIn(trackContent.TrackFlagId, x.Id.ToString()))
|
|
.SelectStringJoin(x => x.Name, ","),
|
|
CreateTime = templateContent.CreateTime,
|
|
CreateUser = createUser.Name,
|
|
UpdateTime = templateContent.UpdateTime,
|
|
UpdateUser = updateUser.Name
|
|
}, true)
|
|
.OrderBy(templateContent => templateContent.Sort)
|
|
.ToPagedListAsync(input.PageIndex, input.PageSize);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task<GetTrackTemplateContentDetailOutputVo> GetContentDetailAsync(int id)
|
|
{
|
|
return await Context.Queryable<TrackTemplateContentEntity>()
|
|
.InnerJoin<TrackContentEntity>((templateContent, trackContent) =>
|
|
templateContent.TrackContentId == trackContent.Id && !trackContent.IsDeleted)
|
|
.LeftJoin<TrackStatusEntity>((templateContent, trackContent, trackStatus) =>
|
|
trackContent.TrackStatusId == trackStatus.Id && !trackStatus.IsDeleted)
|
|
.Filter(null, true)
|
|
.Where(templateContent => templateContent.Id == id && !templateContent.IsDeleted)
|
|
.Select(
|
|
(templateContent, trackContent, trackStatus) => new GetTrackTemplateContentDetailOutputVo
|
|
{
|
|
Id = templateContent.Id,
|
|
TrackContent = trackContent.Code + "-" + trackContent.Content,
|
|
TrackStatus = trackStatus.Status
|
|
}, true)
|
|
.SingleAsync();
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task<bool> IsContentAnyAsync(Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
|
|
{
|
|
return await Context.Queryable<TrackTemplateContentEntity>().Where(whereExpression).AnyAsync();
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task<bool> InsertContentAsync(TrackTemplateContentEntity insertObj)
|
|
{
|
|
return await Context.Insertable(insertObj).ExecuteCommandAsync() > 0;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task<TrackTemplateContentEntity> GetContentByIdAsync(int id)
|
|
{
|
|
return await Context.Queryable<TrackTemplateContentEntity>().InSingleAsync(id);
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task<bool> UpdateContentAsync(TrackTemplateContentEntity updateObj)
|
|
{
|
|
return await Context.Updateable(updateObj).ExecuteCommandHasChangeAsync();
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public async Task<bool> SoftDeleteContentAsync(int id)
|
|
{
|
|
return await Context.Updateable<TrackTemplateContentEntity>()
|
|
.Where(x => x.Id == id)
|
|
.SetColumns(nameof(ISoftDeleteBasicEntity.IsDeleted), true)
|
|
.ExecuteCommandHasChangeAsync();
|
|
}
|
|
|
|
public async Task<List<TrackTemplateContentEntity>> GetContentListAsync(
|
|
Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
|
|
{
|
|
return await Context.Queryable<TrackTemplateContentEntity>().Where(whereExpression).ToListAsync();
|
|
}
|
|
|
|
public async Task<bool> UpdateContentRangeAsync(List<TrackTemplateContentEntity> updateObjs)
|
|
{
|
|
return await Context.Updateable(updateObjs).ExecuteCommandHasChangeAsync();
|
|
}
|
|
|
|
public async Task<T> ContentMaxAsync<T>(Expression<Func<TrackTemplateContentEntity, T>> columns,
|
|
Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
|
|
{
|
|
return await Context.Queryable<TrackTemplateContentEntity>().Where(whereExpression).MaxAsync(columns);
|
|
}
|
|
|
|
public async Task<bool> UpdateContentAsync(Expression<Func<TrackTemplateContentEntity, bool>> columns,
|
|
Expression<Func<TrackTemplateContentEntity, bool>> whereExpression)
|
|
{
|
|
return await Context.Updateable<TrackTemplateContentEntity>().SetColumns(columns).Where(whereExpression)
|
|
.ExecuteCommandHasChangeAsync();
|
|
}
|
|
|
|
public async Task<List<TrackTemplateOutputVo>> GetTrackTemplateListAsync(GetTrackTemplateListInputVo input)
|
|
{
|
|
var templates = await Context.Queryable<TrackTemplateEntity>()
|
|
.Where(x => x.SubSystemId == input.SubSystemId)
|
|
.WhereIF(input.CustomerId.HasValue, x => x.CustomerId == input.CustomerId)
|
|
.WhereIF(input.TemplateType.HasValue, x => x.CategoryId == input.TemplateType)
|
|
.Select(x => new TrackTemplateOutputVo
|
|
{
|
|
Id = x.Id,
|
|
TemplateName = x.Name,
|
|
TemplateCode = x.Code,
|
|
})
|
|
.ToListAsync();
|
|
|
|
if (templates == default) return new List<TrackTemplateOutputVo>();
|
|
var templateIds = templates.Select(x => x.Id).ToArray();
|
|
var contents = await Context.Queryable<TrackTemplateContentEntity>()
|
|
.LeftJoin<TrackContentEntity>((a, b) => a.TrackContentId == b.Id)
|
|
.LeftJoin<TrackStatusEntity>((a, b, c) => b.TrackStatusId == c.Id)
|
|
.LeftJoin<TrackNodeEntity>((a, b, c, d) => c.Node == d.Id)
|
|
.Where(a => templateIds.Contains(a.TrackTemplateId))
|
|
.Select((a, b, c, d) => new TemplateContentDtoVo
|
|
{
|
|
TemplateId = a.TrackTemplateId,
|
|
Code = b.Code,
|
|
ContentCn = b.Content,
|
|
ContentEn = b.EnContent,
|
|
Status = c.Status,
|
|
Node = d.NodeName
|
|
})
|
|
.ToListAsync();
|
|
|
|
foreach (var template in templates)
|
|
{
|
|
var templateContents = contents.Where(x => x.TemplateId == template.Id).ToList();
|
|
|
|
template.TemplateContents = templateContents;
|
|
}
|
|
|
|
return templates;
|
|
}
|
|
|
|
public async Task<List<string>> GetContentByTemplateCodes(string[] codes, int systemId)
|
|
{
|
|
|
|
var sql = @$"
|
|
select
|
|
distinct
|
|
c.Code
|
|
from t_track_template a
|
|
left join t_track_template_content b on a.id = b.TrackTemplateId and b.IsDeleted = 0
|
|
left join t_track_content c on b.TrackContentId = c.Id and c.IsDeleted = 0
|
|
where
|
|
a.SubSystemId = {systemId}
|
|
and a.Code in (@codes)
|
|
and a.IsDeleted = 0
|
|
";
|
|
|
|
|
|
var list = Context.Ado.SqlQuery<string>(sql, new {codes = codes}).ToList();
|
|
|
|
return list;
|
|
}
|
|
}
|