EI-Image-Viewer-Api/IRaCIS.Core.API/Controllers/InspectionController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using Castle.Core.Internal;
using IRaCIS.Application.Contracts;
using IRaCIS.Application.Interfaces;
using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Application.Contracts.DTO;
using IRaCIS.Core.Application.Filter;
using IRaCIS.Core.Application.Image.QA;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.Service.Inspection.DTO;
using IRaCIS.Core.Application.Service.Inspection.Interface;
using IRaCIS.Core.Domain.Models;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infra.EFCore;
using IRaCIS.Core.Infrastructure.Extention;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;

namespace IRaCIS.Core.API.Controllers
{

    [ApiController, ApiExplorerSettings(GroupName = "Reviewer")]
    [UnitOfWork]
    public class InspectionController : ControllerBase
    {
        private readonly IRepository _repository;
        private readonly IMapper _mapper;
        private readonly IUserInfo _userInfo;
        private readonly ITrialDocumentService _trialDocumentService;
        private readonly IQCListService _qCListService;
        private readonly IHttpContextAccessor _httpContext;
        private readonly ITrialConfigService _trialConfigService;
        private readonly INoneDicomStudyService _noneDicomStudyService;
        private readonly ISubjectService _subjectService;
        private readonly ISubjectVisitService _subjectVisitService;
        private readonly IQCOperationService _qCOperationService;
        private readonly IClinicalDataService _clinicalDataService;
        private readonly IVisitPlanService _visitPlanService;
        private readonly IInspectionService _inspectionService;

        private readonly IRepository<DataInspection> _dataInspectionRepository;
        private delegate Task<IResponseOutput> executionFun(dynamic data);

        public InspectionController(IRepository repository,
            IRepository<DataInspection> _repositoryDataInspection,
            IMapper mapper, IUserInfo userInfo,
            ITrialDocumentService trialDocumentService,
            IRepository<DataInspection> dataInspectionRepository,
            IQCListService _qCListService,
            IHttpContextAccessor httpContext,
            IInspectionService sinspectionService,
            ITrialConfigService _trialConfigService,
            INoneDicomStudyService noneDicomStudyService,
            ISubjectService _subjectService,

            ISubjectVisitService subjectVisitService,
            IQCOperationService qCOperationService,
            IClinicalDataService clinicalDataService,
            IVisitPlanService visitPlanService
            )
        {
            this._repository = repository;
            this._mapper = mapper;
            this._userInfo = userInfo;
            this._inspectionService = sinspectionService;
            this._trialDocumentService = trialDocumentService;
            this._qCListService = _qCListService;
            this._httpContext = httpContext;
            this._trialConfigService = _trialConfigService;
            this._noneDicomStudyService = noneDicomStudyService;
            this._subjectService = _subjectService;
            this._subjectVisitService = subjectVisitService;
            this._qCOperationService = qCOperationService;
            this._clinicalDataService = clinicalDataService;
            this._visitPlanService = visitPlanService;
            this._dataInspectionRepository = dataInspectionRepository;
        }


        //[HttpPost, Route("Inspection/Test")]
        //public async Task Test(string Table, string ForeignKeyValue, string ForeignKeyText, string value)
        //{
        //   string a= await _dataInspectionRepository.GetDictionaryValue(Table, ForeignKeyValue, ForeignKeyText, value);
        //}

        #region 文件管理

        /// <summary>
        /// 废除项目
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/TrialConfig/AbandonTrial")]
        [UnitOfWork]
        public async Task<IResponseOutput> AbandonTrial(DataInspectionDto<AbandonTrial> opt)
        {
            var fun = await _trialConfigService.AbandonTrial(opt.OptCommand.trialId, opt.OptCommand.isAbandon);
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }

        /// <summary>
        /// 修改项目状态项目
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/TrialConfig/UpdateTrialState")]
        [UnitOfWork]
        public async Task<IResponseOutput> UpdateTrialState(DataInspectionDto<UpdateTrialState> opt)
        {
            var fun = await _trialConfigService.UpdateTrialState(opt.OptCommand.trialId, opt.OptCommand.trialStatusStr, opt.OptCommand.reason);
            opt.AuditInfo.Reason = opt.OptCommand.reason;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="opt">参数</param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/trialDocument/AddOrUpdateTrialDocument")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdateTrialDocument(DataInspectionDto<AddOrEditTrialDocument> opt)
        {
            var fun = _trialDocumentService.AddOrUpdateTrialDocument;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }


        [HttpPost, Route("Inspection/trialDocument/UserAbandonDoc")]
        [UnitOfWork]
        public async Task<IResponseOutput> UserAbandonDoc(DataInspectionDto<AddOrEditTrialDocument> opt)
        {
            var fun = _trialDocumentService.UserAbandonDoc;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }
        #endregion

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


        #region 影像质疑
        /// <summary>
        /// 手动领取 或者取消 QC任务
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/ObtainOrCancelQCTask")]
        [UnitOfWork]
        public async Task<IResponseOutput> ObtainOrCancelQCTask(DataInspectionDto<ObtainOrCancelQCTaskDto> opt)
        {
            var fun = await _qCOperationService.ObtainOrCancelQCTask(opt.OptCommand.trialId, opt.OptCommand.subjectVisitId, opt.OptCommand.obtaionOrCancel);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }

        /// <summary>
        /// 添加或者更新 QC核对问题列表
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/AddOrUpdateQCQuestionAnswerList")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdateQCQuestionAnswerList(DataInspectionDto<AddOrUpdateQCQuestionAnswerListDto> opt)

        {
            var fun = await _qCOperationService.AddOrUpdateQCQuestionAnswerList(opt.OptCommand.qcQuestionAnswerCommands, opt.OptCommand.trialId, opt.OptCommand.subjectVisitId, opt.OptCommand.trialQCProcess, opt.OptCommand.currentQCType);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);


        }


        /// <summary>
        ///  添加和更新质疑
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/AddOrUpdateQCChallenge")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdateQCChallenge(DataInspectionDto<AddOrUpdateQCChallengeDto> opt)
        {
            var fun = await _qCOperationService.AddOrUpdateQCChallenge(opt.OptCommand.qaQuestionCommand, opt.OptCommand.trialId, opt.OptCommand.trialQCProcess, opt.OptCommand.currentQCType);
            opt.AuditInfo.GeneralId = fun.Id;
            Dictionary<string, object> keyValuePairs = new Dictionary<string, object>();
            keyValuePairs.Add("ChallengeCode", "Q" + fun.ChallengeCode.ToString("D5"));
            opt.AuditInfo.JsonDetail = _inspectionService.AddJsonItem(opt.AuditInfo.JsonDetail, keyValuePairs);
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, ResponseOutput.Ok());
        }


        /// <summary>
        /// 回复质疑
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/AddQCChallengeReply")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddQCChallengeReply(DataInspectionDto<QADialogCommand> opt)
        {
            var fun = _qCOperationService.AddQCChallengeReply;
            opt.AuditInfo.GeneralId = opt.OptCommand.QCChallengeId;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 关闭质疑
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/CloseQCChallenge")]
        [UnitOfWork]
        public async Task<IResponseOutput> CloseQCChallenge(DataInspectionDto<CloseQCChallengeDto> opt)
        {
            var fun = await _qCOperationService.CloseQCChallenge(opt.OptCommand.qcChallengeId, opt.OptCommand.subjectVisitId, opt.OptCommand.closeEnum, opt.OptCommand.closeReason);

            opt.AuditInfo.GeneralId = opt.OptCommand.qcChallengeId;
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }



        /// <summary>
        /// 删除QC质疑记录
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/DeleteQCChallenge")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeleteQCChallenge(DataInspectionDto<IDDto> opt)
        {
            var fun = _qCOperationService.DeleteQCChallenge;
            opt.AuditInfo.GeneralId = opt.OptCommand.Id;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }



        /// <summary>
        /// 一致性核查 质疑的添加/回复
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/AddCheckChallengeReply")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddCheckChallengeReply(DataInspectionDto<CheckChallengeDialogCommand> opt)

        {
            var fun = _qCOperationService.AddCheckChallengeReply;

            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }


        /// <summary>
        /// 删除QC质疑记录
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/CloseCheckChallenge")]
        [UnitOfWork]
        public async Task<IResponseOutput> CloseCheckChallenge(DataInspectionDto<CloseCheckChallengeDto> opt)
        {
            var fun = _qCOperationService.CloseCheckChallenge;
            opt.AuditInfo.Reason = opt.OptCommand.CloseCheckChallenge;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 手动设置一致性核查通过
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/SetCheckPass")]
        [UnitOfWork]
        public async Task<IResponseOutput> SetCheckPass(DataInspectionDto<SetCheckPassDt> opt)
        {
            var fun = _qCOperationService.SetCheckPass;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// CRC 请求回退
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/CRCRequstCheckBack")]
        [UnitOfWork]
        public async Task<IResponseOutput> CRCRequstCheckBack(DataInspectionDto<IDDto> opt)
        {
            var fun = _qCOperationService.CRCRequstCheckBack;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }


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


        /// <summary>
        /// QC修改检查部位和 拍片类型
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/UpdateModality")]
        [UnitOfWork]
        public async Task<IResponseOutput> UpdateModality(DataInspectionDto<UpdateModalityDto> opt)
        {
            var fun = await _qCOperationService.UpdateModality(opt.OptCommand.id, (Guid)opt.AuditInfo.SubjectVisitId, opt.OptCommand.type, opt.OptCommand.modality, opt.OptCommand.bodyPart);
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }

        /// <summary>
        /// 1、设置为不读片，2 设置为读片(取消 先前设置为不读片)  4 设置为删除(数据库记录软删除) 5 恢复为未删除
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/SetSeriesState")]
        [UnitOfWork]
        public async Task<IResponseOutput> SetSeriesState(DataInspectionDto<SetSeriesStateDto> opt)
        {
            var fun = await _qCOperationService.SetSeriesState(opt.OptCommand.subjectVisitId, opt.OptCommand.studyId, opt.OptCommand.seriesId, opt.OptCommand.state);
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }

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


        /// <summary>
        /// 设置、取消 访视紧急
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/SetVisitUrgent")]
        [UnitOfWork]
        public async Task<IResponseOutput> SetVisitUrgent(DataInspectionDto<SetVisitUrgentDto> opt)
        {
            var fun = await _qCOperationService.SetVisitUrgent(opt.OptCommand.trialId, opt.OptCommand.subjectVisitId, opt.OptCommand.setOrCancel);
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// QA设置  需要重传
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/SetNeedReupload")]
        [UnitOfWork]
        public async Task<IResponseOutput> SetNeedReupload(DataInspectionDto<SetNeedReuploadDto> opt)
        {
            var fun = await _qCOperationService.SetNeedReupload(opt.OptCommand.trialId, opt.OptCommand.qcChallengeId);
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// CRC  设置已经重传完成
        /// </summary>
        [HttpPost, Route("Inspection/QCOperation/SetReuploadFinished")]
        [UnitOfWork]
        public async Task<IResponseOutput> SetReuploadFinished(DataInspectionDto<CRCReuploadFinishedCommand> opt)
        {
            var fun = _qCOperationService.SetReuploadFinished;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// CRCRequestReUpload
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/CRCRequestReUpload")]
        [UnitOfWork]
        public async Task<IResponseOutput> CRCRequestReUpload(DataInspectionDto<IDDto> opt)
        {
            var fun = _qCOperationService.CRCRequestReUpload;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 影像转发
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/ForwardSVDicomImage")]
        [UnitOfWork]
        public async Task<IResponseOutput> ForwardSVDicomImage(DataInspectionDto<ForwardSVDicomImageDto> opt)
        {
            var fun = _qCOperationService.ForwardSVDicomImage;
            opt.AuditInfo.NeedSava = false;
            return await _inspectionService.Enforcement(opt.OptCommand.subjectVisitIdList, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 一致性核查 excel上传 支持三种格式
        /// </summary>
        /// <param name="file"></param>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/UploadVisitCheckExcel")]
        [UnitOfWork]
        public async Task<IResponseOutput> UploadVisitCheckExcel(IFormFile file, [FromForm] UploadVisitCheckExcelDto opt)
        {


            var fun = await _qCOperationService.UploadVisitCheckExcel(file, opt.trialId);
            return fun;
            //var data = JsonConvert.DeserializeObject<DataInspectionAddDTO>(opt.AuditInfo);
            //return await _inspectionService.Enforcement(opt.trialId, data, null, null, fun);
        }

        #endregion
        #region 影像上传


        /// <summary>
        /// 疾病进展确认评估
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/UpdateSubjectAndSVInfo")]
        [UnitOfWork]
        public async Task<IResponseOutput> UpdateSubjectAndSVInfo(DataInspectionDto<UploadSubjectAndVisitCommand> opt)
        {
            var fun = _qCOperationService.UpdateSubjectAndSVInfo;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }


        /// <summary>
        /// 删除影像
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/deleteStudyList")]
        [UnitOfWork]
        public async Task<IResponseOutput> deleteStudyList(DataInspectionDto<DeleteStudyList> opt)
        {
            var fun = await _qCOperationService.DeleteStudyList(opt.OptCommand.ids, opt.OptCommand.subjectVisitId, opt.OptCommand.trialId);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            opt.AuditInfo.NeedSava = false;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// CRC RequestToQC  批量提交
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/QCOperation/CRCRequestToQC")]
        [UnitOfWork]
        public async Task<IResponseOutput> CRCRequestToQC(DataInspectionDto<CRCRequestToQCCommand> opt)
        {
            var fun = _qCOperationService.CRCRequestToQC;
            opt.AuditInfo.NeedSava = false;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }


        /// <summary>
        /// 非DICOM影像新增编辑
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/noneDicomStudy/AddOrUpdateNoneDicomStudy")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdateNoneDicomStudy(DataInspectionDto<NoneDicomStudyAddOrEdit> opt)
        {
            var fun = await _noneDicomStudyService.AddOrUpdateNoneDicomStudy(opt.OptCommand);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            if (opt.OptCommand.Id == null)
            {
                Dictionary<string, object> keyValuePairs = new Dictionary<string, object>();
                keyValuePairs.Add("CodeView", fun.Data.StudyCode);
                opt.AuditInfo.JsonDetail = _inspectionService.AddJsonItem(opt.AuditInfo.JsonDetail, keyValuePairs);
            }

            opt.AuditInfo.GeneralId = fun.Data.Id;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// 删除非dicom
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/noneDicom/DeleteNoneDicomStudy")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeleteNoneDicomStudy(DataInspectionDto<IDDto> opt)
        {
            var fun = _noneDicomStudyService.DeleteNoneDicomStudy;
            opt.AuditInfo.GeneralId = opt.OptCommand.Id;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }



        /// <summary>
        /// 删除非dicom文件
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/noneDicom/deleteNoneDicomStudyFile")]
        [UnitOfWork]
        public async Task<IResponseOutput> deleteNoneDicomStudyFile(DataInspectionDto<IDDto> opt)
        {
            var fun = _noneDicomStudyService.DeleteNoneDicomStudyFile;
            //opt.AuditInfo.GeneralId = opt.OptCommand.Id;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }

        #endregion
        #region 临床数据采集 ClinicalDataService 
        /// <summary>
        /// 新增或修改既往放疗史
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/clinicalData/AddOrUpdatePreviousHistory")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdatePreviousHistory(DataInspectionDto<PreviousHistoryAddOrEdit> opt)
        {
            var fun = await _clinicalDataService.AddOrUpdatePreviousHistory(opt.OptCommand);
            opt.AuditInfo.GeneralId = fun.Data;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// 删除既往放疗史
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/clinicalData/DeletePreviousHistory")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeletePreviousHistory(DataInspectionDto<IDDto> opt)
        {
            var fun = _clinicalDataService.DeletePreviousHistory;
            opt.AuditInfo.GeneralId = opt.OptCommand.Id;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }




        /// <summary>
        /// 新增或修改既往手术史
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/clinicalData/AddOrUpdatePreviousSurgery")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdatePreviousSurgery(DataInspectionDto<PreviousSurgeryAddOrEdit> opt)
        {
            var fun = await _clinicalDataService.AddOrUpdatePreviousSurgery(opt.OptCommand);
            opt.AuditInfo.GeneralId = fun.Data;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// 删除既往手术史
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/clinicalData/DeletePreviousSurgery")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeletePreviousSurgery(DataInspectionDto<IDDto> opt)
        {
            var fun = _clinicalDataService.DeletePreviousSurgery;
            opt.AuditInfo.GeneralId = opt.OptCommand.Id;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }


        /// <summary>
        /// 新增或修改既往其他治疗史
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/clinicalData/AddOrUpdatePreviousOther")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdatePreviousOther(DataInspectionDto<PreviousOtherAddOrEdit> opt)
        {
            var fun = await _clinicalDataService.AddOrUpdatePreviousOther(opt.OptCommand);
            opt.AuditInfo.GeneralId = fun.Data;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// 删除既往其他治疗史
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/clinicalData/DeletePreviousOther")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeletePreviousOther(DataInspectionDto<IDDto> opt)
        {

            var fun = _clinicalDataService.DeletePreviousOther;
            opt.AuditInfo.GeneralId = opt.OptCommand.Id;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }
        #endregion
        #region 访视计划
        /// <summary>
        /// 新增或添加访视计划
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/VisitPlan/AddOrUpdateVisitStage")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdateVisitStage(DataInspectionDto<VisitPlanCommand> opt)
        {
            var fun = await _visitPlanService.AddOrUpdateVisitStage(opt.OptCommand);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            opt.AuditInfo.VisitStageId = fun.Data.Id;
            opt.OptCommand.Id = fun.Data.Id;
            opt.AuditInfo.BlindName = fun.Data.BlindName;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        /// <summary>
        /// 删除访视计划对象
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/VisitPlan/DeleteVisitStage")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeleteVisitStage(DataInspectionDto<IDDto> opt)
        {
            var fun = _visitPlanService.DeleteVisitStage;

            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 确认访视计划
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/VisitPlan/ConfirmTrialVisitPlan")]
        [UnitOfWork]
        public async Task<IResponseOutput> ConfirmTrialVisitPlan(DataInspectionDto<IDDto> opt)
        {
            var fun = _visitPlanService.ConfirmTrialVisitPlan;
            opt.AuditInfo.NeedSava = false;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 下载访视计划
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/VisitPlan/DownloadInflunceStudyList")]
        [UnitOfWork]
        public async Task<IResponseOutput> DownloadInflunceStudyList(DataInspectionDto<IDDto> opt)
        {
            var fun = _visitPlanService.DownloadInflunceStudyList;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }
        #endregion
        #region 访视

        [HttpPost, Route("Inspection/subjectVisit/addOrUpdateSV")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdateSV(DataInspectionDto<SubjectVisitCommand> opt)
        {
            var fun = await _subjectVisitService.AddOrUpdateSV(opt.OptCommand);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            opt.AuditInfo.SubjectVisitId = Guid.Parse(fun.Data);
            opt.AuditInfo.SubjectVisitName = opt.OptCommand.VisitName;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        [HttpPost, Route("Inspection/subjectVisit/SetSubjectVisitUrgent")]
        [UnitOfWork]
        public async Task<IResponseOutput> SetSubjectVisitUrgent(DataInspectionDto<SetSubjectVisitUrgentCommand> opt)
        {

            var fun = await _subjectVisitService.SetSubjectVisitUrgent(opt.OptCommand.SubjectVisitId, opt.OptCommand.isUrgent);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }


        [HttpPost, Route("Inspection/subjectVisit/DeleteSV")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeleteSV(DataInspectionDto<DeleteSVCommand> opt)
        {

            var fun = await _subjectVisitService.DeleteSV(opt.OptCommand.SubjectVisitId);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }

        [HttpPost, Route("Inspection/subjectVisit/SetSVExecuted")]
        [UnitOfWork]
        public async Task<IResponseOutput> SetSVExecuted(DataInspectionDto<DeleteSVCommand> opt)
        {

            var fun = await _subjectVisitService.SetSVExecuted(opt.OptCommand.SubjectVisitId);
            if (!fun.IsSuccess)
            {
                return ResponseOutput.NotOk(fun.ErrorMessage);
            }
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }

        #endregion
        #region 配置项目信息
        /// <summary>
        /// 配置 基础逻辑信息
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/configTrialBasicInfo")]
        [UnitOfWork]
        public async Task<IResponseOutput> ConfigTrialBasicInfo(DataInspectionDto<BasicTrialConfig> opt)
        {
            var fun = _trialConfigService.ConfigTrialBasicInfo;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 配置流程
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/configTrialProcessInfo")]
        [UnitOfWork]
        public async Task<IResponseOutput> ConfigTrialProcessInfo(DataInspectionDto<TrialProcessConfig> opt)
        {
            var fun = _trialConfigService.ConfigTrialProcessInfo;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 配置加急信息
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialUrgentInfo")]
        [UnitOfWork]
        public async Task<IResponseOutput> ConfigTrialUrgentInfo(DataInspectionDto<TrialUrgentConfig> opt)
        {
            var fun = _trialConfigService.ConfigTrialUrgentInfo;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 签名确认
        /// </summary>
        /// <returns></returns>
        [HttpPost, Route("Inspection/configTrialBasicInfo/TrialConfigSignatureConfirm")]
        [UnitOfWork]
        public async Task<IResponseOutput> TrialConfigSignatureConfirm(DataInspectionDto<SignConfirmDTO> opt)
        {
            var fun = _trialConfigService.TrialConfigSignatureConfirm;
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }


        /// <summary>
        /// 配置 基础逻辑信息并确认
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialBasicInfoConfirm")]
        [UnitOfWork]
        public async Task<IResponseOutput> ConfigTrialBasicInfoConfirm(DataInspectionDto<BasicTrialConfig> opt)
        {
            var data = await _trialConfigService.ConfigTrialBasicInfo(opt.OptCommand);
            if (!data.IsSuccess)
            {
                return ResponseOutput.NotOk(data.ErrorMessage);
            }
            var fun = _trialConfigService.TrialConfigSignatureConfirm;
            return await _inspectionService.Enforcement(new SignConfirmDTO()
            {
                TrialId = opt.OptCommand.TrialId,
                SignCode = opt.OptCommand.SignCode
            }, opt.AuditInfo, opt.SignInfo, fun);

        }

        /// <summary>
        /// 配置流程并确认
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialProcessInfoConfirm")]
        [UnitOfWork]
        public async Task<IResponseOutput> ConfigTrialProcessInfoConfirm(DataInspectionDto<TrialProcessConfig> opt)
        {
            var data = await _trialConfigService.ConfigTrialProcessInfo(opt.OptCommand);
            if (!data.IsSuccess)
            {
                return ResponseOutput.NotOk(data.ErrorMessage);
            }
            var fun = _trialConfigService.TrialConfigSignatureConfirm;
            return await _inspectionService.Enforcement(new SignConfirmDTO()
            {
                TrialId = opt.OptCommand.TrialId,
                SignCode = opt.OptCommand.SignCode
            }, opt.AuditInfo, opt.SignInfo, fun);
        }

        /// <summary>
        /// 配置加急信息并确认
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns> 
        [HttpPost, Route("Inspection/configTrialBasicInfo/ConfigTrialUrgentInfoConfirm")]
        [UnitOfWork]
        public async Task<IResponseOutput> ConfigTrialUrgentInfoConfirm(DataInspectionDto<TrialUrgentConfig> opt)
        {
            var data = await _trialConfigService.ConfigTrialUrgentInfo(opt.OptCommand);
            if (!data.IsSuccess)
            {
                return ResponseOutput.NotOk(data.ErrorMessage);
            }
            var fun = _trialConfigService.TrialConfigSignatureConfirm;
            return await _inspectionService.Enforcement(new SignConfirmDTO()
            {
                TrialId = opt.OptCommand.TrialId,
                SignCode = opt.OptCommand.SignCode
            }, opt.AuditInfo, opt.SignInfo, fun);
        }


        /// <summary>
        /// 保存并确认访视计划
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpPost, Route("Inspection/VisitPlan/SaveConfirmTrialVisitPlan")]
        [UnitOfWork]
        public async Task<IResponseOutput> SaveConfirmTrialVisitPlan(DataInspectionDto<VisitPlanCommand> opt)
        {
            var update = await _visitPlanService.AddOrUpdateVisitStage(opt.OptCommand);
            if (!update.IsSuccess)
            {
                return ResponseOutput.NotOk(update.ErrorMessage);
            }
            var fun = _visitPlanService.ConfirmTrialVisitPlan;
            return await _inspectionService.Enforcement(opt.OptCommand.Id, opt.AuditInfo, opt.SignInfo, fun);
        }

        #endregion
        #region 受试者
        /// <summary>
        /// 添加或更新受试者信息[New]
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        //[TypeFilter(typeof(TrialResourceFilter))]
        [HttpPost, Route("Inspection/Subject/AddOrUpdateSubject")]
        [UnitOfWork]
        public async Task<IResponseOutput> AddOrUpdateSubject(InsSubjectCommand opt)
        {


            opt.AuditInfo.SubjectCode = opt.OptCommand.Code;
            var fun = await _subjectService.AddOrUpdateSubject(opt.OptCommand);
            opt.AuditInfo.SubjectId = Guid.Parse(fun.Data);
            //var statusdata = new
            //{
            //    Status = "OnVisit",
            //    //OutEnrollmentTime = DateTime.Now.ToString("yyyy-MM-dd"),
            //    //VisitOverTime = DateTime.Now.ToString("yyyy-MM-dd"),
            //    Reason = string.Empty,
            //};

            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, null, fun);
        }

        /// <summary>
        /// 修改受试者状态
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        /// 
        [HttpPut, Route("Inspection/Subject/UpdateSubjectStatus")]
        [UnitOfWork]
        public async Task<IResponseOutput> UpdateSubjectStatus(InsUpdateSubjectStatus opt)
        {
            var fun = _subjectService.UpdateSubjectStatus;

            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun);
        }


        /// <summary>
        /// 删除受试者
        /// </summary>
        /// <param name="opt"></param>
        /// <returns></returns>
        [HttpDelete, Route("Inspection/Subject/DeleteSubject")]
        [UnitOfWork]
        public async Task<IResponseOutput> DeleteSubject(InsDeleteSubjectDto opt)
        {
            var fun = _subjectService.DeleteSubject;
            opt.AuditInfo.SubjectCode = opt.OptCommand.Code;
            var data = await _subjectService.DeleteSubject(opt.OptCommand.SubjectId);
            return await _inspectionService.Enforcement(opt.OptCommand, opt.AuditInfo, opt.SignInfo, fun, data);
        }
        #endregion



    }




}