using Model.ModelDto;
|
using Model.ModelVm;
|
using SqlSugar;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Linq.Expressions;
|
using Model.InterFaceModel;
|
using Model.ModelDto.BllSoDto;
|
using Model.ModelDto.SysDto;
|
using Newtonsoft.Json;
|
using Utility.Tools;
|
using WMS.BLL.Logic;
|
using WMS.BLL.LogServer;
|
using WMS.DAL;
|
using WMS.Entity.BllAsnEntity;
|
using WMS.Entity.BllSoEntity;
|
using WMS.Entity.Context;
|
using WMS.Entity.DataEntity;
|
using WMS.Entity.LogEntity;
|
using WMS.Entity.SysEntity;
|
using WMS.IBLL.IBllAsnServer;
|
using WMS.Entity.BllQualityEntity;
|
|
namespace WMS.BLL.BllAsnServer
|
{
|
public class PalletBindServer : DbHelper<BllPalletBind>, IPalletBindServer
|
{
|
private static readonly SqlSugarScope Db = DataContext.Db;
|
public PalletBindServer() : base(Db)
|
{
|
}
|
|
#region 接口方法
|
|
//JC26绑定物料托盘即增加库存
|
public void BindPalletStock(BoxPalletBindVm model, int userId)
|
{
|
try
|
{
|
#region 判断
|
|
//判断托盘是否在库外
|
var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
|
if (stockDetail != null)
|
{
|
if (!string.IsNullOrWhiteSpace(stockDetail.LocatNo))
|
{
|
throw new Exception("该托盘已有库存信息，请核实！");
|
}
|
return;
|
}
|
if (model.Type != "0" && model.Type != "1")
|
{
|
throw new Exception("托盘类型错误");
|
}
|
if (string.IsNullOrEmpty(model.PalletNo))
|
{
|
throw new Exception("托盘号不可为空!");
|
}
|
|
if (model.Detail.Count == 0)
|
{
|
throw new Exception("托盘绑定明细信息为空，请核实");
|
}
|
BllArrivalNotice notice = null;
|
BllArrivalNoticeDetail detail = null;
|
if (model.Type == "0")
|
{
|
//0：成品入库 1：采购入库 3：退货入库 4：车间余料入库 5：其它入库 6：代储入库
|
if (string.IsNullOrEmpty(model.AsnNo))
|
{
|
throw new Exception("单据号不可为空!");
|
}
|
//if (model.AsnDetailNo == 0)
|
//{
|
// throw new Exception("单据明细不可为空!");
|
//}
|
//根据单据号获取入库单总单
|
notice = Db.Queryable<BllArrivalNotice>().First(a => a.IsDel == "0" && a.ASNNo == model.AsnNo && a.OrderCode == model.OrderCode);
|
if (notice.Status != "0" && notice.Status != "1" && notice.Status != "2")
|
{
|
throw new Exception("该单据已关单!");
|
}
|
if (notice.Type != "0")
|
{
|
throw new Exception("当前单据不能生产成品入库，请核实");
|
}
|
if (string.IsNullOrEmpty(model.LotNo))
|
{
|
throw new Exception("批次不能为空!");
|
}
|
// 验证入库单明细是否存在
|
detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0"
|
&& m.ASNNo == model.AsnNo && m.LotNo == model.LotNo && m.SkuNo == model.SkuNo);
|
if (detail == null)
|
{
|
throw new Exception("当前物料及批次与单据无关联，请核实!");
|
}
|
model.AsnDetailNo = detail.Id;
|
}
|
|
|
|
|
#endregion
|
|
Db.BeginTran();
|
|
var comTime = DateTime.Now;
|
|
//托盘是否存在
|
var pallet = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
|
if (pallet == null)
|
{
|
throw new Exception("未查询到托盘信息，请核实！");
|
}
|
|
|
|
#region 包装
|
var package = Db.Queryable<SysPackag>().Where(m => m.IsDel == "0");
|
var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == model.SkuNo);
|
SysPackag pack = null;
|
if (model.Type == "0")
|
{
|
pack = package.First(m => m.IsDel == "0" && m.PackagNo == detail.PackagNo); // liudl 由Sku包装编号变更为入库单明细包装编号
|
}
|
else
|
{
|
pack = package.First(m => m.IsDel == "0" && m.PackagNo == sku.PackagNo); // liudl 由Sku包装编号变更为入库单明细包装编号
|
}
|
|
|
var pNum = 0;//托盘物品数量
|
var bNum = 0;//箱码物品数量
|
|
if (pack == null)
|
{
|
throw new Exception("获取物料包装失败，请核实!");
|
}
|
if (pack.L5Num.HasValue)
|
{
|
pNum = (int)pack.L5Num;
|
bNum = (int)pack.L4Num;
|
}
|
else if (pack.L4Num.HasValue)
|
{
|
pNum = (int)pack.L4Num;
|
bNum = (int)pack.L3Num;
|
}
|
else if (pack.L3Num.HasValue)
|
{
|
pNum = (int)pack.L3Num;
|
bNum = (int)pack.L2Num;
|
}
|
else if (pack.L2Num.HasValue)
|
{
|
pNum = (int)pack.L2Num;
|
bNum = (int)pack.L1Num;
|
}
|
else if (pack.L1Num.HasValue)
|
{
|
pNum = (int)pack.L1Num;
|
bNum = (int)pack.L1Num;
|
}
|
if (pNum == 0 || bNum == 0)
|
{
|
throw new Exception($"绑定失败，{detail.SkuNo}物品包装未找到！");
|
}
|
|
#endregion
|
|
#region 验证是否允许立库同托盘不同物料入库或同托盘同物料不同批次入库
|
var list = model.Detail.GroupBy(m => new { m.SkuNo, m.LotNo }).ToList();
|
|
if (list.Count >= 2)
|
{
|
var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "Fun045");
|
if (funSetting == null || funSetting.IsEnable == "OFF")
|
{
|
throw new Exception($"不允许立库同托盘不同物料入库或同托盘不同批次入库！");
|
}
|
}
|
|
#endregion
|
|
//liudl && m.Status != "2" 组盘既入库完成无需根据托盘状态判断
|
var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == model.AsnDetailNo && m.PalletNo == model.PalletNo);
|
var bindId = 0;
|
if (bind == null)
|
{
|
bind = new BllPalletBind
|
{
|
ASNNo = model.AsnNo,
|
ASNDetailNo = model.AsnDetailNo,
|
PalletNo = model.PalletNo,
|
PalletNo2 = "",
|
PalletNo3 = "",
|
Qty = model.Qty,
|
FullQty = pNum,
|
Status = "2",//入库完成
|
Type = model.Type, //托盘类型 0物料托 1空托盘托
|
LotNo = model.LotNo,
|
LotText = model.LotText,
|
SupplierLot = model.SupplierLot,
|
//InspectMark = model.IsSample, //是否取样托盘 后期业务开发时 接口传值需添加对应字段判断
|
//SamplingQty = 0, //取样数量 后期业务开发时 接口传值需添加对应字段判断
|
BitPalletMark = model.Qty == pNum ? "0" : "1",
|
IsBale = "0",
|
IsBelt = "0",
|
CreateUser = userId,
|
|
};
|
if (bind.FullQty < bind.Qty)
|
{
|
throw new Exception("托盘绑定数量已超出该物料包装数量");
|
}
|
// 插入托盘绑定表
|
bindId = Db.Insertable(bind).ExecuteReturnIdentity();
|
}
|
else
|
{
|
throw new Exception("组盘信息重复");
|
}
|
|
#region 库存明细
|
//获取该批次最终质检结果
|
BllQualityInspect quality = new BllQualityInspect();
|
if (model.Type == "0")
|
{
|
quality = Db.Queryable<BllQualityInspect>()
|
.Where(a => a.IsDel == "0" && a.SkuNo == detail.SkuNo && a.LotNo == detail.LotNo)
|
.OrderByDescending(a => a.CreateTime).First();
|
}
|
|
DataStockDetail sd1 = null;
|
// 判断库存明细是否已有此托盘信息
|
if (model.Type == "0")
|
{
|
sd1 = Db.Queryable<DataStockDetail>()
|
.First(m => m.IsDel == "0" && m.ASNDetailNo == bind.ASNDetailNo && m.PalletNo == model.PalletNo);
|
}
|
else
|
{
|
sd1 = Db.Queryable<DataStockDetail>()
|
.First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
|
}
|
|
var sdId1 = 0;
|
if (sd1 != null)
|
{
|
throw new Exception("库存中已有此托盘信息，请核实");
|
}
|
else
|
{
|
// 库存不存在 插入数据
|
sd1 = new DataStockDetail()
|
{
|
LotNo = bind.LotNo,
|
LotText = bind.LotText,
|
SupplierLot = bind.SupplierLot,
|
SkuNo = sku.SkuNo,
|
SkuName = sku.SkuName,
|
Standard = sku.Standard,
|
Qty = bind.Qty,
|
LockQty = 0,
|
FrozenQty = 0,
|
InspectQty = 0,
|
ASNNo = bind.ASNNo,
|
ASNDetailNo = bind.ASNDetailNo,
|
WareHouseNo = "W01",//所属仓库
|
RoadwayNo = "",//所属巷道
|
AreaNo = "",//所属区域
|
LocatNo = "",//储位地址
|
PalletNo = bind.PalletNo,
|
PalletNo2 = bind.PalletNo2,
|
PalletNo3 = bind.PalletNo3,
|
PalletTags = "0",
|
CompleteTime = comTime,
|
ProductionTime = bind.ProductionTime,
|
ExpirationTime = bind.ExpirationTime,
|
Status = "0",
|
InspectMark = bind.InspectMark,
|
InspectStatus = sku.IsInspect,
|
BitPalletMark = bind.BitPalletMark,
|
PackagNo = model.Type == "0" ? detail.PackagNo : sku.PackagNo, //liudl 由sku的包装编号变为入库单明细的包装编码
|
IsBale = bind.IsBale,
|
IsBelt = bind.IsBelt,
|
OwnerNo = model.Type == "0" ? notice.CustomerNo : null,//货主编码
|
OwnerName = model.Type == "0" ? notice.CustomerName : null,//货主名称
|
IsDel = "0",
|
CreateUser = 0,
|
CreateTime = comTime
|
};
|
//修改质检信息合格与不合格数量 库存托盘明细质检状态
|
if (quality != null)
|
{
|
//修改合格不合格数量
|
if (quality.IsQualified == "1") //合格
|
{
|
//增加合格数量
|
quality.PassQty += bind.Qty;
|
sd1.InspectStatus = "1";
|
}
|
else if (quality.IsQualified == "0") //不合格
|
{
|
//增加不合格数量
|
quality.FailQty += bind.Qty;
|
sd1.InspectStatus = "2";
|
}
|
Db.Updateable(quality).ExecuteCommand(); //修改质检信息
|
}
|
//添加库存明细
|
sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
|
}
|
#endregion
|
|
#region 箱码信息
|
decimal factQty = 0.00m;//托盘总数量
|
|
var boxInfoList = new List<BllBoxInfo>();
|
if (model.Type == "1")//托盘托
|
{
|
if (model.Detail.Count > 1)
|
{
|
throw new Exception("空托盘绑定信息中明细错误，超过了两条明细");
|
}
|
decimal boxFullQty = 0;//箱内总数量
|
//添加箱码信息/空托盘明细信息
|
foreach (var box in model.Detail)
|
{
|
var boxInfo = new BllBoxInfo()
|
{
|
ASNNo = model.AsnNo,
|
ASNDetailNo = model.AsnDetailNo,
|
OrderCode = box.OrderCode,
|
BindNo = bindId,
|
BoxNo = box.BoxNo,
|
BoxNo2 = box.BoxNo2,
|
BoxNo3 = box.BoxNo3,
|
PalletNo = model.PalletNo,
|
Qty = box.Qty,
|
FullQty = box.FullQty,
|
Status = "2",//入库即完成
|
SkuNo = box.SkuNo,
|
SkuName = box.SkuName,
|
LotNo = box.LotNo,
|
LotText = box.LotText,
|
SupplierLot = model.SupplierLot,
|
ProductionTime = box.ProductionTime,
|
ExpirationTime = box.ExpirationTime,
|
CompleteTime = comTime,
|
InspectMark = box.InspectMark,
|
BitBoxMark = box.BitBoxMark,
|
InspectStatus = box.InspectStatus,
|
Origin = "WCS",
|
Standard = box.Standard,
|
PackageStandard = box.PackageStandard,
|
StoreTime = box.StoreTime,
|
CreateUser = userId,
|
CreateTime = comTime,
|
};
|
|
boxInfoList.Add(boxInfo);
|
factQty += box.Qty;
|
|
#region 库存箱码明细
|
var box2 = new DataBoxInfo()
|
{
|
StockDetailId = sdId1,
|
BindNo = bind.Id,
|
BoxNo = box.BoxNo,
|
BoxNo2 = box.BoxNo2,
|
BoxNo3 = box.BoxNo3,
|
PalletNo = model.PalletNo,
|
Qty = box.Qty,
|
FullQty = box.FullQty,
|
Status = "2",//0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
|
LotNo = box.LotNo,
|
LotText = box.LotText,
|
SkuNo = box.SkuNo,
|
SkuName = box.SkuName,
|
Standard = sku.Standard,
|
ProductionTime = box.ProductionTime,
|
SupplierLot = model.SupplierLot,
|
InspectStatus = sku.IsInspect,
|
InspectMark = box.InspectMark,
|
BitBoxMark = box.BitBoxMark,
|
ExpirationTime = box.ExpirationTime,
|
|
CreateUser = 0,
|
CreateTime = comTime
|
};
|
//添加库存箱码明细
|
Db.Insertable(box2).ExecuteCommand();
|
#endregion
|
}
|
if (boxFullQty > bNum)
|
{
|
throw new Exception($"绑定失败，托盘绑定数量大于该物品包装数量！");
|
}
|
}
|
else if (model.Type == "0")//物料托
|
{
|
// 使用场景不明确
|
//if (model.Detail.Count(m => m.OrderCode != detail.OrderDetailCode) > 0)
|
//{
|
// throw new Exception($"托盘绑定明细中，含有箱码生产工单不一致");
|
//}
|
if (model.Detail.Count(m => m.SkuNo != model.SkuNo || m.LotNo != model.LotNo) > 0)
|
{
|
throw new Exception($"托盘绑定明细中，含有箱码物料或批次不一致");
|
}
|
var boxGroup = model.Detail.GroupBy(m => m.BoxNo).ToList();
|
foreach (var g in boxGroup)
|
{
|
decimal boxFullQty = 0;//箱内总数量
|
foreach (var box in g)
|
{
|
factQty += box.Qty;
|
boxFullQty += box.Qty;
|
var boxInfo = new BllBoxInfo()
|
{
|
ASNNo = model.AsnNo,
|
ASNDetailNo = model.AsnDetailNo,
|
OrderCode = box.OrderCode,
|
BindNo = bindId,
|
BoxNo = box.BoxNo,
|
BoxNo2 = box.BoxNo2,
|
BoxNo3 = box.BoxNo3,
|
PalletNo = model.PalletNo,
|
Qty = box.Qty,
|
FullQty = box.FullQty,
|
Status = "2",//入库即完成
|
SkuNo = box.SkuNo,
|
SkuName = box.SkuName,
|
LotNo = box.LotNo,
|
LotText = box.LotText,
|
SupplierLot = model.SupplierLot,
|
ProductionTime = box.ProductionTime,
|
ExpirationTime = box.ExpirationTime,
|
CompleteTime = comTime,
|
InspectMark = box.InspectMark,
|
BitBoxMark = box.BitBoxMark,
|
InspectStatus = box.InspectStatus,
|
Origin = "WCS",
|
Standard = box.Standard,
|
PackageStandard = box.PackageStandard,
|
StoreTime = box.StoreTime,
|
QtyCount = box.QtyCount,
|
QtyOrd = box.QtyOrd,
|
CreateUser = userId,
|
CreateTime = comTime,
|
};
|
boxInfoList.Add(boxInfo);
|
|
#region 库存箱码明细
|
var box2 = new DataBoxInfo()
|
{
|
StockDetailId = sdId1,
|
BindNo = bind.Id,
|
BoxNo = box.BoxNo,
|
BoxNo2 = box.BoxNo2,
|
BoxNo3 = box.BoxNo3,
|
PalletNo = model.PalletNo,
|
Qty = box.Qty,
|
FullQty = box.FullQty,
|
Status = "2",//0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
|
LotNo = box.LotNo,
|
LotText = box.LotText,
|
SkuNo = box.SkuNo,
|
SkuName = box.SkuName,
|
Standard = sku.Standard,
|
ProductionTime = box.ProductionTime,
|
SupplierLot = model.SupplierLot,
|
InspectStatus = sku.IsInspect,
|
InspectMark = box.InspectMark,
|
BitBoxMark = box.BitBoxMark,
|
ExpirationTime = box.ExpirationTime,
|
|
CreateUser = 0,
|
CreateTime = comTime
|
};
|
//添加库存箱码明细
|
Db.Insertable(box2).ExecuteCommand();
|
#endregion
|
}
|
if (boxFullQty > bNum)
|
{
|
throw new Exception($"绑定失败，{g.Key}箱码绑定数量大于该物品包装数量！");
|
}
|
}
|
}
|
|
Db.Insertable(boxInfoList).ExecuteCommand();
|
#endregion
|
|
|
if (factQty != bind.Qty)
|
{
|
throw new Exception("箱码明细总数量不同于托盘总数量，请核实");
|
}
|
|
#region 入库单及明细
|
if (model.Type == "0")
|
{
|
detail.FactQty += factQty;//已组数量
|
detail.CompleteQty += factQty;//完成数量
|
|
detail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
|
if (detail.CompleteQty >= detail.Qty)
|
{
|
detail.Status = "2";
|
detail.CompleteTime = comTime;
|
}
|
detail.UpdateUser = userId;
|
detail.UpdateTime = comTime;
|
//更新入库单明细
|
Db.Updateable(detail).ExecuteCommand();
|
|
notice.UpdateUser = userId;
|
notice.UpdateTime = comTime;
|
if (notice.Status == "0")
|
{
|
notice.Status = "1";
|
}
|
var asnDetailNum = Db.Queryable<BllArrivalNoticeDetail>().Count(m => m.IsDel == "0" && m.ASNNo == detail.ASNNo && m.Status != "2");
|
if (asnDetailNum == 0)
|
{
|
notice.Status = "2";
|
notice.CompleteTime = comTime;//完成时间
|
}
|
//更新入库单
|
Db.Updateable(notice).ExecuteCommand();
|
}
|
|
#endregion
|
|
#region 库存
|
var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo);
|
if (dataStock != null)
|
{
|
dataStock.Qty += factQty;
|
|
if (bind.InspectMark == "1")
|
{
|
dataStock.IsSampling = bind.InspectMark;
|
}
|
Db.Updateable(dataStock).ExecuteCommand();
|
}
|
else
|
{
|
var stock = new DataStock()
|
{
|
SkuNo = sku.SkuNo,
|
SkuName = sku.SkuName,
|
Standard = sku.Standard,
|
LotNo = bind.LotNo,
|
LotText = bind.LotText,
|
Qty = bind.Qty,
|
LockQty = 0,
|
FrozenQty = 0,
|
IsSampling = bind.InspectMark,
|
IsDel = "0",
|
CreateUser = userId,
|
CreateTime = comTime
|
};
|
if (model.Type == "0")
|
{
|
//维护库存货主信息//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
|
if (notice.Type == "0" || notice.Type == "2" || notice.Type == "4" || notice.Type == "6" || notice.Type == "7")
|
{
|
stock.OwnerNo = notice.CustomerNo;//货主编码
|
stock.OwnerName = notice.CustomerName;//货主名称
|
}
|
}
|
Db.Insertable(stock).ExecuteCommand();
|
}
|
#endregion
|
|
// 更改托盘使用状态
|
var sqlStr = $"update SysPallets set Status = '1' where PalletNo = '{model.PalletNo}';";
|
//添加托盘记录表数据
|
sqlStr += $"insert into LogPalletTrack values('{model.PalletNo}','{model.AsnNo}','组盘','0',getDate(),{userId},NULL,NULL);";
|
Db.Ado.ExecuteCommand(sqlStr);
|
new OperationASNServer().AddLogOperationAsn("PDA模块", "托盘绑定", model.AsnNo, "添加", $"添加了托盘码为：{model.PalletNo}的组盘信息", userId);
|
|
Db.CommitTran();
|
}
|
catch (Exception e)
|
{
|
Db.RollbackTran();
|
throw new Exception(e.Message);
|
}
|
}
|
|
#endregion
|
|
#region 组托收货 JC34
|
|
/// <summary>
|
/// 组托收货列表
|
/// </summary>
|
/// <param name="model"></param>
|
/// <param name="count"></param>
|
/// <returns></returns>
|
/// <exception cref="Exception"></exception>
|
public List<PalletBindDto> GetPalletBindList(PalletBindVm model, out int count)
|
{
|
try
|
{
|
var strList = new List<int>();
|
|
if (!string.IsNullOrWhiteSpace(model.SkuNo) || !string.IsNullOrWhiteSpace(model.SkuName))
|
{
|
var detailList = Db.Queryable<BllArrivalNoticeDetail>()
|
.Where(m => m.IsDel == "0" && m.SkuNo.Contains(model.SkuNo.Trim()) && m.SkuName.Contains(model.SkuName.Trim()))
|
.Select(m => m.Id).Distinct().ToList();
|
strList = detailList;
|
if (strList.Count <= 0)
|
{
|
// 物料编码、名称检索失败直接返回null
|
count = 0;
|
return null;
|
}
|
|
}
|
Expression<Func<BllPalletBind, bool>> item = Expressionable.Create<BllPalletBind>()
|
.AndIF(!string.IsNullOrWhiteSpace(model.ASNNo), it => it.ASNNo.Contains(model.ASNNo.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.PalletNo), it => it.PalletNo.Contains(model.PalletNo.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.LocatNo), it => it.LocatNo.Contains(model.LocatNo.Trim()))
|
.AndIF(!string.IsNullOrEmpty(model.RoadwayNo), a => a.RoadwayNo == model.RoadwayNo)
|
.AndIF(!string.IsNullOrEmpty(model.WareHouseNo), a => a.WareHouseNo == model.WareHouseNo)
|
.AndIF(strList.Count > 0, it => strList.Contains((int)it.ASNDetailNo))
|
.AndIF(!string.IsNullOrWhiteSpace(model.LotNo), it => it.LotNo.Contains(model.LotNo.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.LotText), it => it.LotText.Contains(model.LotText.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.StartTime), it => it.CreateTime >= Convert.ToDateTime(model.StartTime))
|
.AndIF(!string.IsNullOrWhiteSpace(model.EndTime), it => it.CreateTime <= Convert.ToDateTime(model.EndTime).AddDays(1))
|
.AndIF(!string.IsNullOrWhiteSpace(model.Status), it => it.Status == model.Status)
|
.And(m => m.IsDel == "0")
|
.ToExpression();//注意 这一句 不能少
|
var total = 0;
|
var sku = Db.Queryable<SysMaterials>().First(a => a.IsDel == "0" && a.SkuNo == "100099" && a.SkuName == "托盘");
|
var data = GetAllWhereAsync(item)
|
.LeftJoin<BllArrivalNoticeDetail>((a, b) => a.ASNDetailNo == b.Id)
|
.LeftJoin<SysUserInfor>((a, b, c) => a.CreateUser == c.Id)
|
.LeftJoin<SysUserInfor>((a, b, c, d) => a.UpdateUser == d.Id)
|
//.LeftJoin<SysStorageLocat>((a, b, c, d, e) => a.LocatNo == e.LocatNo)
|
.LeftJoin<SysWareHouse>((a, b, c, d,f) => a.WareHouseNo == f.WareHouseNo)
|
.LeftJoin<SysStorageRoadway>((a, b, c, d, f,g) => a.RoadwayNo == g.RoadwayNo)
|
.Select((a, b, c, d,f,g) => new PalletBindDto()
|
{
|
Id = a.Id,
|
ASNNo = a.ASNNo,
|
ASNDetailNo = a.ASNDetailNo,
|
|
PalletNo = a.PalletNo,
|
PalletNo2 = a.PalletNo2,
|
PalletNo3 = a.PalletNo3,
|
LocatNo = a.LocatNo,
|
RoadwayNo = a.RoadwayNo,
|
RoadwayName = g.RoadwayName,
|
WareHouseNo = a.WareHouseNo,
|
WareHouseName = a.WareHouseNo+"-"+f.WareHouseName,
|
Qty = a.Qty,
|
FullQty = a.FullQty,
|
SamplingQty = a.SamplingQty,
|
Status = a.Status,
|
Type = a.Type,
|
CompleteTime = a.CompleteTime,
|
|
SkuNo = (b.SkuNo == null && a.Type == "1") ? sku.SkuNo : b.SkuNo,
|
SkuName = (b.SkuName == null && a.Type == "1") ? sku.SkuName : b.SkuName,
|
|
LotNo = a.LotNo,
|
LotText = a.LotText,
|
ProductionTime = a.ProductionTime,
|
ExpirationTime = a.ExpirationTime,
|
SupplierLot = a.SupplierLot,
|
InspectMark = a.InspectMark,
|
BitPalletMark = a.BitPalletMark,
|
|
CreateUserName = c.RealName,
|
CreateTime = a.CreateTime,
|
})
|
.OrderBy(a => a.Status).OrderByDescending(a => a.CreateTime)
|
.ToOffsetPage(model.Page, model.Limit, ref total);
|
|
count = data.Count;
|
return data;
|
|
}
|
catch (Exception ex)
|
{
|
throw new Exception(ex.Message);
|
}
|
}
|
|
/// <summary>
|
/// 明细列表
|
/// </summary>
|
/// <param name="model"></param>
|
/// <param name="count"></param>
|
/// <returns></returns>
|
public List<BoxInfoDto> GetBoxInfoList(BoxInfoVm model, out int count)
|
{
|
try
|
{
|
Expression<Func<BllBoxInfo, bool>> item1 = Expressionable.Create<BllBoxInfo>()
|
.AndIF(!string.IsNullOrWhiteSpace(model.ASNNo), it => it.ASNNo.Contains(model.ASNNo.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.PalletNo), it => it.PalletNo.Contains(model.PalletNo.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.LotNo), it => it.LotNo.Contains(model.LotNo.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.SkuNo), it => it.SkuNo.Contains(model.SkuNo.Trim()))
|
.AndIF(!string.IsNullOrWhiteSpace(model.SkuName), it => it.SkuName.Contains(model.SkuName.Trim()))
|
.AndIF((model.BindNo != 0 && !string.IsNullOrWhiteSpace(model.BindNo.ToString())), it => it.BindNo == model.BindNo)
|
.And(m => m.IsDel == "0")
|
.ToExpression();
|
|
var total = 0;
|
DbHelper<BllBoxInfo> helper = new DbHelper<BllBoxInfo>(Db);
|
var data = helper.GetAllWhereAsync(item1).Where(m => m.IsDel == "0")
|
.LeftJoin<BllPalletBind>((a, b) => a.BindNo == b.Id)
|
.GroupBy((a, b) => new
|
{
|
a.PalletNo,
|
a.BindNo,
|
a.BoxNo,
|
a.SkuNo,
|
a.SkuName,
|
a.LotNo,
|
a.LotText,
|
a.SupplierLot,
|
a.FullQty,
|
a.ProductionTime,
|
a.ExpirationTime,
|
a.InspectMark,
|
a.BitBoxMark,
|
a.InspectStatus,
|
b.Status
|
})
|
.Select((a, b) => new BoxInfoDto()
|
{
|
BoxNo = a.BoxNo,
|
PalletNo = a.PalletNo,
|
BindNo = a.BindNo,
|
Qty = SqlFunc.AggregateSum(a.Qty),
|
SamplingQty = SqlFunc.AggregateSum(a.SamplingQty),
|
FullQty = a.FullQty,
|
SkuNo = a.SkuNo,
|
SkuName = a.SkuName,
|
LotNo = a.LotNo,
|
LotText = a.LotText,
|
ProductionTime = a.ProductionTime,
|
ExpirationTime = a.ExpirationTime,
|
SupplierLot = a.SupplierLot,
|
InspectMark = a.InspectMark,
|
BitBoxMark = a.BitBoxMark,
|
InspectStatus = a.InspectStatus,
|
BindStatus = b.Status
|
}).ToOffsetPage(model.Page, model.Limit, ref total);
|
count = total;
|
return data;
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
}
|
|
/// <summary>
|
/// 根据箱码获取箱支信息
|
/// </summary>
|
/// <param name="boxNo">箱码</param>
|
/// <param name="boxNo3">支码</param>
|
/// <returns></returns>
|
public List<BoxInfoDto> GetBoxInfoByBoxNo(string boxNo, string boxNo3, int bindNo)
|
{
|
Expression<Func<BllBoxInfo, bool>> item = Expressionable.Create<BllBoxInfo>()
|
.AndIF(!string.IsNullOrWhiteSpace(boxNo), it => it.BoxNo == boxNo.Trim())
|
.AndIF(!string.IsNullOrWhiteSpace(boxNo3), it => it.BoxNo3.Contains(boxNo3.Trim()))
|
.AndIF(bindNo != 0, it => it.BindNo == bindNo)
|
.And(m => m.IsDel == "0")
|
.ToExpression();
|
|
var data = Db.Queryable<BllBoxInfo>().Where(item)
|
.LeftJoin<SysUserInfor>((a, b) => a.CreateUser == b.Id)
|
.LeftJoin<SysUserInfor>((a, b, c) => a.UpdateUser == c.Id)
|
.Select((a, b, c) => new BoxInfoDto()
|
{
|
Id = a.Id,
|
ASNNo = a.ASNNo,
|
ASNDetailNo = a.ASNDetailNo,
|
BindNo = a.BindNo,
|
BoxNo = a.BoxNo,
|
BoxNo3 = a.BoxNo3,
|
PalletNo = a.PalletNo,
|
Qty = a.Qty,
|
FullQty = a.FullQty,
|
|
Status = a.Status,
|
SkuNo = a.SkuNo,
|
SkuName = a.SkuName,
|
LotNo = a.LotNo,
|
LotText = a.LotText,
|
ProductionTime = a.ProductionTime,
|
ExpirationTime = a.ExpirationTime,
|
CompleteTime = a.CompleteTime,
|
SupplierLot = a.SupplierLot,
|
InspectStatus = a.InspectStatus,
|
InspectMark = a.InspectMark,
|
BitBoxMark = a.BitBoxMark,
|
Origin = a.Origin,
|
|
CreateUserName = b.RealName,
|
UpdateUserName = c.RealName,
|
CreateTime = a.CreateTime,
|
UpdateTime = a.UpdateTime
|
}).ToList();
|
|
return data;
|
}
|
|
/// <summary>
|
/// 删除托盘绑定信息
|
/// </summary>
|
/// <param name="id"></param>
|
/// <param name="userId"></param>
|
/// <exception cref="Exception"></exception>
|
public void DelPalletBind(int id, int userId)
|
{
|
try
|
{
|
//获取托盘绑定信息
|
var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Id == id);
|
if (bind == null)
|
{
|
throw new Exception("未查询到托盘绑定信息");
|
}
|
|
#region 验证当前托盘信息是否可删除
|
// 判断订单是否关闭
|
var asnData = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == bind.ASNNo);
|
if (asnData != null)
|
{
|
if (asnData.Status == "3" || asnData.Status == "4")
|
{
|
throw new Exception("单据已关单不可删除");
|
}
|
}
|
|
// 判断是否已有巷道和储位
|
if (!string.IsNullOrWhiteSpace(bind.LocatNo) || !string.IsNullOrWhiteSpace(bind.RoadwayNo))
|
{
|
throw new Exception("托盘已上架不可删除组托");
|
}
|
|
// 判断此托盘是否已分配 (收货后不上架可以被分配)
|
var dataBindItem = Db.Queryable<DataStockDetail>()
|
.First(m => m.IsDel == "0" && m.ASNDetailNo == bind.ASNDetailNo && m.ASNNo == bind.ASNNo && m.PalletNo == bind.PalletNo);
|
|
if (dataBindItem == null)
|
{
|
throw new Exception("库内不存在此托盘!");
|
}
|
else
|
{
|
if (dataBindItem.Status != "0")
|
{
|
throw new Exception("托盘不是待分配状态，不可删除");
|
}
|
}
|
|
// 验证此托盘上货物是否被锁定
|
var dataStocks = Db.Queryable<DataStock>()
|
.First(m => m.LotNo == dataBindItem.LotNo && m.IsDel == "0" && m.SkuNo == dataBindItem.SkuNo);
|
if (dataStocks == null)
|
{
|
throw new Exception("库内不存在此托盘上物料批次信息!");
|
}
|
if (dataStocks.Qty - dataBindItem.Qty < dataStocks.LockQty)
|
{
|
throw new Exception("托盘上货物已被锁定不可删除");
|
}
|
|
// 验证库内托盘信息和绑定托盘信息是否一致
|
var bllboxItem = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == bind.Id).ToList();
|
var databoxItem = new List<DataBoxInfo>();
|
if (bllboxItem.Count == 0)
|
{
|
// 按数量组托，没有箱支关系
|
if (dataBindItem.ASNDetailNo != bind.ASNDetailNo
|
|| dataBindItem.ASNNo != bind.ASNNo
|
|| dataBindItem.LotNo != bind.LotNo
|
|| dataBindItem.Qty != bind.Qty)
|
{
|
throw new Exception("托盘上货物已变更不可删除");
|
}
|
}
|
else
|
{
|
// 循环对比箱支关系是否存在
|
foreach (BllBoxInfo box in bllboxItem)
|
{
|
var databox = Db.Queryable<DataBoxInfo>()
|
.First(m => m.IsDel == "0" && m.BoxNo == box.BoxNo
|
&& m.BoxNo2 == box.BoxNo2 && m.BoxNo3 == box.BoxNo3);
|
|
if (databox == null)
|
{
|
throw new Exception("托盘上货物已变更不可删除");
|
}
|
var dataBox = Db.Queryable<DataBoxInfo>().First(m => m.IsDel == "0" && m.BoxNo == box.BoxNo
|
&& m.BoxNo2 == box.BoxNo2 && m.BoxNo3 == box.BoxNo3);
|
databoxItem.Add(databox);
|
}
|
}
|
|
// 验证是否已有入库任务
|
var taskitem = new LogTask();
|
if (!string.IsNullOrWhiteSpace(bind.TaskNo))
|
{
|
taskitem = Db.Queryable<LogTask>().First(m => m.TaskNo == bind.TaskNo);
|
|
if (taskitem != null)
|
{
|
if (taskitem.IsSuccess == 1)
|
{
|
throw new Exception("托盘关联的入库任务已下发不可删除");
|
}
|
}
|
}
|
#endregion
|
|
//获取托盘信息
|
var pallet = Db.Queryable<SysPallets>().First(a => a.IsDel == "0" && a.PalletNo == bind.PalletNo && a.Status == "1");
|
if (pallet == null)
|
{
|
throw new Exception("未查询到托盘信息!");
|
}
|
|
Db.BeginTran();
|
var time = DateTime.Now;
|
//托盘绑定的箱支信息集合
|
//var boxList = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == bind.Id).ToList();
|
if (bllboxItem.Count != 0)
|
{
|
var ids = databoxItem.Select(m => m.StockDetailId).Distinct().ToList();
|
var dataStockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && ids.Contains(m.Id)).ToList();
|
var stockItem = new List<DataStock>();
|
foreach (var item in dataStockDetail)
|
{
|
var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == item.SkuNo && m.LotNo == item.LotNo);
|
if (!stockItem.Contains(dataStock))
|
{
|
stockItem.Add(dataStock);
|
}
|
}
|
|
foreach (var b in bllboxItem)
|
{
|
b.IsDel = "0";
|
b.PalletNo = "";
|
b.BindNo = null;
|
b.Status = "0";
|
b.CompleteTime = null;
|
b.UpdateTime = time;
|
b.UpdateUser = userId;
|
var i = Db.Updateable(b).ExecuteCommand();
|
if (i != 1)
|
{
|
throw new Exception($"{b.BoxNo}箱码、{b.BoxNo3}支码删除失败");
|
}
|
//删除库存箱码明细信息
|
var box = databoxItem.FirstOrDefault(m => m.BoxNo == b.BoxNo && m.BoxNo2 == b.BoxNo2 && m.BoxNo3 == b.BoxNo3);
|
if (box == null)
|
{
|
throw new Exception($"未查询到{b.BoxNo}箱码、{b.BoxNo3}支码的库存信息");
|
}
|
//删除/修改库存托盘明细信息
|
var stockDetail = dataStockDetail.FirstOrDefault(m => m.Id == box.StockDetailId);
|
if (stockDetail == null)
|
{
|
throw new Exception($"未查询到{b.BoxNo}箱码、{b.BoxNo3}支码的库存托盘信息");
|
}
|
stockDetail.Qty -= box.Qty;
|
|
if (stockDetail.Qty <= 0)
|
{
|
Db.Deleteable(stockDetail).ExecuteCommand();
|
}
|
else
|
{
|
Db.Updateable(stockDetail).ExecuteCommand();
|
}
|
//删除/修改库存总表信息
|
var stock = stockItem.FirstOrDefault(m => m.SkuNo == b.SkuNo && m.LotNo == b.LotNo);
|
if (stock == null)
|
{
|
throw new Exception($"未查询到{b.BoxNo}箱码、{b.BoxNo3}支码的库存总信息");
|
}
|
stock.Qty -= box.Qty;
|
if (stock.Qty <= 0)
|
{
|
Db.Deleteable(stock).ExecuteCommand();
|
}
|
else
|
{
|
Db.Updateable(stock).ExecuteCommand();
|
}
|
//删除库存箱码信息
|
Db.Deleteable(box).ExecuteCommand();
|
}
|
|
}
|
else
|
{
|
//删除/修改库存托盘明细信息
|
var stockDetail = dataBindItem;
|
|
stockDetail.Qty -= bind.Qty;
|
|
if (stockDetail.Qty <= 0)
|
{
|
Db.Deleteable(stockDetail).ExecuteCommand();
|
}
|
else
|
{
|
Db.Updateable(stockDetail).ExecuteCommand();
|
}
|
//删除/修改库存总表信息
|
var stock = dataStocks;
|
|
stock.Qty -= bind.Qty;
|
if (stock.Qty <= 0)
|
{
|
Db.Deleteable(stock).ExecuteCommand();
|
}
|
else
|
{
|
Db.Updateable(stock).ExecuteCommand();
|
}
|
}
|
//判断是否有指定储位
|
if (taskitem != null)
|
{
|
if (!string.IsNullOrWhiteSpace(taskitem.EndLocat))
|
{
|
//储位状态变更为空储位
|
var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == taskitem.EndLocat);
|
locate.Status = "0";
|
Db.Updateable(locate).ExecuteCommand();
|
|
bind.LocatNo = "";
|
bind.WareHouseNo = "";
|
bind.RoadwayNo = "";
|
}
|
//删除托盘绑定信息
|
bind.IsDel = "1";
|
bind.UpdateTime = time;
|
bind.UpdateUser = userId;
|
Db.Updateable(bind).ExecuteCommand();
|
}
|
|
|
//入库单明细
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == bind.ASNDetailNo);
|
if (noticeDetail == null)
|
{
|
if (bllboxItem.Count != 0 && bllboxItem[0].SkuNo != "100099")
|
{
|
throw new Exception("未查询到托盘绑定的入库单明细信息");
|
}
|
|
}
|
|
if (noticeDetail != null)
|
{
|
if (bllboxItem.Count != 0 && bllboxItem[0].SkuNo == "100099")
|
{
|
throw new Exception("查询到空托有单据信息，错误。");
|
}
|
|
//修改入库单明细
|
noticeDetail.FactQty -= bind.Qty;
|
noticeDetail.CompleteQty -= bind.Qty;
|
//判断入库单明细组托数量是否为0，是：修改明细状态
|
//入库总单信息
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == bind.ASNNo);
|
if (noticeDetail.FactQty == 0)
|
{
|
noticeDetail.Status = "0";
|
//获取状态不是等待执行的明细信息
|
var count = Db.Queryable<BllArrivalNoticeDetail>().Count(m => m.IsDel == "0" && m.Id != noticeDetail.Id && m.ASNNo == bind.ASNNo && m.Status != "0");
|
if (count == 0)
|
{
|
notice.Status = "0";
|
}
|
else
|
{
|
notice.Status = "1";
|
}
|
}
|
else if (noticeDetail.FactQty > 0 && noticeDetail.FactQty < noticeDetail.Qty)
|
{
|
noticeDetail.Status = "1";
|
notice.Status = "1";
|
}
|
notice.UpdateTime = time;
|
notice.UpdateUser = userId;
|
//修改入库总单状态
|
Db.Updateable(notice).ExecuteCommand();
|
//修改入库单明细
|
Db.Updateable(noticeDetail).ExecuteCommand();
|
}
|
//获取除删除绑定信息外是否存在该托盘且同单据其它绑定信息
|
var bindid = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == bind.PalletNo).ToList();
|
if (bindid.Count == 0)
|
{
|
pallet.Status = "0";
|
pallet.UpdateUser = userId;
|
pallet.UpdateTime = DateTime.Now;
|
Db.Updateable(pallet).ExecuteCommand();
|
}
|
|
new OperationASNServer().AddLogOperationAsn("入库作业", "托盘绑定", bind.PalletNo, "删除", $"删除了入库单：{bind.ASNNo}、托盘码：{bind.PalletNo}的信息", userId);
|
Db.CommitTran();
|
}
|
catch (Exception e)
|
{
|
Db.RollbackTran();
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 删除绑定的箱码信息
|
/// </summary>
|
/// <param name="boxNo"></param>
|
/// <param name="userId"></param>
|
/// <exception cref="Exception"></exception>
|
public void DelBindBoxInfo(string boxNo, int userId)
|
{
|
try
|
{
|
var boxInfos = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo).ToList();
|
|
if (boxInfos.Count == 0)
|
{
|
throw new Exception("未查询到绑定箱支信息");
|
}
|
|
var boxInfo = boxInfos.First();
|
if (boxInfo.Status == "2")
|
{
|
throw new Exception("该箱支信息状态为已入库，不能删除");
|
}
|
|
if (boxInfo.SkuNo == "100099")
|
{
|
throw new Exception("该箱支信息属于空托组盘，请在托盘信息页中删除");
|
}
|
var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == boxInfo.PalletNo);
|
var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Id == boxInfo.BindNo);
|
if (bind == null)
|
{
|
throw new Exception("未查询到托盘绑定信息");
|
}
|
if (bind.Status != "0")
|
{
|
throw new Exception("该托盘绑定信息的状态不是等待入库，不能删除");
|
}
|
Db.BeginTran();
|
var time = DateTime.Now;
|
decimal qty = 0;
|
decimal? qty2 = 0;
|
foreach (var item in boxInfos)
|
{
|
//删除解绑箱支信息
|
if (item.Origin != "WMS")
|
{
|
item.ASNNo = "";
|
item.ASNDetailNo = null;
|
}
|
item.BindNo = null;
|
item.PalletNo = "";
|
item.Status = "0";
|
item.CompleteTime = null;
|
item.UpdateTime = time;
|
item.UpdateUser = userId;
|
qty += item.Qty;
|
qty2 += item.SamplingQty == null ? 0 : item.SamplingQty;
|
|
}
|
Db.Updateable(boxInfos).ExecuteCommand();
|
|
//修改托盘绑定信息
|
bind.Qty -= qty; // 数量变更
|
bind.BitPalletMark = "1"; // 零托标记变更
|
if (bind.SamplingQty != null)
|
{
|
bind.SamplingQty -= qty2;
|
}
|
|
if (bind.Qty == 0)
|
{
|
//判断是否有指定储位
|
if (!string.IsNullOrWhiteSpace(bind.LocatNo))
|
{
|
bind.LocatNo = "";
|
bind.RoadwayNo = "";
|
bind.WareHouseNo = "";
|
//储位状态变更为空储位
|
var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == bind.LocatNo);
|
locate.Status = "0";
|
Db.Updateable(locate).ExecuteCommand();
|
}
|
//删除托盘绑定信息
|
bind.IsDel = "1";
|
bind.UpdateTime = time;
|
bind.UpdateUser = userId;
|
//变更托盘使用状态
|
pallet.Status = "0";
|
pallet.UpdateTime = time;
|
pallet.UpdateUser = userId;
|
}
|
Db.Updateable(bind).ExecuteCommand();
|
Db.Updateable(pallet).ExecuteCommand();
|
|
//入库单明细
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == bind.ASNDetailNo);
|
if (noticeDetail == null && boxInfo.SkuNo != "100099")
|
{
|
throw new Exception("未查询到托盘绑定的入库单明细信息");
|
}
|
if (noticeDetail != null && boxInfo.SkuNo != "100099")
|
{
|
var bind2 = Db.Queryable<BllPalletBind>().Where(a => a.IsDel == "0" && a.Id != bind.Id && a.ASNDetailNo == noticeDetail.Id).ToList();
|
|
if (bind2.Count(m => m.InspectMark == "1") > 0)
|
{
|
noticeDetail.IsSampling = "1";
|
}
|
else
|
{
|
noticeDetail.IsSampling = "0";
|
}
|
//修改入库单明细
|
noticeDetail.FactQty -= qty;
|
//判断入库单明细组托数量是否为0，是：修改明细状态
|
if (noticeDetail.FactQty == 0)
|
{
|
noticeDetail.Status = "0";
|
//获取状态不是等待执行的明细信息
|
var count = Db.Queryable<BllArrivalNoticeDetail>().Count(m => m.IsDel == "0" && m.Id != noticeDetail.Id && m.ASNNo == bind.ASNNo && m.Status != "0");
|
if (count == 0)
|
{
|
//修改入库单信息
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == bind.ASNNo);
|
notice.Status = "0";
|
notice.UpdateTime = time;
|
notice.UpdateUser = userId;
|
Db.Updateable(notice).ExecuteCommand();
|
}
|
|
}
|
Db.Updateable(noticeDetail).ExecuteCommand();
|
}
|
//判断是否为托盘物料
|
//if (boxInfo.SkuNo == "100099")
|
//{
|
// new OperationASNServer().AddLogOperationAsn("入库作业", "托盘绑定", boxInfo.PalletNo, "删除", $"删除了托盘码：{boxInfo.PalletNo}的箱支物料信息", userId);
|
//}
|
//else
|
//{
|
new OperationASNServer().AddLogOperationAsn("入库作业", "托盘绑定", boxInfo.BoxNo3, "删除", $"删除了箱码：{boxInfo.BoxNo}、追溯码：{boxInfo.BoxNo3}的箱支物料信息", userId);
|
//}
|
|
Db.CommitTran();
|
}
|
catch (Exception e)
|
{
|
Db.RollbackTran();
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 托盘绑定撤销申请
|
/// </summary>
|
/// <param name="id"></param>
|
/// <param name="reason"></param>
|
/// <param name="userId"></param>
|
/// <exception cref="Exception"></exception>
|
public void CancelPalletBind(int id, string reason, int userId)
|
{
|
try
|
{
|
|
|
var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Id == id);
|
if (bind == null)
|
{
|
throw new Exception("未查询到入库单据的托盘绑定信息");
|
}
|
|
if (bind.Type == "1")
|
{
|
throw new Exception("该托盘是空托，不是物料托盘");
|
}
|
|
if (bind.Status == "1")
|
{
|
throw new Exception("该托盘状态为正在执行，请稍后撤销");
|
}
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == bind.ASNNo);
|
if (notice == null)
|
{
|
throw new Exception("未查询到入库单据信息");
|
}
|
if (notice.Status != "1" && notice.Status != "2")
|
{
|
throw new Exception("入库单据状态不是正在执行或执行完成，不能撤销");
|
}
|
var auditLog = Db.Queryable<BllAuditLog>().Where(m => m.IsDel == "0" && m.Status == "0");
|
var boxInfo = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.ASNNo == notice.ASNNo);
|
|
var time = DateTime.Now;
|
|
var startStatusName = "";
|
var endStatusName = "";
|
switch (notice.Status)
|
{
|
case "1":
|
startStatusName = "正在执行";
|
endStatusName = "正在执行";
|
break;
|
case "2":
|
startStatusName = "执行完成";
|
endStatusName = "正在执行";
|
break;
|
default:
|
throw new Exception("单据状态错误");
|
}
|
|
|
if (auditLog.Count(m => m.OrderNo == bind.ASNNo && m.PalletNo.Contains(bind.PalletNo)) > 0)
|
{
|
throw new Exception("该托盘已有申请撤销信息，请勿重复申请");
|
}
|
|
var info = boxInfo.First(m => m.BindNo == bind.Id);
|
//入库单明细
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == bind.ASNDetailNo);
|
if (noticeDetail == null && info.SkuNo != "100099")
|
{
|
throw new Exception("未查询到托盘绑定的入库单明细信息");
|
}
|
var log = new BllAuditLog()
|
{
|
OrderNo = notice.ASNNo,
|
PalletNo = bind.PalletNo,
|
Msg = info == null ? $"物料：{noticeDetail.SkuNo}、批次：{noticeDetail.LotNo};" : $"物料：{info.SkuNo}、批次：{info.LotNo};",
|
Reason = reason,
|
Status = "0",
|
Opinion = "",
|
StartStatus = startStatusName,
|
EndStatus = endStatusName,
|
FunctionCode = "002",
|
|
IsDel = "0",
|
CreateUser = userId,
|
CreateTime = time
|
};
|
|
|
Db.Insertable(log).ExecuteCommand();
|
new OperationASNServer().AddLogOperationAsn("入库作业", "托盘绑定", notice.ASNNo, "取消", $"添加了单据号为{notice.ASNNo}、托盘号为{bind.PalletNo}撤销申请", userId);
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 申请储位 （立体库）
|
/// </summary>
|
/// <param name="palletNo"></param>
|
/// <param name="houseNo"></param>
|
/// <param name="roadwayNo"></param>
|
/// <returns></returns>
|
/// <exception cref="Exception"></exception>
|
public OutCommandDto RequestLocation(string palletNo, string houseNo)
|
{
|
try
|
{
|
//验证托盘条码是否为空
|
if (string.IsNullOrEmpty(palletNo))
|
{
|
throw new Exception("请输入要申请的托盘条码");
|
}
|
//验证所属仓库是否为空
|
if (string.IsNullOrEmpty(houseNo))
|
{
|
throw new Exception("请选择所属仓库");
|
}
|
//验证是否为平库入库
|
var houseType = Db.Queryable<SysWareHouse>().First(a => a.WareHouseNo == houseNo);//获取仓库类型
|
//验证是否为立体库入库
|
if (houseType.Type != "1")
|
{
|
throw new Exception("仓库类型错误，请选择立体库仓库");
|
}
|
|
OutCommandDto comDto;//返回wcs的入库命令
|
var isHaveLocateNo = false; //托盘绑定信息中是否已有指定储位
|
|
var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息
|
|
//判断托盘条码是否有效
|
if (stock == null)
|
throw new Exception("托盘条码不受WMS管理，不可入库！");
|
|
#region
|
|
//查询托盘绑定信息(状态为等待入库的)
|
var palletBindList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" || m.Status == "1")).ToList();
|
var haveLocate = palletBindList.FirstOrDefault(m => !string.IsNullOrWhiteSpace(m.LocatNo));
|
|
var skuList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();
|
//物料类别信息
|
var skuCategoryList = Db.Queryable<SysMaterialCategory>().Where(m => m.IsDel == "0").ToList();
|
|
var skuNo = ""; //入库物料
|
var isAddTask = true; //是否添加新任务
|
var oldTaskNo = ""; //旧任务号
|
var starLocate = ""; // 起始储位
|
var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
|
//验证物料是否有成品
|
foreach (var item in stockDetail)
|
{
|
var skuItem = skuList.First(m => m.SkuNo == item.SkuNo);
|
if (skuItem.Type == "2")
|
{
|
throw new Exception("成品物料请入成品库");
|
}
|
}
|
if (palletBindList.Count >= 1) //正常入库
|
{
|
var palletBind = palletBindList.FirstOrDefault(m => m.Status == "1");
|
if (palletBind != null)
|
{
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == palletBind.TaskNo);
|
if (beingTask == null)
|
{
|
throw new Exception("该托盘正在入库，但未查询到任务信息");
|
}
|
if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
|
{
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = starLocate, // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
return comDto;
|
}
|
else
|
{
|
//if (string.IsNullOrWhiteSpace(roadwayNo))
|
//{
|
// roadwayNo = beingTask.EndRoadway;
|
//}
|
isAddTask = false;
|
oldTaskNo = beingTask.TaskNo;
|
}
|
}
|
if (haveLocate != null)
|
{
|
isHaveLocateNo = true; //已有指定储位
|
}
|
|
if (palletBindList.First().Type == "0") //物料托入库
|
{
|
//判断是否绑定单据及单据状态是否正常
|
foreach (var item in palletBindList)
|
{
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == item.ASNNo);
|
if (notice == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单，不可入库！");
|
}
|
if (notice.Status == "3")
|
{
|
throw new Exception($"入库单{item.ASNNo}已关闭，不可入库！");
|
}
|
}
|
|
//获取物料存放区域
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m =>
|
m.IsDel == "0" && m.Id == palletBindList.First().ASNDetailNo);
|
if (noticeDetail == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单明细，不可入库");
|
}
|
|
skuNo = noticeDetail.SkuNo;
|
|
}
|
else if (palletBindList.First().Type == "1")//空托盘
|
{
|
skuNo = "100099";
|
}
|
}
|
else //回流入库
|
{
|
if (stockDetail.Count == 0)
|
{
|
throw new Exception($"{palletNo}托盘条码不具有箱码信息，不可入库！");
|
}
|
if (stockDetail.Count(m => !string.IsNullOrWhiteSpace(m.LocatNo)) == 0)
|
{
|
throw new Exception("当前托盘没有在平库储位上，请核实");
|
}
|
starLocate = stockDetail.First().LocatNo;
|
|
var pingAreaStr = Db.Queryable<SysStorageArea>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W04" && m.AreaNo != "B06" && m.AreaNo != "B07").Select(m=>m.AreaNo).ToList();
|
var pingLocateInfo = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == starLocate && pingAreaStr.Contains(m.AreaNo) && m.IsDel == "0");
|
if (pingLocateInfo == null )
|
{
|
throw new Exception("当前托盘所在的储位没有在系统中找到信息");
|
}
|
if (pingLocateInfo.Status != "1")
|
{
|
throw new Exception("当前托盘所在的储位状态错误，不是空储位");
|
}
|
skuNo = stockDetail.First().SkuNo;
|
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0"
|
&& (m.Status == "0" || m.Status == "1") && m.PalletNo == palletNo && m.Type == "0");
|
if (beingTask != null)
|
{
|
if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
|
{
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = beingTask.StartLocat, // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1,
|
Type = PLCTypeEnum.AGV
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
beingTask.Status = "1";
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
return comDto;
|
}
|
else
|
{
|
//if (string.IsNullOrWhiteSpace(roadwayNo))
|
//{
|
// roadwayNo = beingTask.EndRoadway;
|
//}
|
isAddTask = false;
|
oldTaskNo = beingTask.TaskNo;
|
}
|
}
|
|
//获取对应回库规则
|
var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetName == "托盘回库验证" && a.IsEnable == "NO");
|
#region 托盘回库规则
|
|
if (function != null)
|
{
|
//拣货完成后允许托盘回库
|
if (function.SetValue == "CompletePick")
|
{
|
var allot = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0" && a.LotNo == stockDetail[0].LotNo && a.PalletNo == palletNo && a.SkuNo == stockDetail[0].SkuNo);
|
|
//验证拣货明细是否存在
|
if (allot != null)
|
{
|
//验证当前托盘拣货信息是否已完成
|
if (allot.Status != "5")
|
{
|
throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
|
}
|
}
|
}
|
}
|
#endregion
|
}
|
|
var allotLocate = new AllotLocation();
|
|
#region 申请储位
|
|
SysStorageLocat locate;
|
if (isHaveLocateNo) //指定储位
|
{
|
locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == haveLocate.LocatNo);
|
}
|
else
|
{
|
var sku = skuList.FirstOrDefault(m => m.SkuNo == skuNo);
|
if (sku == null)
|
{
|
throw new Exception("物料信息中未查询到入库单明细包含的物料信息，不可入库");
|
}
|
//判断物料是否含有类别信息
|
if (string.IsNullOrWhiteSpace(sku.CategoryNo))
|
{
|
throw new Exception($"物料：{sku.SkuNo}未查询到类别信息");
|
}
|
|
var skuCategory = skuCategoryList.FirstOrDefault(m => m.CategoryNo == sku.CategoryNo);
|
if (skuCategory == null)
|
{
|
throw new Exception($"未在类别信息中查询到物料：{sku.SkuNo}包含的类别");
|
}
|
|
var areaStr = skuCategory.AreaNo.Split(",");
|
var areaList = new List<string>();
|
foreach (var item in areaStr)
|
{
|
areaList.Add(item);
|
}
|
|
locate = allotLocate.GetSuiTableLocate(houseNo, areaList, "");
|
}
|
|
#endregion
|
|
Db.BeginTran();
|
try
|
{
|
|
if (isAddTask) // 正常入库
|
{
|
//添加巷道使用记录
|
var log = new SysRoadwayUseLog
|
{
|
RoadwayNo = locate.RoadwayNo,
|
WareHouseNo = houseNo,
|
Row = 0,
|
Column = 0,
|
Layer = 0,
|
};
|
Db.Insertable(log).ExecuteCommand();
|
var taskNo = new Common().GetMaxNo("TK");
|
var exTask = new LogTask //入库任务
|
{
|
TaskNo = taskNo,
|
Sender = "WMS",
|
Receiver = "WCS",
|
IsSuccess = 1, //是否下发成功 0失败 1成功
|
SendDate = DateTime.Now, //发送时间
|
BackDate = DateTime.Now, //返回时间
|
StartRoadway = "", // 起始巷道
|
StartLocat = starLocate,//起始位置
|
EndLocat = locate.LocatNo,//目标位置
|
EndRoadway = locate.RoadwayNo, // 目标巷道
|
PalletNo = palletNo,//托盘码
|
IsSend = 1,//是否可再次下发
|
IsCancel = 1,//是否可取消
|
IsFinish = 1,//是否可完成
|
Type = "0",//任务类型 0 入库任务 1 出库任务 2 移库任务
|
Status = "1",//任务状态0：等待执行1正在执行2执行完成
|
OrderType = "0",//0 入库单 1 出库单 2 盘点单 3 移库单
|
Msg = "入库口到=>>" + locate.LocatNo + "的入库任务", //关键信息
|
|
};
|
Db.Insertable(exTask).ExecuteCommand();
|
var asnNo = "";
|
// 添加托盘绑定表托盘入库任务号 liudl
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
var bindModel = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Status == "2"
|
&& m.PalletNo == stockModel.PalletNo && m.ASNNo == stockModel.ASNNo && m.ASNDetailNo == stockModel.ASNDetailNo);
|
if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.TaskNo))
|
{
|
bindModel.TaskNo = taskNo;
|
bindModel.WareHouseNo = locate.WareHouseNo;
|
bindModel.RoadwayNo = locate.RoadwayNo;
|
bindModel.LocatNo = locate.LocatNo;
|
Db.Updateable(bindModel).ExecuteCommand();
|
asnNo = stockModel.ASNNo;
|
}
|
}
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
//添加托盘上架记录
|
var upShelf = new BllPalletUpShelf()
|
{
|
TaskNo = exTask.TaskNo,
|
TraceNo = asnNo,
|
PalletNo = palletNo,
|
SkuNo = stockModel.SkuNo,
|
SkuName = stockModel.SkuName,
|
LotNo = stockModel.LotNo,
|
Status = "1",
|
|
WareHouseNo = houseNo,
|
RoadwayNo = locate.RoadwayNo,
|
AreaNo = locate.AreaNo,
|
LocatNo = locate.LocatNo,
|
|
CreateUser = 0,
|
};
|
Db.Insertable(upShelf).ExecuteCommand();
|
}
|
|
oldTaskNo = taskNo;
|
}
|
else
|
{
|
var oldTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == oldTaskNo);
|
oldTask.EndLocat = locate.LocatNo;
|
oldTask.EndRoadway = locate.RoadwayNo;
|
if (oldTask.IsSuccess == 0)
|
{
|
oldTask.IsSuccess = 1;
|
oldTask.Status = "1";
|
}
|
Db.Updateable(oldTask).ExecuteCommand();
|
|
|
var bindModelList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.Status == "2"
|
&& m.PalletNo == oldTask.PalletNo && m.TaskNo == oldTaskNo).ToList();
|
foreach (var bindModel in bindModelList)
|
{
|
if (string.IsNullOrWhiteSpace(bindModel.LocatNo))
|
{
|
bindModel.TaskNo = oldTask.TaskNo;
|
bindModel.WareHouseNo = locate.WareHouseNo;
|
bindModel.RoadwayNo = locate.RoadwayNo;
|
bindModel.LocatNo = locate.LocatNo;
|
Db.Updateable(bindModel).ExecuteCommand();
|
|
}
|
}
|
//更改上架信息
|
var upShelfList = Db.Queryable<BllPalletUpShelf>().Where(m => m.IsDel == "0" && m.TaskNo == oldTask.TaskNo && m.PalletNo == palletNo).ToList();
|
foreach (var upShelf in upShelfList)
|
{
|
upShelf.WareHouseNo = locate.WareHouseNo;
|
upShelf.RoadwayNo = locate.RoadwayNo;
|
upShelf.LocatNo = locate.LocatNo;
|
upShelf.Status = "1";
|
Db.Updateable(upShelf).ExecuteCommand();
|
|
}
|
|
|
}
|
|
locate.Status = "2";
|
Db.Updateable(locate).ExecuteCommand();
|
if (palletBindList.Count >= 1)
|
{
|
foreach (var item in palletBindList)
|
{
|
item.Status = "1";
|
item.WareHouseNo = locate.WareHouseNo;
|
item.RoadwayNo = locate.RoadwayNo;
|
item.LocatNo = locate.LocatNo;
|
item.TaskNo = oldTaskNo;
|
}
|
Db.Updateable(palletBindList).ExecuteCommand();
|
}
|
Db.CommitTran();
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = "",
|
StartLocate = starLocate, // 起始位置
|
EndLocate = locate.LocatNo, // 目标位置
|
EndRoadway = locate.RoadwayNo, // 目标巷道
|
TaskNo = oldTaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1,
|
Type = PLCTypeEnum.AGV
|
};
|
|
}
|
catch (Exception ex)
|
{
|
Db.RollbackTran();
|
throw new Exception(ex.Message);
|
}
|
#endregion
|
|
|
return comDto;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 申请巷道(密集库)
|
/// </summary>
|
/// <param name="palletNo"></param>
|
/// <param name="houseNo"></param>
|
/// <returns></returns>
|
/// <exception cref="Exception"></exception>
|
public OutCommandDto RequestMiJiRoadWay(string palletNo, string houseNo)
|
{
|
try
|
{
|
#region 验证托盘合法性
|
//验证托盘条码是否为空
|
if (string.IsNullOrEmpty(palletNo))
|
{
|
throw new Exception("请输入要申请的托盘条码");
|
}
|
//验证所属仓库是否为空
|
if (string.IsNullOrEmpty(houseNo))
|
{
|
throw new Exception("请选择所属仓库");
|
}
|
//获取仓库类型
|
var houseType = Db.Queryable<SysWareHouse>().First(a => a.WareHouseNo == houseNo);
|
//验证是否为密集库
|
if (houseType.Type != "3")
|
{
|
throw new Exception("仓库不是密集库");
|
}
|
|
var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息
|
//判断托盘条码是否有效
|
if (stock == null)
|
{
|
throw new Exception("托盘条码不受WMS管理，不可入库！");
|
}
|
#endregion
|
|
|
OutCommandDto comDto;//返回wcs的入库命令
|
#region
|
|
//查询托盘绑定信息(状态为等待入库/正在执行的)
|
var palletBindList = Db.Queryable<BllPalletBind>()
|
.Where(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" || m.Status == "1")).ToList();
|
var haveLocate = palletBindList.FirstOrDefault(m => !string.IsNullOrWhiteSpace(m.LocatNo));
|
|
var skuNo = ""; //入库物料
|
var lotNo = ""; //入库批次
|
|
var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
|
if (palletBindList.Count >= 1) //正常入库
|
{
|
var palletBind = palletBindList.FirstOrDefault(m => m.Status == "1");//查询是否有正在执行的托盘绑定
|
if (palletBind != null)
|
{
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == palletBind.TaskNo);
|
if (beingTask == null)
|
{
|
throw new Exception("该托盘正在入库，但未查询到任务信息");
|
}
|
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = beingTask.StartLocat, // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (入库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
return comDto;
|
|
}
|
|
|
// 验证是否关联单据，获取托盘上存放的物料
|
if (palletBindList.First().Type == "0") //物料托入库
|
{
|
//判断是否绑定单据及单据状态是否正常
|
foreach (var item in palletBindList)
|
{
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == item.ASNNo);
|
if (notice == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单，不可入库！");
|
}
|
if (notice.Status == "3" || notice.Status == "4")
|
{
|
throw new Exception($"入库单{item.ASNNo}已关闭，不可入库！");
|
}
|
}
|
|
//获取物料存放区域
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m =>
|
m.IsDel == "0" && m.Id == palletBindList.First().ASNDetailNo);
|
if (noticeDetail == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单明细，不可入库");
|
}
|
|
skuNo = noticeDetail.SkuNo;
|
lotNo = noticeDetail.LotNo;
|
|
}
|
else if (palletBindList.First().Type == "1")//空托盘
|
{
|
skuNo = "100099";
|
}
|
}
|
else //回流入库
|
{
|
if (stockDetail.Count == 0)
|
{
|
throw new Exception($"{palletNo}托盘不存在库存信息，不可入库！");
|
}
|
if (stockDetail.Count(m => !string.IsNullOrWhiteSpace(m.LocatNo)) > 0)
|
{
|
throw new Exception("当前托盘已在库内，请核实");
|
}
|
skuNo = stockDetail.First().SkuNo;
|
lotNo = stockDetail.First().LotNo;
|
|
#region 判断任务是否已经存在，若存在直接返回任务；
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0"
|
&& (m.Status == "0" || m.Status == "1") && m.PalletNo == palletNo && m.Type == "0");
|
if (beingTask != null)
|
{
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = beingTask.StartLocat, // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
beingTask.Status = "1";
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
|
return comDto;
|
}
|
#endregion
|
|
#region 判断该托盘，是否符合回库功能设定的回库规则
|
//获取对应回库规则
|
var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0"
|
&& a.FunSetNo == "Fun041" && a.IsEnable == "NO");
|
if (function != null)
|
{
|
//拣货完成后允许托盘回库
|
var allot = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0"
|
&& a.LotNo == stockDetail[0].LotNo && a.PalletNo == palletNo && a.SkuNo == stockDetail[0].SkuNo);
|
|
//验证拣货明细是否存在
|
if (allot != null)
|
{
|
//验证当前托盘拣货信息是否已完成
|
if (allot.Status != "5")
|
{
|
throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
|
}
|
}
|
}
|
#endregion
|
}
|
|
var allotLocate = new AllotLocation();
|
|
SysStorageLocat locate;
|
|
#region 根据sku确认区域划分
|
|
//物料信息
|
var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == skuNo);
|
if (sku == null)
|
{
|
throw new Exception("物料编码不存在，不可入库");
|
}
|
//判断物料是否含有类别信息
|
if (string.IsNullOrWhiteSpace(sku.CategoryNo))
|
{
|
throw new Exception($"物料：{sku.SkuNo}未设置类别,不可入库");
|
}
|
//物料类别信息
|
var skuCategory = Db.Queryable<SysMaterialCategory>().First(m => m.IsDel == "0" && m.CategoryNo == sku.CategoryNo);
|
if (skuCategory == null)
|
{
|
throw new Exception($"{sku.SkuNo}物料类别不存在，不可入库");
|
}
|
//整理区域信息
|
var areaStr = skuCategory.AreaNo.Split(",");
|
var areaList = new List<string>();
|
foreach (var item in areaStr)
|
{
|
areaList.Add(item);
|
}
|
|
|
var roadList = Db.Queryable<SysStorageLocat>().Where(m => m.WareHouseNo == houseNo && areaList.Contains(m.AreaNo))
|
.GroupBy(m => m.RoadwayNo).OrderBy(m => m.RoadwayNo).Select(m => m.RoadwayNo).ToList();
|
|
|
#endregion
|
|
var roadNo = allotLocate.GetMiJiSuiTableRoad(houseNo, roadList, areaList, skuNo, lotNo);
|
|
if (string.IsNullOrWhiteSpace(roadNo))
|
{
|
throw new Exception("未查询到存在空储位巷道");
|
}
|
|
Db.BeginTran();
|
try
|
{
|
//添加巷道使用记录
|
var log = new SysRoadwayUseLog
|
{
|
RoadwayNo = roadNo,
|
WareHouseNo = houseNo,
|
Row = 0,
|
Column = 0,
|
Layer = 0,
|
};
|
Db.Insertable(log).ExecuteCommand();
|
|
// 添加入库日志记录
|
var taskNo = new Common().GetMaxNo("TK");
|
var exTask = new LogTask //入库任务
|
{
|
TaskNo = taskNo,
|
Sender = "WMS",
|
Receiver = "WCS",
|
IsSuccess = 1, //是否下发成功 0失败 1成功
|
SendDate = DateTime.Now, //发送时间
|
BackDate = DateTime.Now, //返回时间
|
StartRoadway = "", // 起始巷道
|
StartLocat = "",//起始位置
|
EndLocat = "",//目标位置
|
EndRoadway = roadNo, // 目标巷道
|
PalletNo = palletNo,//托盘码
|
IsSend = 1,//是否可再次下发
|
IsCancel = 1,//是否可取消
|
IsFinish = 1,//是否可完成
|
Type = "0",//任务类型 0 入库任务 1 出库任务 2 移库任务
|
Status = "1",//任务状态0：等待执行1正在执行2执行完成
|
OrderType = "0",//0 入库单 1 出库单 2 盘点单 3 移库单
|
Msg = "入库口到=>>" + roadNo + "巷道的入库任务", //关键信息
|
|
};
|
Db.Insertable(exTask).ExecuteCommand();
|
|
var asnNo = "";
|
// 添加托盘绑定表托盘入库任务号 liudl
|
if (palletBindList.Count < 1)
|
{
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
var bindModel = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Status == "2"
|
&& m.PalletNo == stockModel.PalletNo && m.ASNNo == stockModel.ASNNo && m.ASNDetailNo == stockModel.ASNDetailNo);
|
if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.TaskNo))
|
{
|
bindModel.TaskNo = taskNo;
|
bindModel.WareHouseNo = houseNo;
|
bindModel.RoadwayNo = roadNo;
|
Db.Updateable(bindModel).ExecuteCommand();
|
asnNo = stockModel.ASNNo;
|
}
|
|
|
}
|
}
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
//添加托盘上架记录
|
var upShelf = new BllPalletUpShelf()
|
{
|
TaskNo = exTask.TaskNo,
|
TraceNo = asnNo,
|
PalletNo = palletNo,
|
SkuNo = stockModel.SkuNo,
|
SkuName = stockModel.SkuName,
|
LotNo = stockModel.LotNo,
|
Status = "1",
|
|
WareHouseNo = houseNo,
|
RoadwayNo = roadNo,
|
AreaNo = "",
|
LocatNo = "",
|
|
CreateUser = 0,
|
};
|
Db.Insertable(upShelf).ExecuteCommand();
|
}
|
|
|
if (palletBindList.Count >= 1)
|
{
|
foreach (var item in palletBindList)
|
{
|
item.WareHouseNo = houseNo;
|
item.RoadwayNo = roadNo;
|
item.TaskNo = taskNo;
|
}
|
Db.Updateable(palletBindList).ExecuteCommand();
|
}
|
Db.CommitTran();
|
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = "",
|
StartLocate = "", // 起始位置
|
EndLocate = "", // 目标位置
|
EndRoadway = roadNo, // 目标巷道
|
TaskNo = taskNo, // 任务号
|
TaskType = "0",// 任务类型:入库任务
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
}
|
catch (Exception ex)
|
{
|
Db.RollbackTran();
|
throw new Exception(ex.Message);
|
}
|
#endregion
|
|
return comDto;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 1 申请储位 2 申请巷道后 再申请储位储位
|
/// </summary>
|
/// <param name="palletNo"></param>
|
/// <param name="houseNo"></param>
|
/// <param name="roadwayNo"></param>
|
/// <returns></returns>
|
/// <exception cref="Exception"></exception>
|
public OutCommandDto RequestMiJiLocation(string palletNo, string houseNo, string roadwayNo)
|
{
|
try
|
{
|
//验证托盘条码是否为空
|
if (string.IsNullOrEmpty(palletNo))
|
{
|
throw new Exception("请输入要申请的托盘条码");
|
}
|
//验证所属仓库是否为空
|
if (string.IsNullOrEmpty(houseNo))
|
{
|
throw new Exception("请选择所属仓库");
|
}
|
//验证是否为平库入库
|
if (houseNo == "W02")
|
{
|
throw new Exception("平库请使用PDA手持进行平库入库");
|
}
|
|
OutCommandDto comDto;//返回wcs的入库命令
|
var isHaveLocateNo = false; //托盘绑定信息中是否已有指定储位
|
|
var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息
|
|
//判断托盘条码是否有效
|
if (stock == null)
|
throw new Exception("托盘条码不受WMS管理，不可入库！");
|
|
#region
|
|
//查询托盘绑定信息(状态为等待入库的)
|
var palletBindList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" || m.Status == "1")).ToList();
|
var haveLocate = palletBindList.FirstOrDefault(m => !string.IsNullOrWhiteSpace(m.LocatNo));
|
|
var skuList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();
|
//物料类别信息
|
var skuCategoryList = Db.Queryable<SysMaterialCategory>().Where(m => m.IsDel == "0").ToList();
|
|
var skuNo = ""; //入库物料
|
var isAddTask = true; //是否添加新任务
|
var oldTaskNo = ""; //旧任务号
|
var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
|
if (palletBindList.Count >= 1) //正常入库
|
{
|
var palletBind = palletBindList.FirstOrDefault(m => m.Status == "1");
|
if (palletBind != null)
|
{
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == palletBind.TaskNo);
|
if (beingTask == null)
|
{
|
throw new Exception("该托盘正在入库，但未查询到任务信息");
|
}
|
if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
|
{
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = "", // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
return comDto;
|
}
|
else
|
{
|
if (string.IsNullOrWhiteSpace(roadwayNo))
|
{
|
roadwayNo = beingTask.EndRoadway;
|
}
|
isAddTask = false;
|
oldTaskNo = beingTask.TaskNo;
|
}
|
}
|
if (haveLocate != null)
|
{
|
isHaveLocateNo = true; //已有指定储位
|
}
|
|
if (palletBindList.First().Type == "0") //物料托入库
|
{
|
//判断是否绑定单据及单据状态是否正常
|
foreach (var item in palletBindList)
|
{
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == item.ASNNo);
|
if (notice == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单，不可入库！");
|
}
|
if (notice.Status == "3")
|
{
|
throw new Exception($"入库单{item.ASNNo}已关闭，不可入库！");
|
}
|
}
|
|
//获取物料存放区域
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m =>
|
m.IsDel == "0" && m.Id == palletBindList.First().ASNDetailNo);
|
if (noticeDetail == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单明细，不可入库");
|
}
|
|
skuNo = noticeDetail.SkuNo;
|
|
}
|
else if (palletBindList.First().Type == "1")//空托盘
|
{
|
skuNo = "100099";
|
}
|
}
|
else //回流入库
|
{
|
if (stockDetail.Count == 0)
|
{
|
throw new Exception($"{palletNo}托盘条码不具有箱码信息，不可入库！");
|
}
|
if (stockDetail.Count(m => !string.IsNullOrWhiteSpace(m.LocatNo)) > 0)
|
{
|
throw new Exception("当前托盘已在库内，请核实");
|
}
|
skuNo = stockDetail.First().SkuNo;
|
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0"
|
&& (m.Status == "0" || m.Status == "1") && m.PalletNo == palletNo && m.Type == "0");
|
if (beingTask != null)
|
{
|
if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
|
{
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = "", // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
beingTask.Status = "1";
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
return comDto;
|
}
|
else
|
{
|
if (string.IsNullOrWhiteSpace(roadwayNo))
|
{
|
roadwayNo = beingTask.EndRoadway;
|
}
|
isAddTask = false;
|
oldTaskNo = beingTask.TaskNo;
|
}
|
}
|
|
//获取对应回库规则
|
var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetName == "托盘回库验证" && a.IsEnable == "NO");
|
#region 托盘回库规则
|
|
if (function != null)
|
{
|
//拣货完成后允许托盘回库
|
if (function.SetValue == "CompletePick")
|
{
|
var allot = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0" && a.LotNo == stockDetail[0].LotNo && a.PalletNo == palletNo && a.SkuNo == stockDetail[0].SkuNo);
|
|
//验证拣货明细是否存在
|
if (allot != null)
|
{
|
//验证当前托盘拣货信息是否已完成
|
if (allot.Status != "5")
|
{
|
throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
|
}
|
}
|
}
|
}
|
#endregion
|
}
|
|
var allotLocate = new AllotLocation();
|
|
#region 申请储位
|
|
SysStorageLocat locate;
|
if (isHaveLocateNo) //指定储位
|
{
|
locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == haveLocate.LocatNo);
|
}
|
else
|
{
|
var sku = skuList.FirstOrDefault(m => m.SkuNo == skuNo);
|
if (sku == null)
|
{
|
throw new Exception("物料信息中未查询到入库单明细包含的物料信息，不可入库");
|
}
|
//判断物料是否含有类别信息
|
if (string.IsNullOrWhiteSpace(sku.CategoryNo))
|
{
|
throw new Exception($"物料：{sku.SkuNo}未查询到类别信息");
|
}
|
|
var skuCategory = skuCategoryList.FirstOrDefault(m => m.CategoryNo == sku.CategoryNo);
|
if (skuCategory == null)
|
{
|
throw new Exception($"未在类别信息中查询到物料：{sku.SkuNo}包含的类别");
|
}
|
|
var areaStr = skuCategory.AreaNo.Split(",");
|
var areaList = new List<string>();
|
foreach (var item in areaStr)
|
{
|
areaList.Add(item);
|
}
|
|
locate = allotLocate.GetMiJiSuiTableLocate(roadwayNo, areaList);
|
}
|
|
#endregion
|
|
Db.BeginTran();
|
try
|
{
|
|
if (isAddTask) // 正常入库
|
{
|
var taskNo = new Common().GetMaxNo("TK");
|
var exTask = new LogTask //入库任务
|
{
|
TaskNo = taskNo,
|
Sender = "WMS",
|
Receiver = "WCS",
|
IsSuccess = 1, //是否下发成功 0失败 1成功
|
SendDate = DateTime.Now, //发送时间
|
BackDate = DateTime.Now, //返回时间
|
StartRoadway = "", // 起始巷道
|
StartLocat = "",//起始位置
|
EndLocat = locate.LocatNo,//目标位置
|
EndRoadway = locate.RoadwayNo, // 目标巷道
|
PalletNo = palletNo,//托盘码
|
IsSend = 1,//是否可再次下发
|
IsCancel = 1,//是否可取消
|
IsFinish = 1,//是否可完成
|
Type = "0",//任务类型 0 入库任务 1 出库任务 2 移库任务
|
Status = "1",//任务状态0：等待执行1正在执行2执行完成
|
OrderType = "0",//0 入库单 1 出库单 2 盘点单 3 移库单
|
Msg = "入库口到=>>" + locate.LocatNo + "的入库任务", //关键信息
|
|
};
|
Db.Insertable(exTask).ExecuteCommand();
|
var asnNo = "";
|
// 添加托盘绑定表托盘入库任务号 liudl
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
var bindModel = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Status == "2"
|
&& m.PalletNo == stockModel.PalletNo && m.ASNNo == stockModel.ASNNo && m.ASNDetailNo == stockModel.ASNDetailNo);
|
if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.TaskNo))
|
{
|
bindModel.TaskNo = taskNo;
|
bindModel.WareHouseNo = locate.WareHouseNo;
|
bindModel.RoadwayNo = locate.RoadwayNo;
|
bindModel.LocatNo = locate.LocatNo;
|
Db.Updateable(bindModel).ExecuteCommand();
|
asnNo = stockModel.ASNNo;
|
}
|
}
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
//添加托盘上架记录
|
var upShelf = new BllPalletUpShelf()
|
{
|
TaskNo = exTask.TaskNo,
|
TraceNo = asnNo,
|
PalletNo = palletNo,
|
SkuNo = stockModel.SkuNo,
|
SkuName = stockModel.SkuName,
|
LotNo = stockModel.LotNo,
|
Status = "1",
|
|
WareHouseNo = houseNo,
|
RoadwayNo = locate.RoadwayNo,
|
AreaNo = locate.AreaNo,
|
LocatNo = locate.LocatNo,
|
|
CreateUser = 0,
|
};
|
Db.Insertable(upShelf).ExecuteCommand();
|
}
|
|
oldTaskNo = taskNo;
|
}
|
else
|
{
|
var oldTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == oldTaskNo);
|
oldTask.EndLocat = locate.LocatNo;
|
oldTask.EndRoadway = locate.RoadwayNo;
|
if (oldTask.IsSuccess == 0)
|
{
|
oldTask.IsSuccess = 1;
|
oldTask.Status = "1";
|
}
|
Db.Updateable(oldTask).ExecuteCommand();
|
|
|
var bindModelList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.Status == "2"
|
&& m.PalletNo == oldTask.PalletNo && m.TaskNo == oldTaskNo).ToList();
|
foreach (var bindModel in bindModelList)
|
{
|
if (string.IsNullOrWhiteSpace(bindModel.LocatNo))
|
{
|
bindModel.TaskNo = oldTask.TaskNo;
|
bindModel.WareHouseNo = locate.WareHouseNo;
|
bindModel.RoadwayNo = locate.RoadwayNo;
|
bindModel.LocatNo = locate.LocatNo;
|
Db.Updateable(bindModel).ExecuteCommand();
|
|
}
|
}
|
//更改上架信息
|
var upShelfList = Db.Queryable<BllPalletUpShelf>().Where(m => m.IsDel == "0" && m.TaskNo == oldTask.TaskNo && m.PalletNo == palletNo).ToList();
|
foreach (var upShelf in upShelfList)
|
{
|
upShelf.WareHouseNo = locate.WareHouseNo;
|
upShelf.RoadwayNo = locate.RoadwayNo;
|
upShelf.LocatNo = locate.LocatNo;
|
upShelf.Status = "1";
|
Db.Updateable(upShelf).ExecuteCommand();
|
|
}
|
|
|
}
|
|
locate.Status = "2";
|
Db.Updateable(locate).ExecuteCommand();
|
if (palletBindList.Count >= 1)
|
{
|
foreach (var item in palletBindList)
|
{
|
item.Status = "1";
|
item.WareHouseNo = locate.WareHouseNo;
|
item.RoadwayNo = locate.RoadwayNo;
|
item.LocatNo = locate.LocatNo;
|
item.TaskNo = oldTaskNo;
|
}
|
Db.Updateable(palletBindList).ExecuteCommand();
|
}
|
Db.CommitTran();
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = "",
|
StartLocate = "", // 起始位置
|
EndLocate = locate.LocatNo, // 目标位置
|
EndRoadway = locate.RoadwayNo, // 目标巷道
|
TaskNo = oldTaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
|
}
|
catch (Exception ex)
|
{
|
Db.RollbackTran();
|
throw new Exception(ex.Message);
|
}
|
#endregion
|
|
|
return comDto;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 下发入库申请储位任务（下发==》WCS）
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
public void IssueAsnTask(OutCommandDto model,string url)
|
{
|
try
|
{
|
|
// 将任务发送至AGV 正式运行程序放开
|
var jsonData = JsonConvert.SerializeObject(model);
|
string response = "";
|
|
try
|
{
|
var time1 = DateTime.Now;//发送时间 .ToString("yyyy-MM-dd HH:mm:ss")
|
response = HttpHelper.DoPost(url, jsonData, "下发给WCS入库命令", "WCS");
|
var time2 = DateTime.Now;//返回时间 .ToString("yyyy-MM-dd HH:mm:ss")
|
var list = new List<string>() { model.TaskNo };
|
//解析返回数据
|
var wcsModel = JsonConvert.DeserializeObject<WcsModel2>(response);
|
if (wcsModel.code == 200)
|
{
|
//更改任务的发送返回时间//
|
new TaskServer().EditTaskIssueOk(list, time1, time2);
|
}
|
else
|
{
|
new TaskServer().EditTaskIssueNo(list, time1, time2, wcsModel.message);
|
throw new Exception("WCS反馈：" + wcsModel.message);
|
}
|
}
|
catch (Exception ex)
|
{
|
throw new Exception(ex.Message);
|
}
|
}
|
catch (Exception)
|
{
|
throw;
|
}
|
}
|
|
|
|
#endregion
|
|
#region 指定储位
|
//指定储位数据源（正常的空储位）
|
public List<LocatDto> GetLocateList(string houseNo, string roadwayNo, string row, string column, string layer,
|
string locateNo, string stockDetailId, int page, int limit, out int count)
|
{
|
try
|
{
|
//获取库存明细
|
var DetailSkuNo = Db.Queryable<DataStockDetail>().Where(a => a.Id == int.Parse(stockDetailId)
|
&& a.IsDel == "0").Select(a => a.SkuNo).First();
|
//获取物料
|
var skuCategoryNo = Db.Queryable<SysMaterials>().Where(a => a.IsDel == "0" && a.SkuNo == DetailSkuNo)
|
.Select(a => a.CategoryNo).First();
|
//获取物料对应区域
|
var categoryAreaNo = Db.Queryable<SysMaterialCategory>().Where(a => a.IsDel == "0" && a.CategoryNo == skuCategoryNo)
|
.Select(a => a.AreaNo).First();
|
|
Expression<Func<SysStorageLocat, bool>> item = Expressionable.Create<SysStorageLocat>()
|
.AndIF(!string.IsNullOrWhiteSpace(roadwayNo), m => m.RoadwayNo == roadwayNo)
|
.AndIF(!string.IsNullOrWhiteSpace(row), m => m.Row == int.Parse(row))
|
.AndIF(!string.IsNullOrWhiteSpace(column), m => m.Column == int.Parse(column))
|
.AndIF(!string.IsNullOrWhiteSpace(layer), m => m.Layer == int.Parse(layer))
|
.AndIF(!string.IsNullOrWhiteSpace(locateNo), m => m.LocatNo.Contains(locateNo))
|
.And(m => m.IsDel == "0" && m.Status == "0" && m.Flag == "0" && m.WareHouseNo == houseNo)
|
.And(m => categoryAreaNo.Contains(m.AreaNo))
|
.ToExpression();//注意 这一句 不能少
|
var total = 0;
|
var list = Db.Queryable<SysStorageLocat>().Where(item).OrderByDescending(a => a.Depth).OrderBy(a => a.Column)
|
.Select(a => new LocatDto()
|
{
|
Id = a.Id,
|
RoadwayNo = a.RoadwayNo,
|
LocatNo = a.LocatNo,
|
Row = a.Row,
|
Column = a.Column,
|
Layer = a.Layer,
|
Depth = a.Depth,
|
Status = a.Status
|
}).ToOffsetPage(page, limit, ref total);
|
count = total;
|
|
return list;
|
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
//保存指定的储位
|
public void SaveAppointSlot(int bindId, int locateId, int userId)
|
{
|
try
|
{
|
//托盘绑定信息
|
var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Id == bindId);
|
if (bind == null)
|
{
|
throw new Exception("未查询到托盘绑定的信息");
|
}
|
if (bind.Status != "0")
|
{
|
throw new Exception("该托盘绑定的信息状态不是等待执行，不能指定储位，请核实！");
|
}
|
//储位
|
var locate = Db.Queryable<SysStorageLocat>().First(m => m.IsDel == "0" && m.Id == locateId);
|
if (locate == null)
|
{
|
throw new Exception("未查询到储位的信息");
|
}
|
if (locate.Status != "0" || locate.Flag != "0")
|
{
|
throw new Exception("该储位状态不是空储位或标志不是正常的");
|
}
|
|
|
|
//判断当前托盘是否存在绑定信息
|
if (!string.IsNullOrWhiteSpace(bind.LocatNo))
|
{
|
//分割已绑储位与新储位
|
//已绑储位
|
var bindRow = bind.LocatNo.Substring(0, 2);
|
var bindColumn = bind.LocatNo.Substring(2, 2);
|
var bindLayer = bind.LocatNo.Substring(4, 2);
|
var bindDepth = bind.LocatNo.Substring(6, 2);
|
//新储位
|
var Row = locate.LocatNo.Substring(0, 2);
|
var Column = locate.LocatNo.Substring(2, 2);
|
var Layer = locate.LocatNo.Substring(4, 2);
|
var Depth = locate.LocatNo.Substring(6, 2);
|
|
if (bindDepth == "02")
|
{
|
//判断排列层是否相同
|
if (bindRow == Row && bindColumn == Column && bindLayer == Layer)
|
{
|
throw new Exception("同储位深度2不可向深度1切换！");
|
}
|
}
|
}
|
else
|
{
|
//若是深度1的 则判断深度2是否为空储位
|
if (locate.Depth == "01")
|
{
|
var locateDepth = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.Row == locate.Row && a.Column == locate.Column && a.Layer == locate.Layer && a.Depth == "02");
|
if (locateDepth != null)
|
{
|
if (locateDepth.Status != "1")
|
{
|
throw new Exception("该储位深度2不是有物品，不可绑定");
|
}
|
}
|
}
|
//判断是否为深度2的 若为深度2 则获取深度1储位 判断是否为空储位
|
if (locate.Depth == "02")
|
{
|
var locateDepth = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.Row == locate.Row && a.Column == locate.Column && a.Layer == locate.Layer && a.Depth == "01");
|
if (locateDepth.Status != "0" || locateDepth.Flag == "2")
|
{
|
throw new Exception("该储位深度1不是空储位或标志不是正常的");
|
}
|
}
|
}
|
|
|
var bindIdList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.PalletNo == bind.PalletNo && m.Status != "2").Select(m => m.Id).ToList();
|
//判断是否有零箱
|
foreach (var item in bindIdList)
|
{
|
var boxInfo = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == item);
|
if (boxInfo.Count(m => m.BitBoxMark == "1") > 0)
|
{
|
throw new Exception($"{bind.PalletNo}托盘上有零箱，请入零箱库！");
|
}
|
}
|
Db.BeginTran();
|
try
|
{
|
var time = DateTime.Now;
|
//判断托盘绑定信息是否已有指定储位
|
if (!string.IsNullOrWhiteSpace(bind.LocatNo))
|
{
|
var locate2 = Db.Queryable<SysStorageLocat>().First(m => m.IsDel == "0" && m.LocatNo == bind.LocatNo);
|
locate2.Status = "0";
|
Db.Updateable(locate2).ExecuteCommand();
|
}
|
//获取同托盘的托盘绑定信息
|
var bindList = Db.Queryable<BllPalletBind>()
|
.Where(m => m.IsDel == "0" && m.PalletNo == bind.PalletNo && m.Status == "0").ToList();
|
if (bindList.Count > 0)
|
{
|
foreach (var b in bindList)
|
{
|
b.LocatNo = locate.LocatNo;
|
b.WareHouseNo = locate.WareHouseNo;
|
b.RoadwayNo = locate.RoadwayNo;
|
b.UpdateTime = time;
|
b.UpdateUser = userId;
|
}
|
|
Db.Updateable(bindList).ExecuteCommand();
|
}
|
//修改指定的储位
|
bind.LocatNo = locate.LocatNo;
|
bind.WareHouseNo = locate.WareHouseNo;
|
bind.RoadwayNo = locate.RoadwayNo;
|
bind.UpdateTime = time;
|
bind.UpdateUser = userId;
|
locate.Status = "2";
|
Db.Updateable(bind).ExecuteCommand();
|
Db.Updateable(locate).ExecuteCommand();
|
|
new OperationASNServer().AddLogOperationAsn("入库作业", "托盘绑定", bind.PalletNo, "编辑", $"指定了储位：{locate.LocatNo}、单据号：{bind.ASNNo}、托盘码：{bind.PalletNo}的信息", userId);
|
Db.CommitTran();
|
}
|
catch (Exception e)
|
{
|
Db.RollbackTran();
|
throw new Exception(e.Message);
|
}
|
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
#endregion
|
|
|
#region 申请储位、巷道 任务完成、取消
|
|
|
|
/// <summary>
|
/// 申请巷道 （立体库）
|
/// </summary>
|
/// <param name="palletNo"></param>
|
/// <param name="houseNo"></param>
|
/// <returns></returns>
|
/// <exception cref="Exception"></exception>
|
public OutCommandDto RequestRoadWay(string palletNo, string houseNo)
|
{
|
try
|
{
|
#region 验证托盘合法性
|
//验证托盘条码是否为空
|
if (string.IsNullOrEmpty(palletNo))
|
{
|
throw new Exception("请输入要申请的托盘条码");
|
}
|
//验证所属仓库是否为空
|
if (string.IsNullOrEmpty(houseNo))
|
{
|
throw new Exception("请选择所属仓库");
|
}
|
//验证是否为平库入库
|
var houseType = Db.Queryable<SysWareHouse>().First(a => a.WareHouseNo == houseNo);//获取仓库类型
|
//验证是否为立体库入库
|
if (houseType.Type != "1")
|
{
|
throw new Exception("仓库类型错误，请选择立体库仓库");
|
}
|
|
var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息
|
//判断托盘条码是否有效
|
if (stock == null)
|
{
|
throw new Exception("托盘条码不受WMS管理，不可入库！");
|
}
|
#endregion
|
|
|
OutCommandDto comDto;//返回wcs的入库命令
|
#region
|
|
//查询托盘绑定信息(状态为等待入库的)
|
var palletBindList = Db.Queryable<BllPalletBind>()
|
.Where(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" || m.Status == "1")).ToList();
|
var haveLocate = palletBindList.FirstOrDefault(m => !string.IsNullOrWhiteSpace(m.LocatNo));
|
|
var skuList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();
|
//物料类别信息
|
var skuCategoryList = Db.Queryable<SysMaterialCategory>().Where(m => m.IsDel == "0").ToList();
|
|
var skuNo = ""; //入库物料
|
var isAddTask = true; //是否添加新任务
|
var oldTaskNo = ""; //旧任务号
|
var isHaveLocateNo = false;
|
var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
|
if (palletBindList.Count >= 1) //正常入库
|
{
|
var palletBind = palletBindList.FirstOrDefault(m => m.Status == "1");//查询是否有正在执行的托盘绑定
|
if (palletBind != null)
|
{
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == palletBind.TaskNo);
|
if (beingTask == null)
|
{
|
throw new Exception("该托盘正在入库，但未查询到任务信息");
|
}
|
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = "", // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
return comDto;
|
|
}
|
if (haveLocate != null)
|
{
|
isHaveLocateNo = true; //已有指定储位
|
}
|
|
|
// 验证是否关联单据，获取托盘上存放的物料
|
if (palletBindList.First().Type == "0") //物料托入库
|
{
|
//判断是否绑定单据及单据状态是否正常
|
foreach (var item in palletBindList)
|
{
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == item.ASNNo);
|
if (notice == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单，不可入库！");
|
}
|
if (notice.Status == "3" || notice.Status == "4")
|
{
|
throw new Exception($"入库单{item.ASNNo}已关闭，不可入库！");
|
}
|
}
|
|
//获取物料存放区域
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m =>
|
m.IsDel == "0" && m.Id == palletBindList.First().ASNDetailNo);
|
if (noticeDetail == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单明细，不可入库");
|
}
|
|
skuNo = noticeDetail.SkuNo;
|
|
}
|
else if (palletBindList.First().Type == "1")//空托盘
|
{
|
skuNo = "100099";
|
}
|
}
|
else //回流入库
|
{
|
if (stockDetail.Count == 0)
|
{
|
throw new Exception($"{palletNo}托盘不存在库存信息，不可入库！");
|
}
|
if (stockDetail.Count(m => !string.IsNullOrWhiteSpace(m.LocatNo)) > 0)
|
{
|
throw new Exception("当前托盘已在库内，请核实");
|
}
|
skuNo = stockDetail.First().SkuNo;
|
|
#region 判断任务是否已经存在，若存在直接返回任务；
|
var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0"
|
&& (m.Status == "0" || m.Status == "1") && m.PalletNo == palletNo && m.Type == "0");
|
if (beingTask != null)
|
{
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = beingTask.StartRoadway, // 起始巷道
|
StartLocate = "", // 起始位置
|
EndLocate = beingTask.EndLocat, // 目标位置
|
EndRoadway = beingTask.EndRoadway, // 目标巷道
|
TaskNo = beingTask.TaskNo, // 任务号
|
TaskType = "0",// 任务类型 (出库)
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
if (beingTask.IsSuccess == 0)
|
{
|
beingTask.IsSuccess = 1;
|
beingTask.Status = "1";
|
Db.Updateable(beingTask).ExecuteCommand();
|
}
|
|
return comDto;
|
}
|
#endregion
|
|
#region 判断该托盘，是否符合回库功能设定的回库规则
|
//获取对应回库规则
|
var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0"
|
&& a.FunSetNo == "Fun041" && a.IsEnable == "NO");
|
if (function != null)
|
{
|
//拣货完成后允许托盘回库
|
var allot = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0"
|
&& a.LotNo == stockDetail[0].LotNo && a.PalletNo == palletNo && a.SkuNo == stockDetail[0].SkuNo);
|
|
//验证拣货明细是否存在
|
if (allot != null)
|
{
|
//验证当前托盘拣货信息是否已完成
|
if (allot.Status != "5")
|
{
|
throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
|
}
|
}
|
}
|
#endregion
|
}
|
|
var allotLocate = new AllotLocation();
|
|
SysStorageLocat locate;
|
|
#region 根据sku确认区域划分
|
var sku = skuList.FirstOrDefault(m => m.SkuNo == skuNo);
|
if (sku == null)
|
{
|
throw new Exception("物料编码不存在，不可入库");
|
}
|
//判断物料是否含有类别信息
|
if (string.IsNullOrWhiteSpace(sku.CategoryNo))
|
{
|
throw new Exception($"物料：{sku.SkuNo}未设置类别,不可入库");
|
}
|
|
var skuCategory = skuCategoryList.FirstOrDefault(m => m.CategoryNo == sku.CategoryNo);
|
if (skuCategory == null)
|
{
|
throw new Exception($"{sku.SkuNo}物料类别不存在，不可入库");
|
}
|
|
var areaStr = skuCategory.AreaNo.Split(",");
|
var areaList = new List<string>();
|
foreach (var item in areaStr)
|
{
|
areaList.Add(item);
|
}
|
|
var laneAllot = 0; //储位跳巷分配 0:跳着分配(一个一个分配)1:巷道按照优先级分配，同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
|
var funSet3 = Db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位跳巷分配" && m.IsEnable == "NO");
|
if (funSet3 != null)
|
{
|
switch (funSet3.SetValue)
|
{
|
case "JumpLaneAllot":
|
laneAllot = 0;//立库储位分配 巷道同优先级巷道跳着分配(一个一个分配)
|
break;
|
case "RankLaneAllot":
|
laneAllot = 1;//立库储位分配 巷道按照优先级分配，同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
|
break;
|
default:
|
laneAllot = 1;// 默认 跳着分配
|
break;
|
}
|
}
|
var roadList = Db.Queryable<SysStorageLocat>().Where(m => m.WareHouseNo == houseNo && areaList.Contains(m.AreaNo))
|
.GroupBy(m => m.RoadwayNo).OrderBy(m => m.RoadwayNo).Select(m => m.RoadwayNo).ToList();
|
|
SysRoadwayUseLog useLog = Db.Queryable<SysRoadwayUseLog>()
|
.Where(m => m.IsDel == "0" && roadList.Contains(m.RoadwayNo))
|
.OrderByDescending(l => l.Id).First(); //巷道最后一次使用记录
|
#endregion
|
|
|
#region 确定巷道排序
|
List<string> roadList2 = new List<string>();
|
List<string> roadSmall = new List<string>();
|
List<string> roadLarge = new List<string>();
|
if (useLog != null)
|
{
|
roadList2.Add(useLog.RoadwayNo);
|
foreach (var r in roadList)
|
{
|
if (r == useLog.RoadwayNo)
|
{
|
continue;
|
}
|
//如果结果为0，则说明两个字符串相等； ABC BCE
|
//如果结果小于0，则说明第一个字符串小于第二个字符串；
|
//如果结果大于0，则说明第一个字符串大于第二个字符串。
|
var bol = String.CompareOrdinal(r, useLog.RoadwayNo);
|
if (bol < 0)
|
{
|
roadSmall.Add(r);
|
}
|
if (bol > 0)
|
{
|
roadLarge.Add(r);
|
}
|
}
|
roadList2.AddRange(roadLarge);
|
roadList2.AddRange(roadSmall);
|
}
|
else
|
{
|
roadList2 = roadList;
|
}
|
|
roadList = roadList2;
|
#endregion
|
|
|
var roadNo = "";
|
if (laneAllot == 0)//跳巷道平均分配
|
{
|
//取各巷道所有排第一个合适位
|
foreach (var l in roadList)
|
{
|
//如果上次是当前巷道则跳出
|
if (useLog != null && l == useLog.RoadwayNo)
|
{
|
continue;
|
}
|
|
var locateCount = Db.Queryable<SysStorageLocat>()
|
.Where(m => m.Status == "0" && m.Flag == "0" && areaList.Contains(m.AreaNo) && m.RoadwayNo == l).Count();
|
|
var bindNum = Db.Queryable<BllPalletBind>()
|
.Where(m => m.IsDel == "0" && m.Status == "0" && m.RoadwayNo == l)
|
.GroupBy(m => m.PalletNo).Select(m => m.PalletNo).Count();
|
if (locateCount - bindNum > 0)
|
{
|
roadNo = l;
|
}
|
//当前巷有位置则退出
|
if (roadNo != null)
|
{
|
break;
|
}
|
}
|
//如果跳巷道并且未找到合适空储位,则跳到最后一次使用的巷道查询
|
|
if (string.IsNullOrWhiteSpace(roadNo))
|
{
|
if (useLog != null)
|
{
|
var locateCount = Db.Queryable<SysStorageLocat>()
|
.Where(m => m.Status == "0" && m.Flag == "0" && areaList.Contains(m.AreaNo) && m.RoadwayNo == useLog.RoadwayNo).Count();
|
|
var bindNum = Db.Queryable<BllPalletBind>()
|
.Where(m => m.IsDel == "0" && m.Status == "0" && m.RoadwayNo == useLog.RoadwayNo)
|
.GroupBy(m => m.PalletNo).Select(m => m.PalletNo).Count();
|
if (locateCount - bindNum > 0)
|
{
|
roadNo = useLog.RoadwayNo;
|
}
|
}
|
}
|
}
|
else//按照巷道优先级分配
|
{
|
foreach (var item in roadList)
|
{
|
var locateCount = Db.Queryable<SysStorageLocat>()
|
.Where(m => m.Status == "0" && m.Flag == "0" && areaList.Contains(m.AreaNo) && m.RoadwayNo == item).Count();
|
|
var bindNum = Db.Queryable<BllPalletBind>()
|
.Where(m => m.IsDel == "0" && m.Status == "0" && m.RoadwayNo == item)
|
.GroupBy(m => m.PalletNo).Select(m => m.PalletNo).Count();
|
|
if (locateCount - bindNum > 0)
|
{
|
roadNo = item;
|
}
|
//当前巷有位置则退出
|
if (!string.IsNullOrWhiteSpace(roadNo))
|
{
|
break;
|
}
|
}
|
}
|
|
if (string.IsNullOrWhiteSpace(roadNo))
|
{
|
throw new Exception("未查询到存在空储位巷道");
|
}
|
|
Db.BeginTran();
|
try
|
{
|
//添加巷道使用记录
|
var log = new SysRoadwayUseLog
|
{
|
RoadwayNo = roadNo,
|
WareHouseNo = houseNo,
|
Row = 0,
|
Column = 0,
|
Layer = 0,
|
};
|
Db.Insertable(log).ExecuteCommand();
|
|
// 添加入库日志记录
|
var taskNo = new Common().GetMaxNo("TK");
|
var exTask = new LogTask //入库任务
|
{
|
TaskNo = taskNo,
|
Sender = "WMS",
|
Receiver = "WCS",
|
IsSuccess = 1, //是否下发成功 0失败 1成功
|
SendDate = DateTime.Now, //发送时间
|
BackDate = DateTime.Now, //返回时间
|
StartRoadway = "", // 起始巷道
|
StartLocat = "",//起始位置
|
EndLocat = "",//目标位置
|
EndRoadway = roadNo, // 目标巷道
|
PalletNo = palletNo,//托盘码
|
IsSend = 1,//是否可再次下发
|
IsCancel = 1,//是否可取消
|
IsFinish = 1,//是否可完成
|
Type = "0",//任务类型 0 入库任务 1 出库任务 2 移库任务
|
Status = "1",//任务状态0：等待执行1正在执行2执行完成
|
OrderType = "0",//0 入库单 1 出库单 2 盘点单 3 移库单
|
Msg = "入库口到=>>" + roadNo + "巷道的入库任务", //关键信息
|
|
};
|
Db.Insertable(exTask).ExecuteCommand();
|
|
var asnNo = "";
|
// 添加托盘绑定表托盘入库任务号 liudl
|
if (palletBindList.Count < 1)
|
{
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
var bindModel = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Status == "2"
|
&& m.PalletNo == stockModel.PalletNo && m.ASNNo == stockModel.ASNNo && m.ASNDetailNo == stockModel.ASNDetailNo);
|
if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.TaskNo))
|
{
|
bindModel.TaskNo = taskNo;
|
bindModel.WareHouseNo = houseNo;
|
bindModel.RoadwayNo = roadNo;
|
Db.Updateable(bindModel).ExecuteCommand();
|
asnNo = stockModel.ASNNo;
|
}
|
|
|
}
|
}
|
foreach (DataStockDetail stockModel in stockDetail)
|
{
|
//添加托盘上架记录
|
var upShelf = new BllPalletUpShelf()
|
{
|
TaskNo = exTask.TaskNo,
|
TraceNo = asnNo,
|
PalletNo = palletNo,
|
SkuNo = stockModel.SkuNo,
|
SkuName = stockModel.SkuName,
|
LotNo = stockModel.LotNo,
|
Status = "1",
|
|
WareHouseNo = houseNo,
|
RoadwayNo = roadNo,
|
AreaNo = "",
|
LocatNo = "",
|
|
CreateUser = 0,
|
};
|
Db.Insertable(upShelf).ExecuteCommand();
|
}
|
|
|
if (palletBindList.Count >= 1)
|
{
|
foreach (var item in palletBindList)
|
{
|
item.WareHouseNo = houseNo;
|
item.RoadwayNo = roadNo;
|
item.TaskNo = taskNo;
|
}
|
Db.Updateable(palletBindList).ExecuteCommand();
|
}
|
Db.CommitTran();
|
|
comDto = new OutCommandDto()
|
{
|
PalletNo = palletNo,//托盘号
|
StartRoadway = "",
|
StartLocate = "", // 起始位置
|
EndLocate = "", // 目标位置
|
EndRoadway = roadNo, // 目标巷道
|
TaskNo = taskNo, // 任务号
|
TaskType = "0",// 任务类型:入库任务
|
OutMode = "", //目标地址
|
Order = 1
|
};
|
}
|
catch (Exception ex)
|
{
|
Db.RollbackTran();
|
throw new Exception(ex.Message);
|
}
|
#endregion
|
|
return comDto;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
|
/// <summary>
|
/// 入库完成(wcs反馈、wms手动完成)
|
/// </summary>
|
/// <param name="taskNo"></param>
|
/// <param name="userId"></param>
|
/// <exception cref="Exception"></exception>
|
public void ArrivalSuccess(string taskNo, int userId)
|
{
|
try
|
{
|
//正常入库
|
var task = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == taskNo);
|
if (task == null)
|
{
|
throw new Exception("未查询到任务信息");
|
}
|
if (task.Status == "2")
|
{
|
throw new Exception("当前任务已完成");
|
}
|
|
var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
|
//当前任务中的储位信息
|
var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
|
if (locate == null)
|
{
|
throw new Exception($"未查询到任务中的储位信息");
|
}
|
//获取箱码信息
|
var box1 = Db.Queryable<BllBoxInfo>().First(a => a.PalletNo == task.PalletNo && a.IsDel == "0" && a.Status != "2");
|
|
Db.BeginTran();
|
|
task.Status = "2";//任务状态
|
task.IsSend = 0;
|
task.IsCancel = 0;
|
task.IsFinish = 0;
|
task.FinishDate = DateTime.Now;//完成时间
|
Db.Updateable(task).ExecuteCommand();
|
if (userId != 0)
|
{
|
//添加操作日志记录
|
var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
|
}
|
|
//判断是否是回流入库完成
|
if (stockDetail.Any())
|
{
|
foreach (var item in stockDetail)
|
{
|
item.WareHouseNo = locate.WareHouseNo;
|
item.RoadwayNo = locate.RoadwayNo;
|
item.AreaNo = locate.AreaNo;
|
item.LocatNo = locate.LocatNo;
|
item.UpdateTime = DateTime.Now;
|
if (userId != 0)
|
{
|
item.UpdateUser = userId;
|
}
|
}
|
|
locate.Status = "1";
|
Db.Updateable(locate).ExecuteCommand();
|
Db.Updateable(stockDetail).ExecuteCommand();
|
Db.CommitTran();
|
return;
|
}
|
//正常入库
|
var bindList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.TaskNo == taskNo && m.Status == "1").ToList();
|
if (bindList.Count == 0)
|
{
|
throw new Exception($"{taskNo}该任务没有对应的流水信息");
|
}
|
|
var comTime = DateTime.Now;
|
foreach (var item in bindList)
|
{
|
switch (item.Type)
|
{
|
case "1":
|
var boxInfo = Db.Queryable<BllBoxInfo>().First(m => m.IsDel == "0" && m.BindNo == item.Id);
|
var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == boxInfo.SkuNo);
|
#region 库存明细
|
var sd1 = new DataStockDetail()
|
{
|
LotNo = item.LotNo,
|
LotText = item.LotText,
|
SupplierLot = item.SupplierLot,
|
SkuNo = boxInfo.SkuNo,
|
SkuName = boxInfo.SkuName,
|
Standard = sku.Standard,
|
Qty = item.Qty,
|
LockQty = 0,
|
FrozenQty = 0,
|
InspectQty = 0,
|
ASNNo = item.ASNNo,
|
ASNDetailNo = item.ASNDetailNo,
|
WareHouseNo = locate.WareHouseNo,
|
RoadwayNo = locate.RoadwayNo,
|
AreaNo = locate.AreaNo,
|
LocatNo = locate.LocatNo,
|
PalletNo = item.PalletNo,
|
PalletNo2 = item.PalletNo2,
|
PalletNo3 = item.PalletNo3,
|
PalletTags = "0",
|
CompleteTime = comTime,
|
ProductionTime = item.ProductionTime,
|
ExpirationTime = item.ExpirationTime,
|
Status = "0",
|
InspectMark = item.InspectMark,
|
InspectStatus = sku.IsInspect,
|
BitPalletMark = item.BitPalletMark,
|
PackagNo = sku.PackagNo,
|
IsBale = item.IsBale,
|
IsBelt = item.IsBelt,
|
|
|
IsDel = "0",
|
CreateUser = 0,
|
CreateTime = comTime
|
};
|
var sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
|
#endregion
|
|
#region 库存箱码明细
|
|
var box2 = new DataBoxInfo()
|
{
|
StockDetailId = sdId1,
|
BindNo = item.Id,
|
BoxNo = boxInfo.BoxNo,
|
BoxNo2 = boxInfo.BoxNo2,
|
BoxNo3 = boxInfo.BoxNo3,
|
PalletNo = boxInfo.PalletNo,
|
PalletNo2 = boxInfo.PalletNo2,
|
PalletNo3 = boxInfo.PalletNo3,
|
Qty = boxInfo.Qty,
|
FullQty = boxInfo.FullQty,
|
Status = "2",
|
LotNo = boxInfo.LotNo,
|
LotText = boxInfo.LotText,
|
SkuNo = boxInfo.SkuNo,
|
SkuName = boxInfo.SkuName,
|
Standard = sku.Standard,
|
ProductionTime = boxInfo.ProductionTime,
|
SupplierLot = boxInfo.SupplierLot,
|
InspectStatus = sku.IsInspect,
|
InspectMark = boxInfo.InspectMark,
|
BitBoxMark = boxInfo.BitBoxMark,
|
ExpirationTime = boxInfo.ExpirationTime,
|
|
CreateUser = 0,
|
CreateTime = comTime
|
};
|
boxInfo.Status = "2";
|
Db.Updateable(boxInfo).ExecuteCommand();
|
Db.Insertable(box2).ExecuteCommand();
|
#endregion
|
|
#region 库存
|
var dataStock1 = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo);
|
if (dataStock1 != null)
|
{
|
dataStock1.Qty += item.Qty;
|
if (item.InspectMark == "1")
|
{
|
dataStock1.IsSampling = item.InspectMark;
|
}
|
Db.Updateable(dataStock1).ExecuteCommand();
|
}
|
else
|
{
|
var stock = new DataStock()
|
{
|
SkuNo = sku.SkuNo,
|
SkuName = sku.SkuName,
|
Standard = sku.Standard,
|
LotNo = "",
|
LotText = "",
|
Qty = item.Qty,
|
LockQty = 0,
|
FrozenQty = 0,
|
IsSampling = item.InspectMark,
|
IsDel = "0",
|
CreateUser = userId,
|
CreateTime = comTime
|
};
|
Db.Insertable(stock).ExecuteCommand();
|
}
|
#endregion
|
|
break;
|
case "0":
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.ASNDetailNo);
|
if (noticeDetail == null)
|
{
|
throw new Exception("未查询到托盘绑定的入库单明细信息");
|
}
|
var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == noticeDetail.ASNNo);
|
if (notice == null)
|
{
|
throw new Exception("未查询到托盘绑定的入库单信息");
|
}
|
string ownerNo = notice.CustomerNo;//货主编码
|
string ownerName = notice.CustomerName;//货主名称
|
|
var sku1 = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == noticeDetail.SkuNo);
|
string isinspect = "0";
|
//判断物料是否免检
|
if (sku1.IsInspect == "1")
|
{
|
isinspect = sku1.IsInspect;
|
}
|
|
//获取该批次最终质检结果
|
BllQualityInspect quality = new BllQualityInspect();
|
//判断是否为退货入库单
|
if (notice.Type == "3")
|
{
|
quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.ASNNo == noticeDetail.ASNNo && a.SkuNo == noticeDetail.SkuNo && a.LotNo == noticeDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
|
}
|
else
|
{
|
quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.SkuNo == noticeDetail.SkuNo && a.LotNo == noticeDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
|
}
|
|
var tags = "0";
|
if (notice.Type == "3" || notice.Type == "4")
|
{
|
tags = "1";
|
}
|
#region 库存明细
|
var sd = new DataStockDetail()
|
{
|
LotNo = item.LotNo,
|
LotText = noticeDetail.LotText,
|
SupplierLot = noticeDetail.SupplierLot,
|
SkuNo = noticeDetail.SkuNo,
|
SkuName = noticeDetail.SkuName,
|
Standard = noticeDetail.Standard,
|
Qty = item.Qty,
|
LockQty = 0,
|
FrozenQty = 0,
|
InspectQty = 0,
|
ASNNo = item.ASNNo,
|
ASNDetailNo = item.ASNDetailNo,
|
WareHouseNo = locate.WareHouseNo,
|
RoadwayNo = locate.RoadwayNo,
|
AreaNo = locate.AreaNo,
|
LocatNo = !string.IsNullOrWhiteSpace(locate.LocatNo) ? locate.LocatNo : "",
|
PalletNo = item.PalletNo,
|
PalletNo2 = item.PalletNo2,
|
PalletNo3 = item.PalletNo3,
|
PalletTags = tags,
|
CompleteTime = comTime,
|
ProductionTime = item.ProductionTime,
|
ExpirationTime = item.ExpirationTime,
|
Status = "0",
|
InspectMark = item.InspectMark,
|
InspectStatus = isinspect,
|
BitPalletMark = item.BitPalletMark,
|
PackagNo = noticeDetail.PackagNo,
|
IsBale = item.IsBale,
|
IsBelt = item.IsBelt,
|
Demo = item.Demo,
|
|
IsDel = "0",
|
CreateUser = 0,
|
CreateTime = comTime
|
};
|
//维护库存明细货主/供应商信息
|
if (notice.Type == "0" || notice.Type == "2" || notice.Type == "4" || notice.Type == "6" || notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
|
{
|
sd.OwnerNo = notice.CustomerNo;//货主编码
|
sd.OwnerName = notice.CustomerName;//货主名称
|
}
|
else if (notice.Type == "1" || notice.Type == "5")//1:采购入库,2:其它入库
|
{
|
sd.SupplierNo = notice.CustomerNo;//供应商编码
|
sd.SupplierName = notice.CustomerName;//供应商名称
|
}
|
|
if (quality != null)
|
{
|
//修改合格不合格数量
|
if (quality.IsQualified == "1") //合格
|
{
|
//增加合格数量
|
quality.PassQty += item.Qty;
|
sd.InspectStatus = "1";
|
}
|
else if (quality.IsQualified == "0") //不合格
|
{
|
//增加不合格数量
|
quality.FailQty += item.Qty;
|
sd.InspectStatus = "2";
|
}
|
Db.Updateable(quality).ExecuteCommand(); //修改质检信息
|
}
|
|
var sdId = Db.Insertable(sd).ExecuteReturnIdentity(); //新增库存明细信息
|
|
#endregion
|
|
#region 库存箱码明细
|
var boxInfoList = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == item.Id).ToList();
|
var boxList = new List<DataBoxInfo>();
|
foreach (var demo in boxInfoList)
|
{
|
var box = new DataBoxInfo()
|
{
|
StockDetailId = sdId,
|
BindNo = demo.BindNo,
|
BoxNo = demo.BoxNo,
|
BoxNo2 = demo.BoxNo2,
|
BoxNo3 = demo.BoxNo3,
|
PalletNo = demo.PalletNo,
|
PalletNo2 = demo.PalletNo2,
|
PalletNo3 = demo.PalletNo3,
|
Qty = demo.Qty,
|
FullQty = demo.FullQty,
|
Status = "2",
|
LotNo = demo.LotNo,
|
LotText = demo.LotText,
|
SkuNo = demo.SkuNo,
|
SkuName = demo.SkuName,
|
Standard = noticeDetail.Standard,
|
ProductionTime = demo.ProductionTime,
|
SupplierLot = demo.SupplierLot,
|
InspectStatus = isinspect,
|
InspectMark = demo.InspectMark,
|
BitBoxMark = demo.BitBoxMark,
|
|
CreateUser = 0,
|
CreateTime = comTime
|
};
|
boxList.Add(box);
|
demo.Status = "2";
|
}
|
Db.Updateable(boxInfoList).ExecuteCommand();
|
Db.Insertable(boxList).ExecuteCommand();
|
|
#endregion
|
|
#region 库存
|
var dataStock = Db.Queryable<DataStock>().First(m =>
|
m.IsDel == "0" && m.SkuNo == noticeDetail.SkuNo && m.LotNo == item.LotNo);
|
if (dataStock != null)
|
{
|
dataStock.Qty += item.Qty;
|
if (item.InspectMark == "1")
|
{
|
dataStock.IsSampling = item.InspectMark;
|
}
|
Db.Updateable(dataStock).ExecuteCommand();
|
}
|
else
|
{
|
var stock = new DataStock()
|
{
|
SkuNo = noticeDetail.SkuNo,
|
SkuName = noticeDetail.SkuName,
|
Standard = noticeDetail.Standard,
|
LotNo = item.LotNo,
|
LotText = noticeDetail.LotText,
|
Qty = item.Qty,
|
LockQty = 0,
|
FrozenQty = 0,
|
IsSampling = item.InspectMark,
|
IsDel = "0",
|
CreateUser = userId,
|
CreateTime = comTime
|
};
|
//维护库存货主信息
|
if (notice.Type == "0" || notice.Type == "2" || notice.Type == "4" || notice.Type == "6" || notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
|
{
|
stock.OwnerNo = notice.CustomerNo;//货主编码
|
stock.OwnerName = notice.CustomerName;//货主名称
|
}
|
Db.Insertable(stock).ExecuteCommand();
|
}
|
#endregion
|
|
#region 入库单 及 明细
|
//入库单明细
|
noticeDetail.CompleteQty += item.Qty;
|
if (noticeDetail.CompleteQty >= noticeDetail.Qty)
|
{
|
noticeDetail.Status = "2";
|
noticeDetail.CompleteTime = comTime;
|
}
|
Db.Updateable(noticeDetail).ExecuteCommand();
|
//入库单
|
var asnDetailNum = Db.Queryable<BllArrivalNoticeDetail>()
|
.Count(m => m.IsDel == "0" && m.ASNNo == noticeDetail.ASNNo && m.Status != "2");
|
if (asnDetailNum == 0)
|
{
|
notice.Status = "2";
|
notice.CompleteTime = comTime;
|
Db.Updateable(notice).ExecuteCommand();
|
}
|
|
#endregion
|
|
#region 采购计划
|
if (notice.Type == "1" && !string.IsNullOrEmpty(noticeDetail.OrderDetailCode))
|
{
|
//采购单明细
|
var planDetail = Db.Queryable<BllProcurePlanNoticeDetail>().First(it => it.OrderDetailCode == noticeDetail.OrderDetailCode && it.IsDel == "0");
|
planDetail.CompleteQty += item.Qty;
|
if (planDetail.CompleteQty >= planDetail.Qty)
|
{
|
planDetail.Status = "2";
|
planDetail.CompleteTime = comTime;
|
}
|
Db.Updateable(planDetail).ExecuteCommand();
|
|
//采购单
|
var planOrd = Db.Queryable<BllProcurePlanNotice>().First(it => it.Id == planDetail.ParentId && it.IsDel == "0");
|
var planDetailNum = Db.Queryable<BllProcurePlanNoticeDetail>()
|
.Count(m => m.IsDel == "0" && m.ParentId == planDetail.ParentId && m.Status != "2");
|
if (planDetailNum == 0)
|
{
|
planOrd.Status = "2";
|
planOrd.CompleteTime = comTime;
|
Db.Updateable(planOrd).ExecuteCommand();
|
}
|
else
|
{
|
if (planOrd.Status == "0")
|
{
|
planOrd.Status = "1";
|
Db.Updateable(planOrd).ExecuteCommand();
|
}
|
}
|
}
|
|
#endregion
|
break;
|
}
|
item.Status = "2";
|
item.CompleteTime = comTime;
|
|
#region 手动完成注释代码
|
|
//item.Status = "2";
|
//item.CompleteTime = comTime;
|
//var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>()
|
// .First(m => m.IsDel == "0" && m.Id == item.ASNDetailNo);
|
//if (noticeDetail == null)
|
//{
|
// throw new Exception("未查询到托盘绑定的入库单明细信息");
|
//}
|
//#region 库存明细
|
//var sd = new DataStockDetail()
|
//{
|
// LotNo = noticeDetail.LotNo,
|
// LotText = noticeDetail.LotText,
|
// SupplierLot = noticeDetail.SupplierLot,
|
// SkuNo = noticeDetail.SkuNo,
|
// SkuName = noticeDetail.SkuName,
|
// Standard = noticeDetail.Standard,
|
// Qty = item.Qty,
|
// LockQty = 0,
|
// FrozenQty = 0,
|
// InspectQty = 0,
|
// ASNNo = item.ASNNo,
|
// ASNDetailNo = item.ASNDetailNo,
|
// WareHouseNo = locate.WareHouseNo,
|
// RoadwayNo = locate.RoadwayNo,
|
// AreaNo = locate.AreaNo,
|
// LocatNo = locate.LocatNo,
|
// PalletNo = item.PalletNo,
|
// PalletNo2 = item.PalletNo2,
|
// PalletNo3 = item.PalletNo3,
|
// CompleteTime = comTime,
|
// ProductionTime = item.ProductionTime,
|
// ExpirationTime = item.ExpirationTime,
|
// Status = "0",
|
// InspectMark = item.InspectMark,
|
// InspectStatus = "1",
|
// BitPalletMark = item.BitPalletMark,
|
// PackagNo = noticeDetail.PackagNo,
|
// IsBale = item.IsBale,
|
// IsBelt = item.IsBelt,
|
|
// IsDel = "0",
|
// CreateUser = 0,
|
// CreateTime = comTime
|
//};
|
//var sdId = Db.Insertable(sd).ExecuteReturnIdentity();
|
//#endregion
|
|
//#region 库存箱码明细
|
//var boxInfoList = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == item.Id).ToList();
|
//var boxList = new List<DataBoxInfo>();
|
//foreach (var demo in boxInfoList)
|
//{
|
// var box = new DataBoxInfo()
|
// {
|
// StockDetailId = sdId,
|
// BindNo = demo.BindNo,
|
// BoxNo = demo.BoxNo,
|
// BoxNo2 = demo.BoxNo2,
|
// BoxNo3 = demo.BoxNo3,
|
// PalletNo = demo.PalletNo,
|
// PalletNo2 = demo.PalletNo2,
|
// PalletNo3 = demo.PalletNo3,
|
// Qty = demo.Qty,
|
// FullQty = demo.FullQty,
|
// Status = "2",
|
// LotNo = demo.LotNo,
|
// LotText = demo.LotText,
|
// SkuNo = demo.SkuNo,
|
// SkuName = demo.SkuName,
|
// Standard = noticeDetail.Standard,
|
// ProductionTime = demo.ProductionTime,
|
// SupplierLot = demo.SupplierLot,
|
// InspectStatus = demo.InspectStatus,
|
// InspectMark = demo.InspectMark,
|
// BitBoxMark = demo.BitBoxMark,
|
|
// CreateUser = 0,
|
// CreateTime = comTime
|
// };
|
// boxList.Add(box);
|
// demo.Status = "2";
|
//}
|
//Db.Updateable(boxInfoList).ExecuteCommand();
|
//Db.Insertable(boxList).ExecuteCommand();
|
|
//#endregion
|
|
//#region 库存
|
//var dataStock = Db.Queryable<DataStock>().First(m =>
|
// m.IsDel == "0" && m.SkuNo == noticeDetail.SkuNo && m.LotNo == noticeDetail.LotNo);
|
//if (dataStock != null)
|
//{
|
// dataStock.Qty += item.Qty;
|
// Db.Updateable(dataStock).ExecuteCommand();
|
//}
|
//else
|
//{
|
// var stock = new DataStock()
|
// {
|
// SkuNo = noticeDetail.SkuNo,
|
// SkuName = noticeDetail.SkuName,
|
// Standard = noticeDetail.Standard,
|
// LotNo = noticeDetail.LotNo,
|
// LotText = noticeDetail.LotText,
|
// Qty = item.Qty,
|
// LockQty = 0,
|
// FrozenQty = 0,
|
|
// IsDel = "0",
|
// CreateUser = userId,
|
// CreateTime = comTime
|
// };
|
// Db.Insertable(stock).ExecuteCommand();
|
//}
|
//#endregion
|
|
//#region 入库单 及 明细
|
////入库单明细
|
//noticeDetail.CompleteQty += item.Qty;
|
//if (noticeDetail.CompleteQty>=noticeDetail.Qty)
|
//{
|
// noticeDetail.Status = "2";
|
// noticeDetail.CompleteTime = comTime;
|
//}
|
//Db.Updateable(noticeDetail).ExecuteCommand();
|
////入库单
|
//var asnDetailNum = Db.Queryable<BllArrivalNoticeDetail>()
|
// .Count(m => m.IsDel == "0" && m.ASNNo == noticeDetail.ASNNo && m.Status!="2");
|
//if (asnDetailNum == 0)
|
//{
|
// var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == noticeDetail.ASNNo);
|
// notice.Status = "2";
|
// notice.CompleteTime = comTime;
|
// Db.Updateable(notice).ExecuteCommand();
|
//}
|
|
//#endregion
|
#endregion
|
|
}
|
//判断储位信息
|
locate.Status = "1";
|
Db.Updateable(locate).ExecuteCommand();
|
|
|
Db.Updateable(bindList).ExecuteCommand();
|
|
Db.CommitTran();
|
|
}
|
catch (Exception e)
|
{
|
Db.RollbackTran();
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 入库完成(wcs反馈、wms手动完成)，针对组托即增加库存，这里入库完成不再更新库存信息
|
/// </summary>
|
/// <param name="taskNo"></param>
|
/// <param name="userId"></param>
|
public void ArrivalSuccessBack(string taskNo, int userId)
|
{
|
try
|
{
|
//入库任务信息
|
var task = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == taskNo);
|
if (task == null)
|
{
|
throw new Exception("未查询到任务信息");
|
}
|
if (task.Status == "2")
|
{
|
throw new Exception("当前任务已完成");
|
}
|
if (string.IsNullOrWhiteSpace(task.EndLocat))
|
{
|
throw new Exception("当前任务没有目标地址");
|
}
|
|
var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
|
//当前任务中的储位信息
|
var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
|
if (locate == null)
|
{
|
throw new Exception($"未查询到任务中的储位信息");
|
}
|
var comTime = DateTime.Now;
|
Db.BeginTran();
|
|
task.Status = "2";//任务状态
|
task.IsSend = 0;
|
task.IsCancel = 0;
|
task.IsFinish = 0;
|
task.FinishDate = comTime;//完成时间
|
//更新任务信息
|
Db.Updateable(task).ExecuteCommand();
|
//更改托盘上架记录信息
|
var upShelfList = Db.Queryable<BllPalletUpShelf>().Where(m => m.IsDel == "0" && m.TaskNo == taskNo && m.PalletNo == task.PalletNo).ToList();
|
foreach (var upShelf in upShelfList)
|
{
|
upShelf.Status = "2";
|
Db.Updateable(upShelf).ExecuteCommand();
|
}
|
//判断是否是回流入库完成
|
if (stockDetail.Any())
|
{
|
foreach (var item in stockDetail)
|
{
|
item.WareHouseNo = locate.WareHouseNo;
|
item.RoadwayNo = locate.RoadwayNo;
|
item.AreaNo = locate.AreaNo;
|
item.LocatNo = locate.LocatNo;
|
item.UpdateTime = DateTime.Now;
|
if (userId != 0)
|
{
|
item.UpdateUser = userId;
|
}
|
}
|
locate.Status = "1";
|
//更新储位地址状态
|
Db.Updateable(locate).ExecuteCommand();
|
//更新库存明细信息
|
Db.Updateable(stockDetail).ExecuteCommand();
|
|
var bindList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.TaskNo == taskNo && m.Status == "2").ToList();
|
foreach (var item in bindList)
|
{
|
#region 库存箱码明细
|
var boxInfoList = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == item.Id).ToList();
|
foreach (var demo in boxInfoList)
|
{
|
demo.Status = "2";
|
}
|
//更新箱支信息表状态
|
Db.Updateable(boxInfoList).ExecuteCommand();
|
|
var dataBoxInfoList = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == item.Id).ToList();
|
foreach (var demo2 in dataBoxInfoList)
|
{
|
demo2.Status = "2";
|
}
|
//更新库存箱支明细状态
|
Db.Updateable(dataBoxInfoList).ExecuteCommand();
|
#endregion
|
|
item.Status = "3";
|
item.CompleteTime = comTime;
|
}
|
//更新托盘绑定状态
|
Db.Updateable(bindList).ExecuteCommand();
|
if (userId != 0)
|
{
|
//添加操作日志记录
|
var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
|
}
|
Db.CommitTran();
|
return;
|
}
|
}
|
catch (Exception e)
|
{
|
Db.RollbackTran();
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 满入异常
|
/// </summary>
|
/// <param name="model">任务信息</param>
|
/// <returns>返回新的储位地址</returns>
|
public OutCommandDto FullException(ReceiveWcsSignal model)
|
{
|
try
|
{
|
OutCommandDto comDto;//返回wcs的入库命令
|
|
// 判断当前任务状态 Status 1:正在执行 3:异常结束
|
var taskModel = Db.Queryable<LogTask>().First(m => m.TaskNo == model.TaskNo && m.IsDel == "0" && m.Status == "1");
|
if (taskModel == null)
|
{
|
throw new Exception("此任务不存在或任务状态已变更!");
|
}
|
|
Db.BeginTran();
|
// 将当前任务状态变更异常结束
|
taskModel.Status = "3";
|
Db.Updateable(taskModel).ExecuteCommand();
|
|
// 改变当前储位地址的储位标志变更为屏蔽
|
var locatModel = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == taskModel.EndLocat && m.IsDel == "0");
|
if (locatModel == null)
|
{
|
throw new Exception("未查询到当前任务储位信息!");
|
}
|
locatModel.Flag = "1";
|
Db.Updateable(locatModel).ExecuteCommand();
|
|
// 验证托盘绑定信息
|
string asnNo = "回流托盘";
|
var palletBindModel = Db.Queryable<BllPalletBind>().First(m => m.PalletNo == model.PalletNo && m.TaskNo == model.TaskNo && m.IsDel == "0" && m.Status == "1");
|
if (palletBindModel != null)
|
{
|
asnNo = palletBindModel.ASNNo;
|
}
|
|
// 插入异常处理表
|
string exceptionNo = new Common().GetMaxNo("EX");
|
var exceptionModel = new SysException()
|
{
|
ExceptionNo = exceptionNo,
|
Type = "1", // 0:空取异常 1:满入异常 2:双工位异常
|
PalletNo = taskModel.PalletNo,
|
ExcLocatNo = taskModel.EndLocat,
|
OrderNo = asnNo,
|
TaskNo = taskModel.TaskNo,
|
Status = "0",
|
Text = "", // 处理描述
|
CreateUser = 0
|
};
|
Db.Insertable(exceptionModel).ExecuteCommand();
|
|
|
// 根据托盘号重新获取储位地址（当前巷道优先）
|
SysStorageLocat locate = new SysStorageLocat();
|
AllotLocation allotLocate = new AllotLocation();
|
try
|
{
|
var skuNo = "";
|
if (asnNo != "回流托盘")
|
{
|
//获取物料存放区域
|
var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m =>
|
m.IsDel == "0" && m.Id == palletBindModel.ASNDetailNo);
|
if (noticeDetail == null)
|
{
|
throw new Exception("托盘存在物料未绑定入库单明细，不可入库");
|
}
|
|
skuNo = noticeDetail.SkuNo;
|
}
|
else
|
{
|
var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == model.PalletNo).ToList();
|
if (stockDetail.Count == 0)
|
{
|
throw new Exception($"{model.PalletNo}托盘条码不具有箱码信息，不可入库！");
|
}
|
skuNo = stockDetail.First().SkuNo;
|
}
|
|
var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == skuNo);
|
if (sku == null)
|
{
|
throw new Exception("物料信息中未查询到入库单明细包含的物料信息，不可入库");
|
}
|
//判断物料是否含有类别信息
|
if (string.IsNullOrWhiteSpace(sku.CategoryNo))
|
{
|
throw new Exception($"物料：{sku.SkuNo}未查询到类别信息");
|
}
|
|
var skuCategory = Db.Queryable<SysMaterialCategory>().First(m => m.IsDel == "0" && m.CategoryNo == sku.CategoryNo);
|
if (skuCategory == null)
|
{
|
throw new Exception($"未在类别信息中查询到物料：{sku.SkuNo}包含的类别");
|
}
|
|
var areaStr = skuCategory.AreaNo.Split(",");
|
var areaList = new List<string>();
|
foreach (var item in areaStr)
|
{
|
areaList.Add(item);
|
}
|
|
locate = allotLocate.GetSuiTableLocate("W01", areaList, taskModel.EndRoadway);
|
}
|
catch (Exception ex)
|
{
|
//try
|
//{
|
// locate = allotLocate.GetSuiTableLocate("W01", "");
|
//}
|
//catch (Exception ex)
|
//{
|
// 整个仓库都没有找到托盘
|
if (asnNo != "回流托盘")
|
{
|
palletBindModel.Status = "0"; // 等待执行
|
palletBindModel.LocatNo = ""; // 储位地址
|
Db.Updateable(palletBindModel).ExecuteCommand();
|
Db.CommitTran();
|
}
|
|
return null;
|
//throw ex;
|
//}
|
}
|
|
|
|
// 生成入库任务
|
var taskNo = new Common().GetMaxNo("TK"); // 获取任务编号
|
var exTask = new LogTask
|
{
|
TaskNo = taskNo,
|
Sender = "WMS",
|
Receiver = "WCS",
|
IsSuccess = 1, //是否下发成功 0失败 1成功
|
SendDate = DateTime.Now, //发送时间
|
BackDate = DateTime.Now, //返回时间
|
StartRoadway = taskModel.EndRoadway, //起始巷道
|
StartLocat = taskModel.EndLocat, //起始位置
|
EndLocat = locate.LocatNo, //目标位置
|
EndRoadway = locate.RoadwayNo, //目标巷道
|
PalletNo = taskModel.PalletNo, //托盘码
|
IsSend = 1, //是否可再次下发
|
IsCancel = 1, //是否可取消
|
IsFinish = 1, //是否可完成
|
Type = "0", //任务类型 0 入库任务 1 出库任务 2 移库任务
|
Status = "1", //任务状态0：等待执行1正在执行2执行完成
|
OrderType = "0", //0 入库单 1 出库单 2 盘点单 3 移库单
|
Msg = taskModel.EndLocat + ">>>>" + locate.LocatNo + "的入库任务", //关键信息
|
};
|
Db.Insertable(exTask).ExecuteCommand();
|
locate.Status = "2";
|
Db.Updateable(locate).ExecuteCommand();
|
|
if (asnNo != "回流托盘")
|
{
|
palletBindModel.TaskNo = taskNo; // 更新储位地址
|
palletBindModel.LocatNo = locate.LocatNo; // 更新储位地址
|
Db.Updateable(palletBindModel).ExecuteCommand();
|
}
|
|
comDto = new OutCommandDto()
|
{
|
PalletNo = taskModel.PalletNo, //托盘号
|
StartRoadway = taskModel.EndRoadway,
|
StartLocate = taskModel.EndLocat, // 起始位置
|
EndLocate = locate.LocatNo, // 目标位置
|
EndRoadway = locate.RoadwayNo, // 目标巷道
|
TaskNo = exTask.TaskNo, // 任务号
|
TaskType = "0",
|
OutMode = "", //目标地址
|
Order = 1 // 优先级
|
};
|
Db.CommitTran();
|
|
|
return comDto;
|
}
|
catch (Exception e)
|
{
|
Db.RollbackTran();
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 手动取消入库任务
|
/// </summary>
|
/// <param name="taskNo"></param>
|
/// <param name="userId"></param>
|
/// <exception cref="Exception"></exception>
|
public void CancelAsnTask(string taskNo, int userId)
|
{
|
try
|
{
|
var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
|
if (task == null)
|
{
|
throw new Exception("未查询到任务信息");
|
}
|
Db.BeginTran();
|
var time = DateTime.Now;
|
//修改任务
|
task.IsSuccess = 1;
|
task.IsCancel = 0;
|
task.IsFinish = 0;
|
task.IsSend = 0;
|
task.Status = "4";
|
task.CancelDate = DateTime.Now;
|
Db.Updateable(task).ExecuteCommand();
|
|
//托盘绑定信息
|
var bind = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.TaskNo == taskNo).ToList();
|
if (bind.Count > 0)
|
{
|
foreach (var item in bind)
|
{
|
item.Status = "2";//修改托盘绑定状态信息
|
item.TaskNo = "";//任务号清空
|
item.LocatNo = ""; //储位地址清空
|
item.WareHouseNo = "";
|
item.RoadwayNo = "";
|
item.UpdateTime = time;
|
item.UpdateUser = userId;
|
}
|
Db.Updateable(bind).ExecuteCommand();
|
}
|
//更改托盘上架记录信息
|
var upShelfList = Db.Queryable<BllPalletUpShelf>().Where(m => m.IsDel == "0" && m.TaskNo == taskNo && m.PalletNo == task.PalletNo).ToList();
|
foreach (var upShelf in upShelfList)
|
{
|
//upShelf.IsDel = "1";
|
upShelf.Status = "4";
|
Db.Updateable(upShelf).ExecuteCommand();
|
}
|
|
//储位信息
|
var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
|
if (locate != null)
|
{
|
locate.Status = "0"; //修改储位状态
|
Db.Updateable(locate).ExecuteCommand();
|
//throw new Exception("未查询道储位信息");
|
}
|
|
//添加操作日志记录
|
var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "取消", $"点击取消按钮取消了任务号为：{taskNo}的任务", (int)userId);
|
Db.CommitTran();
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
#endregion
|
|
#region 数据归档
|
public List<PalletBindDto> GetArchivingPalletBindList(PalletBindVm model, out int count)
|
{
|
try
|
{
|
var strList = new List<int>();
|
|
if (!string.IsNullOrWhiteSpace(model.SkuNo) || !string.IsNullOrWhiteSpace(model.SkuName))
|
{
|
string sql = $"select Distinct Id from ArchivingArrivalNoticeDetail where IsDel='0' and SkuNo like '%{model.SkuNo}%' and SkuName like '{model.SkuName}'";
|
var detailList = Db.Ado.SqlQuery<int>(sql);
|
|
strList = detailList;
|
}
|
string strListStr = string.Join(",", strList);
|
|
string sqlString = string.Empty;
|
string sqlCount = string.Empty;
|
string sqlPub = string.Empty;
|
sqlCount += "SELECT COUNT(tb1.ID) FROM ArchivingPalletBind AS tb1 ";
|
sqlString += "SELECT tb1.*,tb2.SkuNo,tb2.SkuName,tb3.RealName as CreateUserName FROM ArchivingPalletBind AS tb1 ";
|
sqlPub += "left join ArchivingArrivalNoticeDetail as tb2 on tb1.ASNDetailNo=tb2.Id ";
|
sqlPub += "left join SysUserInfor as tb3 on tb1.CreateUser=tb3.Id ";
|
sqlPub += "where tb1.IsDel = '0' ";
|
if (!string.IsNullOrEmpty(model.ASNNo))
|
{
|
sqlPub += $"AND tb1.ASNNo like '%{model.ASNNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.PalletNo))
|
{
|
sqlPub += $"AND tb1.PalletNo like '%{model.PalletNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.LocatNo))
|
{
|
sqlPub += $"AND tb1.LocatNo like '%{model.LocatNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.RoadwayNo))
|
{
|
sqlPub += $"AND tb1.RoadwayNo = '{model.RoadwayNo}' ";
|
}
|
if (!string.IsNullOrEmpty(model.WareHouseNo))
|
{
|
sqlPub += $"AND tb1.WareHouseNo = '{model.WareHouseNo}' ";
|
}
|
if (!string.IsNullOrEmpty(model.LotNo))
|
{
|
sqlPub += $"AND tb1.LotNo like '%{model.LotNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.LotText))
|
{
|
sqlPub += $"AND tb1.LotText like '%{model.LotText.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.StartTime))
|
{
|
sqlPub += $"AND tb1.CreateTime >= '{Convert.ToDateTime(model.StartTime)}' ";
|
}
|
if (!string.IsNullOrEmpty(model.EndTime))
|
{
|
sqlPub += $"AND tb1.CreateTime <= '{Convert.ToDateTime(model.EndTime)}' ";
|
}
|
if (!string.IsNullOrEmpty(model.Status))
|
{
|
sqlPub += $"AND tb1.Status = '{model.Status}' ";
|
}
|
if (strList.Count > 0)
|
{
|
sqlPub += $"AND tb1.ASNDetailNo in '{strListStr}' ";
|
}
|
|
sqlCount += sqlPub;
|
sqlPub += " order by tb1.CreateTime desc ";
|
if (model.Page == 0)
|
{
|
model.Page = 1;
|
}
|
sqlString += sqlPub + $" offset {((model.Page - 1) * model.Limit)} rows fetch next {model.Limit} rows only;";
|
|
var com = new Common();
|
count = com.GetRowCount(sqlCount);
|
|
var modelList = Db.Ado.SqlQuery<PalletBindDto>(sqlString);
|
var sku = Db.Queryable<SysMaterials>().First(a => a.IsDel == "0" && a.SkuNo == "100099" && a.SkuName == "托盘");
|
foreach (var item in modelList)
|
{
|
if (item.Type == "1" && string.IsNullOrEmpty(item.SkuNo))
|
{
|
item.SkuNo = sku.SkuNo;
|
}
|
if (item.Type == "1" && string.IsNullOrEmpty(item.SkuName))
|
{
|
item.SkuName = sku.SkuName;
|
}
|
}
|
|
return modelList;
|
}
|
catch (Exception ex)
|
{
|
throw new Exception(ex.Message);
|
}
|
}
|
|
public List<BoxInfoDto> GetArchivingBoxInfoList(BoxInfoVm model, out int count)
|
{
|
try
|
{
|
string sqlString = string.Empty;
|
string sqlCount = string.Empty;
|
string sqlPub = string.Empty;
|
sqlCount += "SELECT tb1.BoxNo,tb1.PalletNo,SUM(tb1.Qty) as Qty,SUM(tb1.SamplingQty) as SamplingQty,tb1.FullQty,tb1.SkuNo,tb1.SkuName,tb1.LotNo,tb1.LotText, ";
|
sqlCount += "tb1.ProductionTime,tb1.ExpirationTime,tb1.SupplierLot,tb1.InspectMark,tb1.BitBoxMark,tb1.InspectStatus,tb2.Status FROM ArchivingBoxInfo AS tb1 ";
|
sqlString += "SELECT tb1.BoxNo,tb1.PalletNo,SUM(tb1.Qty) as Qty,SUM(tb1.SamplingQty) as SamplingQty,tb1.FullQty,tb1.SkuNo,tb1.SkuName,tb1.LotNo,tb1.LotText, ";
|
sqlString += "tb1.ProductionTime,tb1.ExpirationTime,tb1.SupplierLot,tb1.InspectMark,tb1.BitBoxMark,tb1.InspectStatus,tb2.Status FROM ArchivingBoxInfo AS tb1 ";
|
sqlPub += "left join ArchivingPalletBind as tb2 on tb1.BindNo=tb2.Id ";
|
sqlPub += "where tb1.IsDel = '0' ";
|
if (!string.IsNullOrEmpty(model.ASNNo))
|
{
|
sqlPub += $"AND tb1.ASNNo like '%{model.ASNNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.PalletNo))
|
{
|
sqlPub += $"AND tb1.PalletNo like '%{model.PalletNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.LotNo))
|
{
|
sqlPub += $"AND tb1.LotNo like '%{model.LotNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.SkuNo))
|
{
|
sqlPub += $"AND tb1.SkuNo like '%{model.SkuNo.Trim()}%' ";
|
}
|
if (!string.IsNullOrEmpty(model.SkuName))
|
{
|
sqlPub += $"AND tb1.SkuName like '%{model.SkuName.Trim()}%' ";
|
}
|
if (model.BindNo != 0 && !string.IsNullOrWhiteSpace(model.BindNo.ToString()))
|
{
|
sqlPub += $"AND tb1.BindNo = '{model.BindNo}' ";
|
}
|
sqlPub += "group by tb1.PalletNo,tb1.BoxNo, tb1.SkuNo,tb1.SkuName,tb1.LotNo,tb1.LotText,tb1.SupplierLot,tb1.FullQty,tb1.ProductionTime,tb1.ExpirationTime,tb1.InspectMark,tb1.BitBoxMark,tb1.InspectStatus,tb2.Status ";
|
|
sqlCount += sqlPub;
|
sqlCount = $"select Count(1) from ({sqlCount}) as dd";
|
sqlPub += " order by tb1.PalletNo ";
|
if (model.Page == 0)
|
{
|
model.Page = 1;
|
}
|
sqlString += sqlPub + $" offset {((model.Page - 1) * model.Limit)} rows fetch next {model.Limit} rows only;";
|
|
var com = new Common();
|
count = com.GetRowCount(sqlCount);
|
|
var modelList = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);
|
|
return modelList;
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
}
|
|
/// <summary>
|
/// 根据箱码获取箱支信息-数据归档
|
/// </summary>
|
/// <param name="boxNo">箱码</param>
|
/// <param name="boxNo3">支码</param>
|
/// <returns></returns>
|
public List<BoxInfoDto> GetArchivingBoxInfoByBoxNo(string boxNo, string boxNo3)
|
{
|
string sqlString = string.Empty;
|
string sqlPub = string.Empty;
|
sqlString += "select tb1.*,tb2.RealName as CreateUserName,tb3.RealName as UpdateUserName from ArchivingBoxInfo as tb1 ";
|
sqlPub += "left join SysUserInfor as tb2 on tb1.CreateUser=tb2.Id ";
|
sqlPub += "left join SysUserInfor as tb3 on tb1.UpdateUser=tb3.Id ";
|
sqlPub += "where tb1.IsDel = '0' ";
|
if (!string.IsNullOrEmpty(boxNo))
|
{
|
sqlPub += $"AND tb1.BoxNo = '{boxNo.Trim()}' ";
|
}
|
if (!string.IsNullOrEmpty(boxNo3))
|
{
|
sqlPub += $"AND tb1.BoxNo3 = '{boxNo3.Trim()}' ";
|
}
|
|
sqlString += sqlPub;
|
var modelList = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);
|
|
return modelList;
|
}
|
#endregion
|
|
|
////重新下发入库任务
|
//public OutCommandDto AgainSendAsnTask(string taskNo, int userId, string url)
|
//{
|
// try
|
// {
|
// var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
|
// if (task == null)
|
// {
|
// throw new Exception("未查询到任务信息");
|
// }
|
// var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.PalletNo == task.PalletNo);
|
// if (stockDetail == null)
|
// {
|
// throw new Exception(task.PalletNo + " 当前托盘未在库内，请核实信息");
|
// }
|
|
|
// var outDto = new OutCommandDto()
|
// {
|
// PalletNo = task.PalletNo,//托盘号
|
// StartLocate = "", // 起始位置
|
// EndLocate = task.EndLocat, // 目标位置
|
// TaskNo = task.TaskNo, // 任务号
|
// TaskType = "1",// 任务类型 (出库)
|
// OutMode = "", //目标地址
|
// Order = 1
|
// };
|
// //添加操作日志记录
|
// var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "下发", $"点击下发按钮、重新下发了任务号为：{taskNo}的入库任务", (int)userId);
|
|
// // 正式运行程序放开
|
// var list = new List<string> { outDto.TaskNo };
|
// var jsonData = JsonConvert.SerializeObject(outDto);
|
|
// try
|
// {
|
// var time1 = DateTime.Now;//发送时间 .ToString("yyyy-MM-dd HH:mm:ss")
|
// var response = HttpHelper.DoPost(url, jsonData, "下发给WCS出库命令", "WCS");
|
// var time2 = DateTime.Now;//返回时间 .ToString("yyyy-MM-dd HH:mm:ss")
|
|
// ////解析返回数据
|
// var wcsModel = JsonConvert.DeserializeObject<WcsModel>(response);
|
// if (wcsModel.StatusCode == 0)
|
// {
|
// //更改任务的发送返回时间//
|
// new TaskServer().EditTaskIssueOk(list, time1, time2);
|
// }
|
// if (wcsModel.StatusCode == -1)
|
// {
|
// new TaskServer().EditTaskIssueNo(list, time1, time2, wcsModel.Msg);
|
// throw new Exception($"wcs返回状态异常：{wcsModel.Msg}");
|
// }
|
// }
|
// catch (Exception ex)
|
// {
|
// throw new Exception(ex.Message);
|
// }
|
// return outDto;
|
// }
|
// catch (Exception e)
|
// {
|
// throw new Exception(e.Message);
|
// }
|
//}
|
|
|
|
}
|
}
|
