using Admin.NET.Core.Service;
|
using Admin.NET.Application.Entity;
|
using Microsoft.AspNetCore.Http;
|
using Admin.NET.Application;
|
using StackExchange.Redis;
|
using System.Linq.Expressions;
|
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
|
using Qiniu.Storage;
|
using Mapster;
|
using Elastic.Clients.Elasticsearch;
|
using Furion.DatabaseAccessor;
|
using static SKIT.FlurlHttpClient.Wechat.Api.Models.ChannelsECMerchantAddFreightTemplateRequest.Types.FreightTemplate.Types;
|
using System.ComponentModel;
|
using static SKIT.FlurlHttpClient.Wechat.Api.Models.ChannelsECLogisticsEWaybillOrderCreateRequest.Types;
|
using NewLife.Security;
|
using Admin.NET.Application.CommonHelper;
|
using DocumentFormat.OpenXml.Office2013.Word;
|
using Newtonsoft.Json;
|
|
namespace Admin.NET.Application;
|
/// <summary>
|
/// 收货服务
|
/// </summary>
|
[ApiDescriptionSettings(ApplicationConst.WmsOperationsGroupName, Order = 100)]
|
public class ReceivingProcessService : IDynamicApiController, ITransient
|
{
|
private readonly SysFileService _sysFileService;
|
private readonly SqlSugarRepository<WmsRecordReceivingDelivery> _wareConfirmDeliveryRep;
|
private readonly SqlSugarRepository<SysDictData> _sysDictDataRep;
|
private readonly SqlSugarRepository<SysDictType> _sysDictTypeRep;
|
private readonly WmsOrderPurchaseService _wmsOrderPurchaseService;
|
private readonly SqlSugarRepository<WmsStockQuan> _wmsContainerMaterial;
|
private readonly SqlSugarRepository<WmsRecordTrans> _wmsRecordTransRep;
|
private readonly SqlSugarRepository<WmsContainerPlace> _wmsContainerPlaceRep;
|
private readonly SqlSugarRepository<WmsLogAction> _wareActionLogRep;
|
private readonly SqlSugarRepository<SysConfig> _sysConfigRep;
|
|
private readonly SqlSugarRepository<WmsOrderAsn> _wmsOrderAsnrep;
|
private readonly SqlSugarRepository<WmsOrderAsnDetails> _wmsOrderAsnDetailsRep;
|
|
private readonly SqlSugarRepository<WmsOrderPurchase> _wmsOrderPurchase;
|
private readonly SqlSugarRepository<WmsOrderPurchaseDetails> _wmsOrderPurchaseDetails;
|
|
private readonly SqlSugarRepository<WmsBaseMaterial> _wmsMaterialRep;
|
|
private readonly SqlSugarRepository<WmsBaseContainer> _wmsContainerRep;
|
private readonly SqlSugarRepository<WmsBaseArea> _wmsAreaRep;
|
private readonly SqlSugarRepository<WmsBasePlace> _wmsPlaceRep;
|
|
private readonly SqlSugarRepository<WmsOrderQc> _wmsQcRep;
|
private readonly SqlSugarRepository<WmsOrderQcDetails> _wmsQcDetailsRep;
|
private readonly SysConfigService _sysConfigService;
|
private readonly SqlSugarRepository<WmsBaseUnit> _wmsUnitRep;
|
private readonly SqlSugarRepository<WmsBaseBatchRule> _wmsBatchRuleDetailRep;
|
private readonly SqlSugarRepository<WmsConfigSerialSN> _repSNRep;
|
private readonly SqlSugarRepository<WmsConfigNoRule> _WmsNoCreateRuleRep;
|
private readonly SqlSugarRepository<WmsBaseBusinessType> _wmsBaseBusinessType;
|
|
public ReceivingProcessService(
|
SysFileService sysFileService,
|
SqlSugarRepository<WmsRecordReceivingDelivery> wareConfirmDeliveryRep,
|
SqlSugarRepository<SysDictData> sysDictDataRep,
|
SqlSugarRepository<SysDictType> sysDictTypeRep,
|
SqlSugarRepository<WmsStockQuan> wmsContainerMaterial,
|
WmsOrderPurchaseService wmsOrderPurchaseService,
|
SqlSugarRepository<WmsRecordTrans> wmsRecordTransRep,
|
SqlSugarRepository<WmsContainerPlace> wmsContainerPlaceRep,
|
SqlSugarRepository<WmsLogAction> wareActionLogRep,
|
SqlSugarRepository<WmsOrderAsn> wmsOrderAsnrep,
|
SqlSugarRepository<WmsOrderAsnDetails> wmsOrderAsnDetailsRep,
|
SqlSugarRepository<WmsOrderPurchase> wmsOrderPurchase,
|
SqlSugarRepository<WmsOrderPurchaseDetails> wmsOrderPurchaseDetails,
|
SqlSugarRepository<WmsBaseMaterial> wmsMaterialRep,
|
SqlSugarRepository<WmsBaseContainer> wmsContainerRep,
|
SqlSugarRepository<WmsBaseArea> wmsAreaRep,
|
SqlSugarRepository<WmsBasePlace> wmsPlaceRep,
|
SqlSugarRepository<WmsOrderQc> wmsQcRep,
|
SqlSugarRepository<WmsOrderQcDetails> wmsQcDetailsRep,
|
SqlSugarRepository<WmsBaseUnit> wmsUnitRep,
|
SqlSugarRepository<WmsBaseBatchRule> wmsBatchRuleDetailRep,
|
SysConfigService sysConfigService,
|
SqlSugarRepository<WmsConfigSerialSN> repSNRep,
|
SqlSugarRepository<WmsConfigNoRule> wmsNoCreateRuleRep,
|
SqlSugarRepository<WmsBaseBusinessType> wmsBaseBusinessType,
|
SqlSugarRepository<SysConfig> sysConfigRep
|
)
|
{
|
_sysFileService = sysFileService;
|
_wareConfirmDeliveryRep = wareConfirmDeliveryRep;
|
_sysDictDataRep = sysDictDataRep;
|
_sysDictTypeRep = sysDictTypeRep;
|
_wmsContainerMaterial = wmsContainerMaterial;
|
_wmsRecordTransRep = wmsRecordTransRep;
|
_wmsContainerPlaceRep = wmsContainerPlaceRep;
|
_wareActionLogRep = wareActionLogRep;
|
_wmsOrderAsnrep = wmsOrderAsnrep;
|
_wmsOrderAsnDetailsRep = wmsOrderAsnDetailsRep;
|
_wmsOrderPurchase = wmsOrderPurchase;
|
_wmsOrderPurchaseDetails = wmsOrderPurchaseDetails;
|
_wmsMaterialRep = wmsMaterialRep;
|
_wmsContainerRep = wmsContainerRep;
|
_wmsAreaRep = wmsAreaRep;
|
_wmsPlaceRep = wmsPlaceRep;
|
_wmsQcRep = wmsQcRep;
|
_wmsQcDetailsRep = wmsQcDetailsRep;
|
_sysConfigService = sysConfigService;
|
_wmsUnitRep = wmsUnitRep;
|
_wmsBatchRuleDetailRep = wmsBatchRuleDetailRep;
|
_repSNRep = repSNRep;
|
_WmsNoCreateRuleRep = wmsNoCreateRuleRep;
|
_wmsBaseBusinessType = wmsBaseBusinessType;
|
_wmsOrderPurchaseService = wmsOrderPurchaseService;
|
_sysConfigRep = sysConfigRep;
|
}
|
|
#region ASN单PDA收货
|
|
/// <summary>
|
/// ASN单PDA收货
|
/// </summary>
|
/// <param name="sourceinput"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Add")]
|
[Description("/receivingProcess/addDelivery")]
|
public async Task<long> AddDelivery(List<ReceivingProcessInput> sourceinput)
|
{
|
/*
|
* 1、获取asn单和明细
|
* 2.验证asn单明细和收货入参
|
* 3.SN码校验库存是否已存在
|
* 4.是否需要质检
|
* 4.1 质检进入待检区
|
* 4.2 不质检直接进收货区
|
* 4.新增库存 --
|
* 4.1 绑定容器和库位（收货容器、收货库位）
|
* 5.获取PO单和明细
|
* 6.更新po单和明细
|
* 7.插入收货记录
|
* 8.插入事务记录
|
* 9.操作日志
|
*/
|
|
|
List<ReceivingProcessInput> input = new List<ReceivingProcessInput>();
|
|
|
#region 校验
|
if (sourceinput?.Count == 0)
|
{
|
throw Oops.Oh("入参不能为空");
|
}
|
//if (sourceinput.Select(s=>s.OrderAsnDetailsId).Distinct().Count()>1)
|
//{
|
// throw Oops.Oh("本次收货的ASN单明细重复");
|
//}
|
|
|
var isExist = sourceinput.Exists(x => x.PDAReceivingActionType == null);
|
if (isExist)
|
{
|
throw Oops.Oh("PDA收货操作类型不能为空");
|
}
|
|
isExist = sourceinput.Exists(x => x.UncollectedQuantity <= 0);
|
if (isExist)
|
{
|
throw Oops.Oh("收货数量必须大于0");
|
}
|
|
|
//只存在前绑定收货
|
PDAReceivingActionTypeEnum pDAReceivingActionType = PDAReceivingActionTypeEnum.前绑定;
|
|
|
//TODO 批次规则验证
|
//TODO ERP库存地验证
|
|
//获取本次收货的ASN单明细
|
List<long> asndetailsIds = sourceinput.Select(s => s.OrderAsnDetailsId).ToList();
|
var receivingOrderAsndetails = await _wmsOrderAsnDetailsRep.AsQueryable().Where(u => asndetailsIds.Contains(u.Id)).ToListAsync();
|
if (receivingOrderAsndetails?.Count == 0)
|
{
|
throw Oops.Oh("本次收货的ASN单明细不存在");
|
}
|
|
//获取收货的ASN单
|
List<long> orderAsnIds = receivingOrderAsndetails.Select(s => s.AsnId).Distinct().ToList();
|
//判断
|
if (orderAsnIds.Count() > 1) throw Oops.Oh("不可同时下发不同ASN单！");
|
List<WmsOrderAsn> orderAsnList = await _wmsOrderAsnrep.AsQueryable().Where(u => orderAsnIds.Contains(u.Id)).ToListAsync();
|
if (orderAsnList?.Count == 0)
|
{
|
throw Oops.Oh("本次收货的ASN单不存在");
|
}
|
|
|
|
//获取全部的ASN单明细
|
var orderAsndetails = await _wmsOrderAsnDetailsRep.AsQueryable().Where(u => orderAsnIds.Contains(u.AsnId)).ToListAsync();
|
if (orderAsndetails?.Count == 0)
|
{
|
throw Oops.Oh("ASN单明细不存在");
|
}
|
//获取po单信息
|
List<string> poNoList = orderAsndetails.Where(w => !string.IsNullOrWhiteSpace(w.PoNo)).Select(u => u.PoNo).ToList();
|
List<WmsOrderPurchaseDetails> orderPurchaseDetailsList = null;
|
List<WmsOrderPurchase> orderPurchaseList = null;
|
if (poNoList?.Count > 0)
|
{
|
orderPurchaseDetailsList = await _wmsOrderPurchaseDetails.AsQueryable().Where(u => poNoList.Contains(u.PoNo) && u.IsDelete == false).ToListAsync();
|
orderPurchaseList = await _wmsOrderPurchase.AsQueryable().Where(u => poNoList.Contains(u.PurchaseNo) && u.IsDelete == false).ToListAsync();
|
|
}
|
|
//此处感觉没用了？？？？？？
|
////获取收货区、待检区库区、容器和库位信息
|
//List<string> toContainerCodeList = new List<string>()
|
//{
|
// OperationsContainerEnum.STAGING.ToString()//收货区容器
|
//};
|
//List<string> toPlaceCodeList = new List<string>()
|
//{
|
// OperationsPlaceEnum.STAGING.ToString()//收货区库位
|
//};
|
|
////收货区、待检区库位信息
|
//var toContainerList = await _wmsContainerRep.GetListAsync(x => toContainerCodeList.Contains(x.ContainerCode) && x.IsDelete == false);
|
////收货区、待检区容器信息
|
//var toPlaceList = await _wmsPlaceRep.GetListAsync(x => toPlaceCodeList.Contains(x.PlaceCode) && x.IsDelete == false);
|
////收货区、待检区库区信息
|
//var toAreaList = await _wmsAreaRep.GetListAsync(x => toPlaceList.Select(s => s.AreaId).Contains(x.Id) && x.IsDelete == false);
|
|
|
//获取所有要收货的物料基础数据
|
List<string> materialCodeList = orderAsndetails.Select(s => s.MaterialCode).ToList();
|
var wmsMaterialList = await _wmsMaterialRep.AsQueryable().Where(u => materialCodeList.Contains(u.MaterialCode)).Select<WmsMaterialOutput>().ToListAsync();
|
if (wmsMaterialList?.Count == 0)
|
{
|
throw Oops.Oh("物料基础数据不存在");
|
}
|
|
|
//获取批次规则
|
List<string> batchCodes = wmsMaterialList.Select(s => s.BatchRuleCode).ToList();
|
List<WmsBaseBatchRule> allWmsBatchRuleDetailList = null;
|
if (batchCodes?.Count > 0)
|
{
|
allWmsBatchRuleDetailList = await _wmsBatchRuleDetailRep.GetListAsync(u => batchCodes.Contains(u.RuleCode) && u.IsDisabled == false && u.IsDelete == false);
|
}
|
|
|
//获取收货物料所有采购单位信息
|
List<string> toPOUnitList = wmsMaterialList.Select(s => s.POUnit).Distinct().ToList();//
|
//获取收货物料所有库存单位信息
|
List<string> toMaterialUnitList = wmsMaterialList.Select(s => s.MaterialUnit).Distinct().ToList();
|
List<string> allUnitKeyList = new List<string>();
|
allUnitKeyList.AddRange(toPOUnitList);
|
allUnitKeyList.AddRange(toMaterialUnitList);
|
allUnitKeyList = allUnitKeyList.Distinct().ToList();
|
//所有的收货查询的物料单位信息
|
var allUnitList = await _wmsUnitRep.AsQueryable().Where(u => allUnitKeyList.Contains(u.UnitCode)).ToListAsync();
|
|
//验证入参相关的单据是否合法
|
ValidateInput(sourceinput, pDAReceivingActionType, orderAsndetails, orderAsnList, orderPurchaseDetailsList, orderPurchaseList, wmsMaterialList, allWmsBatchRuleDetailList);
|
|
|
//前绑定收货 根据SnCode获取库存信息
|
List<WmsStockQuan> allSnCodeContainerVsMaterialList = null;
|
//if (pDAReceivingActionType == PDAReceivingActionTypeEnum.前绑定)
|
//{
|
// List<string> sn1dCodeList = orderAsndetails.Where(w => !string.IsNullOrWhiteSpace(w.SN_1d)).Select(u => u.SN_1d).ToList();
|
// List<string> sn2dCodeList = orderAsndetails.Where(w => !string.IsNullOrWhiteSpace(w.SN_2d)).Select(u => u.SN_2d).ToList();
|
// allSnCodeContainerVsMaterialList = await _wmsContainerMaterial.GetListAsync(x => (sn1dCodeList.Contains(x.SNCode) || sn2dCodeList.Contains(x.SNCode)) && x.IsDelete == false);
|
//}
|
List<string> sn1dCodeList = orderAsndetails.Where(w => !string.IsNullOrWhiteSpace(w.SN_1d)).Select(u => u.SN_1d).ToList();
|
List<string> sn2dCodeList = orderAsndetails.Where(w => !string.IsNullOrWhiteSpace(w.SN_2d)).Select(u => u.SN_2d).ToList();
|
allSnCodeContainerVsMaterialList = await _wmsContainerMaterial.GetListAsync(x => (sn1dCodeList.Contains(x.SNCode) || sn2dCodeList.Contains(x.SNCode)) && x.IsDelete == false);
|
|
|
#endregion
|
|
List<WmsStockQuan> addWmsContainerMaterialList = new List<WmsStockQuan>();
|
List<WmsContainerPlace> addWmsContainerPlaceList = new List<WmsContainerPlace>();
|
|
List<WmsRecordTrans> addWmsRecordTransList = new List<WmsRecordTrans>();
|
List<WmsRecordReceivingDelivery> addWareConfirmDeliveryList = new List<WmsRecordReceivingDelivery>();
|
List<WmsLogAction> addWareActionLogList = new List<WmsLogAction>();
|
|
List<WmsOrderPurchaseDetails> updateWmsOrderPurchaseDetails = new List<WmsOrderPurchaseDetails>();
|
List<WmsOrderPurchase> updateWmsOrderPurchaseList = new List<WmsOrderPurchase>();
|
List<WmsOrderAsn> updateWmsOrderAsnList = new List<WmsOrderAsn>();
|
List<WmsOrderAsnDetails> updateWmsOrderAsnDetails = new List<WmsOrderAsnDetails>();
|
|
|
#region 循环处理收货
|
|
|
//string erpVoucher = Yitter.IdGenerator.YitIdHelper.NextId().ToString();//对接ERP 收货凭证号 推送erp系统成功后赋值
|
|
|
|
//ly - 0806 ERP库存地动态收货
|
var toAreaListFromErp = await _wmsAreaRep.GetListAsync(x => orderAsndetails.Select(s => s.ErpCode).Contains(x.ErpCode) && x.IsDelete == false);
|
var toPlaceListFromErp = await _wmsPlaceRep.GetListAsync(x => toAreaListFromErp.Select(s => s.AreaCode).Contains(x.AreaCode) && x.IsDelete == false);
|
var toContainerListFromErp = await _wmsContainerRep.GetListAsync(x => toPlaceListFromErp.Select(s => s.PlaceCode).Contains(x.ContainerCode) && x.IsDelete == false);
|
//ly - 0806
|
|
foreach (var receivingItem in sourceinput)
|
{
|
|
//获取当前ASN单明细
|
var currentAsnDetails = orderAsndetails.FirstOrDefault(f => f.Id == receivingItem.OrderAsnDetailsId);
|
|
//isUsedPo = true 表示使用PO单，isUsedPo = false 表示不使用PO单
|
//如果使用PO单，则验证PO单和明细
|
bool isUsedPo = false;
|
if (!string.IsNullOrWhiteSpace(currentAsnDetails.PoNo) && !string.IsNullOrWhiteSpace(currentAsnDetails.PoLineNumber))
|
{
|
isUsedPo = true;
|
}
|
|
//获取当前ASN单
|
var currentAsn = orderAsnList.FirstOrDefault(f => f.Id == currentAsnDetails.AsnId);
|
//处理动态字段
|
string _materialCode = currentAsnDetails.MaterialCode;
|
|
|
|
//获取SnCode跟踪码
|
//前绑定收货，跟踪码从ASN单明细获取
|
//后绑定收货，跟踪码自定义，暂时使用SN_+ 雪花ID
|
string snCode = GetSNCode(pDAReceivingActionType, currentAsnDetails);
|
|
//if (pDAReceivingActionType == PDAReceivingActionTypeEnum.前绑定)
|
//{
|
// //跟踪码获取库存
|
// WmsStockQuan containerVsMaterial = allSnCodeContainerVsMaterialList.FirstOrDefault(x => x.SNCode == snCode && x.IsDelete == false);
|
// //验证SNCode是否重复创建库存
|
// if (containerVsMaterial != null)
|
// {
|
// throw Oops.Oh($"SN码{snCode}库存已存在");
|
// }
|
//}
|
|
//跟踪码获取库存
|
WmsStockQuan containerVsMaterial = allSnCodeContainerVsMaterialList.FirstOrDefault(x => x.SNCode == snCode && x.IsDelete == false);
|
//验证SNCode是否重复创建库存
|
if (containerVsMaterial != null)
|
{
|
throw Oops.Oh($"SN码{snCode}库存已存在");
|
}
|
|
//获取当前收货物料的物料基础信息
|
var materialBaseInfo = wmsMaterialList.FirstOrDefault(f => f.MaterialCode == _materialCode);
|
|
decimal currentQuantity = receivingItem.UncollectedQuantity;//当前收的根据物料库存单位转换的库存数
|
|
decimal currentPoQuantity = (decimal)receivingItem.POQuantity;//当前收的根据物料采购单位转换的采购数
|
|
|
var needGoodQty = currentAsnDetails.Quantity - currentAsnDetails.GoodsQuantity;
|
|
if (needGoodQty < currentQuantity)
|
{
|
throw Oops.Oh(_materialCode + $" : 收货数{currentQuantity}不能超过ASN单剩余可收货数{needGoodQty}");
|
}
|
|
//更新ASN单明细
|
currentAsnDetails.GoodsQuantity += currentQuantity;//累计的ASN单的收货数 是 采购数
|
OrderHelper.UpdateOrderAsnDetailsStatus(currentAsnDetails);
|
|
updateWmsOrderAsnDetails.Add(currentAsnDetails);
|
|
|
//如果ASN单明细关联PO,就更新PO明细
|
WmsOrderPurchaseDetails currentPurchaseDetails = null;
|
if (isUsedPo)
|
{
|
//更新PO单明细
|
currentPurchaseDetails = orderPurchaseDetailsList.FirstOrDefault(f => f.PoNo == currentAsnDetails.PoNo && f.MaterialCode == currentAsnDetails.MaterialCode && f.PoLineNumber == currentAsnDetails.PoLineNumber);
|
currentPurchaseDetails.GoodsQuantity += currentPoQuantity;//累计的PO单的收货数 是 采购数
|
OrderHelper.UpdateOrderPurchaseDetailsStatus(currentPurchaseDetails);
|
updateWmsOrderPurchaseDetails.Add(currentPurchaseDetails);
|
}
|
|
|
#region 物料质检逻辑
|
var toPlace = "";
|
var toContainer = "";
|
StockQcStatusEnum setCheckStatus = default(StockQcStatusEnum);
|
StockStatusEnum setStockStatusEnum = default(StockStatusEnum);
|
|
//------------------ly-0806
|
|
////默认收货区容器 （不管是否需要质检，都在收货区）
|
//toContainer = OperationsContainerEnum.STAGING.ToString();
|
////默认收货区库位
|
//toPlace = OperationsPlaceEnum.STAGING.ToString();
|
|
//ly-0806 收货时，根据 ASN单上的erp库存地，寻找同名库区下的 top1 收货库位类型的库位，作为 收货库位,如果找不到，就报错。提示 用户要建立 相应的库区和库位
|
if (String.IsNullOrEmpty(currentAsnDetails.ErpCode))
|
{
|
throw Oops.Oh($"单号{currentAsnDetails.AsnNo}物料{currentAsnDetails.MaterialCode}行号{currentAsnDetails.AsnLineNumber}Erp库存地不存在，不能收货");
|
}
|
|
var getAreaErpItem = toAreaListFromErp.FirstOrDefault(x => currentAsnDetails.ErpCode ==x.ErpCode && x.IsDelete == false);
|
if (getAreaErpItem == null)
|
{
|
throw Oops.Oh($"ERP库存地是{currentAsnDetails.ErpCode}的库区不存在");
|
}
|
|
var getPlaceErpItem = toPlaceListFromErp.FirstOrDefault(x => getAreaErpItem.AreaCode == x.AreaCode && x.PlaceType ==PlaceTypeEnum.收货库位 && x.IsVirtually ==true && x.IsDelete == false);
|
if (getPlaceErpItem == null)
|
{
|
throw Oops.Oh($"在库区{getAreaErpItem.AreaCode}中，虚拟收货库位不存在！");
|
}
|
|
//一个库区 只能有一个 虚拟的收货库位
|
var ShPlaceList = toPlaceListFromErp.Where(x => getAreaErpItem.AreaCode == x.AreaCode && x.PlaceType == PlaceTypeEnum.收货库位 && x.IsVirtually == true && x.IsDelete == false).ToList();
|
if (ShPlaceList.Count > 1)
|
{
|
throw Oops.Oh($"库区{getAreaErpItem.AreaCode}中存在{ShPlaceList.Count}个虚拟的收货库位！");
|
}
|
//收货库位和收货容器要同名
|
var getContainerErpItem = toContainerListFromErp.FirstOrDefault(x => getPlaceErpItem.PlaceCode == x.ContainerCode && x.IsVirtually == true && x.IsDelete == false);
|
if (getContainerErpItem == null)
|
{
|
throw Oops.Oh($"库区{getAreaErpItem.AreaCode} 库位{getPlaceErpItem.PlaceCode}中不存在虚拟容器{getPlaceErpItem.PlaceCode}");
|
}
|
|
toPlace = getPlaceErpItem.PlaceCode;
|
toContainer = getContainerErpItem.ContainerCode;
|
|
if (toPlace == null || toContainer == null)
|
{
|
throw Oops.Oh($"目标库区 目标库位不能为空");
|
}
|
//-------------ly-0806
|
|
|
|
|
if (materialBaseInfo.IsCheck == true)//需要质检
|
{
|
|
//库存质检状态赋值
|
setCheckStatus = StockQcStatusEnum.待检;
|
//库存状态赋值
|
setStockStatusEnum = StockStatusEnum.待质检;
|
}
|
else//免检
|
{
|
|
//库存质检状态赋值
|
setCheckStatus = StockQcStatusEnum.合格;
|
//库存状态赋值
|
setStockStatusEnum = StockStatusEnum.待上架;
|
|
}
|
|
#endregion
|
|
//根据批次规则生成批次号
|
|
var batchRuleDetailsList = allWmsBatchRuleDetailList.Where(u => u.RuleCode == materialBaseInfo.BatchRuleCode).ToList();
|
|
string batchNo = BatchRuleHelper.GetBatch(currentAsnDetails, materialBaseInfo, batchRuleDetailsList);
|
|
#region 获取上架的 库位、库区、容器数据信息
|
|
//查询上架的容器信息
|
WmsBaseContainer toContainerInfo = await BaseInfoHelper.GetContainer(toContainer, _wmsContainerRep);
|
|
// 查询上架的库位信息
|
WmsBasePlace toPlaceInfo = await BaseInfoHelper.GetPlace(toPlace, _wmsPlaceRep);
|
|
//查询上架的库区信息
|
WmsBaseArea toAreaInfo = await BaseInfoHelper.GetAreaByPlace(toPlaceInfo, _wmsAreaRep);
|
#endregion
|
|
|
#region 新增库存、事务记录、收货记录、操作日志
|
|
string actionTitle = $"PDA{PDAReceivingActionTypeEnum.前绑定.ToString()}收货";//操作履历标题
|
//获取业务类型
|
var businessTypeInfo = BusinessTypeHelper.GetBusinessTypeInfoFromDB(currentAsn.BusinessType, _wmsBaseBusinessType);
|
|
//新增库存
|
WmsStockQuan addStockQuan = CreateWmsContainerMaterial(batchNo, materialBaseInfo, allUnitList, receivingItem, currentAsnDetails, snCode, setCheckStatus, setStockStatusEnum, toContainerInfo, toPlaceInfo, toAreaInfo);
|
|
|
|
//创建事务的入参
|
#region 创建事务的入参
|
TransferOtherDetail transferOtherDetail = new TransferOtherDetail()
|
{
|
RelationNo = currentAsnDetails.AsnNo,
|
RelationNoLineNumber = currentAsnDetails.AsnLineNumber,
|
Remarks = $"ASN单{currentAsnDetails.AsnNo}{currentAsn.BusinessTypeName}"
|
|
};
|
|
#endregion
|
|
//新增事务记录
|
//新增的库存源信息都是空
|
|
addWmsRecordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(businessTypeInfo, null, addStockQuan, toPlaceInfo, transferOtherDetail));
|
|
//新增收货记录
|
WmsRecordReceivingDelivery addRecordReceivingDelivery = CreateWareConfirmDelivery(batchNo, pDAReceivingActionType, receivingItem, currentAsn, currentAsnDetails, snCode, currentPurchaseDetails);
|
addRecordReceivingDelivery.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
//判断是否需要记录收货适配器记录，并推送Erp
|
var sysConfigModel = await _sysConfigRep.AsQueryable().FirstAsync(p => p.Id == 573736595685445);
|
if (sysConfigModel.Value == "True")
|
{
|
var receivingAdapterLogsInput = new ReceivingAdapterLogsInput();
|
receivingAdapterLogsInput.OPOrderReceivingAdapterAdd = sourceinput;
|
receivingAdapterLogsInput.KeyCode = addRecordReceivingDelivery.Id;
|
await _wmsOrderPurchaseService.ReceivingAdapterLogs(receivingAdapterLogsInput);
|
}
|
//新增操作日志
|
WmsLogAction wareActionLog = LogActionHelper.CreateWmsLogAction(currentAsnDetails.Id, actionTitle, $"跟踪码{snCode}");
|
|
addWareConfirmDeliveryList.Add(addRecordReceivingDelivery);
|
|
addWmsContainerMaterialList.Add(addStockQuan);
|
addWareActionLogList.Add(wareActionLog);
|
#endregion
|
|
|
}
|
|
#endregion
|
|
|
//处理ANS单
|
|
if (orderAsnList.Count > 0)
|
{
|
foreach (var item in orderAsnList)
|
{
|
var updateOrderAsndetails = orderAsndetails.Where(w => w.AsnId == item.Id).ToList();
|
////计算 ASN单的状态和总已收货数
|
OrderHelper.UpdateWmsOrderAsnStatus(orderAsndetails, item);
|
updateWmsOrderAsnList.Add(item);
|
}
|
}
|
|
|
|
// 处理PO单
|
if (orderPurchaseList?.Count > 0)
|
{
|
foreach (var item in orderPurchaseList)
|
{
|
var updatePurchaseDetails = orderPurchaseDetailsList.Where(w => w.PoId == item.Id).ToList();
|
|
////计算 PO单的状态 和总已收货数
|
OrderHelper.UpdatOrderPurchaseStatus(updatePurchaseDetails, item);
|
updateWmsOrderPurchaseList.Add(item);
|
}
|
}
|
|
//创建报检单
|
WmsQcInfoByReceiving wmsQcInfoByReceiving = await CreateWmsQc(addWmsContainerMaterialList, orderAsndetails, addWmsRecordTransList);
|
|
var _tenant = _wmsContainerMaterial.AsTenant();
|
try
|
{
|
await _tenant.BeginTranAsync();
|
|
#region 事务内执行操作
|
//新增库存
|
await _wmsContainerMaterial.InsertRangeAsync(addWmsContainerMaterialList);
|
await _wmsContainerPlaceRep.InsertRangeAsync(addWmsContainerPlaceList);
|
//更新ASN单
|
await _wmsOrderAsnDetailsRep.UpdateRangeAsync(updateWmsOrderAsnDetails);
|
await _wmsOrderAsnrep.UpdateRangeAsync(updateWmsOrderAsnList);
|
//更新PO单
|
await _wmsOrderPurchaseDetails.UpdateRangeAsync(updateWmsOrderPurchaseDetails);
|
await _wmsOrderPurchase.UpdateRangeAsync(updateWmsOrderPurchaseList);
|
|
//新增事务记录、收货记录、操作日志
|
await _wareActionLogRep.InsertRangeAsync(addWareActionLogList);
|
await _wareConfirmDeliveryRep.InsertRangeAsync(addWareConfirmDeliveryList);
|
await _wmsRecordTransRep.InsertRangeAsync(addWmsRecordTransList);
|
|
if (wmsQcInfoByReceiving != null)
|
{
|
await _wmsQcRep.InsertAsync(wmsQcInfoByReceiving.wmsQc);
|
await _wmsQcDetailsRep.InsertRangeAsync(wmsQcInfoByReceiving.wmsQcDetails);
|
}
|
|
#endregion
|
|
await _tenant.CommitTranAsync();
|
}
|
catch
|
{
|
await _tenant.RollbackTranAsync();
|
throw;
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
//public async Task ReceivingAdapterLogs(ReceivingAdapterLogsInput input)
|
//{
|
// var getAdapterModel = await _repAdapterManagement.AsQueryable().FirstAsync(p => p.AdapterMethodName.Contains("PO单接收"));
|
// string OrderADapter = JsonConvert.SerializeObject(wcsInput.OPOrderAdapterAdd);
|
// string Message = JsonConvert.SerializeObject(wcsInput.AdapterReturnMassageObject);
|
// //插入一条记录，初始化记录的时候一定要先将记录变成未处理
|
// if (getAdapterModel == null) throw Oops.Oh("当前接口地址不正确，未找到相应适配器");
|
// var newRecordAdapter = new RecordAdapter()
|
// {
|
// AdapterCategoryId = getAdapterModel.AdapterCategoryId,
|
// AdapterName = getAdapterModel.AdapterName,
|
// CategoryName = getAdapterModel.CategoryName,
|
// AdapterId = getAdapterModel.Id,
|
// AdapterMethodName = getAdapterModel.AdapterMethodName,
|
// RequestSoure = "CC",
|
// AdapterSID = wcsInput.SID,
|
// BeginTime = DateTime.Now,
|
// DealWithStatus = AdapterLogDealWithEnum.未处理,
|
// ErrMessage = wcsInput.AdapterReturnMassageObject.Message,
|
// // ErrMessage = wcsInput.ErrMessage == null ? "" : wcsInput.ErrMessage,
|
// AdapterInput = OrderADapter,
|
// AdapterReturnMassage = Message,
|
// OrderNo = wcsInput.AdapterReturnMassageObject.Result.ToString()
|
// };
|
// await _repRecordAdapter.InsertAsync(newRecordAdapter);
|
//}
|
|
/// <summary>
|
/// 创建报检单
|
/// </summary>
|
/// <param name="addWmsContainerMaterialList"></param>
|
/// <param name="wmsOrderAsnDetails"></param>
|
/// <param name="addRecordTransList"></param>
|
/// <returns></returns>
|
private async Task<WmsQcInfoByReceiving> CreateWmsQc(List<WmsStockQuan> addWmsContainerMaterialList, List<WmsOrderAsnDetails> wmsOrderAsnDetails, List<WmsRecordTrans> addRecordTransList)
|
{
|
//新增表头
|
|
//系统配置 收货是否创建报检单
|
var addQCOrder = await _sysConfigService.GetConfigValue<bool>(CommonConst.SysAddQCOrder);
|
if (addQCOrder != true)
|
{
|
return null;
|
}
|
var checkList = addWmsContainerMaterialList.Where(w => w.StockStatus == StockStatusEnum.待质检).ToList();
|
if (checkList?.Count > 0)
|
{
|
WmsQcInfoByReceiving result = new WmsQcInfoByReceiving();
|
WmsOrderQc warehousOrder = new WmsOrderQc();
|
List<WmsOrderQcDetails> wmsQcDetails = new List<WmsOrderQcDetails>();
|
|
var hearId = Yitter.IdGenerator.YitIdHelper.NextId();
|
warehousOrder.Id = hearId;
|
|
// 获取当前时间
|
DateTime currentTime = DateTime.Now;
|
|
// 格式化为年月日字符串
|
string formattedDate = currentTime.ToString("yyyyMMdd");
|
|
//按照单号规则生成单号 - 查找最新的创建的一条单据记录
|
//var newestOrder = await _wmsQcRep.AsQueryable().Where(p => p.RelationOrderType == OrderTypeEnum.报检单).Where(p => p.QCNo.Contains(formattedDate)).OrderBy(it => it.CreateTime, OrderByType.Desc)
|
// .FirstAsync();
|
|
|
var newestOrder = await _wmsQcRep.AsQueryable().OrderBy(it => it.CreateTime, OrderByType.Desc)
|
.FirstAsync();
|
|
//按照单号规则生成单号-ly
|
warehousOrder.QCNo = await SerialUtilOrder.GetSerialOrder(OrderTypeEnum.报检单, _WmsNoCreateRuleRep, _repSNRep, (int)BusinessTypeEnum.进料检验, newestOrder == null ? null : newestOrder.QCNo);
|
if (warehousOrder.QCNo == null || warehousOrder.QCNo == "")
|
{
|
warehousOrder.QCNo = Yitter.IdGenerator.YitIdHelper.NextId().ToString();
|
}
|
|
|
warehousOrder.QCOrderStatus = OrderStatusEnum.新建;
|
warehousOrder.QCOrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
|
warehousOrder.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.待检);
|
warehousOrder.QCStatus = QcStatusEnum.待检;
|
//TODO 关联单据类型
|
//warehousOrder.RelationOrderType =null; //一次收货只能是一种关联单据类型
|
warehousOrder.BusinessType = BusinessTypeEnum.进料检验;
|
warehousOrder.BusinessTypeName = BusinessTypeEnum.进料检验.GetDescription();
|
if (addRecordTransList.Select(p => p.RelationNo).Distinct().ToList().Count() > 1) throw Oops.Oh("下发了不同的ASN单号！");
|
warehousOrder.RelationNo = addRecordTransList.Select(p => p.RelationNo).First();
|
warehousOrder.RelationOrderType = OrderTypeEnum.ASN单;
|
//warehousOrder.RelationOrderType = addRecordTransList.Select(p => p.RelationOrderType).First(); //事务记录 已经去掉这个字段了
|
int lineNumber = 0;//行号 后期根据对接的第三方返回的格式重新定义
|
foreach (var item in checkList)
|
{
|
lineNumber++;
|
WmsRecordTrans wmsRecordTrans = addRecordTransList.FirstOrDefault(f => f.ToSNCode.Equals(item.SNCode));
|
//查询PO单行号
|
if (wmsRecordTrans == null)
|
{
|
throw Oops.Oh($"跟踪码{item.SNCode}未获取到事务记录，创建报检单失败");
|
}
|
|
var currentAsnDetails = wmsOrderAsnDetails.FirstOrDefault(f => f.AsnNo == wmsRecordTrans.RelationNo && f.AsnLineNumber == wmsRecordTrans.RelationNoLineNumber);
|
if (currentAsnDetails == null)
|
{
|
throw Oops.Oh($"创建报检单ASN单{wmsRecordTrans.RelationNo}行号{wmsRecordTrans.RelationNoLineNumber}未获取到ASN单明细");
|
}
|
WmsOrderQcDetails wmsQcDetailsInput = new WmsOrderQcDetails()
|
{
|
QCLineNumber = lineNumber.ToString(),
|
ErpVoucher = item.ErpVoucher,//对接ERP收货返回的凭证，用于获取质检结果
|
SNCode = item.SNCode,
|
QCOrderId = warehousOrder.Id,
|
QCOrderNo = warehousOrder.QCNo,
|
PassQuantity = 0,
|
RejectQuantity = 0,
|
GoodsQuantity = item.Quantity,
|
QCQuantity = 0,
|
QCStatus = QcStatusEnum.待检,
|
QCStatusName = QcStatusEnum.待检.GetDescription(),
|
MaterialCode = item.MaterialCode,
|
MaterialName = item.MaterialName,
|
Unit = currentAsnDetails.POUnit,
|
SupplierCode = item.SupplierCode,
|
SupplierName = item.SupplierName,
|
QCOrderStatus = OrderStatusEnum.新建,
|
QCOrderStatusName = OrderStatusEnum.新建.GetDescription(),
|
PoNo = currentAsnDetails.PoNo,
|
PoLineNumber = currentAsnDetails.PoLineNumber,
|
AsnNo = wmsRecordTrans.RelationNo,
|
AsnLineNumber = wmsRecordTrans.RelationNoLineNumber,
|
};
|
wmsQcDetails.Add(wmsQcDetailsInput);
|
}
|
//warehousOrder.RelationNo= wmsQcDetails[0].RelationNo;//TODO 一个报检单的明细是否只能是同一个关联单号（ASN单）
|
//warehousOrder.RelationOrderType = wmsQcDetails[0].RelationOrderType;//
|
warehousOrder.SupplierName = wmsQcDetails[0].SupplierName;
|
warehousOrder.SupplierCode = wmsQcDetails[0].SupplierCode;
|
|
|
result.wmsQc = warehousOrder;
|
result.wmsQcDetails = wmsQcDetails;
|
return result;
|
}
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
/// 创建收货记录
|
/// </summary>
|
/// <param name="batchNo"></param>
|
/// <param name="pDAReceivingActionType"></param>
|
/// <param name="receivingItem"></param>
|
/// <param name="currentOrderAsn"></param>
|
/// <param name="currentAsnDetails"></param>
|
/// <param name="erpVoucher"></param>
|
/// <param name="snCode"></param>
|
/// <param name="currentPurchaseDetails"></param>
|
/// <returns></returns>
|
private WmsRecordReceivingDelivery CreateWareConfirmDelivery(string batchNo, PDAReceivingActionTypeEnum pDAReceivingActionType, ReceivingProcessInput receivingItem, WmsOrderAsn currentOrderAsn, WmsOrderAsnDetails currentAsnDetails, string snCode, WmsOrderPurchaseDetails currentPurchaseDetails)
|
{
|
WmsRecordReceivingDelivery wareConfirmDelivery = new WmsRecordReceivingDelivery()
|
{
|
Remarks = GetEnumDescriptionUtil.GetEnumDescription(pDAReceivingActionType),
|
OrderNoLineNumber = currentAsnDetails.AsnLineNumber,
|
OrderNo = currentAsnDetails.AsnNo,
|
Batch = batchNo,//根据批次规则创建的批次
|
OrderType = currentOrderAsn.AsnType,//全部都是asn单收货
|
OrderTypeName = currentOrderAsn.AsnTypeName,
|
BusinessType = currentOrderAsn.BusinessType,
|
BusinessTypeName = currentOrderAsn.BusinessTypeName,
|
Quantity = receivingItem.UncollectedQuantity,
|
POQuantity = receivingItem.POQuantity,
|
ErpCode = currentAsnDetails.ErpCode,
|
ErpOrderNo = currentAsnDetails.ErpOrderNo,
|
Images = receivingItem.ImageIds,//上传图片暂时空着
|
MaterialCode = currentAsnDetails.MaterialCode,
|
MaterialName = currentAsnDetails.MaterialName,
|
MoveType = MoveTypeEnum.收货,
|
MoveTypeName = MoveTypeEnum.收货.GetDescription(),
|
RelationNoLineNumber = currentPurchaseDetails != null ? currentPurchaseDetails.PoLineNumber : "",
|
RelationNo = currentPurchaseDetails != null ? currentPurchaseDetails.PoNo : "",
|
SNCode = snCode,
|
SupplierBatch = currentAsnDetails.SupplierBatch,//供应商批次
|
SupplierCode = currentAsnDetails.SupplierCode,
|
SupplierName = currentAsnDetails.SupplierName,
|
POUnit = currentAsnDetails.POUnit,
|
MaterialUnit = currentAsnDetails.MaterialUnit,
|
InOutFlag = InOutFlagEnum.入
|
};
|
return wareConfirmDelivery;
|
}
|
/// <summary>
|
/// 收货创建库存实体
|
/// </summary>
|
/// <param name="receivingItem"></param>
|
/// <param name="currentAsnDetails"></param>
|
/// <param name="erpVoucher"></param>
|
/// <param name="snCode"></param>
|
/// <param name="setCheckStatus"></param>
|
/// <param name="setStockStatusEnum"></param>
|
/// <param name="wmsContainer"></param>
|
/// <param name="wmsPlace"></param>
|
/// <param name="wmsArea"></param>
|
/// <returns></returns>
|
private WmsStockQuan CreateWmsContainerMaterial(string batchNo, WmsMaterialOutput materialBaseInfo, List<WmsBaseUnit> allUnitList, ReceivingProcessInput receivingItem, WmsOrderAsnDetails currentAsnDetails, string snCode, StockQcStatusEnum setCheckStatus, StockStatusEnum setStockStatusEnum, WmsBaseContainer wmsContainer, WmsBasePlace wmsPlace, WmsBaseArea wmsArea)
|
{
|
|
//获取物料基础信息
|
|
decimal inQuantity = receivingItem.UncollectedQuantity;//实际收货库存
|
#region 单位换算，重新计算收货库存
|
//TODO 库存单位跟采购单位不一致，进行单位换算，重新计算入库库存
|
//TODO 实际库存 不要影响 收货数，应该在创建库存信息的时候在计算库存数
|
|
|
|
#endregion
|
|
//物料基础信息库存单位不等于采购单位，库存根据单位换算率计算，库存=收货数*换算率
|
WmsStockQuan addWmsStockQuan = new WmsStockQuan()
|
{
|
|
ContainerCode = wmsContainer.ContainerCode,//收货区容器\待检区容器
|
RelationNo = currentAsnDetails.AsnNo,//TODO关联单号记录ASN单还是PO单号，存在没有PO单直接建asn单收货的情况？？？
|
ContainerId = wmsContainer.Id,
|
SupplierBatch = currentAsnDetails.SupplierBatch,
|
Batch = batchNo,
|
MaterialCode = currentAsnDetails.MaterialCode,
|
MaterialName = currentAsnDetails.MaterialName,
|
Quantity = inQuantity,
|
QCStatus = setCheckStatus,
|
QCStatusName = setCheckStatus.ToString(),
|
StockStatus = setStockStatusEnum,
|
StockStatusName = setStockStatusEnum.ToString(),
|
RecordInsertTime = DateTime.Now,
|
SNCode = snCode,
|
SourceSNCode = snCode,//赋值源跟踪码-新增的库存，源跟踪码=跟踪码 update by liuwq 20240708
|
ErpCode = currentAsnDetails.ErpCode,
|
ErpOrderNo = currentAsnDetails.ErpOrderNo,
|
SN_1d = currentAsnDetails.SN_1d,
|
SN_2d = currentAsnDetails.SN_2d,
|
SupplierCode = currentAsnDetails.SupplierCode,
|
SupplierName = currentAsnDetails.SupplierName,
|
Remarks = "收货",
|
MaterialUnit = materialBaseInfo.MaterialUnit//库存单位
|
|
};
|
return addWmsStockQuan;
|
}
|
|
|
|
|
//private WmsRecordTrans CreateStockRecordTrans()
|
//{
|
|
//}
|
|
|
//验证入参
|
private void ValidateInput(
|
List<ReceivingProcessInput> sourceinput,
|
PDAReceivingActionTypeEnum pDAReceivingActionType,
|
List<WmsOrderAsnDetails> orderAsndetails,
|
List<WmsOrderAsn> orderAsnList,
|
List<WmsOrderPurchaseDetails> orderPurchaseDetailsList,
|
List<WmsOrderPurchase> orderPurchaseList,
|
List<WmsMaterialOutput> materialList, List<WmsBaseBatchRule> allBatchRuleDetailsList)
|
{
|
|
//当前收货的asn单明细 前绑定asn单明细一维码或二维码必须有一个有值，实际业务不太可能同时有值
|
|
if (orderAsndetails.Count(w => string.IsNullOrWhiteSpace(w.SN_1d) && string.IsNullOrWhiteSpace(w.SN_2d)&& sourceinput.Select(s=>s.OrderAsnDetailsId).Contains(w.Id) ) > 0)
|
{
|
throw Oops.Oh("前绑定收货ASN单明细一维码和二维码不能同时为空");
|
}
|
|
//if (pDAReceivingActionType == PDAReceivingActionTypeEnum.前绑定)
|
//{
|
// //前绑定asn单明细一维码或二维码必须有一个有值，实际业务不太可能同时有值
|
|
// if (orderAsndetails.Count(w => string.IsNullOrWhiteSpace(w.SN_1d) && string.IsNullOrWhiteSpace(w.SN_2d)) > 0)
|
// {
|
// throw Oops.Oh("前绑定收货ASN单明细一维码和二维码不能同时为空");
|
// }
|
//}
|
//else
|
//{
|
// //后绑定asn单明细一维码和二维码不能有值
|
// if (orderAsndetails.Count(w => !string.IsNullOrWhiteSpace(w.SN_1d) || !string.IsNullOrWhiteSpace(w.SN_2d)) > 0)
|
// {
|
// throw Oops.Oh("后绑定收货ASN单明细一维码或二维码不能有值");
|
// }
|
|
//}
|
|
//验证asn单
|
foreach (var item in orderAsndetails)
|
{
|
//验证asn单是否存咋
|
var orderAsn = orderAsnList.FirstOrDefault(u => u.Id == item.AsnId);
|
if (orderAsn == null)
|
{
|
throw Oops.Oh($"ID{item.AsnId}未查询到ASN单！");
|
}
|
//验证asn单的状态
|
if (orderAsn.AsnStatus != OrderStatusEnum.新建 && orderAsn.AsnStatus != OrderStatusEnum.处理中)
|
{
|
throw Oops.Oh($"ASN单{orderAsn.AsnNo}状态是[{orderAsn.AsnStatus.GetDescription()}]，不能操作！");
|
}
|
}
|
|
|
|
|
|
|
// 验证收货明细
|
foreach (var validateItem in sourceinput)
|
{
|
|
//根据validateItem.OrderAsnDetailsId获取明细
|
var orderAsndetail = orderAsndetails.FirstOrDefault(u => u.Id == validateItem.OrderAsnDetailsId);
|
if (orderAsndetail == null)
|
{
|
throw Oops.Oh($"本次收货的ASN单明细ID[{validateItem.OrderAsnDetailsId}]未查询到数据");
|
}
|
|
|
#region 验证物料是否有基础数据
|
string _materialCode = orderAsndetail.MaterialCode;
|
var material = materialList.FirstOrDefault(u => u.MaterialCode == _materialCode);
|
|
if (material == null)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}物料{_materialCode}没有配置物料基础信息");
|
}
|
if (material.IsDisabled)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}物料{_materialCode}基础数据已禁用");
|
}
|
|
if (material.POUnit != orderAsndetail.POUnit)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}物料{_materialCode}单位{orderAsndetail.POUnit}跟物料基础数据采购单位{material.POUnit}不一致");
|
}
|
#endregion
|
|
//物料可以不配置批次规则
|
//配置了批次规则就要验证明细是否存在
|
|
if (!string.IsNullOrWhiteSpace(material.BatchRuleCode))
|
{
|
var batchRuleDetailsList = allBatchRuleDetailsList.Where(u => u.RuleCode == material.BatchRuleCode).ToList();
|
|
if (batchRuleDetailsList?.Count <= 0)
|
{
|
throw Oops.Oh($"批次规则{material.BatchRuleCode}没有获取到有效的规则明细");
|
}
|
}
|
|
|
|
|
//isUsedPo = true 表示使用PO单，isUsedPo = false 表示不使用PO单
|
//如果使用PO单，则验证PO单和明细
|
bool isUsedPo = false;
|
if (!string.IsNullOrWhiteSpace(orderAsndetail.PoNo) && !string.IsNullOrWhiteSpace(orderAsndetail.PoLineNumber))
|
{
|
isUsedPo = true;
|
}
|
if (isUsedPo)
|
{
|
//获取ASN单明细关联的PO明细
|
|
|
//验证PO单
|
if (orderPurchaseList?.Count == 0)
|
{
|
throw Oops.Oh("本次收货的PO单不存在");
|
|
}
|
|
var orderPurchaseDetail = orderPurchaseDetailsList.FirstOrDefault(f => f.PoNo == orderAsndetail.PoNo && f.MaterialCode == orderAsndetail.MaterialCode && f.PoLineNumber == orderAsndetail.PoLineNumber);
|
if (orderPurchaseDetail == null)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}明细关联的PO单号{orderAsndetail.PoNo},物料{orderAsndetail.MaterialCode},行号{orderAsndetail.PoLineNumber}未查询到PO单明细！");
|
}
|
|
//验证asn单是否存咋
|
var orderPurchase = orderPurchaseList.FirstOrDefault(u => u.Id == orderPurchaseDetail.PoId);
|
if (orderPurchase == null)
|
{
|
throw Oops.Oh($"ID{orderPurchaseDetail.PoId}未查询到PO单！");
|
}
|
//验证PO单的状态
|
if (orderPurchase.PoStatus != OrderStatusEnum.新建 && orderPurchase.PoStatus != OrderStatusEnum.处理中)
|
{
|
throw Oops.Oh($"PO单{orderPurchase.PurchaseNo}状态是[{orderPurchase.PoStatus.GetDescription()}]，不能操作！");
|
}
|
|
|
}
|
|
if (pDAReceivingActionType == PDAReceivingActionTypeEnum.前绑定)
|
{
|
string snCode = string.IsNullOrWhiteSpace(orderAsndetail.SN_1d) ? orderAsndetail.SN_2d : orderAsndetail.SN_1d;
|
//前绑定只有新建状态的明细才能收货
|
if (orderAsndetail.AsnStatus != OrderStatusEnum.新建)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}跟踪码[{snCode}]的ASN单明细状态不是[{OrderStatusEnum.新建.GetDescription()}]，不能操作！");
|
}
|
if (orderAsndetail.GoodsQuantity > 0)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}跟踪码[{snCode}]的ASN单明细已收货数[{orderAsndetail.GoodsQuantity}]大于0，不能操作！");
|
}
|
//validateItem收货数必须等于明细的需求数
|
if (validateItem.UncollectedQuantity != orderAsndetail.Quantity)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}跟踪码[{snCode}]的ASN单明细的需求数{orderAsndetail.Quantity}不等于本次收货数{validateItem.UncollectedQuantity}！");
|
}
|
}
|
else
|
{ //后绑定asn单明细的 状态只能是新建或执行中才能收货
|
if (orderAsndetail.AsnStatus != OrderStatusEnum.新建 && orderAsndetail.AsnStatus != OrderStatusEnum.处理中)
|
{
|
throw Oops.Oh($"ASN单{orderAsndetail.AsnNo}物料[{orderAsndetail.MaterialCode}]Asn单明细行号[{orderAsndetail.AsnLineNumber}]的ASN单明细状态是[{orderAsndetail.AsnStatus.GetDescription()}]，不能操作！");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
/// <summary>
|
/// 根据PDA收货操作类型获取SN条码
|
/// </summary>
|
/// <param name="pDAReceivingActionType"></param>
|
/// <param name="currentAsnDetails"></param>
|
/// <returns></returns>
|
private static string GetSNCode(PDAReceivingActionTypeEnum pDAReceivingActionType, WmsOrderAsnDetails currentAsnDetails)
|
{
|
//现在都是用前绑定收货了，自建的ASN也会根据条码规则生成跟踪码
|
//1.前绑定跟踪码取asn单明细的一维码或二维码，哪个有值取哪个。实际业务不太可能同时有值。
|
//2.后绑定自动生成跟踪码。
|
string SNCode;
|
if (pDAReceivingActionType == PDAReceivingActionTypeEnum.前绑定)
|
{
|
|
if (!string.IsNullOrWhiteSpace(currentAsnDetails.SN_1d))
|
{
|
SNCode = currentAsnDetails.SN_1d;
|
}
|
else
|
{
|
SNCode = currentAsnDetails.SN_2d;
|
}
|
|
}
|
else
|
{
|
//TODO 测试先用雪花ID
|
SNCode = "SN_" + Yitter.IdGenerator.YitIdHelper.NextId();
|
}
|
|
return SNCode;
|
}
|
#endregion
|
|
}
|
