ICM-WCS/wcs
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

增加盘点模式

Browse Source
This commit is contained in:
hehaibing-1996
2024-05-09 09:43:28 +08:00
parent 311a695498
commit cb6090bf0b
43 changed files with 2909 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
WCS.BLL/DbModels/InOutRecord.cs
View File

@ -5,6 +5,7 @@ using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.DAL.DbModels;
using WCS.Model.ApiModel.InOutRecord;
namespace WCS.BLL.DbModels
{
@ -113,13 +114,17 @@ namespace WCS.BLL.DbModels
/// </summary>
[SugarColumn(ColumnName = "operate_user", Length = 100, IsNullable = true, ColumnDescription = "创建人")]
public string OperateUser { get; set; }
/// <summary>
/// 序号
/// </summary>
[SugarColumn(IsIgnore = true)]
public int RowNumber { get; set; }
/// <summary>
/// 是否已经选择
/// </summary>
[SugarColumn(IsIgnore = true)]
public bool IsSelected { get; set; }
}
public enum DirectionEnum
{
入库 = 0,
出库 = 1,
丢失 = 2,
盘点 = 3,
}
}

13
WCS.BLL/DbModels/StockTakingOrderDetail.cs → WCS.BLL/DbModels/StockTakingOrderMatDetail.cs
View File

@ -47,7 +47,12 @@ namespace WCS.BLL.DbModels
public StoreInfo StoreInfo { get; set; }
#endregion
#region 物料属性
#region 库存属性
/// <summary>
/// 库存数据的ID
/// </summary>
[SugarColumn(ColumnName = "inventory_detail_id", IsNullable = true)]
public int InventoryDetailId { get; set; }
/// <summary>
/// 物料编码（SN）
/// </summary>
@ -116,5 +121,11 @@ namespace WCS.BLL.DbModels
/// </summary>
[SugarColumn(ColumnName = "create_user", Length = 100, IsNullable = true, ColumnDescription = "最后更新人")]
public string UpdateUser { get; set; }
/// <summary>
/// 用于绑定中显示序号
/// </summary>
[SugarColumn(IsIgnore = true)]
public int RowNumber { get; set; }
}
}

8
WCS.BLL/HardWare/IShelfBase.cs
View File

@ -90,7 +90,13 @@ namespace WCS.BLL.HardWare
/// <summary>
/// 货架进入盘点模式
/// </summary>
public void GoInStocktaking();
public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder outOrder);
/// <summary>
/// 货架单个确认盘点
/// </summary>
public bool ConfirmStocktakingSingle(int BoardId,int LightNumber);
/// <summary>
/// 货架退出盘点模式

10
WCS.BLL/HardWare/SingleLightShelf.cs
View File

@ -26,6 +26,11 @@ namespace WCS.BLL.HardWare
public List<string> ExceptionMessages { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
public bool IsWarning { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
{
throw new NotImplementedException();
}
public void GoInInstore(string IPAdress)
{
throw new NotImplementedException();
@ -41,6 +46,11 @@ namespace WCS.BLL.HardWare
throw new NotImplementedException();
}
public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder outOrder)
{
throw new NotImplementedException();
}
public void GoOutInstore()
{
throw new NotImplementedException();

755
WCS.BLL/HardWare/SmartShelf.cs
View File

@ -1,20 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using TouchSocket.Core;
using TouchSocket.Sockets;
using WCS.BLL.Config;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.DAL;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.ApiModel.OutStore;
using WCS.Model.WebSocketModel;
using static System.Formats.Asn1.AsnWriter;
namespace WCS.BLL.HardWare
{
@ -150,6 +142,7 @@ namespace WCS.BLL.HardWare
public string OrderNumber { get; set; }
public StockTakingOrder CurrentStockTakingOrder { get; set; }
public List<int> ModuleIds { get; set; }
public string ClientIp { get; set; }
@ -224,13 +217,28 @@ namespace WCS.BLL.HardWare
ExceptionMessages.Add($"模组{item.ModuleCode}未进入入库模式！");
}
//通信校验
var messages = notInstoreList.Select(t => $"模组{t.ModuleCode}未进入入库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
IsWarning = true;
WarningLight.WaringLightAlwaysRed(TcpCleint);
}
//没有报警才亮蓝灯
if(!IsWarning)
if (!IsWarning)
WarningLight.BlueLight(TcpCleint);
//绑定当前进入入库PDA/WCS前端的IP
CurrentCom = IPAddress;
@ -295,6 +303,22 @@ namespace WCS.BLL.HardWare
{
ExceptionMessages.Add($"模组{item.ModuleCode}未成功退出入库模式！");
}
var messages = list.Select(t => $"模组{t.ModuleCode}未成功退出入库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
//报警灯熄灭
WarningLight.CloseLight(TcpCleint);
@ -302,43 +326,89 @@ namespace WCS.BLL.HardWare
public void GoInOutstore(List<OutOrderMatDetail> MatDetails, OutOrder outOrder)
{
//第一步：设置货架当前模式
if (CurrentMode != Mode.待机模式)
try
{
Modules.ForEach(t => { t.Reset(TcpCleint); });
//第一步：设置货架当前模式
if (CurrentMode != Mode.待机模式)
{
Modules.ForEach(t => { t.Reset(TcpCleint); });
//复位需要点时间间隔才能响应指令
Thread.Sleep(1500);
}
CurrentMode = Mode.出库模式;
//第二步：货架添加需要出的SN 出库的领料单号
//移除货架所有现有待出库的MatSN
CurrentOutStoreMatSNs.Clear();
////添加属于当前货架的物料
CurrentOutStoreMatSNs.AddRange(MatDetails.Select(t => t.MatSN).ToList());
////记录当前出库的发料单
CurrentOutOrder = outOrder;
////第三步：对应的模组进入出库模式
var boardIds = MatDetails.Select(t => t.StoreInfo.BoardId)
.Distinct()
.OrderBy(t => t)
.ToList();
var outModules = Modules.Where(t => boardIds.Contains(t.BoardId)).ToList();
outModules.ForEach(t =>
{
var outMatSns = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Select(mat => mat.MatSN)
.ToList();
t.GoInOutStoreMode(TcpCleint, outMatSns);
});
//所有板子亮灯后 亮警示灯
WarningLight.GreenLight(TcpCleint);
Task.Run(() =>
{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功进入出库模式 表示进入出库模式成功，跳出循环
var isExistsNotInstore = outModules.Where(t => t.CurrentMode != Mode.出库模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsNotInstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = outModules.Where(t => t.IsEnable && t.CurrentMode != Mode.出库模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未进入出库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
});
}
CurrentMode = Mode.出库模式;
//第二步：货架添加需要出的SN 出库的领料单号
//移除货架所有现有待出库的MatSN
CurrentOutStoreMatSNs.Clear();
////添加属于当前货架的物料
CurrentOutStoreMatSNs.AddRange(MatDetails.Select(t => t.MatSN).ToList());
////记录当前出库的发料单
CurrentOutOrder = outOrder;
////第三步：对应的模组进入出库模式
var boardIds = MatDetails.Select(t => t.StoreInfo.BoardId)
.Distinct()
.OrderBy(t => t)
.ToList();
var outModules = Modules.Where(t => boardIds.Contains(t.BoardId)).ToList();
outModules.ForEach(t =>
catch (Exception e)
{
var outMatSns = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Select(mat => mat.MatSN)
.ToList();
t.GoInOutStoreMode(TcpCleint, outMatSns);
});
//所有板子亮灯后 亮警示灯
WarningLight.GreenLight(TcpCleint);
GoOutOutstore();
throw e;
}
}
public void GoInStocktaking()
{
this.CurrentMode = Mode.盘点模式;
}
public void GoOutOutstore()
{
//找到在出库中的模组
@ -348,13 +418,228 @@ namespace WCS.BLL.HardWare
{
module.GoOutOutStoreMode(TcpCleint);
}
//Task.Run(() =>
//{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功退出出库模式 表示退出出库模式成功，跳出循环
var isExistsOutstore = outingModules.Where(t => t.CurrentMode == Mode.出库模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsOutstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = outingModules.Where(t => t.IsEnable && t.CurrentMode == Mode.出库模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未退出出库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.退出入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
//});
CurrentOutStoreMatSNs.Clear();
WarningLight.CloseLight(TcpCleint);
this.CurrentMode = Mode.待机模式;
}
public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder stockTakingOrder)
{
try
{
//第一步：设置货架当前模式
if (CurrentMode != Mode.待机模式)
{
Modules.ForEach(t =>
{
if (CurrentMode != Mode.待机模式)
t.Reset(TcpCleint);
});
//复位需要点时间间隔才能响应指令
Thread.Sleep(1500);
}
CurrentMode = Mode.盘点模式;
//第二步：货架添加 盘点单号 记录当前盘点的发料单
CurrentStockTakingOrder = stockTakingOrder;
//第三步：对应的模组进入盘点模式
var boardIds = MatDetails.Select(t => t.StoreInfo.BoardId)
.Distinct()
.OrderBy(t => t)
.ToList();
var outModules = Modules.Where(t => boardIds.Contains(t.BoardId)).ToList();
outModules.ForEach(t =>
{
var noStockTakings = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Where(t => t.IsStocktaking == false)
.Select(mat => mat.MatSN)
.ToList();
t.GoInStockTakingMode(TcpCleint, noStockTakings);
var stockTakings = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Where(t => t.IsStocktaking)
.Select(mat => mat.MatSN)
.ToList();
t.ConfirmStockTaking(TcpCleint, stockTakings);
});
//所有板子亮灯后 亮警示灯
WarningLight.GreenLight(TcpCleint);
Task.Run(() =>
{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功进入盘点模式 表示进入盘点模式成功，跳出循环
var isExistsNotInstore = outModules.Where(t => t.CurrentMode != Mode.盘点模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsNotInstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = outModules.Where(t => t.IsEnable && t.CurrentMode != Mode.盘点模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未进入盘点模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入盘点未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
});
}
catch (Exception e)
{
GoOutStocktaking();
throw e;
}
}
/// <summary>
/// 确认盘点 Pda进行触发
/// </summary>
public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
{
//寻找对应模组
var module = Modules.Where(t => t.BoardId == BoardId).FirstOrDefault(); ;
if (module == null)
return false;
else
{
module.ConfirmStockTakingSingle(TcpCleint, LightNumber);
//报警灯闪一下
WarningLight.SuccessLightGreenEnd(TcpCleint);
//通知前台刷新
Task.Run(() =>
{
var messageMode = new WebSocketMessageModel()
{
IsWarning = false,
ClientIp = "127.0.0.1",
WarningType = WarningTypeEnum.通知刷新盘点
};
WarningManager.SendWarning(messageMode);
});
return true;
}
}
public void GoOutStocktaking()
{
//找到在盘点中的模组
var stockTakingModules = Modules.Where(t => t.CurrentMode == Mode.盘点模式)
.ToList();
foreach (var module in stockTakingModules)
{
module.GoOutStockTakingMode(TcpCleint);
}
Task.Run(() =>
{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功退出盘点模式 表示退出盘点模式成功，跳出循环
var isExistsNotInstore = stockTakingModules.Where(t => t.CurrentMode == Mode.盘点模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsNotInstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = stockTakingModules.Where(t => t.IsEnable && t.CurrentMode == Mode.盘点模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未退出盘点模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.退出盘点未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
});
CurrentOutStoreMatSNs.Clear();
WarningLight.CloseLight(TcpCleint);
this.CurrentMode = Mode.待机模式;
}
@ -413,6 +698,12 @@ namespace WCS.BLL.HardWare
case 0x08://出库模式中异常信号
OutstoreExceptionReturnProcess(data, boardId, lightNumber);
break;
case 0x09://进入盘点模式返回信号
GoInStockTakingReturnProcess(data, boardId, lightNumber);
break;
case 0x0A://退出盘点模式返回信号
GoOutStockTakingReturnProcess(data, boardId, lightNumber);
break;
case 0x13://复位的返回信号
ResetReturnProcess(data, boardId, lightNumber);
break;
@ -508,7 +799,7 @@ namespace WCS.BLL.HardWare
// var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.StoreId == storeInfo.Id).First();
// if (inventoryDetail != null)
// {
// var inOutRecord = new InOutRecord()
// var inOutRecord = new MatInventoryDetailService()
// {
// StoreCode = storeInfo.StoreCode,
// StoreId = storeInfo.Id,
@ -622,18 +913,17 @@ namespace WCS.BLL.HardWare
/// <param name="data"></param>
public void InStoreReturnProcess(byte[] data)
{
Logs.Write("协议处理5.1");
var boardId = (data[TcpCleint.PreFixLength + 0] << 8) + data[TcpCleint.PreFixLength + 1];
var number = Convert.ToInt32(data[TcpCleint.PreFixLength + 3]);
var storeInfo = DbHelp.db.Queryable<StoreInfo>().Where(t => t.BoardId == boardId
&& t.LightNumber == number).First();
Logs.Write("协议处理5.2");
if (storeInfo == null)
{
//TODO 报错
return;
}
Logs.Write("协议处理5.3");
var module = this.Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module == null)
@ -641,7 +931,7 @@ namespace WCS.BLL.HardWare
//TODO 报错
return;
}
Logs.Write("协议处理5.4");
#region 判断是否扫码获取物料信息
//物料未扫码
if (this.InStoreData == null)
@ -655,7 +945,6 @@ namespace WCS.BLL.HardWare
}
else
{
Logs.Write("协议处理5.5");
var exceptionMessage = storeInfo.StoreCode + "入库过程中存在物料未扫描上架！";
var warningModel = new WebSocketMessageModel()
{
@ -671,7 +960,6 @@ namespace WCS.BLL.HardWare
};
WarningManager.SendWarning(warningModel);
Logs.Write("协议处理5.4");
module.ComfirmErrInstore(TcpCleint);
WarningLight.WaringLightAlwaysRed(TcpCleint);
return;
@ -750,7 +1038,6 @@ namespace WCS.BLL.HardWare
module.ComfirmInstore(TcpCleint);
//报警灯亮绿灯 鸣叫一次提示
WarningLight.SuccessLightBlueEnd(TcpCleint);
//SuccessLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
});
}
catch (Exception ex)
@ -759,7 +1046,6 @@ namespace WCS.BLL.HardWare
Logs.Write($"入库保存数据异常，异常信息为{ex.Message}");
//报警灯报警
WarningLight.WaringLightBlueEnd(TcpCleint);
//WaringLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
}
}
#endregion
@ -822,7 +1108,6 @@ namespace WCS.BLL.HardWare
{
Logs.Write("协议处理5.4");
var exceptionMessage = storeInfo.StoreCode + "入库过程中存在物料未扫描上架！";
//WebSoceketManager.TrySendMessage("127.0.0.1", exceptionMessage);
var warningModel = new WebSocketMessageModel()
{
WarningType = WarningTypeEnum.入库中未扫描上架,
@ -954,47 +1239,21 @@ namespace WCS.BLL.HardWare
ExceptionMessages.Add($"{storeInfo.StoreCode}物料{storeInfo.CurrentMatSn}丢失,库存数据已删除，请重新扫码后入库");
#endregion
#region 【后台】丢失的数据处理
Task.Run(() =>
#region 不处理、WebSocket通知前台
var exceptionMessage = storeInfo.StoreCode + $"进入出库自检发现物料{storeInfo.CurrentMatSn}丢失，请确认是否删除？";
var warningModel = new WebSocketMessageModel()
{
try
{
DbHelp.db.BeginTran();
//库位表字段清空
storeInfo.CurrentMatSn = string.Empty;
DbHelp.db.Updateable(storeInfo).ExecuteCommand();
//库存表记录删除、插入出入记录
var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.StoreId == storeInfo.Id).First();
if (inventoryDetail != null)
{
var inOutRecord = new InOutRecord()
{
StoreCode = storeInfo.StoreCode,
StoreId = storeInfo.Id,
StoreInfo = storeInfo,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
MatBatch = inventoryDetail.MatBatch,
MatQty = inventoryDetail.MatQty,
MatSpec = inventoryDetail.MatSpec,
MatCustomer = inventoryDetail.MatCustomer,
MatSupplier = inventoryDetail.MatSupplier,
Direction = DirectionEnum.丢失,
};
DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
DbHelp.db.Deleteable(inventoryDetail).ExecuteCommand();
}
DbHelp.db.CommitTran();
}
catch (Exception e)
{
DbHelp.db.RollbackTran();
}
});
WarningType = WarningTypeEnum.出库自检丢失,
StoreId = storeInfo.Id,
StoreCode = storeInfo.StoreCode,
ModuleId = module.ModuleId,
ModuleCode = module.ModuleCode,
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1"
};
WarningManager.SendWarning(warningModel);
#endregion
WarningLight.WaringLightAlwaysRed(TcpCleint);
@ -1013,6 +1272,23 @@ namespace WCS.BLL.HardWare
#region 缓存记录异常信息
ExceptionMessages.Add($"库位{storeInfo.StoreCode}:存在物料未扫描上架");
#endregion
#region 不处理、WebSocket通知前台
var exceptionMessage = $"进入出库自检发现库位{storeInfo.StoreCode}存在物料未扫描上架，请拿下后点击【确认】消除报警";
var warningModel = new WebSocketMessageModel()
{
WarningType = WarningTypeEnum.出库自检未扫描上架,
StoreId = storeInfo.Id,
StoreCode = storeInfo.StoreCode,
ModuleId = module.ModuleId,
ModuleCode = module.ModuleCode,
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1"
};
WarningManager.SendWarning(warningModel);
#endregion
WarningLight.WaringLightAlwaysRed(TcpCleint);
}
else
@ -1029,7 +1305,6 @@ namespace WCS.BLL.HardWare
{
if (CurrentMode != Mode.出库模式)
{
//TO DO 未在出库模式 要报错
Logs.Write($"出库错误：{ShelfCode}该货架模式不是出库模式或盘点模式！");
return;
}
@ -1039,14 +1314,12 @@ namespace WCS.BLL.HardWare
.First();
if (storeInfo == null)
{
//TO DO 报错
return;
}
var module = this.Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module == null)
{
//TO DO 报错
return;
}
//当前库位未记录MatSn
@ -1076,12 +1349,14 @@ namespace WCS.BLL.HardWare
WarningLight.WaringLightAlwaysRed(TcpCleint);
return;
}
//获取对应的出库单明细
var orderOrderDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
//获取对应的出库单物料明细
var orderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == CurrentOutOrder.Id)
.Where(t => t.MatSN == inventoryDetail.MatSN)
.ToList();
if (orderOrderDetails == null || orderOrderDetails.Count == 0)
.First();
if (orderMatDetails == null)
{
Logs.Write($"{storeInfo.CurrentMatSn},OrderDetail出库明细信息不存在");
//报警灯报警
@ -1118,18 +1393,28 @@ namespace WCS.BLL.HardWare
//库位表 修改
storeInfo.CurrentMatSn = string.Empty;
//发料单明细表 更新为已出库
orderOrderDetails.ForEach(x =>
//发料单物料明细表 更新为已出库
orderMatDetails.IsSended = true;
//发料需求表增加数量
if (CurrentOutOrder.SyncType == SyncTypeEnum.ByMatCode)
{
x.IsSended = true;
});
//TO DO 发料需求表增加数量
//同步更新发料需求表已发数量
var outOrderDetail = DbHelp.db.Queryable<OutOrderDetail>()
.Where(t => t.Id == orderMatDetails.OutOrderDetailId)
.First();
if (outOrderDetail != null)
{
outOrderDetail.OutQty += orderMatDetails.MatQty;
DbHelp.db.Updateable(outOrderDetail).ExecuteCommand();
}
}
//保存数据
DbHelp.db.Deleteable(inventoryDetail).ExecuteCommand();
DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
DbHelp.db.Updateable(storeInfo).ExecuteCommand();
DbHelp.db.Updateable(orderOrderDetails).ExecuteCommand();
DbHelp.db.Updateable(orderMatDetails).ExecuteCommand();
DbHelp.db.CommitTran();
//报警灯同时亮绿灯并鸣叫一次提示。
@ -1154,104 +1439,115 @@ namespace WCS.BLL.HardWare
CurrentOutStoreMatSNs.RemoveAll(t => t == matSN);//删除本次已出的物料SN
var isExsistOut = CurrentOutStoreMatSNs.Any();
//本批次出库已完成
//本次亮灯的物料已全部取出
if (!isExsistOut)
{
//退出出库模式
GoOutOutstore();
WarningLight.CloseLight(TcpCleint);
var currentPickBillNumber = CurrentOutOrder.OrderNumber;
//OrderNumber = string.Empty;
//更新订单状态
UpdateOutOrderStatus(CurrentOutOrder);
CurrentOutOrder = null;
}
//看是否是分批次出库的情况 分批次亮灯
if (LocalFile.Config.IsSameMatCodeOut)
{
#region 触发下一批次的精准发料
//查一下是否是当前发料单最后一个货架（在出库模式 同一个发料单下）
var isLastShelf = ShelfManager.Shelves
.Where(t => t.OrderNumber == OrderNumber)
.Where(t => t.CurrentMode == Mode.出库模式)
.Any();
if (!isLastShelf)
//退出出库模式
var taskGoOut = Task.Run(() =>
{
Logs.Write($"发料单{OrderNumber}，最后一个出库货架，触发精准发料机制！查询是否还存在待出库物料");
var outOrder = DbHelp.db.Queryable<OutOrder>()
.Where(t => t.OrderNumber == OrderNumber)
.First();
if (outOrder != null)
GoOutOutstore();
});
//看是否是分批次出库的情况 分批次亮灯
Task.Run(async () =>
{
await Task.WhenAll(taskGoOut);
if (LocalFile.Config.IsSameMatCodeOut)
{
var outOrderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == outOrder.Id)
.Where(t => t.IsSended == false)
.Includes(t => t.StoreInfo)
.ToList();
if (outOrderMatDetails != null && outOrderMatDetails.Count > 0)
#region 触发下一批次的物料发料
//查一下是否是当前发料单最后一个货架（在出库模式 同一个发料单下）
var isLastShelf = ShelfManager.Shelves
.Where(t => t.OrderNumber == OrderNumber)
.Where(t => t.CurrentMode == Mode.出库模式)
.Any();
if (!isLastShelf)
{
//存在待出库 然后之前又没亮灯的情况 => 精准发料分批次亮灯
Logs.Write($"发料单{OrderNumber}，还有物料未出！");
var outOrderDetailCount = outOrderMatDetails.GroupBy(t => t.MatCode)
.Select(o => new { count = o.Count(), bb = o })
.Where(o => o.count >= 2)
.OrderByDescending(o => o.count)
.ToList();
//相同物料存在盘数超过2的情况，亮下一个盘数多的物料
if (outOrderDetailCount.Count > 0)
Logs.Write($"发料单{OrderNumber}，最后一个出库货架，触发精准发料机制！查询是否还存在待出库物料");
var outOrder = DbHelp.db.Queryable<OutOrder>()
.Where(t => t.OrderNumber == OrderNumber)
.First();
if (outOrder != null)
{
var matCode = outOrderDetailCount.First().bb.Key;
outOrderMatDetails = outOrderMatDetails.Where(t => t.MatCode == matCode)
.ToList();
Logs.Write($"发料单{OrderNumber}，本次亮灯物料{matCode}！");
var outOrderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == outOrder.Id)
.Where(t => t.IsSended == false)
.Includes(t => t.StoreInfo)
.ToList();
if (outOrderMatDetails != null && outOrderMatDetails.Count > 0)
{
//存在待出库 然后之前又没亮灯的情况 => 继续分批次亮灯
Logs.Write($"发料单{OrderNumber}，还有物料未出！");
var outOrderDetailCount = outOrderMatDetails.GroupBy(t => t.MatCode)
.Select(o => new { count = o.Count(), bb = o })
.Where(o => o.count >= 2)
.OrderByDescending(o => o.count)
.ToList();
//相同物料存在盘数超过2的情况，亮下一个盘数多的物料
if (outOrderDetailCount.Count > 0)
{
var matCode = outOrderDetailCount.First().bb.Key;
outOrderMatDetails = outOrderMatDetails.Where(t => t.MatCode == matCode)
.ToList();
Logs.Write($"发料单{OrderNumber}，本次亮灯物料{matCode}！");
}
//相同物料不存在盘数超过n的情况，剩余物料全部亮灯
else
{
//剩余物料全出
Logs.Write($"发料单{OrderNumber}，剩余物料灯全亮！");
}
var shelfIds = outOrderMatDetails.Select(t => t.StoreInfo.ShelfId)
.Distinct()
.ToList();
var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList();
var otherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).ToList();
if (otherModeShelfs != null && otherModeShelfs.Count > 0)
{
otherModeShelfs.ForEach(t =>
{
t.Reset();
});
Thread.Sleep(1000);
}
//对应的货架对应位置 进入出库模式 亮灯
shelfs.ForEach(shelf =>
{
var matDetails = outOrderMatDetails.Where(t => t.StoreInfo.ShelfCode == shelf.ShelfCode)
.Distinct()
.ToList();
shelf.GoInOutstore(matDetails, outOrder);
shelf.OrderNumber = outOrder.OrderNumber;
});
}
else
{
Logs.Write($"发料单{OrderNumber}，当前物料已发完！");
}
}
//相同物料不存在盘数超过n的情况，剩余物料全部亮灯
else
{
//剩余物料全出
Logs.Write($"发料单{OrderNumber}，剩余物料灯全亮！");
Logs.Write($"发料单{OrderNumber}，OutOrder为null，肯定是有问题");
}
var shelfIds = outOrderMatDetails.Select(t => t.StoreInfo.ShelfId)
.Distinct()
.ToList();
var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList(); ;
var otherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).ToList();
if (otherModeShelfs != null && otherModeShelfs.Count > 0)
{
otherModeShelfs.ForEach(t =>
{
t.Reset();
});
Thread.Sleep(1000);
}
//对应的货架对应位置 进入出库模式 亮灯
shelfs.ForEach(shelf =>
{
var matDetails = outOrderMatDetails.Where(t => t.StoreInfo.ShelfCode == shelf.ShelfCode)
.Distinct()
.ToList();
shelf.GoInOutstore(matDetails, outOrder);
shelf.OrderNumber = outOrder.OrderNumber;
});
}
else
{
Logs.Write($"发料单{OrderNumber}，当前物料已发完！");
}
#endregion
}
else
{
Logs.Write($"发料单{OrderNumber}，OutOrder为null，肯定是有问题");
}
}
#endregion
});
}
}
catch (Exception ex)
{
@ -1262,6 +1558,55 @@ namespace WCS.BLL.HardWare
#endregion
}
public void UpdateOutOrderStatus(OutOrder order)
{
//再去获取一遍Order
order = DbHelp.db.Queryable<OutOrder>()
.Where(t => t.Id == order.Id)
.First();
if (order != null)
{
#region 物料明细表是否已发完
var orderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == order.Id)
.ToList();
var isExistNoSendMat = orderMatDetails.Where(t => t.IsSended == false)
.Any();
if (isExistNoSendMat)
{
order.OrderStatus = OutOrderStatus.部分发料;
}
else
{
order.OrderStatus = OutOrderStatus.全部发料;
order.OutOrderExeStatus = OutOrderExeStatus.发料完成;
}
#endregion
#region 单据明细是否已满足发料需求
if (order.OrderStatus == OutOrderStatus.全部发料 &&
order.SyncType == SyncTypeEnum.ByMatCode)
{
var orderDetails = DbHelp.db.Queryable<OutOrderDetail>()
.Where(t => t.OrderId == order.Id)
.ToList();
var isExistNoSend = orderDetails.Where(t => t.ReqQty > t.OutQty).Any();
if (isExistNoSend)
{
order.OrderStatus = OutOrderStatus.部分发料;
}
else
{
order.OrderStatus = OutOrderStatus.全部发料;
}
}
#endregion
DbHelp.db.Updateable(order).ExecuteCommand();
}
}
/// <summary>
/// 退出出库模式返回信号处理
/// </summary>
@ -1385,6 +1730,37 @@ namespace WCS.BLL.HardWare
}
}
/// <summary>
/// 进入盘点模式返回信号
/// </summary>
/// <param name="data"></param>
/// <param name="boardId"></param>
/// <param name="lightNumber"></param>
public void GoInStockTakingReturnProcess(byte[] data, int boardId, int lightNumber)
{
var module = this.Modules.Where(t => t.BoardId == boardId).FirstOrDefault();
if (module == null)
{
return;
}
else
{
module.CurrentMode = Mode.盘点模式;
}
}
public void GoOutStockTakingReturnProcess(byte[] data, int boardId, int lightNumber)
{
var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.盘点模式).FirstOrDefault();
if (module == null)
{
return;
}
else
{
module.CurrentMode = Mode.待机模式;
}
}
public void ResetReturnProcess(byte[] data, int boardId, int lightNumber)
{
@ -1398,7 +1774,6 @@ namespace WCS.BLL.HardWare
module.CurrentMode = Mode.待机模式;
}
}
#endregion
}

153
WCS.BLL/HardWare/SmartShelfModule.cs
View File

@ -40,12 +40,32 @@ namespace WCS.BLL.HardWare
/// </summary>
public byte[] GoInOutstoreModeData = { 0x05, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00 };
/// <summary>
/// 确认出库信号
/// </summary>
public byte[] ComfirmOutstoreData = { 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 退出出库模式
/// </summary>
public byte[] GoOutOutstoreModeData = { 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 进入盘点模式
/// 04代表颜色为蓝色色
/// </summary>
public byte[] GoInStockTakingModeData = { 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00 };
/// <summary>
/// 确认盘点
/// 03代表颜色为黄色
/// </summary>
public byte[] ConfirmStockTakingData = { 0x09, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00 };
/// <summary>
/// 退出盘点模式
/// </summary>
public byte[] GoOutStockTakingModeData = { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 复位命令
/// </summary>
@ -58,6 +78,7 @@ namespace WCS.BLL.HardWare
public Mode CurrentMode { get; set; }
public List<string> CurrentOutSns { get; set; }
public List<string> CurrentStockTakingSns { get; set; }
public void SetCurrentMode()
{
@ -204,13 +225,11 @@ namespace WCS.BLL.HardWare
}
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoInOutstoreModeData));
}
public void ComfirmOutstore(TCPClient tcpClient, byte lightNumber)
{
ComfirmOutstoreData[1] = lightNumber;
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ComfirmOutstoreData));
}
/// <summary>
/// 退出出库模式
/// </summary>
@ -219,5 +238,135 @@ namespace WCS.BLL.HardWare
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoOutOutstoreModeData));
}
/// <summary>
/// 未盘点的物料进入盘点模式、亮灯
/// </summary>
/// <param name="tcpClient"></param>
public void GoInStockTakingMode(TCPClient tcpClient, List<string> stockTakingSns)
{
CurrentStockTakingSns = stockTakingSns;
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
//计算物料在库的库位
char[] data = "0000000000000000".ToCharArray();
var storeNumber = storeInfos.Count();
char[] outData = "0000000000000000".ToCharArray();
//盘点位置亮灯
if (stockTakingSns != null && stockTakingSns.Count > 0)
{
var outStoreInfos = storeInfos.Where(t => stockTakingSns.Contains(t.CurrentMatSn))
.ToList();
foreach (var storeInfo in outStoreInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= storeNumber)
{
outData[storeInfo.LightNumber - 1] = '1';
}
}
}
var outDataStr = string.Join("", outData.Reverse());
var data3 = outDataStr.Substring(8, 8);
var data4 = outDataStr.Substring(0, 8);
GoInStockTakingModeData[2] = Convert.ToByte(data3, 2);
GoInStockTakingModeData[3] = Convert.ToByte(data4, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoInStockTakingModeData));
}
/// <summary>
/// 已确认过的物料
/// </summary>
/// <param name="tcpClient"></param>
public void ConfirmStockTaking(TCPClient tcpClient, List<string> stockTakingSns)
{
CurrentStockTakingSns = stockTakingSns;
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
//计算物料在库的库位
char[] data = "0000000000000000".ToCharArray();
var storeNumber = storeInfos.Count();
char[] outData = "0000000000000000".ToCharArray();
//盘点位置亮灯
if (stockTakingSns != null && stockTakingSns.Count > 0)
{
var outStoreInfos = storeInfos.Where(t => stockTakingSns.Contains(t.CurrentMatSn))
.ToList();
foreach (var storeInfo in outStoreInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= storeNumber)
{
outData[storeInfo.LightNumber - 1] = '1';
}
}
}
var outDataStr = string.Join("", outData.Reverse());
var data3 = outDataStr.Substring(8, 8);
var data4 = outDataStr.Substring(0, 8);
ConfirmStockTakingData[2] = Convert.ToByte(data3, 2);
ConfirmStockTakingData[3] = Convert.ToByte(data4, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ConfirmStockTakingData));
}
/// <summary>
/// 单个确认物料
/// </summary>
/// <param name="tcpClient"></param>
public void ConfirmStockTakingSingle(TCPClient tcpClient, int lightNumber)
{
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
//计算物料在库的库位
char[] data = "0000000000000000".ToCharArray();
var storeNumber = storeInfos.Count();
//盘点位置亮灯
var outStoreInfos = storeInfos.Where(t => t.LightNumber == lightNumber)
.ToList();
char[] outData = "0000000000000000".ToCharArray();
foreach (var storeInfo in outStoreInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= storeNumber)
{
outData[storeInfo.LightNumber - 1] = '1';
}
}
var outDataStr = string.Join("", outData.Reverse());
var data3 = outDataStr.Substring(8, 8);
var data4 = outDataStr.Substring(0, 8);
ConfirmStockTakingData[2] = Convert.ToByte(data3, 2);
ConfirmStockTakingData[3] = Convert.ToByte(data4, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ConfirmStockTakingData));
}
/// <summary>
/// 退出盘点模式
/// </summary>
/// <param name="tcpClient"></param>
public void GoOutStockTakingMode(TCPClient tcpClient)
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoOutStockTakingModeData));
}
public void ComfirmStockTaking(TCPClient tcpClient, byte lightNumber)
{
ComfirmOutstoreData[1] = lightNumber;
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ComfirmOutstoreData));
}
}
}

5
WCS.BLL/Manager/WarningManager.cs
View File

@ -9,6 +9,7 @@ using WCS.BLL.DbModels;
using WCS.BLL.HardWare;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.WebSocketModel;
namespace WCS.BLL.Manager
@ -71,8 +72,8 @@ namespace WCS.BLL.Manager
case WarningTypeEnum.入库自检丢失:
SolveLoss(warningInManager);
break;
case WarningTypeEnum.入库自检未扫描上架:
SolveNoScan(warningInManager);
case WarningTypeEnum.出库自检丢失:
SolveLoss(warningInManager);
break;
}
}

2
WCS.BLL/Services/IService/IGenerateService.cs
View File

@ -13,5 +13,7 @@ namespace WCS.BLL.Services.IService
public Task<ResponseCommon<List<MatInfo>>> generateMatInfo(GenerateMatInfoRequest request);
public Task<string> generateStockTakingNumber();
public Task<string> generateOutOrderNumber();
}
}

19
WCS.BLL/Services/IService/IInOutRecordService.cs Normal file
View File

@ -0,0 +1,19 @@

using WCS.BLL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.ApiModel.MatInventoryDetail;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.IService
{
public interface IInOutRecordService
{
public Task<PageQueryResponse<InOutRecord>> getInOutRecord(GetInOutRecordRequest request);
public Task<PageQueryResponse<InOutRecord>> exportInOutRecord(GetInOutRecordRequest request);
}
}

2
WCS.BLL/Services/IService/IStockTakingService.cs
View File

@ -18,6 +18,8 @@ namespace WCS.BLL.Services.IService
public Task<PageQueryResponse<StockTakingOrder>> getStockTakingOrders(GetStockTakingOrdersRequest request);
public Task<PageQueryResponse<StockTakingOrder>> getStockTakingOrdersByStatus(GetStockTakingOrdersRequest request);
public Task<ResponseBase> getStockTakingOrderMatDetail(GetStockTakingOrderMatDetailRequest request);
public Task<ResponseBase> startStockTakingOrder(GetStockTakingOrderMatDetailRequest request);

9
WCS.BLL/Services/Service/GenerateService.cs
View File

@ -124,5 +124,14 @@ namespace WCS.BLL.Services.Service
return "PD" + DateTime.Now.ToString("yyMMddHHmmssfff");
}
}
public async Task<string> generateOutOrderNumber()
{
lock (stockTakingFlag)
{
Thread.Sleep(1);
return "CK" + DateTime.Now.ToString("yyMMddHHmmssfff");
}
}
}
}

126
WCS.BLL/Services/Service/InOutRecordService.cs Normal file
View File

@ -0,0 +1,126 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.DbModels;
using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.Model;
using WCS.BLL.DbModels;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.ApiModel.MatInventoryDetail;
using WCS.Model.ApiModel.User;
using WCS.DAL.DbModels;
namespace WCS.BLL.Services.Service
{
public class InOutRecordService : IInOutRecordService
{
public async Task<PageQueryResponse<InOutRecord>> getInOutRecord(GetInOutRecordRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<InOutRecord>()
.LeftJoin<StoreInfo>((id, si) => id.StoreId == si.Id)
.WhereIF(!string.IsNullOrEmpty(request.MatSN), (id, si) => id.MatSN.Contains(request.MatSN))
.WhereIF(!string.IsNullOrEmpty(request.MatCode), (id, si) => id.MatCode.Contains(request.MatCode))
.WhereIF(!string.IsNullOrEmpty(request.MatName), (id, si) => id.MatName.Contains(request.MatName))
.WhereIF(!string.IsNullOrEmpty(request.MatBatch), (id, si) => id.MatBatch.Contains(request.MatBatch))
.WhereIF(!string.IsNullOrEmpty(request.MatSpec), (id, si) => id.MatSpec.Contains(request.MatSpec))
.WhereIF(!string.IsNullOrEmpty(request.MatSupplier), (id, si) => id.MatSpec.Contains(request.MatSupplier))
.WhereIF(!string.IsNullOrEmpty(request.MatCustomer), (id, si) => id.MatSpec.Contains(request.MatCustomer))
.WhereIF(request.StoreId != 0, (id, si) => id.StoreId == request.StoreId)
.WhereIF(!string.IsNullOrEmpty(request.StoreCode), (id, si) => id.StoreCode.Contains(request.StoreCode))
;
var totalCount = await recordsQueryable.CountAsync();
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.Select<InOutRecord>()
.ToListAsync();
//生成序号
for (int i = 0; i < records.Count; i++)
{
records[i].RowNumber = (request.PageNumber - 1) * 10 + i + 1;
}
return new PageQueryResponse<InOutRecord>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<InOutRecord>()
{
TotalCount = totalCount,
MaxPage = request.PageSize == 0 ? 0 : (int)Math.Ceiling((decimal)totalCount / request.PageSize),
Count = records.Count,
Lists = records.ToList()
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<InOutRecord>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<PageQueryResponse<InOutRecord>> exportInOutRecord(GetInOutRecordRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<InOutRecord>()
.LeftJoin<StoreInfo>((id, si) => id.StoreId == si.Id)
.WhereIF(!string.IsNullOrEmpty(request.MatSN), (id, si) => id.MatSN.Contains(request.MatSN))
.WhereIF(!string.IsNullOrEmpty(request.MatCode), (id, si) => id.MatCode.Contains(request.MatCode))
.WhereIF(!string.IsNullOrEmpty(request.MatName), (id, si) => id.MatName.Contains(request.MatName))
.WhereIF(!string.IsNullOrEmpty(request.MatBatch), (id, si) => id.MatBatch.Contains(request.MatBatch))
.WhereIF(!string.IsNullOrEmpty(request.MatSpec), (id, si) => id.MatSpec.Contains(request.MatSpec))
.WhereIF(!string.IsNullOrEmpty(request.MatSupplier), (id, si) => id.MatSpec.Contains(request.MatSupplier))
.WhereIF(!string.IsNullOrEmpty(request.MatCustomer), (id, si) => id.MatSpec.Contains(request.MatCustomer))
.WhereIF(request.StoreId != 0, (id, si) => id.StoreId == request.StoreId)
.WhereIF(!string.IsNullOrEmpty(request.StoreCode), (id, si) => id.StoreCode.Contains(request.StoreCode))
;
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.Select<InOutRecord>()
.ToListAsync();
//生成序号
var index = 1;
records.ForEach(r =>
{
r.RowNumber = index++;
});
return new PageQueryResponse<InOutRecord>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<InOutRecord>()
{
Lists = records
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<InOutRecord>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
}
}

10
WCS.BLL/Services/Service/InstoreService.cs
View File

@ -153,7 +153,7 @@ namespace WCS.BLL.Services.Service
}
#region 获取物料数据 //调用接口或者直接查询数据库
//TODO做成配置 调用接口
if (1 == 1)
if (1 != 1)
{
#region 调用Mes接口获取物料信息
try
@ -169,10 +169,10 @@ namespace WCS.BLL.Services.Service
Data = new List<queryByBarResponse>() {new queryByBarResponse()
{
materialBar = request.MatSn,
materialCode = "111222",
materialCode = "100200300",
materialName = "电阻",
materialQty = 1000,
}
}
}
};
//查询到物料信息
@ -341,6 +341,10 @@ namespace WCS.BLL.Services.Service
{
Code = 201,
Message = $"超时未入库！请重新扫码后入库！",
Data = new
{
StoreCode = string.Empty,
}
};
}
}

86
WCS.BLL/Services/Service/OutstoreService.cs
View File

@ -33,12 +33,6 @@ namespace WCS.BLL.Services.Service
Message = "单据同步失败：缺少需要出库的物料类型！"
};
}
//判断是否有单据号 没有单据号系统自动生成一个
if (string.IsNullOrEmpty(request.OrderNumber))
{
request.OrderNumber = GenerateOrderNumber();
}
Console.WriteLine(DateTime.Now);
//保存数据
await DbHelp.db.BeginTranAsync();
try
@ -132,12 +126,6 @@ namespace WCS.BLL.Services.Service
};
}
//判断是否有单据号 没有单据号系统自动生成一个
if (string.IsNullOrEmpty(request.OrderNumber))
{
request.OrderNumber = GenerateOrderNumber();
}
#region 保存数据
//锁库存
@ -205,7 +193,6 @@ namespace WCS.BLL.Services.Service
}
public async Task<ResponseBase> GetOutOrderList(GetOutOrderListRequest request)
{
//直接查询
@ -254,7 +241,7 @@ namespace WCS.BLL.Services.Service
};
}
//直接查询
var recordsQueryable = DbHelp.db.Queryable<OutOrder>();
var recordsQueryable = DbHelp.db.Queryable<OutOrder>().Where(t => request.OrderExeStatus.Contains(t.OutOrderExeStatus));
var totalCount = await recordsQueryable.CountAsync();
var records = await recordsQueryable
@ -396,12 +383,6 @@ namespace WCS.BLL.Services.Service
};
}
private string GenerateOrderNumber()
{
var orderNumber = "PD" + DateTime.Now.ToString("yyyyMMddHHmmss");
return orderNumber;
}
public async Task<ResponseBase> GoInOutstore(GetOutOrderDetailRequest request)
{
try
@ -421,6 +402,7 @@ namespace WCS.BLL.Services.Service
};
}
//如果是按物料编码出库 需要计算物料明细、并进行物料锁定
if (order.SyncType == SyncTypeEnum.ByMatCode)
{
@ -442,10 +424,17 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"出库单据{request.OrderNumber}物料已全部出库！",
Message = $"出库单据{request.OrderNumber}物料已全部完成出库！",
Data = null
};
}
if (request.IsStart)//&& order.OutOrderExeStatus != OutOrderExeStatus.发料完成
{
order.OutOrderExeStatus = OutOrderExeStatus.开始发料;
DbHelp.db.Updateable(order).ExecuteCommand();
}
//按货架分组 按物料找到对应的货架
var shelfIds = outOrderMatDetails.Select(t => t.StoreInfo.ShelfId)
.Distinct()
@ -488,14 +477,13 @@ namespace WCS.BLL.Services.Service
//对应的货架对应位置 进入出库模式 亮灯
shelfs.ForEach(shelf =>
{
var matDetails = outOrderMatDetails.Where(t => t.StoreInfo.ShelfCode == shelf.ShelfCode)
.Distinct()
.ToList();
shelf.GoInOutstore(matDetails, order);
shelf.OrderNumber = order.OrderNumber;
});
{
var matDetails = outOrderMatDetails.Where(t => t.StoreInfo.ShelfCode == shelf.ShelfCode)
.Distinct()
.ToList();
shelf.GoInOutstore(matDetails, order);
shelf.OrderNumber = order.OrderNumber;
});
//返回
return new ResponseCommon()
@ -507,11 +495,11 @@ namespace WCS.BLL.Services.Service
}
catch (Exception ex)
{
await GoInOutstore(request);
await GoOutOutstore(request);
throw ex;
}
}
//计算、加锁
private ResponseBase CaculateOutOrderMatDetails(OutOrder order)
{
try
@ -546,7 +534,7 @@ namespace WCS.BLL.Services.Service
List<OutOrderMatDetail> outOrderMatDetails = new List<OutOrderMatDetail>();
foreach (var outOrderDetail in outOrderDetails)
{
//2.1筛选 满足 图号 批次的库存
//2.1筛选 满足 物料编码、批次的库存
var matInventoryDetails = DbHelp.db.Queryable<InventoryDetail>()
.Where(t => t.MatCode == outOrderDetail.MatCode)
.WhereIF(!string.IsNullOrEmpty(outOrderDetail.MatBatch), t => t.MatBatch == outOrderDetail.MatBatch)
@ -561,8 +549,8 @@ namespace WCS.BLL.Services.Service
{
outOrderMatDetails.Add(new OutOrderMatDetail()
{
OrderId = outOrderDetail.Id,
OrderNumber = outOrderDetail.OrderNumber,
OrderId = order.Id,
OrderNumber = order.OrderNumber,
OutOrderDetailId = outOrderDetail.Id,
InventoryDetailId = matInventoryDetails[i].Id,
StoreId = matInventoryDetails[i].StoreId,
@ -589,8 +577,8 @@ namespace WCS.BLL.Services.Service
outOrderMatDetails.Add(new OutOrderMatDetail()
{
OrderId = outOrderDetail.Id,
OrderNumber = outOrderDetail.OrderNumber,
OrderId = order.Id,
OrderNumber = order.OrderNumber,
OutOrderDetailId = outOrderDetail.Id,
InventoryDetailId = matInventoryDetails[i].Id,
StoreId = matInventoryDetails[i].StoreId,
@ -631,6 +619,7 @@ namespace WCS.BLL.Services.Service
}
}
//解锁
private ResponseBase CancelOutOrderMatDetails(OutOrder order)
{
try
@ -638,7 +627,9 @@ namespace WCS.BLL.Services.Service
DbHelp.db.BeginTran();
var outOrderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == order.Id)
.Where(t => t.IsSended == false)
.ToList();
var inventoryIds = outOrderMatDetails.Select(t => t.Id).ToList();
var inventoryDetails = DbHelp.db.Queryable<InventoryDetail>()
.Where(t => inventoryIds.Contains(t.Id))
@ -646,6 +637,7 @@ namespace WCS.BLL.Services.Service
inventoryDetails.ForEach(t => { t.IsLocked = false; });
DbHelp.db.Deleteable(outOrderMatDetails).ExecuteCommand();
DbHelp.db.Updateable(inventoryDetails).ExecuteCommand();
DbHelp.db.CommitTran();
return new ResponseCommon()
{
@ -666,6 +658,7 @@ namespace WCS.BLL.Services.Service
public async Task<ResponseBase> GoOutOutstore(GetOutOrderDetailRequest request)
{
//获取出库单
var order = await DbHelp.db.Queryable<OutOrder>()
.WhereIF(request.OrderId != 0, t => t.Id == request.OrderId)
@ -681,10 +674,28 @@ namespace WCS.BLL.Services.Service
};
}
//执行状态改为暂停
if (request.IsPause && order.OutOrderExeStatus != OutOrderExeStatus.发料完成)
{
order.OutOrderExeStatus = OutOrderExeStatus.暂停发料;
DbHelp.db.Updateable(order).ExecuteCommand();
}
//找到正在出对应出库单的货架
var shelves = ShelfManager.Shelves.Where(t => t.OrderNumber == request.OrderNumber)
.Where(t => t.CurrentMode == HardWare.Mode.出库模式)
.ToList();
if (shelves == null || shelves.Count == 0)
{
return new ResponseCommon()
{
Code = 201,
Message = $"单据【{request.OrderNumber}】不在出库中！",
Data = null
};
}
//退出出库模式
shelves.ForEach(t =>
{
@ -695,12 +706,15 @@ namespace WCS.BLL.Services.Service
if (order.SyncType == SyncTypeEnum.ByMatCode)
CancelOutOrderMatDetails(order);
return new ResponseCommon()
{
Code = 200,
Message = "Success",
Data = null
};
}
}
}

345
WCS.BLL/Services/Service/StockTakingService.cs
View File

@ -10,6 +10,7 @@ using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.ApiModel.Stocktaking;
namespace WCS.BLL.Services.Service
@ -114,6 +115,7 @@ namespace WCS.BLL.Services.Service
StoreId = inventoryDetail.StoreId,
StoreCode = inventoryDetail.StoreCode,
InventoryDetailId = inventoryDetail.Id,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
@ -193,6 +195,7 @@ namespace WCS.BLL.Services.Service
StoreId = inventoryDetail.StoreId,
StoreCode = inventoryDetail.StoreCode,
InventoryDetailId = inventoryDetail.Id,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
@ -272,6 +275,7 @@ namespace WCS.BLL.Services.Service
StoreId = inventoryDetail.StoreId,
StoreCode = inventoryDetail.StoreCode,
InventoryDetailId = inventoryDetail.Id,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
@ -313,7 +317,7 @@ namespace WCS.BLL.Services.Service
var recordsQueryable = DbHelp.db.Queryable<StockTakingOrder>()
.WhereIF(!string.IsNullOrEmpty(request.StocktakingOrderNumber), t => t.StocktakingOrderNumber.Contains(request.StocktakingOrderNumber))
.WhereIF(!string.IsNullOrEmpty(request.StocktakingOrderSource), t => t.StocktakingOrderSource!=null && t.StocktakingOrderSource.Contains(request.StocktakingOrderSource));
.WhereIF(!string.IsNullOrEmpty(request.StocktakingOrderSource), t => t.StocktakingOrderSource != null && t.StocktakingOrderSource.Contains(request.StocktakingOrderSource));
switch (request.StocktakingOrderStatus)
{
@ -368,6 +372,55 @@ namespace WCS.BLL.Services.Service
}
}
public async Task<PageQueryResponse<StockTakingOrder>> getStockTakingOrdersByStatus(GetStockTakingOrdersRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<StockTakingOrder>();
switch (request.StocktakingOrderStatus)
{
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.未盘点:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.未盘点);
break;
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.部分盘点:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.部分盘点);
break;
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.已提交:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.已提交);
break;
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.盘点完成:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == StocktakingOrderStatus.盘点完成);
break;
default:
break;
}
var records = await recordsQueryable
.OrderByDescending(t => t.CreateTime)
.Take(40)
.ToListAsync();
return new PageQueryResponse<StockTakingOrder>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<StockTakingOrder>()
{
Lists = records.ToList()
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<StockTakingOrder>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<ResponseBase> getStockTakingOrderMatDetail(GetStockTakingOrderMatDetailRequest request)
{
#region 查询盘点单
@ -380,7 +433,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：不存在Id为{request.StockTakingOrderId}的出库单！",
Message = $"查询失败：不存在Id为{request.StockTakingOrderId}的盘点单！",
};
}
}
@ -393,7 +446,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
Message = $"查询失败：不存在单据号为{request.StockTakingOrderNumber}的盘点单！",
};
}
}
@ -411,7 +464,11 @@ namespace WCS.BLL.Services.Service
var stockTakingOrderMatDetail = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.StocktakingOrderId == order.Id)
.ToListAsync();
//生成序号
for (int i = 0; i < stockTakingOrderMatDetail.Count; i++)
{
stockTakingOrderMatDetail[i].RowNumber = i + 1;
}
return new ResponseCommon<List<StockTakingOrderMatDetail>>()
{
Code = 200,
@ -434,7 +491,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的盘点单！",
};
}
}
@ -447,7 +504,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的盘点单！",
};
}
}
@ -461,26 +518,62 @@ namespace WCS.BLL.Services.Service
}
#endregion
#region 查询物料明细
#region 查询需要盘点的物料明细
//查询物料明细
var stockTakingOrderMatDetail = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
var stockTakingOrderMatDetails = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.StocktakingOrderId == order.Id)
//.Where(t => t.IsStocktaking == false)
.Includes(t => t.StoreInfo)
.ToListAsync();
//TO DO 货架按物料进入盘点模式
var shelf = ShelfManager.Shelves.First();
shelf.GoInStocktaking();
shelf.OrderNumber = order.StocktakingOrderNumber;
if (stockTakingOrderMatDetails == null || stockTakingOrderMatDetails.Count == 0)
{
return new ResponseCommon()
{
Code = 201,
Message = $"盘点单据{order.StocktakingOrderNumber}物料已全部盘点！",
Data = null
};
}
#endregion
#region 按货架进入盘点模式
var shelfIds = stockTakingOrderMatDetails.Select(t => t.StoreInfo.ShelfId)
.Distinct()
.ToList();
var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList(); ;
var outherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).Select(t => t.ShelfCode).ToList();
if (outherModeShelfs != null && outherModeShelfs.Count > 0)
{
return new ResponseCommon()
{
Code = 201,
Message = $"进入盘点模式失败：货架{string.Join("", outherModeShelfs)}不在待机模式",
Data = null
};
}
//对应的货架对应位置 进入盘点模式 亮灯
shelfs.ForEach(shelf =>
{
var matDetails = stockTakingOrderMatDetails.Where(t => t.StoreInfo.ShelfCode == shelf.ShelfCode)
.Distinct()
.ToList();
shelf.GoInStocktaking(matDetails, order);
shelf.OrderNumber = order.StocktakingOrderNumber;
});
//返回
return new ResponseCommon()
{
Code = 200,
Message = $"success",
Data = shelf.ShelfCode
Message = "Success",
Data = null
};
#endregion
}
catch (Exception ex)
{
await endStockTakingOrder(request);
return new ResponseCommon()
{
Code = 300,
@ -503,7 +596,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的盘点单！",
};
}
}
@ -516,7 +609,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的盘点单！",
};
}
}
@ -530,7 +623,7 @@ namespace WCS.BLL.Services.Service
}
#endregion
#region 查询当前盘点盘已启动的货架
#region 查询当前盘点单 已启动的货架
var shelfs = ShelfManager.Shelves.Where(t => t.CurrentMode == HardWare.Mode.盘点模式 && t.OrderNumber == order.StocktakingOrderNumber).ToList();
shelfs.ForEach(t =>
{
@ -556,32 +649,43 @@ namespace WCS.BLL.Services.Service
}
public async Task<ResponseBase> queryMatInfoInStocktakingOrder(QueryMatInfoInStocktakingOrderRequest request)
{
//判断是否有这个物料
var storeInfo = await DbHelp.db.Queryable<InventoryDetail>()
.LeftJoin<StoreInfo>((id,si)=>id.StoreId == si.Id)
{
//判断库存中是否有这个物料
var inventoryDetail = await DbHelp.db.Queryable<InventoryDetail>()
.LeftJoin<StoreInfo>((id, si) => id.StoreId == si.Id)
.Where((id, si) => id.MatSN == request.MatSN)
.Select((id, si) => si)
.FirstAsync();
if (storeInfo == null)
if (inventoryDetail == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"不存在物料[{request.MatSN}]",
Message = $"库存中不存在物料[{request.MatSN}]",
};
}
//判断货架是否进入入库模式
var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == storeInfo.ShelfCode).FirstOrDefault();
//判断货架是否已进入盘点模式
var shelf = ShelfManager.Shelves
.Where(t => t.ShelfCode == inventoryDetail.ShelfCode)
.FirstOrDefault(); ;
if (shelf == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"物料[{request.MatSN}不是本次需要盘点的物料！！！]",
Message = $"货架{inventoryDetail.ShelfCode}不存在！",
};
}
//进入入库模式的那个单据是否有对应的单据明细
else if (shelf.CurrentMode != HardWare.Mode.盘点模式)
{
return new ResponseCommon()
{
Code = 201,
Message = $"货架{inventoryDetail.ShelfCode}不在盘点模式！",
};
}
var stockTakingOrder = await DbHelp.db.Queryable<StockTakingOrder>()
.Where(t => t.StocktakingOrderNumber == shelf.OrderNumber)
.FirstAsync();
@ -599,38 +703,89 @@ namespace WCS.BLL.Services.Service
.Where(t => t.MatSN == request.MatSN)
.FirstAsync();
return new ResponseCommon<StockTakingOrderMatDetail>()
{
{
Code = 200,
Message = "success",
Data = stockTakinbgOrder
};
}
public async Task<ResponseBase> confirmStocktakingOrder(ConfirmStocktakingOrderRequest request)
{
//获取盘点物料明细
var stockTakingMatDetail =await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.Id == request.Id)
.FirstAsync();
if (stockTakingMatDetail == null)
try
{
//获取盘点物料明细
var stockTakingMatDetail = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.Id == request.Id)
.Includes(t => t.StoreInfo)
.FirstAsync();
if (stockTakingMatDetail == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"不存在的盘点明细",
};
}
DbHelp.db.BeginTran();
//修改盘点物料明细的数量
stockTakingMatDetail.StocktakingQty = request.Qty;
stockTakingMatDetail.IsStocktaking = true;
DbHelp.db.Updateable(stockTakingMatDetail)
.ExecuteCommand();
#region 发送指令 对应货架对应模组确认盘点
//判断货架是否已进入盘点模式
var shelf = ShelfManager.Shelves
.Where(t => t.ShelfCode == stockTakingMatDetail.StoreInfo.ShelfCode)
.FirstOrDefault(); ;
if (shelf == null)
{
DbHelp.db.RollbackTran();
return new ResponseCommon()
{
Code = 201,
Message = $"货架{stockTakingMatDetail.StoreInfo.ShelfCode}不存在！",
};
}
else if (shelf.CurrentMode != HardWare.Mode.盘点模式)
{
DbHelp.db.RollbackTran();
return new ResponseCommon()
{
Code = 201,
Message = $"货架{stockTakingMatDetail.StoreInfo.ShelfCode}不在盘点模式！",
};
}
if (shelf.OrderNumber != request.StocktakingOrderNumber)
{
return new ResponseCommon()
{
Code = 201,
Message = $"盘点单据{request.StocktakingOrderNumber}不在盘点模式！",
};
}
shelf.ConfirmStocktakingSingle(stockTakingMatDetail.StoreInfo.BoardId, stockTakingMatDetail.StoreInfo.LightNumber);
#endregion
DbHelp.db.CommitTran();
return new ResponseCommon()
{
Code = 200,
Message = $"success",
};
}
catch (Exception ex)
{
DbHelp.db.RollbackTran();
return new ResponseCommon()
{
Code = 201,
Message = $"不存在的盘点明细",
Message = $"确认盘点失败：{ex.Message}",
};
}
//修改盘点吗明细数量
stockTakingMatDetail.StocktakingQty = request.Qty;
stockTakingMatDetail.IsStocktaking = true;
await DbHelp.db.Updateable(stockTakingMatDetail).ExecuteCommandAsync();
return new ResponseCommon()
{
Code = 200,
Message = $"success",
};
}
public async Task<ResponseBase> commitStockTakingOrder(GetStockTakingOrderMatDetailRequest request)
@ -647,7 +802,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的盘点单！",
};
}
}
@ -660,7 +815,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的盘点单！",
};
}
}
@ -675,7 +830,7 @@ namespace WCS.BLL.Services.Service
#endregion
#region 判断单据状态
if (order.StocktakingOrderStatus != StocktakingOrderStatus.已提交)
if (order.StocktakingOrderStatus == StocktakingOrderStatus.已提交)
{
return new ResponseCommon()
{
@ -683,16 +838,102 @@ namespace WCS.BLL.Services.Service
Message = $"单据已提交，请勿重复提交！",
};
}
else if (order.StocktakingOrderStatus != StocktakingOrderStatus.盘点完成)
//else if (order.StocktakingOrderStatus != StocktakingOrderStatus.盘点完成)
//{
// return new ResponseCommon()
// {
// Code = 201,
// Message = $"单据未盘点完成！！！",
// };
//}
#endregion
#region 查询盘点明细
var stockTakingOrderMatDetails = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.StocktakingOrderId == order.Id && t.IsStocktaking)
.ToListAsync();
if (stockTakingOrderMatDetails == null || stockTakingOrderMatDetails.Count == 0)
{
return new ResponseCommon()
{
Code = 201,
Message = $"单据未盘点完成！！！",
Message = $"不存在已盘点的物料！",
};
}
#endregion
#region 提交盘点 修改数量 生成记录
try
{
DbHelp.db.BeginTran();
var inventoryDetailIds = stockTakingOrderMatDetails.Select(t => t.InventoryDetailId)
.ToList();
//查询对应的库存数据
var inventoryDetails = DbHelp.db.Queryable<InventoryDetail>()
.Where(t => inventoryDetailIds.Contains(t.Id))
.ToList();
inventoryDetails.ForEach(inventoryDetail =>
{
//对应的盘点明细
var stockTakingOrderMatDetail = stockTakingOrderMatDetails.Where(t => t.InventoryDetailId == inventoryDetail.Id).FirstOrDefault();
if (stockTakingOrderMatDetail == null)
{
//这个分支应该是不用管的哦
}
else
{
//比对数量变化
var changedQty = stockTakingOrderMatDetail.StocktakingQty - inventoryDetail.MatQty;
if (changedQty != 0)
{
//库存表修改数量
inventoryDetail.MatQty = stockTakingOrderMatDetail.StocktakingQty;
//出入库记录表生成记录
var inOutRecord = new InOutRecord()
{
StoreCode = inventoryDetail.StoreCode,
StoreId = inventoryDetail.StoreId,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
MatBatch = inventoryDetail.MatBatch,
MatQty = changedQty,
MatSpec = inventoryDetail.MatSpec,
MatCustomer = inventoryDetail.MatCustomer,
MatSupplier = inventoryDetail.MatSupplier,
Direction = DirectionEnum.盘点,
OperateUser = request.UserName
};
DbHelp.db.Updateable(inventoryDetail).ExecuteCommand();
DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
}
//数量相等的情况 暂时不用管 不动库存数据也不生成记录
else
{
}
}
});
order.StocktakingOrderStatus = StocktakingOrderStatus.已提交;
DbHelp.db.Updateable(order).ExecuteCommand();
DbHelp.db.CommitTran();
}
catch (Exception ex)
{
DbHelp.db.RollbackTran();
return new ResponseCommon()
{
Code = 300,
Message = $"操作失败，{ex.Message}",
};
}
#endregion
//To do 进行提交！
return new ResponseCommon()
{
@ -709,5 +950,7 @@ namespace WCS.BLL.Services.Service
};
}
}
}
}