724 lines
30 KiB
C#
724 lines
30 KiB
C#
using IRaCIS.Application.Interfaces;
|
|
using IRaCIS.Core.Application.Service.Reading.Dto;
|
|
using IRaCIS.Core.Domain.Share;
|
|
using IRaCIS.Core.Infra.EFCore.Common;
|
|
using IRaCIS.Core.Infrastructure;
|
|
using MassTransit;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Panda.DynamicWebApi.Attributes;
|
|
|
|
namespace IRaCIS.Core.Application.Service.RC
|
|
{
|
|
|
|
|
|
[ApiExplorerSettings(GroupName = "Reading")]
|
|
public class ReadingQuestionService(IRepository<ReadingQuestionCriterionSystem> _readingQuestionCriterionSystemRepository,
|
|
IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository,
|
|
IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository,
|
|
IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswer,
|
|
IRepository<Dictionary> _dictionarRepository,
|
|
IRepository<ReadingCriterionPage> _readingCriterionPageRepository,
|
|
IRepository<ReadingSystemCriterionDictionary> _readingCriterionDictionaryRepository,
|
|
IRepository<ReadingTrialCriterionDictionary> _readingTrialCriterionDictionaryRepository,
|
|
IRepository<VisitTask> _visitTaskRepository,
|
|
ITrialConfigService _trialConfigService,
|
|
IRepository<SystemCriterionDictionaryCode> _systemCriterionDictionaryCodeRepository,
|
|
IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository,
|
|
IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository,
|
|
IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService
|
|
{
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 删除系统标准字典Code
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> DeleteSystemCriterionDictionary(DeleteSystemCriterionDictionaryIndto inDto)
|
|
{
|
|
var criterionDictionaryCode = await _systemCriterionDictionaryCodeRepository.Where(x => x.Id == inDto.Id).FirstNotNullAsync();
|
|
|
|
await _readingCriterionDictionaryRepository.BatchDeleteNoTrackingAsync(x => x.ParentCode == criterionDictionaryCode.Code && x.CriterionId == criterionDictionaryCode.SystemCriterionId);
|
|
|
|
await _systemCriterionDictionaryCodeRepository.DeleteFromQueryAsync(inDto.Id);
|
|
await _systemCriterionDictionaryCodeRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 添加系统标准字典Code
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> AddSystemCriterionDictionaryCode(AddSystemCriterionDictionaryCodeInDto inDto)
|
|
{
|
|
|
|
//var codes= await _systemCriterionDictionaryCodeRepository.Where(x => x.SystemCriterionId == inDto.SystemCriterionId).Select(x => x.Code).ToListAsync();
|
|
|
|
//inDto.CodeList= inDto.CodeList.Except(codes).ToList();
|
|
|
|
await _systemCriterionDictionaryCodeRepository.BatchDeleteNoTrackingAsync(x => x.SystemCriterionId == inDto.SystemCriterionId);
|
|
|
|
await _systemCriterionDictionaryCodeRepository.AddRangeAsync(inDto.CodeList.Select(x => new SystemCriterionDictionaryCode()
|
|
{
|
|
SystemCriterionId = inDto.SystemCriterionId,
|
|
Code = x
|
|
}).ToList());
|
|
|
|
await _systemCriterionDictionaryCodeRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 重置项目标准的重置状态
|
|
/// </summary>
|
|
/// <param name="trialReadingCriterionId">项目标准Id</param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> ResetTrialCriterionAsyncState(Guid trialReadingCriterionId)
|
|
{
|
|
await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => x.Id == trialReadingCriterionId, x => new ReadingQuestionCriterionTrial
|
|
{
|
|
SynchronizeOriginalTime = null,
|
|
SynchronizeTime = DateTime.Now.AddYears(-20),
|
|
IsSigned = false,
|
|
ReadingInfoSignTime = null,
|
|
|
|
});
|
|
|
|
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 设置系统全局阅片阅片信息
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
[UnitOfWork]
|
|
public async Task<IResponseOutput> SetSystemGlobalInfo(SetSystemGlobalInfoInDto inDto)
|
|
{
|
|
|
|
await _readingCriterionDictionaryRepository.BatchDeleteNoTrackingAsync(x => x.CriterionId == inDto.SystemCriterionId && x.ParentCode == ReadingCommon.CriterionDictionary.GlobalAssess);
|
|
|
|
await _readingCriterionDictionaryRepository.AddRangeAsync(inDto.DictionaryList.Select(x => new ReadingSystemCriterionDictionary
|
|
{
|
|
CriterionId = inDto.SystemCriterionId,
|
|
DictionaryId = x.DictionaryId,
|
|
IsSystemCriterion = true,
|
|
ParentCode = ReadingCommon.CriterionDictionary.GlobalAssess,
|
|
IsBaseLineUse = x.IsBaseLineUse,
|
|
IsFollowVisitUse = x.IsFollowVisitUse,
|
|
}));
|
|
|
|
await _readingQuestionCriterionSystemRepository.UpdatePartialFromQueryAsync(inDto.SystemCriterionId, x => new ReadingQuestionCriterionSystem()
|
|
{
|
|
IsMustGlobalReading = inDto.IsMustGlobalReading
|
|
|
|
});
|
|
|
|
var result = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取系统全局阅片信息
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetSystemGlobalInfoOutDto> GetSystemGlobalInfo(GetSystemOncologyInfoInDto inDto)
|
|
{
|
|
GetSystemGlobalInfoOutDto result = new GetSystemGlobalInfoOutDto()
|
|
{
|
|
IsMustGlobalReading = await _readingQuestionCriterionSystemRepository.Where(x => x.Id == inDto.SystemCriterionId).Select(x => x.IsMustGlobalReading).FirstOrDefaultAsync(),
|
|
DictionaryList = await _readingCriterionDictionaryRepository.AsQueryable().Where(x => x.CriterionId == inDto.SystemCriterionId && x.ParentCode == ReadingCommon.CriterionDictionary.GlobalAssess)
|
|
.ProjectTo<CriterionDictionaryInfo>(_mapper.ConfigurationProvider).OrderBy(x => x.ShowOrder).ToListAsync()
|
|
|
|
};
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取系统肿瘤信息
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetSystemOncologyInfoOutDto> GetSystemOncologyInfo(GetSystemOncologyInfoInDto inDto)
|
|
{
|
|
|
|
GetSystemOncologyInfoOutDto result = new GetSystemOncologyInfoOutDto()
|
|
{
|
|
IsOncologyReading = await _readingQuestionCriterionSystemRepository.Where(x => x.Id == inDto.SystemCriterionId).Select(x => x.IsOncologyReading).FirstOrDefaultAsync(),
|
|
DictionaryList = await _readingCriterionDictionaryRepository.AsQueryable().Where(x => x.CriterionId == inDto.SystemCriterionId && x.ParentCode == ReadingCommon.CriterionDictionary.OncologyAssess)
|
|
.ProjectTo<CriterionDictionaryInfo>(_mapper.ConfigurationProvider).OrderBy(x => x.ShowOrder).ToListAsync()
|
|
|
|
};
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置系统肿瘤学阅片信息
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
[UnitOfWork]
|
|
public async Task<IResponseOutput> SetSystemOncologyInfo(SetSystemOncologyInfoInDto inDto)
|
|
{
|
|
|
|
await _readingCriterionDictionaryRepository.BatchDeleteNoTrackingAsync(x => x.CriterionId == inDto.SystemCriterionId && x.ParentCode == ReadingCommon.CriterionDictionary.OncologyAssess);
|
|
|
|
await _readingCriterionDictionaryRepository.AddRangeAsync(inDto.DictionaryIds.Select(x => new ReadingSystemCriterionDictionary
|
|
{
|
|
CriterionId = inDto.SystemCriterionId,
|
|
DictionaryId = x,
|
|
IsSystemCriterion = true,
|
|
ParentCode = ReadingCommon.CriterionDictionary.OncologyAssess
|
|
}));
|
|
|
|
await _readingQuestionCriterionSystemRepository.UpdatePartialFromQueryAsync(inDto.SystemCriterionId, x => new ReadingQuestionCriterionSystem()
|
|
{
|
|
IsOncologyReading = inDto.IsOncologyReading
|
|
|
|
});
|
|
|
|
var result = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
|
|
|
|
#region 系统标准
|
|
/// <summary>
|
|
/// 获取获取系统阅片标准下拉
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<List<GetSystemCriterionListOutDto>> GetSystemCriterionList()
|
|
{
|
|
List<GetSystemCriterionListOutDto> result = await _readingQuestionCriterionSystemRepository.Select(x => new GetSystemCriterionListOutDto()
|
|
{
|
|
|
|
CriterionId = x.Id,
|
|
CriterionName = x.CriterionName,
|
|
|
|
}).ToListAsync();
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取系统问题标准
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<PageOutput<ReadingQuestionCriterionSystemView>> GetReadingQuestionCriterionSystemList(ReadingQuestionCriterionSystemViewInDto inDto)
|
|
{
|
|
//await AddSystemQuestionCriterion();
|
|
var query = _readingQuestionCriterionSystemRepository.AsQueryable()
|
|
.WhereIf(!inDto.CriterionName.IsNullOrEmpty(), x => x.CriterionName.Contains(inDto.CriterionName))
|
|
.WhereIf(inDto.IsEnable!=null, x => x.IsEnable== inDto.IsEnable)
|
|
.WhereIf(inDto.IsCompleteConfig != null, x => x.IsCompleteConfig == inDto.IsCompleteConfig)
|
|
.WhereIf(inDto.CriterionGroup != null, x => x.CriterionGroup == inDto.CriterionGroup)
|
|
.WhereIf(inDto.CriterionType != null, x => x.CriterionType == inDto.CriterionType)
|
|
.ProjectTo<ReadingQuestionCriterionSystemView>(_mapper.ConfigurationProvider);
|
|
|
|
return await query.ToPagedListAsync(inDto, nameof(ReadingQuestionCriterionSystemView.ShowOrder));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取系统问题标准下拉
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<List<GetSystemCriterionSelectDto>> GetSystemCriterionSelectList()
|
|
{
|
|
var criterionList = await _readingQuestionCriterionSystemRepository.AsQueryable()
|
|
.OrderBy(x => x.ShowOrder)
|
|
.Select(x => new GetSystemCriterionSelectDto()
|
|
{
|
|
Id = x.Id,
|
|
CriterionName = x.CriterionName,
|
|
|
|
}).ToListAsync();
|
|
return criterionList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 新增修改系统问题标准
|
|
/// </summary>
|
|
/// <param name="indto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> AddOrUpdateReadingQuestionCriterionSystem(AddOrUpdateReadingQuestionCriterionSystemInDto indto)
|
|
{
|
|
var entity = await _readingQuestionCriterionSystemRepository.InsertOrUpdateAsync(indto, true);
|
|
|
|
if (indto.Id != null)
|
|
{
|
|
await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == indto.Id, x => new ReadingQuestionCriterionTrial()
|
|
{
|
|
CriterionName = indto.CriterionName,
|
|
CriterionType = indto.CriterionType,
|
|
|
|
});
|
|
}
|
|
return ResponseOutput.Ok(entity.Id.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除系统问题标准
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
[HttpDelete("{id:guid}")]
|
|
public async Task<IResponseOutput> DeleteReadingQuestionCriterionSystem(Guid id)
|
|
{
|
|
|
|
|
|
if (await _readingQuestionCriterionTrialRepository.AnyAsync(x => x.IsConfirm && x.ReadingQuestionCriterionSystemId == id))
|
|
{
|
|
//---当前标准被引用过了，不可以删除
|
|
throw new BusinessValidationFailedException(_localizer["ReadingCriterion_Referenced"]);
|
|
}
|
|
|
|
await _readingQuestionCriterionSystemRepository.DeleteFromQueryAsync(t => t.Id == id);
|
|
var success = await _readingQuestionCriterionSystemRepository.SaveChangesAsync();
|
|
return ResponseOutput.Result(success);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 设置系统问题标准是否完成配置
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
public async Task<IResponseOutput> SetSystemReadingQuestionCriterionIsCompleteConfig(SetSystemReadingQuestionCriterionIsIsCompleteConfig inDto)
|
|
{
|
|
|
|
if (!inDto.IsCompleteConfig)
|
|
{
|
|
var trialCriterionIds = await _readingQuestionCriterionTrialRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.Id).Select(x => x.Id).ToListAsync();
|
|
if (await _readingTaskQuestionAnswer.AnyAsync(x => trialCriterionIds.Contains(x.ReadingQuestionCriterionTrialId)))
|
|
{
|
|
//---此标准在项目里面已被使用,操作失败
|
|
return ResponseOutput.NotOk(_localizer["ReadingCriterion_InUse"]);
|
|
}
|
|
}
|
|
|
|
var systemCriterion = await _readingQuestionCriterionSystemRepository.Where(x => x.Id == inDto.Id).AsNoTracking().FirstNotNullAsync();
|
|
|
|
var confirmTime = systemCriterion.ConfirmTime;
|
|
|
|
if (inDto.IsCompleteConfig)
|
|
{
|
|
confirmTime = DateTime.Now;
|
|
}
|
|
|
|
await _readingQuestionCriterionSystemRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingQuestionCriterionSystem()
|
|
{
|
|
IsCompleteConfig = inDto.IsCompleteConfig,
|
|
ConfirmTime = confirmTime,
|
|
});
|
|
|
|
if (inDto.IsCompleteConfig)
|
|
{
|
|
//await SynchronizeSystemCriterion(inDto.Id);
|
|
}
|
|
else
|
|
{
|
|
await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == inDto.Id, x => new ReadingQuestionCriterionTrial()
|
|
{
|
|
IsCompleteConfig = inDto.IsCompleteConfig
|
|
});
|
|
}
|
|
var result = await _readingQuestionCriterionSystemRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region 项目标准
|
|
|
|
/// <summary>
|
|
/// 获取项目裁判信息
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetTrialJudgyInfoOutDto> GetTrialJudgyInfo(GetTrialJudgyInfoInDto inDto)
|
|
{
|
|
GetTrialJudgyInfoOutDto result = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == inDto.TrialReadingCriterionId).Select(x => new GetTrialJudgyInfoOutDto
|
|
{
|
|
TrialId = x.TrialId,
|
|
IsReadingTaskViewInOrder = x.IsReadingTaskViewInOrder,
|
|
ArbitrationRule = x.ArbitrationRule,
|
|
IsArbitrationReading = x.IsArbitrationReading
|
|
|
|
}).FirstNotNullAsync();
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 新增修改项目问题标准（项目）
|
|
/// </summary>
|
|
/// <param name="indto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> AddOrUpdateReadingQuestionCriterionTrial(AddOrUpdateReadingQuestionCriterionTrialInDto indto)
|
|
{
|
|
if (indto.ReadingVersionEnum == null)
|
|
{
|
|
var dic = await _dictionarRepository.Where(x => x.Parent.Code == "ReadingVersion").ToListAsync();
|
|
|
|
var maxDic = dic.Select(x => int.Parse(x.Code)).Max();
|
|
|
|
indto.ReadingVersionEnum=(ReadingVersion)maxDic;
|
|
}
|
|
var entity = await _readingQuestionCriterionTrialRepository.InsertOrUpdateAsync(indto, true);
|
|
return ResponseOutput.Ok(entity.Id.ToString());
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 设置项目标准是否完成配置
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
public async Task<IResponseOutput> SetTrialReadingQuestionCriterionIsIsCompleteConfig(SetSystemReadingQuestionCriterionIsIsCompleteConfig inDto)
|
|
{
|
|
await _readingQuestionCriterionTrialRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingQuestionCriterionTrial()
|
|
{
|
|
IsCompleteConfig = inDto.IsCompleteConfig
|
|
});
|
|
|
|
var result = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取项目问题标准（项目）
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<PageOutput<ReadingQuestionCriterionTrialView>> GetReadingQuestionCriterionTrialList(ReadingQuestionCriterionTrialViewInDto inDto)
|
|
{
|
|
await AddSystemDataToTrila(inDto.TrialId);
|
|
var query = _readingQuestionCriterionTrialRepository.AsQueryable()
|
|
.Where(x => x.TrialId == inDto.TrialId)
|
|
.Where(x => (x.ReadingQuestionCriterionSystemId != null && x.IsEnable) || x.ReadingQuestionCriterionSystemId == null)
|
|
.WhereIf(!inDto.CriterionName.IsNullOrEmpty(), x => x.CriterionName.Contains(inDto.CriterionName))
|
|
|
|
.ProjectTo<ReadingQuestionCriterionTrialView>(_mapper.ConfigurationProvider);
|
|
return await query.ToPagedListAsync(inDto, nameof(ReadingQuestionCriterionTrialView.ShowOrder));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除项目问题标准（项目）
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
[HttpDelete("{id:guid}")]
|
|
public async Task<IResponseOutput> DeleteReadingQuestionCriterionTrial(Guid id)
|
|
{
|
|
await _readingQuestionCriterionTrialRepository.DeleteFromQueryAsync(t => t.Id == id);
|
|
var success = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
|
|
return ResponseOutput.Result(success);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置项目裁判信息
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SetTrialJudgyInfo(SetTrialJudgyInfoInDto inDto)
|
|
{
|
|
|
|
var trialCriterion = await _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == inDto.TrialId && x.Id == inDto.TrialReadingCriterionId).FirstNotNullAsync();
|
|
|
|
var judgeCount = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == trialCriterion.Id && x.IsJudgeQuestion)
|
|
.WhereIf(trialCriterion.FormType == FormType.SinglePage, x => x.ReadingCriterionPageId == null)
|
|
.WhereIf(trialCriterion.FormType == FormType.MultiplePage, x => x.ReadingCriterionPageId != null).CountAsync();
|
|
|
|
if (judgeCount == 0 && (inDto.ArbitrationRule == ArbitrationRule.Visit || inDto.ArbitrationRule == ArbitrationRule.Reading))
|
|
{
|
|
//---无裁判问题却有仲裁对象,操作失败
|
|
throw new BusinessValidationFailedException(_localizer["ReadingCriterion_ArbitratorWithoutJudgment"]);
|
|
}
|
|
await _readingQuestionCriterionTrialRepository.UpdatePartialFromQueryAsync(inDto.TrialReadingCriterionId, x => new ReadingQuestionCriterionTrial()
|
|
{
|
|
ArbitrationRule = inDto.ArbitrationRule,
|
|
//IsArbitrationReading = inDto.IsArbitrationReading,
|
|
});
|
|
|
|
var result = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region 项目阅片标准问题分页
|
|
|
|
/// <summary>
|
|
/// 新增修改项目标准分页
|
|
/// </summary>
|
|
/// <param name="addOrEditReadingCriterionPage"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> AddOrUpdateReadingCriterionPage(ReadingCriterionPageAddOrEdit addOrEditReadingCriterionPage)
|
|
{
|
|
|
|
var entity = await _readingCriterionPageRepository.InsertOrUpdateAsync(addOrEditReadingCriterionPage, true);
|
|
return ResponseOutput.Ok(entity.Id.ToString());
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除标准分页
|
|
/// </summary>
|
|
/// <param name="Id"></param>
|
|
/// <returns></returns>
|
|
[HttpDelete("{Id:guid}")]
|
|
public async Task<IResponseOutput> DeleteReadingCriterionPage(Guid Id)
|
|
{
|
|
var success = await _readingCriterionPageRepository.DeleteFromQueryAsync(t => t.Id == Id, true);
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region 全局评估类型 肿瘤学评估类型
|
|
|
|
/// <summary>
|
|
/// 修改是否是随访使用
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SetDictionaryFollowVisitUse(SetDictionaryFollowVisitUseInDto inDto)
|
|
{
|
|
await _readingCriterionDictionaryRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingSystemCriterionDictionary()
|
|
{
|
|
IsFollowVisitUse = inDto.IsFollowVisitUse
|
|
});
|
|
|
|
await _readingCriterionDictionaryRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(true);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 修改是否是基线使用
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SetDictionaryBaseLineUse(SetDictionaryBaseLineUseInDto inDto)
|
|
{
|
|
await _readingCriterionDictionaryRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingSystemCriterionDictionary()
|
|
{
|
|
IsBaseLineUse = inDto.IsBaseLineUse
|
|
});
|
|
|
|
await _readingCriterionDictionaryRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取标准字典
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<List<CriterionDictionaryInfo>> GetAssessType(GetAssessTypeInDto inDto)
|
|
{
|
|
|
|
if (inDto.SystemCriterionId != null)
|
|
{
|
|
return await _readingCriterionDictionaryRepository.Where(x => x.CriterionId == inDto.SystemCriterionId
|
|
)
|
|
.WhereIf(!inDto.ParentCode.IsNullOrEmpty(), x => x.ParentCode == inDto.ParentCode)
|
|
.ProjectTo<CriterionDictionaryInfo>(_mapper.ConfigurationProvider).OrderBy(x => x.ParentCode).ThenBy(x => x.ShowOrder).ToListAsync();
|
|
}
|
|
else
|
|
{
|
|
return await _readingTrialCriterionDictionaryRepository.Where(x => x.CriterionId == inDto.TrialCriterionId
|
|
)
|
|
.WhereIf(!inDto.ParentCode.IsNullOrEmpty(), x => x.ParentCode == inDto.ParentCode)
|
|
.ProjectTo<CriterionDictionaryInfo>(_mapper.ConfigurationProvider).OrderBy(x => x.ParentCode).ThenBy(x => x.ShowOrder).ToListAsync();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 设置标准字典分组
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<bool> EditCriterionDictionary(EditCriterionDictionaryInDto inDto)
|
|
{
|
|
await _readingCriterionDictionaryRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingSystemCriterionDictionary()
|
|
{
|
|
CrterionDictionaryGroup = inDto.CrterionDictionaryGroup
|
|
});
|
|
|
|
return await _readingCriterionDictionaryRepository.SaveChangesAsync();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置标准字典
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SetCriterionDictionary(SetCriterionDictionaryInDto inDto)
|
|
{
|
|
await _readingCriterionDictionaryRepository.BatchDeleteNoTrackingAsync(x => x.CriterionId == inDto.CriterionId && x.ParentCode == inDto.ParentCode);
|
|
|
|
|
|
await _readingCriterionDictionaryRepository.AddRangeAsync(inDto.DictionaryIds.Select(x => new ReadingSystemCriterionDictionary()
|
|
{
|
|
CriterionId = inDto.CriterionId,
|
|
DictionaryId = x,
|
|
IsSystemCriterion = true,
|
|
ParentCode = inDto.ParentCode
|
|
}));
|
|
|
|
|
|
await _readingCriterionDictionaryRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置评估类型
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SetAssessType(SetAssessTypeInDto inDto)
|
|
{
|
|
await _readingCriterionDictionaryRepository.BatchDeleteNoTrackingAsync(x => x.CriterionId == inDto.CriterionId && x.ParentCode == inDto.ParentCode);
|
|
|
|
await _readingCriterionDictionaryRepository.AddRangeAsync(inDto.DictionaryList.Select(x => new ReadingSystemCriterionDictionary()
|
|
{
|
|
CriterionId = inDto.CriterionId,
|
|
DictionaryId = x.DictionaryId,
|
|
IsBaseLineUse = x.IsBaseLineUse,
|
|
IsFollowVisitUse = x.IsFollowVisitUse,
|
|
IsSystemCriterion = true,
|
|
ParentCode = inDto.ParentCode
|
|
}));
|
|
|
|
await _readingCriterionDictionaryRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// 添加系统数据到项目里面
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[NonDynamicMethod]
|
|
private async Task AddSystemDataToTrila(Guid trialId)
|
|
{
|
|
// 加系统到项目
|
|
var trialUsrSystemIds = _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == trialId && x.ReadingQuestionCriterionSystemId != null)
|
|
.Select(x => x.ReadingQuestionCriterionSystemId);
|
|
var trialCriterionNames = _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == trialId)
|
|
.Select(x => x.CriterionName);
|
|
List<ReadingQuestionCriterionTrial> needAddCriterionList = await _readingQuestionCriterionSystemRepository.Where(x => !trialUsrSystemIds.Contains(x.Id) && x.IsEnable && !trialCriterionNames.Contains(x.CriterionName)).ProjectTo<ReadingQuestionCriterionTrial>(_mapper.ConfigurationProvider).ToListAsync();
|
|
|
|
List<ReadingQuestionTrial> needAddQuestionList = new List<ReadingQuestionTrial>();
|
|
|
|
var dic = await _dictionarRepository.Where(x => x.Parent.Code == "ReadingVersion").ToListAsync();
|
|
|
|
var maxDic = dic.Select(x => int.Parse(x.Code)).Max();
|
|
|
|
needAddCriterionList.ForEach(x =>
|
|
{
|
|
//x.IsEnable = false;
|
|
x.ReadingVersionEnum = (ReadingVersion)maxDic;
|
|
x.TrialId = trialId;
|
|
x.ReadingQuestionCriterionSystemId = x.Id;
|
|
x.Id = NewId.NextGuid();
|
|
|
|
x.IsAutoCreate = x.CriterionType == CriterionType.RECIST1Pointt1_MB ? false : true;
|
|
// 同步问题暂时注释
|
|
//List<ReadingQuestionTrial> readingQuestionTrialList = new List<ReadingQuestionTrial>();
|
|
//SetChildParentQuestion(criterion.Id, trialId, systemQuestionList, readingQuestionTrialList);
|
|
//needAddQuestionList.AddRange(readingQuestionTrialList);
|
|
});
|
|
|
|
// 标准的默认值 标准默认值
|
|
foreach (var criterion in needAddCriterionList)
|
|
{
|
|
|
|
|
|
|
|
switch (criterion.CriterionType)
|
|
{
|
|
case CriterionType.IVUS:
|
|
criterion.IsReadingPeriod = false;
|
|
criterion.IsImageFilter = false;
|
|
criterion.IsGlobalReading = false;
|
|
criterion.IsArbitrationReading = true;
|
|
criterion.ArbitrationRule = ArbitrationRule.Visit;
|
|
criterion.IsReadingTaskViewInOrder = ReadingOrder.SubjectRandom;
|
|
criterion.ImageDownloadEnum = ReadingImageDownload.Subejct;
|
|
criterion.ImageUploadEnum = ReadingImageUpload.IRReadingSubejctEnable;
|
|
break;
|
|
case CriterionType.OCT:
|
|
criterion.IsImageFilter = false;
|
|
criterion.IsReadingPeriod = false;
|
|
criterion.IsGlobalReading = false;
|
|
criterion.IsArbitrationReading = true;
|
|
criterion.ArbitrationRule = ArbitrationRule.Visit;
|
|
criterion.IsReadingTaskViewInOrder = ReadingOrder.SubjectRandom;
|
|
criterion.ImageDownloadEnum = ReadingImageDownload.Subejct;
|
|
criterion.ImageUploadEnum = ReadingImageUpload.IRReadingSubejctEnable;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
await _readingQuestionCriterionTrialRepository.AddRangeAsync(needAddCriterionList);
|
|
await _readingQuestionTrialRepository.AddRangeAsync(needAddQuestionList);
|
|
await _readingQuestionTrialRepository.SaveChangesAsync();
|
|
}
|
|
|
|
}
|
|
}
|