//using IRaCIS.Application.Contracts;
//using IRaCIS.Core.Application.Contracts.Dicom.DTO;
//using IRaCIS.Core.Application.Contracts.DTO;
//using IRaCIS.Core.Infra.EFCore;
//using IRaCIS.Core.Domain.Models;
//using IRaCIS.Core.Domain.Share;
//using IRaCIS.Core.Infrastructure.Extention;
//using Microsoft.AspNetCore.Mvc.Filters;
//using Microsoft.EntityFrameworkCore;
//using Microsoft.Extensions.Logging;
//using IRaCIS.Core.Infrastructure;
//using IRaCIS.Core.Application.Contracts;

//namespace IRaCIS.Core.Application.Filter
//{
//#pragma warning disable CS8618

//#pragma warning disable CS8062
//    //by zhouhang 2021.08


//审计类型大类
using Microsoft.AspNetCore.Mvc.Filters;

public enum AuditType
{
    TrialAudit = 0,
    SubjectAudit = 1,
    StudyAudit = 2
}

//具体审计操作
public enum AuditOptType
{
    //DeleteTrial = 2,
    AddOrUpdateTrial = 0,

    AddTrialSiteSurvey = 1,

    //参与人员
    AddTrialStaff = 3,
    DeleteTrailStaff = 4,

    //Site
    AddTrialSite = 5,
    DeleteTrialSite = 6,

    //Site CRC
    AddTrialSiteCRC = 7,
    DeleteTrialSiteCRC = 8,

    //访视计划
    AddOrUpdateTrialVisitPlanItem = 9,
    DeleteTrialVisitPlanItem = 10,
    ConfirmTrialVisitPlan = 11,

    //项目模板
    AddOrUpdateTrialTemplate = 12,
    DeleteTrialTemplate = 13,

    //subject  访视计划
    AddOrUpdateSubjectOutPlanVisit = 14,
    DeleteSubjectOutPlanVisit = 15,
    SetSVExecuted = 16,

    AddOrUpdateSubject = 17,
    DeleteSubject = 18,

    //影像上传
    UploadImage = 19,

    //变更QA状态  比如设置为QA中  QA结束通过、不通过
    ChangeStudyStatus = 20,

    //匿名化
    Anonymized = 22,

    //转发
    Forwarded = 24
}

[AttributeUsage(AttributeTargets.Method)]
public class TrialAuditAttribute : Attribute,/*IActionFilter, */IAsyncActionFilter
{
    private readonly AuditType _auditType;
    private readonly AuditOptType _auditOptType;
    public TrialAuditAttribute(AuditType auditType, AuditOptType auditOptType)
    {
        _auditType = auditType;
        _auditOptType = auditOptType;
    }
    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
         await next();

    }
}

//    [AttributeUsage(AttributeTargets.Method)]
//    public class TrialAuditAttribute : Attribute,/*IActionFilter, */IAsyncActionFilter
//    {
//        private readonly AuditType _auditType;
//        private readonly AuditOptType _auditOptType;
//        public IDictionary<string, object> _actionArguments;

//        #region 根据不同接口构造的属性

//        private TrialAuditAttribute _attr;

//        private string _userIdStr;

//        private string _userRealName;

//        private IRepository<TrialAudit> _auditRepository;

//        private TrialUser _userTrial;

//        private TrialSiteUser _userTrialSite;

//        private VisitStage _visitPlan;

//        //private QATrialTemplate _qATrailTemplate;

//        private Subject _subject;

//        private SubjectVisit _subjectVisit;

//        private TrialSite _trialSite;

//        private DicomStudy _study;

//        private IRepository<DicomStudy> _studyRepository;

//        //private IRaCISDBContext _dbContext;

//        //private IDbContextTransaction transaction;


//        #endregion

//        public TrialAuditAttribute(AuditType auditType, AuditOptType auditOptType)
//        {
//            _auditType = auditType;
//            _auditOptType = auditOptType;
//        }


//        #region  同步版本 废弃

//        //public void OnActionExecuted(ActionExecutedContext executedcontext)
//        //{

//        //    //上传影像接口返回值类型特殊 需要单独处理
//        //    if (_attr._auditOptType == AuditOptType.UploadImage)
//        //    {
//        //        //接口参数
//        //        var archiveStudyInfo = (ArchiveStudyCommand)_actionArguments.Values.ToList()[0];

//        //        //接口返回结果  因为上传成功和不成功 泛型类型不一样
//        //        dynamic archive = executedcontext.Result;
//        //        if (archive == null)
//        //        {
//        //          var   logger = (ILogger<TrialAuditAttribute>)executedcontext.HttpContext.RequestServices.GetService(
//        //                         typeof(ILogger<TrialAuditAttribute>));

//        //            logger.LogError("影像上传，OnActionExecuted Reuslt 为null");
//        //            return;
//        //        }
//        //        var archiveResult = (IResponseOutput)archive.Value;



//        //        if (archiveResult.IsSuccess)
//        //        {
//        //            _studyRepository = (IRepository<DicomStudy>)executedcontext.HttpContext.RequestServices.GetService(
//        //                typeof(IRepository<DicomStudy>));

//        //            var successResult = (IResponseOutput<DicomArchiveResult>)archiveResult;

//        //            _study = _studyRepository.GetAll().First(t =>
//        //                t.Id == successResult.Data.ArchivedDicomStudies.ToList()[0].Id);

//        //            _auditRepository.Add(new TrialAudit()
//        //            {
//        //                TrialId = _study.TrialId,
//        //                SubjectId = _study.SubjectId,
//        //                StudyId = _study.Id,
//        //                AuditType = (int)AuditType.StudyAudit,
//        //                Note = $"{ _userRealName} 动作变更了 { _study.StudyCode} 检查状态为 {DealStudyStatus(_study.Status)} ",
//        //                Detail = string.Empty,
//        //                OptUserId = Guid.Parse(_userIdStr),
//        //                OptUser = _userRealName,
//        //                OptTime = DateTime.Now
//        //            });

//        //            _auditRepository.SaveChanges();
//        //        }

//        //        return;
//        //    }

//        //    //接口返回结果
//        //    dynamic actionResult = executedcontext.Result;
//        //    var result = (IResponseOutput<string>)actionResult.Value;//此处审计只涉及到添加更新和删除， 统一了相关接口的返回结果，才能在此强制转换



//        //    switch (_attr._auditType)
//        //    {
//        //        //项目审计
//        //        case AuditType.TrialAudit:

//        //            switch (_attr._auditOptType)
//        //            {
//        //                //项目的添加和更新接口
//        //                case AuditOptType.AddOrUpdateTrial:

//        //                    //接口参数
//        //                    var trialInfo = (TrialCommand)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            //判断是添加还是更新
//        //                            TrialId = trialInfo.Id == null ? Guid.Parse(result.Data) : trialInfo.Id.Value,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = trialInfo.Id == null ? $"{ _userRealName} 添加了项目 {trialInfo.Code} " : $"{ _userRealName} 更新了项目 {trialInfo.Code} 基本信息 ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                //添加项目运维人员
//        //                case AuditOptType.AddTrialStaff:

//        //                    //接口参数
//        //                    var trialUsers = (List<TrialUserAddCommand>)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {

//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = trialUsers[0].TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 添加了项目运维人员 {string.Join(',', trialUsers.Select(t => t.UserRealName).ToList())}  ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;

//        //                //添加研究中心
//        //                case AuditOptType.AddTrialSite:
//        //                    //接口参数
//        //                    var trialSites = (List<TrialSiteCommand>)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        //查询site信息
//        //                        var siteIds = trialSites.Select(t => t.SiteId).ToList();
//        //                        var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//        //                        var siteNames = _siteRepository.Where(t => siteIds.Contains(t.Id)).Select(u => u.SiteName);

//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            //判断是添加还是更新
//        //                            TrialId = trialSites[0].TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 添加了项目研究中心 {string.Join(',', siteNames)}  ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;

//        //                //研究中心添加运维人员
//        //                case AuditOptType.AddTrialSiteCRC:
//        //                    //接口参数
//        //                    var trialSiteCRCs = (List<AssginSiteCRCCommand>)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        //查询site信息
//        //                        var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//        //                        var siteName = _siteRepository.GetAll().First(t => t.Id == trialSiteCRCs[0].SiteId).SiteName;

//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = trialSiteCRCs[0].TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 为{ siteName } 添加了运维人员 {string.Join(',', trialSiteCRCs.Select(t => t.UserRealName).ToList())}",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;

//        //                //删除项目运维人员
//        //                case AuditOptType.DeleteTrailStaff:

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _userTrial.TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 移除了项目参与人员 {_userTrial.UserRealName} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                //删除项目site
//        //                case AuditOptType.DeleteTrialSite:

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        //查询site信息
//        //                        var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//        //                        var siteName = _siteRepository.GetAll().First(t => t.Id == _trialSite.SiteId).SiteName;

//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _trialSite.TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 移除了研究中心 {siteName} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                //删除项目Site CRC
//        //                case AuditOptType.DeleteTrialSiteCRC:

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        //查询site信息
//        //                        var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//        //                        var siteName = _siteRepository.GetAll().First(t => t.Id == _userTrial.SiteId).SiteName;

//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _userTrial.TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 移除了 {siteName} 的运维人员 {_userTrial.UserRealName} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }
//        //                    break;

//        //                //添加访视计划Item
//        //                case AuditOptType.AddOrUpdateTrialVisitPlanItem:
//        //                    //接口参数
//        //                    var visitPlanItem = (VisitPlanCommand)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = visitPlanItem.TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = visitPlanItem.Id == null ? $"{ _userRealName} 添加了访视计划项 {visitPlanItem.VisitName} " : $"{ _userRealName} 更新了访视计划项为 {visitPlanItem.VisitName} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                //删除访视计划Item
//        //                case AuditOptType.DeleteTrialVisitPlanItem:

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _visitPlan.TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 移除了访视计划项 {_visitPlan.VisitName} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }
//        //                    break;

//        //                //确认了访视计划
//        //                case AuditOptType.ConfirmTrialVisitPlan:
//        //                    var trialId = (Guid)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = trialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName} 确认了访视计划，不允许修改 ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                //添加了QA模板
//        //                case AuditOptType.AddOrUpdateTrialTemplate:
//        //                    //接口参数
//        //                    var trialQATemplate = (TrialQATemplateAddCommand)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {

//        //                            TrialId = trialQATemplate.TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = trialQATemplate.Id == null ? $"{ _userRealName} 添加了QA模板 {trialQATemplate.Name} " : $"{ _userRealName} 更新了QA模板 {trialQATemplate.Name} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }


//        //                    break;
//        //                //删除项目模板
//        //                case AuditOptType.DeleteTrialTemplate:

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {

//        //                            TrialId = _qATrailTemplate.TrialId,
//        //                            SubjectId = Guid.Empty,
//        //                            AuditType = (int)AuditType.TrialAudit,
//        //                            Note = $"{ _userRealName}  移除了QA模板 {_qATrailTemplate.Name} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }
//        //                    break;

//        //            }

//        //            break;
//        //        //受试者审计
//        //        case AuditType.SubjectAudit:


//        //            switch (_attr._auditOptType)
//        //            {
//        //                // 添加或者更新受试者
//        //                case AuditOptType.AddOrUpdateSubject:

//        //                    //接口参数
//        //                    var subject = (SubjectCommand)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = subject.TrialId,
//        //                            SubjectId = subject.Id == null ? Guid.Parse(result.Data) : subject.Id.Value,
//        //                            AuditType = (int)AuditType.SubjectAudit,
//        //                            Note = subject.Id == null ? $"{ _userRealName} 添加了受试者 {subject.LastName + subject.FirstName} 并初始化了访视计划" : $"{ _userRealName} 对受试者 { subject.LastName + subject.FirstName} 信息进行了更新  ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                // 删除受试者
//        //                case AuditOptType.DeleteSubject:
//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _subject.TrialId,
//        //                            SubjectId = _subject.Id,
//        //                            AuditType = (int)AuditType.SubjectAudit,
//        //                            Note = $"{ _userRealName} 移除了受试者 {_subject.LastName + _subject.FirstName} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                // 受试者计划外访视
//        //                case AuditOptType.AddOrUpdateSubjectOutPlanVisit:

//        //                    //接口参数
//        //                    var subjectVisit = (SubjectVisitCommand)_actionArguments.Values.ToList()[0];

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        var _subjectRepository =
//        //                               (IRepository<Subject>)executedcontext.HttpContext.RequestServices.GetService(
//        //                                   typeof(IRepository<Subject>));

//        //                        _subject = _subjectRepository.FirstOrDefault(t => t.Id == subjectVisit.SubjectId);

//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _subject.TrialId,
//        //                            SubjectId = _subject.Id,
//        //                            AuditType = (int)AuditType.SubjectAudit,
//        //                            Note = subjectVisit.Id == null ? $"{ _userRealName}  为受试者  {_subject.LastName + _subject.FirstName} 添加了计划外访视 {subjectVisit.VisitName}" : $"{ _userRealName} 更新受试者  {_subject.LastName + _subject.FirstName} 计划外访视{subjectVisit.VisitName}",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                // 删除计划外访视
//        //                case AuditOptType.DeleteSubjectOutPlanVisit:

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _subjectVisit.TrialId,
//        //                            SubjectId = _subject.Id,
//        //                            AuditType = (int)AuditType.SubjectAudit,
//        //                            Note = $"{ _userRealName} 移除了受试者{_subject.LastName + _subject.FirstName} 计划外访视 {_subjectVisit.VisitName} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;
//        //                // 人工设置已执行
//        //                case AuditOptType.SetSVExecuted:

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _subjectVisit.TrialId,
//        //                            SubjectId = _subject.Id,
//        //                            AuditType = (int)AuditType.SubjectAudit,
//        //                            Note = $"{ _userRealName} 将受试者 {_subject.LastName + _subject.FirstName} 访视 {_subjectVisit.VisitName} 设置为已执行 ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }


//        //                    break;
//        //            }

//        //            break;

//        //        //检查审计
//        //        case AuditType.StudyAudit:
//        //            _studyRepository =
//        //               (IRepository<DicomStudy>)executedcontext.HttpContext.RequestServices.GetService(
//        //                   typeof(IRepository<DicomStudy>));

//        //            switch (_attr._auditOptType)
//        //            {

//        //                case AuditOptType.ChangeStudyStatus:

//        //                    //接口参数
//        //                    var studyStatusInfo = (StudyStatusDetailCommand)_actionArguments.Values.ToList()[0];

//        //                    _study = _studyRepository.FirstOrDefault(t => t.Id == studyStatusInfo.StudyId);

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _study.TrialId,
//        //                            SubjectId = _study.SubjectId,
//        //                            StudyId = _study.Id,
//        //                            AuditType = (int)AuditType.StudyAudit,
//        //                            Note = $"{ _userRealName} 动作变更了 { _study.StudyCode} 检查状态为 {DealStudyStatus(_study.Status)} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }

//        //                    break;

//        //                case AuditOptType.Anonymized:

//        //                case AuditOptType.Forwarded:

//        //                    //接口参数
//        //                    var studyId = (Guid)_actionArguments.Values.ToList()[0];

//        //                    _study = _studyRepository.FirstOrDefault(t => t.Id == studyId);

//        //                    if (result.IsSuccess)
//        //                    {
//        //                        _auditRepository.Add(new TrialAudit()
//        //                        {
//        //                            TrialId = _study.TrialId,
//        //                            SubjectId = _study.SubjectId,
//        //                            StudyId = _study.Id,
//        //                            AuditType = (int)AuditType.StudyAudit,
//        //                            Note = $"{ _userRealName}  动作变更了 { _study.StudyCode} 检查状态为 {DealStudyStatus(_study.Status)} ",
//        //                            Detail = string.Empty,
//        //                            OptUserId = Guid.Parse(_userIdStr),
//        //                            OptUser = _userRealName,
//        //                            OptTime = DateTime.Now
//        //                        });
//        //                    }


//        //                    break;
//        //            }

//        //            break;

//        //    }

//        //    _auditRepository.SaveChanges();

//        //}


//        //public void OnActionExecuting(ActionExecutingContext context)
//        //{
//        //    //_dbContext = (IRaCISDBContext)context.HttpContext.RequestServices.GetService(typeof(IRaCISDBContext));


//        //    _actionArguments = context.ActionArguments;

//        //    _attr = (TrialAuditAttribute)context.ActionDescriptor.EndpointMetadata.First(m => m.GetType() == typeof(TrialAuditAttribute));

//        //    _userIdStr = context.HttpContext.User.Claims.First(t => t.Type == "id")?.Value ?? Guid.Empty.ToString();
//        //    _userRealName = context.HttpContext.User.Claims.First(t => t.Type == "realName")?.Value ?? string.Empty;

//        //    //获取接口仓储
//        //    _auditRepository = (IRepository<TrialAudit>)context.HttpContext.RequestServices.GetService(typeof(IRepository<TrialAudit>));



//        //    switch (_attr._auditType)
//        //    {
//        //        //项目审计
//        //        case AuditType.TrialAudit:

//        //            switch (_attr._auditOptType)
//        //            {
//        //                //删除项目运维人员
//        //                case AuditOptType.DeleteTrailStaff:

//        //                // 删除项目Site CRC
//        //                case AuditOptType.DeleteTrialSiteCRC:

//        //                    //接口参数
//        //                    var userTrialId = (Guid)_actionArguments.Values.ToList()[0];

//        //                    var _userTrialRepository =
//        //                        (IRepository<UserTrial>)context.HttpContext.RequestServices.GetService(
//        //                            typeof(IRepository<UserTrial>));

//        //                    _userTrial = _userTrialRepository.GetAll().First(t => t.Id == userTrialId);
//        //                    break;


//        //                //删除项目site
//        //                case AuditOptType.DeleteTrialSite:

//        //                    //接口参数
//        //                    var trialSiteId = (Guid)_actionArguments.Values.ToList()[0];

//        //                    var _TrialsiteRepository =
//        //                        (IRepository<TrialSite>)context.HttpContext.RequestServices.GetService(
//        //                            typeof(IRepository<TrialSite>));

//        //                    _trialSite = _TrialsiteRepository.GetAll().First(t => t.Id == trialSiteId);
//        //                    break;

//        //                case AuditOptType.DeleteTrialVisitPlanItem:

//        //                    //接口参数
//        //                    var visitPlanId = (Guid)_actionArguments.Values.ToList()[0];

//        //                    var _visitPlanRepository =
//        //                            (IRepository<VisitStage>)context.HttpContext.RequestServices.GetService(
//        //                                typeof(IRepository<VisitStage>));

//        //                    _visitPlan = _visitPlanRepository.GetAll().First(t => t.Id == visitPlanId);

//        //                    break;
//        //                case AuditOptType.DeleteTrialTemplate:

//        //                    //接口参数
//        //                    var qATrailTemplateId = (Guid)_actionArguments.Values.ToList()[0];
//        //                    var _qATrailTemplateRepository =
//        //                            (IRepository<QATrialTemplate>)context.HttpContext.RequestServices.GetService(
//        //                                typeof(IRepository<QATrialTemplate>));

//        //                    _qATrailTemplate = _qATrailTemplateRepository.GetAll()
//        //                        .FirstOrDefault(t => t.Id == qATrailTemplateId);

//        //                    break;

//        //            }

//        //            break;

//        //        //受试者审计
//        //        case AuditType.SubjectAudit:

//        //            switch (_auditOptType)
//        //            {
//        //                case AuditOptType.DeleteSubject:
//        //                    //接口参数
//        //                    var subjectId = (Guid)_actionArguments.Values.ToList()[0];

//        //                    var _subjectRepository =
//        //                        (IRepository<Subject>)context.HttpContext.RequestServices.GetService(
//        //                            typeof(IRepository<Subject>));

//        //                    _subject = _subjectRepository.FirstOrDefault(t => t.Id == subjectId);

//        //                    break;

//        //                case AuditOptType.DeleteSubjectOutPlanVisit:
//        //                case AuditOptType.SetSVExecuted:

//        //                    //接口参数
//        //                    var subjectVisitId = (Guid)_actionArguments.Values.ToList()[0];

//        //                    var _subjectVisitRepository =
//        //                        (IRepository<SubjectVisit>)context.HttpContext.RequestServices.GetService(
//        //                            typeof(IRepository<SubjectVisit>));

//        //                    _subjectVisit = _subjectVisitRepository.FirstOrDefault(t => t.Id == subjectVisitId);

//        //                    _subjectRepository =
//        //                       (IRepository<Subject>)context.HttpContext.RequestServices.GetService(
//        //                           typeof(IRepository<Subject>));

//        //                    _subject = _subjectRepository.FirstOrDefault(t => t.Id == _subjectVisit.SubjectId);

//        //                    break;
//        //            }
//        //            break;


//        //        //检查审计
//        //        case AuditType.StudyAudit:

//        //            switch (_attr._auditOptType)
//        //            {
//        //                case AuditOptType.UploadImage:

//        //                    break;
//        //            }
//        //            break;

//        //    }

//        //}
//        #endregion

//        public static string DealStudyStatus(int status)
//        {

//            var message = string.Empty;
//            switch (status)
//            {
//                case (int)StudyStatus.Uploaded:
//                    message = "Uploaded";
//                    break;

//                case (int)StudyStatus.QARequested:

//                    message = "QA Requested";
//                    break;
//                case (int)StudyStatus.QAing:

//                    message = "In QA";
//                    break;

//                //case (int)StudyStatus.Abandon:
//                //    message = "Study has abandon";
//                //    break;

//                case (int)StudyStatus.QAFinish:
//                    message = "QA Completed Passed";
//                    break;

//                case (int)StudyStatus.QAFInishNotPass:
//                    message = "QA Completed Failed";
//                    break;

//                case (int)StudyStatus.Anonymizing:
//                    message = "Anonymizing";
//                    break;

//                case (int)StudyStatus.Anonymized:
//                    message = "Anonymized";
//                    break;

//                case (int)StudyStatus.AnonymizeFailed:
//                    message = "Anonymize Failed";
//                    break;

//                case (int)StudyStatus.Forwarding:
//                    message = "Forwarding";
//                    break;

//                case (int)StudyStatus.Forwarded:
//                    message = "Forwarded  ";
//                    break;

//                case (int)StudyStatus.ForwardFailed:
//                    message = "Forward Failed ";
//                    break;
//            }

//            return message;
//        }

//        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
//        {
//            // 开启AOP事务(审计消息记录和 添加更新记录 在一个事务里面，不再是分开的事务)
//            //var _dbContext = (IRaCISDBContext)context.HttpContext.RequestServices.GetService(typeof(IRaCISDBContext));

//            //var strategy = _dbContext.Database.CreateExecutionStrategy();

//            var _dbContext = (IRaCISDBContext)context.HttpContext.RequestServices.GetService(typeof(IRaCISDBContext));

//            var strategy = _dbContext.Database.CreateExecutionStrategy();

//            await strategy.Execute(async () =>
//            {
//                var currentTransaction = _dbContext.Database.CurrentTransaction;

//                var transaction = currentTransaction ?? _dbContext.Database.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted);

//                    #region 执行方法前

//                    _actionArguments = context.ActionArguments;

//                _attr = (TrialAuditAttribute)context.ActionDescriptor.EndpointMetadata.First(m => m.GetType() == typeof(TrialAuditAttribute));

//                _userIdStr = context.HttpContext.User.Claims.First(t => t.Type == "id")?.Value ?? Guid.Empty.ToString();
//                _userRealName = context.HttpContext.User.Claims.First(t => t.Type == "realName")?.Value ?? string.Empty;

//                    //获取接口仓储
//                    _auditRepository = (IRepository<TrialAudit>)context.HttpContext.RequestServices.GetService(typeof(IRepository<TrialAudit>));

//                switch (_attr._auditType)
//                {
//                        //项目审计
//                        case AuditType.TrialAudit:

//                        switch (_attr._auditOptType)
//                        {
//                                //删除项目运维人员
//                                case AuditOptType.DeleteTrailStaff:

//                                    //接口参数
//                                    var userTrial = (Guid)_actionArguments.Values.ToList()[0];

//                                var _userTrialRepository =
//                                    (IRepository<TrialUser>)context.HttpContext.RequestServices.GetService(
//                                        typeof(IRepository<TrialUser>));

//                                _userTrial = _userTrialRepository.AsQueryable().Include(t => t.User).FirstOrDefault(t => t.Id == userTrial);
//                                break;

//                                // 删除项目Site CRC
//                                case AuditOptType.DeleteTrialSiteCRC:

//                                    //接口参数
//                                    var userTrialSiteId = (Guid)_actionArguments.Values.ToList()[0];

//                                var _userTrialSiteRepository =
//                                    (IRepository<TrialSiteUser>)context.HttpContext.RequestServices.GetService(
//                                        typeof(IRepository<TrialSiteUser>));

//                                _userTrialSite = _userTrialSiteRepository.AsQueryable().Include(t => t.User).FirstOrDefault(t => t.Id == userTrialSiteId);
//                                break;


//                                //删除项目site
//                                case AuditOptType.DeleteTrialSite:

//                                    //接口参数
//                                    var trialSiteId = (Guid)_actionArguments.Values.ToList()[0];

//                                var _TrialsiteRepository =
//                                    (IRepository<TrialSite>)context.HttpContext.RequestServices.GetService(
//                                        typeof(IRepository<TrialSite>));

//                                _trialSite = _TrialsiteRepository.AsQueryable().Include(t => t.Site).FirstOrDefault(t => t.Id == trialSiteId);
//                                break;

//                            case AuditOptType.DeleteTrialVisitPlanItem:

//                                    //接口参数
//                                    var visitPlanId = (Guid)_actionArguments.Values.ToList()[0];

//                                var _visitPlanRepository =
//                                        (IRepository<VisitStage>)context.HttpContext.RequestServices.GetService(
//                                            typeof(IRepository<VisitStage>));

//                                _visitPlan = _visitPlanRepository.FirstOrDefault(t => t.Id == visitPlanId).IfNullThrowException();

//                                break;
//                            case AuditOptType.DeleteTrialTemplate:



//                                break;

//                        }

//                        break;

//                        //受试者审计
//                        case AuditType.SubjectAudit:

//                        switch (_auditOptType)
//                        {
//                            case AuditOptType.DeleteSubject:
//                                    //接口参数
//                                    var subjectId = (Guid)_actionArguments.Values.ToList()[0];

//                                var _subjectRepository =
//                                    (IRepository<Subject>)context.HttpContext.RequestServices.GetService(
//                                        typeof(IRepository<Subject>));

//                                _subject = _subjectRepository.FirstOrDefault(t => t.Id == subjectId).IfNullThrowException();

//                                break;

//                            case AuditOptType.DeleteSubjectOutPlanVisit:
//                            case AuditOptType.SetSVExecuted:

//                                    //接口参数
//                                    var subjectVisitId = (Guid)_actionArguments.Values.ToList()[0];

//                                var _subjectVisitRepository =
//                                    (IRepository<SubjectVisit>)context.HttpContext.RequestServices.GetService(
//                                        typeof(IRepository<SubjectVisit>));

//                                _subjectVisit = _subjectVisitRepository.FirstOrDefault(t => t.Id == subjectVisitId).IfNullThrowException();

//                                _subjectRepository =
//                                   (IRepository<Subject>)context.HttpContext.RequestServices.GetService(
//                                       typeof(IRepository<Subject>));

//                                _subject = _subjectRepository.FirstOrDefault(t => t.Id == _subjectVisit.SubjectId).IfNullThrowException();

//                                break;
//                        }
//                        break;


//                        //检查审计
//                        case AuditType.StudyAudit:

//                        switch (_attr._auditOptType)
//                        {
//                            case AuditOptType.UploadImage:

//                                break;
//                        }
//                        break;

//                }

//                    #endregion

//                    //获取实际执行方法next() 的结果
//                    ActionExecutedContext executedcontext = await next();

//                    #region 方法执行后

//                    //上传影像接口返回值类型特殊 需要单独处理
//                    if (_attr._auditOptType == AuditOptType.UploadImage)
//                {

//                        //接口参数
//                        var archiveStudyInfo = (ArchiveStudyCommand)_actionArguments.Values.ToList()[0];

//                    if (executedcontext.Exception != null)
//                    {
//                        var logger = (ILogger<TrialAuditAttribute>)executedcontext.HttpContext.RequestServices.GetService(
//                                       typeof(ILogger<TrialAuditAttribute>));

//                        logger!.LogError("影像上传 中间发生异常", executedcontext.Exception.StackTrace);

//                        return;
//                    }

//                        //接口返回结果  因为上传成功和不成功 泛型类型不一样
//                        dynamic archive = executedcontext.Result;


//                    var archiveResult = (IResponseOutput)archive.Value;

//                    if (archiveResult.IsSuccess)
//                    {


//                        _studyRepository = (IRepository<DicomStudy>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<DicomStudy>));

//                        _auditRepository = (IRepository<TrialAudit>)context.HttpContext.RequestServices.GetService(typeof(IRepository<TrialAudit>));

//                        var successResult = (IResponseOutput<DicomArchiveResult>)archiveResult;

//                        var studyList = _studyRepository.Where(t => t.SubjectVisitId == successResult.Data.ArchivedDicomStudies.ToList()[0].SubjectVisitId).ToList();

//                        studyList.ForEach(study =>
//                        {
//                            var mes = study.Status == (int)StudyStatus.Uploaded ? "上传了" : "重传了";
//                            _auditRepository.Add(new TrialAudit()
//                            {
//                                TrialId = study.TrialId,
//                                SubjectId = study.SubjectId,
//                                StudyId = study.Id,
//                                AuditType = (int)AuditType.StudyAudit,
//                                    //Note = $"{ _userRealName} 动作变更了 { _study.StudyCode} 检查状态为 {DealStudyStatus(_study.Status)} ",
//                                    Note = $"{ _userRealName} {mes} { study.StudyCode}  ",
//                                Detail = string.Empty,
//                                OptUserId = Guid.Parse(_userIdStr),
//                                OptUser = _userRealName,
//                                OptTime = DateTime.Now
//                            });
//                        });



//                        _auditRepository.SaveChanges();

//                        transaction.Commit();

//                        return;

//                    }


//                }

//                    //接口返回结果
//                    if (executedcontext.Result is null)
//                {
//                    throw new BusinessValidationFailedException(executedcontext.Exception.Message);
//                }
//                dynamic actionResult = executedcontext.Result;

//                    //此处审计只涉及到添加更新和删除， 统一了相关接口的返回结果，才能在此强制转换
//                    //var result = (IResponseOutput<string>)actionResult.Value;

//                    var result = (IResponseOutput<string>)actionResult.Value;


//                switch (_attr._auditType)
//                {
//                        //项目审计
//                        case AuditType.TrialAudit:

//                        switch (_attr._auditOptType)
//                        {
//                                //项目的添加和更新接口
//                                case AuditOptType.AddOrUpdateTrial:

//                                    //接口参数
//                                    var trialInfo = (TrialCommand)_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                            //判断是添加还是更新
//                                            TrialId = trialInfo.Id == null ? Guid.Parse(result.Data) : trialInfo.Id.Value,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = trialInfo.Id == null ? $"{ _userRealName} 添加了项目 {trialInfo.TrialCode} " : $"{ _userRealName} 更新了项目 {trialInfo.TrialCode} 基本信息 ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                //添加项目运维人员
//                                case AuditOptType.AddTrialStaff:

//                                    //接口参数
//                                    var trialUsers = (TrialUserAddCommand[])_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {

//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = trialUsers[0].TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        //Note = $"{ _userRealName} 添加了项目运维人员 {string.Join(',', trialUsers.Select(t => t.UserRealName).ToList())}  ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;

//                                //添加研究中心
//                                case AuditOptType.AddTrialSite:
//                                    //接口参数
//                                    var trialSites = (List<TrialSiteCommand>)_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {
//                                        //查询site信息
//                                        var siteIds = trialSites.Select(t => t.SiteId).ToList();
//                                    var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//                                    var siteNames = _siteRepository.Where(t => siteIds.Contains(t.Id)).Select(u => u.SiteName);

//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                            //判断是添加还是更新
//                                            TrialId = trialSites[0].TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = $"{ _userRealName} 添加了项目研究中心 {string.Join(',', siteNames)}  ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;

//                                //研究中心添加运维人员
//                                case AuditOptType.AddTrialSiteCRC:
//                                    //接口参数
//                                    var trialSiteCRCs = (List<AssginSiteCRCCommand>)_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {
//                                        //查询site信息
//                                        var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//                                    var siteName = _siteRepository.FirstOrDefault(t => t.Id == trialSiteCRCs[0].SiteId).IfNullThrowException().SiteName;

//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = trialSiteCRCs[0].TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = $"{ _userRealName} 为{ siteName } 添加了运维人员 {string.Join(',', trialSiteCRCs.Select(t => t.UserRealName).ToList())}",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;

//                                //删除项目运维人员
//                                case AuditOptType.DeleteTrailStaff:

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _userTrial.TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = $"{ _userRealName} 移除了项目参与人员 {_userTrial.User.LastName + " / " + _userTrial.User.FirstName} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                //删除项目site
//                                case AuditOptType.DeleteTrialSite:

//                                if (result.IsSuccess)
//                                {
//                                        //查询site信息
//                                        var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//                                    var siteName = _siteRepository.FirstOrDefault(t => t.Id == _trialSite.SiteId).IfNullThrowException().SiteName;

//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _trialSite.TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = $"{ _userRealName} 移除了研究中心 {siteName} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                //删除项目Site CRC
//                                case AuditOptType.DeleteTrialSiteCRC:

//                                if (result.IsSuccess)
//                                {
//                                        //查询site信息
//                                        var _siteRepository = (IRepository<Site>)executedcontext.HttpContext.RequestServices.GetService(typeof(IRepository<Site>));
//                                    var siteName = _siteRepository.FirstOrDefault(t => t.Id == _userTrialSite.SiteId).IfNullThrowException().SiteName;

//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _userTrialSite.TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = $"{ _userRealName} 移除了 {siteName} 的运维人员 {_userTrialSite.User.UserName} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }
//                                break;

//                                //添加访视计划Item
//                                case AuditOptType.AddOrUpdateTrialVisitPlanItem:
//                                    //接口参数
//                                    var visitPlanItem = (VisitPlanCommand)_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = visitPlanItem.TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = visitPlanItem.Id == null ? $"{ _userRealName} 添加了访视计划项 {visitPlanItem.VisitName} " : $"{ _userRealName} 更新了访视计划项为 {visitPlanItem.VisitName} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                //删除访视计划Item
//                                case AuditOptType.DeleteTrialVisitPlanItem:

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _visitPlan.TrialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = $"{ _userRealName} 移除了访视计划项 {_visitPlan.VisitName} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }
//                                break;

//                                //确认了访视计划
//                                case AuditOptType.ConfirmTrialVisitPlan:
//                                var trialId = (Guid)_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = trialId,
//                                        SubjectId = Guid.Empty,
//                                        AuditType = (int)AuditType.TrialAudit,
//                                        Note = $"{ _userRealName} 确认了访视计划，不允许修改 ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                //添加了QA模板
//                                case AuditOptType.AddOrUpdateTrialTemplate:
//                                    //接口参数

//                                    if (result.IsSuccess)
//                                {

//                                }


//                                break;
//                                //删除项目模板
//                                case AuditOptType.DeleteTrialTemplate:

//                                if (result.IsSuccess)
//                                {

//                                }
//                                break;

//                        }

//                        break;
//                        //受试者审计
//                        case AuditType.SubjectAudit:


//                        switch (_attr._auditOptType)
//                        {
//                                // 添加或者更新受试者
//                                case AuditOptType.AddOrUpdateSubject:

//                                    //接口参数
//                                    var subject = (SubjectCommand)_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = subject.TrialId,
//                                        SubjectId = subject.Id == null ? Guid.Parse(result.Data) : subject.Id.Value,
//                                        AuditType = (int)AuditType.SubjectAudit,
//                                        Note = subject.Id == null ? $"{ _userRealName} 添加了受试者 {subject.ShortName } 并初始化了访视计划" : $"{ _userRealName} 对受试者 { subject.ShortName } 信息进行了更新  ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                // 删除受试者
//                                case AuditOptType.DeleteSubject:
//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _subject.TrialId,
//                                        SubjectId = _subject.Id,
//                                        AuditType = (int)AuditType.SubjectAudit,
//                                        Note = $"{ _userRealName} 移除了受试者 {_subject.LastName + _subject.FirstName} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                // 受试者计划外访视
//                                case AuditOptType.AddOrUpdateSubjectOutPlanVisit:

//                                    //接口参数
//                                    var subjectVisit = (SubjectVisitCommand)_actionArguments.Values.ToList()[0];

//                                if (result.IsSuccess)
//                                {
//                                    var _subjectRepository =
//                                           (IRepository<Subject>)executedcontext.HttpContext.RequestServices.GetService(
//                                               typeof(IRepository<Subject>));

//                                    _subject = _subjectRepository.FirstOrDefault(t => t.Id == subjectVisit.SubjectId).IfNullThrowException();

//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _subject.TrialId,
//                                        SubjectId = _subject.Id,
//                                        AuditType = (int)AuditType.SubjectAudit,
//                                        Note = subjectVisit.Id == null ? $"{ _userRealName}  为受试者  {_subject.LastName + _subject.FirstName} 添加了计划外访视 {subjectVisit.VisitName}" : $"{ _userRealName} 更新受试者  {_subject.LastName + _subject.FirstName} 计划外访视{subjectVisit.VisitName}",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                // 删除计划外访视
//                                case AuditOptType.DeleteSubjectOutPlanVisit:

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _subjectVisit.TrialId,
//                                        SubjectId = _subject.Id,
//                                        AuditType = (int)AuditType.SubjectAudit,
//                                        Note = $"{ _userRealName} 移除了受试者{_subject.LastName + _subject.FirstName} 计划外访视 {_subjectVisit.VisitName} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;
//                                // 人工设置已执行
//                                case AuditOptType.SetSVExecuted:

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _subjectVisit.TrialId,
//                                        SubjectId = _subject.Id,
//                                        AuditType = (int)AuditType.SubjectAudit,
//                                        Note = $"{ _userRealName} 将受试者 {_subject.LastName + _subject.FirstName} 访视 {_subjectVisit.VisitName} 设置为已执行 ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }


//                                break;
//                        }

//                        break;

//                        //检查审计
//                        case AuditType.StudyAudit:
//                        _studyRepository =
//                           (IRepository<DicomStudy>)executedcontext.HttpContext.RequestServices.GetService(
//                               typeof(IRepository<DicomStudy>));

//                        switch (_attr._auditOptType)
//                        {

//                            case AuditOptType.ChangeStudyStatus:

//                                    //接口参数
//                                    var studyStatusInfo = (StudyStatusDetailCommand)_actionArguments.Values.ToList()[0];

//                                _study = _studyRepository.FirstOrDefault(t => t.Id == studyStatusInfo.StudyId).IfNullThrowException();

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _study.TrialId,
//                                        SubjectId = _study.SubjectId,
//                                        StudyId = _study.Id,
//                                        AuditType = (int)AuditType.StudyAudit,
//                                        Note = $"{ _userRealName} 动作变更了 { _study.StudyCode} 检查状态为 {DealStudyStatus(_study.Status)} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }

//                                break;

//                            case AuditOptType.Anonymized:

//                            case AuditOptType.Forwarded:

//                                    //接口参数
//                                    var studyId = (Guid)_actionArguments.Values.ToList()[0];

//                                _study = _studyRepository.FirstOrDefault(t => t.Id == studyId).IfNullThrowException();

//                                if (result.IsSuccess)
//                                {
//                                    _auditRepository.Add(new TrialAudit()
//                                    {
//                                        TrialId = _study.TrialId,
//                                        SubjectId = _study.SubjectId,
//                                        StudyId = _study.Id,
//                                        AuditType = (int)AuditType.StudyAudit,
//                                        Note = $"{ _userRealName}  动作变更了 { _study.StudyCode} 检查状态为 {DealStudyStatus(_study.Status)} ",
//                                        Detail = string.Empty,
//                                        OptUserId = Guid.Parse(_userIdStr),
//                                        OptUser = _userRealName,
//                                        OptTime = DateTime.Now
//                                    });
//                                }


//                                break;
//                        }

//                        break;

//                }

//                _auditRepository.SaveChanges();

//                    #endregion


//                    //提交事务 Commit transaction if all commands succeed, transaction will auto-rollback when disposed if either commands fails
//                    transaction.Commit();
//            }
//            );









//        }
//    }
//}




