箱库存名称

This commit is contained in:
tongfei
2023-11-16 16:16:10 +08:00
parent ff6b6fc799
commit ec486c1dbd
4 changed files with 122 additions and 122 deletions

View File

@@ -0,0 +1,718 @@
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 BoxInventoryService : IBoxInventoryService
{
private readonly IMapper _mapper;
private readonly IBoxRepositories _boxRepositories;
private readonly ISerialNumbersRepositories _serialNumbersRepositories;
private readonly IBoxInventoryRepositories _boxInventoryRepositories;
public BoxInventoryService(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();
}
}
}