383 lines
17 KiB
C#
383 lines
17 KiB
C#
using Amazon.Runtime.Internal.Auth;
|
|
using IRaCIS.Core.Application.Contracts;
|
|
using IRaCIS.Core.Application.Filter;
|
|
using IRaCIS.Core.Application.Service.Reading.Dto;
|
|
using IRaCIS.Core.Application.ViewModel;
|
|
using IRaCIS.Core.Domain.Share;
|
|
using MassTransit;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Panda.DynamicWebApi.Attributes;
|
|
using System.Linq.Dynamic.Core;
|
|
|
|
namespace IRaCIS.Core.Application.Service
|
|
{
|
|
|
|
/// <summary>
|
|
/// 非Dicom
|
|
/// </summary>
|
|
public partial class ReadingImageTaskService : BaseService, IReadingImageTaskService
|
|
{
|
|
/// <summary>
|
|
/// 提交访视阅片问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[NonDynamicMethod]
|
|
public async Task<IResponseOutput> SubmitVisitTaskQuestions(SubmitVisitTaskQuestionsInDto inDto)
|
|
{
|
|
await VerifyTaskIsSign(inDto.VisitTaskId);
|
|
await this.SaveVisitTaskQuestions(inDto);
|
|
|
|
|
|
await this.SubmitTaskChangeState(inDto.VisitTaskId);
|
|
return ResponseOutput.Ok(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存答案和非Dicom标记绑定关系
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SaveAnswerAndBindingNoneDicomMark(AddNoneDicomMarkAndBinding inDto)
|
|
{
|
|
var visitTask = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
|
|
// 说明要移除标记数据
|
|
if (inDto.MeasureData == string.Empty)
|
|
{
|
|
// 先找到绑定关系
|
|
var binding = await _readingNoneDicomMarkBindingRepository.Where(x =>
|
|
x.VisitTaskId == inDto.VisitTaskId &&
|
|
x.QuestionId == inDto.QuestionId &&
|
|
x.RowId == inDto.RowId &&
|
|
x.TableQuestionId == inDto.TableQuestionId).FirstOrDefaultAsync();
|
|
if (binding != null)
|
|
{
|
|
if ((await _readingNoneDicomMarkBindingRepository.Where(x => x.NoneDicomMarkId == binding.NoneDicomMarkId).CountAsync()) == 1)
|
|
{
|
|
|
|
await _readingNoneDicomMarkBindingRepository.DeleteFromQueryAsync(x => x.Id == binding.Id);
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 找到标记信息
|
|
var mark = await _readingNoneDicomMarkRepository.Where(x => x.MarkId == inDto.MarkId).FirstOrDefaultAsync();
|
|
if (mark != null)
|
|
{
|
|
if (mark.MeasureData != inDto.MeasureData || mark.Path != inDto.Path|| mark.OrderMarkName != inDto.OrderMarkName || mark.MarkTool != inDto.MarkTool)
|
|
{
|
|
await _readingNoneDicomMarkRepository.UpdatePartialFromQueryAsync(x => x.Id == mark.Id, u => new Domain.Models.ReadingNoneDicomMark()
|
|
{
|
|
MeasureData = inDto.MeasureData,
|
|
MarkTool=inDto.MarkTool,
|
|
OrderMarkName=inDto.OrderMarkName,
|
|
Path = inDto.Path
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 添加标记信息
|
|
mark = new ReadingNoneDicomMark()
|
|
{
|
|
Id = NewId.NextGuid(),
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
StudyId = inDto.StudyId,
|
|
MarkTool = inDto.MarkTool,
|
|
OrderMarkName = inDto.OrderMarkName,
|
|
NoneDicomFileId = inDto.NoneDicomFileId,
|
|
Path = inDto.Path,
|
|
MeasureData = inDto.MeasureData,
|
|
MarkId = inDto.MarkId
|
|
};
|
|
await _readingNoneDicomMarkRepository.AddAsync(mark);
|
|
}
|
|
|
|
await _readingNoneDicomMarkBindingRepository.BatchDeleteNoTrackingAsync(x =>
|
|
x.VisitTaskId == inDto.VisitTaskId &&
|
|
x.QuestionId == inDto.QuestionId &&
|
|
x.RowId == inDto.RowId &&
|
|
x.TableQuestionId == inDto.TableQuestionId);
|
|
|
|
await _readingNoneDicomMarkBindingRepository.AddAsync(new ReadingNoneDicomMarkBinding()
|
|
{
|
|
Id = NewId.NextGuid(),
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
QuestionId = inDto.QuestionId,
|
|
RowId = inDto.RowId,
|
|
TableQuestionId = inDto.TableQuestionId,
|
|
NoneDicomMarkId = mark.Id,
|
|
MarkId = mark.MarkId
|
|
});
|
|
|
|
|
|
|
|
}
|
|
|
|
// 处理答案
|
|
|
|
if (inDto.RowId == null)
|
|
{
|
|
await _readingTaskQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.ReadingQuestionTrialId == inDto.QuestionId);
|
|
await _readingTaskQuestionAnswerRepository.AddAsync(new ReadingTaskQuestionAnswer()
|
|
{
|
|
Id = NewId.NextGuid(),
|
|
SubjectId = visitTask.SubjectId,
|
|
Answer = inDto.Answer,
|
|
ReadingQuestionTrialId = inDto.QuestionId,
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
TrialId = visitTask.TrialId
|
|
});
|
|
}
|
|
else
|
|
{
|
|
await _readingTableQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.RowId == inDto.RowId&&x.TableQuestionId==inDto.TableQuestionId);
|
|
|
|
var rowinfo=await _readingTableAnswerRowInfoRepository.Where(x => x.Id == inDto.RowId.Value).FirstNotNullAsync();
|
|
await _readingTableQuestionAnswerRepository.AddAsync(new ReadingTableQuestionAnswer()
|
|
{
|
|
Id = NewId.NextGuid(),
|
|
RowId = inDto.RowId.Value,
|
|
Answer = inDto.Answer,
|
|
QuestionId= inDto.QuestionId,
|
|
TableQuestionId= inDto.TableQuestionId.Value,
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
TrialId = visitTask.TrialId,
|
|
RowIndex= rowinfo.RowIndex,
|
|
|
|
|
|
|
|
});
|
|
}
|
|
|
|
await _visitTaskRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除绑定关系
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> DeleteBinding(DeleteBindingInDto inDto)
|
|
{
|
|
await _readingNoneDicomMarkBindingRepository.DeleteFromQueryAsync(x =>x.Id==inDto.BindingIdId, true);
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取非Dicom标记和绑定关系
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetNoneDicomMarkAndBindingOutDto> GetNoneDicomMarkAndBinding(GetNoneDicomMarkAndBindingInDto inDto)
|
|
{
|
|
GetNoneDicomMarkAndBindingOutDto result=new GetNoneDicomMarkAndBindingOutDto ();
|
|
result.NoneDicomMarkList = await _readingNoneDicomMarkRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId)
|
|
.ProjectTo<AddNoneDicomMarkInDto>(_mapper.ConfigurationProvider)
|
|
.ToListAsync();
|
|
result.BindingList = await _readingNoneDicomMarkBindingRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId)
|
|
.ProjectTo<BindingData>(_mapper.ConfigurationProvider)
|
|
.ToListAsync();
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加非Dicom标记
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> AddNoneDicomMark(AddNoneDicomMarkInDto inDto)
|
|
{
|
|
var entity = await _readingNoneDicomMarkRepository.InsertOrUpdateAsync(inDto, true);
|
|
return ResponseOutput.Ok(entity.Id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取非Dicom标记
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetNoneDicomMarkListOutDto> GetNoneDicomMarkListOutDto(GetNoneDicomMarkListInDtoDto inDto)
|
|
{
|
|
var result = await _readingNoneDicomMarkRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId)
|
|
|
|
.ProjectTo<AddNoneDicomMarkInDto>(_mapper.ConfigurationProvider)
|
|
.ToListAsync();
|
|
|
|
return new GetNoneDicomMarkListOutDto()
|
|
{
|
|
NoneDicomMarkList = result
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除非Dicom标记
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("{id:guid}")]
|
|
public async Task<IResponseOutput> DeleteTrialFileType(Guid id)
|
|
{
|
|
var success = await _readingNoneDicomMarkRepository.DeleteFromQueryAsync(t => t.Id == id, true);
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存任务问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
[TrialGlobalLimit("AfterStopCannNotOpt")]
|
|
public async Task<IResponseOutput> SaveVisitTaskQuestions(SubmitVisitTaskQuestionsInDto inDto)
|
|
{
|
|
await VerifyTaskIsSign(inDto.VisitTaskId);
|
|
var subjectId = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.SubjectId).FirstOrDefaultAsync();
|
|
await _readingTaskQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId);
|
|
List<ReadingTaskQuestionAnswer> readingTaskAnswerList = inDto.AnswerList.Select(x => new ReadingTaskQuestionAnswer()
|
|
{
|
|
Id = NewId.NextGuid(),
|
|
SubjectId = subjectId,
|
|
Answer = x.Answer,
|
|
ReadingQuestionCriterionTrialId = inDto.ReadingQuestionCriterionTrialId,
|
|
ReadingQuestionTrialId = x.ReadingQuestionTrialId,
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
TrialId = inDto.TrialId
|
|
}).ToList();
|
|
|
|
await _readingTaskQuestionAnswerRepository.AddRangeAsync(readingTaskAnswerList);
|
|
var result = await _visitTaskRepository.SaveChangesAsync();
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取阅片非Dicom文件
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput<List<NoneDicomStudyView>>> GetReadingImageFile(GetReadingImgInDto inDto)
|
|
{
|
|
var task = await GetNextTask(new GetNextTaskInDto()
|
|
{
|
|
TrialId = inDto.TrialId,
|
|
SubjectId = inDto.SubjectId,
|
|
VisitTaskId = inDto.VisistTaskId,
|
|
});
|
|
List<Guid> visitIds = new List<Guid>();
|
|
if (task.ReadingCategory == ReadingCategory.Visit)
|
|
{
|
|
visitIds.Add(task.VisistId);
|
|
}
|
|
else
|
|
{
|
|
// 阅片期取前面所有的图像
|
|
visitIds.AddRange(await _subjectVisitRepository.Where(x => x.VisitNum <= task.VisitNum && x.SubjectId == task.SubjectId).Select(x => x.Id).ToListAsync());
|
|
}
|
|
|
|
var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisistTaskId).Select(t => new { t.BlindSubjectCode, t.ReadingTaskState, t.TrialReadingCriterionId, t.TrialReadingCriterion.IsImageFilter, t.TrialReadingCriterion.CriterionModalitys }).FirstNotNullAsync();
|
|
|
|
|
|
|
|
IQueryable<NoneDicomStudyView> noneDicomStudyQueryable = default;
|
|
|
|
noneDicomStudyQueryable = _noneDicomStudyRepository.Where(t => t.IsReading)
|
|
.Where(t => visitIds.Contains(t.SubjectVisitId) && t.NoneDicomFileList.Any(t => !t.FileType.Contains(StaticData.FileType.Zip)))
|
|
.WhereIf(taskinfo.IsImageFilter == true, t => taskinfo.CriterionModalitys.Contains(t.Modality))
|
|
.ProjectTo<NoneDicomStudyView>(_mapper.ConfigurationProvider, new { isFilterZip = true, isReading = true });
|
|
|
|
if (inDto.VisistTaskId != null && _noneDicomStudyFileSystem.Any(t => t.VisitTaskId == inDto.VisistTaskId))
|
|
{
|
|
noneDicomStudyQueryable = _noneDicomStudyRepository.Where(t => t.IsReading)
|
|
.Where(t => t.TaskNoneDicomFileList.Any(t => t.VisitTaskId == inDto.VisistTaskId))
|
|
.Where(t => taskinfo.IsImageFilter ? ("|" + taskinfo.CriterionModalitys + "|").Contains("|" + t.Modality + "|") : true)
|
|
.Where(t => visitIds.Contains(t.SubjectVisitId))
|
|
.ProjectTo<TaskDicomStudyView>(_mapper.ConfigurationProvider, new { isFilterZip = true, isReading = true, visiTaskId = inDto.VisistTaskId });
|
|
}
|
|
|
|
List<NoneDicomStudyView> result = await noneDicomStudyQueryable.OrderBy(x => x.ImageDate).ThenBy(x => x.CreateTime).ToListAsync();
|
|
|
|
|
|
var nonoDicomStudyFileIds = await _readingNoneDicomMarkRepository.Where(x => x.VisitTaskId == inDto.VisistTaskId).ToListAsync();
|
|
if (nonoDicomStudyFileIds.Count > 0 && taskinfo.ReadingTaskState == ReadingTaskState.HaveSigned)
|
|
{
|
|
var studyId = nonoDicomStudyFileIds.Select(x => x.StudyId).FirstOrDefault();
|
|
|
|
var noneDicomids = nonoDicomStudyFileIds.Select(x => x.NoneDicomFileId).ToList();
|
|
var noneDicomStudyViewMark = new NoneDicomStudyView() { Id = Guid.NewGuid() };
|
|
noneDicomStudyViewMark.IsCriticalSequence = true;
|
|
noneDicomStudyViewMark.NoneDicomStudyFileList = await _noneDicomStudyFileRepository.Where(x => noneDicomids.Contains(x.Id)).ProjectTo<NoneDicomStudyFileView>(_mapper.ConfigurationProvider).ToListAsync();
|
|
|
|
foreach (var item in noneDicomStudyViewMark.NoneDicomStudyFileList)
|
|
{
|
|
item.MarkTime = nonoDicomStudyFileIds.Where(x => x.NoneDicomFileId == item.Id).Select(x => x.CreateTime).FirstOrDefault();
|
|
}
|
|
|
|
noneDicomStudyViewMark.NoneDicomStudyFileList= noneDicomStudyViewMark.NoneDicomStudyFileList.OrderBy(x => x.MarkTime).ToList();
|
|
result.Insert(0, noneDicomStudyViewMark);
|
|
}
|
|
|
|
|
|
|
|
var trialInfo = await _trialRepository.Where(x => x.Id == inDto.TrialId).Select(x => new
|
|
{
|
|
x.ClinicalInformationTransmissionEnum,
|
|
}).FirstOrDefaultAsync();
|
|
|
|
|
|
var criterionInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == taskinfo.TrialReadingCriterionId).Select(x => new
|
|
{
|
|
x.IsReadingShowPreviousResults,
|
|
x.IsReadingShowSubjectInfo,
|
|
x.CriterionName,
|
|
x.Id,
|
|
x.ReadingTool,
|
|
|
|
}).FirstOrDefaultAsync();
|
|
|
|
|
|
bool isExistsClinicalData = false;
|
|
if (trialInfo.ClinicalInformationTransmissionEnum == 1)
|
|
{
|
|
isExistsClinicalData = (await _readingClinicalDataService.GetClinicalDataList(new GetReadingOrTaskClinicalDataListInDto()
|
|
{
|
|
|
|
SubjectId = task.SubjectId,
|
|
TrialId = inDto.TrialId,
|
|
VisitTaskId = task.VisitTaskId,
|
|
})).Count() > 0;
|
|
}
|
|
|
|
|
|
var taskInfo = await _visitTaskRepository.Where(x => x.Id == task.VisitTaskId).FirstNotNullAsync();
|
|
|
|
return ResponseOutput.Ok(result, new
|
|
{
|
|
VisitTaskId = task.VisitTaskId,
|
|
SubjectId = task.SubjectId,
|
|
SubjectCode = taskInfo.BlindSubjectCode.IsNullOrEmpty() ? task.SubjectCode : taskInfo.BlindSubjectCode,
|
|
ReadingCategory = task.ReadingCategory,
|
|
TaskBlindName = task.TaskBlindName,
|
|
IsReadingShowPreviousResults = criterionInfo.IsReadingShowPreviousResults,
|
|
IsReadingShowSubjectInfo = criterionInfo.IsReadingShowSubjectInfo,
|
|
IsExistsClinicalData = isExistsClinicalData,
|
|
TrialCriterionName = criterionInfo.CriterionName,
|
|
TrialCriterionId = criterionInfo.Id
|
|
|
|
});
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|