using Admin.NET.Application.CommonHelper;
|
using Admin.NET.Application.Entity;
|
|
namespace Admin.NET.Application;
|
/// <summary>
|
/// 报检单服务
|
/// </summary>
|
[ApiDescriptionSettings(ApplicationConst.WmsQCGroupName, Order = 100)]
|
public class WmsOrderQcService : IDynamicApiController, ITransient
|
{
|
private readonly SqlSugarRepository<WmsBaseBusinessType> _WmsBaseBusinessTypeRep;
|
private readonly SqlSugarRepository<WmsOrderQc> _rep;
|
private readonly SqlSugarRepository<WmsBaseMaterial> _wmsMaterialRep;
|
private readonly SqlSugarRepository<WmsOrderQcDetails> _WmsQcDetailsRep;
|
private readonly SqlSugarRepository<WmsBaseCustomer> _BaseCustomerRep;
|
private readonly SqlSugarRepository<WmsStockQuan> _WmsContainerMaterialRep;
|
private readonly SqlSugarRepository<WmsOrderQcTrans> _WmsQcTransRep;
|
private readonly SqlSugarRepository<WmsLogAction> _wmsLogActionRep;
|
private readonly SqlSugarRepository<WmsRecordTrans> _wmsRecordTransdRep;
|
private readonly SqlSugarRepository<WmsConfigSerialSN> _repSNRep;
|
private readonly SqlSugarRepository<WmsConfigNoRule> _WmsNoCreateRuleRep;
|
private readonly SqlSugarRepository<v_wms_stock_quan> _v_wms_stock_quanRep;
|
private readonly SqlSugarRepository<WmsBaseBusinessType> _wmsBaseBusinessType;
|
private readonly SqlSugarRepository<WmsBasePlace> _wmsPlaceRep;
|
public WmsOrderQcService(
|
|
SqlSugarRepository<WmsBaseBusinessType> WmsBaseBusinessTypeRep,
|
SqlSugarRepository<WmsOrderQc> rep,
|
SqlSugarRepository<WmsBaseMaterial> wmsMaterialRep,
|
SqlSugarRepository<WmsOrderQcDetails> wmsQcDetailsRep,
|
SqlSugarRepository<WmsBaseCustomer> baseCustomerRep,
|
SqlSugarRepository<WmsStockQuan> wmsContainerMaterialRep, SqlSugarRepository<WmsOrderQcTrans> wmsQcTransRep,
|
SqlSugarRepository<WmsLogAction> wmsLogActionRep, SqlSugarRepository<WmsRecordTrans> wmsRecordTransdRep,
|
SqlSugarRepository<WmsConfigSerialSN> repSNRep,
|
SqlSugarRepository<WmsConfigNoRule> wmsNoCreateRuleRep, SqlSugarRepository<v_wms_stock_quan> v_wms_stock_quanRep,
|
|
SqlSugarRepository<WmsBaseBusinessType> wmsBaseBusinessType,
|
|
SqlSugarRepository<WmsBasePlace> wmsPlaceRep
|
)
|
{
|
|
_WmsBaseBusinessTypeRep = WmsBaseBusinessTypeRep;
|
_rep = rep;
|
_wmsMaterialRep = wmsMaterialRep;
|
_WmsQcDetailsRep = wmsQcDetailsRep;
|
_BaseCustomerRep = baseCustomerRep;
|
_WmsContainerMaterialRep = wmsContainerMaterialRep;
|
_WmsQcTransRep = wmsQcTransRep;
|
_wmsLogActionRep = wmsLogActionRep;
|
_wmsRecordTransdRep = wmsRecordTransdRep;
|
_repSNRep = repSNRep;
|
_WmsNoCreateRuleRep = wmsNoCreateRuleRep;
|
_v_wms_stock_quanRep = v_wms_stock_quanRep;
|
|
_wmsBaseBusinessType = wmsBaseBusinessType;
|
_wmsPlaceRep = wmsPlaceRep;
|
}
|
|
/// <summary>
|
/// 分页查询报检单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Page")]
|
[Description("WmsOrderQc/Page")]
|
public async Task<SqlSugarPagedList<WmsOrderQcOutput>> Page(WmsOrderQcInput input)
|
{
|
|
var query = CommonPageFilter(input);
|
return await query
|
.OrderBy(x => x.QCOrderStatus).OrderByDescending(x => x.CreateTime)
|
//.OrderBuilder(input)
|
.ToPagedListAsync(input.Page, input.PageSize);
|
}
|
|
/// <summary>
|
/// 不分页查询报检单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "List")]
|
[Description("WmsOrderQc/List")]
|
public async Task<List<WmsOrderQcOutput>> List([FromQuery] WmsOrderQcInput input)
|
{
|
var query = CommonPageFilter(input);
|
//return await query.OrderBuilder(input, "", "u.Id").Select<WmsQcOutput>().ToListAsync();
|
return await query.OrderBuilder(input).Select<WmsOrderQcOutput>().ToListAsync();
|
|
}
|
|
/// <summary>
|
/// 增加报检单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Add")]
|
[Description("WmsOrderQc/Add")]
|
public async Task<long> Add(DiyAddWmsQcInput input)
|
{
|
//if (input.orderDetails is null || input.orderDetails.Count == 0)
|
//{
|
// throw Oops.Oh("明细不能为空");
|
//}
|
//var hearId = await AddOrderEFsql(input);
|
return 200;
|
}
|
|
private async Task<long> AddOrderEFsql(DiyAddWmsQcInput input)
|
{
|
//新增表头
|
var warehousOrder = input.Adapt<WmsOrderQc>();
|
var hearId = Yitter.IdGenerator.YitIdHelper.NextId();
|
warehousOrder.Id = hearId;
|
|
// 获取当前时间
|
DateTime currentTime = DateTime.Now;
|
|
// 格式化为年月日字符串
|
string formattedDate = currentTime.ToString("yyyyMMdd");
|
|
//按照单号规则生成单号 - 查找最新的创建的一条单据记录
|
var newestOrder = await _rep.AsQueryable().Where(p => p.RelationOrderType == OrderTypeEnum.报检单).Where(p => p.QCNo.Contains(formattedDate)).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.QCOrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
|
warehousOrder.BusinessTypeName = GetEnumDescriptionUtil.GetEnumDescription(BusinessTypeEnum.进料检验);
|
//新增明细
|
var warehousOrderDetails1 = input.orderDetails.Adapt<List<WmsOrderQcDetails>>();
|
int lineNumber = 0;
|
foreach (var w in warehousOrderDetails1)
|
{
|
lineNumber++;//报检单行号实际可根据对接的第三方返回的格式定义。
|
w.QCLineNumber = lineNumber.ToString();//update by liuwq 20240526
|
w.GoodsQuantity = w.QCQuantity;
|
var idMaterial = Yitter.IdGenerator.YitIdHelper.NextId();
|
w.Id = idMaterial;
|
w.QCOrderId = warehousOrder.Id;
|
w.RejectQuantity = w.QCQuantity - w.PassQuantity;
|
w.QCOrderStatus = OrderStatusEnum.新建;
|
w.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
|
w.QCOrderNo = warehousOrder.Id.ToString();
|
//w.RelationNo = ""; TODO 关联单号 update liuwq
|
//w.RelationOrderType = null; TODO 关联单类型 update liuwq
|
w.SNCode = "SN_" + w.Id.ToString();
|
if (w.QCQuantity == w.PassQuantity && w.PassQuantity > 0)
|
{
|
w.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.合格);
|
}
|
else if (w.QCQuantity != w.PassQuantity && w.PassQuantity > 0)
|
{
|
w.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.部分合格);
|
}
|
else if (w.QCQuantity == w.RejectQuantity)
|
{
|
w.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.不合格);
|
}
|
var Info_BaseCustomer = await _BaseCustomerRep.GetFirstAsync(u => u.CustCode == w.SupplierCode);
|
if (Info_BaseCustomer != null)
|
{
|
w.SupplierName = Info_BaseCustomer.CustChinaName;
|
}
|
else
|
{
|
throw Oops.Oh("供应商编号不正确！");
|
}
|
w.IsDelete = false;
|
}
|
try
|
{
|
await _rep.AsTenant().BeginTranAsync();
|
|
//插入主表
|
await _rep.InsertAsync(warehousOrder);
|
//插入明细表
|
await _WmsQcDetailsRep.InsertRangeAsync(warehousOrderDetails1);
|
|
await _rep.AsTenant().CommitTranAsync();
|
}
|
catch
|
{
|
await _rep.AsTenant().RollbackTranAsync();
|
throw;
|
}
|
|
return hearId;
|
}
|
|
|
|
/// <summary>
|
/// 删除报检单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Delete")]
|
[Description("WmsOrderQc/Delete")]
|
public async Task Delete(DeleteWmsQcInput input)
|
{
|
var entity = await _rep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
|
//await _rep.FakeDeleteAsync(entity); //假删除
|
await _rep.DeleteAsync(entity); //真删除
|
}
|
|
/// <summary>
|
/// 更新报检单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Update")]
|
[Description("WmsOrderQc/Update")]
|
public async Task Update(UpdateWmsQcInput input)
|
{
|
var entity = input.Adapt<WmsOrderQc>();
|
|
//重复性验证
|
await CheckExist(entity, true);
|
|
await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
|
}
|
|
/// <summary>
|
/// 获取报检单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "Detail")]
|
[Description("WmsOrderQc/Detail")]
|
public async Task<WmsOrderQc> Detail([FromQuery] QueryByIdWmsQcInput input)
|
{
|
return await _rep.GetFirstAsync(u => u.Id == input.Id);
|
}
|
|
|
/// <summary>
|
/// 0708确认报检单:仅支持一次确认 仅处理一个单据 SNCode SNCode_1
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "ConfirmQc")]
|
[Description("WmsOrderQc/ConfirmQc")]
|
public async Task Confirm(DiyAddWmsQcInput input)
|
{
|
/// 1 验证输入明细不能为空； 订单是否不存在； 验证数量是否正确
|
////2更新主表明细表
|
//// -- 2.1--主表-单据状态为【已完成】
|
//// -- 2.2--明细表-单据状态为【已完成】， 根据合格数更新质检状态为【合格|部分合格|不合格】
|
|
////3操作库存表的物料
|
//// 3.1无需拆分物料
|
//// 3.1.1--全合格物料，更新【质检状态-合格】，更新【库存状态-待上架】，更新【库存数量】
|
//// 3.1.2--全不合格物料，更新【质检状态-不合格】，更新【库存状态-待上架】，更新【库存数量】
|
//// 3.2需要拆分的物料
|
//// 3.2.1--更新库存1条数据【合格物料】，更新【质检状态-合格】，更新【库存状态-待上架】，更新【库存数量】，更新【SNCode】
|
//// 3.2.2--增1条数据【不合格物料】，更新【质检状态-不合格】，更新【库存状态-待上架】，更新【库存数量】，更新【SNCode_1】
|
//// 3.2.3--删拆分之前的物料【SNCode】
|
// 4 添加更改库存记录
|
// 5更新操作履历 更新事务记录
|
if (input is null)
|
{
|
throw Oops.Oh("输入参不能为空");
|
}
|
|
if (input.orderDetails is null || input.orderDetails.Count == 0)
|
{
|
throw Oops.Oh("明细不能为空");
|
}
|
|
var dbOrder = await _rep.GetFirstAsync(w => w.QCNo == input.QCNo);
|
if (dbOrder == null)
|
{
|
throw Oops.Oh($"订单{input.QCNo}不存在");
|
}
|
|
//验证数量是否正确
|
foreach (var item in input.orderDetails)
|
{
|
if (item.QCQuantity != item.GoodsQuantity)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的实检数量{item.QCQuantity}不等于收货数量{item.GoodsQuantity}");
|
}
|
if (item.QCQuantity < item.PassQuantity)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的实检数量{item.QCQuantity}不能小于合格数量{item.PassQuantity}");
|
}
|
if (item.QCQuantity < item.RejectQuantity)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的实检数量{item.QCQuantity}不能小于不合格数量{item.RejectQuantity}");
|
}
|
if (item.QCQuantity != (item.RejectQuantity + item.PassQuantity))
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的实检数量{item.QCQuantity}不能等于合格数量{item.PassQuantity}和不合格数量{item.RejectQuantity}之和");
|
}
|
}
|
|
var OrderDetails = await _WmsQcDetailsRep.AsQueryable()
|
.Where(x => x.QCOrderId == dbOrder.Id)
|
.Where(u => u.IsDelete == false)
|
.Select<WmsOrderQcDetails>()
|
.ToListAsync();
|
|
List<WmsOrderQcDetails> updateWareOrderDetails = new List<WmsOrderQcDetails>();
|
List<WmsStockQuan> updateWmsContainerMaterial = new List<WmsStockQuan>();
|
List<WmsStockQuan> addWmsContainerMaterial = new List<WmsStockQuan>();
|
|
List<WmsStockQuan> deleteWmsContainerMaterial = new List<WmsStockQuan>();
|
List<WmsOrderQcTrans> addWmsQcTrans = new List<WmsOrderQcTrans>();
|
//新增事务记录
|
List<WmsRecordTrans> addWmsRecordTransList = new List<WmsRecordTrans>();
|
//寻找更新单据明细的物料
|
var updateList = OrderDetails.Where(x => input.orderDetails.Any(p => p.Id == x.Id && p.MaterialCode == x.MaterialCode)).ToList();
|
|
//寻找更新库存的物料
|
List<string> queryCodeList = input.orderDetails.Select(v => v.SNCode).Distinct().ToList();
|
var handleList = await _WmsContainerMaterialRep.GetListAsync(u => queryCodeList.Contains(u.SNCode) && u.IsDelete == false);
|
|
|
var snCodeList = handleList.Select(s => s.SNCode).ToList();
|
//获取要报检的库存视图-根据盘点库区的容器和盘点范围的物料获取盘点库存-包含库位信息、库区信息，新增事务用
|
var all_v_wms_stock_quanList = await _v_wms_stock_quanRep.GetListAsync(x => x.IsDelete == false && snCodeList.Contains(x.SNCode));
|
|
//获取库位相信
|
var placeCodeList = all_v_wms_stock_quanList.Select(s=>s.PlaceCode).Distinct().ToList();
|
var allPlaeList= await _wmsPlaceRep.GetListAsync(u=> placeCodeList.Contains(u.PlaceCode)&&u.IsDelete==false);
|
|
//获取业务类型
|
BusinessTypeEnum businessTypeEnum = BusinessTypeEnum.报检;
|
var businessTypeInfo = BusinessTypeHelper.GetBusinessTypeInfoFromDB((int)businessTypeEnum, _wmsBaseBusinessType);
|
|
if (handleList == null || handleList.Count <= 0)
|
{
|
throw Oops.Oh($"没有找到需要更新的库存物料！");
|
|
}
|
//2更新主表明细表 单据状态为【已完成】 质检状态为【合格|部分合格|不合格】
|
foreach (var item in updateList)
|
{
|
if (item.QCStatus == QcStatusEnum.待检)
|
{
|
throw Oops.Oh("待检状态不能操作！");
|
}
|
var orderDetails = input.orderDetails.Where(x => x.MaterialCode == item.MaterialCode && x.Id == item.Id).First();
|
if (orderDetails == null)
|
{
|
continue;
|
}
|
else
|
{
|
//item.PassQuantity = (decimal)orderDetails.PassQuantity;
|
//item.RejectQuantity = (decimal)orderDetails.QCQuantity - (decimal)orderDetails.PassQuantity;
|
if (orderDetails.QCQuantity == orderDetails.PassQuantity)
|
{
|
item.QCStatus = QcStatusEnum.合格;
|
item.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.合格);
|
}
|
if (orderDetails.PassQuantity > 0 && orderDetails.QCQuantity > orderDetails.PassQuantity)
|
{
|
item.QCStatus = QcStatusEnum.部分合格;
|
item.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.部分合格);
|
}
|
if (orderDetails.QCQuantity == orderDetails.RejectQuantity)
|
{
|
item.QCStatus = QcStatusEnum.不合格;
|
item.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.不合格);
|
}
|
item.QCOrderStatus = OrderStatusEnum.已完成;
|
item.QCOrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.已完成);
|
|
}
|
//变更明细的状态
|
updateWareOrderDetails.Add(item);
|
}
|
|
//2更改主表-单据状态-----------调用刘文奇的公共方法
|
OrderHelper.UpdateQCOrderStatus(OrderDetails, dbOrder); // dbOrder.QCOrderStatus = OrderStatusEnum.Completed;
|
|
//3库存物料
|
foreach (var itemUp in handleList)
|
{
|
|
//获取源库存信息
|
var sourceStockView = StockQuanHelper.GetVMmsStockQuan(all_v_wms_stock_quanList, itemUp.SNCode);
|
|
|
//获取目标库位信息
|
//目标库存不变 新增的库存也是源库存的库位
|
var toPlaceInfo = BaseInfoHelper.GetPlace(sourceStockView.PlaceCode, allPlaeList);
|
|
//事务记录其他入参
|
TransferOtherDetail transferOtherDetail = new TransferOtherDetail()
|
{
|
RelationNo = dbOrder.QCNo,//报检单号
|
RelationNoLineNumber = string.Empty,
|
Remarks = "",
|
|
};
|
|
var orderDetails = input.orderDetails.Where(x => x.MaterialCode == itemUp.MaterialCode && x.SNCode == itemUp.SNCode).First();
|
if (orderDetails == null)
|
{
|
continue;
|
}
|
else
|
{
|
//4------------加拆分物料记录
|
var itemChifenOne = itemUp.Adapt<WmsOrderQcTrans>();
|
itemChifenOne.QCOrderNo = dbOrder.QCNo;
|
itemChifenOne.QCOrderDetailsId = orderDetails.Id;
|
itemChifenOne.SNCode = itemUp.SNCode;
|
|
|
//3.1无需拆分物料 实检 = 合格数
|
if (orderDetails.QCQuantity == orderDetails.PassQuantity)
|
{
|
//实检 = 合格数
|
itemUp.QCStatus = StockQcStatusEnum.合格;
|
itemUp.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(StockQcStatusEnum.合格);
|
StockQuanHelper.UpdateStockStatus(itemUp, StockStatusEnum.待上架, BusinessTypeEnum.报检.GetDescription());
|
itemUp.Quantity = (decimal)orderDetails.QCQuantity;
|
|
//4------------加拆分物料记录
|
itemChifenOne.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
itemChifenOne.PassQuantity = (decimal)orderDetails.QCQuantity;
|
addWmsQcTrans.Add(itemChifenOne);
|
updateWmsContainerMaterial.Add(itemUp); //更新库存表
|
|
//库存状态、质检状态变更 创建事务记录 update by liuwq 20240730
|
addWmsRecordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(businessTypeInfo, sourceStockView, itemUp, toPlaceInfo, transferOtherDetail));
|
|
}
|
|
//3.1无需拆分物料 实检 = 不合格数
|
if (orderDetails.QCQuantity == orderDetails.RejectQuantity)
|
{
|
//实检 = 不合格数
|
itemUp.QCStatus = StockQcStatusEnum.不合格;
|
itemUp.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(StockQcStatusEnum.不合格);
|
StockQuanHelper.UpdateStockStatus(itemUp, StockStatusEnum.待上架, BusinessTypeEnum.报检.GetDescription());
|
itemUp.Quantity = (decimal)orderDetails.QCQuantity;
|
|
//4------------加拆分物料记录
|
itemChifenOne.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
itemChifenOne.RejectQuantity = (decimal)orderDetails.QCQuantity;
|
addWmsQcTrans.Add(itemChifenOne);
|
updateWmsContainerMaterial.Add(itemUp); //更新库存表
|
|
|
//库存状态、质检状态变更 创建事务记录 update by liuwq 20240730
|
addWmsRecordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(businessTypeInfo, sourceStockView, itemUp, toPlaceInfo, transferOtherDetail));
|
|
}
|
|
//3.2需要拆分的物料 实检 > 合格数
|
if (orderDetails.PassQuantity > 0 && orderDetails.QCQuantity > orderDetails.PassQuantity)
|
{
|
//------------A-更新合格1条
|
itemUp.QCStatus = StockQcStatusEnum.合格;
|
itemUp.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(StockQcStatusEnum.合格);
|
StockQuanHelper.UpdateStockStatus(itemUp, StockStatusEnum.待上架, BusinessTypeEnum.报检.GetDescription());
|
itemUp.Quantity = (decimal)orderDetails.PassQuantity;
|
updateWmsContainerMaterial.Add(itemUp); //更新库存表
|
|
|
//库存状态、质检状态、数量变更 创建事务记录 update by liuwq 20240730
|
addWmsRecordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(businessTypeInfo, sourceStockView, itemUp, toPlaceInfo, transferOtherDetail));
|
|
|
//---------------------B-加不合格1条-----------------
|
var itemReject = itemUp.Adapt<WmsStockQuan>();
|
itemReject.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
itemReject.QCStatus = StockQcStatusEnum.不合格;
|
itemReject.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(StockQcStatusEnum.不合格);
|
|
|
StockQuanHelper.UpdateStockStatus(itemReject, StockStatusEnum.待上架, BusinessTypeEnum.报检.GetDescription());
|
itemReject.Quantity = (decimal)orderDetails.RejectQuantity;
|
itemReject.SourceSNCode = itemReject.SNCode;//记录源跟踪码 update by liuwq 20240719
|
itemReject.SNCode = itemReject.SNCode + "_1";
|
addWmsContainerMaterial.Add(itemReject);
|
|
|
//新增状态、质检状态 数量 创建事务记录 update by liuwq 20240730
|
//新增的库存源信息都是空
|
addWmsRecordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(businessTypeInfo, null, itemReject, toPlaceInfo, transferOtherDetail));
|
|
//4------------加拆分物料记录 对应A-加合格1条
|
itemChifenOne.SNCode = itemUp.SNCode;
|
itemChifenOne.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
itemChifenOne.PassQuantity = itemUp.Quantity;
|
addWmsQcTrans.Add(itemChifenOne);
|
|
//4------------加拆分物料记录 对应B-加不合格1条-
|
var itemChifenReject = itemUp.Adapt<WmsOrderQcTrans>();
|
itemChifenReject.QCOrderNo = dbOrder.QCNo;
|
itemChifenReject.QCOrderDetailsId = orderDetails.Id;
|
itemChifenReject.SNCode = itemReject.SNCode;
|
itemChifenReject.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
itemChifenReject.RejectQuantity = itemReject.Quantity;
|
addWmsQcTrans.Add(itemChifenReject);
|
|
//----------3.3删除之前的数据1条
|
//deleteWmsContainerMaterial.Add(itemUp);
|
}
|
|
|
|
|
|
|
}
|
}
|
|
//添加操作履历操作日志 update by liuwq 20240720
|
List<WmsLogAction> addWmsLogActionList = new List<WmsLogAction>();
|
WmsLogAction wmsLogAction = LogActionHelper.CreateWmsLogAction(dbOrder.Id, $"报检单{dbOrder.QCNo}{BusinessTypeEnum.报检.GetDescription()}");
|
addWmsLogActionList.Add(wmsLogAction);
|
|
|
|
|
|
|
try
|
{
|
await _rep.AsTenant().BeginTranAsync();
|
if (updateWareOrderDetails.Count > 0)
|
{
|
await _rep.UpdateAsync(dbOrder); //更新主表
|
await _WmsQcDetailsRep.UpdateRangeAsync(updateWareOrderDetails); //更新明细表
|
if (updateWmsContainerMaterial.Count > 0)
|
{
|
await _WmsContainerMaterialRep.UpdateRangeAsync(updateWmsContainerMaterial); //更新库存表-3.1无需拆分物料
|
}
|
|
//if (deleteWmsContainerMaterial.Count > 0)
|
//{
|
// await _WmsContainerMaterialRep.DeleteAsync(deleteWmsContainerMaterial); //删除库存表 -3.2需要拆分的物料
|
//}
|
if (addWmsContainerMaterial.Count > 0)
|
{
|
await _WmsContainerMaterialRep.InsertRangeAsync(addWmsContainerMaterial); //插上架存表 -3.2需要拆分的物料 ---拆分不合格 A_1
|
}
|
|
if (addWmsQcTrans.Count > 0)
|
{
|
await _WmsQcTransRep.InsertRangeAsync(addWmsQcTrans); //插入更改库存记录
|
}
|
|
|
|
//// 4新增操作履历操作日志 update by liuwq 20240720
|
await _wmsLogActionRep.InsertRangeAsync(addWmsLogActionList);
|
|
// 5新增事务记录 update by liuwq 20240720
|
await _wmsRecordTransdRep.InsertRangeAsync(addWmsRecordTransList);
|
|
}
|
await _rep.AsTenant().CommitTranAsync();
|
}
|
catch
|
{
|
await _rep.AsTenant().RollbackTranAsync();
|
throw;
|
}
|
}
|
|
|
|
|
|
/// <summary>
|
/// 获取拆分物料明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "WmsOrderQcTransDetail")]
|
[Description("WmsOrderQc/WmsOrderQcTransDetail")]
|
public async Task<List<WmsOrderQcTransOutput>> SplitMaterialDetail([FromQuery] QuerySplitMaterialDetailInput input)
|
{
|
var query = _WmsQcTransRep.AsQueryable()
|
.WhereIF(input.QCOrderDetailsId > 0, u => u.QCOrderDetailsId == input.QCOrderDetailsId)
|
.Select<WmsOrderQcTransOutput>();
|
return await query.Select<WmsOrderQcTransOutput>().Distinct().ToListAsync();
|
}
|
|
|
|
|
|
/// <summary>
|
/// WMS系统-手工确认质检:仅支持一次确认 仅处理一个单据
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "HandleConfirmQc")]
|
[Description("WmsOrderQc/HandleConfirmQc")]
|
public async Task HandleConfirmQc(DiyAddWmsQcInput input)
|
{
|
if (input is null)
|
{
|
throw Oops.Oh("输入参不能为空");
|
}
|
|
if (input.orderDetails is null || input.orderDetails.Count == 0)
|
{
|
throw Oops.Oh("明细不能为空");
|
}
|
|
var dbOrder = await _rep.GetFirstAsync(w => w.QCNo == input.QCNo);
|
if (dbOrder == null)
|
{
|
throw Oops.Oh($"订单{input.QCNo}不存在");
|
}
|
|
//验证数量是否正确
|
foreach (var item in input.orderDetails)
|
{
|
if (item.PassQuantity == 0 && item.RejectQuantity == 0)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的合格数量和不合格数量必须大于0");
|
}
|
if (item.PassQuantity < 0)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的合格数量必须大于0");
|
}
|
if (item.RejectQuantity < 0)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的不合格数量必须大于0");
|
}
|
if (item.GoodsQuantity <= 0)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的已收数量{item.GoodsQuantity}必须大于0");
|
}
|
decimal dQty = ((decimal)item.RejectQuantity + (decimal)item.PassQuantity);
|
decimal dQtyT = Convert.ToDecimal(item.GoodsQuantity);
|
|
if (dQtyT != dQty)
|
{
|
throw Oops.Oh($"物料{item.MaterialCode}的已收数量{item.GoodsQuantity}必须等于合格数量{item.PassQuantity}和不合格数量{item.RejectQuantity}之和");
|
}
|
}
|
|
var OrderDetails = await _WmsQcDetailsRep.AsQueryable()
|
.Where(x => x.QCOrderId == dbOrder.Id)
|
.Where(u => u.QCStatus == QcStatusEnum.待检)
|
.Where(u => u.IsDelete == false)
|
.Select<WmsOrderQcDetails>()
|
.ToListAsync();
|
|
List<WmsOrderQcDetails> updateWareOrderDetails = new List<WmsOrderQcDetails>();
|
List<WmsStockQuan> updateWmsContainerMaterial = new List<WmsStockQuan>();
|
|
//寻找更新单据明细的物料
|
var updateList = OrderDetails.Where(x => input.orderDetails.Any(p => p.Id == x.Id && p.MaterialCode == x.MaterialCode)).ToList();
|
if (updateList == null || updateList.Count <= 0)
|
{
|
throw Oops.Oh($"质检物料信息传入错误！");
|
}
|
//寻找更新库存的物料
|
List<string> queryCodeList = input.orderDetails.Select(v => v.SNCode).Distinct().ToList();
|
var handleList = await _WmsContainerMaterialRep.GetListAsync(u => queryCodeList.Contains(u.SNCode) && u.IsDelete == false);
|
|
if (handleList == null || handleList.Count <= 0)
|
{
|
throw Oops.Oh($"没有找到需要更新的库存物料！");
|
|
}
|
//2更新主表明细表 单据状态为【执行中】 质检状态为【合格|部分合格|不合格】
|
foreach (var item in updateList)
|
{
|
if (item.QCStatus != QcStatusEnum.待检)
|
{
|
throw Oops.Oh("质检状态不是待检！");
|
}
|
var orderDetails = input.orderDetails.Where(x => x.MaterialCode == item.MaterialCode && x.Id == item.Id).First();
|
if (orderDetails == null)
|
{
|
continue;
|
}
|
else
|
{
|
item.QCQuantity = (decimal)orderDetails.GoodsQuantity;
|
item.PassQuantity = (decimal)orderDetails.PassQuantity;
|
item.RejectQuantity = (decimal)orderDetails.GoodsQuantity - (decimal)orderDetails.PassQuantity;
|
if (orderDetails.GoodsQuantity == orderDetails.PassQuantity)
|
{
|
item.QCStatus = QcStatusEnum.合格;
|
item.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.合格);
|
}
|
else if (orderDetails.GoodsQuantity == orderDetails.RejectQuantity)
|
{
|
item.QCStatus = QcStatusEnum.不合格;
|
item.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.不合格);
|
}
|
else
|
{
|
item.QCStatus = QcStatusEnum.部分合格;
|
item.QCStatusName = GetEnumDescriptionUtil.GetEnumDescription(QcStatusEnum.部分合格);
|
}
|
item.QCOrderStatus = OrderStatusEnum.处理中;
|
item.QCOrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
|
}
|
//变更明细的状态
|
updateWareOrderDetails.Add(item);
|
}
|
|
//2更改主表-单据状态-----------调用的公共方法
|
OrderHelper.UpdateQCOrderStatus(OrderDetails, dbOrder);
|
|
//3库存物料
|
foreach (var itemUp in handleList)
|
{
|
var orderDetails = input.orderDetails.Where(x => x.MaterialCode == itemUp.MaterialCode && x.SNCode == itemUp.SNCode).First();
|
if (orderDetails == null)
|
{
|
continue;
|
}
|
else
|
{
|
if (itemUp.StockStatus != StockStatusEnum.待质检)
|
{
|
throw Oops.Oh($"物料{itemUp.MaterialCode}的状态不是待质检！");
|
}
|
StockQuanHelper.UpdateStockStatus(itemUp, StockStatusEnum.待上架, BusinessTypeEnum.报检.GetDescription());
|
}
|
updateWmsContainerMaterial.Add(itemUp);
|
}
|
|
try
|
{
|
await _rep.AsTenant().BeginTranAsync();
|
if (updateWareOrderDetails.Count > 0)
|
{
|
await _rep.UpdateAsync(dbOrder); //更新主表
|
await _WmsQcDetailsRep.UpdateRangeAsync(updateWareOrderDetails); //更新明细表
|
if (updateWmsContainerMaterial.Count > 0)
|
{
|
await _WmsContainerMaterialRep.UpdateRangeAsync(updateWmsContainerMaterial); //更新库存表 - 待上架
|
}
|
// 4更新操作履历
|
// 5更新事务记录
|
}
|
await _rep.AsTenant().CommitTranAsync();
|
}
|
catch
|
{
|
await _rep.AsTenant().RollbackTranAsync();
|
throw;
|
}
|
}
|
|
|
|
#region 私有方法
|
|
/// <summary>
|
/// 公共查询报检单条件
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
private ISugarQueryable<WmsOrderQcOutput> CommonPageFilter(WmsOrderQcInput input)
|
{
|
var query = _rep.AsQueryable()
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
|
u.QCNo.Contains(input.SearchKey.Trim())
|
|| u.QCOrderStatusName.Contains(input.SearchKey.Trim())
|
|| u.SupplierName.Contains(input.SearchKey.Trim())
|
|| u.SupplierCode.Contains(input.SearchKey.Trim())
|
|| u.CustCode.Contains(input.SearchKey.Trim())
|
|| u.CustChinaName.Contains(input.SearchKey.Trim())
|
|| u.CustEnglishName.Contains(input.SearchKey.Trim())
|
|| u.RelationNo.Contains(input.SearchKey.Trim())
|
|| u.RelationOrderTypeName.Contains(input.SearchKey.Trim())
|
|| u.Remarks.Contains(input.SearchKey.Trim())
|
|| u.ErpVoucher.Contains(input.SearchKey.Trim())
|
|| u.CreateUserName.Contains(input.SearchKey.Trim())
|
|| u.UpdateUserName.Contains(input.SearchKey.Trim())
|
)
|
.WhereIF(!string.IsNullOrWhiteSpace(input.QCNo), u => u.QCNo.Contains(input.QCNo.Trim()))
|
.WhereIF(input.BusinessType.HasValue, u => u.BusinessType == input.BusinessType)
|
.WhereIF(input.QCOrderStatus.HasValue, u => u.QCOrderStatus == input.QCOrderStatus)
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SupplierName), u => u.SupplierName.Contains(input.SupplierName.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SupplierCode), u => u.SupplierCode.Contains(input.SupplierCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.CustCode), u => u.CustCode.Contains(input.CustCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.CustChinaName), u => u.CustChinaName.Contains(input.CustChinaName.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.CustEnglishName), u => u.CustEnglishName.Contains(input.CustEnglishName.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.RelationNo), u => u.RelationNo.Contains(input.RelationNo.Trim()))
|
.WhereIF(input.RelationOrderType.HasValue, u => u.RelationOrderType == input.RelationOrderType)
|
.WhereIF(!string.IsNullOrWhiteSpace(input.Remarks), u => u.Remarks.Contains(input.Remarks.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.ErpVoucher), u => u.ErpVoucher.Contains(input.ErpVoucher.Trim()))
|
.Select<WmsOrderQcOutput>();
|
return query;
|
}
|
|
/// <summary>
|
/// 重复性验证
|
/// </summary>
|
/// <param name="input">验证对象</param>
|
/// <param name="isEdit">是否是编辑</param>
|
/// <returns></returns>
|
private async Task CheckExist(WmsOrderQc input, bool isEdit = false)
|
{
|
|
|
|
//没有配置组合校验，不需要验重
|
|
|
//没有配置单独校验，不需要验重
|
}
|
#endregion
|
|
}
|
