377 lines
17 KiB
C#
377 lines
17 KiB
C#
using DocumentFormat.OpenXml.EMMA;
|
|
using IRaCIS.Core.Application.Service.Reading.Dto;
|
|
using IRaCIS.Core.Application.ViewModel;
|
|
using IRaCIS.Core.Domain.Share;
|
|
using IRaCIS.Core.Infra.EFCore.Common;
|
|
using MassTransit;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using NPOI.Util;
|
|
|
|
namespace IRaCIS.Core.Application.Service.ReadingCalculate
|
|
{
|
|
[ApiExplorerSettings(GroupName = "Reading")]
|
|
public class SelfDefineCalculateService(IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository,
|
|
IRepository<VisitTask> _visitTaskRepository,
|
|
IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository,
|
|
IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository,
|
|
IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository,
|
|
IRepository<ReadingGlobalTaskInfo> _readingGlobalTaskInfoRepository,
|
|
IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository,
|
|
IRepository<SubjectVisit> _subjectVisitRepository,
|
|
IRepository<OrganInfo> _organInfoRepository,
|
|
IRepository<DicomStudy> _dicomStudyRepository,
|
|
IRepository<NoneDicomStudy> _noneDicomStudyRepository,
|
|
IRepository<TumorAssessment_RECIST1Point1> _tumorAssessmentRepository,
|
|
IGeneralCalculateService _generalCalculateService,
|
|
IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService, ICriterionCalculateService
|
|
{
|
|
|
|
|
|
private List<SiteVisitForTumor> siteVisitForTumorList = new List<SiteVisitForTumor>();
|
|
|
|
/// <summary>
|
|
/// 阅片导入
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task ReadingImport()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取阅片的计算数据
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
public async Task<object> GetReadingCalculationData(GetReadingCalculationDataInDto inDto)
|
|
{
|
|
return new
|
|
{
|
|
};
|
|
}
|
|
|
|
#region 删除病灶获取起始病灶序号
|
|
/// <summary>
|
|
/// 删除病灶获取起始病灶序号
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<int> GetDeleteLesionStatrIndex(DeleteReadingRowAnswerInDto inDto)
|
|
{
|
|
return 1;
|
|
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region 获取阅片报告
|
|
/// <summary>
|
|
/// 获取阅片报告
|
|
/// </summary>
|
|
/// <param name="indto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetReadingReportEvaluationOutDto> GetReadingReportEvaluation(GetReadingReportEvaluationInDto indto)
|
|
{
|
|
GetReadingReportEvaluationOutDto result = new GetReadingReportEvaluationOutDto();
|
|
|
|
result.CalculateResult = await this.GetReportVerify(new GetReportVerifyInDto()
|
|
{
|
|
VisitTaskId = indto.VisitTaskId
|
|
});
|
|
|
|
var visitTaskInfo = await _visitTaskRepository.Where(x => x.Id == indto.VisitTaskId).FirstNotNullAsync();
|
|
|
|
|
|
result.ReadingTaskState = visitTaskInfo.ReadingTaskState;
|
|
var taskInfoList = await _generalCalculateService.GetReadingReportTaskList(indto.VisitTaskId);
|
|
|
|
result.VisitTaskList = taskInfoList;
|
|
|
|
var visitTaskIds = taskInfoList.Select(x => x.VisitTaskId).ToList();
|
|
|
|
var criterionId = visitTaskInfo.TrialReadingCriterionId;
|
|
var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == criterionId && x.ShowQuestion != ShowQuestion.Hide).ToListAsync();
|
|
var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == criterionId).OrderBy(x => x.ShowOrder).ToListAsync();
|
|
|
|
var lesionsIndexs = await _readingTableAnswerRowInfoRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).GroupBy(x => new { x.QuestionId }).Select(x => new lesionsIndexDto()
|
|
{
|
|
QuestionId = x.Key.QuestionId,
|
|
Rowindexs = x.Select(x => x.RowIndex).Distinct().OrderBy(x => x).ToList()
|
|
|
|
}).ToListAsync();
|
|
|
|
var tableAnsweRowInfos = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == indto.VisitTaskId).ProjectTo<TableAnsweRowInfo>(_mapper.ConfigurationProvider).ToListAsync();
|
|
|
|
var answers = await _readingTaskQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();
|
|
var tableAnswers = await _readingTableQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();
|
|
var globalanswerList = await _readingGlobalTaskInfoRepository.Where(x => visitTaskIds.Contains(x.TaskId) && x.GlobalVisitTask.TaskState == TaskState.Effect && x.Answer != string.Empty).Select(x => new Globalanswer()
|
|
{
|
|
TaskId = x.TaskId,
|
|
VisitTaskNum = x.GlobalVisitTask.VisitTaskNum,
|
|
QuestionId = x.QuestionId,
|
|
Answer = x.Answer
|
|
}).ToListAsync();
|
|
var alltableAnsweRowInfos = await _readingTableAnswerRowInfoRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();
|
|
var organIds = alltableAnsweRowInfos.Where(x => x.OrganInfoId != null).Select(x => x.OrganInfoId).Distinct().ToList();
|
|
var organInfos = await _organInfoRepository.Where(x => organIds.Contains(x.Id)).ToListAsync();
|
|
|
|
var needChangeType = new List<QuestionMark?>() {
|
|
QuestionMark.Organ,
|
|
QuestionMark.Location,
|
|
QuestionMark.Part,
|
|
};
|
|
|
|
// 第一级
|
|
|
|
List<ReadingReportDto> questions = await _generalCalculateService.GetReadingReportQuestion
|
|
(
|
|
questionList,
|
|
taskInfoList,
|
|
globalanswerList,
|
|
answers,
|
|
tableAnsweRowInfos,
|
|
tableQuestionList,
|
|
alltableAnsweRowInfos,
|
|
tableAnswers,
|
|
organInfos,
|
|
needChangeType
|
|
);
|
|
|
|
|
|
|
|
result.TaskQuestions = questions;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// 将上一次的访视病灶添加到这一次
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
public async Task<AddTaskLesionAnswerFromLastTaskOutDto> AddTaskLesionAnswerFromLastTask(AddTaskLesionAnswerFromLastTaskInDto inDto)
|
|
{
|
|
var visitTaskId = inDto.VisitTaskId;
|
|
var taskinfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).FirstNotNullAsync();
|
|
var isReadingTaskViewInOrder = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == taskinfo.TrialReadingCriterionId).Select(x => x.IsReadingTaskViewInOrder).FirstOrDefaultAsync();
|
|
var baseLineVisitId = await _subjectVisitRepository.Where(x => x.SubjectId == taskinfo.SubjectId && x.IsBaseLine).Select(x => x.Id).FirstOrDefaultAsync();
|
|
|
|
List<ReadingTableAnswerRowInfo> addRowList = new List<ReadingTableAnswerRowInfo>();
|
|
List<ReadingTableQuestionAnswer> addTableQuestionAnswerList = new List<ReadingTableQuestionAnswer>();
|
|
|
|
if (!(await _readingTableQuestionAnswerRepository.AnyAsync(x => x.VisitTaskId == visitTaskId)))
|
|
{
|
|
// 添加 是否预设
|
|
var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.ReadingQuestionTrial.ReadingQuestionCriterionTrialId == taskinfo.TrialReadingCriterionId && x.IsPreinstall).Include(x => x.ReadingQuestionTrial).ToListAsync();
|
|
// 是否有预设
|
|
if (tableQuestionList.Count() > 0)
|
|
{
|
|
|
|
foreach (var tableQuestion in tableQuestionList)
|
|
{
|
|
var thisTableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.ReadingQuestionId == tableQuestion.ReadingQuestionId).ToListAsync();
|
|
|
|
decimal index = 1;
|
|
|
|
foreach (var item in tableQuestion.TypeValue.Split('|'))
|
|
{
|
|
var newRowId = NewId.NextGuid();
|
|
addRowList.Add(new ReadingTableAnswerRowInfo()
|
|
{
|
|
Id = newRowId,
|
|
QuestionId = tableQuestion.ReadingQuestionId,
|
|
VisitTaskId = taskinfo.Id,
|
|
TrialId = taskinfo.TrialId,
|
|
RowIndex = index,
|
|
IsCurrentTaskAdd = true,
|
|
BlindName = taskinfo.TaskBlindName,
|
|
OrderMark = tableQuestion.ReadingQuestionTrial.OrderMark,
|
|
FristAddTaskId = taskinfo.Id,
|
|
RowMark = tableQuestion.ReadingQuestionTrial.OrderMark + decimal.Parse(index.ToString()).GetLesionMark()
|
|
|
|
});
|
|
|
|
foreach (var thisTableQuestion in thisTableQuestionList)
|
|
{
|
|
addTableQuestionAnswerList.Add(new ReadingTableQuestionAnswer()
|
|
{
|
|
Answer = thisTableQuestion.Id == tableQuestion.Id ? item : string.Empty,
|
|
QuestionId = tableQuestion.ReadingQuestionId,
|
|
TrialId = taskinfo.TrialId,
|
|
VisitTaskId = taskinfo.Id,
|
|
RowId = newRowId,
|
|
RowIndex = index,
|
|
TableQuestionId = thisTableQuestion.Id,
|
|
});
|
|
}
|
|
index++;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (taskinfo.SourceSubjectVisitId != baseLineVisitId && isReadingTaskViewInOrder == ReadingOrder.InOrder)
|
|
{
|
|
|
|
var LastVisitTaskId = await _visitTaskRepository.Where(x => x.ReadingCategory == ReadingCategory.Visit &&
|
|
x.TrialReadingCriterionId == taskinfo.TrialReadingCriterionId &&
|
|
x.IsAnalysisCreate == taskinfo.IsAnalysisCreate &&
|
|
x.DoctorUserId == taskinfo.DoctorUserId &&
|
|
x.IsSelfAnalysis == taskinfo.IsSelfAnalysis &&
|
|
x.SubjectId == taskinfo.SubjectId && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.VisitTaskNum < taskinfo.VisitTaskNum && x.TaskState == TaskState.Effect && x.ArmEnum == taskinfo.ArmEnum
|
|
).OrderByDescending(x => x.VisitTaskNum).Select(x => x.Id).FirstOrDefaultAsync();
|
|
|
|
var copyTableAnswers = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == LastVisitTaskId && x.ReadingTableQuestionTrial.IsCopy).Select(x => new CopyTableAnswerDto()
|
|
{
|
|
Answer = x.Answer,
|
|
QuestionId = x.QuestionId,
|
|
RowId = x.RowId,
|
|
QuestionMark = x.ReadingTableQuestionTrial.QuestionMark,
|
|
TableQuestionId = x.TableQuestionId,
|
|
RowIndex = x.RowIndex,
|
|
IsCopy = x.ReadingTableQuestionTrial.IsCopy,
|
|
TrialId = x.TrialId,
|
|
}).ToListAsync();
|
|
|
|
var tableRowAnswers = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == LastVisitTaskId && x.ReadingQuestionTrial.ReadingTableQuestionTrialList.Any(x=>x.IsCopy)).ProjectTo<CopyTableAnswerRowInfo>(_mapper.ConfigurationProvider).ToListAsync();
|
|
|
|
tableRowAnswers.ForEach(x =>
|
|
{
|
|
|
|
var rowinfo = addTableQuestionAnswerList.Where(y => y.QuestionId == x.QuestionId && y.RowIndex == x.RowIndex).FirstOrDefault();
|
|
|
|
x.VisitTaskId = visitTaskId;
|
|
x.IsCurrentTaskAdd = false;
|
|
x.Id = rowinfo == null ? NewId.NextGuid() : rowinfo.Id;
|
|
x.SeriesId = null;
|
|
x.InstanceId = null;
|
|
x.MeasureData = string.Empty;
|
|
x.PicturePath = string.Empty;
|
|
});
|
|
|
|
tableRowAnswers.ForEach(x =>
|
|
{
|
|
x.SplitRowId = tableRowAnswers.Where(y => y.OriginalId == x.SplitRowId).FirstOrDefault()?.Id;
|
|
x.MergeRowId = tableRowAnswers.Where(y => y.OriginalId == x.MergeRowId).FirstOrDefault()?.Id;
|
|
|
|
});
|
|
|
|
var tableAnswers = copyTableAnswers.Select(x => new ReadingTableQuestionAnswer
|
|
{
|
|
Id = NewId.NextGuid(),
|
|
Answer = x.IsCopy ? x.Answer : string.Empty,
|
|
QuestionId = x.QuestionId,
|
|
RowIndex = x.RowIndex,
|
|
RowId = tableRowAnswers.Where(y => y.OriginalId == x.RowId).Select(x => x.Id).FirstOrDefault(),
|
|
TableQuestionId = x.TableQuestionId,
|
|
TrialId = x.TrialId,
|
|
VisitTaskId = visitTaskId,
|
|
});
|
|
|
|
var addList = _mapper.Map<List<ReadingTableAnswerRowInfo>>(tableRowAnswers);
|
|
|
|
addRowList.AddRange(addList);
|
|
addTableQuestionAnswerList.AddRange(tableAnswers);
|
|
|
|
addRowList = addRowList.GroupBy(x => new { x.Id }).Select(x => x.ToList().FirstOrDefault()).ToList();
|
|
addTableQuestionAnswerList = addTableQuestionAnswerList.GroupBy(x =>
|
|
new
|
|
{
|
|
x.RowId,
|
|
x.TableQuestionId,
|
|
x.Id
|
|
}).Select(x => new ReadingTableQuestionAnswer()
|
|
{
|
|
Id = NewId.NextGuid(),
|
|
Answer = x.Select(y => y.Answer).Max() ?? string.Empty,
|
|
QuestionId = x.Select(y => y.QuestionId).Max(),
|
|
RowIndex = x.Select(y => y.RowIndex).Max(),
|
|
RowId = x.Key.RowId,
|
|
TableQuestionId = x.Key.TableQuestionId,
|
|
TrialId = x.Select(y => y.TrialId).Max(),
|
|
VisitTaskId = visitTaskId,
|
|
}).ToList();
|
|
|
|
}
|
|
}
|
|
|
|
await _readingTableAnswerRowInfoRepository.AddRangeAsync(addRowList);
|
|
await _readingTableQuestionAnswerRepository.AddRangeAsync(addTableQuestionAnswerList);
|
|
await _readingTableQuestionAnswerRepository.SaveChangesAsync();
|
|
return new AddTaskLesionAnswerFromLastTaskOutDto()
|
|
{
|
|
|
|
IsBaseLine = taskinfo.SourceSubjectVisitId == baseLineVisitId,
|
|
};
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 测试计算
|
|
/// </summary>
|
|
/// <param name="visitTaskId"></param>
|
|
/// <param name="type"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task TestCalculate(Guid visitTaskId, QuestionType type)
|
|
{
|
|
ReadingCalculateDto readingData = await _generalCalculateService.GetReadingCalculateDto(visitTaskId);
|
|
await ReadingCalculate(readingData, new List<QuestionType>() { type });
|
|
}
|
|
|
|
/// <summary>
|
|
/// 计算任务
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task CalculateTask(CalculateTaskInDto inDto)
|
|
{
|
|
ReadingCalculateDto readingData = await _generalCalculateService.GetReadingCalculateDto(inDto.VisitTaskId);
|
|
readingData.IsChangeOtherTask = inDto.IsChangeOtherTask;
|
|
await ReadingCalculate(readingData);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 自动计算
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <param name="calculateType"></param>
|
|
/// <returns></returns>
|
|
public async Task ReadingCalculate(ReadingCalculateDto inDto, List<QuestionType>? calculateType = null)
|
|
{
|
|
//var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.CriterionId && x.CustomCalculateMark != null).ToListAsync();
|
|
//var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == inDto.CriterionId && x.CustomCalculateMark != null).ToListAsync();
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public async Task<GetReportVerifyOutDto> GetReportVerify(GetReportVerifyInDto inDto)
|
|
{
|
|
return new GetReportVerifyOutDto()
|
|
{
|
|
|
|
};
|
|
}
|
|
|
|
public async Task VerifyVisitTaskQuestions(VerifyVisitTaskQuestionsInDto inDto)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|