peis/src/Shentun.Peis.Domain/RegisterAsbitems/RegisterAsbitemManager.cs

using Microsoft.EntityFrameworkCore;
using Shentun.Peis.Enums;
using Shentun.Peis.Models;
using Shentun.Peis.ReferenceRanges;
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 TencentCloud.Ame.V20190916.Models;
using TencentCloud.Iot.V20180123.Models;
using Volo.Abp;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Domain.Services;

namespace Shentun.Peis.RegisterAsbitems
{
    /// <summary>
    /// 检查组合项目记录
    /// </summary>
    public class RegisterAsbitemManager : DomainService
    {
        private readonly IRepository<RegisterAsbitem, Guid> _registerAsbitemRepository;
        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 ReferenceRangeManager _referenceRangeManager;
        private readonly RegisterCheckManager _registerCheckManager;
        private readonly RegisterCheckItemManager _registerCheckItemManager;

        public RegisterAsbitemManager(IRepository<RegisterAsbitem, Guid> registerAsbitemRepository,
            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
            )
        {
            this._registerAsbitemRepository = registerAsbitemRepository;
            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;
        }




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

            var IsregisterAsbitemEnt = await _registerAsbitemRepository.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

              


                RegisterAsbitem entity = new RegisterAsbitem
                {
                    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 _registerAsbitemRepository.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.GetReferenceRangeInSexAgeTemp(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 _registerAsbitemRepository.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)
                            {
                                //有需要合并的数据

                                await MergeRegisterAsbitemAsync(mergerRegisterAsbitemList.Select(s => s.Id).ToList(), OrganizationUnitId);
                            }
                        }
                    }
                }

                #endregion


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


        public async Task<List<RegisterAsbitem>>CreateManyAsync(PatientRegister patientRegister, List<RegisterAsbitem> registerAsbitems)
        {
            if(patientRegister == null)
            {
                throw new UserFriendlyException("patientRegister不能为空");
            } 
            foreach(var registerAsbitem in registerAsbitems)
            {
                registerAsbitem.PatientRegisterId = patientRegister.Id;
                if(registerAsbitem.StandardPrice < 0)
                {
                    throw new UserFriendlyException("标准价格不能小于0");
                }
                if (registerAsbitem.ChargePrice < 0)
                {
                    throw new UserFriendlyException("实收价格不能小于0");
                }

                if (registerAsbitem.Amount < 1)
                {
                    throw new UserFriendlyException("数量不能小于1");
                }
                DataHelper.CheckCharIsYOrN(registerAsbitem.IsCharge,"是否已收费");
                if(registerAsbitem.PayTypeFlag != PayTypeFlag.OrgPay &&
                    registerAsbitem.PayTypeFlag != PayTypeFlag.PersonPay && 
                    registerAsbitem.PayTypeFlag != PayTypeFlag.Free)
                {
                    throw new UserFriendlyException("支付方式类别不存在");
                }
            }
            return new List<RegisterAsbitem>();
        }
        /// <summary>
        ///  删除数据  判断条件（1.只能删除未收费的   2.已完成体检的不能删除）
        /// </summary>
        /// <param name="RegisterAsbitemId"></param>
        /// <returns></returns>
        public async Task DeleteAsync(Guid RegisterAsbitemId)
        {
            var registerAsbitemEnt = await _registerAsbitemRepository.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)
                throw new UserFriendlyException($"当前体检项目已完成，不能删除");

            await _registerAsbitemRepository.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(RegisterAsbitem sourceEntity, RegisterAsbitem 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.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>
        /// 合并组合项目
        /// </summary>
        /// <param name="RegisterAsbitemIds"></param>
        /// <param name="OrganizationUnitId">体检中心ID</param>
        /// <returns></returns>
        public async Task MergeRegisterAsbitemAsync(List<Guid> RegisterAsbitemIds, Guid OrganizationUnitId)
        {

            //原有项目
            var registerAsbitemList = await _registerAsbitemRepository.GetListAsync(m => RegisterAsbitemIds.Contains(m.Id));

            //待删除RegisterCheck
            List<Guid> RegisterCheckIds = registerAsbitemList.GroupBy(g => g.RegisterCheckId.Value).Select(s => s.Key).ToList();

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

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

            #region 重新插入一个新的registerCheck


            //添加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

            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 => registerAsbitemList.Select(s => s.AsbitemId).Contains(m.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.GetReferenceRangeInSexAgeTemp(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
                        };

                        //去重
                        if (!registerCheckItemList.Any() || (registerCheckItemList.Any() && registerCheckItemList.Where(m => m.ItemId == registerCheckItem.ItemId).Count() == 0))
                            registerCheckItemList.Add(registerCheckItem);
                    }


                    await _registerCheckItemRepository.InsertManyAsync(registerCheckItemList);

                }


                #endregion

                registerAsbitemList.ForEach(registerAsbitem => registerAsbitem.RegisterCheckId = registerCheckEnt_Res.Id);
            }




            #endregion
        }


        /// <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)
        {

            //原有项目
            var registerAsbitemList = await _registerAsbitemRepository.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.GetReferenceRangeInSexAgeTemp(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 _registerAsbitemRepository.UpdateManyAsync(registerAsbitemList);
        }


        /// <summary>
        /// 检查是否能删除、合并、取消合并
        /// </summary>
        /// <param name="RegisterAsbitemId"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task CheckIsDelete(Guid RegisterAsbitemId)
        {
            var registerAsbitemEnt = await _registerAsbitemRepository.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 _registerAsbitemRepository.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($"合并的项目不在一个项目类别内");
            }




        }

    }
}