using Microsoft.EntityFrameworkCore;
using NUglify.Helpers;
using Shentun.Peis.Enums;
using Shentun.Peis.Models;
using Shentun.Peis.ReferenceRanges;
using Shentun.Peis.RegisterCheckAsbitems;
using Shentun.Peis.RegisterCheckItems;
using Shentun.Peis.RegisterChecks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Volo.Abp;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Domain.Services;

namespace Shentun.Peis.RegisterAsbitems
{
    /// <summary>
    /// 检查组合项目记录
    /// </summary>
    public class RegisterCheckAsbitemManager : DomainService
    {
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<AsbitemDetail> _asbitemDetailRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly IRepository<Unit, Guid> _unitRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<ReferenceRange, Guid> _referenceRangeRepository;
        private readonly IRepository<ChargeRequest, Guid> _chargeRequestRepository;
        private readonly ReferenceRangeManager _referenceRangeManager;
        private readonly RegisterCheckManager _registerCheckManager;
        private readonly RegisterCheckItemManager _registerCheckItemManager;
        private readonly CacheService _cacheService;
        public RegisterCheckAsbitemManager(IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
            IRepository<AsbitemDetail> asbitemDetailRepository,
             IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<Unit, Guid> unitRepository,
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<Item, Guid> itemRepository,
            IRepository<ReferenceRange, Guid> referenceRangeRepository,
            ReferenceRangeManager referenceRangeManager,
            RegisterCheckManager registerCheckManager,
            RegisterCheckItemManager registerCheckItemManager,
            CacheService cacheService,
            IRepository<ChargeRequest, Guid> chargeRequestRepository
            )
        {
            this._registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            this._registerCheckRepository = registerCheckRepository;
            this._registerCheckItemRepository = registerCheckItemRepository;
            this._asbitemDetailRepository = asbitemDetailRepository;
            this._asbitemRepository = asbitemRepository;
            this._unitRepository = unitRepository;
            this._patientRegisterRepository = patientRegisterRepository;
            this._itemRepository = itemRepository;
            this._referenceRangeRepository = referenceRangeRepository;
            this._referenceRangeManager = referenceRangeManager;
            this._registerCheckManager = registerCheckManager;
            this._registerCheckItemManager = registerCheckItemManager;
            _cacheService = cacheService;
            _chargeRequestRepository = chargeRequestRepository;
        }




        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="OrganizationUnitId">体检中心ID</param>
        /// <param name="ent">登记的组合项目</param>
        /// <param name="IsAutoMerger">是否需要自动合并</param>
        /// <returns></returns>
        public async Task<RegisterCheckAsbitem> CreateAsync(Guid OrganizationUnitId, RegisterCheckAsbitem ent, bool IsAutoMerger)
        {
            throw new Exception("RegisterCheckAsbitem.CreateAsync禁止使用");

            var IsregisterAsbitemEnt = await _registerCheckAsbitemRepository.FirstOrDefaultAsync(m => m.PatientRegisterId == ent.PatientRegisterId && m.AsbitemId == ent.AsbitemId);
            if (IsregisterAsbitemEnt == null)
            {

                //添加check跟item数据

                #region 默认添加RegisterCheck数据

                RegisterCheck registerCheckEnt = new RegisterCheck
                {
                    CheckRequestNo = await _registerCheckManager.CreateCheckRequestNo(OrganizationUnitId),
                    CheckRequestPrintTimes = 0,
                    CompleteFlag = RegisterCheckCompleteFlag.UnChecked,
                    IsAudit = 'N',
                    IsLock = 'N'
                };

                var registerCheckEnt_Res = await _registerCheckRepository.InsertAsync(registerCheckEnt, true);

                #endregion




                RegisterCheckAsbitem entity = new RegisterCheckAsbitem
                {
                    Amount = ent.Amount,
                    AsbitemId = ent.AsbitemId,
                    ChargePrice = ent.ChargePrice,
                    IsCharge = ent.IsCharge,
                    LisRequestId = ent.LisRequestId,
                    PatientRegisterId = ent.PatientRegisterId,
                    PayTypeFlag = ent.PayTypeFlag,
                    StandardPrice = ent.StandardPrice,
                    GroupPackageId = ent.GroupPackageId,
                    RegisterCheckId = registerCheckEnt_Res.Id
                };
                var registerAsbitemEnt_Res = await _registerCheckAsbitemRepository.InsertAsync(entity, true);


                if (registerCheckEnt_Res != null)
                {
                    #region 默认添加RegisterCheckItem数据 需要遍历Item

                    //  var itemList = await _asbitemDetailRepository.GetListAsync(m => m.AsbitemId == ent.AsbitemId);
                    var asbitemDetailList = (await _asbitemDetailRepository.GetDbSetAsync()).Include(x => x.Item).Where(m => m.AsbitemId == ent.AsbitemId).ToList();
                    List<RegisterCheckItem> registerCheckItemList = new List<RegisterCheckItem>();

                    if (asbitemDetailList.Any())
                    {


                        var itemList = await _itemRepository.GetListAsync();
                        var referenceRangeList = await _referenceRangeRepository.GetListAsync();
                        var patientRegisterEnt = await _patientRegisterRepository.GetAsync(ent.PatientRegisterId);

                        foreach (var item in asbitemDetailList)
                        {
                            //参考范围
                            //  var referenceRangeEnt = await _referenceRangeManager.GetReferenceRangeInSexAge(item.ItemId, ent.PatientRegisterId);
                            var referenceRangeEnt = _referenceRangeManager.GetReferenceRangeBySexAgeTemp(referenceRangeList,
                                itemList.Where(m => m.Id == item.ItemId).FirstOrDefault(),
                                patientRegisterEnt.SexId,
                                patientRegisterEnt.Age);

                            string UnitName = "";
                            if (item.Item.UnitId != null && item.Item.UnitId != Guid.Empty)
                            {
                                //单位
                                var unitEnt = await _unitRepository.GetAsync(item.Item.UnitId.Value);
                                if (unitEnt != null)
                                {
                                    UnitName = unitEnt.DisplayName;
                                }
                            }


                            RegisterCheckItem registerCheckItem = new RegisterCheckItem
                            {
                                ItemId = item.ItemId,
                                RegisterCheckId = registerCheckEnt_Res.Id,
                                ReferenceRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.ReferenceRangeValue,
                                CriticalRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.CriticalRangeValue,
                                Unit = UnitName
                            };
                            registerCheckItemList.Add(registerCheckItem);
                        }


                        await _registerCheckItemRepository.InsertManyAsync(registerCheckItemList);

                    }
                    else
                    {
                        var asbitemEntity = await _asbitemRepository.FindAsync(m => m.Id == ent.AsbitemId);

                        if (asbitemEntity.IsCheck == 'Y')
                            throw new UserFriendlyException($"{asbitemEntity.DisplayName}项目未包含明细项目");
                    }

                    #endregion
                }


                #region 数据登记完，自动合并  先判断自身组合项目能否合并  如果可以合并再去找当前登记下的组合项目是否有同项目类别的数据（并且判断这个组合项目是否为可以合并的）
                //是否需要自动合并
                if (IsAutoMerger)
                {
                    var asbitemEnt = (await _asbitemRepository.GetDbSetAsync()).Include(x => x.ItemType).Where(m => m.Id == ent.AsbitemId).FirstOrDefault();
                    if (asbitemEnt != null)
                    {
                        if (asbitemEnt.IsItemResultMerger == 'Y' && asbitemEnt.ItemType.IsMergeAsbitem == 'Y')
                        {
                            //可以合并
                            //查询需要合并的数据
                            var mergerRegisterAsbitemList = (await _registerCheckAsbitemRepository.GetDbSetAsync()).Include(x => x.Asbitem).Include(x => x.Asbitem.ItemType)
                                .Where(m => m.PatientRegisterId == ent.PatientRegisterId
                                && m.Asbitem.IsItemResultMerger == 'Y'
                                && m.Asbitem.ItemType.IsMergeAsbitem == 'Y'
                                && m.Asbitem.ItemTypeId == asbitemEnt.ItemTypeId);

                            //1就是本身
                            if (mergerRegisterAsbitemList.Count() > 1)
                            {
                                //有需要合并的数据hh
                                await MergeRegisterAsbitemAsync(mergerRegisterAsbitemList.Select(s => s.Id).ToList());
                            }
                        }
                    }
                }

                #endregion


                return registerAsbitemEnt_Res;
            }
            else
            {
                //重复
                return IsregisterAsbitemEnt;
            }
        }


        public async Task<CreateRegisterCheckAsbitemEntity> CreateManyAsync(PatientRegister patientRegister, List<RegisterCheckAsbitem> registerAsbitems)
        {
            if (patientRegister == null)
            {
                throw new UserFriendlyException("patientRegister不能为空");
            }
            var createRegisterCheckAsbitemEntity = new CreateRegisterCheckAsbitemEntity();

            if (registerAsbitems == null || registerAsbitems.Count == 0)
            {

                return null;
            }

            var asbitems = new List<Asbitem>();
            Dictionary<Guid, Guid> registerCheckIdValues = new Dictionary<Guid, Guid>();
            foreach (var registerAsbitem in registerAsbitems)
            {
                registerAsbitem.PatientRegisterId = patientRegister.Id;
                var asbitem = await _cacheService.GetAsbitemAsync(registerAsbitem.AsbitemId);
                asbitems.Add(asbitem);
                if (registerAsbitem.StandardPrice < 0)
                {
                    throw new UserFriendlyException($"{asbitem.DisplayName}标准价格不能小于0");
                }
                if (registerAsbitem.ChargePrice < 0)
                {
                    throw new UserFriendlyException($"{asbitem.DisplayName}实收价格不能小于0");
                }

                if (registerAsbitem.Amount < 1)
                {
                    throw new UserFriendlyException($"{asbitem.DisplayName}数量不能小于1");
                }
                if (registerAsbitem.Amount > 10)
                {
                    throw new UserFriendlyException($"{asbitem.DisplayName}数量不能大于10");
                }
                DataHelper.CheckCharIsYOrN(registerAsbitem.IsCharge, $"{asbitem.DisplayName}是否已收费");
                if (registerAsbitem.PayTypeFlag != PayTypeFlag.OrgPay &&
                    registerAsbitem.PayTypeFlag != PayTypeFlag.PersonPay &&
                    registerAsbitem.PayTypeFlag != PayTypeFlag.Free)
                {
                    throw new UserFriendlyException($"{asbitem.DisplayName}支付方式类别不存在");
                }

                if (patientRegister.SexId != SexFlag.UnKnown && asbitem.ForSexId != ForSexFlag.All)
                {
                    if (patientRegister.SexId != asbitem.ForSexId)
                    {
                        throw new UserFriendlyException($"{asbitem.DisplayName}要求的性别和人员性别不一致");
                    }
                }
                var newRegisterCheckAsbitem = new RegisterCheckAsbitem(GuidGenerator.Create())
                {
                    PatientRegisterId = patientRegister.Id,
                    AsbitemId = registerAsbitem.AsbitemId,
                    Amount = registerAsbitem.Amount,
                    StandardPrice = registerAsbitem.StandardPrice,
                    ChargePrice = registerAsbitem.ChargePrice,
                    PayTypeFlag = registerAsbitem.PayTypeFlag,
                    ChargeSourceFlag = registerAsbitem.ChargeSourceFlag,
                    ChargeAsbitemId = registerAsbitem.ChargeAsbitemId

                };
                createRegisterCheckAsbitemEntity.NewRegisterCheckAsbitems.Add(newRegisterCheckAsbitem);
                //增加RegisterCheck
                var itemType = await _cacheService.GetItemTypeAsync(asbitem.ItemTypeId);
                Guid registerCheckId;
                RegisterCheck registerCheck = null;
                if (itemType.IsMergeAsbitem == 'Y' && asbitem.IsItemResultMerger == 'Y' && registerCheckIdValues.TryGetValue(itemType.Id, out registerCheckId))
                {
                    newRegisterCheckAsbitem.RegisterCheckId = registerCheckId;

                }
                else
                {
                    registerCheck = new RegisterCheck(GuidGenerator.Create())
                    {
                        PatientRegisterId = patientRegister.Id,
                        IsLock = 'N',
                        CompleteFlag = RegisterCheckCompleteFlag.UnChecked,
                        IsCriticalValue = '0',
                        //CriticalValueProcessFlag = '0',
                        IsAudit = 'N',
                        CheckRequestNo = await _registerCheckManager.CreateCheckRequestNo(patientRegister.MedicalCenterId)
                    };
                    registerCheckId = registerCheck.Id;
                    newRegisterCheckAsbitem.RegisterCheckId = registerCheckId;
                    createRegisterCheckAsbitemEntity.NewRegisterChecks.Add(registerCheck);
                }
                registerCheckIdValues[itemType.Id] = registerCheckId;
                //增加register_check_item
                var asbitemDetails = (await _asbitemDetailRepository.GetQueryableAsync()).Where(o => o.AsbitemId == registerAsbitem.AsbitemId).ToList();
                foreach (var asbitemDetail in asbitemDetails)
                {
                    if (createRegisterCheckAsbitemEntity.NewRegisterCheckItems.Where(o => o.RegisterCheckId == registerCheckId &&
                                            o.ItemId == asbitemDetail.ItemId).Count() == 0)
                    {
                        var registerCheckItem = new RegisterCheckItem()
                        {
                            RegisterCheckId = registerCheckId,
                            ItemId = asbitemDetail.ItemId,
                            ResultStatusId = ResultStatusFlag.Normal
                        };
                        createRegisterCheckAsbitemEntity.NewRegisterCheckItems.Add(registerCheckItem);
                    }

                }

            }

            if (createRegisterCheckAsbitemEntity.NewRegisterChecks.Count == 0)
            {
                throw new UserFriendlyException("没有生成检查单");
            }
            if (createRegisterCheckAsbitemEntity.NewRegisterCheckAsbitems.Count == 0)
            {
                throw new UserFriendlyException("没有生成登记组合项目");
            }
            if (createRegisterCheckAsbitemEntity.NewRegisterCheckItems.Count == 0)
            {
                throw new UserFriendlyException("没有生成登记明细项目");
            }
            return createRegisterCheckAsbitemEntity;
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="patientRegister"></param>
        /// <param name="registerAsbitems"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task<CreateRegisterCheckAsbitemEntity> UpdateManyAsync(PatientRegister patientRegister, List<RegisterCheckAsbitem> registerAsbitems)
        {
            if (patientRegister == null)
            {
                throw new UserFriendlyException("patientRegister不能为空");
            }
            if (patientRegister.CompleteFlag == PatientRegisterCompleteFlag.SumCheck)
            {
                throw new UserFriendlyException("已总检不允许修改");
            }
            if (patientRegister.IsLock == 'Y')
            {
                throw new UserFriendlyException("已加锁不允许修改");
            }

            var createRegisterCheckAsbitemEntity = new CreateRegisterCheckAsbitemEntity();
            //获取已登记的检查
            var existRegisterChecks = (await _registerCheckRepository.GetQueryableAsync()).Where(o => o.PatientRegisterId == patientRegister.Id).ToList();

            //已登记的组合项目
            var existRegisterAsbitems = (await _registerCheckAsbitemRepository.GetQueryableAsync()).Where(o =>
                  existRegisterChecks.Select(x => x.Id).Contains(o.RegisterCheckId)).ToList();

            //已登记的明细项目
            var existRegisterItems = (await _registerCheckItemRepository.GetQueryableAsync()).Where(o =>
                  existRegisterChecks.Select(x => x.Id).Contains(o.RegisterCheckId)).ToList();

            //if (registerAsbitems == null || registerAsbitems.Count == 0)
            //{
            //    //删除登记的组合项目信息
            //    if (existRegisterChecks.Count > 0)
            //    {
            //        createRegisterCheckAsbitemEntity.DeleteRegisterChecks = existRegisterChecks;
            //        createRegisterCheckAsbitemEntity.DeleteRegisterCheckAsbitems = existRegisterAsbitems;
            //        createRegisterCheckAsbitemEntity.DeleteRegisterCheckItems = existRegisterItems;
            //    }
            //    return createRegisterCheckAsbitemEntity;
            //}

            //获取删除的组合项目 遍历登记的组合项目
            foreach (var existRegisterAsbitem in existRegisterAsbitems)
            {
                var asbitem = await _cacheService.GetAsbitemAsync(existRegisterAsbitem.AsbitemId);
                if (registerAsbitems.Where(o => o.Id == existRegisterAsbitem.Id && o.AsbitemId == existRegisterAsbitem.AsbitemId).Count() == 0)
                {
                    //入参里面未找到项目，删除该项目
                    if (existRegisterAsbitem.IsCharge == 'Y')
                    {
                        throw new UserFriendlyException($"{asbitem.DisplayName}已收费不能删除");
                    }

                    if (existRegisterChecks.Where(o => o.Id == existRegisterAsbitem.RegisterCheckId).Single().CompleteFlag
                        == RegisterCheckCompleteFlag.Checked)
                    {
                        throw new UserFriendlyException($"{asbitem.DisplayName}已检查不能删除");
                    }
                    if (existRegisterChecks.Where(o => o.Id == existRegisterAsbitem.RegisterCheckId).Single().IsLock
                       == 'Y')
                    {
                        throw new UserFriendlyException($"{asbitem.DisplayName}已锁住不能删除");
                    }
                    if (existRegisterAsbitem.ChargeRequestId != null)
                    {
                        var chargeRequest = (await _chargeRequestRepository.GetQueryableAsync()).Where(o => o.Id == existRegisterAsbitem.ChargeRequestId).FirstOrDefault();
                        if (chargeRequest != null)
                        {
                            if (chargeRequest.ChargeRequestFlag == ChargeRequestFlag.ChargeRequest)
                            {
                                throw new UserFriendlyException($"{asbitem.DisplayName}已有收费申请不能删除，必须先作废收费申请");
                            }
                            if (chargeRequest.ChargeRequestFlag == ChargeRequestFlag.CancelChargeRequest)
                            {
                                throw new UserFriendlyException($"{asbitem.DisplayName}已有作废申请不能删除，必须先作废成功");
                            }
                            if (chargeRequest.ChargeRequestFlag == ChargeRequestFlag.RefundRequest)
                            {
                                throw new UserFriendlyException($"{asbitem.DisplayName}已有退费申请不能删除，必须先退费");
                            }
                        }
                    }

                    //登记项目加到删除列表里面
                    createRegisterCheckAsbitemEntity.DeleteRegisterCheckAsbitems.Add(existRegisterAsbitem);
                }
            }

            //获取更新的组合项目  遍历请求参数里面的组合项目列表
            foreach (var registerAsbitem in registerAsbitems)
            {

                var asbitem = await _cacheService.GetAsbitemAsync(registerAsbitem.AsbitemId);
                //根据请求参数里面的登记组合项目查找已登记里面数据
                var existRegisterAsbitem = existRegisterAsbitems.Where(o => o.Id == registerAsbitem.Id &&
                 o.AsbitemId == registerAsbitem.AsbitemId).SingleOrDefault();
                if (existRegisterAsbitem == null && registerAsbitem.Id != Guid.Empty)
                {
                    throw new UserFriendlyException($"组合项目：{asbitem.DisplayName}传输了registerAsbitem.Id，但不存在");
                }
                if (registerAsbitem.Id == Guid.Empty)
                {
                    //检查组合项目id是否登记，并且删除列表里面是否有组合项目id
                    if (existRegisterAsbitems.Where(o => o.AsbitemId == registerAsbitem.AsbitemId).Count() > 0 &&
                        createRegisterCheckAsbitemEntity.DeleteRegisterCheckAsbitems.Where(o => o.AsbitemId == registerAsbitem.AsbitemId).Count() == 0)
                    {
                        throw new UserFriendlyException($"组合项目：{asbitem.DisplayName}已存在不能增加");
                    }
                }

                if (existRegisterAsbitem != null)
                {
                    //对比登记的组合项目信息，有修改就加到修改列表里面
                    var isModified = false;
                    if (registerAsbitem.Amount != existRegisterAsbitem.Amount ||
                        registerAsbitem.StandardPrice != existRegisterAsbitem.StandardPrice ||
                        registerAsbitem.ChargePrice != existRegisterAsbitem.ChargePrice ||
                        registerAsbitem.PayTypeFlag != existRegisterAsbitem.PayTypeFlag)
                    {
                        isModified = true;
                    }
                    if (registerAsbitem.IsCharge == 'Y' && isModified)
                    {
                        throw new UserFriendlyException($"{asbitem.DisplayName}已收费不能修改");
                    }

                    //if (existRegisterChecks.Where(o => o.Id == existRegisterAsbitem.RegisterCheckId).Single().CompleteFlag
                    //    == RegisterCheckCompleteFlag.Checked && isModified)
                    //{
                    //    throw new UserFriendlyException($"{asbitem.DisplayName}已检查不能修改");
                    //}
                    var registerCheck = existRegisterChecks.Where(o => o.Id == existRegisterAsbitem.RegisterCheckId).Single();
                    if (string.IsNullOrWhiteSpace(registerCheck.CheckRequestNo))
                    {
                        //没有申请号的要重新生成申请号，所有设置成修改状态
                        isModified = true;
                    }
                    if (!isModified)
                    {
                        continue;
                    }
                    await Verify(patientRegister, registerAsbitem);
                    existRegisterAsbitem.Amount = registerAsbitem.Amount;
                    existRegisterAsbitem.StandardPrice = registerAsbitem.StandardPrice;
                    existRegisterAsbitem.ChargePrice = registerAsbitem.ChargePrice;
                    existRegisterAsbitem.PayTypeFlag = registerAsbitem.PayTypeFlag;
                    existRegisterAsbitem.ChargeSourceFlag = registerAsbitem.ChargeSourceFlag;
                    existRegisterAsbitem.ChargeAsbitemId = registerAsbitem.ChargeAsbitemId;
                    createRegisterCheckAsbitemEntity.UpdateRegisterCheckAsbitems.Add(existRegisterAsbitem);
                }
            }

            //获取新增的组合项目  遍历请求参数里面的组合项目列表
            foreach (var registerAsbitem in registerAsbitems)
            {
                if (registerAsbitem.Id == Guid.Empty)
                {
                    await Verify(patientRegister, registerAsbitem);
                    var newRegisterCheckAsbitem = new RegisterCheckAsbitem(GuidGenerator.Create())
                    {
                        PatientRegisterId = patientRegister.Id,
                        AsbitemId = registerAsbitem.AsbitemId,
                        Amount = registerAsbitem.Amount,
                        StandardPrice = registerAsbitem.StandardPrice,
                        ChargePrice = registerAsbitem.ChargePrice,
                        PayTypeFlag = registerAsbitem.PayTypeFlag,
                        IsCharge = registerAsbitem.IsCharge,
                        ChargeSourceFlag = registerAsbitem.ChargeSourceFlag,
                        ChargeAsbitemId = registerAsbitem.ChargeAsbitemId
                    };

                    //添加到新增列表
                    createRegisterCheckAsbitemEntity.NewRegisterCheckAsbitems.Add(newRegisterCheckAsbitem);
                }
            }


            //获取更新的RegisterCheck   遍历需要修改的登记组合项目
            foreach (var registerCheckAsbitem in createRegisterCheckAsbitemEntity.UpdateRegisterCheckAsbitems)
            {
                if (createRegisterCheckAsbitemEntity.UpdateRegisterChecks.
                    Where(o => o.Id == registerCheckAsbitem.RegisterCheckId).Count() == 0)
                {
                    //从登记的registerCheck里查找实体，添加到RegisterCheck更新列表
                    var registerCheck = existRegisterChecks.Where(o => o.Id == registerCheckAsbitem.RegisterCheckId).Single();
                    createRegisterCheckAsbitemEntity.UpdateRegisterChecks.Add(registerCheck);
                }
            }
            //获取删除的RegisterCheck及其对应的RegisterCheckItem     遍历已登记RegisterCheck
            foreach (var registerCheck in existRegisterChecks)
            {
                if (createRegisterCheckAsbitemEntity.DeleteRegisterCheckAsbitems.
                    Where(o => o.RegisterCheckId == registerCheck.Id).Count() > 0 &&
                    createRegisterCheckAsbitemEntity.UpdateRegisterCheckAsbitems.
                    Where(o => o.RegisterCheckId == registerCheck.Id).Count() == 0)
                {
                    //添加registerCheck、registerCheckItem到删除列表
                    createRegisterCheckAsbitemEntity.DeleteRegisterChecks.Add(registerCheck);
                    createRegisterCheckAsbitemEntity.DeleteRegisterCheckItems.AddRange(
                        existRegisterItems.Where(o => o.RegisterCheckId == registerCheck.Id).ToList());
                }
            }

            //不需要添加明细的检查id   修改项目时，如果项目保存了结果，加进来
            List<Guid> NoInsertRegisterCheckItemRegisterCheckIds = new List<Guid>();

            //将更新UpdateRegisterChecks对应的所有RegisterCheckItem放入删除中
            foreach (var registerCheck in createRegisterCheckAsbitemEntity.UpdateRegisterChecks)
            {
                var registerItems = existRegisterItems.Where(o => o.RegisterCheckId == registerCheck.Id).ToList();
                //明细项目结果如果有保存过结果，就不删除
                var isDelete = registerItems.Count(m => !string.IsNullOrWhiteSpace(m.Result)) > 0 ? true : false;
                if (!isDelete)
                {
                    foreach (var registerItem in registerItems)
                    {
                        if (createRegisterCheckAsbitemEntity.DeleteRegisterCheckItems.
                            Where(o => o.RegisterCheckId == registerItem.RegisterCheckId && o.ItemId == registerItem.ItemId).Count() == 0)
                        {
                            createRegisterCheckAsbitemEntity.DeleteRegisterCheckItems.Add(registerItem);
                        }
                    }
                }
                else
                {
                    NoInsertRegisterCheckItemRegisterCheckIds.Add(registerCheck.Id);
                }
                //没有检查申请单号的，重新生成检查申请单号
                if (string.IsNullOrWhiteSpace(registerCheck.CheckRequestNo))
                {
                    registerCheck.CheckRequestNo = await _registerCheckManager.CreateCheckRequestNo(patientRegister.MedicalCenterId);
                }

            }
            //获取所有已有的itemtype和checkId
            Dictionary<Guid, Guid> registerCheckIdValues = new Dictionary<Guid, Guid>();
            foreach (var registerCheckAsbitem in createRegisterCheckAsbitemEntity.UpdateRegisterCheckAsbitems)
            {
                var asbitem = await _cacheService.GetAsbitemAsync(registerCheckAsbitem.AsbitemId);
                registerCheckIdValues[asbitem.ItemTypeId] = registerCheckAsbitem.RegisterCheckId;
            }
            //将新增加和修改的asbitem重新生成registerCheckItems,仅新增加的生成registerCheck
            List<RegisterCheckAsbitem> newAndModifiedRegisterAsbitems = new List<RegisterCheckAsbitem>();
            newAndModifiedRegisterAsbitems.AddRange(createRegisterCheckAsbitemEntity.NewRegisterCheckAsbitems);
            newAndModifiedRegisterAsbitems.AddRange(createRegisterCheckAsbitemEntity.UpdateRegisterCheckAsbitems);

            foreach (var registerCheckAsbitem in newAndModifiedRegisterAsbitems)
            {
                registerCheckAsbitem.PatientRegisterId = patientRegister.Id;
                await Verify(patientRegister, registerCheckAsbitem);

                var asbitem = await _cacheService.GetAsbitemAsync(registerCheckAsbitem.AsbitemId);
                //增加RegisterCheck
                var itemType = await _cacheService.GetItemTypeAsync(asbitem.ItemTypeId);
                Guid registerCheckId = registerCheckAsbitem.RegisterCheckId;
                RegisterCheck registerCheck = null;
                if (registerCheckId == Guid.Empty)
                {
                    if (itemType.IsMergeAsbitem == 'Y' && asbitem.IsItemResultMerger == 'Y' && registerCheckIdValues.TryGetValue(asbitem.ItemTypeId, out registerCheckId))
                    {
                        registerCheckAsbitem.RegisterCheckId = registerCheckId;

                    }
                    else
                    {
                        registerCheck = new RegisterCheck(GuidGenerator.Create())
                        {
                            PatientRegisterId = patientRegister.Id,
                            IsLock = 'N',
                            CompleteFlag = RegisterCheckCompleteFlag.UnChecked,
                            IsCriticalValue = '0',
                            //CriticalValueProcessFlag = '0',
                            IsAudit = 'N',
                            CheckRequestNo = await _registerCheckManager.CreateCheckRequestNo(patientRegister.MedicalCenterId)
                        };
                        registerCheckId = registerCheck.Id;
                        registerCheckAsbitem.RegisterCheckId = registerCheckId;
                        createRegisterCheckAsbitemEntity.NewRegisterChecks.Add(registerCheck);
                        registerCheckIdValues[asbitem.ItemTypeId] = registerCheckId;
                    }

                }



                //增加register_check_item
                //判断是否需要添加，已保存结果的原有项目不需要重新添加
                if (!NoInsertRegisterCheckItemRegisterCheckIds.Contains(registerCheckId))
                {
                    var asbitemDetails = (await _asbitemDetailRepository.GetQueryableAsync()).Where(o => o.AsbitemId == registerCheckAsbitem.AsbitemId).ToList();
                    foreach (var asbitemDetail in asbitemDetails)
                    {
                        if (createRegisterCheckAsbitemEntity.NewRegisterCheckItems.Where(o => o.RegisterCheckId == registerCheckId &&
                                                o.ItemId == asbitemDetail.ItemId).Count() == 0)
                        {
                            var registerCheckItem = new RegisterCheckItem()
                            {
                                RegisterCheckId = registerCheckId,
                                ItemId = asbitemDetail.ItemId,
                                ResultStatusId = ResultStatusFlag.Normal
                            };
                            createRegisterCheckAsbitemEntity.NewRegisterCheckItems.Add(registerCheckItem);
                        }

                    }
                }

            }


            return createRegisterCheckAsbitemEntity;
        }


        public async Task Verify(PatientRegister patientRegister, RegisterCheckAsbitem registerCheckAsbitem)
        {
            registerCheckAsbitem.PatientRegisterId = patientRegister.Id;
            var asbitem = await _cacheService.GetAsbitemAsync(registerCheckAsbitem.AsbitemId);
            if (registerCheckAsbitem.StandardPrice < 0)
            {
                throw new UserFriendlyException($"{asbitem.DisplayName}标准价格不能小于0");
            }
            if (registerCheckAsbitem.ChargePrice < 0)
            {
                throw new UserFriendlyException($"{asbitem.DisplayName}实收价格不能小于0");
            }

            if (registerCheckAsbitem.Amount < 1)
            {
                throw new UserFriendlyException($"{asbitem.DisplayName}数量不能小于1");
            }
            if (registerCheckAsbitem.Amount > 10)
            {
                throw new UserFriendlyException($"{asbitem.DisplayName}数量不能大于10");
            }
            DataHelper.CheckCharIsYOrN(registerCheckAsbitem.IsCharge, $"{asbitem.DisplayName}是否已收费");
            if (registerCheckAsbitem.PayTypeFlag != PayTypeFlag.OrgPay &&
                registerCheckAsbitem.PayTypeFlag != PayTypeFlag.PersonPay &&
                registerCheckAsbitem.PayTypeFlag != PayTypeFlag.Free)
            {
                throw new UserFriendlyException($"{asbitem.DisplayName}支付方式类别不存在");
            }

            if (patientRegister.SexId != SexFlag.UnKnown && asbitem.ForSexId != ForSexFlag.All)
            {
                if (patientRegister.SexId != asbitem.ForSexId)
                {
                    throw new UserFriendlyException($"{asbitem.DisplayName}要求的性别和人员性别不一致");
                }
            }
        }
        /// <summary>
        ///  删除数据  判断条件（1.只能删除未收费的   2.已完成体检的不能删除）
        /// </summary>
        /// <param name="RegisterAsbitemId"></param>
        /// <returns></returns>
        public async Task DeleteAsync(Guid RegisterAsbitemId)
        {
            var registerAsbitemEnt = (await _registerCheckAsbitemRepository.GetQueryableAsync()).Include(x => x.Asbitem).FirstOrDefault(f => f.Id == RegisterAsbitemId);
            if (registerAsbitemEnt == null)
                throw new UserFriendlyException($"数据有误");
            if (registerAsbitemEnt.IsCharge == 'Y')
                throw new UserFriendlyException($"当前体检项目已收费，不能删除");
            var registerCheckEnt = await _registerCheckRepository.GetAsync(m => m.Id == registerAsbitemEnt.RegisterCheckId);
            if (registerCheckEnt != null && registerCheckEnt.CompleteFlag == RegisterCheckCompleteFlag.Checked)
                throw new UserFriendlyException($"当前体检项目已完成，不能删除");


            if (registerAsbitemEnt.ChargeRequestId != null)
            {
                var chargeRequest = (await _chargeRequestRepository.GetQueryableAsync()).Where(o => o.Id == registerAsbitemEnt.ChargeRequestId).FirstOrDefault();
                if (chargeRequest != null)
                {
                    if (chargeRequest.ChargeRequestFlag == ChargeRequestFlag.ChargeRequest)
                    {
                        throw new UserFriendlyException($"{registerAsbitemEnt.Asbitem.DisplayName}已有收费申请不能删除，必须先作废收费申请");
                    }
                    if (chargeRequest.ChargeRequestFlag == ChargeRequestFlag.CancelChargeRequest)
                    {
                        throw new UserFriendlyException($"{registerAsbitemEnt.Asbitem.DisplayName}已有作废申请不能删除，必须先作废成功");
                    }
                    if (chargeRequest.ChargeRequestFlag == ChargeRequestFlag.RefundRequest)
                    {
                        throw new UserFriendlyException($"{registerAsbitemEnt.Asbitem.DisplayName}已有退费申请不能删除，必须先退费");
                    }
                }
            }

            await _registerCheckAsbitemRepository.DeleteAsync(registerAsbitemEnt);

        }

        /// <summary>
        ///  删除数据  判断条件（1.只能删除未收费的   2.已完成体检的不能删除）
        /// </summary>
        /// <param name="RegisterAsbitemId"></param>
        /// <returns></returns>
        public async Task DeleteManyAsync(List<Guid> RegisterAsbitemIds)
        {
            foreach (var RegisterAsbitemId in RegisterAsbitemIds)
            {
                await DeleteAsync(RegisterAsbitemId);
            }
        }


        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="sourceEntity">dto</param>
        /// <param name="targetEntity">需要更新的目标实体</param>
        /// <returns></returns>
        public void UpdateAsync(RegisterCheckAsbitem sourceEntity, RegisterCheckAsbitem targetEntity)
        {
            if (sourceEntity.ChargePrice != null)
                targetEntity.ChargePrice = sourceEntity.ChargePrice;
            if (sourceEntity.Amount != null)
                targetEntity.Amount = sourceEntity.Amount;
            if (sourceEntity.IsCharge != null)
                targetEntity.IsCharge = sourceEntity.IsCharge;
            if (sourceEntity.PayTypeFlag != null)
                targetEntity.PayTypeFlag = sourceEntity.PayTypeFlag;

            targetEntity.GroupPackageId = sourceEntity.GroupPackageId;
        }


        ///// <summary>
        ///// 更新Check表下的参考范围信息
        ///// </summary>
        ///// <param name="PatientRegisterId"></param>
        //public async Task UpdateCheckReferenceRange(Guid PatientRegisterId)
        //{
        //    var entlist = (await _registerCheckItemRepository.GetDbSetAsync())
        //           .Include(x => x.RegisterCheck)
        //           .Include(x => x.RegisterCheck.RegisterAsbitems)
        //           .ThenInclude(x => x.PatientRegister)
        //           .Where(m => m.RegisterCheck.RegisterAsbitems.FirstOrDefault().PatientRegisterId == PatientRegisterId).ToList();

        //    var itemList = await _itemRepository.GetListAsync();
        //    var referenceRangeList = await _referenceRangeRepository.GetListAsync();

        //    foreach (var ent in entlist)
        //    {
        //        // var referenceRangeEnt = await _referenceRangeManager.GetReferenceRangeInSexAge(ent.ItemId, PatientRegisterId);  //根据新的条件获取参考范围
        //        var referenceRangeEnt = _referenceRangeManager.GetReferenceRangeInSexAgeTemp(referenceRangeList,
        //            itemList.Where(m => m.Id == ent.ItemId).FirstOrDefault(),
        //            ent.RegisterCheck.RegisterAsbitems.FirstOrDefault().PatientRegister.SexId,
        //             ent.RegisterCheck.RegisterAsbitems.FirstOrDefault().PatientRegister.Age);  //根据新的条件获取参考范围

        //        ent.ReferenceRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.ReferenceRangeValue;
        //        ent.CriticalRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.CriticalRangeValue;

        //    }

        //    await _registerCheckItemRepository.UpdateManyAsync(entlist);
        //}

        /// <summary>
        /// 更新Check表下的参考范围信息
        /// </summary>
        /// <param name="PatientRegisterId"></param>
        public async Task UpdateCheckReferenceRange(Guid PatientRegisterId)
        {
            var entlist = (await _registerCheckItemRepository.GetDbSetAsync())
                   .Include(x => x.RegisterCheck)
                   .Include(x => x.RegisterCheck.RegisterCheckAsbitems)
                   .ThenInclude(x => x.PatientRegister)
                   .Where(m => m.RegisterCheck.RegisterCheckAsbitems.FirstOrDefault().PatientRegisterId == PatientRegisterId).ToList();

            var itemList = await _itemRepository.GetListAsync();
            var referenceRangeList = await _referenceRangeRepository.GetListAsync();

            foreach (var ent in entlist)
            {
                // var referenceRangeEnt = await _referenceRangeManager.GetReferenceRangeInSexAge(ent.ItemId, PatientRegisterId);  //根据新的条件获取参考范围
                var referenceRangeEnt = _referenceRangeManager.GetReferenceRangeBySexAgeTemp(referenceRangeList,
                    itemList.Where(m => m.Id == ent.ItemId).FirstOrDefault(),
                    ent.RegisterCheck.RegisterCheckAsbitems.FirstOrDefault().PatientRegister.SexId,
                     ent.RegisterCheck.RegisterCheckAsbitems.FirstOrDefault().PatientRegister.Age);  //根据新的条件获取参考范围

                ent.ReferenceRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.ReferenceRangeValue;
                ent.CriticalRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.CriticalRangeValue;

            }

            await _registerCheckItemRepository.UpdateManyAsync(entlist);
        }


        /// <summary>
        /// 合并组合项目
        /// </summary>
        /// <param name="registerCheckIds"></param>
        /// <param name="OrganizationUnitId">体检中心ID</param>
        /// <returns></returns>
        public async Task MergeRegisterAsbitemAsync(List<Guid> registerCheckIds)
        {

            //原有项目
            if (registerCheckIds.Count <= 1)
            {
                throw new UserFriendlyException("合并时必须至少有两个检查单");
            }
            if (registerCheckIds.Count != registerCheckIds.Distinct().Count())
            {
                throw new UserFriendlyException("有重复的检查单不能合并");
            }
            //获取原RegisterCheck对应的所有RegisterCheckAsbitems来进行合并
            var updateCheckIdRegisterCheckAsbitems = await _registerCheckAsbitemRepository.GetListAsync(m => registerCheckIds.Contains(m.RegisterCheckId));
            var registerChecks = await _registerCheckRepository.GetListAsync(o =>
                                registerCheckIds.Contains(o.Id));

            registerChecks.ForEach(o =>
            {
                if (o.CompleteFlag == RegisterCheckCompleteFlag.Checked)
                {
                    throw new UserFriendlyException("有已检组合项目不能合并，必须先删除检查结果");
                }
                if (o.CompleteFlag == RegisterCheckCompleteFlag.GiveUpChecked)
                {
                    throw new UserFriendlyException("有弃检组合项目不能合并，必须先解除弃检");
                }
                if (o.IsLock == 'Y')
                {
                    throw new UserFriendlyException("有加锁组合项目不能合并，必须先解锁");
                }
            });

            var patientRegisterIds = registerChecks.Select(s => s.PatientRegisterId).Distinct().ToList();
            if (patientRegisterIds.Count() > 1)
            {
                throw new UserFriendlyException("所传项目属于不同的人员ID");
            }
            else if (patientRegisterIds.Count() == 0)
            {
                throw new UserFriendlyException("检查单中没有找到人员登记ID对应的记录");
            }

            var patientRegister = await _patientRegisterRepository.GetAsync(patientRegisterIds[0]);
            if (patientRegister.CompleteFlag == PatientRegisterCompleteFlag.SumCheck)
            {
                throw new UserFriendlyException("已总检不能合并");
            }
            //获取第一个RegisterCheck作为要合并的RegisterCheck
            var registerCheck = registerChecks.First();
            //获取待删除RegisterCheck
            var deleteRegisterChecks = registerChecks.Where(o => o.Id != registerCheck.Id).ToList();
            //获取待删除RegisterCheckItems
            var deleteRegisterCheckItems = (await _registerCheckItemRepository.GetListAsync(o => registerChecks.Select(s => s.Id).Contains(o.RegisterCheckId))).ToList();
            //重新设置CheckID
            updateCheckIdRegisterCheckAsbitems.ForEach(o => o.RegisterCheckId = registerCheck.Id);
            //重新生成RegisterCheckItems
            var newRegisterCheckItems = new List<RegisterCheckItem>();
            var asbitemDetailList = (await _asbitemDetailRepository.GetQueryableAsync()).Include(x => x.Item).Where(m => updateCheckIdRegisterCheckAsbitems.Select(s => s.AsbitemId).Contains(m.AsbitemId)).ToList();
            foreach (var asbitemDetail in asbitemDetailList)
            {
                if (newRegisterCheckItems.Where(o => o.ItemId == asbitemDetail.ItemId).Count() == 0)
                {
                    var registerCheckItem = new RegisterCheckItem()
                    {
                        RegisterCheckId = registerCheck.Id,
                        ItemId = asbitemDetail.ItemId,
                        ResultStatusId = ResultStatusFlag.Normal
                    };
                    newRegisterCheckItems.Add(registerCheckItem);
                }

            }
            await _registerCheckItemRepository.DeleteManyAsync(deleteRegisterCheckItems);
            await _registerCheckRepository.DeleteManyAsync(deleteRegisterChecks);

            await _registerCheckAsbitemRepository.UpdateManyAsync(updateCheckIdRegisterCheckAsbitems);
            await _registerCheckItemRepository.InsertManyAsync(newRegisterCheckItems);

        }


        /// <summary>
        /// 取消合并组合项目 按RegisterAsbitemId重新生成新的RegisterCheck数据
        /// </summary>
        /// <param name="RegisterAsbitemIds"></param>
        /// <param name="OrganizationUnitId">体检中心ID</param>
        /// <returns></returns>
        public async Task CancelMergeRegisterAsbitemAsync(List<Guid> RegisterAsbitemIds, Guid RegisterCheckId, Guid OrganizationUnitId)
        {
            throw new Exception("CancelMergeRegisterAsbitemAsync接口不再支持");
            //原有项目
            var registerAsbitemList = await _registerCheckAsbitemRepository.GetListAsync(m => RegisterAsbitemIds.Contains(m.Id));

            //待删除RegisterCheck
            List<Guid> RegisterCheckIds = new List<Guid> { RegisterCheckId };

            //删除registerCheckItem
            await _registerCheckItemManager.CheckAndDeleteAsync(RegisterCheckIds);

            //删除registerCheck
            await _registerCheckManager.CheckAndDeleteAsync(RegisterCheckIds);

            #region 重新插入多个新的registerCheck

            foreach (var registerAsbitem in registerAsbitemList)
            {
                #region 默认添加RegisterCheck数据


                RegisterCheck registerCheckEnt = new RegisterCheck
                {
                    CheckRequestNo = await _registerCheckManager.CreateCheckRequestNo(OrganizationUnitId),
                    CheckRequestPrintTimes = 0,
                    CompleteFlag = RegisterCheckCompleteFlag.UnChecked,
                    IsAudit = 'N',
                    IsLock = 'N'
                };

                var registerCheckEnt_Res = await _registerCheckRepository.InsertAsync(registerCheckEnt, true);



                if (registerCheckEnt_Res != null)
                {
                    #region 默认添加RegisterCheckItem数据 需要遍历Item

                    //  var itemList = await _asbitemDetailRepository.GetListAsync(m => m.AsbitemId == ent.AsbitemId);
                    var asbitemDetailList = (await _asbitemDetailRepository.GetDbSetAsync()).Include(x => x.Item).Where(m => m.AsbitemId == registerAsbitem.AsbitemId).ToList();
                    List<RegisterCheckItem> registerCheckItemList = new List<RegisterCheckItem>();

                    if (asbitemDetailList.Any())
                    {


                        var itemList = await _itemRepository.GetListAsync();
                        var referenceRangeList = await _referenceRangeRepository.GetListAsync();
                        var patientRegisterEnt = await _patientRegisterRepository.GetAsync(registerAsbitemList.FirstOrDefault().PatientRegisterId);

                        foreach (var item in asbitemDetailList)
                        {
                            //参考范围
                            //  var referenceRangeEnt = await _referenceRangeManager.GetReferenceRangeInSexAge(item.ItemId, ent.PatientRegisterId);
                            var referenceRangeEnt = _referenceRangeManager.GetReferenceRangeBySexAgeTemp(referenceRangeList,
                                itemList.Where(m => m.Id == item.ItemId).FirstOrDefault(),
                                patientRegisterEnt.SexId,
                                patientRegisterEnt.Age);

                            string UnitName = "";
                            if (item.Item.UnitId != null && item.Item.UnitId != Guid.Empty)
                            {
                                //单位
                                var unitEnt = await _unitRepository.GetAsync(item.Item.UnitId.Value);
                                if (unitEnt != null)
                                {
                                    UnitName = unitEnt.DisplayName;
                                }
                            }


                            RegisterCheckItem registerCheckItem = new RegisterCheckItem
                            {
                                ItemId = item.ItemId,
                                RegisterCheckId = registerCheckEnt_Res.Id,
                                ReferenceRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.ReferenceRangeValue,
                                CriticalRangeValue = referenceRangeEnt == null ? "" : referenceRangeEnt.CriticalRangeValue,
                                Unit = UnitName
                            };
                            registerCheckItemList.Add(registerCheckItem);
                        }


                        await _registerCheckItemRepository.InsertManyAsync(registerCheckItemList);

                    }


                    #endregion

                    registerAsbitem.RegisterCheckId = registerCheckEnt_Res.Id;
                }

                #endregion
            }

            #endregion

            //更新RegisterAsbitem表RegisterCheckId
            await _registerCheckAsbitemRepository.UpdateManyAsync(registerAsbitemList);
        }

        /// <summary>
        /// 取消合并组合项目 按RegisterAsbitemId重新生成新的RegisterCheck数据
        /// </summary>
        /// <param name="registerCheckIds"></param>
        /// <returns></returns>
        public async Task CancelMergeRegisterAsbitemAsync(List<Guid> registerCheckIds)
        {
            if (registerCheckIds.Count != registerCheckIds.Distinct().Count())
            {
                throw new UserFriendlyException("有重复的检查单不能取消合并");
            }
            //获取原RegisterCheck对应的所有RegisterCheckAsbitems来进行合并
            var registerCheckAsbitems = await _registerCheckAsbitemRepository.GetListAsync(m => registerCheckIds.Contains(m.RegisterCheckId));
            var registerChecks = await _registerCheckRepository.GetListAsync(o =>
                                registerCheckIds.Contains(o.Id));

            registerChecks.ForEach(o =>
            {
                if (o.CompleteFlag == RegisterCheckCompleteFlag.Checked)
                {
                    throw new UserFriendlyException("有已检组合项目不能取消合并，必须先删除检查结果");
                }
                if (o.CompleteFlag == RegisterCheckCompleteFlag.GiveUpChecked)
                {
                    throw new UserFriendlyException("有弃检组合项目不能取消合并，必须先解除弃检");
                }
                if (o.IsLock == 'Y')
                {
                    throw new UserFriendlyException("有加锁组合项目不能取消合并，必须先解锁");
                }
            });

            var patientRegisterIds = registerChecks.Select(s => s.PatientRegisterId).Distinct().ToList();
            if (patientRegisterIds.Count() > 1)
            {
                throw new UserFriendlyException("所传项目属于不同的人员ID");
            }
            var patientRegister = await _patientRegisterRepository.GetAsync(patientRegisterIds[0]);
            if (patientRegister.CompleteFlag == PatientRegisterCompleteFlag.SumCheck)
            {
                throw new UserFriendlyException("已总检不能取消合并");
            }
            //获取待删除RegisterCheckItems
            var deleteRegisterCheckItems = (await _registerCheckItemRepository.GetListAsync(o => registerChecks.Select(s => s.Id).Contains(o.RegisterCheckId))).ToList();
            //获取要重用以前的RegisterCheckID不更新的RegisterCheckAsbitems
            var noUpdateRegisterCheckAsbitems = new List<RegisterCheckAsbitem>();
            foreach (var registerCheckId in registerCheckIds)
            {
                var registerCheckAsbitem = registerCheckAsbitems.Where(o => o.RegisterCheckId == registerCheckId).First();
                noUpdateRegisterCheckAsbitems.Add(registerCheckAsbitem);
            }
            //获取要重新生成RegisterCheckID的RegisterCheckAsbitems
            var updateRegisterCheckAsbitems = new List<RegisterCheckAsbitem>();
            foreach (var registerCheckAsbitem in registerCheckAsbitems)
            {
                if (noUpdateRegisterCheckAsbitems.Where(o => o.Id == registerCheckAsbitem.Id).Count() == 0)
                {
                    updateRegisterCheckAsbitems.Add(registerCheckAsbitem);
                }
            }
            var newRegisterChecks = new List<RegisterCheck>();
            var newRegisterCheckItems = new List<RegisterCheckItem>();
            foreach (var registerCheckAsbitem in updateRegisterCheckAsbitems)
            {
                var registerCheck = new RegisterCheck(GuidGenerator.Create())
                {
                    PatientRegisterId = patientRegister.Id,
                    IsLock = 'N',
                    CompleteFlag = RegisterCheckCompleteFlag.UnChecked,
                    IsCriticalValue = '0',
                    //CriticalValueProcessFlag = '0',
                    IsAudit = 'N',
                    CheckRequestNo = await _registerCheckManager.CreateCheckRequestNo(patientRegister.MedicalCenterId)
                };
                var asbitemDetails = (await _asbitemDetailRepository.GetQueryableAsync()).Include(x => x.Item).Where(o => o.AsbitemId == registerCheckAsbitem.AsbitemId).ToList();

                foreach (var asbitemDetail in asbitemDetails)
                {
                    if (newRegisterCheckItems.Where(o => o.RegisterCheckId == registerCheck.Id &&
                                            o.ItemId == asbitemDetail.ItemId).Count() == 0)
                    {
                        var registerCheckItem = new RegisterCheckItem()
                        {
                            RegisterCheckId = registerCheck.Id,
                            ItemId = asbitemDetail.ItemId,
                            ResultStatusId = ResultStatusFlag.Normal
                        };
                        newRegisterCheckItems.Add(registerCheckItem);
                    }

                }

                newRegisterChecks.Add(registerCheck);
                registerCheckAsbitem.RegisterCheckId = registerCheck.Id;
            }

            await _registerCheckItemRepository.DeleteManyAsync(deleteRegisterCheckItems);

            await _registerCheckRepository.InsertManyAsync(newRegisterChecks);

            await _registerCheckAsbitemRepository.UpdateManyAsync(updateRegisterCheckAsbitems);
            await _registerCheckItemRepository.InsertManyAsync(newRegisterCheckItems);

        }
        /// <summary>
        /// 检查是否能删除、合并、取消合并
        /// </summary>
        /// <param name="RegisterAsbitemId"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task CheckIsDelete(Guid RegisterAsbitemId)
        {
            var registerAsbitemEnt = await _registerCheckAsbitemRepository.GetAsync(RegisterAsbitemId);
            if (registerAsbitemEnt == null)
                throw new UserFriendlyException($"数据有误");
            if (registerAsbitemEnt.IsCharge == 'Y')
                throw new UserFriendlyException($"当前体检项目已收费，不能操作");
            var registerCheckEnt = await _registerCheckRepository.GetAsync(m => m.Id == registerAsbitemEnt.RegisterCheckId);
            if (registerCheckEnt != null && (registerCheckEnt.CompleteFlag == RegisterCheckCompleteFlag.Checked || registerCheckEnt.CompleteFlag == RegisterCheckCompleteFlag.GiveUpChecked))
                throw new UserFriendlyException($"当前体检项目已完成或者已弃检，不能操作");
        }


        /// <summary>
        /// 检查是否在一个项目类别下
        /// </summary>
        /// <param name="RegisterAsbitemId"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task CheckIsItemType(List<Guid> RegisterAsbitemIds)
        {

            var query = from a in await _registerCheckAsbitemRepository.GetQueryableAsync()
                        join b in await _asbitemRepository.GetQueryableAsync() on a.AsbitemId equals b.Id
                        where RegisterAsbitemIds.Contains(a.Id)
                        group b by b.ItemTypeId;


            var itemTypeCount = query.Count();

            if (itemTypeCount > 1)
            {
                throw new UserFriendlyException($"合并的项目不在一个项目类别内");
            }




        }

    }
}