XCKJ
/
irc-netcore-api
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

国际化修改

Uat_Study
he 2023-03-29 14:10:01 +08:00
parent f04d20f57d
commit c6b568c17c
3 changed files with 142 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
IRaCIS.Core.Application/Service/QC/QCOperationService.cs
View File

@ -75,7 +75,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == currentQCType)) if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == currentQCType))
{ {
return ResponseOutput.NotOk("请先核查图像，并保存审核问题，然后再发质疑。"); //---请先核查图像，并保存审核问题，然后再发质疑。
return ResponseOutput.NotOk(_localizer["QCOperation_CheckFirst"]);
} }
return ResponseOutput.Ok(); return ResponseOutput.Ok();
@ -100,7 +101,8 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
if (await _qcChallengeRepository.AnyAsync(t => t.IsClosed == false && t.SubjectVisitId == qaQuestionCommand.SubjectVisitId && t.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload)) if (await _qcChallengeRepository.AnyAsync(t => t.IsClosed == false && t.SubjectVisitId == qaQuestionCommand.SubjectVisitId && t.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload))
{ {
throw new BusinessValidationFailedException("当前访视未关闭的质疑已设置了同意CRC重传影像。请在CRC完成影像重传后，先关闭原质疑，再添加新的质疑。"); //---当前访视未关闭的质疑已设置了同意CRC重传影像。请在CRC完成影像重传后，先关闭原质疑，再添加新的质疑。
throw new BusinessValidationFailedException(_localizer["QCOperation_QuestionExist"]);
} }
@ -164,7 +166,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (dbQCChallenge.ReuploadEnum == QCChanllengeReuploadEnum.CRCRequestReupload || dbQCChallenge.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload) if (dbQCChallenge.ReuploadEnum == QCChanllengeReuploadEnum.CRCRequestReupload || dbQCChallenge.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload)
{ {
throw new BusinessValidationFailedException("CRC已申请重传或者QC同意重传，不允许关闭该质疑。请在QC拒绝重传申请或者CRC设置重传影像后，再关闭质疑。"); //---CRC已申请重传或者QC同意重传，不允许关闭该质疑。请在QC拒绝重传申请或者CRC设置重传影像后，再关闭质疑。
throw new BusinessValidationFailedException(_localizer["QCOperation_QuestionCannotClose"]);
} }
@ -182,7 +185,8 @@ namespace IRaCIS.Core.Application.Image.QA
SubjectVisitId = dbQCChallenge.SubjectVisitId, SubjectVisitId = dbQCChallenge.SubjectVisitId,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt, UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
QCChallengeId = dbQCChallenge.Id, QCChallengeId = dbQCChallenge.Id,
TalkContent = "关闭原因: " + input.closeReason //---关闭原因:
TalkContent = _localizer["QCOperation_CloseReason"] + input.closeReason
}); });
var success = await _qcChallengeRepository.SaveChangesAsync(); var success = await _qcChallengeRepository.SaveChangesAsync();
@ -208,7 +212,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (await _repository.AnyAsync<QCChallengeDialog>(t => t.QCChallengeId == qcChallengeId)) if (await _repository.AnyAsync<QCChallengeDialog>(t => t.QCChallengeId == qcChallengeId))
{ {
ResponseOutput.NotOk("当前QC质疑已经回复。"); //---当前QC质疑已经回复。
ResponseOutput.NotOk(_localizer["QCOperation_QuestionReplied"]);
} }
var qaRecord = (await _qcChallengeRepository.FirstOrDefaultAsync(t => t.Id == qcChallengeId)).IfNullThrowException(); var qaRecord = (await _qcChallengeRepository.FirstOrDefaultAsync(t => t.Id == qcChallengeId)).IfNullThrowException();
@ -289,7 +294,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
throw new BusinessValidationFailedException("您没有权限回复一致性核查对话。"); //---您没有权限回复一致性核查对话。
throw new BusinessValidationFailedException(_localizer["QCOperation_NoPermissionReply"]);
} }
var success = await _repository.SaveChangesAsync(); var success = await _repository.SaveChangesAsync();
@ -311,7 +317,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (sv.RequestBackState == RequestBackStateEnum.CRC_RequestBack) if (sv.RequestBackState == RequestBackStateEnum.CRC_RequestBack)
{ {
ResponseOutput.NotOk("当前访视处于申请回退状态， 不允许关闭质疑。"); //---当前访视处于申请回退状态， 不允许关闭质疑。
ResponseOutput.NotOk(_localizer["QCOperation_CannotClose"]);
} }
@ -321,7 +328,8 @@ namespace IRaCIS.Core.Application.Image.QA
await _checkChallengeDialogrepository.AddAsync(new CheckChallengeDialog() await _checkChallengeDialogrepository.AddAsync(new CheckChallengeDialog()
{ {
SubjectVisitId = input.subjectVisitId, SubjectVisitId = input.subjectVisitId,
TalkContent = "原因:" + input.CloseCheckChallenge, //---原因:
TalkContent = _localizer["QCOperation_Reason"] + input.CloseCheckChallenge,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt, UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
}); });
@ -351,12 +359,14 @@ namespace IRaCIS.Core.Application.Image.QA
if (sv.RequestBackState == RequestBackStateEnum.PM_AgressBack) if (sv.RequestBackState == RequestBackStateEnum.PM_AgressBack)
{ {
ResponseOutput.NotOk("当前访视处于回退状态,不允许设置一致性核查通过"); //---当前访视处于回退状态,不允许设置一致性核查通过
ResponseOutput.NotOk(_localizer["QCOperation_CannotPass"]);
} }
if (sv.CheckChallengeState != CheckChanllengeTypeEnum.Closed && sv.AuditState == AuditStateEnum.QCPassed) if (sv.CheckChallengeState != CheckChanllengeTypeEnum.Closed && sv.AuditState == AuditStateEnum.QCPassed)
{ {
ResponseOutput.NotOk("请先关闭一致性核查质疑后，再设置一致性核查通过。"); //---请先关闭一致性核查质疑后，再设置一致性核查通过。
ResponseOutput.NotOk(_localizer["QCOperation_PassAfterClose"]);
} }
sv.CheckUserId = _userInfo.Id; sv.CheckUserId = _userInfo.Id;
@ -390,7 +400,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (sv.CheckState == CheckStateEnum.CVPassed) if (sv.CheckState == CheckStateEnum.CVPassed)
{ {
return ResponseOutput.NotOk("当前访视已通过一致性核查，不允许申请回退"); //---当前访视已通过一致性核查，不允许申请回退
return ResponseOutput.NotOk(_localizer["QCOperation_Cannotback"]);
} }
var QCChallengeId = await _qcChallengeRepository.Where(x => x.SubjectVisitId == subjectVisitId).Select(x => x.Id).FirstOrDefaultAsync(); var QCChallengeId = await _qcChallengeRepository.Where(x => x.SubjectVisitId == subjectVisitId).Select(x => x.Id).FirstOrDefaultAsync();
@ -399,7 +410,8 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
SubjectVisitId = subjectVisitId, SubjectVisitId = subjectVisitId,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt, UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
TalkContent = "CRC申请回退" //---CRC申请回退
TalkContent = _localizer["QCOperation_CRCRollback"]
}); });
@ -411,7 +423,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
return ResponseOutput.NotOk("其他CRC已申请处理，请刷新页面"); //---其他CRC已申请处理，请刷新页面
return ResponseOutput.NotOk(_localizer["QCOperation_OtherCRC"]);
} }
@ -438,7 +451,8 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
sv.RequestBackState = RequestBackStateEnum.PM_NotAgree; sv.RequestBackState = RequestBackStateEnum.PM_NotAgree;
await _repository.AddAsync(new CheckChallengeDialog() { SubjectVisitId = subjectVisitId, TalkContent = "PM/APM拒绝一致性核查回退", UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt }); //---PM/APM拒绝一致性核查回退
await _repository.AddAsync(new CheckChallengeDialog() { SubjectVisitId = subjectVisitId, TalkContent = _localizer["QCOperation_PMReject"], UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt });
await _subjectVisitRepository.SaveChangesAsync(); await _subjectVisitRepository.SaveChangesAsync();
@ -446,7 +460,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
return ResponseOutput.NotOk("您不具备操作权限。"); //---您不具备操作权限。
return ResponseOutput.NotOk(_localizer["QCOperation_NoPermission"]);
} }
} }
@ -470,7 +485,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (sv.CheckState == CheckStateEnum.CVPassed || sv.CheckState == CheckStateEnum.ToCheck) if (sv.CheckState == CheckStateEnum.CVPassed || sv.CheckState == CheckStateEnum.ToCheck)
{ {
return ResponseOutput.NotOk("当前访视还未进行核查或者核查已通过，不允许设置回退。"); //---当前访视还未进行核查或者核查已通过，不允许设置回退。
return ResponseOutput.NotOk(_localizer["QCOperation_CannotRollback"]);
} }
//sv.CheckChallengeState = (int)CheckChanllengeTypeEnum.None; //sv.CheckChallengeState = (int)CheckChanllengeTypeEnum.None;
@ -509,7 +525,8 @@ namespace IRaCIS.Core.Application.Image.QA
//_qcChallengeRepository.Delete(t => t.SubjectVisitId == subjectVisitId); //_qcChallengeRepository.Delete(t => t.SubjectVisitId == subjectVisitId);
//_qcChallengeDialogRepository.Delete(t => t.SubjectVisitId == subjectVisitId); //_qcChallengeDialogRepository.Delete(t => t.SubjectVisitId == subjectVisitId);
//_checkChallengeDialogRepository.Delete(t => t.SubjectVisitId == subjectVisitId); //_checkChallengeDialogRepository.Delete(t => t.SubjectVisitId == subjectVisitId);
await _repository.AddAsync(new CheckChallengeDialog() { SubjectVisitId = subjectVisitId, TalkContent = "PM/APM同意一致性核查回退。", UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt }); //---PM/APM同意一致性核查回退。
await _repository.AddAsync(new CheckChallengeDialog() { SubjectVisitId = subjectVisitId, TalkContent = _localizer["QCOperation_PMAPMConsistency"], UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt });
await _repository.BatchDeleteAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId); await _repository.BatchDeleteAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId);
@ -684,7 +701,8 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
if (await _subjectVisitRepository.AnyAsync(t => t.Id == updateModalityCommand.SubjectVisitId && t.SubmitState == SubmitStateEnum.Submitted)) if (await _subjectVisitRepository.AnyAsync(t => t.Id == updateModalityCommand.SubjectVisitId && t.SubmitState == SubmitStateEnum.Submitted))
{ {
throw new BusinessValidationFailedException("提交之后，不允许修改!"); //---提交之后，不允许修改!
throw new BusinessValidationFailedException(_localizer["QCOperation_NoModifyAfterSubmit"]);
} }
} }
@ -732,7 +750,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (await _repository.AnyAsync<QCChallenge>(t => t.SubjectVisitId == subjectVisitId && t.IsClosed == false)) if (await _repository.AnyAsync<QCChallenge>(t => t.SubjectVisitId == subjectVisitId && t.IsClosed == false))
{ {
return ResponseOutput.NotOk("当前访视有质疑未关闭，不允许该操作"); //---当前访视有质疑未关闭，不允许该操作
return ResponseOutput.NotOk(_localizer["QCOperation_UnresolvedQCQuery"]);
} }
return ResponseOutput.Ok(); return ResponseOutput.Ok();
} }
@ -759,7 +778,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (await _subjectVisitRepository.AnyAsync(t => t.Id == subjectVisitId && t.SubmitState == SubmitStateEnum.Submitted && if (await _subjectVisitRepository.AnyAsync(t => t.Id == subjectVisitId && t.SubmitState == SubmitStateEnum.Submitted &&
(!t.QCChallengeList.Any(u => u.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload)))) (!t.QCChallengeList.Any(u => u.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload))))
{ {
return ResponseOutput.NotOk("CRC已经提交，不允许删除。"); //---CRC已经提交，不允许删除。
return ResponseOutput.NotOk(_localizer["QCOperation_CrcNoDelete"]);
} }
var waitDeleteStudyList = await _dicomStudyRepository.Where(x => ids.Contains(x.Id)).ToListAsync(); var waitDeleteStudyList = await _dicomStudyRepository.Where(x => ids.Contains(x.Id)).ToListAsync();
@ -853,7 +873,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (subjectVisit!.CurrentActionUserId != _userInfo.Id) if (subjectVisit!.CurrentActionUserId != _userInfo.Id)
{ {
throw new BusinessValidationFailedException("您不是该质控任务当前领取人，没有操作权限!"); //---您不是该质控任务当前领取人，没有操作权限!
throw new BusinessValidationFailedException(_localizer["QCOperation_NoRecipient"]);
} }
} }
@ -871,7 +892,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (dbSubjectVisit.CurrentActionUserId == null && dbSubjectVisit.IsTake == false) if (dbSubjectVisit.CurrentActionUserId == null && dbSubjectVisit.IsTake == false)
{ {
return ResponseOutput.NotOk("当前访视的影像质控任务已被原领取人释放。您可以通过“领取”获得", ApiResponseCodeEnum.NeedTips); //---当前访视的影像质控任务已被原领取人释放。您可以通过“领取”获得
return ResponseOutput.NotOk(_localizer["QCOperation_QCImageTaskAlreadyReleased"], ApiResponseCodeEnum.NeedTips);
} }
@ -916,13 +938,15 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
//throw new BusinessValidationFailedException("当前访视已被领取，不允许领取"); //throw new BusinessValidationFailedException("当前访视已被领取，不允许领取");
return ResponseOutput.NotOk("当前访视的影像质控任务已被其他QC领取，不允许领取", ApiResponseCodeEnum.NeedTips); //---当前访视的影像质控任务已被其他QC领取，不允许领取
return ResponseOutput.NotOk(_localizer["QCOperation_QCTaskNoAccess"], ApiResponseCodeEnum.NeedTips);
} }
if (await _subjectVisitRepository.AnyAsync(t => t.Trial.QCQuestionConfirmedUserId == null && t.Id == subjectVisitId)) if (await _subjectVisitRepository.AnyAsync(t => t.Trial.QCQuestionConfirmedUserId == null && t.Id == subjectVisitId))
{ {
return ResponseOutput.NotOk("请先配置影像质控审核问题，再领取影像质控任务", ApiResponseCodeEnum.NeedTips); //---请先配置影像质控审核问题，再领取影像质控任务
return ResponseOutput.NotOk(_localizer["QCOperation_QCConfigFirst"], ApiResponseCodeEnum.NeedTips);
} }
@ -940,13 +964,15 @@ namespace IRaCIS.Core.Application.Image.QA
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit) if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{ {
return ResponseOutput.NotOk("项目配置为不审，没有领取QC Task"); //---项目配置为不审，没有领取QC Task
return ResponseOutput.NotOk(_localizer["QCOperation_NoQC"]);
} }
else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit) else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit)
{ {
if (dbSubjectVisit.PreliminaryAuditUserId == _userInfo.Id) if (dbSubjectVisit.PreliminaryAuditUserId == _userInfo.Id)
{ {
return ResponseOutput.NotOk("初审已通过，不能继续领取"); //---初审已通过，不能继续领取
return ResponseOutput.NotOk(_localizer["QCOperation_InitialAuditPassed"]);
} }
if (dbSubjectVisit.SubmitState == SubmitStateEnum.Submitted && dbSubjectVisit.AuditState == AuditStateEnum.ToAudit) if (dbSubjectVisit.SubmitState == SubmitStateEnum.Submitted && dbSubjectVisit.AuditState == AuditStateEnum.ToAudit)
@ -966,7 +992,8 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
if (dbSubjectVisit.PreliminaryAuditUserId == _userInfo.Id) if (dbSubjectVisit.PreliminaryAuditUserId == _userInfo.Id)
{ {
return ResponseOutput.NotOk("复审不能和初审是同一个人"); //---复审不能和初审是同一个人
return ResponseOutput.NotOk(_localizer["QCOperation_NoSameReviewer"]);
} }
//提交 并且初审通过 那么领取后进入 复审中 //提交 并且初审通过 那么领取后进入 复审中
@ -985,7 +1012,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
return ResponseOutput.NotOk("项目配置为复审，不满足提交状态：已提交 或者 审核状态：待审核/QC中, 不允许领取,请刷新界面"); //---项目配置为复审，不满足提交状态：已提交 或者 审核状态：待审核/QC中, 不允许领取,请刷新界面
return ResponseOutput.NotOk(_localizer["QCOperation_NoSecondaryAudit"]);
} }
} }
@ -1005,13 +1033,15 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
if (dbSubjectVisit!.CurrentActionUserId != _userInfo.Id) if (dbSubjectVisit!.CurrentActionUserId != _userInfo.Id)
{ {
return ResponseOutput.NotOk("您不是该质控任务当前领取人，没有操作权限!", ApiResponseCodeEnum.NeedTips); //---您不是该质控任务当前领取人，没有操作权限!
return ResponseOutput.NotOk(_localizer["QCOperation_NoRecipient"], ApiResponseCodeEnum.NeedTips);
} }
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit) if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{ {
return ResponseOutput.NotOk("项目配置影像质控为不审，不需要取消任务功能"); //---项目配置影像质控为不审，不需要取消任务功能
return ResponseOutput.NotOk(_localizer["QCOperation_NoQCFunction"]);
} }
else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit) else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit)
{ {
@ -1023,7 +1053,8 @@ namespace IRaCIS.Core.Application.Image.QA
else else
{ {
return ResponseOutput.NotOk("当前访视影像质控任务没有当前领取人，不能释放。"); //---当前访视影像质控任务没有当前领取人，不能释放。
return ResponseOutput.NotOk(_localizer["QCOperation_NoTaskOwner"]);
} }
} }
else if (trialConfig.QCProcessEnum == TrialQCProcess.DoubleAudit) else if (trialConfig.QCProcessEnum == TrialQCProcess.DoubleAudit)
@ -1042,7 +1073,8 @@ namespace IRaCIS.Core.Application.Image.QA
else else
{ {
return ResponseOutput.NotOk("当前访视影像质控任务没有当前领取人, 不能释放"); //---当前访视影像质控任务没有当前领取人，不能释放。
return ResponseOutput.NotOk(_localizer["QCOperation_NoTaskOwner"]);
} }
} }
@ -1076,15 +1108,16 @@ namespace IRaCIS.Core.Application.Image.QA
if (nameList.Count() > 0) if (nameList.Count() > 0)
{ {
return ResponseOutput.NotOk($"当前访视要求进行疾病进展确认。请在提交当前访视前，先处理未提交的前序访视：{string.Join('、', nameList)}。", 1, ApiResponseCodeEnum.NeedTips); //$"当前访视要求进行疾病进展确认。请在提交当前访视前，先处理未提交的前序访视：{string.Join('、', nameList)}。"
return ResponseOutput.NotOk(_localizer["QCOperation_DiseaseProgressConfirmation", string.Join('、', nameList)], 1, ApiResponseCodeEnum.NeedTips);
} }
} }
else else
{ {
if (nameList.Count() > 0) if (nameList.Count() > 0)
{ {
//$"在提交当前访视后，请尽快处理尚未提交的前序访视：{string.Join('、', nameList)}。"
return ResponseOutput.NotOk($"在提交当前访视后，请尽快处理尚未提交的前序访视：{string.Join('、', nameList)}。", 0, ApiResponseCodeEnum.NeedTips); return ResponseOutput.NotOk(_localizer["QCOperation_UnsubmittedVisits", string.Join('、', nameList)], 0, ApiResponseCodeEnum.NeedTips);
} }
} }
} }
@ -1092,7 +1125,8 @@ namespace IRaCIS.Core.Application.Image.QA
//同时要根据项目有没有配置Subject 级别临床数据 //同时要根据项目有没有配置Subject 级别临床数据
if (dbSubjectVisitList.Any(t => t.IsBaseLine && !t.IsHaveClinicalData)) if (dbSubjectVisitList.Any(t => t.IsBaseLine && !t.IsHaveClinicalData))
{ {
return ResponseOutput.NotOk($"基线没有临床数据，确认提交？", 0, ApiResponseCodeEnum.NeedTips); //---基线没有临床数据，确认提交？
return ResponseOutput.NotOk(_localizer["QCOperation_NoBaselineData"], 0, ApiResponseCodeEnum.NeedTips);
} }
return ResponseOutput.Ok(); return ResponseOutput.Ok();
@ -1131,17 +1165,20 @@ namespace IRaCIS.Core.Application.Image.QA
if (dbSubjectVisitList.Any(t => t.SubmitState == SubmitStateEnum.None)) if (dbSubjectVisitList.Any(t => t.SubmitState == SubmitStateEnum.None))
{ {
return ResponseOutput.NotOk("有访视未上传任何Dicom/非Dicom影像数据，不允许提交"); //---有访视未上传任何Dicom/非Dicom影像数据，不允许提交
return ResponseOutput.NotOk(_localizer["QCOperation_NoImageData"]);
} }
//单个提交提示信息 //单个提交提示信息
if (dbSubjectVisitList.Count() == 1 && dbSubjectVisitList.First().SubmitState == SubmitStateEnum.Submitted) if (dbSubjectVisitList.Count() == 1 && dbSubjectVisitList.First().SubmitState == SubmitStateEnum.Submitted)
{ {
return ResponseOutput.NotOk("当前访视的影像数据，已经由其他CRC提交。", 3, ApiResponseCodeEnum.NeedTips); //---当前访视的影像数据，已经由其他CRC提交。
return ResponseOutput.NotOk(_localizer["QCOperation_ImagesSubmitted"], 3, ApiResponseCodeEnum.NeedTips);
} }
else if (dbSubjectVisitList.Any(t => t.SubmitState == SubmitStateEnum.Submitted)) else if (dbSubjectVisitList.Any(t => t.SubmitState == SubmitStateEnum.Submitted))
{ {
return ResponseOutput.NotOk("当前批量提交访视的影像数据，其中部分已由其他CRC提交。", 3, ApiResponseCodeEnum.NeedTips); //---当前批量提交访视的影像数据，其中部分已由其他CRC提交。
return ResponseOutput.NotOk(_localizer["QCOperation_BatchImagesSubmitted"], 3, ApiResponseCodeEnum.NeedTips);
} }
//获取确认的临床数据配置 //获取确认的临床数据配置
@ -1154,7 +1191,8 @@ namespace IRaCIS.Core.Application.Image.QA
//基线不验证 //基线不验证
if (trialConfig.IsHaveFirstGiveMedicineDate && !dbSubjectVisit.IsBaseLine && dbSubjectVisit.Subject.FirstGiveMedicineTime == null) if (trialConfig.IsHaveFirstGiveMedicineDate && !dbSubjectVisit.IsBaseLine && dbSubjectVisit.Subject.FirstGiveMedicineTime == null)
{ {
return ResponseOutput.NotOk("项目配置了需要填写访视基准日期。但是受试者没有填写访视基准日期，不允许提交"); //---项目配置了需要填写访视基准日期。但是受试者没有填写访视基准日期，不允许提交
return ResponseOutput.NotOk(_localizer["QCOperation_MissingBaselineDate"]);
} }
//基线 且配置了临床数据 //基线 且配置了临床数据
@ -1416,7 +1454,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (!await _repository.AnyAsync<TrialUser>(t => t.TrialId == trialId && t.UserId == _userInfo.Id)) if (!await _repository.AnyAsync<TrialUser>(t => t.TrialId == trialId && t.UserId == _userInfo.Id))
{ {
return ResponseOutput.NotOk("您已经被移出项目，没有操作权限。"); //---您已经被移出项目，没有操作权限。
return ResponseOutput.NotOk(_localizer["QCOperation_RemoveItem"]);
} }
@ -1425,7 +1464,8 @@ namespace IRaCIS.Core.Application.Image.QA
//判断质疑是否都关闭了 //判断质疑是否都关闭了
if (await _repository.AnyAsync<QCChallenge>(t => t.SubjectVisitId == subjectVisitId && t.IsClosed == false)) if (await _repository.AnyAsync<QCChallenge>(t => t.SubjectVisitId == subjectVisitId && t.IsClosed == false))
{ {
return ResponseOutput.NotOk("当前访视有影像质控质疑未关闭，不能进行此操作。"); //---当前访视有影像质控质疑未关闭，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotClosed"]);
} }
} }
@ -1455,7 +1495,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit) if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{ {
return ResponseOutput.NotOk("项目配置影像质控为不审，不需要设置为影像质控通过。"); //---项目配置影像质控为不审，不需要设置为影像质控通过。
return ResponseOutput.NotOk(_localizer["QCOperation_NoQCNeeded"]);
} }
else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit) else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit)
@ -1464,7 +1505,8 @@ namespace IRaCIS.Core.Application.Image.QA
{ {
if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == CurrentQC.First)) if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == CurrentQC.First))
{ {
return ResponseOutput.NotOk("影像质控审核问题没有保存，不能进行此操作。"); //---影像质控审核问题没有保存，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotSaved"]);
} }
// 单审 // 单审
@ -1499,7 +1541,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
return ResponseOutput.NotOk("项目配置影像质控为单审，当前访视影像质控任务不能从当前审核状态变更到 审核通过。"); //---项目配置影像质控为单审，当前访视影像质控任务不能从当前审核状态变更到 审核通过。
return ResponseOutput.NotOk(_localizer["QCOperation_NotChangePass"]);
} }
@ -1514,7 +1557,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == CurrentQC.First)) if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == CurrentQC.First))
{ {
return ResponseOutput.NotOk("影像质控审核问题没有保存，不能进行此操作。"); //---影像质控审核问题没有保存，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotSaved"]);
} }
dbSubjectVisit.AuditState = AuditStateEnum.PrimaryQCPassed; dbSubjectVisit.AuditState = AuditStateEnum.PrimaryQCPassed;
@ -1528,7 +1572,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == CurrentQC.Second)) if (!await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.SubjectVisitId == subjectVisitId && t.CurrentQCEnum == CurrentQC.Second))
{ {
return ResponseOutput.NotOk("影像质控审核问题没有保存，不能进行此操作。"); //---影像质控审核问题没有保存，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotSaved"]);
} }
dbSubjectVisit.AuditState = AuditStateEnum.QCPassed; dbSubjectVisit.AuditState = AuditStateEnum.QCPassed;
@ -1560,7 +1605,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
return ResponseOutput.NotOk($"项目配置影像质控为双审。当前审核状态为 {dbSubjectVisit.AuditState}，不能变更到 审核通过。"); //$"项目配置影像质控为双审。当前审核状态为 {dbSubjectVisit.AuditState}，不能变更到 审核通过。"
return ResponseOutput.NotOk(_localizer["QCOperation_CannotChangeToPass", dbSubjectVisit.AuditState]);
} }
} }
} }
@ -1571,7 +1617,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit) if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{ {
return ResponseOutput.NotOk("项目配置影像质控为不审，不允许设置影像质控终止。"); //---项目配置影像质控为不审，不允许设置影像质控终止。
return ResponseOutput.NotOk(_localizer["QCOperation_NoQCNeededNotEnd"]);
} }
else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit) else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit)
{ {
@ -1584,7 +1631,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
return ResponseOutput.NotOk("项目配置影像质控为单审，当前审核状态不为 InPrimaryQC，不能变更到 审核终止"); // 项目配置影像质控为单审，当前审核状态不为 InPrimaryQC，不能变更到 审核终止
return ResponseOutput.NotOk(_localizer["QCOperation_CannotChangeToStop"]);
} }
} }
else if (trialConfig.QCProcessEnum == TrialQCProcess.DoubleAudit) else if (trialConfig.QCProcessEnum == TrialQCProcess.DoubleAudit)
@ -1602,7 +1650,8 @@ namespace IRaCIS.Core.Application.Image.QA
} }
else else
{ {
return ResponseOutput.NotOk($"项目配置影像质控为双审，当前审核状态为 {dbSubjectVisit.AuditState}，不能变更到 审核终止"); //$"项目配置影像质控为双审，当前审核状态为 {dbSubjectVisit.AuditState}，不能变更到 审核终止"
return ResponseOutput.NotOk(_localizer["QCOperation_CannotChangeStop", dbSubjectVisit.AuditState]);
} }
@ -1660,7 +1709,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.QCAgreeUpload) if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.QCAgreeUpload)
{ {
throw new BusinessValidationFailedException("当前重传状态不为QC同意重传，不允许重传"); //---当前重传状态不为QC同意重传，不允许重传
throw new BusinessValidationFailedException(_localizer["QCOperation_InvalidResend"]);
} }
return ResponseOutput.Ok(); return ResponseOutput.Ok();
} }
@ -1684,7 +1734,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit) if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{ {
return ResponseOutput.NotOk("不审操作，不会有需要重传的操作!"); //---不审操作，不会有需要重传的操作!
return ResponseOutput.NotOk(_localizer["QCOperation_NoResendNeeded"]);
} }
var qcChallenge = (await _qcChallengeRepository.FirstOrDefaultAsync(t => t.Id == qcChallengeId)).IfNullThrowException(); var qcChallenge = (await _qcChallengeRepository.FirstOrDefaultAsync(t => t.Id == qcChallengeId)).IfNullThrowException();
@ -1696,13 +1747,15 @@ namespace IRaCIS.Core.Application.Image.QA
if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.CRCRequestReupload) if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.CRCRequestReupload)
{ {
throw new BusinessValidationFailedException("当前重传状态不为CRC申请重传，不允许设置同意重传"); //---当前重传状态不为CRC申请重传，不允许设置同意重传
throw new BusinessValidationFailedException(_localizer["QCOperation_InvalidAgreeResend"]);
} }
if (await _qcChallengeRepository.CountAsync(t => t.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload && t.SubjectVisitId == qcChallenge.SubjectVisitId && t.IsClosed == false) >= 1) if (await _qcChallengeRepository.CountAsync(t => t.ReuploadEnum == QCChanllengeReuploadEnum.QCAgreeUpload && t.SubjectVisitId == qcChallenge.SubjectVisitId && t.IsClosed == false) >= 1)
{ {
return ResponseOutput.NotOk("当前访视,有一个未关闭的质疑 QC设置了同意重传，CRC还未完成上传，当前不允许再次设置"); //---当前访视,有一个未关闭的质疑 QC设置了同意重传，CRC还未完成上传，当前不允许再次设置
return ResponseOutput.NotOk(_localizer["QCOperation_CannotAgreeResend"]);
} }
@ -1718,7 +1771,8 @@ namespace IRaCIS.Core.Application.Image.QA
SubjectVisitId = qcChallenge.SubjectVisitId, SubjectVisitId = qcChallenge.SubjectVisitId,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt, UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
QCChallengeId = qcChallenge.Id, QCChallengeId = qcChallenge.Id,
TalkContent = "QC同意重传" //---QC同意重传
TalkContent = _localizer["QCOperation_AgreeResend"]
}); });
//双审 并且是2QC 那么需要回退到1QC 讲1QC数据清除 //双审 并且是2QC 那么需要回退到1QC 讲1QC数据清除
@ -1779,7 +1833,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.QCAgreeUpload) if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.QCAgreeUpload)
{ {
throw new BusinessValidationFailedException("当前重传状态不为QC同意重传，不允许设置重传完成"); //---当前重传状态不为QC同意重传，不允许设置重传完成
throw new BusinessValidationFailedException(_localizer["QCOperation_InvalidCompleteResend"]);
} }
@ -1788,7 +1843,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (await _subjectVisitRepository.Where(t => t.Id == subjectVisitId).SelectMany(t => t.StudyList).CountAsync() == 0 && if (await _subjectVisitRepository.Where(t => t.Id == subjectVisitId).SelectMany(t => t.StudyList).CountAsync() == 0 &&
await _subjectVisitRepository.Where(t => t.Id == subjectVisitId).SelectMany(t => t.NoneDicomStudyList).SelectMany(u => u.NoneDicomFileList).CountAsync() == 0) await _subjectVisitRepository.Where(t => t.Id == subjectVisitId).SelectMany(t => t.NoneDicomStudyList).SelectMany(u => u.NoneDicomFileList).CountAsync() == 0)
{ {
throw new BusinessValidationFailedException("当前没有影像，不允许设置重传完成"); //---当前没有影像，不允许设置重传完成
throw new BusinessValidationFailedException(_localizer["QCOperation_NoImageNotAllowed"]);
} }
var trialConfig = await _trialRepository var trialConfig = await _trialRepository
@ -1822,7 +1878,8 @@ namespace IRaCIS.Core.Application.Image.QA
QCChallengeId = qcChallenge.Id, QCChallengeId = qcChallenge.Id,
TalkContent = "CRC已重传完成" //---CRC已重传完成
TalkContent = _localizer["QCOperation_CRCTransferCompleted"]
}); });
@ -1854,7 +1911,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.None && qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.CRCReuploaded) if (qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.None && qcChallenge.ReuploadEnum != QCChanllengeReuploadEnum.CRCReuploaded)
{ {
throw new BusinessValidationFailedException("当前质疑重传状态不为初始状态|CRC重传完成状态，不允许申请重传"); //---当前质疑重传状态不为初始状态|CRC重传完成状态，不允许申请重传
throw new BusinessValidationFailedException(_localizer["QCOperation_InvalidTransferStatus"]);
} }
@ -1872,7 +1930,8 @@ namespace IRaCIS.Core.Application.Image.QA
SubjectVisitId = qcChallenge.SubjectVisitId, SubjectVisitId = qcChallenge.SubjectVisitId,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt, UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
QCChallengeId = qcChallenge.Id, QCChallengeId = qcChallenge.Id,
TalkContent = "CRC申请重传/上传影像" //---CRC申请重传/上传影像
TalkContent = _localizer["QCOperation_CRCTransfer"]
}); });
var isSuccess = await _qcChallengeRepository.SaveChangesAsync(); var isSuccess = await _qcChallengeRepository.SaveChangesAsync();
@ -1902,13 +1961,15 @@ namespace IRaCIS.Core.Application.Image.QA
if (await _subjectVisitRepository.Where(t => t.Id == command.SubjectVisitId) if (await _subjectVisitRepository.Where(t => t.Id == command.SubjectVisitId)
.AnyAsync(t => t.SubmitState == SubmitStateEnum.Submitted && t.IsEnrollmentConfirm != command.IsEnrollmentConfirm)) .AnyAsync(t => t.SubmitState == SubmitStateEnum.Submitted && t.IsEnrollmentConfirm != command.IsEnrollmentConfirm))
{ {
return ResponseOutput.NotOk("该访视已提交，不能修改入组确认状态"); //---该访视已提交，不能修改入组确认状态
return ResponseOutput.NotOk(_localizer["QCOperation_CannotModifyConfirmation"]);
} }
if (await _subjectVisitRepository.Where(t => t.Id == command.SubjectVisitId) if (await _subjectVisitRepository.Where(t => t.Id == command.SubjectVisitId)
.AnyAsync(t => t.IsEnrollmentConfirm != command.IsEnrollmentConfirm && t.RequestBackState == RequestBackStateEnum.PM_AgressBack)) .AnyAsync(t => t.IsEnrollmentConfirm != command.IsEnrollmentConfirm && t.RequestBackState == RequestBackStateEnum.PM_AgressBack))
{ {
return ResponseOutput.NotOk("该访视为回退访视，不允许修改PD确认状态"); //---该访视为回退访视，不允许修改PD确认状态
return ResponseOutput.NotOk(_localizer["QCOperation_CannotModifyPDStatus"]);
} }
dbSubjectVisit.IsEnrollmentConfirm = command.IsEnrollmentConfirm.Value; dbSubjectVisit.IsEnrollmentConfirm = command.IsEnrollmentConfirm.Value;
@ -1994,7 +2055,8 @@ namespace IRaCIS.Core.Application.Image.QA
await _subjectVisitRepository.BatchUpdateNoTrackingAsync(t => t.Id == subjectVisitId, await _subjectVisitRepository.BatchUpdateNoTrackingAsync(t => t.Id == subjectVisitId,
u => new SubjectVisit() { ForwardState = ForwardStateEnum.ForwardFailed }); u => new SubjectVisit() { ForwardState = ForwardStateEnum.ForwardFailed });
return ResponseOutput.NotOk("转发影像失败。" + result.Failures.ToString() + result.ToJson()); //---转发影像失败。
return ResponseOutput.NotOk(_localizer["QCOperation_ForwardingFailed"] + result.Failures.ToString() + result.ToJson());
} }
} }
} }
@ -2024,7 +2086,8 @@ namespace IRaCIS.Core.Application.Image.QA
await _subjectVisitRepository.SaveChangesAsync(); await _subjectVisitRepository.SaveChangesAsync();
return isSuccess ? ResponseOutput.Ok() : ResponseOutput.NotOk("转发影像失败。"); //---转发影像失败。
return isSuccess ? ResponseOutput.Ok() : ResponseOutput.NotOk(_localizer["QCOperation_ForwardingFailed"]);
} }

8
IRaCIS.Core.Application/Service/QC/QCQuestionService.cs
View File

@ -1,4 +1,4 @@
//-------------------------------------------------------------------- //--------------------------------------------------------------------
// 此代码由T4模板自动生成 byzhouhang 20210918 // 此代码由T4模板自动生成 byzhouhang 20210918
// 生成时间 2021-11-11 11:04:54 // 生成时间 2021-11-11 11:04:54
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。 // 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
@ -107,7 +107,8 @@ namespace IRaCIS.Core.Application.Contracts
if (await _qcQuestionRepository.AnyAsync(x => x.Id != addOrEditQCQuestionConfigure.Id && x.ShowOrder == addOrEditQCQuestionConfigure.ShowOrder)) if (await _qcQuestionRepository.AnyAsync(x => x.Id != addOrEditQCQuestionConfigure.Id && x.ShowOrder == addOrEditQCQuestionConfigure.ShowOrder))
{ {
throw new BusinessValidationFailedException("序号重复,操作失败"); //---序号重复,操作失败
throw new BusinessValidationFailedException(_localizer["QCQuestion_DuplicateIndexFailed"]);
} }
@ -121,7 +122,8 @@ namespace IRaCIS.Core.Application.Contracts
{ {
if (await _qcQuestionRepository.AnyAsync(x => x.ParentId == qCQuestionConfigureId)) if (await _qcQuestionRepository.AnyAsync(x => x.ParentId == qCQuestionConfigureId))
{ {
throw new BusinessValidationFailedException("当前任务存在子问题,删除失败"); //---当前任务存在子问题,删除失败
throw new BusinessValidationFailedException(_localizer["QCQuestion_HasChildQuestion"]);
} }
await _qcQuestionRepository.DeleteFromQueryAsync(t => t.Id == qCQuestionConfigureId,true); await _qcQuestionRepository.DeleteFromQueryAsync(t => t.Id == qCQuestionConfigureId,true);
return ResponseOutput.Ok(); return ResponseOutput.Ok();

14
IRaCIS.Core.Application/Service/QC/TrialQCQuestionService.cs
View File

@ -1,4 +1,4 @@
//-------------------------------------------------------------------- //--------------------------------------------------------------------
// 此代码由T4模板自动生成 byzhouhang 20210918 // 此代码由T4模板自动生成 byzhouhang 20210918
// 生成时间 2021-11-11 11:04:54 // 生成时间 2021-11-11 11:04:54
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。 // 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
@ -124,7 +124,8 @@ namespace IRaCIS.Core.Application.Contracts
{ {
if (!await _repository.AnyAsync<Trial>(t => t.Id == trialId && t.QCQuestionConfirmedUserId == null)) if (!await _repository.AnyAsync<Trial>(t => t.Id == trialId && t.QCQuestionConfirmedUserId == null))
{ {
throw new BusinessValidationFailedException("影像质控审核问题模板已经确认，不允许操作。"); //---影像质控审核问题模板已经确认，不允许操作。
throw new BusinessValidationFailedException(_localizer["TrialQCQuestion_TemplateConfirmed"]);
} }
} }
@ -250,7 +251,8 @@ namespace IRaCIS.Core.Application.Contracts
if (await _trialQcQuestionRepository.AnyAsync(x => x.TrialId == addOrEditTrialQCQuestionConfigure.TrialId && x.Id != addOrEditTrialQCQuestionConfigure.Id && x.ShowOrder == addOrEditTrialQCQuestionConfigure.ShowOrder)) if (await _trialQcQuestionRepository.AnyAsync(x => x.TrialId == addOrEditTrialQCQuestionConfigure.TrialId && x.Id != addOrEditTrialQCQuestionConfigure.Id && x.ShowOrder == addOrEditTrialQCQuestionConfigure.ShowOrder))
{ {
throw new BusinessValidationFailedException("序号重复,操作失败"); //---序号重复,操作失败
throw new BusinessValidationFailedException(_localizer["TrialQCQuestion_DuplicateIndexFailed"]);
} }
@ -274,12 +276,14 @@ namespace IRaCIS.Core.Application.Contracts
if (await _trialQcQuestionRepository.AnyAsync(t => t.ParentId == trialQCQuestionConfigureId)) if (await _trialQcQuestionRepository.AnyAsync(t => t.ParentId == trialQCQuestionConfigureId))
{ {
return ResponseOutput.NotOk("请在删除父问题前，请先删除引用该父问题的子问题。"); //---请在删除父问题前，请先删除引用该父问题的子问题。
return ResponseOutput.NotOk(_localizer["TrialQCQuestion_DeleteChildFirst"]);
} }
if (await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.TrialQCQuestionConfigureId == trialQCQuestionConfigureId)) if (await _repository.AnyAsync<TrialQCQuestionAnswer>(t => t.TrialQCQuestionConfigureId == trialQCQuestionConfigureId))
{ {
return ResponseOutput.NotOk("该审核问题已被影像质控过程引用，不允许删除。"); //---该审核问题已被影像质控过程引用，不允许删除
return ResponseOutput.NotOk(_localizer["TrialQCQuestion_ReferencedByQCProcess"]);
} }
await _trialQcQuestionRepository.DeleteFromQueryAsync(t => t.Id == trialQCQuestionConfigureId, true); await _trialQcQuestionRepository.DeleteFromQueryAsync(t => t.Id == trialQCQuestionConfigureId, true);