irc-netcore-api/IRaCIS.Core.API/Controllers/InspectionController.cs

using IRaCIS.Application.Interfaces;
using IRaCIS.Core.Application.BusinessFilter;
using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Application.Filter;
using IRaCIS.Core.Application.Image.QA;
using IRaCIS.Core.Application.Service;
using IRaCIS.Core.Application.Service.Inspection.DTO;
using IRaCIS.Core.Application.Service.Inspection.Interface;
using IRaCIS.Core.Application.Service.Reading.Dto;
using IRaCIS.Core.Application.Service.Reading.Interface;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Infra.EFCore;
using IRaCIS.Core.Infrastructure.Extention;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;


namespace IRaCIS.Core.API.Controllers
{

    [ApiController, ApiExplorerSettings(GroupName = "Reviewer")]
    [UnitOfWork]
    public class InspectionController(
        ITrialDocumentService _trialDocumentService,
        IReadingImageTaskService _iReadingImageTaskService,
        ITrialConfigService _trialConfigService,
        IClinicalAnswerService _clinicalAnswerService,
        IReadingClinicalDataService _readingClinicalDataService,
        IQCOperationService _qCOperationService,
        IInspectionService _inspectionService,
        IReadingMedicalReviewService _readingMedicalReviewService,
        IReadingMedicineQuestionService _readingMedicineQuestionService
        ) : ControllerBase
    {

        #region 获取稽查数据
        /// <summary>
        /// 获取稽查数据
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("Inspection/GetInspectionList")]
        public async Task<PageOutput<GetDataInspectionOutDto>> GetInspectionList(GetDataInspectionDto dto)
        {
            return await _inspectionService.GetInspectionList(dto);
        }
        #endregion

        /// <summary>
        /// 提交肿瘤学阅片任务
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/ReadingImageTask/SubmitOncologyReadingInfo")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> SetOncologyReadingInfo(DataInspectionDto<SubmitOncologyReadingInfoInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _iReadingImageTaskService.SubmitOncologyReadingInfo(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// 提交Diocm阅片
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/ReadingImageTask/SubmitDicomVisitTask")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> SubmitDicomVisitTask(DataInspectionDto<SubmitDicomVisitTaskInDto> opt)
        {

            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _iReadingImageTaskService.SubmitDicomVisitTask(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 提交全局阅片任务
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/ReadingImageTask/SubmitGlobalReadingInfo")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> SubmitGlobalReadingInfo(DataInspectionDto<SubmitGlobalReadingInfoInDto> opt)
        {

            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _iReadingImageTaskService.SubmitGlobalReadingInfo(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 项目阅片信息签名
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/TrialReadingInfoSign")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> TrialReadingInfoSign(DataInspectionDto<TrialReadingInfoSignInDto> opt)
        {

            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.TrialReadingInfoSign(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 医学审核完成
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ReadingMedicalReview/FinishMedicalReview")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> FinishMedicalReview(DataInspectionDto<FinishMedicalReviewInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _readingMedicalReviewService.FinishMedicalReview(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// 确认项目医学审核问题
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ReadingMedicineQuestion/ConfirmReadingMedicineQuestion")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> ConfirmReadingMedicineQuestion(DataInspectionDto<ConfirmReadingMedicineQuestionInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _readingMedicineQuestionService.ConfirmReadingMedicineQuestion(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 提交阅片问题
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ReadingImageTask/SubmitVisitTaskQuestions")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> SubmitVisitTaskQuestions(DataInspectionDto<SubmitVisitTaskQuestionsInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _iReadingImageTaskService.SubmitVisitTaskQuestions(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// CRC签名临床数据
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ClinicalAnswer/CRCSignClinicalData")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> CRCSignClinicalData(DataInspectionDto<CRCSignClinicalDataInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _clinicalAnswerService.CRCSignClinicalData(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// CRC确认临床数据
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ClinicalAnswer/CRCConfirmClinical")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> CRCConfirmClinical(DataInspectionDto<CRCConfirmClinicalInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _clinicalAnswerService.CRCConfirmClinical(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// CRC撤销临床数据
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ClinicalAnswer/CRCCancelConfirmClinical")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> CRCCancelConfirmClinical(DataInspectionDto<CRCCancelConfirmClinicalInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _clinicalAnswerService.CRCCancelConfirmClinical(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// PM确认临床数据
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ClinicalAnswer/PMConfirmClinical")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> PMConfirmClinical(DataInspectionDto<CRCConfirmClinicalInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _clinicalAnswerService.PMConfirmClinical(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// PM签名一致性分析临床数据
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ReadingClinicalData/SignConsistencyAnalysisReadingClinicalData")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> SignConsistencyAnalysisReadingClinicalData(DataInspectionDto<SignConsistencyAnalysisReadingClinicalDataInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _readingClinicalDataService.SignConsistencyAnalysisReadingClinicalData(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// 提交结构化录入并签名
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ClinicalAnswer/SubmitClinicalFormAndSign")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> SubmitClinicalFormAndSign(DataInspectionDto<SubmitClinicalFormInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _clinicalAnswerService.SubmitClinicalForm(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// 提交阅片裁判问题
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ReadingImageTask/SubmitJudgeVisitTaskResult")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        [UnitOfWork]
        public async Task<IResponseOutput> SubmitJudgeVisitTaskResult(DataInspectionDto<SaveJudgeVisitTaskResult> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _iReadingImageTaskService.SubmitJudgeVisitTaskResult(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 配置 基础逻辑信息并确认
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialBasicInfoConfirm")]
        [UnitOfWork]
        [TrialGlobalLimit( "BeforeOngoingCantOpt" )]
        public async Task<IResponseOutput> ConfigTrialBasicInfoConfirm(DataInspectionDto<BasicTrialConfig> opt)
        {

            opt.Data.IsTrialBasicLogicConfirmed = true;
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.ConfigTrialBasicInfo(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }



        /// <summary>
        /// 配置流程并确认
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialProcessInfoConfirm")]
        [UnitOfWork]
        //[TrialGlobalLimit( "BeforeOngoingCantOpt" )]
        public async Task<IResponseOutput> ConfigTrialProcessInfoConfirm(DataInspectionDto<TrialProcessConfig> opt)
        {
            opt.Data.IsTrialProcessConfirmed = true;

            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.ConfigTrialProcessInfo(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }





        /// <summary>
        /// 配置加急信息并确认
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialUrgentInfoConfirm")]
        [UnitOfWork]
        [TrialGlobalLimit( "BeforeOngoingCantOpt" )]
        public async Task<IResponseOutput> ConfigTrialUrgentInfoConfirm(DataInspectionDto<TrialUrgentConfig> opt)
        {
            opt.Data.IsTrialUrgentConfirmed = true;
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.ConfigTrialUrgentInfo(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialPACSInfoConfirm")]
        [UnitOfWork]
        [TrialGlobalLimit( "BeforeOngoingCantOpt" )]
        public async Task<IResponseOutput> ConfigTrialPACSInfoConfirm(DataInspectionDto<TrialPACSConfig> opt)
        {
            opt.Data.IsTrialPACSConfirmed = true;
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.ConfigTrialPACSInfo(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// 签名确认
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("Inspection/configTrialBasicInfo/TrialConfigSignatureConfirm")]
        [UnitOfWork]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        public async Task<IResponseOutput> TrialConfigSignatureConfirm(DataInspectionDto<SignConfirmDTO> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.TrialConfigSignatureConfirm(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 重置并同步项目阅片标准
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ReadingCriterion/ResetAndAsyncCriterion")]
        [UnitOfWork]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]

        public async Task<IResponseOutput> ResetAndAsyncCriterion(DataInspectionDto<ResetAndAsyncCriterionInDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.ResetAndAsyncCriterion(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }



        /// <summary>
        /// CRC RequestToQC  批量提交
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/CRCRequestToQC")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        [UnitOfWork]
        public async Task<IResponseOutput> CRCRequestToQC(DataInspectionDto<CRCRequestToQCCommand> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _qCOperationService.CRCRequestToQC(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 设置QC 通过或者不通过   7:QC failed  8：QC passed  
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/QCPassedOrFailed")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        [UnitOfWork]
        public async Task<IResponseOutput> QCPassedOrFailed(DataInspectionDto<QCPassedOrFailedDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _qCOperationService.QCPassedOrFailed(opt.Data.trialId, opt.Data.subjectVisitId, opt.Data.auditState);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// 一致性核查 回退  对话记录不清除  只允许PM回退
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/CheckBack")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        [UnitOfWork]
        public async Task<IResponseOutput> CheckBack(DataInspectionDto<IDDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _qCOperationService.CheckBack(opt.Data.Id);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 影像阅片临床数据签名
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/ReadClinicalData/ReadClinicalDataSign")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        [UnitOfWork]
        public async Task<IResponseOutput> ReadClinicalDataSign(DataInspectionDto<ReadingClinicalDataSignIndto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _readingClinicalDataService.ReadClinicalDataSign(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// CRC  设置已经重传完成
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/SetReuploadFinished")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        [UnitOfWork]
        public async Task<IResponseOutput> SetReuploadFinished(DataInspectionDto<CRCReuploadFinishedCommand> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _qCOperationService.SetReuploadFinished(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }

        /// <summary>
        /// 更新项目状态
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/TrialConfig/updateTrialState")]
        [TrialGlobalLimit( "BeforeOngoingCantOpt")]
        [UnitOfWork]
        public async Task<IResponseOutput> UpdateTrialState(DataInspectionDto<UpdateTrialStateDto> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _trialConfigService.UpdateTrialState(opt.Data.trialId, opt.Data.trialStatusStr, opt.Data.reason);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 用户 签名某个文档  
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("Inspection/TrialDocument/userConfirm")]
        [TrialGlobalLimit( "BeforeOngoingCantOpt", "SignSystemDocNoTrialId", "AfterStopCannNotOpt" )]
        [UnitOfWork]
        public async Task<IResponseOutput> UserConfirm(DataInspectionDto<UserConfirmCommand> opt)
        {
            var singid = await _inspectionService.RecordSing(opt.SignInfo);
            opt.Data.SignText = opt.SignInfo.SignText;
            var result = await _trialDocumentService.UserConfirm(opt.Data);
            await _inspectionService.CompletedSign(singid, result);
            return result;
        }


        /// <summary>
        /// 重阅同意
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("Inspection/VisitTask/ConfirmReReading")]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        [UnitOfWork]

        public async Task<IResponseOutput> ConfirmReReading(DataInspectionDto<ConfirmReReadingCommand> opt,  [FromServices] IVisitTaskService _visitTaskService)
        {
            var singId = await _inspectionService.RecordSing(opt.SignInfo);
            var result = await _visitTaskService.ConfirmReReading(opt.Data);
            await _inspectionService.CompletedSign(singId, result);
            return result;
        }

    }
}