1432 lines
66 KiB
C#
1432 lines
66 KiB
C#
using IRaCIS.Application.Interfaces;
|
|
using IRaCIS.Core.Infra.EFCore;
|
|
using IRaCIS.Core.Domain.Share;
|
|
using IRaCIS.Core.Application.Filter;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using IRaCIS.Core.Application.Service.WorkLoad.DTO;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using IRaCIS.Core.Application.Auth;
|
|
using IRaCIS.Core.Application.Service.Reading.Dto;
|
|
using MassTransit;
|
|
using IRaCIS.Core.Application.Service.Reading;
|
|
using IRaCIS.Core.Infra.EFCore.Common;
|
|
using Panda.DynamicWebApi.Attributes;
|
|
using AutoMapper;
|
|
using IRaCIS.Core.Application.Contracts;
|
|
using IRaCIS.Core.Infrastructure;
|
|
using Newtonsoft.Json;
|
|
using IRaCIS.Core.Application.Service;
|
|
using IRaCIS.Core.Application.ViewModel;
|
|
|
|
namespace IRaCIS.Application.Services
|
|
{
|
|
/// <summary>
|
|
/// IR影像阅片
|
|
/// </summary>
|
|
[ApiExplorerSettings(GroupName = "Reading")]
|
|
public class ReadingImageTaskService : BaseService, IReadingImageTaskService
|
|
{
|
|
|
|
private readonly IRepository<NoneDicomStudy> _noneDicomStudyRepository;
|
|
private readonly IRepository<VisitTask> _visitTaskRepository;
|
|
private readonly IRepository<Trial> _trialRepository;
|
|
private readonly IVisitTaskHelpeService _visitTaskHelpeService;
|
|
private readonly IVisitTaskService _visitTaskService;
|
|
private readonly IReadingClinicalDataService _readingClinicalDataService;
|
|
private readonly IRepository<SubjectVisit> _subjectVisitRepository;
|
|
private readonly IRepository<Subject> _subjectRepository;
|
|
private readonly IRepository<ReadingGlobalTaskInfo> _readingGlobalTaskInfoRepository;
|
|
private readonly IRepository<ReadingCriterionPage> _readingCriterionPageRepository;
|
|
private readonly IRepository<ReadingJudgeInfo> _readingJudgeInfoRepository;
|
|
private readonly IRepository<ReadModule> _readModuleRepository;
|
|
private readonly IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository;
|
|
private readonly IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository;
|
|
private readonly IRepository<ReadingQuestionCriterionSystem> _readingQuestionCriterionSystemRepository;
|
|
private readonly IRepository<ReadingQuestionSystem> _readingQuestionSystem;
|
|
private readonly IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository;
|
|
|
|
|
|
public ReadingImageTaskService(
|
|
IMapper mapper,
|
|
IRepository<NoneDicomStudy> noneDicomStudyRepository,
|
|
IRepository<VisitTask> visitTaskRepository,
|
|
IRepository<Trial> TrialRepository,
|
|
IVisitTaskHelpeService visitTaskHelpeService,
|
|
IVisitTaskService visitTaskService,
|
|
IReadingClinicalDataService readingClinicalDataService,
|
|
IRepository<SubjectVisit> subjectVisitRepository,
|
|
IRepository<Subject> subjectRepository,
|
|
IRepository<ReadingGlobalTaskInfo> readingGlobalTaskInfoRepository,
|
|
IRepository<ReadingCriterionPage> readingCriterionPageRepository,
|
|
IRepository<ReadingJudgeInfo> readingJudgeInfoRepository,
|
|
IRepository<ReadModule> readModuleRepository,
|
|
IRepository<ReadingTaskQuestionAnswer> readingTaskQuestionAnswerRepository,
|
|
IRepository<ReadingQuestionCriterionTrial> readingQuestionCriterionTrialRepository,
|
|
IRepository<ReadingQuestionCriterionSystem> readingQuestionCriterionSystemRepository,
|
|
IRepository<ReadingQuestionSystem> ReadingQuestionSystem,
|
|
IRepository<ReadingQuestionTrial> readingQuestionTrialRepository
|
|
)
|
|
{
|
|
base._mapper = mapper;
|
|
this._noneDicomStudyRepository = noneDicomStudyRepository;
|
|
this._visitTaskRepository = visitTaskRepository;
|
|
this._trialRepository = TrialRepository;
|
|
this._visitTaskHelpeService = visitTaskHelpeService;
|
|
this._visitTaskService = visitTaskService;
|
|
this._readingClinicalDataService = readingClinicalDataService;
|
|
this._subjectVisitRepository = subjectVisitRepository;
|
|
this._subjectRepository = subjectRepository;
|
|
this._readingGlobalTaskInfoRepository = readingGlobalTaskInfoRepository;
|
|
this._readingCriterionPageRepository = readingCriterionPageRepository;
|
|
this._readingJudgeInfoRepository = readingJudgeInfoRepository;
|
|
this._readModuleRepository = readModuleRepository;
|
|
this._readingTaskQuestionAnswerRepository = readingTaskQuestionAnswerRepository;
|
|
this._readingQuestionCriterionTrialRepository = readingQuestionCriterionTrialRepository;
|
|
this._readingQuestionCriterionSystemRepository = readingQuestionCriterionSystemRepository;
|
|
this._readingQuestionSystem = ReadingQuestionSystem;
|
|
this._readingQuestionTrialRepository = readingQuestionTrialRepository;
|
|
}
|
|
|
|
#region 全局阅片相关
|
|
/// <summary>
|
|
/// 获取全局阅片历史记录
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<List<GetHistoryGlobalInfoOutDto>> GetHistoryGlobalInfo(GetHistoryGlobalInfoInDto inDto)
|
|
{
|
|
var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
|
|
List<GetHistoryGlobalInfoOutDto> result = await _visitTaskRepository.Where(x =>x.TaskState==TaskState.Effect&& x.SubjectId == taskInfo.SubjectId && x.ArmEnum == taskInfo.ArmEnum && x.ReadingCategory == ReadingCategory.Global && x.VisitTaskNum < taskInfo.VisitTaskNum)
|
|
.Where(x=>x.IsAnalysisCreate== taskInfo.IsAnalysisCreate)
|
|
.OrderBy(x => x.VisitTaskNum)
|
|
.Select(x => new GetHistoryGlobalInfoOutDto()
|
|
{
|
|
|
|
ReadingTaskState = x.ReadingTaskState,
|
|
TaskName = x.TaskName,
|
|
VisitTaskId = x.Id,
|
|
VisitTaskNum=x.VisitTaskNum
|
|
}).OrderBy(x=>x.VisitTaskNum).ToListAsync();
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存全局阅片结果
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SaveGlobalReadingInfo(SaveGlobalReadingInfoInDto inDto)
|
|
{
|
|
var visitTaskId = inDto.QuestionList.Select(x => x.VisitTaskId).FirstOrDefault();
|
|
await _readingGlobalTaskInfoRepository.BatchDeleteNoTrackingAsync(x => x.GlobalTaskId == inDto.GlobalTaskId&&x.TaskId== visitTaskId);
|
|
|
|
foreach(var item in inDto.QuestionList)
|
|
{
|
|
await _readingTaskQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => x.VisitTaskId == item.VisitTaskId && x.ReadingQuestionTrialId == item.QuestionId, x => new ReadingTaskQuestionAnswer()
|
|
{
|
|
GlobalChangeAnswer = item.Answer
|
|
});
|
|
}
|
|
|
|
await _readingGlobalTaskInfoRepository.AddRangeAsync(inDto.QuestionList.Select(x => new ReadingGlobalTaskInfo()
|
|
{
|
|
Answer = x.Answer,
|
|
QuestionId = x.QuestionId,
|
|
SubjectId = inDto.SubjectId,
|
|
GlobalTaskId = inDto.GlobalTaskId,
|
|
TaskId = x.VisitTaskId,
|
|
TrialId = inDto.TrialId,
|
|
}).ToList());
|
|
|
|
var result = await _readingGlobalTaskInfoRepository.SaveChangesAsync();
|
|
return ResponseOutput.Ok(result);
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取全局阅片信息
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetGlobalReadingInfoOutDto> GetGlobalReadingInfo(GetGlobalReadingInfoInDto inDto)
|
|
{
|
|
var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
|
|
if (taskInfo.ReadingCategory != ReadingCategory.Global)
|
|
{
|
|
throw new BusinessValidationFailedException("当前任务不是全局阅片任务");
|
|
}
|
|
GetGlobalReadingInfoOutDto result = new GetGlobalReadingInfoOutDto()
|
|
{
|
|
GlobalTaskId = inDto.VisitTaskId,
|
|
ReadingTaskState=taskInfo.ReadingTaskState,
|
|
|
|
};
|
|
|
|
result.TaskList = await _visitTaskRepository.Where(x => x.ReadingCategory == ReadingCategory.Visit &&
|
|
x.SubjectId == taskInfo.SubjectId && x.ArmEnum == taskInfo.ArmEnum&&x.IsAnalysisCreate== taskInfo.IsAnalysisCreate&&x.TaskState==TaskState.Effect && x.VisitTaskNum < taskInfo.VisitTaskNum)
|
|
.OrderBy(x => x.VisitTaskNum).Select(x => new GlobalVisitInfo()
|
|
{
|
|
VisitName = x.SourceSubjectVisit.VisitName,
|
|
VisitTaskId = x.Id,
|
|
ArmEnum= taskInfo.ArmEnum,
|
|
VisitNum =x.SourceSubjectVisit.VisitNum,
|
|
VisitId = x.SourceSubjectVisitId.Value,
|
|
BeforeQuestionList = x.ReadingTaskQuestionAnswerList.Where(y => y.ReadingQuestionTrial.IsJudgeQuestion).OrderBy(y => y.ReadingQuestionTrial.ShowOrder)
|
|
.Select(y => new GlobalQuestionInfo()
|
|
{
|
|
QuestionId = y.ReadingQuestionTrialId,
|
|
QuestionName = y.ReadingQuestionTrial.QuestionName,
|
|
AnswerGroup=y.ReadingQuestionTrial.AnswerGroup,
|
|
|
|
AnswerCombination=y.ReadingQuestionTrial.AnswerCombination,
|
|
JudgeType=y.ReadingQuestionTrial.JudgeType,
|
|
Type = y.ReadingQuestionTrial.Type,
|
|
TypeValue = y.ReadingQuestionTrial.TypeValue,
|
|
Answer = y.Answer
|
|
}).ToList()
|
|
}).ToListAsync();
|
|
|
|
|
|
var globalReadingQuestion = await _readingGlobalTaskInfoRepository.Where(x => x.GlobalTaskId == inDto.VisitTaskId).ToListAsync();
|
|
|
|
result.TaskList.ForEach(x =>
|
|
{
|
|
x.AfterQuestionList = x.BeforeQuestionList.GroupJoin(
|
|
globalReadingQuestion
|
|
, l => new { a = l.QuestionId, b = x.VisitTaskId }
|
|
, r => new { a = r.QuestionId, b = r.TaskId }
|
|
, (l, r) => new { question = l, global = r })
|
|
.SelectMany(lr => lr.global.DefaultIfEmpty(), (lr, r) => new GlobalQuestionInfo
|
|
{
|
|
Answer = lr.global == null|| lr.global.Count()==0 ?
|
|
(inDto.UsingOriginalData?lr.question.Answer: string.Empty) :
|
|
|
|
(lr.global.Select(x => x.Answer).FirstOrDefault().IsNullOrEmpty()&& inDto.UsingOriginalData?
|
|
lr.question.Answer:lr.global.Select(x => x.Answer).FirstOrDefault()
|
|
),
|
|
QuestionId = lr.question.QuestionId,
|
|
QuestionName = lr.question.QuestionName,
|
|
Type = lr.question.Type,
|
|
|
|
AnswerGroup = lr.question.AnswerGroup,
|
|
AnswerCombination = lr.question.AnswerCombination,
|
|
JudgeType = lr.question.JudgeType,
|
|
TypeValue = lr.question.TypeValue,
|
|
|
|
}).ToList();
|
|
|
|
var reason = new GlobalQuestionInfo()
|
|
{
|
|
Answer = globalReadingQuestion.Where(y => y.TaskId == x.VisitTaskId && y.QuestionId == null).Select(x => x.Answer).FirstOrDefault() ?? String.Empty,
|
|
QuestionName = "原因",
|
|
Type = "input",
|
|
|
|
|
|
};
|
|
|
|
x.AfterQuestionList.Add(reason);
|
|
|
|
|
|
});
|
|
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region 获取下一个阅片任务
|
|
/// <summary>
|
|
/// 获取下一个阅片任务
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetReadingTaskDto> GetNextTask(GetNextTaskInDto inDto)
|
|
{
|
|
GetReadingTaskDto? task = new GetReadingTaskDto();
|
|
|
|
if (inDto.VisistTaskId != null)
|
|
{
|
|
task = await _visitTaskRepository.Where(x => x.Id == inDto.VisistTaskId).Select(x => new GetReadingTaskDto()
|
|
{
|
|
VisitTaskId = x.Id,
|
|
TaskBlindName = x.TaskBlindName,
|
|
SubjectId = x.SubjectId,
|
|
ReadingCategory = x.ReadingCategory,
|
|
VisistId = x.SourceSubjectVisitId != null ? x.SourceSubjectVisitId.Value :default(Guid) ,
|
|
VisitNum = x.VisitTaskNum,
|
|
|
|
}).FirstOrDefaultAsync();
|
|
|
|
}
|
|
else if (inDto.SubjectId != null)
|
|
{
|
|
|
|
#region 之前的
|
|
//var subjectList = await _subjectRepository.Where(t => t.TrialId == inDto.TrialId)
|
|
|
|
//.Select(s => new SubjectTask()
|
|
//{
|
|
// SubjectId = s.Id,
|
|
// UnReadTaskCount = s.SubjectVisitTaskList.Count(t => t.ReadingTaskState != ReadingTaskState.HaveSigned && t.DoctorUserId == _userInfo.Id && t.TaskState == TaskState.Effect),
|
|
//}).OrderBy(x => x.SubjectId).ToListAsync();
|
|
//subjectList = subjectList.Select((x, index) => new SubjectTask()
|
|
//{
|
|
// Index = index,
|
|
// SubjectId = x.SubjectId,
|
|
// UnReadTaskCount = x.UnReadTaskCount,
|
|
//}).ToList();
|
|
|
|
|
|
//var subjectIndex = subjectList.Where(x => x.SubjectId == inDto.SubjectId).Select(x => x.Index).FirstOrDefault();
|
|
//var newSubjectId = subjectList.Where(x => x.Index >= subjectIndex && x.UnReadTaskCount != 0).Select(x => x.SubjectId).FirstOrDefault();
|
|
|
|
//var taskquery = _visitTaskRepository.Where(x => x.TrialId == inDto.TrialId && x.ReadingTaskState != ReadingTaskState.HaveSigned && x.SubjectId == newSubjectId && x.DoctorUserId == _userInfo.Id && x.TaskState == TaskState.Effect).Select(x => new GetReadingTaskDto()
|
|
//{
|
|
// VisitTaskId = x.Id,
|
|
// TaskBlindName = x.TaskBlindName,
|
|
// ReadingCategory = x.ReadingCategory,
|
|
// VisistId = x.SourceSubjectVisitId != null ? x.SourceSubjectVisitId.Value : x.ReadModule == null ? default(Guid) : x.ReadModule.SubjectVisitId,
|
|
// VisitNum = x.VisitTaskNum,
|
|
//}).OrderBy(x => x.VisitNum).ThenBy(x => x.ReadingCategory);
|
|
#endregion
|
|
|
|
var subjectTaskList = await _visitTaskService.GetOrderReadingIQueryable(inDto.TrialId).Item2.ToListAsync();
|
|
|
|
var index = 0;
|
|
subjectTaskList.ForEach(x =>
|
|
{
|
|
x.Index = index;
|
|
index++;
|
|
});
|
|
|
|
var subjectIndex = subjectTaskList.Where(x => x.SubjectId == inDto.SubjectId&&x.SubjectCode==inDto.SubjectCode).Select(x => x.Index).FirstOrDefault();
|
|
|
|
var currentSubject = subjectTaskList.Where(x => x.Index >= subjectIndex&&!x.ExistReadingApply).OrderBy(x => x.Index).FirstOrDefault();
|
|
|
|
if (currentSubject == null)
|
|
{
|
|
throw new BusinessValidationFailedException("任务都已经完成");
|
|
}
|
|
|
|
task = currentSubject.UnReadTaskList.Select(x => new GetReadingTaskDto()
|
|
{
|
|
ReadingCategory = x.ReadingCategory,
|
|
SubjectCode = currentSubject.SubjectCode,
|
|
SubjectId = currentSubject.SubjectId,
|
|
TaskBlindName = x.TaskBlindName,
|
|
VisitNum = x.VisitNum,
|
|
VisistId = x.VisistId ?? default(Guid),
|
|
VisitTaskId = x.Id
|
|
}).FirstOrDefault();
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
task = await _visitTaskRepository.Where(x => x.TrialId == inDto.TrialId && x.ReadingTaskState != ReadingTaskState.HaveSigned && x.DoctorUserId == _userInfo.Id && x.TaskState == TaskState.Effect).Select(x => new GetReadingTaskDto()
|
|
{
|
|
VisitTaskId = x.Id,
|
|
TaskBlindName = x.TaskBlindName,
|
|
ReadingCategory = x.ReadingCategory,
|
|
VisistId = x.SourceSubjectVisitId != null ? x.SourceSubjectVisitId.Value : x.ReadModule == null ? default(Guid) : x.ReadModule.SubjectVisitId,
|
|
VisitNum = x.VisitTaskNum,
|
|
SubjectId = x.SubjectId,
|
|
SubjectCode = x.Subject.Code,
|
|
}).FirstOrDefaultAsync();
|
|
if (task == null)
|
|
{
|
|
throw new BusinessValidationFailedException("任务都已经完成");
|
|
}
|
|
}
|
|
|
|
if (task.SubjectCode.IsNullOrEmpty())
|
|
{
|
|
task.SubjectCode = await _subjectRepository.Where(x => x.Id == task.SubjectId).Select(x => x.Code).FirstOrDefaultAsync();
|
|
}
|
|
|
|
await _visitTaskRepository.BatchUpdateNoTrackingAsync(x => x.Id == task.VisitTaskId && x.FirstReadingTime == null, x => new VisitTask()
|
|
{
|
|
FirstReadingTime = DateTime.Now,
|
|
});
|
|
await _visitTaskRepository.SaveChangesAsync();
|
|
return task;
|
|
}
|
|
#endregion
|
|
|
|
#region 获取阅片非Dicom文件
|
|
/// <summary>
|
|
/// 获取阅片非Dicom文件
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<(List<NoneDicomStudyView>, object)> GetReadingImageFile(GetReadingImgInDto inDto)
|
|
{
|
|
var task = await GetNextTask(new GetNextTaskInDto()
|
|
{
|
|
TrialId = inDto.TrialId,
|
|
SubjectId = inDto.SubjectId,
|
|
VisistTaskId = 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());
|
|
}
|
|
List<NoneDicomStudyView> result = await _noneDicomStudyRepository.Where(t => visitIds.Contains(t.SubjectVisitId))
|
|
.ProjectTo<NoneDicomStudyView>(_mapper.ConfigurationProvider, new { token = _userInfo.UserToken }).ToListAsync();
|
|
|
|
var trialInfo = await _trialRepository.Where(x => x.Id == inDto.TrialId).Select(x => new
|
|
{
|
|
x.IsReadingShowPreviousResults,
|
|
x.IsReadingShowSubjectInfo,
|
|
x.ClinicalInformationTransmissionEnum,
|
|
}).FirstOrDefaultAsync();
|
|
|
|
#region 临床数据
|
|
|
|
#endregion
|
|
bool isExistsClinicalData = false;
|
|
if (trialInfo.ClinicalInformationTransmissionEnum == 1)
|
|
{
|
|
isExistsClinicalData = (await _readingClinicalDataService.GetClinicalDataList(new GetReadingOrTaskClinicalDataListInDto()
|
|
{
|
|
|
|
SubjectId = task.SubjectId,
|
|
TrialId = inDto.TrialId,
|
|
VisitTaskId = task.VisitTaskId,
|
|
})).Count() > 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
return (result, new
|
|
{
|
|
VisitTaskId = task.VisitTaskId,
|
|
SubjectId = task.SubjectId,
|
|
SubjectCode = task.SubjectCode,
|
|
ReadingCategory = task.ReadingCategory,
|
|
TaskBlindName = task.TaskBlindName,
|
|
IsReadingShowPreviousResults = trialInfo.IsReadingShowPreviousResults,
|
|
IsReadingShowSubjectInfo = trialInfo.IsReadingShowSubjectInfo,
|
|
IsExistsClinicalData = isExistsClinicalData,
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region 获取项目已确认的标准
|
|
/// <summary>
|
|
/// 获取项目已确认的标准
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<List<GetTrialConfirmCriterionListOutDto>> GetTrialConfirmCriterionList(GetConfirmCriterionInDto inDto)
|
|
{
|
|
var result = await _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == inDto.TrialId && x.IsConfirm && x.IsCompleteConfig)
|
|
.Select(x => new GetTrialConfirmCriterionListOutDto()
|
|
{
|
|
ReadingQuestionCriterionTrialId = x.Id,
|
|
ReadingQuestionCriterionTrialName = x.CriterionName
|
|
}).ToListAsync();
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region 配置裁判问题相关
|
|
|
|
/// <summary>
|
|
/// 获取项目标准的裁判问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<(List<GetTrialCriterionJudgeQuestionListOutDto>, object)> GetTrialCriterionJudgeQuestionList(GetTrialCriterionJudgeQuestionListInDto inDto)
|
|
{
|
|
var trialCriterion = await _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == inDto.TrialId && x.IsConfirm).FirstNotNullAsync();
|
|
|
|
var result = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId && x.IsJudgeQuestion)
|
|
.WhereIf(trialCriterion.FormType == FormType.SinglePage, x => x.ReadingCriterionPageId == null)
|
|
.WhereIf(trialCriterion.FormType == FormType.MultiplePage, x => x.ReadingCriterionPageId != null)
|
|
.Select(x => new GetTrialCriterionJudgeQuestionListOutDto()
|
|
{
|
|
AnswerGroup = JsonConvert.DeserializeObject<List<string>>(x.AnswerGroup.IsNullOrEmpty() ? "[]" : x.AnswerGroup),
|
|
AnswerCombination = JsonConvert.DeserializeObject<List<AnswerCombinationDto>>(x.AnswerCombination.IsNullOrEmpty() ? "[]" : x.AnswerCombination),
|
|
QuestionName = x.QuestionName,
|
|
PageName = x.ReadingCriterionPage.PageName,
|
|
TypeValue = x.TypeValue,
|
|
JudgeType = x.JudgeType,
|
|
ReadingQuestionTrialId = x.Id
|
|
}).ToListAsync();
|
|
|
|
var signTime = await _trialRepository.Where(x => x.Id == inDto.TrialId).Select(x => x.ReadingInfoSignTime).FirstOrDefaultAsync();
|
|
|
|
return (result, new
|
|
{
|
|
IsSign = signTime != null,
|
|
});
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置裁判问题的答案分组
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SetTrialCriterionJudgeQuestionAnswerGroup(SetTrialCriterionJudgeQuestionAnswerGroupInDto inDto)
|
|
{
|
|
await _readingQuestionTrialRepository.UpdatePartialFromQueryAsync(inDto.ReadingQuestionTrialId, x => new ReadingQuestionTrial()
|
|
{
|
|
AnswerGroup = JsonConvert.SerializeObject(inDto.AnswerGroup),
|
|
AnswerCombination = JsonConvert.SerializeObject(inDto.AnswerCombination),
|
|
JudgeType = inDto.JudgeType,
|
|
});
|
|
|
|
var result = await _readingQuestionTrialRepository.SaveChangesAsync();
|
|
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
#endregion
|
|
|
|
#region 获取项目的阅片问题
|
|
/// <summary>
|
|
/// 获取项目的阅片问题
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// SinglePage 单页
|
|
///
|
|
/// MultiPage 多页
|
|
///
|
|
/// PublicPage 公共
|
|
/// </remarks>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<(GetTrialReadingQuestionPageDto, object)> GetTrialReadingQuestion(GetTrialReadingQuestionInDto inDto)
|
|
{
|
|
var result = new GetTrialReadingQuestionPageDto();
|
|
var readingTaskState = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.ReadingTaskState).FirstOrDefaultAsync();
|
|
var query = from data in _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId)
|
|
|
|
join page in _readingCriterionPageRepository.AsQueryable() on data.ReadingCriterionPageId ?? default(Guid) equals page.Id into pageTemp
|
|
from leftpage in pageTemp.DefaultIfEmpty()
|
|
|
|
join questionAnswer in _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId) on data.Id equals questionAnswer.ReadingQuestionTrialId into questionAnswerTemp
|
|
from leftquestionAnswer in questionAnswerTemp.DefaultIfEmpty()
|
|
select new GetTrialReadingQuestionOutDto()
|
|
{
|
|
ReadingQuestionTrialId = data.Id,
|
|
ReadingQuestionCriterionTrialId = data.ReadingQuestionCriterionTrialId,
|
|
TrialId = data.TrialId,
|
|
Type = data.Type,
|
|
ParentTriggerValue = data.ParentTriggerValue,
|
|
GroupName = data.GroupName,
|
|
QuestionName = data.QuestionName,
|
|
IsRequired = data.IsRequired,
|
|
ShowOrder = data.ShowOrder,
|
|
ParentId = data.ParentId,
|
|
TypeValue = data.TypeValue,
|
|
Answer = leftquestionAnswer.Answer,
|
|
ReadingCriterionPageId = data.ReadingCriterionPageId,
|
|
PageName = leftpage.PageName,
|
|
PageShowOrder = leftpage.ShowOrder,
|
|
IsPublicPage = leftpage.IsPublicPage,
|
|
};
|
|
|
|
var qusetionList = await query.OrderBy(x => x.ShowOrder).ToListAsync();
|
|
|
|
var formType = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == inDto.ReadingQuestionCriterionTrialId).Select(x => x.FormType).FirstOrDefaultAsync();
|
|
var groupList = new List<GetTrialReadingQuestionOutDto>();
|
|
|
|
if (inDto.FormType != null)
|
|
{
|
|
formType = inDto.FormType.Value;
|
|
}
|
|
|
|
if (formType == FormType.MultiplePage)
|
|
{
|
|
qusetionList = qusetionList.Where(x => x.ReadingCriterionPageId != null).ToList();
|
|
var readingCriterionPageIds = qusetionList.OrderBy(x => x.PageShowOrder).Select(x => x.ReadingCriterionPageId).Distinct().ToList();
|
|
foreach (var item in readingCriterionPageIds)
|
|
{
|
|
var newPageQusetionList = qusetionList.Where(x => x.ReadingCriterionPageId == item).ToList();
|
|
var firstData = newPageQusetionList.FirstOrDefault();
|
|
var page = new GetTrialReadingQuestionOutDto()
|
|
{
|
|
PageName = firstData.PageName,
|
|
IsPage = true,
|
|
IsPublicPage = firstData.IsPublicPage,
|
|
};
|
|
|
|
var pageGroupList = newPageQusetionList.Where(x => x.Type == "group" || (x.ParentId == null && x.GroupName.IsNullOrEmpty())).ToList();
|
|
pageGroupList.ForEach(x =>
|
|
{
|
|
this.FindChildQuestion(x, newPageQusetionList);
|
|
});
|
|
|
|
page.Childrens = pageGroupList.Where(x => !(x.Type == "group" && x.Childrens.Count() == 0)).ToList();
|
|
groupList.Add(page);
|
|
}
|
|
|
|
result.PublicPage = groupList.Where(x => x.IsPublicPage.Value).ToList();
|
|
result.MultiPage = groupList.Where(x => !x.IsPublicPage.Value).ToList();
|
|
}
|
|
else
|
|
{
|
|
qusetionList = qusetionList.Where(x => x.ReadingCriterionPageId == null).ToList();
|
|
|
|
groupList = qusetionList.Where(x => x.Type == "group" || (x.ParentId == null && x.GroupName.IsNullOrEmpty())).ToList();
|
|
groupList.ForEach(x =>
|
|
{
|
|
this.FindChildQuestion(x, qusetionList);
|
|
});
|
|
|
|
groupList = groupList.Where(x => !(x.Type == "group" && x.Childrens.Count() == 0)).ToList();
|
|
|
|
result.SinglePage = groupList;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//List<GetTrialReadingQuestionOutDto> groupList = qusetionList.Where(x => x.ParentId == null).ToList();
|
|
|
|
|
|
|
|
//groupList.ForEach(x =>
|
|
//{
|
|
// this.FindChildQuestion(x, qusetionList);
|
|
//});
|
|
return (result, new
|
|
{
|
|
readingTaskState = readingTaskState,
|
|
FormType = formType
|
|
|
|
}); ;
|
|
}
|
|
#endregion
|
|
|
|
#region 获取系统的阅片问题
|
|
|
|
/// <summary>
|
|
/// 获取系统的阅片问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetTrialReadingQuestionPageDto> GetSystemReadingQuestion(GetSystemReadingQuestionInDto inDto)
|
|
{
|
|
var result = new GetTrialReadingQuestionPageDto();
|
|
var query = from data in _readingQuestionSystem.Where(x => x.ReadingQuestionCriterionSystemId == inDto.Id)
|
|
select new GetTrialReadingQuestionOutDto()
|
|
{
|
|
ReadingQuestionTrialId = data.Id,
|
|
ParentTriggerValue = data.ParentTriggerValue,
|
|
GroupName = data.GroupName,
|
|
QuestionName = data.QuestionName,
|
|
IsRequired = data.IsRequired,
|
|
ShowOrder = data.ShowOrder,
|
|
ParentId = data.ParentId,
|
|
TypeValue = data.TypeValue,
|
|
Answer = string.Empty,
|
|
PageShowOrder = data.ShowOrder,
|
|
Type=data.Type,
|
|
};
|
|
|
|
var qusetionList = await query.OrderBy(x => x.ShowOrder).ToListAsync();
|
|
|
|
var groupList = new List<GetTrialReadingQuestionOutDto>();
|
|
|
|
qusetionList = qusetionList.Where(x => x.ReadingCriterionPageId == null).ToList();
|
|
|
|
groupList = qusetionList.Where(x => x.Type == "group" || (x.ParentId == null && x.GroupName.IsNullOrEmpty())).ToList();
|
|
groupList.ForEach(x =>
|
|
{
|
|
this.FindChildQuestion(x, qusetionList);
|
|
});
|
|
|
|
groupList = groupList.Where(x => !(x.Type == "group" && x.Childrens.Count() == 0)).ToList();
|
|
|
|
result.SinglePage = groupList;
|
|
|
|
|
|
return (result);
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region 获取阅片任务和答案
|
|
/// <summary>
|
|
/// 获取阅片任务和答案
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task<List<GetTrialReadingQuestionOutDto>> GetTaskAndAnswer(Guid visitTaskId)
|
|
{
|
|
var taskQuery = from questionAnswer in _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == visitTaskId)
|
|
join trialQuestion in _readingQuestionTrialRepository.AsQueryable() on questionAnswer.ReadingQuestionTrialId equals trialQuestion.Id
|
|
select new GetTrialReadingQuestionOutDto()
|
|
{
|
|
ReadingQuestionTrialId = trialQuestion.Id,
|
|
ReadingQuestionCriterionTrialId = trialQuestion.ReadingQuestionCriterionTrialId,
|
|
TrialId = trialQuestion.TrialId,
|
|
Type = trialQuestion.Type,
|
|
ParentTriggerValue = trialQuestion.ParentTriggerValue,
|
|
GroupName = trialQuestion.GroupName,
|
|
QuestionName = trialQuestion.QuestionName,
|
|
IsRequired = trialQuestion.IsRequired,
|
|
ShowOrder = trialQuestion.ShowOrder,
|
|
ParentId = trialQuestion.ParentId,
|
|
TypeValue = trialQuestion.TypeValue,
|
|
Answer = questionAnswer.Answer
|
|
};
|
|
var qusetionList = await taskQuery.OrderBy(x => x.ShowOrder).ToListAsync();
|
|
List<GetTrialReadingQuestionOutDto> groupList = qusetionList.Where(x => x.ParentId == null).ToList();
|
|
groupList.ForEach(x =>
|
|
{
|
|
this.FindChildQuestion(x, qusetionList);
|
|
});
|
|
|
|
return groupList;
|
|
}
|
|
#endregion
|
|
|
|
#region 获取裁判阅片任务信息
|
|
/// <summary>
|
|
/// 获取裁判阅片任务信息
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<GetJudgeReadingInfoOutDto> GetJudgeReadingInfo(GetJudgeReadingInfo inDto)
|
|
{
|
|
var visitTask = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => new
|
|
{
|
|
x.ReadingTaskState,
|
|
x.JudgeResultTaskId,
|
|
x.JudgeResultRemark,
|
|
x.JudgeResultImagePath,
|
|
}).FirstOrDefaultAsync();
|
|
GetJudgeReadingInfoOutDto judgeInfo = new GetJudgeReadingInfoOutDto()
|
|
{
|
|
ReadingTaskState = visitTask.ReadingTaskState,
|
|
JudgeResultTaskId = visitTask.JudgeResultTaskId,
|
|
JudgeResultRemark = visitTask.JudgeResultRemark,
|
|
JudgeResultImagePath = visitTask.JudgeResultImagePath,
|
|
VisitInfoList = new List<JudgeReadingInfoDto>()
|
|
};
|
|
|
|
var judgeDataInfo = await _readingJudgeInfoRepository.Where(x => x.JudgeTaskId == inDto.VisitTaskId).FirstNotNullAsync();
|
|
|
|
var taskids = new List<Guid>();
|
|
|
|
taskids.Add(judgeDataInfo.TaskIdOne);
|
|
taskids.Add(judgeDataInfo.TaskIdTwo);
|
|
var taskList = await _visitTaskRepository.Where(x => taskids.Contains(x.Id)).OrderBy(x=>x.ArmEnum).ToListAsync();
|
|
judgeInfo.VisitTaskArmList = taskList.Select(x => new VisitTaskArm()
|
|
{
|
|
ArmEnum = x.ArmEnum,
|
|
VisitTaskId = x.Id
|
|
|
|
}).ToList();
|
|
var visitIds = await _visitTaskRepository.Where(x => x.JudgeVisitTaskId == inDto.VisitTaskId).Select(x => new
|
|
{
|
|
x.Id,
|
|
x.ArmEnum,
|
|
}).ToListAsync();
|
|
|
|
switch (taskList[0].ReadingCategory)
|
|
{
|
|
case ReadingCategory.Visit:
|
|
JudgeReadingInfoDto judgeReadingInfoDto = new JudgeReadingInfoDto() {
|
|
VisitId = taskList[0].SourceSubjectVisitId.Value,
|
|
VisitName = taskList[0].TaskBlindName,
|
|
VisitTaskInfoList = new List<JudgeReadingQuestion>(),
|
|
};
|
|
|
|
foreach (var item in taskList)
|
|
{
|
|
judgeReadingInfoDto.VisitTaskInfoList.Add(new JudgeReadingQuestion()
|
|
{
|
|
ArmEnum = item.ArmEnum,
|
|
VisitTaskId = item.Id,
|
|
JudgeQuestionList = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == item.Id && x.ReadingQuestionTrial.IsJudgeQuestion).OrderBy(x => x.ReadingQuestionTrial.ShowOrder)
|
|
.Select(x => new JudgeQuestion()
|
|
{
|
|
Answer = x.Answer,
|
|
QuestionId = x.ReadingQuestionTrial.Id,
|
|
QuestionName = x.ReadingQuestionTrial.QuestionName
|
|
|
|
}).ToListAsync(),
|
|
});
|
|
}
|
|
judgeInfo.VisitInfoList.Add(judgeReadingInfoDto);
|
|
break;
|
|
|
|
case ReadingCategory.Global:
|
|
var taskOneInfo = await this.GetGlobalReadingInfo(new GetGlobalReadingInfoInDto()
|
|
{
|
|
UsingOriginalData = true,
|
|
VisitTaskId = taskList[0].Id
|
|
});
|
|
|
|
var taskTwoInfo = await this.GetGlobalReadingInfo(new GetGlobalReadingInfoInDto()
|
|
{
|
|
UsingOriginalData = true,
|
|
VisitTaskId = taskList[1].Id
|
|
});
|
|
|
|
|
|
foreach (var item in taskOneInfo.TaskList)
|
|
{
|
|
GlobalVisitInfo twoItem = taskTwoInfo.TaskList.Where(x => x.VisitId == item.VisitId).FirstOrDefault();
|
|
|
|
JudgeReadingInfoDto judgeReadingInfo = new JudgeReadingInfoDto()
|
|
{
|
|
VisitId = item.VisitId,
|
|
VisitName = item.VisitName,
|
|
VisitTaskInfoList = new List<JudgeReadingQuestion>(),
|
|
};
|
|
|
|
judgeReadingInfo.VisitTaskInfoList.Add(new JudgeReadingQuestion()
|
|
{
|
|
ArmEnum = item.ArmEnum,
|
|
VisitTaskId = item.VisitTaskId,
|
|
JudgeQuestionList = item.AfterQuestionList.Where(x => x.QuestionId != null).Select(x => new JudgeQuestion()
|
|
{
|
|
|
|
Answer = x.Answer,
|
|
QuestionId = x.QuestionId.Value,
|
|
QuestionName = x.QuestionName
|
|
}).ToList()
|
|
});
|
|
if (twoItem != null)
|
|
{
|
|
judgeReadingInfo.VisitTaskInfoList.Add(new JudgeReadingQuestion()
|
|
{
|
|
ArmEnum = twoItem.ArmEnum,
|
|
VisitTaskId = twoItem.VisitTaskId,
|
|
JudgeQuestionList = twoItem.AfterQuestionList.Where(x => x.QuestionId != null).Select(x => new JudgeQuestion()
|
|
{
|
|
|
|
Answer = x.Answer,
|
|
QuestionId = x.QuestionId.Value,
|
|
QuestionName = x.QuestionName
|
|
}).ToList()
|
|
});
|
|
}
|
|
|
|
judgeInfo.VisitInfoList.Add(judgeReadingInfo);
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
return judgeInfo;
|
|
}
|
|
#endregion
|
|
|
|
#region 保存裁判问题
|
|
/// <summary>
|
|
/// 保存裁判问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SaveJudgeVisitTaskResult(SaveJudgeVisitTaskResult inDto)
|
|
{
|
|
await _visitTaskRepository.UpdatePartialFromQueryAsync(inDto.VisitTaskId, x => new VisitTask()
|
|
{
|
|
JudgeResultTaskId = inDto.JudgeResultTaskId,
|
|
JudgeResultRemark = inDto.JudgeResultRemark,
|
|
JudgeResultImagePath = inDto.JudgeResultImagePath,
|
|
|
|
});
|
|
var result = await _visitTaskRepository.SaveChangesAsync();
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
#endregion
|
|
|
|
#region 获取既往结果
|
|
/// <summary>
|
|
/// 获取既往结果
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<List<GetReadingPastResultListOutDto>> GetReadingPastResultList(GetReadingPastResultListInDto inDto)
|
|
{
|
|
var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
|
|
var readingPastResultList = await _visitTaskRepository.Where(x => x.TrialId == inDto.TrialId && x.SubjectId == inDto.SubjectId && x.DoctorUserId == _userInfo.Id
|
|
&& x.Id != inDto.VisitTaskId && x.ReadingTaskState == ReadingTaskState.HaveSigned&&x.TaskState==TaskState.Effect)
|
|
.Where(x=>x.IsAnalysisCreate== taskInfo.IsAnalysisCreate).ProjectTo<GetReadingPastResultListOutDto>(_mapper.ConfigurationProvider).OrderBy(x=>x.VisitTaskNum).ToListAsync();
|
|
return readingPastResultList;
|
|
}
|
|
#endregion
|
|
|
|
#region 找子问题
|
|
/// <summary>
|
|
/// 找子问题
|
|
/// </summary>
|
|
/// <param name="trialReadingQuestion"></param>
|
|
/// <param name="questionlists"></param>
|
|
[NonDynamicMethod]
|
|
public void FindChildQuestion(GetTrialReadingQuestionOutDto trialReadingQuestion, List<GetTrialReadingQuestionOutDto> questionlists)
|
|
{
|
|
trialReadingQuestion.Childrens = questionlists.Where(x => x.ParentId == trialReadingQuestion.ReadingQuestionTrialId || (trialReadingQuestion.Type == "group" && x.Type != "group" && x.ParentId == null && x.GroupName == trialReadingQuestion.GroupName)).ToList();
|
|
if (trialReadingQuestion.Childrens != null && trialReadingQuestion.Childrens.Count != 0)
|
|
{
|
|
trialReadingQuestion.Childrens.ForEach(x =>
|
|
{
|
|
this.FindChildQuestion(x, questionlists);
|
|
});
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region 保存任务问题
|
|
/// <summary>
|
|
/// 保存任务问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> SaveVisitTaskQuestions(SubmitVisitTaskQuestionsInDto inDto)
|
|
{
|
|
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 _visitTaskRepository.UpdatePartialFromQueryAsync(x => x.Id == inDto.VisitTaskId, x => new VisitTask()
|
|
{
|
|
ReadingTaskState = ReadingTaskState.Reading,
|
|
|
|
});
|
|
await _readingTaskQuestionAnswerRepository.AddRangeAsync(readingTaskAnswerList);
|
|
var result = await _visitTaskRepository.SaveChangesAsync();
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region 提交问题
|
|
|
|
/// <summary>
|
|
/// 提交访视阅片问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[NonDynamicMethod]
|
|
public async Task<IResponseOutput> SubmitVisitTaskQuestions(SubmitVisitTaskQuestionsInDto inDto)
|
|
{
|
|
await this.SaveVisitTaskQuestions(inDto);
|
|
|
|
|
|
|
|
await this.SubmitTaskChangeState(inDto.VisitTaskId);
|
|
return ResponseOutput.Ok(true);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 提交裁判问题
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[NonDynamicMethod]
|
|
public async Task<IResponseOutput> SubmitJudgeVisitTaskResult(SaveJudgeVisitTaskResult inDto)
|
|
{
|
|
await _visitTaskRepository.UpdatePartialFromQueryAsync(inDto.VisitTaskId, x => new VisitTask()
|
|
{
|
|
JudgeResultTaskId = inDto.JudgeResultTaskId,
|
|
ReadingTaskState = ReadingTaskState.HaveSigned,
|
|
JudgeResultRemark = inDto.JudgeResultRemark,
|
|
SignTime = DateTime.Now,
|
|
JudgeResultImagePath = inDto.JudgeResultImagePath,
|
|
});
|
|
var result = await _visitTaskRepository.SaveChangesAsync();
|
|
return ResponseOutput.Ok(result);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 提交全局阅片结果
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
[NonDynamicMethod]
|
|
public async Task<IResponseOutput> SubmitGlobalReadingInfo(SubmitGlobalReadingInfoInDto inDto)
|
|
{
|
|
//var result = await this.SaveGlobalReadingInfo(inDto);
|
|
|
|
await this.SubmitTaskChangeState(inDto.GlobalTaskId);
|
|
|
|
return ResponseOutput.Ok(true) ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 签名提交任务修改状态
|
|
/// </summary>
|
|
/// <param name="visitTaskId"></param>
|
|
/// <returns></returns>
|
|
private async Task SubmitTaskChangeState(Guid visitTaskId)
|
|
{
|
|
await _visitTaskRepository.BatchUpdateNoTrackingAsync(x => x.Id == visitTaskId, x => new VisitTask()
|
|
{
|
|
ReadingTaskState = ReadingTaskState.HaveSigned,
|
|
SignTime = DateTime.Now,
|
|
});
|
|
|
|
// 触裁判任务
|
|
await this.TriggerJudgeQuestion(visitTaskId);
|
|
// 添加阅片期任务
|
|
await this.AddReadingTask(visitTaskId);
|
|
// 完成阅片修改状态
|
|
await this.FinishReadUpdateState(visitTaskId);
|
|
}
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 完成阅片修改状态
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task FinishReadUpdateState(Guid visitTaskId)
|
|
{
|
|
var taskInfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).FirstNotNullAsync();
|
|
if (!await _visitTaskRepository.AnyAsync(x => x.SourceSubjectVisitId == taskInfo.SourceSubjectVisitId && x.SouceReadModuleId == taskInfo.SouceReadModuleId && x.ReadingTaskState != ReadingTaskState.HaveSigned))
|
|
{
|
|
if (taskInfo.SouceReadModuleId != null)
|
|
{
|
|
await _readModuleRepository.UpdatePartialFromQueryAsync(taskInfo.SouceReadModuleId.Value, x => new ReadModule
|
|
{
|
|
ReadingStatus = ReadingStatusEnum.ReadCompleted
|
|
});
|
|
}
|
|
else if (taskInfo.SourceSubjectVisitId != null)
|
|
{
|
|
await _subjectVisitRepository.UpdatePartialFromQueryAsync(taskInfo.SourceSubjectVisitId.Value, x => new SubjectVisit
|
|
{
|
|
ReadingStatus = ReadingStatusEnum.ReadCompleted
|
|
});
|
|
}
|
|
await _subjectVisitRepository.SaveChangesAsync();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加阅片期任务
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task AddReadingTask(Guid visitTaskId)
|
|
{
|
|
// ****** 先生成阅片期 阅片期任务阅片完成之后生成肿瘤学的 如果没有阅片期 直接生成肿瘤学 *********////
|
|
#region 建立关系
|
|
// 访视阅完产生 全局
|
|
Dictionary<ModuleTypeEnum, ReadingCategory> typeChangeDic = new Dictionary<ModuleTypeEnum, ReadingCategory>();
|
|
typeChangeDic.Add(ModuleTypeEnum.InPlanSubjectVisit, ReadingCategory.Visit);
|
|
typeChangeDic.Add(ModuleTypeEnum.OutPlanSubjectVisit, ReadingCategory.Visit);
|
|
//typeChange.Add(ModuleTypeEnum.Read, ReadingCategory.ReadingPeriod);
|
|
typeChangeDic.Add(ModuleTypeEnum.Global, ReadingCategory.Global);
|
|
typeChangeDic.Add(ModuleTypeEnum.Referee, ReadingCategory.Judge);
|
|
typeChangeDic.Add(ModuleTypeEnum.Oncology, ReadingCategory.Oncology);
|
|
#endregion
|
|
var taskInfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).FirstNotNullAsync();
|
|
List<ReadingGenerataTaskDTO> needReadList = new List<ReadingGenerataTaskDTO>();
|
|
if (!taskInfo.IsAnalysisCreate)
|
|
{
|
|
// 任务类型
|
|
switch (taskInfo.ReadingCategory)
|
|
{
|
|
case ReadingCategory.Visit:
|
|
needReadList = await _readModuleRepository.Where(x => x.SubjectVisitId == taskInfo.SourceSubjectVisitId)
|
|
.Select(x => new ReadingGenerataTaskDTO
|
|
{
|
|
IsUrgent = x.IsUrgent ?? false,
|
|
SubjectId = x.SubjectId,
|
|
VisitNum=x.VisitNum,
|
|
ReadingName = x.ModuleName,
|
|
ReadModuleId = x.Id,
|
|
ReadingCategory = typeChangeDic[x.ModuleType],
|
|
}).ToListAsync();
|
|
if (needReadList.Any(x => x.ReadingCategory == ReadingCategory.Global))
|
|
{
|
|
needReadList = needReadList.Where(x => x.ReadingCategory != ReadingCategory.Oncology).ToList();
|
|
}
|
|
//needReadList = needReadList.Where(x => _visitTaskRepository.Where(y => y.SouceReadModuleId == x.ReadModuleId).Count() == 0).ToList();
|
|
await _visitTaskHelpeService.AddTaskAsync(new GenerateTaskCommand()
|
|
{
|
|
OriginalVisitId= visitTaskId,
|
|
ReadingCategory = GenerateTaskCategory.Global,
|
|
TrialId = taskInfo.TrialId,
|
|
ReadingGenerataTaskList = needReadList
|
|
}) ;
|
|
break;
|
|
// 肿瘤学
|
|
case ReadingCategory.Global:
|
|
var subjectId = await _readModuleRepository.Where(x => x.Id == taskInfo.SouceReadModuleId).Select(x => x.SubjectVisitId).FirstOrDefaultAsync();
|
|
needReadList=await _readModuleRepository.Where(x => x.SubjectVisitId == subjectId&&x.ModuleType==ModuleTypeEnum.Oncology)
|
|
.Select(x => new ReadingGenerataTaskDTO
|
|
{
|
|
IsUrgent = x.IsUrgent ?? false,
|
|
SubjectId = x.SubjectId,
|
|
ReadingName = x.ModuleName,
|
|
VisitNum = x.VisitNum,
|
|
ReadModuleId = x.Id,
|
|
ReadingCategory = typeChangeDic[x.ModuleType],
|
|
}).ToListAsync();
|
|
if (taskInfo.JudgeVisitTaskId == null)
|
|
{
|
|
// 有裁判要等裁判完成之后才进行添加
|
|
await _visitTaskHelpeService.AddTaskAsync(new GenerateTaskCommand()
|
|
{
|
|
|
|
ReadingCategory = GenerateTaskCategory.Oncology,
|
|
TrialId = taskInfo.TrialId,
|
|
ReadingGenerataTaskList = needReadList
|
|
});
|
|
}
|
|
//needReadList = needReadList.Where(x => _visitTaskRepository.Where(y => y.SouceReadModuleId == x.ReadModuleId).Count() == 0).ToList();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 触发裁判任务(新)
|
|
/// </summary>
|
|
/// <param name="visitTaskId"></param>
|
|
/// <returns></returns>
|
|
private async Task TriggerJudgeQuestion(Guid visitTaskId)
|
|
{
|
|
List<Guid> visitTaskids = new List<Guid>();
|
|
|
|
var visitTask = await _visitTaskRepository.Where(x => x.Id == visitTaskId).AsNoTracking().FirstNotNullAsync();
|
|
|
|
// 判断是否是一致性核查产生
|
|
if (visitTask.IsAnalysisCreate&& visitTask.ConsistentAnalysisOriginalTaskId!=null)
|
|
{
|
|
visitTaskids.Add(visitTask.Id);
|
|
visitTaskids.Add(visitTask.ConsistentAnalysisOriginalTaskId.Value);
|
|
}
|
|
else
|
|
{
|
|
// 这里是非一致性分析产生的
|
|
visitTaskids = await _visitTaskRepository.Where(x => x.ReadingTaskState == ReadingTaskState.HaveSigned && x.ReadingCategory != ReadingCategory.Judge
|
|
&& x.TaskState== TaskState.Effect
|
|
&& x.IsAnalysisCreate==false
|
|
&& x.ReReadingApplyState != ReReadingApplyState.Agree && x.SourceSubjectVisitId == visitTask.SourceSubjectVisitId && x.SouceReadModuleId == visitTask.SouceReadModuleId).Select(x => x.Id).ToListAsync();
|
|
}
|
|
|
|
var trialInfo = await _trialRepository.Where(x => x.Id == visitTask.TrialId).Select(x=> new {
|
|
x.IsArbitrationReading,
|
|
x.ArbitrationRule
|
|
}).FirstNotNullAsync();
|
|
|
|
var noteEqual = false;
|
|
|
|
// 判断项目是否设置了裁判
|
|
if (trialInfo.IsArbitrationReading ?? false)
|
|
{
|
|
// 判断数量是否为2 是否仲裁
|
|
if (visitTaskids.Count == 2)
|
|
{
|
|
switch (visitTask.ReadingCategory)
|
|
{
|
|
// 访视
|
|
case ReadingCategory.Visit:
|
|
// 查找两个 访视的阅片答案
|
|
var query = from questionAnswet in _readingTaskQuestionAnswerRepository.Where(x => visitTaskids.Contains(x.VisitTaskId))
|
|
join question in _readingQuestionTrialRepository.Where(x => x.IsJudgeQuestion) on new { ReadingQuestionTrialId = questionAnswet.ReadingQuestionTrialId } equals new { ReadingQuestionTrialId = question.Id }
|
|
select new TaskAnswerDto()
|
|
{
|
|
Answer = questionAnswet.Answer,
|
|
AnswerGroup = question.AnswerGroup,
|
|
AnswerCombination = question.AnswerCombination,
|
|
JudgeType = question.JudgeType,
|
|
QuestionId = question.Id,
|
|
VisitTaskId = questionAnswet.VisitTaskId,
|
|
};
|
|
var questionAnswerlist = await query.ToListAsync();
|
|
|
|
// 将答案进行分组
|
|
List<GroupTaskAnswerDto> groupTasks = questionAnswerlist.GroupBy(x => new { x.QuestionId, x.AnswerGroup, x.JudgeType, x.AnswerCombination }).Select(x => new GroupTaskAnswerDto
|
|
{
|
|
QuestionId = x.Key.QuestionId,
|
|
AnswerGroup = x.Key.AnswerGroup,
|
|
AnswerCombination = x.Key.AnswerCombination,
|
|
JudgeType = x.Key.JudgeType,
|
|
TaskAnswerList = x.Select(y => y.Answer).ToList(),
|
|
}).ToList();
|
|
noteEqual = ComputeJudgeResult(groupTasks);
|
|
break;
|
|
case ReadingCategory.Global:
|
|
var taskOneInfo = await this.GetGlobalReadingInfo(new GetGlobalReadingInfoInDto()
|
|
{
|
|
UsingOriginalData = true,
|
|
VisitTaskId = visitTaskids[0]
|
|
});
|
|
|
|
var taskTwoInfo = await this.GetGlobalReadingInfo(new GetGlobalReadingInfoInDto()
|
|
{
|
|
UsingOriginalData = true,
|
|
VisitTaskId = visitTaskids[1]
|
|
});
|
|
|
|
// 判断两个任务是否
|
|
if (taskOneInfo.TaskList.Count() != taskTwoInfo.TaskList.Count())
|
|
{
|
|
noteEqual = true;
|
|
}
|
|
else
|
|
{
|
|
foreach (var item in taskOneInfo.TaskList)
|
|
{
|
|
GlobalVisitInfo twoItem = taskTwoInfo.TaskList.Where(x => x.VisitId == item.VisitId).FirstOrDefault();
|
|
|
|
if (twoItem == null)
|
|
{
|
|
noteEqual = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
var newlist = item.AfterQuestionList.Where(x => x.QuestionId != null).ToList().Union(
|
|
twoItem.AfterQuestionList.Where(x => x.QuestionId != null).ToList()
|
|
).ToList();
|
|
|
|
List<GroupTaskAnswerDto> globalGroupTasks = newlist.GroupBy(x => new { x.QuestionId, x.AnswerGroup, x.JudgeType, x.AnswerCombination }).Select(x => new GroupTaskAnswerDto
|
|
{
|
|
QuestionId = x.Key.QuestionId.Value,
|
|
AnswerGroup = x.Key.AnswerGroup,
|
|
AnswerCombination = x.Key.AnswerCombination,
|
|
JudgeType = x.Key.JudgeType,
|
|
TaskAnswerList = x.Select(y => y.Answer).ToList(),
|
|
}).ToList();
|
|
noteEqual = noteEqual || ComputeJudgeResult(globalGroupTasks);
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// 这里判断一致性分析产生的全局阅片
|
|
if (visitTask.ReadingCategory == ReadingCategory.Global && visitTask.IsAnalysisCreate)
|
|
{
|
|
var taskOneInfo = await this.GetGlobalReadingInfo(new GetGlobalReadingInfoInDto()
|
|
{
|
|
UsingOriginalData = true,
|
|
VisitTaskId = visitTask.Id
|
|
});
|
|
|
|
// 找到最后一个任务ID
|
|
var lastTask = taskOneInfo.TaskList.Last();
|
|
|
|
if (lastTask == null)
|
|
{
|
|
noteEqual = true;
|
|
}
|
|
else {
|
|
var query = from questionAnswet in _readingTaskQuestionAnswerRepository.Where(x =>
|
|
x.VisitTask.IsAnalysisCreate==false&&
|
|
x.VisitTask.DoctorUserId==visitTask.DoctorUserId&&
|
|
x.VisitTask.TaskState== TaskState.Effect&&
|
|
(x.VisitTask.SourceSubjectVisitId??default(Guid))== lastTask.VisitId)
|
|
join question in _readingQuestionTrialRepository.Where(x => x.IsJudgeQuestion) on new { ReadingQuestionTrialId = questionAnswet.ReadingQuestionTrialId } equals new { ReadingQuestionTrialId = question.Id }
|
|
select new GlobalQuestionInfo()
|
|
{
|
|
Answer = questionAnswet.Answer,
|
|
AnswerGroup = question.AnswerGroup,
|
|
AnswerCombination = question.AnswerCombination,
|
|
JudgeType = question.JudgeType,
|
|
QuestionId = question.Id,
|
|
|
|
};
|
|
|
|
var visitTaskQuestions =await query.ToListAsync();
|
|
|
|
var newlist = visitTaskQuestions.Where(x => x.QuestionId != null).ToList().Union(
|
|
lastTask.AfterQuestionList.Where(x => x.QuestionId != null).ToList()
|
|
).ToList();
|
|
|
|
List<GroupTaskAnswerDto> globalGroupTasks = newlist.GroupBy(x => new { x.QuestionId, x.AnswerGroup, x.JudgeType, x.AnswerCombination }).Select(x => new GroupTaskAnswerDto
|
|
{
|
|
QuestionId = x.Key.QuestionId.Value,
|
|
AnswerGroup = x.Key.AnswerGroup,
|
|
AnswerCombination = x.Key.AnswerCombination,
|
|
JudgeType = x.Key.JudgeType,
|
|
TaskAnswerList = x.Select(y => y.Answer).ToList(),
|
|
}).ToList();
|
|
noteEqual = noteEqual || ComputeJudgeResult(globalGroupTasks);
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (noteEqual)
|
|
{
|
|
if (visitTask.IsAnalysisCreate)
|
|
{
|
|
await _visitTaskRepository.BatchUpdateNoTrackingAsync(x => x.Id == visitTaskId, x => new VisitTask()
|
|
{
|
|
IsAnalysisDiffToOriginalData = true
|
|
});
|
|
await _visitTaskRepository.SaveChangesAsync();
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
if ((visitTask.SourceSubjectVisitId != null && trialInfo.ArbitrationRule == ArbitrationRule.Visit) || (visitTask.SouceReadModuleId != null && trialInfo.ArbitrationRule == ArbitrationRule.Reading))
|
|
{
|
|
await this.SaveJudgeTask(new SaveJudgeTaskDto()
|
|
{
|
|
VisitTaskIds = visitTaskids,
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
if (visitTask.IsAnalysisCreate)
|
|
{
|
|
await _visitTaskRepository.BatchUpdateNoTrackingAsync(x => x.Id == visitTaskId, x => new VisitTask()
|
|
{
|
|
IsAnalysisDiffToOriginalData = false
|
|
});
|
|
await _visitTaskRepository.SaveChangesAsync();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 计算返回的结果 为True表示不相等
|
|
/// </summary>
|
|
/// <param name="groupTasks"></param>
|
|
/// <returns></returns>
|
|
private bool ComputeJudgeResult(List<GroupTaskAnswerDto> groupTasks)
|
|
{
|
|
var noteEqual = false;
|
|
foreach (var item in groupTasks)
|
|
{
|
|
if (item.TaskAnswerList.Count() != 2)
|
|
{
|
|
noteEqual = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
var taskAnswer1 = item.TaskAnswerList[0];
|
|
var taskAnswer2 = item.TaskAnswerList[1];
|
|
if (taskAnswer1 != taskAnswer2)
|
|
{
|
|
|
|
switch (item.JudgeType)
|
|
{
|
|
case JudgeTypeEnum.AnswerDisaffinity:
|
|
noteEqual = true;
|
|
break;
|
|
case JudgeTypeEnum.AnswerGroup:
|
|
var answerGroupList = JsonConvert.DeserializeObject<List<string>>(item.AnswerGroup).Select(x => new AnswerGroup()
|
|
{
|
|
GroupId = NewId.NextGuid(),
|
|
GroupValue = x
|
|
}).ToList();
|
|
var itemAnswerGroupsitem1 = answerGroupList.Where(x => x.GroupValue.Contains($"|{taskAnswer1}|"));
|
|
var itemAnswerGroupsitem2 = answerGroupList.Where(x => x.GroupValue.Contains($"|{taskAnswer2}|"));
|
|
var unionList = itemAnswerGroupsitem1.Intersect(itemAnswerGroupsitem2).ToList();
|
|
if (unionList.Count < 1)
|
|
{
|
|
noteEqual = true;
|
|
}
|
|
break;
|
|
case JudgeTypeEnum.AnswerCombination:
|
|
var answerCombinationList = JsonConvert.DeserializeObject<List<AnswerCombinationDto>>(item.AnswerCombination == string.Empty ? "[]" : item.AnswerCombination).ToList();
|
|
answerCombinationList.ForEach(x =>
|
|
{
|
|
if (x.AnswerGroupA.Contains(taskAnswer1) && x.AnswerGroupB.Contains(taskAnswer2))
|
|
{
|
|
noteEqual = true;
|
|
}
|
|
if (x.AnswerGroupB.Contains(taskAnswer1) && x.AnswerGroupA.Contains(taskAnswer2))
|
|
{
|
|
noteEqual = true;
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return noteEqual;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加裁判任务
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task SaveJudgeTask(SaveJudgeTaskDto inDto)
|
|
{
|
|
var trialId = await _visitTaskRepository.Where(x => inDto.VisitTaskIds.Contains(x.Id)).Select(x => x.TrialId).FirstOrDefaultAsync();
|
|
|
|
await _visitTaskHelpeService.AddTaskAsync(new GenerateTaskCommand()
|
|
{
|
|
JudgeVisitTaskIdList= inDto.VisitTaskIds,
|
|
ReadingCategory= GenerateTaskCategory.Judge,
|
|
TrialId= trialId
|
|
});
|
|
}
|
|
|
|
}
|
|
}
|