using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WMS.Web.Core.Dto.Inventory;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.Entitys;
using WMS.Web.Domain.Infrastructure;
using WMS.Web.Domain.IService;
using WMS.Web.Domain.Values;

namespace WMS.Web.Domain.Services
{
    /// <summary>
    /// 即时库存-服务
    /// </summary>
    public class InventoryService : IInventoryService
    {
        private readonly IMapper _mapper;
        private readonly IBoxRepositories _boxRepositories;
        private readonly ISerialNumbersRepositories _serialNumbersRepositories;
        private readonly IBoxInventoryRepositories _boxInventoryRepositories;
        public InventoryService(IMapper mapper, IBoxRepositories boxRepositories,
            ISerialNumbersRepositories serialNumbersRepositories,
            IBoxInventoryRepositories boxInventoryRepositories)
        {
            _mapper = mapper;
            _boxRepositories = boxRepositories;
            _serialNumbersRepositories = serialNumbersRepositories;
            _boxInventoryRepositories = boxInventoryRepositories;
        }

        /// <summary>
        /// 改箱-箱库存的变更
        /// </summary>
        /// <param name="dtoDatas"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> GenerateChangeBox(List<BoxInventoryChangeGenerateDto> dtoDatas, bool isTransaction)
        {
            //1.判断来源数据是否存在
            if (dtoDatas != null || dtoDatas.Count == 0)
                return Result.ReFailure(ResultCodes.InventoryNoSourceError);

            var update_entitys = new List<BoxInventory>();
            var add_entitys = new List<BoxInventory>();

            var boxIds = dtoDatas.GroupBy(x => x.BoxId).Select(x => x.Key).ToList();
            var targetBoxIds = dtoDatas.GroupBy(x => x.TargetBoxId).Select(x => x.Key).ToList();

            //2.原来箱库存集合
            var sourceBoxInventorys = await _boxInventoryRepositories.GetList(boxIds);

            //2.1目标箱库存集合
            var targetBoxInventorys = await _boxInventoryRepositories.GetList(targetBoxIds);


            foreach (var dto in dtoDatas)
            {
                #region 原箱库存-库存处理
                //2.1找到要改变的源箱数据:备注（原箱号库存一定是存在的）
                var sour = sourceBoxInventorys.Where(x => x.BoxId == dto.BoxId).FirstOrDefault();
                if (sour == null)
                    return Result.ReFailure(ResultCodes.BoxInventoryNoDataError);

                var sour_update_entity = sour;
                sour_update_entity.Details = sour.Details;
                foreach (var dtoItem in dto.Details)
                {
                    //找到原来的箱库存对应要改变的物料:这个一定是存在的，不存在就有问题
                    var sour_ChangeDetail = sour_update_entity.Details.Where(x => x.MaterialId == dtoItem.MaterialId).FirstOrDefault();
                    if(sour_ChangeDetail==null)
                        return Result.ReFailure(ResultCodes.BoxInventoryNoDataError);
                    //箱物料的库存数量不足；小于要拿出来的数量
                    if(sour_ChangeDetail.Qty<dtoItem.Qty)
                        return Result.ReFailure(ResultCodes.BoxInventoryNoInventoryError);
                    //减库存
                    sour_ChangeDetail.Qty = sour_ChangeDetail.Qty - dtoItem.Qty;

                    //再移除要改箱的序列号；最后就是原箱库存的新序列号
                    sour_ChangeDetail.SerialNumbers.RemoveAll(x => dtoItem.SerialNumbers.Contains(x));

                }
                update_entitys.Add(sour_update_entity);
                #endregion

                #region 目标箱库存-库存处理
                //2.2找到要改变的目标箱数据：备注（目标箱库存可能不存在库存，就要新增）
                var tagBox = targetBoxInventorys.Where(x => x.BoxId == dto.TargetBoxId).FirstOrDefault();                
                if (tagBox == null)
                {
                    var newTagBox = new BoxInventory();
                    newTagBox.BoxId = dto.TargetBoxId;
                    newTagBox.Details =_mapper.Map<List<BoxInventoryDetails>>(dto.Details);
                    add_entitys.Add(newTagBox);
                }
                else
                {
                    var tag_update_entity = tagBox;
                    tag_update_entity.Details = tagBox.Details;
                    //2.2.1遍历改变的明细
                    foreach (var item in dto.Details)
                    {
                        //2.2.2找到目标箱对应要改变的物料
                        var tagChangeDetail = tag_update_entity.Details.Where(x => x.MaterialId == item.MaterialId).FirstOrDefault();
                        if (tagChangeDetail != null)
                        {                          
                            tagChangeDetail.Qty = tagChangeDetail.Qty + item.Qty;
                            tagChangeDetail.SerialNumbers.AddRange(item.SerialNumbers);
                        }//2.3.没有对应的箱物料，就新增明细
                        else 
                        {
                            var newTagChangeDetail = new BoxInventoryDetails();
                            newTagChangeDetail.MaterialId = item.MaterialId;
                            newTagChangeDetail.Qty = item.Qty;
                            newTagChangeDetail.SerialNumbers = item.SerialNumbers;
                            tag_update_entity.Details.Add(newTagChangeDetail);
                        }
                    }                    
                    update_entitys.Add(tag_update_entity);

                }
                #endregion
            }

            var isSuccess = true;
            //4.数据库更新操作:更新和添加
            if (add_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (update_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.UpdateRange(update_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }

            return Result.ReSuccess();
        }

        /// <summary>
        /// 移箱-箱库存的变更
        /// </summary>
        /// <param name="dtoDatas"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> GenerateMoveBox(List<BoxInventoryMoveGenerateDto> dtoDatas, bool isTransaction) 
        {
            //1.判断来源数据是否存在
            if (dtoDatas != null || dtoDatas.Count == 0)
                return Result.ReFailure(ResultCodes.InventoryNoSourceError);

            var delete_entitys = new List<BoxInventory>();
            var add_entitys = new List<BoxInventory>();

            //2.获取“箱库存集合”和“箱基本信息集合”
            var boxIds = dtoDatas.GroupBy(x => x.BoxId).Select(x => x.Key).ToList();           
            var boxInventorys = await _boxInventoryRepositories.GetList(boxIds);
            var boxs= await _boxRepositories.GetEntityList(boxIds);
            var serialNumbers = await _serialNumbersRepositories.GetEntityListByBoxIds(boxIds);

            //3.遍历：dto
            foreach (var dto in dtoDatas)
            {
                //上架
                if (dto.InventoryInOutType==(int)InventoryInOutType.In)
                {
                    //3.1上架的时候：箱一定是不存在于箱库存当中的，有则返回提示“已有箱库存，不需要再扫上架”
                    var ishave = boxInventorys.Where(x => x.BoxId == dto.BoxId).Any();
                    if (ishave)
                        return Result.ReFailure(ResultCodes.BoxInventoryHaveInventoryError);
                    //3.1.1取箱信息
                    var box = boxs.Where(x => x.Id == dto.BoxId).FirstOrDefault();
                    if (box == null)
                        return Result.ReFailure(ResultCodes.BoxNoData);
                    //3.1.2去箱对应的序列号信息
                    var box_serialNumbers = serialNumbers.Where(x => x.BoxId == dto.BoxId).Select(x=>new { x.MaterialId,x.SerialNumber}).ToList();                   

                    //3.2组装要新增的箱库存信息：箱和明细
                    var addEntity = _mapper.Map<BoxInventory>(dto);
                    addEntity.Details = _mapper.Map<List<BoxInventoryDetails>>(box.Details);

                    //3.3组装要新增的箱库存：明细中的序列号
                    foreach (var item in addEntity.Details)
                    {
                        var box_serialNub = box_serialNumbers.Where(x => x.MaterialId == item.MaterialId).FirstOrDefault();
                        if (box_serialNub != null)
                            item.SerialNumbers.Add(box_serialNub.SerialNumber);
                    }
                    add_entitys.Add(addEntity);

                }//下架
                else 
                {
                    //3.1下架的时候：箱一定是存在于箱库存当中的，没有则返回提示“箱不存在于库存，请扫其它箱”
                    var ishave = boxInventorys.Where(x => x.BoxId == dto.BoxId).Any();
                    if (!ishave)
                        return Result.ReFailure(ResultCodes.BoxInventoryNoDataError);

                    //3.2整箱移货下架-直接删除当前箱子所在的库存
                    var box_inventory= boxInventorys.Where(x => x.BoxId == dto.BoxId).FirstOrDefault();
                    delete_entitys.Add(box_inventory);
                }
            }

            var isSuccess = true;
            //4.数据库操作处理
            if (add_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.AddRange(add_entitys, isTransaction);
                if(!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (delete_entitys.Count != 0)
            {
                var delete_ids = add_entitys.Select(x => x.Id).ToList();
                isSuccess = await _boxInventoryRepositories.DeleteRange(delete_ids,isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            return Result.ReSuccess();
        }

        /// <summary>
        /// 入库回退上下架-箱库存的变更
        /// </summary>
        /// <param name="dtoDatas"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> GenerateBackBox(List<BoxInventoryBackGenerateDto> dtoDatas, bool isTransaction) 
        {
            //1.判断来源数据是否存在
            if (dtoDatas != null || dtoDatas.Count == 0)
                return Result.ReFailure(ResultCodes.InventoryNoSourceError);

            var update_entitys = new List<BoxInventory>();
            var add_entitys = new List<BoxInventory>();

            //2.获取“箱库存集合”
            var boxIds = dtoDatas.GroupBy(x => x.BoxId).Select(x => x.Key).ToList();
            var boxInventorys = await _boxInventoryRepositories.GetList(boxIds);
            var boxs = await _boxRepositories.GetEntityList(boxIds);
            var serialNumbers = await _serialNumbersRepositories.GetEntityListByBoxIds(boxIds);
            //3.遍历：dto
            foreach (var dto in dtoDatas)
            {
                //上架
                if (dto.InventoryInOutType == (int)InventoryInOutType.In)
                {
                    //3.1上架的时候：箱一定是不存在于箱库存当中的，有则返回提示“已有箱库存，不需要再扫上架”
                    var ishave = boxInventorys.Where(x => x.BoxId == dto.BoxId).Any();
                    if (ishave)
                        return Result.ReFailure(ResultCodes.BoxInventoryHaveInventoryError);
                    //3.1.1取箱信息
                    var box = boxs.Where(x => x.Id == dto.BoxId).FirstOrDefault();
                    if (box == null)
                        return Result.ReFailure(ResultCodes.BoxNoData);
                    //3.1.2去箱对应的序列号信息
                    var box_serialNumbers = serialNumbers.Where(x => x.BoxId == dto.BoxId).Select(x => new { x.MaterialId, x.SerialNumber }).ToList();

                    //3.2组装要新增的箱库存信息：箱和明细和序列号
                    var addEntity = _mapper.Map<BoxInventory>(dto);
                    addEntity.Details = _mapper.Map<List<BoxInventoryDetails>>(box.Details);

                    add_entitys.Add(addEntity);


                }//下架
                else 
                {
                    //3.1下架的时候：箱一定是存在于箱库存当中的，没有则返回提示“箱不存在于库存，请扫其它箱”
                    var boxInventory = boxInventorys.Where(x => x.BoxId == dto.BoxId).FirstOrDefault();
                    if (boxInventory==null)
                        return Result.ReFailure(ResultCodes.BoxInventoryNoDataError);
                    //3.2创建更新对象
                    var update_entity = boxInventory;
                    update_entity.Details = boxInventory.Details;

                    //3.3遍历dto明细
                    foreach (var dtoItem in dto.Details)
                    {
                        //找到原来的箱库存对应要改变的物料:这个一定是存在的，不存在就有问题
                        var updateDetail = update_entity.Details.Where(x => x.MaterialId == dtoItem.MaterialId).FirstOrDefault();
                        if (updateDetail == null)
                            return Result.ReFailure(ResultCodes.BoxInventoryNoDataError);
                        //箱物料的库存数量不足；小于要拿出来的数量
                        if (updateDetail.Qty < dtoItem.Qty)
                            return Result.ReFailure(ResultCodes.BoxInventoryNoInventoryError);

                        updateDetail.Qty = updateDetail.Qty - dtoItem.Qty;
                        //再移除要改箱的序列号；最后就是原箱库存的新序列号
                        updateDetail.SerialNumbers.RemoveAll(x => dtoItem.SerialNumbers.Contains(x));
                    }
                    update_entitys.Add(update_entity);
                }
            }

            var isSuccess = true;
            //4.数据库更新操作:更新和添加
            if (add_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (update_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.UpdateRange(update_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            return Result.ReSuccess();
        }

        /// <summary>
        /// 采购上架-箱库存变更--这个有点问题--请使用HandlBoxInventory
        /// </summary>
        /// <param name="dtoDatas"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> GeneratePurchaseBox(List<BoxInventoryPurchaseGenerateDto> dtoDatas, bool isTransaction) 
        {
            //1.判断来源数据是否存在
            if (dtoDatas != null || dtoDatas.Count == 0)
                return Result.ReFailure(ResultCodes.InventoryNoSourceError);

            var add_entitys = new List<BoxInventory>();

            //1.1通过箱IDS获取箱库存-正常情况下“采购上架”，箱对应的库存是没有的，这里是为了下一步的判断，防止错误数据进入箱库存里面
            var boxIds = dtoDatas.SelectMany(x => x.BoxIds).ToList();
            var boxInventorys = await _boxInventoryRepositories.GetList(boxIds);

            //2.遍历：dto
            foreach (var dto in dtoDatas) 
            {
                //3.1上架的时候：箱一定是不存在于箱库存当中的，有则返回提示“已有箱库存，不需要再扫上架”
                var ishave = dto.BoxIds.All(x => boxInventorys.Any(t => t.BoxId == x));////代码意义：当前dto中的BoxIds是否全部等于箱库存中的boxId;dto中有一个boxID不等于箱库存中的，就失败
                if (ishave)
                    return Result.ReFailure(ResultCodes.BoxInventoryHaveInventoryError);

                //3.2组装要新增的箱库存信息：箱和明细和序列号
                var addEntity = _mapper.Map<BoxInventory>(dto);
                addEntity.Details = _mapper.Map<List<BoxInventoryDetails>>(dto.Details);
                add_entitys.Add(addEntity);
            }

            var isSuccess = true;
            //4.数据库更新操作:更新和添加
            if (add_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            return Result.ReSuccess();
        }

        /// <summary>
        /// 非采购上架-箱库存变更--这个有点问题--请使用HandlBoxInventory
        /// </summary>
        /// <param name="dtoDatas"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> GenerateNoPurchaseBox(List<BoxInventoryNoPurchaseGenerateDto> dtoDatas, bool isTransaction) 
        {
            //1.判断来源数据是否存在
            if (dtoDatas != null || dtoDatas.Count == 0)
                return Result.ReFailure(ResultCodes.InventoryNoSourceError);

            var add_entitys = new List<BoxInventory>();
            var update_entitys = new List<BoxInventory>();

            //1.1通过箱IDS获取箱库存-正常情况下“采购上架”，箱对应的库存是没有的，这里是为了下一步的判断，防止错误数据进入箱库存里面
            var boxIds = dtoDatas.SelectMany(x => x.BoxIds).ToList();
            var boxInventorys = await _boxInventoryRepositories.GetList(boxIds);

            //2.遍历：dto
            foreach (var dto in dtoDatas)
            {
                //按箱上架
                if (dto.InventoryInOutMethod == (int)InventoryInOutMethod.Box)
                {
                    //3.1上架的时候：箱一定是不存在于箱库存当中的，有则返回提示“已有箱库存，不需要再扫上架”
                    var isAllTrueHave = dto.BoxIds.All(x => boxInventorys.Any(t => t.BoxId == x));//代码意义：当前dto中的BoxIds是否全部等于箱库存中的boxId;dto中有一个boxID不等于箱库存中的，就失败
                    if (isAllTrueHave)
                        return Result.ReFailure(ResultCodes.BoxInventoryHaveInventoryError);

                    //3.2组装要新增的箱库存信息：箱和明细和序列号
                    var addEntity = _mapper.Map<BoxInventory>(dto);
                    addEntity.Details = _mapper.Map<List<BoxInventoryDetails>>(dto.Details);
                    add_entitys.Add(addEntity);
                }
                //按产品上架：
                else 
                {
                    //按产品上架：箱只能是一个；箱可能存在库存（修改），也可能不存在库存（新增）
                    var boxInventory = boxInventorys.Where(x => x.BoxId == dto.BoxIds.First()).FirstOrDefault();
                    if (boxInventory == null)
                    {
                        //3.2组装要新增的箱库存信息：箱和明细和序列号
                        var addEntity = _mapper.Map<BoxInventory>(dto);
                        addEntity.Details = _mapper.Map<List<BoxInventoryDetails>>(dto.Details);
                        add_entitys.Add(addEntity);
                    }
                    else 
                    {
                        //3.3创建更新对象
                        var update_entity = boxInventory;
                        update_entity.Details = boxInventory.Details;
                        foreach (var dtoItem in dto.Details)
                        {
                            //明细对应的物料：存在就修改，不存在即新增
                            var update_entity_det = new BoxInventoryDetails();
                            var updateDetail = update_entity.Details.Where(x => x.MaterialId == dtoItem.MaterialId).FirstOrDefault();
                            if (updateDetail == null)
                            {
                                update_entity_det.Qty = dtoItem.Qty;
                                update_entity_det.MaterialId = dtoItem.MaterialId;
                                update_entity_det.SerialNumbers = dtoItem.SerialNumbers;
                                update_entity.Details.Add(update_entity_det);
                            }
                            else
                            {
                                updateDetail.Qty = updateDetail.Qty + dtoItem.Qty;
                                updateDetail.SerialNumbers.AddRange(dtoItem.SerialNumbers);
                            }
                        }
                        update_entitys.Add(update_entity);
                    }
                }
            }

            var isSuccess = true;
            //4.数据库更新操作:更新和添加
            if (add_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (update_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.UpdateRange(update_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            return Result.ReSuccess();
        }

        /// <summary>
        /// 出库下架-箱库存变更--这个有点问题--请使用HandlBoxInventory
        /// </summary>
        /// <param name="dtoDatas"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> GenerateOutStockBox(List<BoxInventoryOutStockGenerateDto> dtoDatas, bool isTransaction)
        {
            //1.判断来源数据是否存在
            if (dtoDatas != null || dtoDatas.Count == 0)
                return Result.ReFailure(ResultCodes.InventoryNoSourceError);

            var delete_entitys_ids = new List<int>();
            var update_entitys = new List<BoxInventory>();

            //1.1通过箱IDS获取箱库存
            var boxIds = dtoDatas.Select(x => x.BoxId).ToList();
            var boxInventorys = await _boxInventoryRepositories.GetList(boxIds);

            //2.遍历：dto
            foreach (var dto in dtoDatas) 
            {
                //3.1出库的时候：箱一定是存在于箱库存当中的，没有则返回提示“箱库存数据不存在，请稍候再试！”
                //   获取箱库存
                var boxInventory = boxInventorys.Where(x => x.BoxId == dto.BoxId).FirstOrDefault();
                if (boxInventory==null)
                    return Result.ReFailure(ResultCodes.BoxInventoryNoDataError);

                //按箱：出库
                if (dto.InventoryInOutMethod == (int)InventoryInOutMethod.Box)
                {
                    //直接添加要删除的箱
                    delete_entitys_ids.Add(boxInventory.Id);
                }
                //按产品：出库
                else 
                {
                    //3.3创建更新对象
                    var update_entity = boxInventory;
                    update_entity.Details = boxInventory.Details;

                    //3.2.遍历：dto明细
                    foreach (var dtoItem in dto.Details)
                    {
                        //3.3.找到当前明细物料：没有则返回失败；提示：“该箱物料库存不存在”
                        var update_entityDetail = update_entity.Details.Where(x => x.MaterialId == dtoItem.MaterialId).FirstOrDefault();
                        if (update_entityDetail == null)
                            return Result.ReFailure(ResultCodes.BoxInventoryMaterialNoDataError);
                        //3.4判断库存数量是否不足
                        if (update_entityDetail.Qty < dtoItem.Qty)
                            return Result.ReFailure(ResultCodes.BoxInventoryNoInventoryError);

                        //3.5物料库存数量变更：减库存
                        update_entityDetail.Qty = update_entityDetail.Qty - dtoItem.Qty;
                        //3.6移除要出库的序列号
                        update_entityDetail.SerialNumbers.RemoveAll(x => dtoItem.SerialNumbers.Contains(x));

                    }
                    //4.1判断要修改的箱库存对象：是否所有的物料库存的数量都为0，“是”则删除该箱库存,"否"则修改；
                    var isAllNoInventory = update_entity.Details.All(x => x.Qty == 0);
                    if (isAllNoInventory)
                        delete_entitys_ids.Add(update_entity.Id);
                    else
                        //4.2添加要更新的箱库存实体
                        update_entitys.Add(update_entity);
                }
                
            }

            //4.数据库更新操作:更新和删除
            var isSuccess = true;
            if (delete_entitys_ids.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.DeleteRange(delete_entitys_ids, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (update_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.UpdateRange(update_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            return Result.ReSuccess();
        }




        /// <summary>
        /// 处理箱库存变更：出入库
        /// </summary>
        /// <param name="dtoDatas"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> HandlBoxInventory(List<BoxInventoryGenerateDto> dtoDatas, bool isTransaction) 
        {
            //1.判断来源数据是否存在
            if (dtoDatas != null || dtoDatas.Count == 0)
                return Result.ReFailure(ResultCodes.InventoryNoSourceError);

            var delete_ids = new List<int>();
            var update_entitys = new List<BoxInventory>();
            var add_entitys = new List<BoxInventory>();

            //1.1通过箱IDS获取箱库存
            var boxIds = dtoDatas.Select(x => x.BoxId).ToList();
            var boxInventorys = await _boxInventoryRepositories.GetList(boxIds);

            //2.遍历：dto
            foreach (var dto in dtoDatas)
            {
                //出库
                if (dto.InventoryInOutType == (int)InventoryInOutType.Out)
                {
                    //生成出库对象：删除和修改
                    var outStockInventoryResult = this.GenerateOutStockBox(dto, boxInventorys, delete_ids, update_entitys);
                    if (!outStockInventoryResult.IsSuccess)
                        return outStockInventoryResult;
                }
                //入库
                else 
                {
                    //生成入库对象：新增和修改
                    var inStockInventoryResult = this.GenerateInStockBox(dto, boxInventorys, add_entitys, update_entitys);
                    if (!inStockInventoryResult.IsSuccess)
                        return inStockInventoryResult;
                }

            }

            //4.数据库更新操作:更新和删除和添加
            var isSuccess = true;
            if (delete_ids.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.DeleteRange(delete_ids, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (add_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            if (update_entitys.Count != 0)
            {
                isSuccess = await _boxInventoryRepositories.UpdateRange(update_entitys, isTransaction);
                if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);
            }
            return Result.ReSuccess();
        }

        /// <summary>
        /// 生成出库对象：删除和修改
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="boxInventorys"></param>
        /// <param name="delete_ids"></param>
        /// <param name="update_entitys"></param>
        /// <returns></returns>
        public Result GenerateOutStockBox(BoxInventoryGenerateDto dto,List<BoxInventory> boxInventorys,List<int> delete_ids, List<BoxInventory> update_entitys) 
        {
            //3.1出库的时候：箱一定是存在于箱库存当中的，没有则返回提示“箱库存数据不存在，请稍候再试！”
            //   获取箱库存
            var boxInventory = boxInventorys.Where(x => x.BoxId == dto.BoxId).FirstOrDefault();
            if (boxInventory == null)
                return Result.ReFailure(ResultCodes.BoxInventoryNoDataError);

            //按箱：出库
            if (dto.InventoryInOutMethod == (int)InventoryInOutMethod.Box)
            {
                //直接添加要删除的箱
                delete_ids.Add(boxInventory.Id);
            }
            //按产品：出库
            else
            {
                //3.3创建更新对象
                var update_entity = boxInventory;
                update_entity.Details = boxInventory.Details;

                //3.2.遍历：dto明细
                foreach (var dtoItem in dto.Details)
                {
                    //3.3.找到当前明细物料：没有则返回失败；提示：“该箱物料库存不存在”
                    var update_entityDetail = update_entity.Details.Where(x => x.MaterialId == dtoItem.MaterialId).FirstOrDefault();
                    if (update_entityDetail == null)
                        return Result.ReFailure(ResultCodes.BoxInventoryMaterialNoDataError);
                    //3.4判断库存数量是否不足
                    if (update_entityDetail.Qty < dtoItem.Qty)
                        return Result.ReFailure(ResultCodes.BoxInventoryNoInventoryError);

                    //3.5物料库存数量变更：减库存
                    update_entityDetail.Qty = update_entityDetail.Qty - dtoItem.Qty;
                    //3.6移除要出库的序列号
                    update_entityDetail.SerialNumbers.RemoveAll(x => dtoItem.SerialNumbers.Contains(x));

                }
                //4.1判断要修改的箱库存对象：是否所有的物料库存的数量都为0，“是”则删除该箱库存,"否"则修改；
                var isAllNoInventory = update_entity.Details.All(x => x.Qty == 0);
                if (isAllNoInventory)
                    delete_ids.Add(update_entity.Id);
                else
                    //4.2添加要更新的箱库存实体
                    update_entitys.Add(update_entity);
            }

            return Result.ReSuccess();
        }

        /// <summary>
        /// 生成入库对象：新增和修改
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="boxInventorys"></param>
        /// <param name="add_entitys"></param>
        /// <param name="update_entitys"></param>
        /// <returns></returns>
        public Result GenerateInStockBox(BoxInventoryGenerateDto dto, List<BoxInventory> boxInventorys, List<BoxInventory> add_entitys, List<BoxInventory> update_entitys) 
        {
            //按箱上架入库
            if (dto.InventoryInOutMethod == (int)InventoryInOutMethod.Box)
            {
                //3.1上架的时候：箱一定是不存在于箱库存当中的，有则返回提示“已有箱库存，不需要再扫上架”
                var isHave = boxInventorys.Where(x=>x.BoxId==dto.BoxId).Any();
                if (isHave)
                    return Result.ReFailure(ResultCodes.BoxInventoryHaveInventoryError);

                //3.2组装要新增的箱库存信息：箱和明细和序列号
                var addEntity = _mapper.Map<BoxInventory>(dto);
                addEntity.Details = _mapper.Map<List<BoxInventoryDetails>>(dto.Details);
                add_entitys.Add(addEntity);
            }
            //按产品上架入库
            else
            {
                //按产品上架：箱只能是一个；箱可能存在库存（修改），也可能不存在库存（新增）
                var boxInventory = boxInventorys.Where(x => x.BoxId == dto.BoxId).FirstOrDefault();
                if (boxInventory == null)
                {
                    //3.2组装要新增的箱库存信息：箱和明细和序列号
                    var addEntity = _mapper.Map<BoxInventory>(dto);
                    addEntity.Details = _mapper.Map<List<BoxInventoryDetails>>(dto.Details);
                    add_entitys.Add(addEntity);
                }
                else
                {
                    //3.3创建更新对象
                    var update_entity = boxInventory;
                    update_entity.Details = boxInventory.Details;
                    foreach (var dtoItem in dto.Details)
                    {
                        //明细对应的物料：存在就修改，不存在即新增
                        var update_entity_det = new BoxInventoryDetails();
                        var updateDetail = update_entity.Details.Where(x => x.MaterialId == dtoItem.MaterialId).FirstOrDefault();
                        if (updateDetail == null)
                        {
                            update_entity_det.Qty = dtoItem.Qty;
                            update_entity_det.MaterialId = dtoItem.MaterialId;
                            update_entity_det.SerialNumbers = dtoItem.SerialNumbers;
                            update_entity.Details.Add(update_entity_det);
                        }
                        else
                        {
                            updateDetail.Qty = updateDetail.Qty + dtoItem.Qty;
                            updateDetail.SerialNumbers.AddRange(dtoItem.SerialNumbers);
                        }
                    }
                    update_entitys.Add(update_entity);
                }
            }

            return Result.ReSuccess();
        }
    }
}