//--------------------------------------------------------------------
// 此代码由T4模板自动生成 byzhouhang 20210918
// 生成时间 2023-03-17 11:58:57
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------
using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Application.Contracts.DTO;
using System.Linq;
using System.Linq.Dynamic.Core;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Application.Contracts;
using DocumentFormat.OpenXml.Spreadsheet;
using Panda.DynamicWebApi.Attributes;
using IRaCIS.Core.Domain.Share.Reading;
using System.Runtime.InteropServices;
using DocumentFormat.OpenXml.Bibliography;
namespace IRaCIS.Core.Application.Service
{
///
/// SubjectCriteriaEvaluationService
///
[ApiExplorerSettings(GroupName = "Trial")]
public class SubjectCriteriaEvaluationService : BaseService, ISubjectCriteriaEvaluationService
{
private readonly IRepository _subjectCriteriaEvaluationRepository;
private readonly IRepository _subjectRepository;
private readonly IRepository _subjectVisitRepository;
private readonly IRepository _subjectCriteriaEvaluationVisitFilterRepository;
private readonly IRepository _subjectCriteriaEvaluationVisitStudyFilterRepository;
private readonly IRepository _trialReadingCriterionRepository;
private readonly IRepository _trialReadingQuestionRepository;
private readonly IVisitTaskHelpeService _IVisitTaskHelpeService;
public SubjectCriteriaEvaluationService(IRepository subjectCriteriaEvaluationRepository, IRepository subjectRepository,
IRepository subjectCriteriaEvaluationVisitFilterRepository, IRepository subjectVisitRepository,
IRepository subjectCriteriaEvaluationVisitStudyFilterRepository,
IRepository trialReadingCriterionRepository, IVisitTaskHelpeService IVisitTaskHelpeService, IRepository trialReadingQuestionRepository)
{
_subjectCriteriaEvaluationRepository = subjectCriteriaEvaluationRepository;
_subjectRepository = subjectRepository;
_subjectCriteriaEvaluationVisitFilterRepository = subjectCriteriaEvaluationVisitFilterRepository;
_subjectVisitRepository = subjectVisitRepository;
_subjectCriteriaEvaluationVisitStudyFilterRepository = subjectCriteriaEvaluationVisitStudyFilterRepository;
_trialReadingCriterionRepository = trialReadingCriterionRepository;
_IVisitTaskHelpeService = IVisitTaskHelpeService;
_trialReadingQuestionRepository = trialReadingQuestionRepository;
}
///
/// subject 某标准 是否评估列表
///
///
///
[HttpPost]
public async Task<(PageOutput,object)> GetSubjectCriteriaEvaluationList(SubjectCriteriaEvaluationQuery inQuery)
{
var trialReadingCritionList = _trialReadingCriterionRepository.Where(t => t.TrialId == inQuery.TrialId).ToList();
var resultTrialReadingCriterionId = Guid.Empty;
var resultTrialReadingCriterion = trialReadingCritionList.First();
var curentCriterionType = CriterionType.NoCriterion;
//BM 需要找基线 两个人做的结果
if (trialReadingCritionList.First(t => t.Id == inQuery.TrialReadingCriterionId).CriterionType == CriterionType.RECIST1Pointt1_MB)
{
resultTrialReadingCriterion = trialReadingCritionList.First(t => t.CriterionType == CriterionType.RECIST1Point1);
resultTrialReadingCriterionId = resultTrialReadingCriterion.Id;
curentCriterionType = CriterionType.RECIST1Pointt1_MB;
}
var addtionalQustionInfoList = _trialReadingQuestionRepository.Where(t => t.ReadingQuestionCriterionTrialId == resultTrialReadingCriterionId && t.IsAdditional == true && t.Type != "group").IgnoreQueryFilters().Select(t => new
{
QuestionId= t.Id,
t.QuestionEnName,
t.QuestionName
}).ToList();
var questionIdList= addtionalQustionInfoList.Select(t=>t.QuestionId).ToList();
var subjectCriteriaEvaluationQueryable = from subject in _subjectRepository.Where(t=>t.TrialId==inQuery.TrialId)
.WhereIf(!string.IsNullOrWhiteSpace(inQuery.SubjectCode), t => t.Code.Contains(inQuery.SubjectCode))
.WhereIf(!string.IsNullOrWhiteSpace(inQuery.TrialSiteCode), t => t.TrialSite.TrialSiteCode.Contains(inQuery.TrialSiteCode))
.WhereIf(inQuery.SubjectStatus != null, t => t.Status == inQuery.SubjectStatus)
join subjectCriteriaEvaluation in _subjectCriteriaEvaluationRepository.Where(t => t.TrialReadingCriterionId == inQuery.TrialReadingCriterionId) on subject.Id equals subjectCriteriaEvaluation.SubjectId into d
from subjectCriteriaEvaluation in d.DefaultIfEmpty()
select new SubjectCriteriaEvaluationView()
{
SubjectCode = subject.Code,
SubjectId = subject.Id,
SubjectStatus = subject.Status,
TrialSiteCode = subject.TrialSite.TrialSiteCode,
Id = subjectCriteriaEvaluation.Id,
TrialReadingCriterionId = inQuery.TrialReadingCriterionId,
IsImageFiltering = subjectCriteriaEvaluation.SubjectCriteriaEvaluationVisitFilterList.Any(t => t.ImageFilterState == ImageFilterState.None),
IsJoinEvaluation = subjectCriteriaEvaluation.IsJoinEvaluation,
ReadingEvaluationList= subject.ReadingTaskQuestionAnswerList
.Where(t=>t.ReadingQuestionCriterionTrialId == resultTrialReadingCriterionId &&
questionIdList.Contains(t.ReadingQuestionTrialId)
&& t.VisitTask.TaskState==TaskState.Effect)
.Select(u=>new EvaluationInfo()
{
QuestionId=u.ReadingQuestionTrialId,
Answer=u.Answer,
FinalTranslateDictionaryCode=u.ReadingQuestionTrial.DictionaryCode
}).ToList()
//EvaluationList=subject
//.SubjectAdditionalEvaluationResult
//.Where(t=>t.IsFinalResult && t.TrialReadingCriterionId==resultTrialReadingCriterionId)
//.Select(u=>new EvaluationInfo()
//{ Answer=u.Answer,FinalTranslateDictionaryCode=u.FinalTranslateDictionaryCode,QuestioName=u.TrialReadingQuestion .QuestionName,QuestioNameEn=u.TrialReadingQuestion.QuestionEnName}).ToList()
};
var pageList = await subjectCriteriaEvaluationQueryable.ToPagedListAsync(inQuery.PageIndex, inQuery.PageSize, inQuery.SortField == string.Empty ? nameof(SubjectCriteriaEvaluationView.SubjectCode) : inQuery.SortField, inQuery.Asc);
foreach (var item in pageList.CurrentPageData)
{
switch (curentCriterionType)
{
case CriterionType.RECIST1Pointt1_MB:
if (resultTrialReadingCriterion.ReadingType == ReadingMethod.Double)
{
if (item.ReadingEvaluationList.Count==2)
{
if (item.ReadingEvaluationList.All(t => t.Answer == 1.ToString()))
{
item.FinalEvaluationList.Add(new EvaluationInfo() { QuestionId=item.ReadingEvaluationList.First().QuestionId, Answer = ((int)BrainMetastasisResult.Yes).ToString(), FinalTranslateDictionaryCode = nameof(BrainMetastasisResult)
});
}
else if (item.ReadingEvaluationList.All(t => t.Answer == 0.ToString()))
{
item.FinalEvaluationList.Add(new EvaluationInfo() {
QuestionId = item.ReadingEvaluationList.First().QuestionId,
Answer = ((int)BrainMetastasisResult.No).ToString(), FinalTranslateDictionaryCode = nameof(BrainMetastasisResult)
});
}
else if (item.ReadingEvaluationList.First().Answer != item.ReadingEvaluationList.Last().Answer)
{
item.FinalEvaluationList.Add(new EvaluationInfo() { QuestionId = item.ReadingEvaluationList.First().QuestionId, Answer = ((int)BrainMetastasisResult.Maybe).ToString(), FinalTranslateDictionaryCode = nameof(BrainMetastasisResult)});
}
else
{
}
}
else
{
item.FinalEvaluationList.Add(new EvaluationInfo() { QuestionId= addtionalQustionInfoList.FirstOrDefault()?.QuestionId, Answer = ((int)BrainMetastasisResult.Unknown).ToString(), FinalTranslateDictionaryCode = nameof(BrainMetastasisResult) });
}
}
else if (resultTrialReadingCriterion.ReadingType == ReadingMethod.Single)
{
if (item.ReadingEvaluationList.Count == 1)
{
if (item.ReadingEvaluationList.All(t => t.Answer == 1.ToString()))
{
item.FinalEvaluationList.Add(new EvaluationInfo() { QuestionId = item.ReadingEvaluationList.First().QuestionId, Answer = ((int)BrainMetastasisResult.Yes).ToString(), FinalTranslateDictionaryCode = nameof(BrainMetastasisResult) });
}
else if (item.ReadingEvaluationList.All(t => t.Answer == 0.ToString()))
{
item.FinalEvaluationList.Add(new EvaluationInfo() { QuestionId = item.ReadingEvaluationList.First().QuestionId, Answer = ((int)BrainMetastasisResult.No).ToString(), FinalTranslateDictionaryCode = nameof(BrainMetastasisResult) });
}
else
{
}
}
else
{
item.FinalEvaluationList.Add(new EvaluationInfo() { QuestionId = addtionalQustionInfoList.FirstOrDefault()?.QuestionId, Answer = ((int)BrainMetastasisResult.Unknown).ToString(), FinalTranslateDictionaryCode = nameof(BrainMetastasisResult) });
}
}
else
{
}
break;
default:
break;
}
}
return (pageList, addtionalQustionInfoList);
}
///
/// 添加 编辑 是否参与评估
///
///
///
[UnitOfWork]
public async Task BatchAddOrUpdateSubjectCriteriaEvaluation(List addOrEditSubjectCriteriaEvaluationList)
{
// 在此处拷贝automapper 映射
foreach (var addOrEditSubjectCriteriaEvaluation in addOrEditSubjectCriteriaEvaluationList)
{
if (addOrEditSubjectCriteriaEvaluation.Id == null)
{
var entity = await _subjectCriteriaEvaluationRepository.InsertFromDTOAsync(addOrEditSubjectCriteriaEvaluation);
//找到一致性核查通过的访视 并且没有 自动影像筛选的数据
var subjectVisitIdList = await _subjectVisitRepository.Where(t => t.SubjectId == addOrEditSubjectCriteriaEvaluation.SubjectId && t.CheckState == CheckStateEnum.CVPassed
&& !t.SubjectCriteriaEvaluationVisitFilterList.Any(t=>t.TrialReadingCriterionId==addOrEditSubjectCriteriaEvaluation.TrialReadingCriterionId && t.SubjectId==addOrEditSubjectCriteriaEvaluation.SubjectId)).Select(t => t.Id)
.ToListAsync();
foreach (var subjectVisitId in subjectVisitIdList)
{
await AutoSubjectCriteriaEvaluationVisitFilter(addOrEditSubjectCriteriaEvaluation.SubjectId, subjectVisitId, addOrEditSubjectCriteriaEvaluation.TrialReadingCriterionId);
}
}
//编辑
else
{
//参与评估
if (addOrEditSubjectCriteriaEvaluation.IsJoinEvaluation)
{
var dbBeforeEntity = await _subjectCriteriaEvaluationRepository.UpdateFromDTOAsync(addOrEditSubjectCriteriaEvaluation);
//从不评估 改为评估
if (addOrEditSubjectCriteriaEvaluation.IsJoinEvaluation != dbBeforeEntity.IsJoinEvaluation)
{
//找到一致性核查通过的访视 并且没有 自动影像筛选的数据
var subjectVisitIdList = await _subjectVisitRepository.Where(t => t.SubjectId == addOrEditSubjectCriteriaEvaluation.SubjectId && t.CheckState == CheckStateEnum.CVPassed &&
!t.SubjectCriteriaEvaluationVisitFilterList.Any(t => t.TrialReadingCriterionId == addOrEditSubjectCriteriaEvaluation.TrialReadingCriterionId && t.SubjectId == addOrEditSubjectCriteriaEvaluation.SubjectId)).
Select(t => t.Id).ToListAsync();
foreach (var subjectVisitId in subjectVisitIdList)
{
await AutoSubjectCriteriaEvaluationVisitFilter(addOrEditSubjectCriteriaEvaluation.SubjectId, subjectVisitId, addOrEditSubjectCriteriaEvaluation.TrialReadingCriterionId);
}
}
//未修改 不做任何操作
}
//不参与评估
else
{
//删除该Subject 该标准访视的所有 访视筛选记录数据
await _subjectCriteriaEvaluationVisitFilterRepository.BatchDeleteNoTrackingAsync(t => t.TrialReadingCriterionId == addOrEditSubjectCriteriaEvaluation.TrialReadingCriterionId && t.SubjectId == addOrEditSubjectCriteriaEvaluation.SubjectId);
await _subjectCriteriaEvaluationVisitStudyFilterRepository.BatchDeleteNoTrackingAsync(t => t.TrialReadingCriterionId == addOrEditSubjectCriteriaEvaluation.TrialReadingCriterionId && t.SubjectVisit.SubjectId == addOrEditSubjectCriteriaEvaluation.SubjectId);
}
}
}
await _subjectCriteriaEvaluationRepository.SaveChangesAsync();
return ResponseOutput.Ok();
}
///
/// 自动访视筛选 (针对单一访视，重新筛选一遍，可能不存在该接口，仅仅留存)
///
///
[NonDynamicMethod]
public async Task AutoSubjectCriteriaEvaluationVisitFilter(Guid subjectId, Guid subjectVisitId, Guid trialReadingCriterionId)
{
if ((await _trialReadingCriterionRepository.FindAsync(trialReadingCriterionId)).CriterionType == CriterionType.RECIST1Pointt1_MB)
{
//如果所有访视 的所有序列部位都是脑部 那么自动筛选通过，同时需要插入序列的筛选记录
//找到该方式的所有序列
var list = await _repository.Where(t => t.SubjectVisitId == subjectVisitId && t.SubjectId == subjectId).Select(t => new { SeriesId = t.Id, t.StudyId, t.BodyPartForEdit }).ToListAsync();
//已经自动筛选过
if (await _subjectCriteriaEvaluationVisitFilterRepository.AnyAsync(t => t.TrialReadingCriterionId == trialReadingCriterionId && t.SubjectVisitId == subjectVisitId))
{
await _subjectCriteriaEvaluationVisitFilterRepository.BatchDeleteNoTrackingAsync(t => t.TrialReadingCriterionId == trialReadingCriterionId && t.SubjectVisitId == subjectVisitId);
await _subjectCriteriaEvaluationVisitStudyFilterRepository.BatchDeleteNoTrackingAsync(t => t.TrialReadingCriterionId == trialReadingCriterionId && t.SubjectVisitId == subjectVisitId);
}
//var existEntity = await _subjectCriteriaEvaluationVisitFilterRepository.FirstOrDefaultAsync(t => t.SubjectId == subjectId && t.SubjectVisitId == subjectVisitId && t.TrialReadingCriterionId == trialReadingCriterionId);
//有不是脑部的序列
if (list.Any(t => t.BodyPartForEdit != "脑部"))
{
//if (existEntity == null)
{
var addItem = new SubjectCriteriaEvaluationVisitFilter
{
SubjectVisitId = subjectVisitId,
SubjectId = subjectId,
ImageDeterminationResultState = ImageDeterminationResultState.None,
ImageFilterState = ImageFilterState.None,
TrialReadingCriterionId = trialReadingCriterionId
};
var subjectCriteriaEvaluationVisitFilter = await _subjectCriteriaEvaluationVisitFilterRepository.AddAsync(addItem);
}
}
//都是脑部的序列
else
{
//if (existEntity == null)
{
var addItem = new SubjectCriteriaEvaluationVisitFilter
{
SubjectVisitId = subjectVisitId,
SubjectId = subjectId,
ImageDeterminationResultState = ImageDeterminationResultState.Passed,
ImageFilterState = ImageFilterState.Finished,
TrialReadingCriterionId = trialReadingCriterionId,
//IsGeneratedTask = true
};
var subjectCriteriaEvaluationVisitFilter = await _subjectCriteriaEvaluationVisitFilterRepository.AddAsync(addItem);
}
foreach (var item in list)
{
await _subjectCriteriaEvaluationVisitStudyFilterRepository.AddAsync(new SubjectCriteriaEvaluationVisitStudyFilter { SubjectVisitId = subjectVisitId, SeriesId = item.SeriesId, TrialReadingCriterionId = trialReadingCriterionId, StudyId = item.StudyId, IsConfirmed = true });
}
//自动生成任务
if (!await _repository.AnyAsync(t => t.SourceSubjectVisitId == subjectVisitId && t.TrialReadingCriterionId == trialReadingCriterionId && t.TaskState == TaskState.Effect))
{
var trialId = _subjectVisitRepository.Where(t => t.Id == subjectVisitId).Select(t => t.TrialId).FirstOrDefault();
await _IVisitTaskHelpeService.BaseCritrionGenerateVisitTask(trialId, trialReadingCriterionId, true, new List() { subjectVisitId });
}
}
}
await _subjectCriteriaEvaluationVisitFilterRepository.SaveChangesAsync();
}
///
/// 评估访视筛选列表(一致性核查通过的访视都会出现 根据条件筛选)
///
///
///
[HttpPost]
public async Task> GetSubjectCriteriaEvaluationVisitFilterList(SubjectCriteriaEvaluationVisitFilterQuery inQuery)
{
var subjectCriteriaEvaluationVisitFilterQueryable = from subjectVisit in _subjectVisitRepository.Where(t => t.SubjectId == inQuery.SubjectId && t.CheckState == CheckStateEnum.CVPassed)
join subjectCriteriaEvaluationVisitFilter in _subjectCriteriaEvaluationVisitFilterRepository
.Where(t => t.TrialReadingCriterionId == inQuery.TrialReadingCriterionId)
.WhereIf(inQuery.ImageDeterminationResultState != null, t => t.ImageDeterminationResultState == inQuery.ImageDeterminationResultState)
.WhereIf(inQuery.ImageFilterState != null, t => t.ImageFilterState == inQuery.ImageFilterState)
.WhereIf(inQuery.IsGeneratedTask != null, t => t.IsGeneratedTask == inQuery.IsGeneratedTask)
on subjectVisit.Id equals subjectCriteriaEvaluationVisitFilter.SubjectVisitId
//into d from subjectCriteriaEvaluationVisitFilter in d.DefaultIfEmpty()
select new SubjectCriteriaEvaluationVisitFilterView()
{
VisitName = subjectVisit.VisitName,
VisitNum=subjectVisit.VisitNum,
SubjectVisitId = subjectVisit.Id,
SubjectId = subjectVisit.SubjectId,
TrialReadingCriterionId = inQuery.TrialReadingCriterionId,
LatestScanDate = subjectVisit.LatestScanDate,
EarliestScanDate = subjectVisit.LatestScanDate,
ImageDeterminationResultState = subjectCriteriaEvaluationVisitFilter.ImageDeterminationResultState,
ImageFilterState = subjectCriteriaEvaluationVisitFilter.ImageFilterState,
IsGeneratedTask = subjectCriteriaEvaluationVisitFilter.IsGeneratedTask,
Id = subjectCriteriaEvaluationVisitFilter.Id,
CreateTime = subjectCriteriaEvaluationVisitFilter.CreateTime,
CreateUserId=subjectCriteriaEvaluationVisitFilter.CreateUserId,
UpdateTime= subjectCriteriaEvaluationVisitFilter.UpdateTime,
UpdateUserId= subjectCriteriaEvaluationVisitFilter.UpdateUserId,
};
return await subjectCriteriaEvaluationVisitFilterQueryable.OrderBy(t=>t.VisitNum).ToListAsync();
}
///
/// 已生成任务列表
///
///
///
[HttpPost]
public async Task> GetHaveGeneratedTaskList(HaveGeneratedTaskQuery inQuery)
{
var list = await _repository.Where(t => t.TrialReadingCriterionId == inQuery.TrialReadingCriterionId && t.SubjectId == inQuery.SubjectId && t.TaskState == TaskState.Effect).OrderBy(t => t.VisitTaskNum)
.ProjectTo(_mapper.ConfigurationProvider).ToListAsync();
return list;
}
///
/// 批量勾选 生成该标准的任务
///
///
[UnitOfWork]
public async Task BatchGenerateTask(BatchGenerateTaskCommand batchGenerateTaskCommand)
{
await _subjectCriteriaEvaluationVisitFilterRepository.BatchUpdateNoTrackingAsync(t => t.SubjectId == batchGenerateTaskCommand.SubjectId
&& t.TrialReadingCriterionId == batchGenerateTaskCommand.TrialReadingCriterionId
&& batchGenerateTaskCommand.SubjectVisitIdList.Contains(t.SubjectVisitId), u => new SubjectCriteriaEvaluationVisitFilter { IsGeneratedTask = true });
await _IVisitTaskHelpeService.BaseCritrionGenerateVisitTask(batchGenerateTaskCommand.TrialId, batchGenerateTaskCommand.TrialReadingCriterionId, true, batchGenerateTaskCommand.SubjectVisitIdList);
}
/////
///// 评估访视 判断结果 影像筛选状态 手动添加/编辑接口
/////
/////
/////
//public async Task AddOrUpdateSubjectCriteriaEvaluationVisitFilter(SubjectCriteriaEvaluationVisitFilterAddOrEdit addOrEditSubjectCriteriaEvaluationVisitFilter)
//{
// var entity = await _subjectCriteriaEvaluationVisitFilterRepository.InsertOrUpdateAsync(addOrEditSubjectCriteriaEvaluationVisitFilter, true);
// return ResponseOutput.Ok(entity.Id.ToString());
//}
///
/// 获取dicom 访视检查列表 （序列的 Id CreateTime 是否为空 代表了记录是否创建、IsConfirmed 代表 保存 确认）
///
///
[HttpPost]
public async Task GetVisitStudyAndSeriesList(VisitStudyAndSeriesQuery inQuery)
{
var studyList = await _repository.Where(s => s.SubjectVisitId == inQuery.SubjectVisitId).ProjectTo(_mapper.ConfigurationProvider).ToListAsync();
var studyIds = studyList.Select(t => t.StudyId).ToList();
var query = from series in _repository.Where(t => studyIds.Contains(t.StudyId))
join visitStudyFilter in _subjectCriteriaEvaluationVisitStudyFilterRepository.Where(t => t.TrialReadingCriterionId == inQuery.TrialReadingCriterionId && t.SubjectVisitId == inQuery.SubjectVisitId) on series.Id equals visitStudyFilter.SeriesId into d
from visitStudyFilter in d.DefaultIfEmpty()
select new SelectSeriesView()
{
Description = series.Description,
BodyPartExamined = series.BodyPartExamined,
BodyPartForEdit = series.BodyPartForEdit,
Modality = series.Modality,
SeriesInstanceUid = series.SeriesInstanceUid,
StudyCode = series.DicomStudy.StudyCode,
SeriesNumber = series.SeriesNumber,
SeriesTime = series.SeriesTime,
InstanceCount=series.InstanceCount,
StudyTime = series.DicomStudy.StudyTime,
StudyId = series.StudyId,
SeriesId = series.Id,
SubjectVisitId = series.SubjectVisitId,
TrialReadingCriterionId = inQuery.TrialReadingCriterionId,
IsReading=visitStudyFilter.IsReading,
Id = visitStudyFilter.Id,
CreateTime = visitStudyFilter.CreateTime,
IsConfirmed = visitStudyFilter.IsConfirmed,
};
var seriesList = query.ToList();
return new SelctStudySeriesView { StudyList = studyList, SeriesList = seriesList };
}
///
/// 批量保存或者确认 选择的序列
///
///
public async Task BatchAddSubjectCriteriaEvaluationVisitStudyFilter(List batchList)
{
var ids = batchList.Select(t => t.Id).ToList();
await _subjectCriteriaEvaluationVisitStudyFilterRepository.BatchDeleteNoTrackingAsync(t => ids.Contains(t.Id));
await _subjectCriteriaEvaluationVisitStudyFilterRepository.AddRangeAsync(_mapper.Map>(batchList));
var first = batchList.First();
if (batchList.Count(t => t.IsReading == true) >= 0 && batchList.All(t => t.IsConfirmed == false))
{
await _subjectCriteriaEvaluationVisitFilterRepository.UpdatePartialFromQueryAsync(t => t.SubjectVisitId == first.SubjectVisitId && t.TrialReadingCriterionId == first.TrialReadingCriterionId,
u => new SubjectCriteriaEvaluationVisitFilter() { ImageFilterState = ImageFilterState.Filtering });
}
if (batchList.All(t => t.IsConfirmed == true))
{
await _subjectCriteriaEvaluationVisitFilterRepository.UpdatePartialFromQueryAsync(t => t.SubjectVisitId == first.SubjectVisitId && t.TrialReadingCriterionId == first.TrialReadingCriterionId,
u => new SubjectCriteriaEvaluationVisitFilter() { ImageFilterState = ImageFilterState.Finished });
}
await _subjectCriteriaEvaluationVisitStudyFilterRepository.SaveChangesAsync();
return ResponseOutput.Ok();
}
//[HttpDelete("{subjectCriteriaEvaluationId:guid}")]
// public async Task DeleteSubjectCriteriaEvaluation(Guid subjectCriteriaEvaluationId)
//{
// var success = await _subjectCriteriaEvaluationRepository.DeleteFromQueryAsync(t => t.Id == subjectCriteriaEvaluationId,true);
// return ResponseOutput.Ok();
//}
}
}