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))
{
return ResponseOutput.NotOk("请先核查图像，并保存审核问题，然后再发质疑。");
//---请先核查图像，并保存审核问题，然后再发质疑。
return ResponseOutput.NotOk(_localizer["QCOperation_CheckFirst"]);
}
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))
{
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)
{
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,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
QCChallengeId = dbQCChallenge.Id,
TalkContent = "关闭原因: " + input.closeReason
//---关闭原因:
TalkContent = _localizer["QCOperation_CloseReason"] + input.closeReason
});
var success = await _qcChallengeRepository.SaveChangesAsync();
@ -208,7 +212,8 @@ namespace IRaCIS.Core.Application.Image.QA
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();
@ -289,7 +294,8 @@ namespace IRaCIS.Core.Application.Image.QA
}
else
{
throw new BusinessValidationFailedException("您没有权限回复一致性核查对话。");
//---您没有权限回复一致性核查对话。
throw new BusinessValidationFailedException(_localizer["QCOperation_NoPermissionReply"]);
}
var success = await _repository.SaveChangesAsync();
@ -311,7 +317,8 @@ namespace IRaCIS.Core.Application.Image.QA
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()
{
SubjectVisitId = input.subjectVisitId,
TalkContent = "原因:" + input.CloseCheckChallenge,
//---原因:
TalkContent = _localizer["QCOperation_Reason"] + input.CloseCheckChallenge,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
});
@ -351,12 +359,14 @@ namespace IRaCIS.Core.Application.Image.QA
if (sv.RequestBackState == RequestBackStateEnum.PM_AgressBack)
{
ResponseOutput.NotOk("当前访视处于回退状态,不允许设置一致性核查通过");
//---当前访视处于回退状态,不允许设置一致性核查通过
ResponseOutput.NotOk(_localizer["QCOperation_CannotPass"]);
}
if (sv.CheckChallengeState != CheckChanllengeTypeEnum.Closed && sv.AuditState == AuditStateEnum.QCPassed)
{
ResponseOutput.NotOk("请先关闭一致性核查质疑后，再设置一致性核查通过。");
//---请先关闭一致性核查质疑后，再设置一致性核查通过。
ResponseOutput.NotOk(_localizer["QCOperation_PassAfterClose"]);
}
sv.CheckUserId = _userInfo.Id;
@ -390,7 +400,8 @@ namespace IRaCIS.Core.Application.Image.QA
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();
@ -399,7 +410,8 @@ namespace IRaCIS.Core.Application.Image.QA
{
SubjectVisitId = subjectVisitId,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
TalkContent = "CRC申请回退"
//---CRC申请回退
TalkContent = _localizer["QCOperation_CRCRollback"]
});
@ -411,7 +423,8 @@ namespace IRaCIS.Core.Application.Image.QA
}
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;
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();
@ -446,7 +460,8 @@ namespace IRaCIS.Core.Application.Image.QA
}
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)
{
return ResponseOutput.NotOk("当前访视还未进行核查或者核查已通过，不允许设置回退。");
//---当前访视还未进行核查或者核查已通过，不允许设置回退。
return ResponseOutput.NotOk(_localizer["QCOperation_CannotRollback"]);
}
//sv.CheckChallengeState = (int)CheckChanllengeTypeEnum.None;
@ -509,7 +525,8 @@ namespace IRaCIS.Core.Application.Image.QA
//_qcChallengeRepository.Delete(t => t.SubjectVisitId == subjectVisitId);
//_qcChallengeDialogRepository.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);
@ -684,7 +701,8 @@ namespace IRaCIS.Core.Application.Image.QA
{
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))
{
return ResponseOutput.NotOk("当前访视有质疑未关闭，不允许该操作");
//---当前访视有质疑未关闭，不允许该操作
return ResponseOutput.NotOk(_localizer["QCOperation_UnresolvedQCQuery"]);
}
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 &&
(!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();
@ -853,7 +873,8 @@ namespace IRaCIS.Core.Application.Image.QA
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)
{
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("当前访视已被领取，不允许领取");
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))
{
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)
{
return ResponseOutput.NotOk("项目配置为不审，没有领取QC Task");
//---项目配置为不审，没有领取QC Task
return ResponseOutput.NotOk(_localizer["QCOperation_NoQC"]);
}
else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit)
{
if (dbSubjectVisit.PreliminaryAuditUserId == _userInfo.Id)
{
return ResponseOutput.NotOk("初审已通过，不能继续领取");
//---初审已通过，不能继续领取
return ResponseOutput.NotOk(_localizer["QCOperation_InitialAuditPassed"]);
}
if (dbSubjectVisit.SubmitState == SubmitStateEnum.Submitted && dbSubjectVisit.AuditState == AuditStateEnum.ToAudit)
@ -966,7 +992,8 @@ namespace IRaCIS.Core.Application.Image.QA
{
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
{
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)
{
return ResponseOutput.NotOk("您不是该质控任务当前领取人，没有操作权限!", ApiResponseCodeEnum.NeedTips);
//---您不是该质控任务当前领取人，没有操作权限!
return ResponseOutput.NotOk(_localizer["QCOperation_NoRecipient"], ApiResponseCodeEnum.NeedTips);
}
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{
return ResponseOutput.NotOk("项目配置影像质控为不审，不需要取消任务功能");
//---项目配置影像质控为不审，不需要取消任务功能
return ResponseOutput.NotOk(_localizer["QCOperation_NoQCFunction"]);
}
else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit)
{
@ -1023,7 +1053,8 @@ namespace IRaCIS.Core.Application.Image.QA
else
{
return ResponseOutput.NotOk("当前访视影像质控任务没有当前领取人，不能释放。");
//---当前访视影像质控任务没有当前领取人，不能释放。
return ResponseOutput.NotOk(_localizer["QCOperation_NoTaskOwner"]);
}
}
else if (trialConfig.QCProcessEnum == TrialQCProcess.DoubleAudit)
@ -1042,7 +1073,8 @@ namespace IRaCIS.Core.Application.Image.QA
else
{
return ResponseOutput.NotOk("当前访视影像质控任务没有当前领取人, 不能释放");
//---当前访视影像质控任务没有当前领取人，不能释放。
return ResponseOutput.NotOk(_localizer["QCOperation_NoTaskOwner"]);
}
}
@ -1076,15 +1108,16 @@ namespace IRaCIS.Core.Application.Image.QA
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
{
if (nameList.Count() > 0)
{
return ResponseOutput.NotOk($"在提交当前访视后，请尽快处理尚未提交的前序访视：{string.Join('、', nameList)}。", 0, ApiResponseCodeEnum.NeedTips);
//$"在提交当前访视后，请尽快处理尚未提交的前序访视：{string.Join('、', nameList)}。"
return ResponseOutput.NotOk(_localizer["QCOperation_UnsubmittedVisits", string.Join('、', nameList)], 0, ApiResponseCodeEnum.NeedTips);
}
}
}
@ -1092,7 +1125,8 @@ namespace IRaCIS.Core.Application.Image.QA
//同时要根据项目有没有配置Subject 级别临床数据
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();
@ -1131,17 +1165,20 @@ namespace IRaCIS.Core.Application.Image.QA
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)
{
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))
{
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)
{
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))
{
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))
{
return ResponseOutput.NotOk("当前访视有影像质控质疑未关闭，不能进行此操作。");
//---当前访视有影像质控质疑未关闭，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotClosed"]);
}
}
@ -1455,7 +1495,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{
return ResponseOutput.NotOk("项目配置影像质控为不审，不需要设置为影像质控通过。");
//---项目配置影像质控为不审，不需要设置为影像质控通过。
return ResponseOutput.NotOk(_localizer["QCOperation_NoQCNeeded"]);
}
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))
{
return ResponseOutput.NotOk("影像质控审核问题没有保存，不能进行此操作。");
//---影像质控审核问题没有保存，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotSaved"]);
}
// 单审
@ -1499,7 +1541,8 @@ namespace IRaCIS.Core.Application.Image.QA
}
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))
{
return ResponseOutput.NotOk("影像质控审核问题没有保存，不能进行此操作。");
//---影像质控审核问题没有保存，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotSaved"]);
}
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))
{
return ResponseOutput.NotOk("影像质控审核问题没有保存，不能进行此操作。");
//---影像质控审核问题没有保存，不能进行此操作。
return ResponseOutput.NotOk(_localizer["QCOperation_QCNotSaved"]);
}
dbSubjectVisit.AuditState = AuditStateEnum.QCPassed;
@ -1560,7 +1605,8 @@ namespace IRaCIS.Core.Application.Image.QA
}
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)
{
return ResponseOutput.NotOk("项目配置影像质控为不审，不允许设置影像质控终止。");
//---项目配置影像质控为不审，不允许设置影像质控终止。
return ResponseOutput.NotOk(_localizer["QCOperation_NoQCNeededNotEnd"]);
}
else if (trialConfig.QCProcessEnum == TrialQCProcess.SingleAudit)
{
@ -1584,7 +1631,8 @@ namespace IRaCIS.Core.Application.Image.QA
}
else
{
return ResponseOutput.NotOk("项目配置影像质控为单审，当前审核状态不为 InPrimaryQC，不能变更到 审核终止");
// 项目配置影像质控为单审，当前审核状态不为 InPrimaryQC，不能变更到 审核终止
return ResponseOutput.NotOk(_localizer["QCOperation_CannotChangeToStop"]);
}
}
else if (trialConfig.QCProcessEnum == TrialQCProcess.DoubleAudit)
@ -1602,7 +1650,8 @@ namespace IRaCIS.Core.Application.Image.QA
}
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)
{
throw new BusinessValidationFailedException("当前重传状态不为QC同意重传，不允许重传");
//---当前重传状态不为QC同意重传，不允许重传
throw new BusinessValidationFailedException(_localizer["QCOperation_InvalidResend"]);
}
return ResponseOutput.Ok();
}
@ -1684,7 +1734,8 @@ namespace IRaCIS.Core.Application.Image.QA
if (trialConfig.QCProcessEnum == TrialQCProcess.NotAudit)
{
return ResponseOutput.NotOk("不审操作，不会有需要重传的操作!");
//---不审操作，不会有需要重传的操作!
return ResponseOutput.NotOk(_localizer["QCOperation_NoResendNeeded"]);
}
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)
{
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)
{
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,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
QCChallengeId = qcChallenge.Id,
TalkContent = "QC同意重传"
//---QC同意重传
TalkContent = _localizer["QCOperation_AgreeResend"]
});
//双审 并且是2QC 那么需要回退到1QC 讲1QC数据清除
@ -1779,7 +1833,8 @@ namespace IRaCIS.Core.Application.Image.QA
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 &&
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
@ -1822,7 +1878,8 @@ namespace IRaCIS.Core.Application.Image.QA
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)
{
throw new BusinessValidationFailedException("当前质疑重传状态不为初始状态|CRC重传完成状态，不允许申请重传");
//---当前质疑重传状态不为初始状态|CRC重传完成状态，不允许申请重传
throw new BusinessValidationFailedException(_localizer["QCOperation_InvalidTransferStatus"]);
}
@ -1872,7 +1930,8 @@ namespace IRaCIS.Core.Application.Image.QA
SubjectVisitId = qcChallenge.SubjectVisitId,
UserTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt,
QCChallengeId = qcChallenge.Id,
TalkContent = "CRC申请重传/上传影像"
//---CRC申请重传/上传影像
TalkContent = _localizer["QCOperation_CRCTransfer"]
});
var isSuccess = await _qcChallengeRepository.SaveChangesAsync();
@ -1902,13 +1961,15 @@ namespace IRaCIS.Core.Application.Image.QA
if (await _subjectVisitRepository.Where(t => t.Id == command.SubjectVisitId)
.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)
.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;
@ -1994,7 +2055,8 @@ namespace IRaCIS.Core.Application.Image.QA
await _subjectVisitRepository.BatchUpdateNoTrackingAsync(t => t.Id == subjectVisitId,
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();
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
// 生成时间 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))
{
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))
{
throw new BusinessValidationFailedException("当前任务存在子问题,删除失败");
//---当前任务存在子问题,删除失败
throw new BusinessValidationFailedException(_localizer["QCQuestion_HasChildQuestion"]);
}
await _qcQuestionRepository.DeleteFromQueryAsync(t => t.Id == qCQuestionConfigureId,true);
return ResponseOutput.Ok();

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

@ -1,4 +1,4 @@
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// 此代码由T4模板自动生成 byzhouhang 20210918
// 生成时间 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))
{
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))
{
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))
{
return ResponseOutput.NotOk("请在删除父问题前，请先删除引用该父问题的子问题。");
//---请在删除父问题前，请先删除引用该父问题的子问题。
return ResponseOutput.NotOk(_localizer["TrialQCQuestion_DeleteChildFirst"]);
}
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);