peis/src/Shentun.Peis.Application/RegisterChecks/RegisterCheckAppService.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Org.BouncyCastle.Asn1.Ocsp;
using Shentun.Peis.Asbitems;
using Shentun.Peis.Enums;
using Shentun.Peis.FollowUps;
using Shentun.Peis.MenuInfos;
using Shentun.Peis.Models;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.RegisterCheckItems;
using Shentun.Peis.RegisterCheckSummarys;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Entities.Events.Distributed;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Guids;
using Volo.Abp.Identity;
using Volo.Abp.ObjectMapping;
using Volo.Abp.Users;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace Shentun.Peis.RegisterChecks
{

    /// <summary>
    /// 登记检查单
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class RegisterCheckAppService : ApplicationService
    {
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<RegisterCheckAsbitem> _registerCheckAsbitemRepository;
        private readonly IRepository<ItemType> _itemTypeRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<ReferenceRange, Guid> _referenceRangeRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckSummary, Guid> _registerCheckSummaryRepository;
        private readonly IRepository<RegisterCheckSuggestion, Guid> _registerCheckSuggestionRepository;
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly RegisterCheckManager _registerCheckManager;
        private readonly RegisterCheckItemManager _registerCheckItemManager;
        private readonly CacheService _cacheService;
        private readonly IGuidGenerator _guidGenerator;
        private readonly IConfiguration _configuration;
        private readonly ICurrentUser _currentUser;
        private readonly IRepository<UserItemType> _userItemTypeRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly IRepository<LisRequest, Guid> _lisRequestRepository;
        private readonly FollowUpAppService _followUpAppService;

        public RegisterCheckAppService(IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
             IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<ReferenceRange, Guid> referenceRangeRepository,
             IRepository<RegisterCheckSummary, Guid> registerCheckSummaryRepository,
            IRepository<RegisterCheckSuggestion, Guid> registerCheckSuggestionRepository,
            IRepository<IdentityUser, Guid> userRepository,
            RegisterCheckManager registerCheckManager,
            RegisterCheckItemManager registerCheckItemManager,
            CacheService cacheService,
            IGuidGenerator guidGenerator,
            IConfiguration configuration,
            ICurrentUser currentUser,
            IRepository<UserItemType> userItemTypeRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<RegisterCheckAsbitem> registerCheckAsbitemRepository,
            IRepository<ItemType> itemTypeRepository,
            IRepository<LisRequest, Guid> lisRequestRepository,
            FollowUpAppService followUpAppService)
        {
            _registerCheckRepository = registerCheckRepository;
            _userRepository = userRepository;
            _registerCheckManager = registerCheckManager;
            _patientRegisterRepository = patientRegisterRepository;
            _referenceRangeRepository = referenceRangeRepository;
            _registerCheckItemRepository = registerCheckItemRepository;
            _registerCheckSummaryRepository = registerCheckSummaryRepository;
            _registerCheckSuggestionRepository = registerCheckSuggestionRepository;
            _registerCheckItemManager = registerCheckItemManager;
            _cacheService = cacheService;
            _guidGenerator = guidGenerator;
            _configuration = configuration;
            _currentUser = currentUser;
            _userItemTypeRepository = userItemTypeRepository;
            _asbitemRepository = asbitemRepository;
            _registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            _itemTypeRepository = itemTypeRepository;
            _lisRequestRepository = lisRequestRepository;
            _followUpAppService = followUpAppService;
        }

        /// <summary>
        /// 根据RegisterCheckId获取当前实体数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("api/app/registercheck/getregistercheck")]
        public async Task<RegisterCheckDto> GetRegisterCheckAsync(Guid id)
        {
            var registerCheckEntity = (await _registerCheckRepository.GetQueryableAsync())
                .Include(x => x.RegisterCheckAsbitems)
                .ThenInclude(x => x.Asbitem)
                .FirstOrDefault(f => f.Id == id);

            var registerCheckDto = new RegisterCheckDto
            {
                AuditorUserId = registerCheckEntity.AuditorUserId,
                AuditTime = registerCheckEntity.AuditTime,
                CheckDate = DataHelper.ConversionDateToString(registerCheckEntity.CheckDate),
                CheckDoctorId = registerCheckEntity.CheckDoctorId,
                CheckRequestNo = registerCheckEntity.CheckRequestNo,
                CheckRequestPrintTimes = registerCheckEntity.CheckRequestPrintTimes,
                CompleteFlag = registerCheckEntity.CompleteFlag,
                CreationTime = registerCheckEntity.CreationTime,
                CreatorId = registerCheckEntity.CreatorId,
                CriticalValue = registerCheckEntity.CriticalRangeValue,
                //CriticalValueCreateDate = DataHelper.ConversionDateToString(registerCheckEntity.CriticalValueCreateDate),
                CriticalValueFlag = registerCheckEntity.IsCriticalValue,
                CriticalValueProcessContent = registerCheckEntity.CriticalValueContent,
                //CriticalValueProcessDate = DataHelper.ConversionDateToString(registerCheckEntity.CriticalValueProcessDate),
                //CriticalValueProcessDoctor = registerCheckEntity.CriticalValueProcessDoctor,
                //CriticalValueProcessFlag = registerCheckEntity.CriticalValueProcessFlag,
                Id = registerCheckEntity.Id,
                IsAudit = registerCheckEntity.IsAudit,
                IsLock = registerCheckEntity.IsLock,
                LastModificationTime = registerCheckEntity.LastModificationTime,
                LastModifierId = registerCheckEntity.LastModifierId,
                ThirdInfo = registerCheckEntity.ThirdInfo,
                LastModifierName = _cacheService.GetSurnameAsync(registerCheckEntity.LastModifierId).Result,
                CreatorName = _cacheService.GetSurnameAsync(registerCheckEntity.CreatorId).Result,
                IsCharge = registerCheckEntity.RegisterCheckAsbitems.Where(m => m.PayTypeFlag == PayTypeFlag.PersonPay && m.IsCharge == 'N').Count() > 0 ? 'N' : 'Y',
                AsbitemName = string.Join(",", registerCheckEntity.RegisterCheckAsbitems.Select(rs => rs.Asbitem.DisplayName).ToList())
            };

            return registerCheckDto;
        }


        /// <summary>
        /// 获取登记check表数据（附带组合项目名称跟是否收费）  医生诊台左边列表  只有一个收费就显示收费
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/RegisterCheck/GetRegisterCheckAsbitemsByPatientRegisterId")]
        public async Task<List<RegisterCheckOrAsbitemNameOrIsChargeDto>> GetRegisterCheckAsbitemsByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            //var list = (from registerCheck in await _registerCheckRepository.GetQueryableAsync()
            //            join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
            //            on registerCheck.Id equals registerCheckAsbitem.AsbitemId
            //            join asbitem in await _asbitemRepository.GetQueryableAsync()
            //            on registerCheckAsbitem.AsbitemId equals asbitem.Id
            //            join itemType in await _itemTypeRepository.GetQueryableAsync()
            //            on asbitem.ItemTypeId equals itemType.Id
            //            where registerCheck.PatientRegisterId == input.PatientRegisterId
            //            orderby itemType.DisplayName, asbitem.DisplayOrder
            //            select new
            //            {
            //                registerCheck,
            //                registerCheckAsbitem,
            //                asbitem,
            //                itemType
            //            }).ToList();

            var entlist = (await _registerCheckRepository.GetQueryableAsync())
                 .Include(x => x.RegisterCheckAsbitems)
                 .ThenInclude(x => x.Asbitem).ThenInclude(x => x.ItemType)
                 .Where(m => m.PatientRegisterId == input.PatientRegisterId).ToList();


            //排序
            entlist = entlist.OrderBy(o => o.RegisterCheckAsbitems.Max(o => o.Asbitem.ItemType.DisplayOrder)).ToList()
                      .OrderBy(o => o.RegisterCheckAsbitems.Max(o => o.Asbitem.DisplayOrder)).ToList();


            var entdto = entlist.Where(m => m.RegisterCheckAsbitems.Where(mm => mm.Asbitem.IsCheck == 'Y').Count() > 0).Select(s => new RegisterCheckOrAsbitemNameOrIsChargeDto
            {
                CheckTypeFlag = s.RegisterCheckAsbitems.First().Asbitem.ItemType.CheckTypeFlag,
                AsbitemName = string.Join(",", s.RegisterCheckAsbitems.Select(rs => rs.Asbitem.DisplayName).ToList()),
                AuditorUserId = s.AuditorUserId,
                AuditTime = s.AuditTime,
                CheckDate = DataHelper.ConversionDateToString(s.CheckDate),
                CheckDoctorId = s.CheckDoctorId,
                CheckRequestNo = s.CheckRequestNo,
                CheckRequestPrintTimes = s.CheckRequestPrintTimes,
                CompleteFlag = s.CompleteFlag,
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                CriticalValue = s.CriticalRangeValue,
                //CriticalValueCreateDate = DataHelper.ConversionDateToString(s.CriticalValueCreateDate),
                CriticalValueFlag = s.IsCriticalValue,
                CriticalValueProcessContent = s.CriticalValueContent,
                // CriticalValueProcessDate = DataHelper.ConversionDateToString(s.CriticalValueProcessDate),
                // CriticalValueProcessDoctor = s.CriticalValueProcessDoctor,
                // CriticalValueProcessFlag = s.CriticalValueProcessFlag,
                Id = s.Id,
                IsAudit = s.IsAudit,
                IsCharge = s.RegisterCheckAsbitems.Where(m => m.IsCharge == 'Y').Count() > 0 ? 'Y' : 'N',
                IsLock = s.IsLock,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                //RegisterAsbitemId = s.RegisterAsbitemId,
                ThirdInfo = s.ThirdInfo,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result,
                ItemTypeDisplayOrder = s.RegisterCheckAsbitems.First().Asbitem.ItemType.DisplayOrder,
                AsbitemDisplayOrder = s.RegisterCheckAsbitems.First().Asbitem.DisplayOrder
            }).ToList();

            return entdto;
        }


        /// <summary>
        /// 获取登记check表数据（附带组合项目名称跟是否收费）  医生诊台左边列表  只有一个收费就显示收费  增加项目类别权限控制
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/RegisterCheck/GetRegisterCheckWithAsbitems")]
        public async Task<List<RegisterCheckWithAsbitemsDto>> GetRegisterCheckWithAsbitemsAsync(PatientRegisterIdInputDto input)
        {

            var entlist = (await _registerCheckRepository.GetQueryableAsync())
                .Include(x => x.RegisterCheckAsbitems)
                .ThenInclude(x => x.Asbitem).ThenInclude(x => x.ItemType)
                .Where(m => m.RegisterCheckAsbitems.Select(s => s.PatientRegisterId)
                .Contains(input.PatientRegisterId)
                && m.RegisterCheckAsbitems.Select(s => s.Asbitem.IsCheck).Contains('Y'));

            #region 增加项目类别权限

            string AdminId = _configuration.GetValue<string>("AdminId");
            if (_currentUser.Id.Value != Guid.Parse(AdminId))
            {
                var asbitemIds = (from userItemType in await _userItemTypeRepository.GetQueryableAsync()
                                  join asbitem in await _asbitemRepository.GetQueryableAsync() on userItemType.ItemTypeId equals asbitem.ItemTypeId
                                  where userItemType.UserId == _currentUser.Id.Value
                                  select asbitem.Id).ToList();

                if (asbitemIds.Any())
                {
                    entlist = entlist.Where(m => asbitemIds.Contains(m.RegisterCheckAsbitems.FirstOrDefault().AsbitemId));
                }
                else
                {
                    return new List<RegisterCheckWithAsbitemsDto>();
                }

            }

            #endregion


            //排序
            entlist = entlist.OrderBy(o => o.RegisterCheckAsbitems.Max(o => o.Asbitem.ItemType.DisplayOrder))
                      .ThenBy(o => o.RegisterCheckAsbitems.Max(o => o.Asbitem.DisplayOrder));


            var entdto = entlist.ToList().Select(s => new RegisterCheckWithAsbitemsDto
            {
                AsbitemName = string.Join(",", s.RegisterCheckAsbitems.Select(rs => rs.Asbitem.DisplayName).ToList()),
                AuditorUserId = s.AuditorUserId,
                AuditTime = s.AuditTime,
                CheckDate = DataHelper.ConversionDateToString(s.CheckDate),
                CheckDoctorId = s.CheckDoctorId,
                CheckRequestNo = s.CheckRequestNo,
                CompleteFlag = s.CompleteFlag,
                Id = s.Id,
                IsAudit = s.IsAudit,
                IsCharge = s.RegisterCheckAsbitems.Where(m => m.IsCharge == 'Y').Count() > 0 ? 'Y' : 'N',
                IsLock = s.IsLock,
                CheckTypeFlag = s.RegisterCheckAsbitems.First().Asbitem.ItemType.CheckTypeFlag,
                ItemTypeDisplayOrder = s.RegisterCheckAsbitems.First().Asbitem.ItemType.DisplayOrder,
                AsbitemDisplayOrder = s.RegisterCheckAsbitems.First().Asbitem.DisplayOrder,
            }).ToList();

            return entdto;
        }

        [HttpPost("api/app/registercheck/UpdateCheckResult")]
        public async Task UpdateCheckResult(UpdateCheckResultDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("input参数不能为空");
            }
            if (input.RegisterCheckItems == null)
            {
                throw new UserFriendlyException("RegisterCheckItems参数不能为空");
            }
            if (!input.RegisterCheckItems.Where(o => !string.IsNullOrWhiteSpace(o.Result)).ToList().Any())
            {
                throw new UserFriendlyException("明细结果不能全部为空");
            }
            if (input.Summarys == null || !input.Summarys.Any())
            {
                throw new UserFriendlyException("小结不能为空");
            }
            var registerCheck = await _registerCheckRepository.GetAsync(input.RegisterCheckId);
            var patientRegister = await _patientRegisterRepository.GetAsync(registerCheck.PatientRegisterId);
            //修改医生和检查日期
            if (string.IsNullOrWhiteSpace(input.CheckDoctorId))
            {
                input.CheckDoctorId = CurrentUser.Id.ToString();
            }
            _registerCheckManager.UpdateCheckDoctorAndDateAsync(patientRegister, registerCheck, input.CheckDoctorId, input.CheckDate, input.ExecOrganizationUnitId);
            if (!string.IsNullOrWhiteSpace(input.LisAuditorDoctorName))
                registerCheck.LisAuditorDoctorName = input.LisAuditorDoctorName;
            if (!string.IsNullOrWhiteSpace(input.LisSampleNo))
                registerCheck.LisSampleNo = input.LisSampleNo;
            //更新人员登记信息完成标志
            patientRegister.CompleteFlag = PatientRegisterCompleteFlag.PartCheck;
            await _patientRegisterRepository.UpdateAsync(patientRegister);
            await _registerCheckRepository.UpdateAsync(registerCheck);
            //修改项目结果
            var registerCheckItems = await _registerCheckItemRepository.GetListAsync(o => o.RegisterCheckId == input.RegisterCheckId);
            foreach (var registerCheckItem in registerCheckItems)
            {
                var inputCheckItem = input.RegisterCheckItems.Where(o => o.ItemId == registerCheckItem.ItemId).FirstOrDefault();
                if (inputCheckItem == null)
                {
                    continue;
                }
                var registerCheckItemUpdate = new RegisterCheckItem()
                {
                    Result = inputCheckItem.Result,
                    CheckDoctorName = inputCheckItem.CheckDoctorName,
                    CriticalValue = inputCheckItem.CriticalValue,
                    CheckDate = DateTime.Now
                };
                await _registerCheckItemManager.UpdateRegisterCheckItemAsync(registerCheckItemUpdate, registerCheckItem);
            }
            await _registerCheckItemRepository.UpdateManyAsync(registerCheckItems);
            //修改小结
            var deleteRegisterCheckSummarys = await _registerCheckSummaryRepository.GetListAsync(o => o.RegisterCheckId == input.RegisterCheckId);
            await _registerCheckSummaryRepository.DeleteManyAsync(deleteRegisterCheckSummarys);
            for (var i = 0; i < input.Summarys.Count; i++)
            {
                var registerCheckSummary = new RegisterCheckSummary(_guidGenerator.Create())
                {
                    DisplayOrder = i + 1,
                    RegisterCheckId = input.RegisterCheckId,
                    Summary = input.Summarys[i].Summary,
                    SummaryFlag = '0'
                };
                await _registerCheckSummaryRepository.InsertAsync(registerCheckSummary);
            }
            //修改建议
            var _registerCheckSuggestions = await _registerCheckSuggestionRepository.GetListAsync(o => o.RegisterCheckId == input.RegisterCheckId);
            await _registerCheckSuggestionRepository.DeleteManyAsync(_registerCheckSuggestions);
            for (var i = 0; i < input.Suggestions.Count; i++)
            {
                var registerCheckSuggestion = new RegisterCheckSuggestion(_guidGenerator.Create())
                {
                    DisplayOrder = i + 1,
                    RegisterCheckId = input.RegisterCheckId,
                    Suggestion = input.Suggestions[i].Suggestion,
                };
                await _registerCheckSuggestionRepository.InsertAsync(registerCheckSuggestion);
            }
        }
        ///// <summary>
        ///// 弃检跟恢复操作   0(为未检)， 1（已检）, 2（弃检）
        ///// </summary>
        ///// <param name="RegisterCheckId">检查单ID</param>
        ///// <param name="CompleteFlag">检查状态</param>
        ///// <returns></returns>
        //[HttpPost("api/app/registercheck/updatecomplete")]
        //public async Task<RegisterCheckDto> UpdateCompleteAsync(Guid RegisterCheckId, char CompleteFlag)
        //{
        //    var registerCheckEnt = await _registerCheckManager.UpdateCompleteAsync(RegisterCheckId, CompleteFlag);
        //    return ObjectMapper.Map<RegisterCheck, RegisterCheckDto>(registerCheckEnt);
        //}

        /// <summary>
        /// 批量弃检跟恢复操作   0(为未检)， 1（已检）, 2（弃检）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/registercheck/updatecompletemany")]
        public async Task<List<RegisterCheckDto>> UpdateCompleteManyAsync(List<UpdateCompleteManyDto> input)
        {
            List<RegisterCheckDto> msg = new List<RegisterCheckDto>();

            if (input.Any())
            {
                foreach (var item in input)
                {
                    var registerCheckEnt = await _registerCheckManager.UpdateCompleteAsync(item.RegisterCheckId, item.CompleteFlag);
                    var newentity = ObjectMapper.Map<RegisterCheck, RegisterCheckDto>(registerCheckEnt);
                    if (newentity != null)
                    {
                        msg.Add(newentity);
                    }
                }

            }
            return msg;
        }


        /// <summary>
        /// 更新审核状态   Y 已审核  N 未审核
        /// </summary>
        /// <param name="RegisterCheckId">检查单ID</param>
        /// <param name="IsAudit">审核状态( Y 已审核  N 未审核)</param>
        /// <returns></returns>
        [HttpPost("api/app/registercheck/updateisaudit")]
        public async Task<RegisterCheckDto> UpdateIsAuditAsync(Guid RegisterCheckId, char IsAudit)
        {
            var registerCheckEnt = await _registerCheckManager.UpdateIsAuditAsync(RegisterCheckId, IsAudit);
            return ObjectMapper.Map<RegisterCheck, RegisterCheckDto>(registerCheckEnt);
        }


        /// <summary>
        /// 更改检查医生（自动更新完成状态为已检）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/registercheck/updatecheckdoctor")]
        public async Task<RegisterCheckDto> UpdateCheckDoctorAsync(UpdateCheckDoctorDto input)
        {
            if (input == null || input.RegisterCheckId == Guid.Empty)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            var entity = await _registerCheckRepository.GetAsync(m => m.Id == input.RegisterCheckId);
            var entitydto = ObjectMapper.Map<UpdateCheckDoctorDto, RegisterCheck>(input);
            var newentity = await _registerCheckManager.UpdateCheckDoctorAsync(entitydto, entity);

            return ObjectMapper.Map<RegisterCheck, RegisterCheckDto>(newentity);
        }


        /// <summary>
        /// 更改危警值内容
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/registercheck/updatecriticalvalue")]
        public async Task<RegisterCheckDto> UpdateCriticalValueAsync(UpdateCriticalValueDto input)
        {
            if (input == null || input.RegisterCheckId == Guid.Empty)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            var entity = await _registerCheckRepository.GetAsync(m => m.Id == input.RegisterCheckId);
            var entitydto = ObjectMapper.Map<UpdateCriticalValueDto, RegisterCheck>(input);
            var newentity = await _registerCheckManager.UpdateCriticalValueAsync(entitydto, entity);

            return ObjectMapper.Map<RegisterCheck, RegisterCheckDto>(newentity);
        }


        /// <summary>
        /// 更改审核医生（自动更新审核状态为已审核）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/registercheck/updateauditordoctor")]
        public async Task<RegisterCheckDto> UpdateAuditorDoctorAsync(UpdateAuditorDoctorDto input)
        {
            if (input == null || input.RegisterCheckId == Guid.Empty)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            var entity = await _registerCheckRepository.GetAsync(m => m.Id == input.RegisterCheckId);
            var entitydto = ObjectMapper.Map<UpdateAuditorDoctorDto, RegisterCheck>(input);
            var newentity = await _registerCheckManager.UpdateAuditorDoctorAsync(entitydto, entity);

            return ObjectMapper.Map<RegisterCheck, RegisterCheckDto>(newentity);
        }





        /// <summary>
        /// 修改人员登记的组合项目锁定状态  批量
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/registercheck/updateregistercheckislockmany")]
        public async Task<List<RegisterCheckDto>> UpdateRegisterCheckIsLockManyAsync(List<UpdateRegisterCheckIsLockDto> input)
        {
            if (!input.Any())
                throw new UserFriendlyException("请求参数有误");


            List<RegisterCheck> entlist = new List<RegisterCheck>();

            foreach (var item in input)
            {
                var ent = await _registerCheckRepository.GetAsync(item.RegisterCheckId);
                ent.IsLock = item.IsLock;
                entlist.Add(ent);
            }

            await _registerCheckRepository.UpdateManyAsync(entlist);

            return ObjectMapper.Map<List<RegisterCheck>, List<RegisterCheckDto>>(entlist);

        }



        /// <summary>
        /// 根据人员ID集合获取所有项目
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/RegisterCheck/GetRegisterCheckAsbitemsByPatientRegisterIds")]
        public async Task<List<SimpleAsbitemDto>> GetRegisterCheckAsbitemsByPatientRegisterIdsAsync(PatientRegisterIdsInputDto input)
        {
            if (!input.PatientRegisterIds.Any())
                throw new UserFriendlyException("人员ID不能为空");
            var entListDto = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                              join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                              join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                              join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id
                              where input.PatientRegisterIds.Contains(patientRegister.Id) && asbitem.IsCheck == 'Y'
                              select new SimpleAsbitemDto
                              {
                                  AsbitemId = registerCheckAsbitem.AsbitemId,
                                  AsbitemName = asbitem.DisplayName
                              }).Distinct().ToList();

            return entListDto;
        }


        /// <summary>
        /// 根据人员条码号集合获取所有项目
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/RegisterCheck/GetRegisterCheckAsbitemsByPatientRegisterNos")]
        public async Task<List<SimpleAsbitemDto>> GetRegisterCheckAsbitemsByPatientRegisterNosAsync(PatientRegisterNosInputDto input)
        {
            if (!input.PatientRegisterNos.Any())
                throw new UserFriendlyException("人员条码号不能为空");
            var entListDto = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                              join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                              join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                              join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id
                              where input.PatientRegisterNos.Contains(patientRegister.PatientRegisterNo) && asbitem.IsCheck == 'Y'
                              select new SimpleAsbitemDto
                              {
                                  AsbitemId = registerCheckAsbitem.AsbitemId,
                                  AsbitemName = asbitem.DisplayName
                              }).Distinct().ToList();

            return entListDto;
        }


        /// <summary>
        /// 根据检验条码号集合获取所有项目
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/RegisterCheck/GetRegisterCheckAsbitemsByLisRequestNos")]
        public async Task<List<SimpleAsbitemDto>> GetRegisterCheckAsbitemsByLisRequestNosAsync(LisRequestNosInputDto input)
        {
            if (!input.LisRequestNos.Any())
                throw new UserFriendlyException("检验条码号不能为空");
            var entListDto = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                              join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                              join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                              join lisRequest in await _lisRequestRepository.GetQueryableAsync() on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                              join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id
                              where input.LisRequestNos.Contains(lisRequest.LisRequestNo) && asbitem.IsCheck == 'Y'
                              select new SimpleAsbitemDto
                              {
                                  AsbitemId = registerCheckAsbitem.AsbitemId,
                                  AsbitemName = asbitem.DisplayName
                              }).Distinct().ToList();

            return entListDto;
        }


        /// <summary>
        /// 批量修改医生 根据人员ID集合
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/RegisterCheck/UpdateBatchCheckDoctor")]
        public async Task UpdateBatchCheckDoctorAsync(UpdateBatchCheckDoctorInputDto input)
        {
            if (!input.PatientRegisterIds.Any())
                throw new UserFriendlyException("人员ID不能为空");

            if (!input.CheckDoctorDetail.Any())
                throw new UserFriendlyException("需要修改的信息不能为空");

            var registerCheckAsbitemList = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                                            join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                                            join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                                            where input.PatientRegisterIds.Contains(patientRegister.Id)
                                            select registerCheckAsbitem).ToList();

            if (registerCheckAsbitemList.Any())
            {
                foreach (var registerCheckAsbitem in registerCheckAsbitemList)
                {
                    var checkDoctorEnt = input.CheckDoctorDetail.FirstOrDefault(f => f.AsbitemId == registerCheckAsbitem.AsbitemId);
                    if (checkDoctorEnt != null)
                    {
                        var registerCheckEnt = await _registerCheckRepository.FirstOrDefaultAsync(f => f.Id == registerCheckAsbitem.RegisterCheckId);
                        if (registerCheckEnt != null)
                        {
                            registerCheckEnt.CheckDoctorId = checkDoctorEnt.CheckDoctorId;
                            await _registerCheckRepository.UpdateAsync(registerCheckEnt);
                        }
                    }
                }
            }
        }


        /// <summary>
        /// 修改检查表危急值相关内容
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/RegisterCheck/UpdateRegisterCheckCritical")]
        public async Task UpdateRegisterCheckCriticalAsync(UpdateRegisterCheckCriticalInputDto input)
        {
            var registerCheckEnt = await _registerCheckRepository.FirstOrDefaultAsync(f => f.Id == input.RegisterCheckId);
            if (registerCheckEnt == null)
            {
                throw new UserFriendlyException("参数不正确");
            }

            if (input.IsCriticalValue != null)
            {
                registerCheckEnt.IsCriticalValue = input.IsCriticalValue;
            }
            if (input.IsCriticalValueAudit != null)
            {
                registerCheckEnt.IsCriticalValueAudit = input.IsCriticalValueAudit;
            }
            if (input.IsReview != null)
            {
                registerCheckEnt.IsReview = input.IsReview;
            }
            if (!string.IsNullOrWhiteSpace(input.CriticalValueContent))
            {
                registerCheckEnt.CriticalValueContent = input.CriticalValueContent;
            }

            if (input.IsFollowUp != null && input.IsFollowUp == 'Y')
            {
                registerCheckEnt.FollowUpFlag = '1';
            }

            if (registerCheckEnt.CriticalValueCreatorId == null)
            {
                registerCheckEnt.CriticalValueCreatorId = _currentUser.Id;
                registerCheckEnt.CriticalValueCreationTime = DateTime.Now;
            }

            await _registerCheckRepository.UpdateAsync(registerCheckEnt);

            if ((input.IsFollowUp != null && input.IsFollowUp == 'Y')
               || (input.IsCriticalValue != null && input.IsCriticalValue == 'Y'))
            {

                //增加随访表记录
                await _followUpAppService.CreateAsync(new PatientRegisterIdInputDto
                {
                    PatientRegisterId = registerCheckEnt.PatientRegisterId
                });

            }
        }
    }



}