using Admin.NET.Core.Service;
|
using Admin.NET.Application.Entity;
|
using Microsoft.AspNetCore.Http;
|
using System.Data;
|
using System.Web;
|
using System.Text;
|
using Furion.DatabaseAccessor;
|
using MathNet.Numerics;
|
using DocumentFormat.OpenXml.VariantTypes;
|
|
namespace Admin.NET.Application;
|
/// <summary>
|
/// 波次单明细服务
|
/// </summary>
|
[ApiDescriptionSettings(ApplicationConst.WmsOrderGroupName, Order = 100)]
|
public class WmsOrderSortDetailsService : IDynamicApiController, ITransient
|
{
|
private readonly SqlSugarRepository<WmsOrderSortDetails> _rep;
|
private readonly SqlSugarRepository<WmsOrderSort> _WmsOrderSortRep;
|
private readonly SqlSugarRepository<WmsOrderMovementDetails> _WmsOrderMovementDetailsRep;
|
private readonly SqlSugarRepository<WmsOrderMovement> _WmsOrderMovementRep;
|
private readonly SqlSugarRepository<WmsConfigNoRule> _WmsNoCreateRuleRep;
|
private readonly SqlSugarRepository<WmsConfigSerialSN> _repSNRep;
|
private readonly SqlSugarRepository<WmsBaseBusinessType> _WmsBaseBusinessTypeRep;
|
private readonly SqlSugarRepository<WmsOrderDeliverDetails> _WmsOrderDeliverDetailsRep;
|
private readonly SqlSugarRepository<WmsOrderDeliver> _WmsOrderDeliverRep;
|
private readonly WmsIssueService _wmsIssueService;
|
|
public WmsOrderSortDetailsService(SqlSugarRepository<WmsOrderSortDetails> rep, SqlSugarRepository<WmsOrderSort> wmsOrderSortRep,
|
SqlSugarRepository<WmsOrderMovementDetails> WmsOrderMovementDetailsRep,
|
SqlSugarRepository<WmsOrderMovement> wmsOrderMovementRep,
|
SqlSugarRepository<WmsConfigNoRule> wmsNoCreateRuleRep,
|
SqlSugarRepository<WmsConfigSerialSN> repSNRep,
|
SqlSugarRepository<WmsBaseBusinessType> WmsBaseBusinessTypeRep,
|
SqlSugarRepository<WmsOrderDeliverDetails> WmsOrderDeliverDetailsRep,
|
SqlSugarRepository<WmsOrderDeliver> WmsOrderDeliverRep,
|
WmsIssueService wmsIssueService
|
)
|
{
|
_rep = rep;
|
_WmsOrderSortRep = wmsOrderSortRep;
|
_WmsOrderMovementDetailsRep = WmsOrderMovementDetailsRep;
|
_WmsOrderMovementRep = wmsOrderMovementRep;
|
_WmsNoCreateRuleRep = wmsNoCreateRuleRep;
|
_repSNRep = repSNRep;
|
_WmsBaseBusinessTypeRep = WmsBaseBusinessTypeRep;
|
_WmsOrderDeliverDetailsRep = WmsOrderDeliverDetailsRep;
|
_WmsOrderDeliverRep = WmsOrderDeliverRep;
|
_wmsIssueService = wmsIssueService;
|
}
|
|
/// <summary>
|
/// 分页查询波次单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Page")]
|
[Description("WmsOrderSortDetails/Page")]
|
public async Task<SqlSugarPagedList<WmsOrderSortDetailsOutput>> Page(WmsOrderSortDetailsInput input)
|
{
|
var query = CommonPageFilter(input);
|
return await query
|
.OrderBy(x => x.LineNumber)
|
//.OrderBuilder(input, "", "Id")
|
.ToPagedListAsync(input.Page, input.PageSize);
|
}
|
|
/// <summary>
|
/// 不分页查询波次单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "List")]
|
[Description("WmsOrderSortDetails/List")]
|
public async Task<List<WmsOrderSortDetailsOutput>> List([FromQuery] WmsOrderSortDetailsInput input)
|
{
|
var query = CommonPageFilter(input);
|
return await query.OrderBuilder(input, "", "Id").Select<WmsOrderSortDetailsOutput>().ToListAsync();
|
}
|
|
/// <summary>
|
/// 创建波次-确认
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Add")]
|
[Description("WmsOrderSortDetails/Add")]
|
[UnitOfWork]
|
public async Task<long> Add(List<DiyAddWmsOrderSortDetailsInput> input)
|
{
|
/*
|
1 插入波次主表1条
|
2 插入波次明细表n条
|
3 更新下架单明细表的物料 - 状态 波次数
|
4 更新下架单主表 - 状态
|
5 如果存在DO单的物料 更新状态 波次数 --ly
|
* **/
|
|
if (input is null || input.Count == 0)
|
{
|
throw Oops.Oh("明细不能为空");
|
}
|
var hearId = await AddOrderEFsql(input);
|
return 200;
|
//var entity = input.Adapt<WmsOrderSortDetails>();
|
////重复性验证
|
//await CheckExist(entity);
|
//await _rep.InsertAsync(entity);
|
//return entity.Id;
|
}
|
|
/// <summary>
|
/// 创建波次单并且下发
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "CreateOrderAndIssue")]
|
[Description("WmsOrderSortDetails/CreateOrderAndIssue")]
|
[UnitOfWork]
|
public async Task<long> CreateOrderAndIssue(List<DiyAddWmsOrderSortDetailsInput> input)
|
{
|
if (input is null || input.Count == 0)
|
{
|
throw Oops.Oh("明细不能为空");
|
}
|
var wmsOrderSortDetails = await AddOrderEFsql(input);
|
|
var issueList = wmsOrderSortDetails.Select(n => new IssueInput
|
{
|
SendQuantity = n.Quantity,
|
Batch = n.Batch,
|
SortNo = n.SortNo,
|
SortDetailsId = n.Id,
|
}).ToList();
|
|
await _wmsIssueService.Issue(issueList);
|
return 200;
|
}
|
|
private async Task<List<WmsOrderSortDetails>> AddOrderEFsql(List<DiyAddWmsOrderSortDetailsInput> input)
|
{
|
//-----------新增表头
|
var warehousOrder = new WmsOrderSort();
|
var hearId = Yitter.IdGenerator.YitIdHelper.NextId();
|
warehousOrder.Id = hearId;
|
|
warehousOrder.BusinessType = BusinessTypeEnum.波次下发;
|
warehousOrder.BusinessTypeName = GetEnumDescriptionUtil.GetEnumDescription(BusinessTypeEnum.波次下发);
|
|
var entity = await _WmsBaseBusinessTypeRep.GetFirstAsync(u => u.BusinessTypeValue == (int)warehousOrder.BusinessType);
|
if (entity == null)
|
{
|
throw Oops.Oh("业务类型名称获取失败");
|
}
|
|
// 获取当前时间
|
DateTime currentTime = DateTime.Now;
|
|
// 格式化为年月日字符串
|
string formattedDate = currentTime.ToString("yyyyMMdd");
|
|
//按照单号规则生成单号 - 查找最新的创建的一条单据记录
|
var newestOrder = await _WmsOrderSortRep.AsQueryable().Where(p => p.OrderType == OrderTypeEnum.波次单).Where(p => p.SortNo.Contains(formattedDate)).OrderBy(it => it.CreateTime, OrderByType.Desc)
|
.FirstAsync();
|
|
//ly-按照单号规则生成单号
|
warehousOrder.SortNo = await SerialUtilOrder.GetSerialOrder(OrderTypeEnum.波次单, _WmsNoCreateRuleRep, _repSNRep,
|
(int)warehousOrder.BusinessType, newestOrder == null ? null : newestOrder.SortNo);
|
if (warehousOrder.SortNo == null || warehousOrder.SortNo == "")
|
{
|
warehousOrder.SortNo = Yitter.IdGenerator.YitIdHelper.NextId().ToString();
|
}
|
|
warehousOrder.OrderType = OrderTypeEnum.波次单;
|
warehousOrder.OrderTypeName = OrderTypeEnum.波次单.GetDescription();
|
|
warehousOrder.OrderSocure = SourceByEnum.系统;
|
warehousOrder.SortStatus = OrderStatusEnum.新建;
|
warehousOrder.SortStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
|
|
//-------新增明细
|
var warehousOrderDetails1 = input.Adapt<List<WmsOrderSortDetails>>();
|
for (int i = 0; i < warehousOrderDetails1.Count; i++)
|
{
|
warehousOrderDetails1[i].RelationNo = input[i].MovementNo;
|
}
|
//定义行号
|
int lineNumber = 1;
|
foreach (var w in warehousOrderDetails1)
|
{
|
if (w.Quantity == 0)
|
{
|
throw Oops.Oh("创建失败：数量需要大于0");
|
}
|
if (String.IsNullOrEmpty(w.LineNumber))
|
{
|
throw Oops.Oh("创建失败：行号不能为空");
|
}
|
w.RelationNoLineNumber = w.LineNumber;
|
//系统自己生成行号
|
// string myLineNumeber = (input.Where(x => x.SortNo == w.SortNo).Count()).ToString();
|
string myLineNumeber = lineNumber.ToString();
|
w.LineNumber = OrderHelper.AutoCompleEBELP(myLineNumeber,4);
|
w.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
w.SortNo = warehousOrder.SortNo;
|
w.SortId = warehousOrder.Id;
|
w.SortDetailStatus = OrderStatusEnum.新建;
|
w.SortDetailStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
|
w.OffShelvesQuantity = 0M;
|
w.PickQuantity = 0M;
|
w.IssueQuantity = 0M;
|
lineNumber++;
|
}
|
|
//------------更新下架单的物料-状态 波次数
|
var WmsOrderMovementDetailsArr = new List<WmsOrderMovementDetails>();
|
List<long> queryCodeList = input.Select(v => v.Id).Distinct().ToList();
|
var handleList = await _WmsOrderMovementDetailsRep.GetListAsync(u => queryCodeList.Contains(u.Id) && u.IsDelete == false);
|
foreach (var w in handleList)
|
{
|
//ly 数量可自定义 波次对象
|
var paramWarehousOrderDetails1 = warehousOrderDetails1
|
.FirstOrDefault(x => x.MaterialCode == w.MaterialCode && x.RelationNoLineNumber == w.LineNumber && x.RelationNo == w.MovementNo);
|
if (paramWarehousOrderDetails1 == null)
|
{
|
throw Oops.Oh("创建失败：下架单明细中没有找到相应的物料！");
|
}
|
decimal usedQty = w.Quantity - w.CreateWaveQuantity;
|
if (paramWarehousOrderDetails1.Quantity > usedQty)
|
{
|
throw Oops.Oh($"创建失败：{paramWarehousOrderDetails1.RelationNo}需求数量必须小于订单数{w.Quantity}与波次数量{w.CreateWaveQuantity}之差");
|
}
|
w.CreateWaveQuantity += paramWarehousOrderDetails1.Quantity;
|
w.OrderStatus = OrderStatusEnum.处理中;
|
w.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
|
WmsOrderMovementDetailsArr.Add(w);
|
}
|
|
//------------更新主表下架单-状态
|
var WmsOrderMovementArr = new List<WmsOrderMovement>();
|
List<string> queryCodeListMovement = input.Select(v => v.MovementNo).Distinct().ToList();
|
var handleListZ = await _WmsOrderMovementRep
|
.GetListAsync(u => queryCodeListMovement.Contains(u.OrderNo) && u.IsDelete == false);
|
if (handleListZ==null || handleListZ.Count<=0)
|
{
|
throw Oops.Oh($"创建失败：没有找到下架单");
|
}
|
|
foreach (var w in handleListZ)
|
{
|
w.OrderStatus = OrderStatusEnum.处理中;
|
w.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
|
WmsOrderMovementArr.Add(w);
|
}
|
|
//------------ly-如果存在DO单的物料 更新DO单的物料 - 更新状态 波次数
|
var WmsOrderDeliverDetailsArr = new List<WmsOrderDeliverDetails>();
|
var WmsOrderDeliverArr = new List<WmsOrderDeliver>();
|
List<string> queryCodeListForDo = input.Where(v => !string.IsNullOrWhiteSpace(v.RelationNo)).Select(v => v.RelationNo).Distinct().ToList();
|
if (queryCodeListForDo.Count > 0)
|
{
|
|
//DO单明细
|
var handleListForDo = await _WmsOrderDeliverDetailsRep.GetListAsync(u => queryCodeListForDo.Contains(u.DoNo) && u.IsDelete == false);
|
foreach (var w in handleListForDo)
|
{
|
var item = input.FirstOrDefault(x => x.MaterialCode == w.MaterialCode && x.RelationNoLineNumber == w.DoLineNumber && x.RelationNo == w.DoNo);
|
if (item != null)
|
{
|
var hasUseBoQty = w.CreateMovementQuantity;
|
w.CreateMovementQuantity += item.Quantity;
|
if (w.CreateMovementQuantity > w.Quantity)
|
{
|
throw Oops.Oh($"创建失败：DO单号{w.DoNo},物料编号{w.MaterialCode},DO行号{w.DoLineNumber},订单数{w.Quantity},已创建的波次数{hasUseBoQty},无可用数量!");
|
}
|
w.DoDetailStatus = OrderStatusEnum.处理中;
|
w.DoDetailStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
|
WmsOrderDeliverDetailsArr.Add(w);
|
}
|
|
}
|
//------------end ly更新DO单的物料 - 更新状态 波次数
|
|
//------------ly--更新DO主表下架单-状态
|
if (queryCodeListForDo.Count > 0 && WmsOrderDeliverDetailsArr.Count > 0)
|
{
|
var handleListForDoMain = await _WmsOrderDeliverRep.GetListAsync(u => queryCodeListForDo.Contains(u.DeliverNo) && u.IsDelete == false);
|
if (handleListForDoMain == null || handleListForDoMain.Count <= 0)
|
{
|
throw Oops.Oh("创建失败：没有找到主DO订单单号");
|
}
|
|
foreach (var w in handleListForDoMain)
|
{
|
if (w.DoStatus == OrderStatusEnum.处理中 || w.DoStatus == OrderStatusEnum.新建)
|
{
|
w.DoStatus = OrderStatusEnum.处理中;
|
w.DoStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
|
WmsOrderDeliverArr.Add(w);
|
}
|
else
|
{
|
throw Oops.Oh($"创建失败：DO订单{w.DeliverNo}状态{w.DoStatusName} 不可操作！");
|
}
|
}
|
}
|
//------------ly--end更新DO主表下架单-状态
|
}
|
|
try
|
{
|
// await _rep.AsTenant().BeginTranAsync();
|
if (warehousOrder != null)
|
{
|
await _WmsOrderSortRep.InsertAsync(warehousOrder);//插入波次主表
|
}
|
|
if (warehousOrderDetails1.Count > 0)
|
{
|
await _rep.InsertRangeAsync(warehousOrderDetails1); //插入波次明细表
|
}
|
|
if (WmsOrderMovementDetailsArr.Count > 0)
|
{
|
await _WmsOrderMovementDetailsRep.UpdateRangeAsync(WmsOrderMovementDetailsArr); //更新下架单明细表
|
}
|
if (WmsOrderMovementArr.Count > 0)
|
{
|
await _WmsOrderMovementRep.UpdateRangeAsync(WmsOrderMovementArr); //更新下架单主表
|
}
|
|
////--ly0701 存在DO单 更新Do单波次数
|
if (WmsOrderDeliverDetailsArr.Count > 0)
|
{
|
await _WmsOrderDeliverDetailsRep.UpdateRangeAsync(WmsOrderDeliverDetailsArr); //更新DO单明细表
|
}
|
if (WmsOrderDeliverArr.Count > 0)
|
{
|
await _WmsOrderDeliverRep.UpdateRangeAsync(WmsOrderDeliverArr); //更新DO单主表
|
}
|
//调用公共方法
|
//await _WmsOrderMovementDetailsRep.UpdateRangeAsync(WmsOrderMovementDetailsArr); //更新下架单主表
|
// await _rep.AsTenant().CommitTranAsync();
|
}
|
catch
|
{
|
// await _rep.AsTenant().RollbackTranAsync();
|
throw;
|
}
|
return warehousOrderDetails1;
|
}
|
|
|
|
/// <summary>
|
/// 删除波次单明细
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "Delete")]
|
[Description("WmsOrderSortDetails/Delete")]
|
public async Task Delete(DeleteWmsOrderSortDetailsInput 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("WmsOrderSortDetails/Update")]
|
public async Task Update(UpdateWmsOrderSortDetailsInput input)
|
{
|
var entity = input.Adapt<WmsOrderSortDetails>();
|
|
//重复性验证
|
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("WmsOrderSortDetails/Detail")]
|
public async Task<WmsOrderSortDetails> Detail([FromQuery] QueryByIdWmsOrderSortDetailsInput input)
|
{
|
return await _rep.GetFirstAsync(u => u.Id == input.Id);
|
}
|
|
|
|
|
|
#region 导入
|
|
/// <summary>
|
/// Excel模板导入波次单明细功能
|
/// </summary>
|
/// <param name="file">Excel模板文件</param>
|
/// <returns>导入的记录数</returns>
|
[HttpPost]
|
[ApiDescriptionSettings(Name = "ImportExcel")]
|
[Description("WmsOrderSortDetails/ImportExcel")]
|
public async Task<int> ImportExcelAsync(IFormFile file)
|
{
|
int _HeadStartLine = 2;//第1行是说明,第2行是列名
|
int _DataStartLine = 3;//第3行开始是数据
|
DataTable importDataTable = ExcelUtil.ImportExcelToDataTable(file, _HeadStartLine, _DataStartLine);
|
var addList =await CommonImport(importDataTable, _DataStartLine);
|
await _rep.InsertRangeAsync(addList);
|
return addList.Count;
|
}
|
|
/// <summary>
|
/// DataTable转换实体对象列表
|
/// </summary>
|
/// <param name="dataTable"></param>
|
/// <param name="dataStartLine">模版列名开始行</param>
|
/// <returns></returns>
|
private async Task<List<WmsOrderSortDetails>> CommonImport(DataTable dataTable, int dataStartLine)
|
{
|
var details = new List<WmsOrderSortDetails>();
|
int index = dataStartLine;//模版列名开始行
|
foreach (System.Data.DataRow row in dataTable.Rows)
|
{
|
index++;
|
//导入模版定制化代码（替换模版使用）
|
|
var addItem = new WmsOrderSortDetails();
|
#region 定义变量
|
var _SortId = "";//波次单ID
|
var _SortNo = "";//波次单号
|
var _SortDetailStatus = "";//状态
|
var _SortDetailStatusName = "";//状态名称
|
var _LineNumber = "";//行号
|
var _MaterialCode = "";//物料编号
|
var _MaterialName = "";//物料名称
|
var _RelationNo = "";//关联单号
|
var _RelationNoLineNumber = "";//关联单行号
|
var _SNCode = "";//跟踪码
|
var _Unit = "";//单位
|
var _Quantity = "";//数量
|
var _DispenseQuantity = "";//分配数
|
var _OffShelvesQuantity = "";//下架数
|
var _DeliverQuantity = "";//发货数
|
var _PickQuantity = "";//分拣数
|
var _IssueQuantity = "";//下发数
|
var _BatchRule = "";//批次规则
|
var _Batch = "";//批次
|
var _ErpOrderNo = "";//ERP单号
|
var _ErpCode = "";//ERP库存地
|
#endregion
|
|
|
#region 取值
|
_SortId = row["波次单ID"]?.ToString() ;
|
_SortNo = row["波次单号"]?.ToString() ;
|
_SortDetailStatus = row["状态"]?.ToString() ;
|
_SortDetailStatusName = row["状态名称"]?.ToString() ;
|
_LineNumber = row["行号"]?.ToString() ;
|
_MaterialCode = row["物料编号"]?.ToString() ;
|
_MaterialName = row["物料名称"]?.ToString() ;
|
_RelationNo = row["关联单号"]?.ToString() ;
|
_RelationNoLineNumber = row["关联单行号"]?.ToString() ;
|
_SNCode = row["跟踪码"]?.ToString() ;
|
_Unit = row["单位"]?.ToString() ;
|
_Quantity = row["数量"]?.ToString() ;
|
// _DispenseQuantity = row["分配数"]?.ToString() ;
|
//_OffShelvesQuantity = row["下架数"]?.ToString() ;
|
//_DeliverQuantity = row["发货数"]?.ToString() ;
|
// _PickQuantity = row["分拣数"]?.ToString() ;
|
_IssueQuantity = row["下发数"]?.ToString() ;
|
_BatchRule = row["批次规则"]?.ToString() ;
|
_Batch = row["批次"]?.ToString() ;
|
_ErpOrderNo = row["ERP单号"]?.ToString() ;
|
_ErpCode = row["ERP库存地"]?.ToString() ;
|
#endregion
|
|
|
#region 验证
|
|
if (string.IsNullOrEmpty(_SortId))
|
{
|
throw Oops.Oh($"第{index}行[波次单ID]{_SortId}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_SortId))
|
{
|
if (!long.TryParse(_SortId, out long outSortId)&&!string.IsNullOrEmpty(_SortId))
|
{
|
throw Oops.Oh($"第{index}行[波次单ID]{_SortId}值不正确！");
|
}
|
if (outSortId <= 0&&!string.IsNullOrEmpty(_SortId))
|
{
|
throw Oops.Oh($"第{index}行[波次单ID]{_SortId}值不能小于等于0！");
|
}
|
else
|
{
|
addItem.SortId = outSortId;
|
}
|
|
}
|
|
if (string.IsNullOrEmpty(_SortNo))
|
{
|
throw Oops.Oh($"第{index}行[波次单号]{_SortNo}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_SortNo))
|
{
|
addItem.SortNo = (string)(_SortNo.Trim());
|
}
|
|
if (string.IsNullOrEmpty(_SortDetailStatus))
|
{
|
throw Oops.Oh($"第{index}行[状态]{_SortDetailStatus}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_SortDetailStatus))
|
{
|
Admin.NET.Application.OrderStatusEnum enumSortDetailStatus = default(Admin.NET.Application.OrderStatusEnum);
|
|
if(!Enum.TryParse<Admin.NET.Application.OrderStatusEnum>(_SortDetailStatus, out enumSortDetailStatus)&&!string.IsNullOrEmpty(_SortDetailStatus))
|
{
|
throw Oops.Oh($"第{index}行[状态]{_SortDetailStatus}值不正确！");
|
}
|
else
|
{
|
addItem.SortDetailStatus = enumSortDetailStatus;
|
}
|
|
}
|
|
if (string.IsNullOrEmpty(_SortDetailStatusName))
|
{
|
throw Oops.Oh($"第{index}行[状态名称]{_SortDetailStatusName}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_SortDetailStatusName))
|
{
|
addItem.SortDetailStatusName = (string)(_SortDetailStatusName.Trim());
|
}
|
|
if (string.IsNullOrEmpty(_LineNumber))
|
{
|
throw Oops.Oh($"第{index}行[行号]{_LineNumber}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_LineNumber))
|
{
|
addItem.LineNumber = (string)(_LineNumber.Trim());
|
}
|
|
if (string.IsNullOrEmpty(_MaterialCode))
|
{
|
throw Oops.Oh($"第{index}行[物料编号]{_MaterialCode}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_MaterialCode))
|
{
|
addItem.MaterialCode = (string)(_MaterialCode.Trim());
|
}
|
|
if (string.IsNullOrEmpty(_MaterialName))
|
{
|
throw Oops.Oh($"第{index}行[物料名称]{_MaterialName}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_MaterialName))
|
{
|
addItem.MaterialName = (string)(_MaterialName.Trim());
|
}
|
if(!string.IsNullOrEmpty(_RelationNo))
|
{
|
addItem.RelationNo = (string)(_RelationNo.Trim());
|
}
|
if(!string.IsNullOrEmpty(_RelationNoLineNumber))
|
{
|
addItem.RelationNoLineNumber = (string)(_RelationNoLineNumber.Trim());
|
}
|
|
if (string.IsNullOrEmpty(_SNCode))
|
{
|
throw Oops.Oh($"第{index}行[跟踪码]{_SNCode}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_SNCode))
|
{
|
addItem.SNCode = (string)(_SNCode.Trim());
|
}
|
if(!string.IsNullOrEmpty(_Unit))
|
{
|
addItem.Unit = (string)(_Unit.Trim());
|
}
|
|
if (string.IsNullOrEmpty(_Quantity))
|
{
|
throw Oops.Oh($"第{index}行[数量]{_Quantity}不能为空！");
|
}
|
|
if(!string.IsNullOrEmpty(_Quantity))
|
{
|
if (!decimal.TryParse(_Quantity, out decimal outQuantity)&&!string.IsNullOrEmpty(_Quantity))
|
{
|
throw Oops.Oh($"第{index}行[数量]{_Quantity}值不正确！");
|
}
|
if (outQuantity <= 0&&!string.IsNullOrEmpty(_Quantity))
|
{
|
throw Oops.Oh($"第{index}行[数量]{_Quantity}值不能小于等于0！");
|
}
|
else
|
{
|
addItem.Quantity = outQuantity;
|
}
|
|
}
|
|
if(!string.IsNullOrEmpty(_OffShelvesQuantity))
|
{
|
if (!decimal.TryParse(_OffShelvesQuantity, out decimal outOffShelvesQuantity)&&!string.IsNullOrEmpty(_OffShelvesQuantity))
|
{
|
throw Oops.Oh($"第{index}行[下架数]{_OffShelvesQuantity}值不正确！");
|
}
|
if (outOffShelvesQuantity <= 0&&!string.IsNullOrEmpty(_OffShelvesQuantity))
|
{
|
throw Oops.Oh($"第{index}行[下架数]{_OffShelvesQuantity}值不能小于等于0！");
|
}
|
else
|
{
|
addItem.OffShelvesQuantity = outOffShelvesQuantity;
|
}
|
|
}
|
if(!string.IsNullOrEmpty(_DeliverQuantity))
|
{
|
if (!decimal.TryParse(_DeliverQuantity, out decimal outDeliverQuantity)&&!string.IsNullOrEmpty(_DeliverQuantity))
|
{
|
throw Oops.Oh($"第{index}行[发货数]{_DeliverQuantity}值不正确！");
|
}
|
if (outDeliverQuantity <= 0&&!string.IsNullOrEmpty(_DeliverQuantity))
|
{
|
throw Oops.Oh($"第{index}行[发货数]{_DeliverQuantity}值不能小于等于0！");
|
}
|
else
|
{
|
addItem.DeliverQuantity = outDeliverQuantity;
|
}
|
|
}
|
if(!string.IsNullOrEmpty(_PickQuantity))
|
{
|
if (!decimal.TryParse(_PickQuantity, out decimal outPickQuantity)&&!string.IsNullOrEmpty(_PickQuantity))
|
{
|
throw Oops.Oh($"第{index}行[分拣数]{_PickQuantity}值不正确！");
|
}
|
if (outPickQuantity <= 0&&!string.IsNullOrEmpty(_PickQuantity))
|
{
|
throw Oops.Oh($"第{index}行[分拣数]{_PickQuantity}值不能小于等于0！");
|
}
|
else
|
{
|
addItem.PickQuantity = outPickQuantity;
|
}
|
|
}
|
//if(!string.IsNullOrEmpty(_IssueQuantity))
|
//{
|
// addItem.IssueQuantity = _IssueQuantity;
|
// }
|
if(!string.IsNullOrEmpty(_BatchRule))
|
{
|
addItem.BatchRule = (string)(_BatchRule.Trim());
|
}
|
if(!string.IsNullOrEmpty(_Batch))
|
{
|
addItem.Batch = (string)(_Batch.Trim());
|
}
|
if(!string.IsNullOrEmpty(_ErpOrderNo))
|
{
|
addItem.ErpOrderNo = (string)(_ErpOrderNo.Trim());
|
}
|
if(!string.IsNullOrEmpty(_ErpCode))
|
{
|
addItem.ErpCode = (string)(_ErpCode.Trim());
|
}
|
#endregion
|
|
|
details.Add(addItem);
|
}
|
//验重
|
await CheckExisitForImport(details);
|
return details;
|
}
|
|
/// <summary>
|
/// 根据版本下载波次单明细的Excel导入模板
|
/// </summary>
|
/// <returns>下载的模板文件</returns>
|
[HttpGet]
|
[ApiDescriptionSettings(Name = "DownloadExcelTemplate")]
|
[Description("WmsOrderSortDetails/DownloadExcelTemplate")]
|
public IActionResult DownloadExcelTemplate()
|
{
|
string _path = TemplateConst.EXCEL_TEMPLATEFILE_导入模版路径 + $"\\波次单明细{TemplateConst.EXCEL_TEMPLATEFILE_导入模版名称后缀}.xlsx";
|
var fileName = HttpUtility.UrlEncode($"导入模板(波次单明细).xlsx", Encoding.GetEncoding("UTF-8"));
|
return new FileStreamResult(new FileStream(_path, FileMode.Open), "application/octet-stream") { FileDownloadName = fileName };
|
}
|
|
#endregion
|
|
#region 私有方法
|
|
/// <summary>
|
/// 公共查询波次单明细条件
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
private ISugarQueryable<WmsOrderSortDetailsOutput> CommonPageFilter(WmsOrderSortDetailsInput input)
|
{
|
|
//ly-0606 波次-下发-需要传递的参数
|
if (!string.IsNullOrWhiteSpace(input.OrdersId))
|
{
|
input.OrdersIdList = new List<long>();
|
|
if (input.OrdersId.IndexOf(',') >= 0 || input.OrdersId.IndexOf('，') >= 0)
|
{
|
var list = input.OrdersId.Replace('，', ',').Split(',').ToList();
|
foreach (var item in list)
|
{
|
input.OrdersIdList.Add(Convert.ToInt64(item));
|
}
|
input.OrdersId = string.Empty;
|
}
|
else
|
{
|
input.OrdersIdList.Add(Convert.ToInt64(input.OrdersId));
|
}
|
}
|
var query = _rep.AsQueryable()
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
|
u.SortNo.Contains(input.SearchKey.Trim())
|
|| u.SortDetailStatusName.Contains(input.SearchKey.Trim())
|
|| u.LineNumber.Contains(input.SearchKey.Trim())
|
|| u.MaterialCode.Contains(input.SearchKey.Trim())
|
|| u.MaterialName.Contains(input.SearchKey.Trim())
|
|| u.RelationNo.Contains(input.SearchKey.Trim())
|
|| u.RelationNoLineNumber.Contains(input.SearchKey.Trim())
|
|| u.SNCode.Contains(input.SearchKey.Trim())
|
|| u.Unit.Contains(input.SearchKey.Trim())
|
// || u.IssueQuantity.Contains(input.SearchKey.Trim())
|
|| u.BatchRule.Contains(input.SearchKey.Trim())
|
|| u.Batch.Contains(input.SearchKey.Trim())
|
|| u.ErpOrderNo.Contains(input.SearchKey.Trim())
|
|| u.ErpCode.Contains(input.SearchKey.Trim())
|
|| u.CreateUserName.Contains(input.SearchKey.Trim())
|
|| u.UpdateUserName.Contains(input.SearchKey.Trim())
|
)
|
.WhereIF(input.SortId>0, u => u.SortId == input.SortId)
|
.WhereIF(input.OrdersIdList != null && input.OrdersIdList.Count > 0, u => input.OrdersIdList.Contains(u.SortId)) // 下发波次单-需要传递的参数- 支持多个Id集合查询
|
.WhereIF(input.AbleSendForMateriral==true, u => u.Quantity > u.IssueQuantity) //ly-波次单-下发页面用
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SortNo), u => u.SortNo.Contains(input.SortNo.Trim()))
|
.WhereIF(input.SortDetailStatus.HasValue, u => u.SortDetailStatus == input.SortDetailStatus)
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SortDetailStatusName), u => u.SortDetailStatusName.Contains(input.SortDetailStatusName.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.LineNumber), u => u.LineNumber.Contains(input.LineNumber.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.RelationNo), u => u.RelationNo.Contains(input.RelationNo.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.RelationNoLineNumber), u => u.RelationNoLineNumber.Contains(input.RelationNoLineNumber.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.Unit), u => u.Unit.Contains(input.Unit.Trim()))
|
// .WhereIF(!string.IsNullOrWhiteSpace(input.IssueQuantity), u => u.IssueQuantity.Contains(input.IssueQuantity.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.BatchRule), u => u.BatchRule.Contains(input.BatchRule.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.ErpOrderNo), u => u.ErpOrderNo.Contains(input.ErpOrderNo.Trim()))
|
.WhereIF(!string.IsNullOrWhiteSpace(input.ErpCode), u => u.ErpCode.Contains(input.ErpCode.Trim()))
|
.Select<WmsOrderSortDetailsOutput>();
|
return query;
|
}
|
|
/// <summary>
|
/// 重复性验证
|
/// </summary>
|
/// <param name="input">验证对象</param>
|
/// <param name="isEdit">是否是编辑</param>
|
/// <returns></returns>
|
private async Task CheckExist( WmsOrderSortDetails input,bool isEdit=false)
|
{
|
|
|
|
//没有配置组合校验，不需要验重
|
|
|
//没有配置单独校验，不需要验重
|
}
|
|
/// <summary>
|
/// 根据组合校验和单独校验验证数据是否已存在-导入时验证
|
/// </summary>
|
/// <param name="inputs"></param>
|
/// <returns></returns>
|
private async Task CheckExisitForImport(List<WmsOrderSortDetails> inputs)
|
{
|
if (inputs?.Count <= 0)
|
{
|
throw Oops.Oh($"导入数据不能为空");
|
}
|
//根据组合校验验证表格中中是否已存在相同数据
|
|
|
|
|
|
|
|
|
//根据单独校验验证表格中中是否已存在相同数据
|
|
|
|
}
|
#endregion
|
|
}
|
