//--------------------------------------------------------------------
// 此代码由T4模板自动生成 byzhouhang 20210918
// 生成时间 2023-06-15 15:06:06
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------
using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.Service.Reading.Dto;
using IRaCIS.Core.Application.Service.Reading.Interface;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infra.EFCore.Common;
using IRaCIS.Core.Infrastructure;
using MassTransit;
using Microsoft.AspNetCore.Mvc;
namespace IRaCIS.Core.Application.Service
{
/// <summary>
/// 临床答案
/// </summary>
[ApiExplorerSettings(GroupName = "Reading")]
public class ClinicalAnswerService(IRepository<TrialClinicalQuestion> _trialClinicalQuestionRepository,
IRepository<TrialClinicalTableQuestion> _trialClinicalTableQuestionRepository,
IRepository<ClinicalDataTrialSet> _clinicalDataTrialSetRepository,
IRepository<ClinicalForm> _clinicalFormRepository,
IRepository<Subject> _subjectRepository,
IRepository<ReadModuleCriterionFrom> _readModuleCriterionFromRepository,
IRepository<ReadModule> _readModuleRepository,
IRepository<DicomStudy> _dicomStudyRepository,
IRepository<ClinicalQuestionAnswer> _clinicalQuestionAnswerRepository,
IRepository<ClinicalTableAnswer> _clinicalTableAnswerRepository,
IRepository<ClinicalAnswerRowInfo> _clinicalAnswerRowInfoRepository,
IRepository<ReadingClinicalData> _readingClinicalDataRepository,
IRepository<SubjectVisit> _subjectVisitRepository,
IClinicalQuestionService _iClinicalQuestionService,
IReadingClinicalDataService _iReadingClinicalDataService, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService, IClinicalAnswerService
{
/// <summary>
/// CRC签名临床数据
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<IResponseOutput> CRCSignClinicalData(CRCSignClinicalDataInDto inDto)
{
await _readingClinicalDataRepository.UpdatePartialFromQueryAsync(x => x.Id == inDto.ReadingClinicalDataId, x => new ReadingClinicalData()
{
IsSign = true,
ReadingClinicalDataState = ReadingClinicalDataStatus.HaveSigned
});
await _readingClinicalDataRepository.SaveChangesAsync();
return ResponseOutput.Ok(true);
}
/// <summary>
/// 删除检查级别临床数据
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
public async Task DeleteStudyClinical(DeleteStudyClinicalInDto inDto)
{
await _readingClinicalDataRepository.BatchDeleteNoTrackingAsync(x => x.StudyId == inDto.StudyId);
}
/// <summary>
/// 添加检查级别临床数据
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
public async Task AddStudyClinical(AddStudyClinicalInDto inDto)
{
var studyInfo = await _dicomStudyRepository.Where(x => x.Id == inDto.StudyId).FirstNotNullAsync();
List<ClinicalDataTrialSet> clinicals = await _clinicalDataTrialSetRepository.Where(x =>
x.TrialId == studyInfo.TrialId && x.IsConfirm && x.ClinicalDataLevel == ClinicalLevel.Study).ToListAsync();
List<ReadingClinicalData> datas = new List<ReadingClinicalData>();
clinicals.ForEach(x =>
{
datas.Add(new ReadingClinicalData()
{
ClinicalDataTrialSetId = x.Id,
IsVisit = true,
SubjectId = studyInfo.SubjectId,
ReadingId = studyInfo.SubjectVisitId,
TrialId = studyInfo.TrialId,
StudyId = studyInfo.Id
});
});
await _readingClinicalDataRepository.AddRangeAsync(datas);
await _readingClinicalDataRepository.SaveChangesAsync();
}
/// <summary>
/// 自动添加CRC临床数据 (不包括检查级别)
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
public async Task AutoAddCRCClinical(AutoAddClinicalInDto inDto)
{
var dataTrialSetList = await _clinicalDataTrialSetRepository.Where(x => x.TrialId == inDto.TrialId && x.UploadRole == UploadRole.CRC && x.IsConfirm)
.IgnoreAutoIncludes().ToListAsync();
var baseLine = await _subjectVisitRepository.Where(x => x.TrialId == inDto.TrialId)
.WhereIf(inDto.SubjectId != null, x => x.SubjectId == inDto.SubjectId)
.Select(x => new
{
x.SubjectId,
VisitId = x.Id,
x.IsBaseLine,
}).ToListAsync();
var clinicalDataList = await _readingClinicalDataRepository
.WhereIf(inDto.SubjectId != null, x => x.SubjectId == inDto.SubjectId)
.Where(x => x.TrialId == inDto.TrialId && x.ClinicalDataTrialSet.UploadRole == UploadRole.CRC)
.Select(x => new
{
ClinicalDataTrialSetId = x.ClinicalDataTrialSetId,
SubjectId = x.SubjectId,
x.ReadingId,
}).ToListAsync();
List<ReadingClinicalData> readingClinicalDatas = new List<ReadingClinicalData>();
baseLine.Select(x => x.SubjectId).Distinct().ForEach(n =>
{
var baseLineVisitId = baseLine.Where(x => x.IsBaseLine && x.SubjectId == n).Select(x => x.VisitId).First();
readingClinicalDatas.AddRange(
dataTrialSetList.Where(x => x.ClinicalDataLevel == ClinicalLevel.Subject).Where(x => clinicalDataList.Where(y => y.ClinicalDataTrialSetId == x.Id && y.SubjectId == n).Count() == 0)
.Select(x => new ReadingClinicalData()
{
ClinicalDataTrialSetId = x.Id,
IsVisit = true,
SubjectId = n,
ReadingId = baseLineVisitId,
TrialId = inDto.TrialId
}).ToList());
readingClinicalDatas.AddRange(
dataTrialSetList.Where(x => x.ClinicalDataLevel == ClinicalLevel.ImageRead).Where(x => clinicalDataList.Where(y => y.ClinicalDataTrialSetId == x.Id && y.SubjectId == n).Count() == 0)
.Select(x => new ReadingClinicalData()
{
ClinicalDataTrialSetId = x.Id,
IsVisit = false,
SubjectId = n,
ReadingId = default(Guid),
TrialId = inDto.TrialId
}).ToList());
readingClinicalDatas.AddRange(
dataTrialSetList.Where(x => x.ClinicalDataLevel == ClinicalLevel.OncologyRead).Where(x => clinicalDataList.Where(y => y.ClinicalDataTrialSetId == x.Id && y.SubjectId == n).Count() == 0)
.Select(x => new ReadingClinicalData()
{
ClinicalDataTrialSetId = x.Id,
IsVisit = false,
SubjectId = n,
ReadingId = default(Guid),
TrialId = inDto.TrialId
}).ToList());
});
baseLine.ForEach(n =>
{
readingClinicalDatas.AddRange(
dataTrialSetList.Where(x => x.ClinicalDataLevel == ClinicalLevel.SubjectVisit).Where(x => clinicalDataList.Where(y => y.ClinicalDataTrialSetId == x.Id && y.ReadingId == n.VisitId).Count() == 0)
.Select(x => new ReadingClinicalData()
{
ClinicalDataTrialSetId = x.Id,
IsVisit = true,
SubjectId = n.SubjectId,
ReadingId = n.VisitId,
TrialId = inDto.TrialId
}).ToList());
//readingClinicalDatas.AddRange(
// dataTrialSetList.Where(x => x.ClinicalDataLevel == ClinicalLevel.Study).Where(x => clinicalDataList.Where(y => y.ClinicalDataTrialSetId == x.Id && y.ReadingId == n.VisitId).Count() == 0)
// .Select(x => new ReadingClinicalData()
// {
// ClinicalDataTrialSetId = x.Id,
// IsVisit = true,
// SubjectId = n.SubjectId,
// ReadingId = n.VisitId,
// TrialId = inDto.TrialId
// }).ToList());
});
await _readingClinicalDataRepository.AddRangeAsync(readingClinicalDatas);
await _readingClinicalDataRepository.SaveChangesAsync();
}
/// <summary>
/// 获取CRC受试者临床数据
/// </summary>
/// <param name="inQuery"></param>
/// <returns></returns>
[HttpPost]
public async Task<PageOutput<GetCRCSubjectClinicalOutDto>> GetCRCSubjectClinicalList(GetCRCSubjectClinicalInDto inQuery)
{
//await AutoAddCRCClinical(new AutoAddClinicalInDto()
//{
// TrialId = inDto.TrialId
//}) ;
var subjects = await _subjectRepository.Where(x => x.TrialId == inQuery.TrialId).Select(x => new GetCRCSubjectClinicalResultDto()
{
SubjectId = x.Id,
SubjectCode = x.Code
}).ToListAsync();
var clinicalData = _readingClinicalDataRepository.Where(x => x.TrialId == inQuery.TrialId && x.ClinicalDataTrialSet.UploadRole == UploadRole.CRC && x.ClinicalDataTrialSet.ClinicalDataLevel != ClinicalLevel.SubjectVisit)
.Where(x => !x.IsSign)
.WhereIf(inQuery.SubjectId != null, x => x.SubjectId == inQuery.SubjectId)
.WhereIf(inQuery.SubjectCode != null, x => x.Subject.Code.Contains(inQuery.SubjectCode ?? string.Empty))
.Where(x => x.ClinicalDataTrialSet.ClinicalDataLevel != ClinicalLevel.Subject)
.Include(x => x.ClinicalDataTrialSet).Select(x => new GetCRCSubjectClinicalOutDto()
{
SubjectId = x.SubjectId,
SubjectCode = x.Subject.Code,
TrialId = inQuery.TrialId,
ReadingId = x.ReadingId,
ReadingClinicalDataId = x.Id,
UploadRole = x.ClinicalDataTrialSet.UploadRole,
ClinicalDataLevel = x.ClinicalDataTrialSet.ClinicalDataLevel,
ClinicalUploadType = x.ClinicalDataTrialSet.ClinicalUploadType,
BaseLineVisitId = x.Subject.SubjectVisitList.Where(x => x.IsBaseLine).Select(x => x.Id).FirstOrDefault(),
ClinicalDataTrialSetId = x.ClinicalDataTrialSet.Id,
ClinicalDataSetEnName = x.ClinicalDataTrialSet.ClinicalDataSetEnName,
ClinicalDataSetName = x.ClinicalDataTrialSet.ClinicalDataSetName,
});
var pageList = await clinicalData.ToPagedListAsync(inQuery, nameof(GetCRCSubjectClinicalOutDto.SubjectCode));
// 一次查询报错 分两次写
pageList.CurrentPageData.ForEach(x =>
{
x.ClinicalDataSetEnName = x.ClinicalDataSetName.LanguageName(x.ClinicalDataSetEnName, _userInfo.IsEn_Us);
});
var clinicalFormData = await _clinicalFormRepository.Where(x => x.TrialId == inQuery.TrialId).ToListAsync();
pageList.CurrentPageData.ForEach(n =>
{
n.ClinicalCount = clinicalFormData.Where(y => y.ClinicalDataTrialSetId == n.ClinicalDataTrialSetId && y.SubjectId == n.SubjectId).Count();
});
return pageList;
}
/// <summary>
/// 获取表单列表
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<GetClinicalQuestionAnswerListOutDto> GetClinicalQuestionFormList(GetClinicalQuestionAnswerListInDto inDto)
{
var result = new GetClinicalQuestionAnswerListOutDto();
result.AnswerList = new List<Dictionary<string, string>>();
result.QuestionList = await _trialClinicalQuestionRepository.Where(x => x.TrialClinicalId == inDto.ClinicalDataTrialSetId
&& x.ClinicalQuestionType != ReadingQestionType.Group
&& x.ClinicalQuestionType != ReadingQestionType.Table
&& x.ClinicalQuestionType != ReadingQestionType.BasicTable
).OrderByDescending(x => x.IsCheckDate).ThenBy(x => x.ShowOrder)
.ProjectTo<TrialClinicalQuestionDto>(_mapper.ConfigurationProvider).ToListAsync();
if (_userInfo.IsEn_Us)
{
result.QuestionList.ForEach(x =>
{
x.GroupName = x.GroupEnName;
x.QuestionName = x.QuestionEnName;
});
}
var answers = await _clinicalQuestionAnswerRepository.Where(x => x.SubjectId == inDto.SubjectId && x.ClinicalDataTrialSetId == inDto.ClinicalDataTrialSetId)
.Select(x => new
{
x.ClinicalFormId,
x.ClinicalForm.CheckDate,
x.QuestionId,
x.Answer
})
.ToListAsync();
var ClinicalFormIds = answers.OrderBy(x => x.CheckDate).Select(x => x.ClinicalFormId).Distinct().ToList();
ClinicalFormIds.ForEach(x =>
{
var dic = answers.Where(y => y.ClinicalFormId == x).ToDictionary(x => x.QuestionId.ToString(), x => x.Answer);
dic.Add("ClinicalFormId", x.ToString());
dic.Add("TrialId", inDto.TrialId.ToString());
dic.Add("SubjectId", inDto.SubjectId.ToString());
dic.Add("ClinicalDataTrialSetId", inDto.ClinicalDataTrialSetId.ToString());
result.AnswerList.Add(dic);
});
return result;
}
/// <summary>
/// 获取临床数据表单问题
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<List<ClinicalQuestionPreviewDto>> GetClinicalFormInfo(GetClinicalFormInfoInDto inDto)
{
var formInfo = await _clinicalFormRepository.Where(x => x.Id == inDto.ClinicalFormId).FirstNotNullAsync();
var questionAnswer = await _clinicalQuestionAnswerRepository.Where(x => x.ClinicalFormId == inDto.ClinicalFormId).Select(x => new ClinicalFormQuestionAnswer
{
QuestionId = x.QuestionId,
Answer = x.Answer
}).ToListAsync();
var tableAnswer = await _clinicalTableAnswerRepository.Where(x => x.ClinicalFormId == inDto.ClinicalFormId).Select(x => new ClinicalFormTableQuestionAnswer
{
TableQuestionId = x.TableQuestionId,
Answer = x.Answer,
QuestionId = x.QuestionId,
RowIndex = x.ClinicalAnswerRowInfo.RowIndex
}).ToListAsync();
var questions = await _trialClinicalQuestionRepository.Where(x => x.TrialClinicalId == formInfo.ClinicalDataTrialSetId)
.ProjectTo<ClinicalQuestionPreviewDto>(_mapper.ConfigurationProvider).OrderBy(x => x.ShowOrder).ToListAsync();
var tableQuestions = await _trialClinicalTableQuestionRepository.Where(x => x.TrialClinicalId == formInfo.ClinicalDataTrialSetId)
.ProjectTo<ClinicalTablePreviewDto>(_mapper.ConfigurationProvider).OrderBy(x => x.ShowOrder).ToListAsync();
questions.ForEach(x => x.CreateTime = formInfo.CreateTime);
var result = questions.Where(x => x.ClinicalQuestionType == ReadingQestionType.Group).ToList();
result.ForEach(x =>
{
_iClinicalQuestionService.FindChildQuestion(x, questions, tableQuestions, questionAnswer, tableAnswer);
});
return result;
}
/// <summary>
/// 提交临床数据表单
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<IResponseOutput> SubmitClinicalForm(SubmitClinicalFormInDto inDto)
{
ClinicalForm clinicalForm = new ClinicalForm() { };
clinicalForm = new ClinicalForm()
{
ClinicalDataTrialSetId = inDto.ClinicalDataTrialSetId,
SubjectId = inDto.SubjectId,
PicturePath = inDto.PicturePath,
TrialId = inDto.TrialId,
Id = inDto.ClinicalFormId ?? NewId.NextGuid(),
ReadingId = inDto.ReadingId,
};
if (inDto.ClinicalFormId != null && (await _readModuleCriterionFromRepository.AnyAsync(x => x.ClinicalFormId == inDto.ClinicalFormId.Value)))
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_translation"]);
}
var existsClinical = await _clinicalFormRepository.Where(x =>
x.SubjectId == inDto.SubjectId
&& x.ClinicalDataTrialSetId == inDto.ClinicalDataTrialSetId
).WhereIf(inDto.ReadingId != null, x => x.ReadingId == inDto.ReadingId)
.Where(x => x.ClinicalDataTrialSet.UploadRole != UploadRole.CRC && !(x.ClinicalDataTrialSet.ClinicalDataLevel == ClinicalLevel.ImageRead
|| x.ClinicalDataTrialSet.ClinicalDataLevel == ClinicalLevel.OncologyRead)).AnyAsync();
if (existsClinical)
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_duplicateData"]);
}
try
{
var checkDateQuestionId = await _trialClinicalQuestionRepository.Where(x => x.TrialClinicalId == inDto.ClinicalDataTrialSetId && x.IsCheckDate).Select(x => x.Id).FirstNotNullAsync();
clinicalForm.CheckDate = DateTime.Parse(inDto.QuestionAnswers.Where(x => x.QuestionId == checkDateQuestionId).Select(x => x.Answer).First());
}
catch (Exception)
{
}
if (clinicalForm.CheckDate != null)
{
if (await _readModuleRepository.AnyAsync(x => x.SubjectId == inDto.SubjectId && x.SubjectVisit.LatestScanDate <= clinicalForm.CheckDate && x.IsCRCConfirm))
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_unableToAddOrUpdate", clinicalForm.CheckDate.Value.ToString("yyyy-MM-dd")]);
}
}
List<ClinicalQuestionAnswer> clinicalQuestionAnswers = inDto.QuestionAnswers.Select(x => new ClinicalQuestionAnswer()
{
Answer = x.Answer,
ClinicalDataTrialSetId = inDto.ClinicalDataTrialSetId,
SubjectId = inDto.SubjectId,
ClinicalFormId = clinicalForm.Id,
QuestionId = x.QuestionId,
}).ToList();
List<ClinicalAnswerRowInfo> clinicalAnswerRowInfos = new List<ClinicalAnswerRowInfo>();
List<ClinicalTableAnswer> clinicalTableAnswers = new List<ClinicalTableAnswer>();
inDto.TableQuestionAnswerList.ForEach(x =>
{
var questionid = x.QuestionId;
for (int i = 0; i < x.TableQuestionAnswers.Count(); i++)
{
var rowInfo = new ClinicalAnswerRowInfo()
{
Id = NewId.NextGuid(),
SubjectId = inDto.SubjectId,
ClinicalFormId = clinicalForm.Id,
QuestionId = questionid,
RowIndex = i + 1,
};
clinicalAnswerRowInfos.Add(rowInfo);
x.TableQuestionAnswers[i].ForEach(y =>
{
clinicalTableAnswers.Add(new ClinicalTableAnswer()
{
Answer = y.Answer,
ClinicalFormId = clinicalForm.Id,
QuestionId = questionid,
RowId = rowInfo.Id,
TableQuestionId = y.TableQuestionId,
SubjectId = inDto.SubjectId,
});
});
}
});
if (inDto.ClinicalFormId != null)
{
await _clinicalFormRepository.BatchDeleteNoTrackingAsync(x => x.Id == inDto.ClinicalFormId);
await _clinicalQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.ClinicalFormId == inDto.ClinicalFormId);
await _clinicalAnswerRowInfoRepository.BatchDeleteNoTrackingAsync(x => x.ClinicalFormId == inDto.ClinicalFormId);
await _clinicalTableAnswerRepository.BatchDeleteNoTrackingAsync(x => x.ClinicalFormId == inDto.ClinicalFormId);
}
//if(inDto.ReadingId!=null)
//{
// await _readingClinicalDataRepository.UpdatePartialFromQueryAsync(x => x.ReadingId == inDto.ReadingId && x.ClinicalDataTrialSetId == inDto.ClinicalDataTrialSetId, x => new ReadingClinicalData()
// {
// IsSign = true
// });
//}
await _clinicalFormRepository.AddAsync(clinicalForm);
await _clinicalQuestionAnswerRepository.AddRangeAsync(clinicalQuestionAnswers);
await _clinicalAnswerRowInfoRepository.AddRangeAsync(clinicalAnswerRowInfos);
await _clinicalTableAnswerRepository.AddRangeAsync(clinicalTableAnswers);
await _clinicalTableAnswerRepository.SaveChangesAsync();
return ResponseOutput.Ok(true);
}
/// <summary>
/// 删除表单数据
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
/// <exception cref="BusinessValidationFailedException"></exception>
[HttpPost]
public async Task<IResponseOutput> DeleteClinicalForm(DeleteClinicalFormInDto inDto)
{
if (await _readModuleCriterionFromRepository.AnyAsync(x => x.ClinicalFormId == inDto.ClinicalFormId))
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_unableToDelete"]);
}
await _clinicalFormRepository.BatchDeleteNoTrackingAsync(x => x.Id == inDto.ClinicalFormId);
await _clinicalQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.ClinicalFormId == inDto.ClinicalFormId);
await _clinicalAnswerRowInfoRepository.BatchDeleteNoTrackingAsync(x => x.ClinicalFormId == inDto.ClinicalFormId);
await _clinicalTableAnswerRepository.BatchDeleteNoTrackingAsync(x => x.ClinicalFormId == inDto.ClinicalFormId);
return ResponseOutput.Ok(true);
}
/// <summary>
/// 获取PM待确认列表
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<PageOutput<GetCRCConfirmListOutDto>> GetPMConfirmList(GetPMConfirmListInDto inDto)
{
return await GetCRCConfirmList(new GetCRCConfirmListInDto()
{
TrialId = inDto.TrialId,
IsCRCConfirm = true,
IsPMConfirm = false,
PageIndex = inDto.PageIndex,
PageSize = inDto.PageSize,
Asc = inDto.Asc,
SortField = inDto.SortField,
TrialReadingCriterionId = inDto.TrialReadingCriterionId
});
}
/// <summary>
/// 获取CRC确认列表
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<PageOutput<GetCRCConfirmListOutDto>> GetCRCConfirmList(GetCRCConfirmListInDto inDto)
{
if (inDto.ReadModuleId != null)
{
var readModule = await _readModuleRepository.Where(x => x.Id == inDto.ReadModuleId).FirstNotNullAsync();
inDto.TrialReadingCriterionId = readModule.TrialReadingCriterionId;
}
// 有全局就查全局 有肿瘤学就查肿瘤学
var clinicalDataLevelList = await _clinicalDataTrialSetRepository.Where(x => x.TrialId == inDto.TrialId && x.IsConfirm && x.UploadRole == UploadRole.CRC && x.ClinicalUploadType == ClinicalUploadType.Structuring).Select(x => x.ClinicalDataLevel).Distinct().ToListAsync();
var existsCRCStructuring = clinicalDataLevelList.Any(x => x == ClinicalLevel.OncologyRead || x == ClinicalLevel.ImageRead);
ReadingSetType? readingSetType = null;
if (clinicalDataLevelList.Contains(ClinicalLevel.ImageRead) && !clinicalDataLevelList.Contains(ClinicalLevel.OncologyRead))
{
readingSetType = ReadingSetType.ImageReading;
}
else if (clinicalDataLevelList.Contains(ClinicalLevel.OncologyRead) && !clinicalDataLevelList.Contains(ClinicalLevel.ImageRead))
{
readingSetType = ReadingSetType.TumorReading;
}
var query = _readModuleRepository.Where(x => x.TrialId == inDto.TrialId)
.Where(x => existsCRCStructuring)
.WhereIf(inDto.ReadModuleId == null, x => x.TrialReadingCriterion.IsConfirm)
.WhereIf(inDto.ReadModuleId != null, x => x.Id == inDto.ReadModuleId)
.WhereIf(inDto.IsCRCConfirm != null, x => x.IsCRCConfirm == inDto.IsCRCConfirm)
.WhereIf(inDto.IsPMConfirm != null, x => x.IsPMConfirm == inDto.IsPMConfirm)
.WhereIf(inDto.SubjectCode != null, x => x.Subject.Code.Contains(inDto.SubjectCode ?? string.Empty))
.WhereIf(inDto.TrialReadingCriterionId != null, x => x.TrialReadingCriterionId == inDto.TrialReadingCriterionId)
.WhereIf(inDto.SubjectId != null, x => x.SubjectId == inDto.SubjectId)
.WhereIf(inDto.StartTime != null, x => x.SubjectVisit.LatestScanDate >= inDto.StartTime)
.WhereIf(inDto.EndTime != null, x => x.SubjectVisit.LatestScanDate <= inDto.EndTime)
.WhereIf(readingSetType != null, x => x.ReadingSetType == readingSetType)
.Select(x => new GetCRCConfirmListOutDto()
{
SubjectId = x.SubjectId,
IsNotNeedPMConfirm = x.IsNotNeedPMConfirm,
IsCRCConfirm = x.IsCRCConfirm,
IsCRCApplicationRevoke = x.IsCRCApplicationRevoke,
VisitBlindName = x.SubjectVisit.BlindName,
LatestScanDate = x.SubjectVisit.LatestScanDate,
ReadingSetType = x.ReadingSetType,
IsPMConfirm = x.IsPMConfirm,
SubjectCode = x.Subject.Code,
ReadModuleId = x.Id,
ModuleName = x.ModuleName,
});
var defalutSortArray = new string[] { nameof(GetCRCConfirmListOutDto.SubjectCode) + " desc", nameof(GetCRCConfirmListOutDto.LatestScanDate) };
var result = await query.ToPagedListAsync(inDto, defalutSortArray);
var formList = await _clinicalFormRepository.Where(x => x.TrialId == inDto.TrialId)
.Where(x => x.ClinicalDataTrialSet.UploadRole == UploadRole.CRC)
.WhereIf(inDto.TrialReadingCriterionId != null, x => x.ClinicalDataTrialSet.TrialClinicalDataSetCriteriaList.Any(y => y.TrialReadingCriterionId == inDto.TrialReadingCriterionId))
.Where(x => x.ClinicalDataTrialSet.ClinicalDataLevel == ClinicalLevel.ImageRead || x.ClinicalDataTrialSet.ClinicalDataLevel == ClinicalLevel.OncologyRead)
.Include(x => x.ClinicalDataTrialSet)
.Select(x => new CRCClinicalForm
{
SubjectId = x.SubjectId,
CheckDate = x.CheckDate,
ClinicalDataLevel = x.ClinicalDataTrialSet.ClinicalDataLevel,
ClinicalFormId = x.Id,
ClinicalDataTrialSetId = x.ClinicalDataTrialSet.Id,
ClinicalDataSetName = x.ClinicalDataTrialSet.ClinicalDataSetName,
ClinicalDataSetEnName = x.ClinicalDataTrialSet.ClinicalDataSetEnName,
IsHaveTableQuestion = x.ClinicalDataTrialSet.TrialClinicalQuestionList.Any(y => y.ClinicalQuestionType == ReadingQestionType.Table || y.ClinicalQuestionType == ReadingQestionType.BasicTable),
}).ToListAsync();
var confirmList = await _readModuleCriterionFromRepository.Where(x => x.TrialId == inDto.TrialId
&& x.ClinicalForm.ClinicalDataTrialSet.UploadRole == UploadRole.CRC
&& (x.ClinicalForm.ClinicalDataTrialSet.ClinicalDataLevel == ClinicalLevel.ImageRead || x.ClinicalForm.ClinicalDataTrialSet.ClinicalDataLevel == ClinicalLevel.OncologyRead))
.Select(x => new GetCRCBeConfirm
{
CheckDate = x.ClinicalForm.CheckDate ?? default(DateTime),
ClinicalDataSetName = x.ClinicalForm.ClinicalDataTrialSet.ClinicalDataSetName,
ClinicalDataSetEnName = x.ClinicalForm.ClinicalDataTrialSet.ClinicalDataSetEnName,
ClinicalFormId = x.ClinicalFormId,
ClinicalDataTrialSetId = x.ClinicalForm.ClinicalDataTrialSet.Id,
ReadModuleId = x.ReadModuleId,
IsHaveTableQuestion = x.ClinicalForm.ClinicalDataTrialSet.TrialClinicalQuestionList.Any(y => y.ClinicalQuestionType == ReadingQestionType.Table || y.ClinicalQuestionType == ReadingQestionType.BasicTable)
}).ToListAsync();
result.CurrentPageData.ForEach(x =>
{
if (x.IsCRCConfirm)
{
x.ClinicalFormList = confirmList.Where(y => y.ReadModuleId == x.ReadModuleId).Select(y => new GetCRCBeConfirmListOutDto()
{
CheckDate = y.CheckDate,
ClinicalDataSetName = y.ClinicalDataSetName.LanguageName(y.ClinicalDataSetEnName, _userInfo.IsEn_Us),
ClinicalDataSetEnName = y.ClinicalDataSetEnName,
ClinicalFormId = y.ClinicalFormId,
ClinicalDataTrialSetId = y.ClinicalDataTrialSetId,
IsHaveTableQuestion = y.IsHaveTableQuestion,
}).ToList();
}
else
{
if (x.ReadingSetType == ReadingSetType.ImageReading)
{
x.ClinicalFormList = formList.Where(y => y.ClinicalDataLevel == ClinicalLevel.ImageRead && y.CheckDate <= x.LatestScanDate && y.SubjectId == x.SubjectId)
.Select(y => new GetCRCBeConfirmListOutDto()
{
CheckDate = y.CheckDate ?? default(DateTime),
ClinicalDataSetName = y.ClinicalDataSetName.LanguageName(y.ClinicalDataSetEnName, _userInfo.IsEn_Us),
ClinicalDataSetEnName = y.ClinicalDataSetEnName,
ClinicalFormId = y.ClinicalFormId,
ClinicalDataTrialSetId = y.ClinicalDataTrialSetId,
IsHaveTableQuestion = y.IsHaveTableQuestion,
}).ToList();
}
else
{
x.ClinicalFormList = formList.Where(y => y.ClinicalDataLevel == ClinicalLevel.OncologyRead && y.CheckDate <= x.LatestScanDate && y.SubjectId == x.SubjectId)
.Select(y => new GetCRCBeConfirmListOutDto()
{
CheckDate = y.CheckDate ?? default(DateTime),
ClinicalDataSetName = y.ClinicalDataSetName.LanguageName(y.ClinicalDataSetEnName, _userInfo.IsEn_Us),
ClinicalDataSetEnName = y.ClinicalDataSetEnName,
ClinicalFormId = y.ClinicalFormId,
ClinicalDataTrialSetId = y.ClinicalDataTrialSetId,
IsHaveTableQuestion = y.IsHaveTableQuestion,
}).ToList();
}
}
});
return result;
}
/// <summary>
/// 获取CRC待确认列表
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<List<GetCRCBeConfirmListOutDto>> GetCRCBeConfirmList(GetCRCBeConfirmListInDto inDto)
{
var result = (await this.GetCRCConfirmList(new GetCRCConfirmListInDto()
{
ReadModuleId = inDto.ReadModuleId,
TrialId = inDto.TrialId,
PageIndex = 1,
PageSize = 9999,
})).CurrentPageData.SelectMany(x => x.ClinicalFormList).ToList();
return result.OrderBy(x => x.ClinicalDataSetName).ThenBy(x => x.CheckDate).ToList();
}
/// <summary>
/// 获取临床数据表格信息 查看没有表格问题的列表
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<(List<GetClinicalTableListOutDto>, object)> GetClinicalTableList(GetClinicalTableListInDto inDto)
{
var readModule = await _readModuleRepository.Where(x => x.Id == inDto.ReadModuleId).FirstNotNullAsync();
var confirmList = (await this.GetCRCConfirmList(new GetCRCConfirmListInDto()
{
ReadModuleId = inDto.ReadModuleId,
TrialId = inDto.TrialId,
PageIndex = 1,
PageSize = 9999,
})).CurrentPageData.SelectMany(x => x.ClinicalFormList).ToList();
var clinicalDataTrialSetIds = confirmList.Select(x => x.ClinicalDataTrialSetId).Distinct().ToList();
var clinicalFormIds = confirmList.Select(x => x.ClinicalFormId).ToList();
var questionList = await _trialClinicalQuestionRepository.Where(x => clinicalDataTrialSetIds.Contains(x.TrialClinicalId)
&& x.ClinicalQuestionType != ReadingQestionType.Group
&& x.ClinicalQuestionType != ReadingQestionType.Table
&& x.ClinicalQuestionType != ReadingQestionType.BasicTable
).OrderBy(x => x.TrialClinicalId).ThenBy(x => x.ShowOrder)
.ProjectTo<TrialClinicalQuestionDto>(_mapper.ConfigurationProvider).ToListAsync();
var answers = await _clinicalQuestionAnswerRepository.Where(x => clinicalFormIds.Contains(x.ClinicalFormId))
.Select(x => new
{
x.ClinicalDataTrialSetId,
x.ClinicalFormId,
x.ClinicalForm.CheckDate,
x.QuestionId,
x.Answer
})
.ToListAsync();
List<GetClinicalTableListOutDto> result = new List<GetClinicalTableListOutDto>();
clinicalDataTrialSetIds.ForEach(x =>
{
GetClinicalTableListOutDto dto = new GetClinicalTableListOutDto();
dto.ModuleName = readModule.ModuleName;
dto.ClinicalDataSetName = confirmList.Where(y => y.ClinicalDataTrialSetId == x).Select(y => y.ClinicalDataSetName).First();
dto.QuestionList = questionList.Where(y => y.TrialClinicalId == x).OrderBy(y => y.ShowOrder).ToList();
dto.AnswerList = new List<Dictionary<string, string>>();
var ClinicalFormIds = answers.Where(y => y.ClinicalDataTrialSetId == x).OrderBy(x => x.CheckDate).Select(x => x.ClinicalFormId).Distinct().ToList();
ClinicalFormIds.ForEach(z =>
{
var dic = answers.Where(y => y.ClinicalFormId == z).OrderBy(y => y.CheckDate).ToDictionary(x => x.QuestionId.ToString(), x => x.Answer);
dic.Add("ClinicalFormId", z.ToString());
dic.Add("TrialId", inDto.TrialId.ToString());
dic.Add("SubjectId", readModule.SubjectId.ToString());
dic.Add("ClinicalDataTrialSetId", x.ToString());
dto.AnswerList.Add(dic);
});
result.Add(dto);
});
return (result, new
{
readModule.ModuleName,
});
}
/// <summary>
/// 获取临床数据表格信息 查看有表格问题的列表
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<(List<GetClinicalDateListOutDto>, object)> GetClinicalDateList(GetCRCBeConfirmListInDto inDto)
{
var readModule = await _readModuleRepository.Where(x => x.Id == inDto.ReadModuleId).FirstNotNullAsync();
var confirmList = (await this.GetCRCConfirmList(new GetCRCConfirmListInDto()
{
ReadModuleId = inDto.ReadModuleId,
TrialId = inDto.TrialId,
PageIndex = 1,
PageSize = 9999,
})).CurrentPageData.SelectMany(x => x.ClinicalFormList).ToList();
var clinicalDataTrialSetIds = confirmList.Select(x => x.ClinicalDataTrialSetId).Distinct().ToList();
List<GetClinicalDateListOutDto> result = new List<GetClinicalDateListOutDto>();
clinicalDataTrialSetIds.ForEach(x =>
{
result.Add(new GetClinicalDateListOutDto()
{
ClinicalDataSetName = confirmList.Where(y => y.ClinicalDataTrialSetId == x).Select(y => y.ClinicalDataSetName).First(),
DateList = confirmList.Where(y => y.ClinicalDataTrialSetId == x).ToList()
});
});
return (result, new
{
readModule.ModuleName,
});
}
/// <summary>
/// CRC 确认临床数据
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<IResponseOutput> CRCConfirmClinical(CRCConfirmClinicalInDto inDto)
{
var readModule = await _readModuleRepository.Where(x => x.Id == inDto.ReadModuleId).FirstNotNullAsync();
var confirmlist = (await this.GetCRCConfirmList(new GetCRCConfirmListInDto()
{
TrialId = inDto.TrialId,
SubjectId = readModule.SubjectId,
IsCRCConfirm = false,
TrialReadingCriterionId = readModule.TrialReadingCriterionId,
//ReadModuleId = inDto.ReadModuleId,
PageIndex = 1,
PageSize = 9999,
})).CurrentPageData.ToList();
var presentData = confirmlist.Where(x => x.ReadModuleId == inDto.ReadModuleId).First();
confirmlist = confirmlist.Where(x => x.LatestScanDate <= presentData.LatestScanDate).ToList();
await _readModuleCriterionFromRepository.BatchDeleteNoTrackingAsync(x => x.ReadModuleId == inDto.ReadModuleId);
List<ReadModuleCriterionFrom> needAddList = new List<ReadModuleCriterionFrom>()
{
};
confirmlist.ForEach(x =>
{
x.ClinicalFormList.ForEach(y =>
{
needAddList.Add(new ReadModuleCriterionFrom()
{
ClinicalFormId = y.ClinicalFormId,
ReadModuleId = x.ReadModuleId,
SubjectId = x.SubjectId,
TrialId = inDto.TrialId,
});
});
});
foreach (var item in confirmlist)
{
await _readModuleRepository.UpdatePartialFromQueryAsync(x => x.Id == item.ReadModuleId, x => new ReadModule()
{
IsCRCConfirm = true,
IsPMConfirm = item.ClinicalFormList.Count() == 0 ? true : false,
IsNotNeedPMConfirm = item.ClinicalFormList.Count() == 0 ? true : false,
});
}
await _readModuleCriterionFromRepository.AddRangeAsync(needAddList);
await _readModuleCriterionFromRepository.SaveChangesAsync();
await _iReadingClinicalDataService.DealVisiTaskClinicalDataSignedAsync(inDto.TrialId, inDto.SubjectId, inDto.ReadModuleId, false, readModule.TrialReadingCriterionId);
return ResponseOutput.Ok(true);
}
/// <summary>
/// CRC 取消确认
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
[HttpPost]
public async Task<IResponseOutput> CRCCancelConfirmClinical(CRCCancelConfirmClinicalInDto inDto)
{
var readModule = await _readModuleRepository.Where(x => x.Id == inDto.ReadModuleId).FirstNotNullAsync();
var dataList = (await this.GetCRCConfirmList(new GetCRCConfirmListInDto()
{
TrialId = inDto.TrialId,
SubjectId = readModule.SubjectId,
TrialReadingCriterionId = readModule.TrialReadingCriterionId,
PageIndex = 1,
PageSize = 9999,
})).CurrentPageData;
var presentData = dataList.Where(x => x.ReadModuleId == inDto.ReadModuleId).First();
if (dataList.Any(x => x.IsCRCConfirm && x.LatestScanDate > presentData.LatestScanDate && x.ReadingSetType == presentData.ReadingSetType))
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_unableToCancel"]);
}
if (presentData.IsPMConfirm)
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_unableToCancelPMConfirmed"]);
}
if (presentData.IsNotNeedPMConfirm)
{
await _readModuleRepository.UpdatePartialFromQueryAsync(x => presentData.ReadModuleId == x.Id, x => new ReadModule()
{
IsPMConfirm = false,
IsCRCConfirm = false,
IsNotNeedPMConfirm = false,
});
}
else
{
await _readModuleRepository.UpdatePartialFromQueryAsync(x => presentData.ReadModuleId == x.Id, x => new ReadModule()
{
IsCRCApplicationRevoke = true,
});
}
//await _readModuleCriterionFromRepository.BatchDeleteNoTrackingAsync(x=>x.ReadModuleId== presentData.ReadModuleId);
await _readModuleCriterionFromRepository.SaveChangesAsync();
return ResponseOutput.Ok(true);
}
/// <summary>
/// PM确认临床数据
/// </summary>
/// <param name="inDto"></param>
/// <returns></returns>
/// <exception cref="BusinessValidationFailedException"></exception>
[HttpPost]
public async Task<IResponseOutput> PMConfirmClinical(CRCConfirmClinicalInDto inDto)
{
var readModuleData = await _readModuleRepository.Where(x => x.Id == inDto.ReadModuleId).FirstNotNullAsync();
if (!readModuleData.IsCRCConfirm)
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_PMUnableToOperate"]);
}
if (readModuleData.IsCRCApplicationRevoke && inDto.IsConfirm)
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_PMUnableToConfirm"]);
}
if (!readModuleData.IsCRCApplicationRevoke && !inDto.IsConfirm)
{
throw new BusinessValidationFailedException(_localizer["ClinicalAnswer_PMUnableToWithdraw"]);
}
if (inDto.IsConfirm)
{
await _readModuleRepository.UpdatePartialFromQueryAsync(x => inDto.ReadModuleId == x.Id, x => new ReadModule()
{
IsPMConfirm = true,
IsClinicalDataBlind = inDto.IsClinicalDataBlind,
IsClinicalDataComplete = inDto.IsClinicalDataComplete,
});
await _readModuleRepository.SaveChangesAsync();
await _iReadingClinicalDataService.DealVisiTaskClinicalDataSignedAsync(inDto.TrialId, inDto.SubjectId, inDto.ReadModuleId, false, readModuleData.TrialReadingCriterionId);
}
else
{
await _readModuleRepository.UpdatePartialFromQueryAsync(x => inDto.ReadModuleId == x.Id, x => new ReadModule()
{
IsCRCConfirm = false,
IsCRCApplicationRevoke = false,
});
await _readModuleRepository.SaveChangesAsync();
await _readModuleCriterionFromRepository.BatchDeleteNoTrackingAsync(x => x.ReadModuleId == inDto.ReadModuleId);
}
return ResponseOutput.Ok(true);
}
}
}