using Admin.NET.Core.Service;
|
using Admin.NET.Application.Entity;
|
using Microsoft.AspNetCore.Http;
|
using System.Data;
|
using System.Web;
|
using System.Text;
|
using Admin.NET.Application.CommonHelper;
|
using System.Linq.Expressions;
|
using Furion.LinqBuilder;
|
using OracleInternal.Sharding;
|
using System;
|
using Furion.DatabaseAccessor;
|
|
namespace Admin.NET.Application;
|
/// <summary>
|
/// 盘点单明细服务
|
/// </summary>
|
[ApiDescriptionSettings(ApplicationConst.WmsInventoryCheckGroupName, Order = 100)]
|
public class WmsInventoryCheckOrderDetailsService : IDynamicApiController, ITransient
|
{
|
private readonly SqlSugarRepository<WmsBaseBusinessType> _wmsBaseBusinessTypeRep;
|
private readonly SqlSugarRepository<WmsInventoryCheckOrderDetails> _wmsInventoryCheckOrderDetailsRep;
|
private readonly SqlSugarRepository<WmsInventoryCheckOrder> _wmsInventoryCheckOrderRep;
|
private readonly SqlSugarRepository<WmsInventoryCheckRange> _wmsInventoryCheckRangeRep;
|
private readonly SqlSugarRepository<WmsInventoryCheckRecord> _wmsInventoryCheckRecord;
|
private readonly SqlSugarRepository<WmsBaseArea> _wmsAreaRep;
|
private readonly SqlSugarRepository<WmsBasePlace> _wmsPlaceRep;
|
private readonly SqlSugarRepository<WmsBaseContainer> _wmsContainerRep;
|
private readonly SqlSugarRepository<WmsContainerPlace> _wmsContainerPlaceRep;
|
private readonly SqlSugarRepository<WmsStockQuan> _wmsStockQuanRep;
|
private readonly SqlSugarRepository<WmsRecordTrans> _wmsRecordTransRep;
|
private readonly SqlSugarRepository<WmsLogAction> _wareActionLogRep;
|
private readonly SqlSugarRepository<v_wms_stock_quan> _v_wms_stock_quanRep;
|
private readonly SqlSugarRepository<WmsTask> _wmsTaskRep;
|
private readonly SqlSugarRepository<WmsStockQuanZero> _wmsStockQuanZeroRep;
|
private readonly UserManager _userManager;
|
private readonly WmsStockQuanService _wmsStockQuanService;
|
|
private readonly SqlSugarRepository<v_wms_inventory_check_order_details_order> _v_wms_inventory_check_order_details_orderRep;
|
public WmsInventoryCheckOrderDetailsService(
|
WmsStockQuanService wmsStockQuanService,
|
SqlSugarRepository<WmsBaseBusinessType> wmsBaseBusinessTypeRep,
|
SqlSugarRepository<WmsInventoryCheckOrderDetails> wmsInventoryCheckOrderDetailsRep,
|
SqlSugarRepository<WmsInventoryCheckOrder> wmsInventoryCheckOrderRep,
|
SqlSugarRepository<WmsInventoryCheckRange> wmsInventoryCheckRangeRep,
|
SqlSugarRepository<WmsInventoryCheckRecord> wmsInventoryCheckRecord,
|
SqlSugarRepository<WmsBaseArea> wmsAreaRep,
|
SqlSugarRepository<WmsBasePlace> wmsPlaceRep,
|
SqlSugarRepository<WmsContainerPlace> wmsContainerPlaceRep,
|
SqlSugarRepository<WmsBaseContainer> wmsContainerRep,
|
SqlSugarRepository<WmsStockQuan> wmsStockQuanRep,
|
SqlSugarRepository<WmsRecordTrans> wmsRecordTransRep,
|
SqlSugarRepository<WmsLogAction> wareActionLogRep,
|
SqlSugarRepository<v_wms_stock_quan> v_wms_stock_quanRep,
|
SqlSugarRepository<WmsTask> wmsTaskRep,
|
SqlSugarRepository<WmsStockQuanZero> wmsStockQuanZeroRep,
|
|
UserManager userManager,
|
SqlSugarRepository<v_wms_inventory_check_order_details_order> v_wms_inventory_check_order_details_orderRep
|
)
|
{
|
|
_wmsStockQuanService = wmsStockQuanService;
|
_wmsBaseBusinessTypeRep = wmsBaseBusinessTypeRep;
|
_wmsInventoryCheckOrderDetailsRep = wmsInventoryCheckOrderDetailsRep;
|
_wmsInventoryCheckOrderRep = wmsInventoryCheckOrderRep;
|
_wmsInventoryCheckRangeRep = wmsInventoryCheckRangeRep;
|
_wmsInventoryCheckRecord = wmsInventoryCheckRecord;
|
_wmsAreaRep = wmsAreaRep;
|
_wmsPlaceRep = wmsPlaceRep;
|
_wmsContainerPlaceRep = wmsContainerPlaceRep;
|
_wmsContainerRep = wmsContainerRep;
|
_wmsStockQuanRep = wmsStockQuanRep;
|
_wmsRecordTransRep = wmsRecordTransRep;
|
_wareActionLogRep = wareActionLogRep;
|
_v_wms_stock_quanRep = v_wms_stock_quanRep;
|
_wmsTaskRep = wmsTaskRep;
|
_wmsStockQuanZeroRep = wmsStockQuanZeroRep;
|
|
_userManager = userManager;
|
_v_wms_inventory_check_order_details_orderRep = v_wms_inventory_check_order_details_orderRep;
|
|
}
|
|
/// <summary>
|
/// 分页查询盘点单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Page")]
|
[Description("WmsInventoryCheckOrderDetails/Page")]
|
public async Task<SqlSugarPagedList<WmsInventoryCheckOrderDetailsOutput>> Page(WmsInventoryCheckOrderDetailsInput input)
|
{
|
var query = CommonPageFilter(input);
|
return await query.OrderBuilder(input, "", "Id").ToPagedListAsync(input.Page, input.PageSize);
|
}
|
|
|
/// <summary>
|
/// 分页查询盘点单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "PDAInventoryQueryAndInsert")]
|
[Description("WmsInventoryCheckOrderDetails/PDAInventoryQueryAndInsert")]
|
[UnitOfWork]
|
public async Task<SqlSugarPagedList<WmsInventoryCheckOrderDetailsOutput>> PDAInventoryQueryAndInsert([FromQuery] WmsInventoryCheckOrderDetailsInput input)
|
{
|
if (input.OrderNo == null) throw Oops.Oh("必须传入盘点单号！");
|
|
if (string.IsNullOrEmpty(input.ContainerCodeAndPlaceCodeForpda) && string.IsNullOrEmpty(input.SNCode))
|
{
|
return null;
|
}
|
|
var InventoryDetailsModel = await _wmsInventoryCheckOrderDetailsRep.AsQueryable()
|
.WhereIF(!string.IsNullOrWhiteSpace(input.OrderNo), u => u.OrderNo.Contains(input.OrderNo.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCodeAndPlaceCodeForpda), u => u.ContainerCode.Contains(input.ContainerCodeAndPlaceCodeForpda.Trim()) ||
|
u.PlaceCode.Contains(input.ContainerCodeAndPlaceCodeForpda.Trim())
|
).FirstAsync();
|
if (InventoryDetailsModel == null)
|
{
|
var orderMain = await _wmsInventoryCheckOrderRep.AsQueryable().FirstAsync(p => p.OrderNo == input.OrderNo);
|
if (orderMain == null) throw Oops.Oh("当前盘点单未找到");
|
|
//设置
|
|
if (string.IsNullOrEmpty(input.ContainerCodeAndPlaceCodeForpda))
|
{
|
throw Oops.Oh("请扫描容器编号或库位");
|
}
|
|
var containerPlaceModel = await _wmsContainerPlaceRep.GetFirstAsync(p => (p.ContainerCode == input.ContainerCodeAndPlaceCodeForpda || p.PlaceCode == input.ContainerCodeAndPlaceCodeForpda));
|
if (containerPlaceModel == null)
|
{
|
throw Oops.Oh($"容器编号或库位'{input.ContainerCodeAndPlaceCodeForpda}'没有找到库位和容器绑定关系");
|
}
|
//查询库区
|
var placeModel = await _wmsPlaceRep.GetFirstAsync(p => p.PlaceCode == containerPlaceModel.PlaceCode);
|
if (placeModel == null) throw Oops.Oh($"库位{containerPlaceModel.PlaceCode}没有找到信息");
|
|
if (string.IsNullOrEmpty(input.SNCode))
|
{
|
return null;
|
}
|
|
var materialModel = await _v_wms_stock_quanRep.AsQueryable().FirstAsync(p => p.SNCode == input.SNCode);
|
if (materialModel == null)
|
{
|
var zeroModel = await _wmsStockQuanService.GetStockBySnCodeIncludeDelete(input.SNCode);
|
if (zeroModel == null) throw Oops.Oh("未找到当前跟踪码" + input.SNCode + "库存信息");
|
var newInventoryCheckDetailsModel = new WmsInventoryCheckOrderDetails()
|
{
|
OrderId = orderMain.Id,
|
OrderNo = input.OrderNo,
|
SNCode = input.SNCode,
|
ContainerCode = containerPlaceModel.ContainerCode,
|
PlaceCode = containerPlaceModel.PlaceCode,
|
PlaceName = containerPlaceModel.PlaceName,
|
AreaCode = placeModel.AreaCode,
|
AreaName = placeModel.AreaName,
|
Batch = zeroModel.Batch,
|
MaterialCode = zeroModel.MaterialCode,
|
MaterialName = zeroModel.MaterialName,
|
Quantity = 0,
|
CheckStatus = CheckStatusEnum.盘点中,
|
CheckStatusName = CheckStatusEnum.盘点中.GetDescription(),
|
CheckResult = CheckResultEnum.未盘,
|
CheckResultName = CheckResultEnum.未盘.GetDescription(),
|
CheckCount = 0,
|
CheckOperatorClassify = CheckOperatorClassifyEnum.初盘,
|
CheckOperatorClassifyName = CheckOperatorClassifyEnum.初盘.GetDescription()
|
};
|
await _wmsInventoryCheckOrderDetailsRep.InsertAsync(newInventoryCheckDetailsModel);
|
}
|
else
|
{
|
var newInventoryCheckDetailsModel = new WmsInventoryCheckOrderDetails()
|
{
|
OrderId = orderMain.Id,
|
OrderNo = input.OrderNo,
|
SNCode = input.SNCode,
|
ContainerCode = containerPlaceModel.ContainerCode,
|
AreaCode = placeModel.AreaCode,
|
AreaName = placeModel.AreaName,
|
PlaceCode = containerPlaceModel.PlaceCode,
|
PlaceName = containerPlaceModel.PlaceName,
|
Batch = materialModel.Batch,
|
MaterialCode = materialModel.MaterialCode,
|
MaterialName = materialModel.MaterialName,
|
Quantity = 0,
|
CheckStatus = CheckStatusEnum.盘点中,
|
CheckStatusName = CheckStatusEnum.盘点中.GetDescription(),
|
CheckResult = CheckResultEnum.未盘,
|
CheckResultName = CheckResultEnum.未盘.GetDescription(),
|
CheckCount = 0,
|
CheckOperatorClassify = CheckOperatorClassifyEnum.初盘,
|
CheckOperatorClassifyName = CheckOperatorClassifyEnum.初盘.GetDescription()
|
};
|
await _wmsInventoryCheckOrderDetailsRep.InsertAsync(newInventoryCheckDetailsModel);
|
}
|
input.SNCode = input.SNCode;
|
var query = CommonPageFilter(input);
|
return await query.OrderBuilder(input, "", "Id").ToPagedListAsync(input.Page, input.PageSize);
|
|
}
|
else
|
{
|
input.SNCode = InventoryDetailsModel.SNCode;
|
input.OrderNo = InventoryDetailsModel.OrderNo;
|
input.ContainerCode = null;
|
input.ContainerCodeAndPlaceCodeForpda = null;
|
var query = CommonPageFilter(input);
|
return await query.OrderBuilder(input, "", "Id").ToPagedListAsync(input.Page, input.PageSize);
|
}
|
|
}
|
|
|
/// <summary>
|
/// 分页查询盘点单明细-pda下发
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "PageForPda")]
|
[Description("WmsInventoryCheckOrderDetails/PageForPda")]
|
public async Task<SqlSugarPagedList<WmsInventoryCheckOrderDetailsOutput>> PageForPda(WmsInventoryCheckOrderDetailsInput input)
|
{
|
/*
|
pda 盘点下发 - 二级明细 - 按照容器编号分组
|
*/
|
var query = await _wmsInventoryCheckOrderDetailsRep.AsQueryable()
|
.WhereIF(!string.IsNullOrWhiteSpace(input.OrderNo), u => u.OrderNo.Contains(input.OrderNo.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCode), u => u.ContainerCode.Contains(input.ContainerCode.Trim()))
|
.WhereIF(input.CheckStatus.HasValue, u => u.CheckStatus == input.CheckStatus)
|
.WhereIF(input.CheckStatus.HasValue, u => u.CheckStatusName == input.CheckStatusName)
|
.WhereIF(input.CheckResult.HasValue, u => u.CheckResult == input.CheckResult)
|
.WhereIF(input.CheckOperatorClassify.HasValue, u => u.CheckOperatorClassify == input.CheckOperatorClassify)
|
.Where(u => u.CheckStatus == CheckStatusEnum.未盘点) //初盘 复盘时 只显示未盘点
|
.Select<WmsInventoryCheckOrderDetailsOutput>().ToListAsync(); ;
|
|
var newList = query.GroupBy(it => new
|
{
|
it.ContainerCode,
|
it.OrderNo,
|
it.CheckStatusName,
|
it.CheckStatus
|
}).Select(s => new
|
{
|
s.Key.ContainerCode,
|
s.Key.OrderNo,
|
s.Key.CheckStatusName,
|
s.Key.CheckStatus
|
}).ToList();
|
|
|
List<WmsInventoryCheckOrderDetailsOutput> resultList = newList.Adapt<List<WmsInventoryCheckOrderDetailsOutput>>();
|
var groupList = resultList.ToPagedList(input.Page, input.PageSize);
|
return groupList;
|
}
|
|
/// <summary>
|
/// 不分页查询盘点单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "List")]
|
[Description("WmsInventoryCheckOrderDetails/List")]
|
public async Task<List<WmsInventoryCheckOrderDetailsOutput>> List([FromQuery] WmsInventoryCheckOrderDetailsInput input)
|
{
|
var query = CommonPageFilter(input);
|
return await query.OrderBuilder(input, "", "Id").Select<WmsInventoryCheckOrderDetailsOutput>().ToListAsync();
|
}
|
|
/// <summary>
|
/// 增加盘点单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Add")]
|
[Description("WmsInventoryCheckOrderDetails/Add")]
|
public async Task<long> Add(AddWmsInventoryCheckOrderDetailsInput input)
|
{
|
var entity = input.Adapt<WmsInventoryCheckOrderDetails>();
|
|
//重复性验证
|
await CheckExist(entity);
|
|
await _wmsInventoryCheckOrderDetailsRep.InsertAsync(entity);
|
return entity.Id;
|
}
|
|
|
/// <summary>
|
/// 初盘开启、复盘开启
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "StartInventoryCheck")]
|
[Description("WmsInventoryCheckOrderDetails/StartInventoryCheck")]
|
public async Task<long> StartInventoryCheck(WmsStartInventoryCheckInput input)
|
{
|
|
/*1.根据盘点单据的ID,获取盘点单和盘点范围
|
*2.根据盘点范围获取所有库存信息、容器信息和库位信息
|
* 2.1库区+物料 获取要盘点的库存信息
|
* 2.2根据库存信息获取容器
|
*3.不判断库位是立体库或平库
|
* 整个容器的所有库存全部锁定，库存状态变为已冻结，赋值记录冻结前的库存状态
|
*4.创建盘点单据明细
|
*4 增加事务记录-业务类型：盘点冻结(未实现)
|
*5 增加操作履历(未实现)
|
*
|
*/
|
|
|
|
List<WmsStockQuan> upadteWmsStockQuanList = new List<WmsStockQuan>();
|
List<WmsRecordTrans> addWmsRecordTransList = new List<WmsRecordTrans>();
|
List<WmsLogAction> addWmsLogActionList = new List<WmsLogAction>();
|
List<WmsInventoryCheckOrderDetails> addWmsInventoryCheckOrderDetailsList = new List<WmsInventoryCheckOrderDetails>();
|
List<WmsInventoryCheckOrderDetails> updateWmsInventoryCheckOrderDetailsList = new List<WmsInventoryCheckOrderDetails>();
|
List<WmsInventoryCheckOrder> updateWmsInventoryCheckOrderList = new List<WmsInventoryCheckOrder>();
|
if (input.OrderId <= 0)
|
{
|
|
throw Oops.Oh("盘点单据ID不能为空！");
|
}
|
|
if (!input.CheckOperatorClassify.HasValue)
|
{
|
|
throw Oops.Oh("盘点操作分类不能为空！");
|
}
|
|
|
CheckOperatorClassifyEnum CheckOperatorClassify = (CheckOperatorClassifyEnum)input.CheckOperatorClassify;
|
CheckStageEnum checkStage = CheckStageEnum.初盘开启;
|
//判断是初盘还是复盘
|
if (CheckOperatorClassify == CheckOperatorClassifyEnum.复盘)
|
{
|
checkStage = CheckStageEnum.复盘开启;
|
}
|
|
//获取盘点单据
|
var inventoryCheckOrder = await _wmsInventoryCheckOrderRep.GetFirstAsync(u => u.Id == input.OrderId && u.IsDelete == false) ?? throw Oops.Oh("盘点单信息不存在！");
|
if (inventoryCheckOrder.CheckStage != CheckStageEnum.新建 && inventoryCheckOrder.CheckStage != CheckStageEnum.初盘已完成)
|
{
|
throw Oops.Oh($"盘点单状态是{inventoryCheckOrder.CheckStage.GetDescription()},不能操作！");
|
}
|
|
|
|
List<string> snCodeList = new List<string>();
|
List<v_wms_stock_quan> check_v_wms_stock_quanList = null;//要盘点的库存视图
|
List<WmsInventoryCheckOrderDetails> checkOrderDetailsList = null;
|
if (CheckOperatorClassify == CheckOperatorClassifyEnum.复盘)
|
{
|
//复盘开启获取可盘点库存校验
|
checkOrderDetailsList = await CheckForFP(input, inventoryCheckOrder, checkOrderDetailsList);
|
|
|
//获取要盘点的库存视图-根据盘点库区的容器和盘点范围的物料获取盘点库存-包含库位信息、库区信息
|
check_v_wms_stock_quanList = await _v_wms_stock_quanRep.GetListAsync(u => checkOrderDetailsList.Select(s => s.SNCode).ToList().Contains(u.SNCode));
|
}
|
else
|
{
|
check_v_wms_stock_quanList = await GetLastCheck_v_wms_stock_quanListForCP(inventoryCheckOrder, check_v_wms_stock_quanList);
|
|
|
//没有获取到盘点库存 不创建盘点单明细，仍然让用户开启盘点
|
|
|
}
|
|
// 校验盘点的容器是否有未完成调度任务的容器、盘点单
|
|
await CheckContainer(inventoryCheckOrder,_v_wms_inventory_check_order_details_orderRep, check_v_wms_stock_quanList);
|
|
//最终可以盘点的容器
|
var lastCheckContainerCodeList = check_v_wms_stock_quanList.Select(s => s.ContainerCode).Distinct().ToList();
|
|
|
////获取盘点容器上所有的库存详情-视图
|
var checkStockQuanViewList = await _v_wms_stock_quanRep.GetListAsync(u => lastCheckContainerCodeList.Contains(u.ContainerCode));
|
////获取盘点容器上所有的库存信息-锁定库存用
|
var checkStockQuanList = await _wmsStockQuanRep.GetListAsync(u => lastCheckContainerCodeList.Contains(u.ContainerCode));
|
|
//获取库位相信
|
var placeCodeList = checkStockQuanViewList.Select(s => s.PlaceCode).Distinct().ToList();
|
var allPlaeList = await _wmsPlaceRep.GetListAsync(u => placeCodeList.Contains(u.PlaceCode) && u.IsDelete == false);
|
|
// 获取业务类型 update by liuwq 2024 07 30
|
BusinessTypeEnum businessTypeEnum = BusinessTypeEnum.盘点冻结;
|
var wmsBaseBusinessType = BusinessTypeHelper.GetBusinessTypeInfoFromDB((int)businessTypeEnum, _wmsBaseBusinessTypeRep);
|
|
string remarks = $"{wmsBaseBusinessType.BusinessTypeName}";
|
|
|
|
//变更盘点单阶段
|
inventoryCheckOrder.CheckStage = checkStage;
|
inventoryCheckOrder.CheckStageName = checkStage.GetDescription();
|
|
//循环库存创建盘点单据明细
|
//初盘新建盘点单据明细
|
foreach (var item in checkStockQuanList)
|
{
|
//获取库存详情-包含库位信息、库区信息
|
var viewStockQuan = checkStockQuanViewList.FirstOrDefault(f => f.SNCode.Equals(item.SNCode));
|
if (viewStockQuan == null)
|
{
|
throw Oops.Oh($"跟踪码{item.SNCode}库存信息不存在");
|
}
|
|
|
|
//冻结库存
|
|
LockInfo freezeInfo = new LockInfo()
|
{
|
LockReason = businessTypeEnum.GetDescription(),
|
LockTime = DateTime.Now,
|
LockUser = _userManager.RealName,//登录人的真实姓名
|
LockStatus = LockStatusEnum.已锁定,//
|
|
};
|
StockQuanHelper.UpdateStockLockStatus(item, freezeInfo);
|
|
|
|
//添加冻结库存集合
|
upadteWmsStockQuanList.Add(item);
|
|
//初盘创建盘点单据明细实体
|
if (CheckOperatorClassify == CheckOperatorClassifyEnum.初盘)
|
{
|
if (check_v_wms_stock_quanList.Select(x => x.MaterialCode).ToList().Contains(item.MaterialCode))
|
{//只有在本次盘点范围的物料才能创建盘点单明细
|
var entityDetails = new WmsInventoryCheckOrderDetails()
|
{
|
OrderId = inventoryCheckOrder.Id,
|
OrderNo = inventoryCheckOrder.OrderNo,
|
AreaCode = viewStockQuan.AreaCode,
|
AreaName = viewStockQuan.AreaName,
|
PlaceCode = viewStockQuan.PlaceCode,
|
PlaceName = viewStockQuan.PlaceName,
|
MaterialCode = item.MaterialCode,
|
MaterialName = item.MaterialName,
|
Quantity = item.Quantity,
|
SNCode = item.SNCode,
|
Batch = item.Batch,
|
CheckOperatorClassify = CheckOperatorClassifyEnum.初盘,
|
CheckOperatorClassifyName = CheckOperatorClassifyEnum.初盘.GetDescription(),
|
CheckCount = 0,
|
ContainerCode = item.ContainerCode,
|
};
|
//盘点状态赋值
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckStatus(entityDetails, CheckStatusEnum.未盘点);
|
//盘点结果赋值
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckResult(entityDetails, CheckResultEnum.未盘);
|
//盘点操作分类
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckOperatorClassify(entityDetails, CheckOperatorClassifyEnum.初盘);
|
//添加盘点单据明细集合
|
addWmsInventoryCheckOrderDetailsList.Add(entityDetails);
|
}
|
}
|
|
|
|
#region 添加事务
|
|
|
|
#region 创建事务日志入参
|
|
|
//获取源库存信息
|
var sourceStockView = StockQuanHelper.GetVMmsStockQuan(checkStockQuanViewList, item.SNCode);
|
|
//update by liuwq 20240730
|
//获取目标库位
|
//开启盘点库存没有变更库位，目标库位还是源库位
|
//调度任务改变库位到盘点区域库位，调度任务添加事务
|
var toPlace = BaseInfoHelper.GetPlace(sourceStockView.PlaceCode, allPlaeList);
|
|
// 其他参数对象
|
TransferOtherDetail transferOtherDetail = new TransferOtherDetail()
|
{
|
RelationNo = inventoryCheckOrder.OrderNo,
|
RelationNoLineNumber = "",
|
Remarks = remarks,
|
|
};
|
#endregion
|
|
|
//新增事务记录
|
//仅变更冻结状态
|
addWmsRecordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(wmsBaseBusinessType, sourceStockView, item, toPlace, transferOtherDetail));
|
|
|
|
addWmsLogActionList.Add(new WmsLogAction()
|
{
|
Title = businessTypeEnum.GetDescription(),
|
Remarks = $"盘点单{inventoryCheckOrder.OrderNo}跟踪码{item.SNCode}"
|
|
});
|
#endregion
|
|
}
|
|
//复盘更新盘点单明细状态
|
if (checkOrderDetailsList?.Count > 0)
|
{
|
foreach (var updateDetails in checkOrderDetailsList)
|
{
|
//复盘更新初盘已完成的盘点单明细
|
|
var item = checkStockQuanList.FirstOrDefault(f => f.SNCode.Equals(updateDetails.SNCode));
|
|
if (item == null)
|
{
|
|
throw Oops.Oh($"盘点单{updateDetails.OrderNo}物料{updateDetails.MaterialCode}跟踪码{item.SNCode}未获取到库存信息");
|
|
}
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckStatus(updateDetails, CheckStatusEnum.未盘点);
|
//盘点结果赋值
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckResult(updateDetails, CheckResultEnum.未盘);
|
//盘点操作分类
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckOperatorClassify(updateDetails, CheckOperatorClassifyEnum.复盘);
|
updateWmsInventoryCheckOrderDetailsList.Add(updateDetails);
|
}
|
}
|
|
|
|
var _tenant = _wmsInventoryCheckOrderRep.AsTenant();
|
try
|
{
|
await _tenant.BeginTranAsync();
|
|
#region 事务内执行操作
|
//更新盘点单
|
await _wmsInventoryCheckOrderRep.UpdateAsync(inventoryCheckOrder);
|
//新增盘点单明细
|
if (addWmsInventoryCheckOrderDetailsList?.Count > 0)
|
{
|
await _wmsInventoryCheckOrderDetailsRep.InsertRangeAsync(addWmsInventoryCheckOrderDetailsList);
|
}
|
|
if (updateWmsInventoryCheckOrderDetailsList?.Count > 0)
|
{
|
await _wmsInventoryCheckOrderDetailsRep.UpdateRangeAsync(updateWmsInventoryCheckOrderDetailsList);
|
}
|
|
await _wmsRecordTransRep.InsertRangeAsync(addWmsRecordTransList);
|
//更新库存
|
|
await _wmsStockQuanRep.UpdateRangeAsync(upadteWmsStockQuanList);
|
|
// 操作日志
|
await _wareActionLogRep.InsertRangeAsync(addWmsLogActionList);
|
|
|
#endregion
|
|
await _tenant.CommitTranAsync();
|
}
|
catch
|
{
|
await _tenant.RollbackTranAsync();
|
throw;
|
}
|
|
return 1;
|
}
|
|
/// <summary>
|
/// 复盘开启获取可盘点库存校验
|
/// </summary>
|
/// <param name="input"></param>
|
/// <param name="inventoryCheckOrder"></param>
|
/// <param name="checkOrderDetailsList"></param>
|
/// <returns></returns>
|
private async Task<List<WmsInventoryCheckOrderDetails>> CheckForFP(WmsStartInventoryCheckInput input, WmsInventoryCheckOrder inventoryCheckOrder, List<WmsInventoryCheckOrderDetails> checkOrderDetailsList)
|
{
|
if (input.DetailsId == null)
|
{
|
throw Oops.Oh("复盘开启明细不能为空！");
|
}
|
if (input.DetailsId.Any(a => a <= 0))
|
{
|
throw Oops.Oh("复盘开启明细ID不能为空！");
|
}
|
|
//获取复盘的明细ID
|
checkOrderDetailsList = await _wmsInventoryCheckOrderDetailsRep.AsQueryable().Where(u => u.OrderId == inventoryCheckOrder.Id && input.DetailsId.Contains(u.Id) && u.IsDelete == false)
|
.Select<WmsInventoryCheckOrderDetails>().ToListAsync();
|
|
if (checkOrderDetailsList?.Count <= 0)
|
{
|
throw Oops.Oh($"盘点单{inventoryCheckOrder.OrderNo}没有获取到可复盘的盘点单明细");
|
}
|
|
if (checkOrderDetailsList.Any(a => a.CheckResult != CheckResultEnum.盘亏 && a.CheckResult != CheckResultEnum.盘盈))
|
{
|
throw Oops.Oh($"存在盘点结果没有差异的盘点单明细");
|
}
|
|
return checkOrderDetailsList;
|
}
|
|
/// <summary>
|
/// 获取初盘可盘点的库存
|
/// </summary>
|
/// <param name="inventoryCheckOrder"></param>
|
/// <param name="check_v_wms_stock_quanList"></param>
|
/// <returns></returns>
|
private async Task<List<v_wms_stock_quan>> GetLastCheck_v_wms_stock_quanListForCP(WmsInventoryCheckOrder inventoryCheckOrder, List<v_wms_stock_quan> check_v_wms_stock_quanList)
|
{
|
List<string> checkAreaCodeList = ParamHelper.GetStringParamToList(inventoryCheckOrder.AreaCode);
|
|
List<string> checkMaterialCodeList = null;
|
//获取盘点范围的物料
|
var rangeList = await _wmsInventoryCheckRangeRep.GetListAsync(u => u.OrderId == inventoryCheckOrder.Id && u.IsDelete == false);
|
if (rangeList?.Count > 0)
|
{
|
checkMaterialCodeList = rangeList.Select(s => s.MaterialCode).ToList();
|
}
|
|
|
|
|
#region 盘点范围
|
//虚拟库区的库存也锁定
|
Expression<Func<v_wms_stock_quan, bool>> predicate = null;
|
|
//获取指定库区库存
|
if (checkAreaCodeList?.Count > 0)
|
{
|
if (predicate == null)
|
{
|
predicate = u => 1 == 1;
|
}
|
//获取盘点指定库区的正常库位库存\非禁用库位库存、非禁用库区库存
|
predicate = predicate.And(u => checkAreaCodeList.Contains(u.AreaCode) && u.PlaceStatus == PlaceStatusEnum.正常 && u.IsDisabledPlace == false && u.IsDisabledArea == false);
|
|
}
|
//获取指定盘点范围的物料
|
if (checkMaterialCodeList?.Count > 0)
|
{
|
if (predicate == null)
|
{
|
predicate = u => 1 == 1;
|
}
|
predicate = predicate.And(u => checkMaterialCodeList.Contains(u.MaterialCode));
|
}
|
|
if (predicate != null)
|
{
|
//虚拟库位库存不盘点
|
predicate = predicate.And(x => x.IsDelete == false && x.IsVirtuallyPlace == false);
|
|
}
|
|
#endregion
|
|
//获取要盘点的库存视图-根据盘点库区的容器和盘点范围的物料获取盘点库存-包含库位信息、库区信息
|
if (predicate == null)
|
{
|
check_v_wms_stock_quanList = new List<v_wms_stock_quan>();
|
}
|
else
|
{
|
check_v_wms_stock_quanList = await _v_wms_stock_quanRep.GetListAsync(predicate);
|
}
|
|
return check_v_wms_stock_quanList;
|
}
|
|
/// <summary>
|
/// 校验盘点的容器是否有未完成调度任务的容器、盘点单
|
/// </summary>
|
/// <param name="checkOrder"></param>
|
/// <param name="_v_wms_inventory_check_order_details_orderRep"></param>
|
/// <param name="check_v_wms_stock_quanList"></param>
|
/// <returns></returns>
|
private async Task CheckContainer(WmsInventoryCheckOrder checkOrder, SqlSugarRepository<v_wms_inventory_check_order_details_order> _v_wms_inventory_check_order_details_orderRep, List<v_wms_stock_quan> check_v_wms_stock_quanList)
|
{
|
//获取盘点的容器
|
var allContainerCodeList = check_v_wms_stock_quanList.Select(s => s.ContainerCode).Distinct().ToList();
|
|
//获取容器未完成的调度任务
|
var activeTaskList = await TaskHelper.GetActiveTaskByContainerCode(allContainerCodeList, _wmsTaskRep);
|
|
//盘点的容器获取未完成的盘点单
|
var notFinishCheckOrderList = await GetNotFinishCheckOrder(checkOrder, _v_wms_inventory_check_order_details_orderRep, allContainerCodeList, _v_wms_stock_quanRep);
|
|
|
foreach (var item in check_v_wms_stock_quanList)
|
{
|
//容器有未完成的调度任务
|
var activeTask = activeTaskList.FirstOrDefault(w => w.ContainerCode == item.ContainerCode);
|
if (activeTask!=null)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}跟踪码{item.SNCode}所在容器{item.ContainerCode}有未完成的调度任务{activeTask.TaskNo}");
|
}
|
|
//容器虽有跟踪码有未完成的盘点单
|
|
var notFinishCheckOrder = notFinishCheckOrderList.FirstOrDefault(w => w.SNCode == item.SNCode);
|
|
if (notFinishCheckOrder!=null)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}跟踪码{item.SNCode}所在容器{item.ContainerCode}有未完成的盘点单{notFinishCheckOrder.OrderNo}");
|
}
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
/// 盘点的容器获取未完成的盘点单
|
/// </summary>
|
/// <param name="checkOrder"></param>
|
/// <param name="_v_wms_inventory_check_order_details_orderRep"></param>
|
/// <param name="containerCodeList"></param>
|
/// <param name="_v_wms_stock_quanRep"></param>
|
/// <returns></returns>
|
private async Task<List<v_wms_inventory_check_order_details_order>> GetNotFinishCheckOrder(WmsInventoryCheckOrder checkOrder, SqlSugarRepository<v_wms_inventory_check_order_details_order> _v_wms_inventory_check_order_details_orderRep, List<string> containerCodeList, SqlSugarRepository<v_wms_stock_quan> _v_wms_stock_quanRep)
|
{
|
//校验盘点单的库区和物料所在容器的 库存 是否存在未完成的盘点单
|
var stockList = await _v_wms_stock_quanRep.GetListAsync(u => containerCodeList.Contains(u.ContainerCode));
|
var snCodeList = stockList.Select(s => s.SNCode).ToList();
|
|
//根据要创建盘点的物料跟踪码获取已创建的未完成的盘点明细-排除当前盘点单
|
List<v_wms_inventory_check_order_details_order> notFinishCheckOrderDetailsList = await _v_wms_inventory_check_order_details_orderRep.
|
GetListAsync(u => snCodeList.Contains(u.SNCode)&&u.OrderId!= checkOrder.Id
|
&& u.CheckStage != CheckStageEnum.已关闭 && u.CheckStage != CheckStageEnum.已取消 && u.CheckStage != CheckStageEnum.已调账);
|
|
|
return notFinishCheckOrderDetailsList;
|
}
|
|
|
|
/// <summary>
|
/// 盘点完成
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "OutFinish")]
|
[Description("WmsInventoryCheckOrderDetails/OutFinish")]
|
public async Task<long> OutFinish(WmsInventoryCheckOutFinishInput input)
|
{
|
|
|
/*
|
* 0.容器存在活跃的调度任务，不能操作
|
* 1.检验单盘点单阶段
|
* 1.1 初盘操作：阶段不是初盘中 不能操作
|
* 1.2 复盘操作：阶段不是复盘中 不能操作
|
*
|
* 3. 循环处理盘点明细
|
* 3.1 校验 盘点的物料跟踪码不在盘点明细中，报错（以后考虑 这种场景的处理）
|
* 3.2 盘点单明细赋值 状态、盘点次数、盘点数量、库存数量、盘点结果
|
* 状态=》已盘点
|
* 盘点次数=》累计
|
* 盘点数量=》实际盘点用户输入的数量
|
* 库存数量=》此时查询到的库存信息的数量
|
* 盘点结果：
|
* 盘点数量>库存数量：盘点结果=》盘盈
|
* 盘点数量<库存数量：盘点结果=》盘亏
|
* 盘点数量=库存数量：盘点结果=》盘平
|
* 4.增加盘点记录
|
* 6 增加操作履历
|
*
|
*/
|
|
List<WmsLogAction> addWmsLogActionList = new List<WmsLogAction>();
|
List<WmsInventoryCheckOrderDetails> updateWmsInventoryCheckOrderDetailsList = new List<WmsInventoryCheckOrderDetails>();
|
List<WmsInventoryCheckOrder> updateWmsInventoryCheckOrderList = new List<WmsInventoryCheckOrder>();
|
List<WmsInventoryCheckRecord> addWmsInventoryCheckRecordList = new List<WmsInventoryCheckRecord>();
|
|
|
#region 校验
|
|
await Check(input);
|
|
var orderId = input.Details[0].OrderId;
|
CheckOperatorClassifyEnum checkOperatorClassify = CheckOperatorClassifyEnum.初盘;
|
//获取盘点单据
|
var inventoryCheckOrder = await _wmsInventoryCheckOrderRep.GetFirstAsync(u => u.Id == orderId && u.IsDelete == false) ?? throw Oops.Oh("盘点单信息不存在！");
|
if (inventoryCheckOrder.CheckStage != CheckStageEnum.初盘中 && inventoryCheckOrder.CheckStage != CheckStageEnum.复盘中)
|
{
|
throw Oops.Oh($"盘点单状态是{inventoryCheckOrder.CheckStage.GetDescription()}不能盘点！");
|
}
|
//判断盘点操作分类是初盘还是复盘
|
if (inventoryCheckOrder.CheckStage == CheckStageEnum.复盘中)
|
{
|
checkOperatorClassify = CheckOperatorClassifyEnum.复盘;
|
}
|
|
|
//获取盘点明细
|
List<WmsInventoryCheckOrderDetails> checkOrderDetailsList = await _wmsInventoryCheckOrderDetailsRep.AsQueryable().Where(u => u.OrderId == inventoryCheckOrder.Id && u.IsDelete == false)
|
.Select<WmsInventoryCheckOrderDetails>().ToListAsync();
|
if (checkOrderDetailsList?.Count <= 0)
|
{
|
throw Oops.Oh($"盘点单{inventoryCheckOrder.OrderNo}没有获取到盘点单明细信息");
|
}
|
|
|
//获取盘点下架容器的所有库存
|
var checkOutStockQuanList = await _v_wms_stock_quanRep.GetListAsync(u => (u.ContainerCode.Equals(input.ContainerCode) || u.PlaceCode.Equals(input.ContainerCode)) && u.IsDelete == false);
|
|
#endregion
|
|
|
|
|
//循环盘点单据明细
|
|
foreach (var item in input.Details)
|
{
|
// 盘点的物料跟踪码不在盘点明细中，报错（以后考虑 这种场景的处理）
|
var checkItem = checkOrderDetailsList.FirstOrDefault(f => f.SNCode.Equals(item.SNCode));
|
if (checkItem == null)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}跟踪码{item.SNCode}不在盘点单明细中");
|
}
|
|
if (checkItem.CheckStatus != CheckStatusEnum.盘点中)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}跟踪码{item.SNCode}盘点单明细状态不是{CheckStatusEnum.盘点中.GetDescription()}");
|
}
|
|
|
////获取当前盘点的库存详情-库位、库区、容器、库存信息
|
//var currentStockQuanView = checkOutStockQuanList.FirstOrDefault(w => w.SNCode == item.SNCode);
|
//if (currentStockQuanView == null)
|
//{
|
// throw Oops.Oh($"盘点单明细物料{currentStockQuanView.MaterialCode}跟踪码{currentStockQuanView.SNCode}库存信息不存在");
|
//}
|
|
|
|
//累计 盘点次数
|
var CheckCount = checkItem.CheckCount ?? 0;
|
CheckCount += 1;
|
if (CheckCount > 2) CheckCount = 2;
|
checkItem.CheckCount = CheckCount;
|
|
|
|
//赋值盘点数量
|
checkItem.CheckQuantity = item.CheckQuantity;
|
//更新最新的库存数量
|
checkItem.Quantity = item.Quantity;
|
//计算盘点结果
|
|
|
if (checkItem.CheckQuantity > checkItem.Quantity)
|
{
|
//盘点数量 > 库存数量：盘点结果 =》盘盈
|
//更新盘点结果
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckResult(checkItem, CheckResultEnum.盘盈);
|
|
}
|
else if (checkItem.CheckQuantity < checkItem.Quantity)
|
{
|
//盘点数量<库存数量：盘点结果=》盘亏
|
//更新盘点结果
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckResult(checkItem, CheckResultEnum.盘亏);
|
|
}
|
else
|
{
|
//更新盘点结果
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckResult(checkItem, CheckResultEnum.盘平);
|
}
|
|
//变更状态
|
OrderHelper.UpdateInventoryCheckOrderDetailsCheckStatus(checkItem, CheckStatusEnum.已盘点);
|
|
updateWmsInventoryCheckOrderDetailsList.Add(checkItem);
|
|
//新增盘点记录
|
|
WmsInventoryCheckRecord addWmsInventoryCheckRecord = new WmsInventoryCheckRecord()
|
{
|
Quantity = checkItem.Quantity,
|
CheckQuantity = checkItem.CheckQuantity,
|
CheckStatus = checkItem.CheckStatus,
|
CheckStatusName = checkItem.CheckStatus.GetDescription(),
|
CheckResult = checkItem.CheckResult,
|
CheckResultName = checkItem.CheckResultName,
|
|
AreaCode = item.AreaCode,
|
AreaName = item.AreaName,
|
PlaceCode = item.PlaceCode,
|
PlaceName = item.PlaceName,
|
Batch = item.Batch,
|
|
ContainerCode = item.ContainerCode,
|
|
MaterialCode = item.MaterialCode,
|
|
MaterialName = item.MaterialName,
|
SNCode = item.SNCode,
|
CheckOperatorClassify = checkOperatorClassify,
|
CheckOperatorClassifyName = checkOperatorClassify.GetDescription(),
|
OrderId = inventoryCheckOrder.Id,
|
OrderNo = inventoryCheckOrder.OrderNo,
|
};
|
addWmsInventoryCheckRecordList.Add(addWmsInventoryCheckRecord);
|
|
}
|
|
|
//创建操作日志
|
|
string title = "盘点单" + inventoryCheckOrder.OrderNo + "容器" + input.ContainerCode + "操作" + BusinessTypeEnum.盘点完成.GetDescription();
|
WmsLogAction addWmsActionLog = LogActionHelper.CreateWmsLogAction(inventoryCheckOrder.Id, title);
|
addWmsLogActionList.Add(addWmsActionLog);
|
|
var _tenant = _wmsInventoryCheckOrderRep.AsTenant();
|
try
|
{
|
await _tenant.BeginTranAsync();
|
|
#region 事务内执行操作
|
//新增盘点记录
|
await _wmsInventoryCheckRecord.InsertRangeAsync(addWmsInventoryCheckRecordList);
|
//更新盘点单明细
|
await _wmsInventoryCheckOrderDetailsRep.UpdateRangeAsync(updateWmsInventoryCheckOrderDetailsList);
|
|
|
//操作日志
|
|
await _wareActionLogRep.InsertAsync(addWmsActionLog);
|
|
|
#endregion
|
|
await _tenant.CommitTranAsync();
|
}
|
catch
|
{
|
await _tenant.RollbackTranAsync();
|
throw;
|
}
|
|
return 1;
|
}
|
|
private async Task Check(WmsInventoryCheckOutFinishInput input)
|
{
|
if (string.IsNullOrWhiteSpace(input.ContainerCode))
|
{
|
throw Oops.Oh("容器编号不能为空");
|
}
|
if (input.Details == null)
|
{
|
throw Oops.Oh("盘点物料不能为空");
|
}
|
if (input.Details.Any(x => x.CheckQuantity < 0))
|
{
|
throw Oops.Oh("盘点数量不能小于0");
|
}
|
//一次只能盘点同一个盘点单据的明细
|
if (input.Details.Select(s => s.OrderId).Distinct().Count() > 1)
|
{
|
throw Oops.Oh("一次盘点只能操作一个盘点单");
|
}
|
|
var container = await _wmsContainerRep.GetFirstAsync(x => x.ContainerCode == input.ContainerCode && x.IsDelete == false);
|
|
|
if (container == null)
|
{
|
var place = await _wmsPlaceRep.GetFirstAsync(x => x.PlaceCode == input.ContainerCode && x.IsDelete == false);
|
|
if (place == null)
|
{
|
|
throw Oops.Oh($"容器\\库位{input.ContainerCode}不存在");
|
}
|
|
}
|
|
//根据容器或库位获取活跃的调度任务
|
var taskList = await TaskHelper.GetActiveTaskByContainerCodeOrPlaceCode(new List<string> { input.ContainerCode }, _wmsTaskRep);
|
|
|
if (taskList?.Count > 0)
|
{
|
throw Oops.Oh($"容器{input.ContainerCode}存在未完成任务不能盘点");
|
}
|
}
|
|
|
|
|
/// <summary>
|
/// 删除盘点单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Delete")]
|
[Description("WmsInventoryCheckOrderDetails/Delete")]
|
public async Task Delete(DeleteWmsInventoryCheckOrderDetailsInput input)
|
{
|
var entity = await _wmsInventoryCheckOrderDetailsRep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
|
//await _rep.FakeDeleteAsync(entity); //假删除
|
await _wmsInventoryCheckOrderDetailsRep.DeleteAsync(entity); //真删除
|
}
|
|
/// <summary>
|
/// 更新盘点单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Update")]
|
[Description("WmsInventoryCheckOrderDetails/Update")]
|
public async Task Update(UpdateWmsInventoryCheckOrderDetailsInput input)
|
{
|
var entity = input.Adapt<WmsInventoryCheckOrderDetails>();
|
|
//重复性验证
|
await CheckExist(entity, true);
|
|
await _wmsInventoryCheckOrderDetailsRep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
|
}
|
|
/// <summary>
|
/// 获取盘点单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "Detail")]
|
[Description("WmsInventoryCheckOrderDetails/Detail")]
|
public async Task<WmsInventoryCheckOrderDetails> Detail([FromQuery] QueryByIdWmsInventoryCheckOrderDetailsInput input)
|
{
|
return await _wmsInventoryCheckOrderDetailsRep.GetFirstAsync(u => u.Id == input.Id);
|
}
|
|
|
|
|
|
|
#region 私有方法
|
|
/// <summary>
|
/// 公共查询盘点单明细条件
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
private ISugarQueryable<WmsInventoryCheckOrderDetailsOutput> CommonPageFilter(WmsInventoryCheckOrderDetailsInput input)
|
{
|
var query = _wmsInventoryCheckOrderDetailsRep.AsQueryable()
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
|
u.OrderNo.Contains(input.SearchKey.Trim())
|
|| u.AreaCode.Contains(input.SearchKey.Trim())
|
|| u.PlaceCode.Contains(input.SearchKey.Trim())
|
|| u.SNCode.Contains(input.SearchKey.Trim())
|
|| u.Batch.Contains(input.SearchKey.Trim())
|
|| u.MaterialCode.Contains(input.SearchKey.Trim())
|
|| u.MaterialName.Contains(input.SearchKey.Trim())
|
|| u.ContainerCode.Contains(input.SearchKey.Trim())
|
|| u.CreateUserName.Contains(input.SearchKey.Trim())
|
|| u.UpdateUserName.Contains(input.SearchKey.Trim())
|
)
|
.WhereIF(!string.IsNullOrWhiteSpace(input.OrderNo), u => u.OrderNo.Contains(input.OrderNo.Trim()))
|
.WhereIF(input.OrderId > 0, u => u.OrderId == input.OrderId) //盘点差异 明细用
|
.WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCodeAndPlaceCodeForpda), u => u.PlaceCode == input.ContainerCodeAndPlaceCodeForpda.Trim() || u.ContainerCode == input.ContainerCodeAndPlaceCodeForpda.Trim()) //ly0724 - pad盘点-容器编号 库位编号查询
|
.WhereIF(!string.IsNullOrWhiteSpace(input.AreaCode), u => u.AreaCode.Contains(input.AreaCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.PlaceCode), u => u.PlaceCode.Contains(input.PlaceCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCode), u => u.ContainerCode.Contains(input.ContainerCode.Trim()))
|
.WhereIF(input.CheckStatus.HasValue, u => u.CheckStatus == input.CheckStatus)
|
.WhereIF(input.CheckResult.HasValue, u => u.CheckResult == input.CheckResult)
|
.WhereIF(input.CheckOperatorClassify.HasValue, u => u.CheckOperatorClassify == input.CheckOperatorClassify)
|
.WhereIF(!string.IsNullOrWhiteSpace(input.CheckSendForpda), u => u.CheckResult != CheckResultEnum.盘平 ) //ly0807-pda盘点下发 - 不显示盘平
|
.Select<WmsInventoryCheckOrderDetailsOutput>();
|
return query;
|
}
|
|
/// <summary>
|
/// 重复性验证
|
/// </summary>
|
/// <param name="input">验证对象</param>
|
/// <param name="isEdit">是否是编辑</param>
|
/// <returns></returns>
|
private async Task CheckExist(WmsInventoryCheckOrderDetails input, bool isEdit = false)
|
{
|
|
|
|
//没有配置组合校验，不需要验重
|
|
|
//没有配置单独校验，不需要验重
|
}
|
|
/// <summary>
|
/// 根据组合校验和单独校验验证数据是否已存在-导入时验证
|
/// </summary>
|
/// <param name="inputs"></param>
|
/// <returns></returns>
|
private async Task CheckExisitForImport(List<WmsInventoryCheckOrderDetails> inputs)
|
{
|
if (inputs?.Count <= 0)
|
{
|
throw Oops.Oh($"导入数据不能为空");
|
}
|
//根据组合校验验证表格中中是否已存在相同数据
|
|
|
|
|
|
|
|
|
//根据单独校验验证表格中中是否已存在相同数据
|
|
|
|
}
|
|
#endregion
|
|
}
|
