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-04-19 08:47:45 +08:00
parent e89b64ea3a
commit d40c3f253a
46 changed files with 2500 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
WCS.BLL/Services/IService/IGenerateService.cs Normal file
View File

@ -0,0 +1,18 @@

using WCS.BLL.DbModels;
using WCS.DAL.AuthDbModel;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.MatBaseInfo;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.IService
{
public interface IGenerateService
{
public Task<ResponseCommon<List<MatInfo>>> generateMatInfo(GenerateMatInfoRequest request);
public Task<string> generateStockTakingNumber();
}
}

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

@ -11,7 +11,7 @@ namespace WCS.BLL.Services.IService
{
public ResponseBase shelfGoInInStore(ShelfGoInInstoreRequest request);
public ResponseBase shelfGoOutInStore(ShelfGoOutInStoreRequest request);
public ResponseBase queryByMatSn(QueryByMatSnRequest request);
public Task<ResponseBase> queryByMatSn(QueryByMatSnRequest request);
public Task<ResponseBase> queryInstoreStatus(QueryByMatSnRequest request);
}
}

34
WCS.BLL/Services/IService/IStockTakingService.cs Normal file
View File

@ -0,0 +1,34 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.BLL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.Stocktaking;
namespace WCS.BLL.Services.IService
{
/// <summary>
/// 盘点模式
/// </summary>
public interface IStockTakingService
{
public Task<ResponseBase> SysStockTakingOrder(SysStockTakingOrderRequest request);
public Task<PageQueryResponse<StockTakingOrder>> getStockTakingOrders(GetStockTakingOrdersRequest request);
public Task<ResponseBase> getStockTakingOrderMatDetail(GetStockTakingOrderMatDetailRequest request);
public Task<ResponseBase> startStockTakingOrder(GetStockTakingOrderMatDetailRequest request);
public Task<ResponseBase> endStockTakingOrder(GetStockTakingOrderMatDetailRequest request);
public Task<ResponseBase> queryMatInfoInStocktakingOrder(QueryMatInfoInStocktakingOrderRequest request);
public Task<ResponseBase> comfirmStocktakingOrder(ComfirmStocktakingOrderRequest request);
public Task<ResponseBase> commitStockTakingOrder(GetStockTakingOrderMatDetailRequest request);
}
}

129
WCS.BLL/Services/Service/GenerateService.cs Normal file
View File

@ -0,0 +1,129 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime;
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;
using WCS.DAL.AuthDbModel;
using WCS.DAL.Db;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.MatBaseInfo;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.Service
{
/// <summary>
/// 需要生成序列号保证不重复的方法
/// </summary>
public class GenerateService : IGenerateService
{
public static object matFlag = new object();
public static object stockTakingFlag = new object();
public async Task<ResponseCommon<List<MatInfo>>> generateMatInfo(GenerateMatInfoRequest request)
{
//校验是否被禁用
var matBaseInfo = await DbHelp.db.Queryable<MatBaseInfo>()
.Where(t => t.Id == request.MatBaseInfo.Id)
.FirstAsync();
if (matBaseInfo == null)
{
return new ResponseCommon<List<MatInfo>>()
{
Code = 201,
Message = $"生成失败：该物料基础信息不存在",
Data = null
};
}
else if (matBaseInfo.IsEnable == false)
{
return new ResponseCommon<List<MatInfo>>()
{
Code = 201,
Message = $"生成失败：该物料已被禁用",
Data = null
};
}
//生成条码
lock (matFlag)
{
try
{
DbHelp.db.BeginTran();
var startNumber = matBaseInfo.SerialNumber++;
var matInfoList = new List<MatInfo>();
for (var i = 0; i < request.TotalCount; i++)
{
var matInfo = new MatInfo()
{
MatSn = GetMatSn(matBaseInfo, startNumber + i),
MatCode = matBaseInfo.MatCode,
MatName = matBaseInfo.MatName,
MatBatch = matBaseInfo.MatBatch,
MatSpec = matBaseInfo.MatSpec,
MatUnit = matBaseInfo.MatUnit,
MatSupplier = matBaseInfo.MatSupplier,
MatCustomer = matBaseInfo.MatCustomer,
MatQty = request.MatQty,
ModifyUser = request.UserName
};
matInfoList.Add(matInfo);
}
DbHelp.db.Insertable(matInfoList).ExecuteCommand();
matBaseInfo.SerialNumber = startNumber + request.TotalCount;
DbHelp.db.Updateable(matBaseInfo).ExecuteCommand();
DbHelp.db.CommitTran();
return new ResponseCommon<List<MatInfo>>()
{
Code = 200,
Message = "success",
Data = matInfoList
};
}
catch (Exception ex)
{
DbHelp.db.RollbackTran();
return new ResponseCommon<List<MatInfo>>()
{
Code = 201,
Message = $"生成失败：{ex.Message}",
Data = null
};
}
}
}
private string GetMatSn(MatBaseInfo matBaseInfo, int serialNumber)
{
var gongshi = "=A1&\"-\"&A2&A3";
//var matSn = matBaseInfo.MatCode + matBaseInfo.MatBatch + serialNumber.ToString().PadLeft(6, '0');
Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
keyValuePairs.Add("A1", matBaseInfo.MatCode);
keyValuePairs.Add("A2", matBaseInfo.MatName);
keyValuePairs.Add("A3", serialNumber.ToString().PadLeft(6, '0'));
var matSn = PnHelp.Jx(gongshi, keyValuePairs);
return matSn;
}
public async Task<string> generateStockTakingNumber()
{
lock (stockTakingFlag)
{
Thread.Sleep(1);
return "PD" + DateTime.Now.ToString("yyMMddHHmmssfff");
}
}
}
}

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

@ -6,6 +6,7 @@ using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.HardWare;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
@ -79,7 +80,7 @@ namespace WCS.BLL.Services.Service
};
}
public ResponseBase queryByMatSn(QueryByMatSnRequest request)
public async Task<ResponseBase> queryByMatSn(QueryByMatSnRequest request)
{
//获取货架
var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
@ -100,22 +101,58 @@ namespace WCS.BLL.Services.Service
Message = $"操作失败：货架[{request.ShelfCode}]不在入库模式!\r\n当前为{shelf.CurentMode}",
};
}
//判断物料是否已入库
var inventory = await DbHelp.db.Queryable<InventoryDetail>().Where(t => t.MatSN == request.MatSn).FirstAsync();
if (inventory != null)
{
return new QueryByMatSnResponse()
{
Code = 201,
Message = $"操作失败：物料{inventory.MatSN}已入库，库位为{inventory.StoreCode}",
};
}
#region 获取物料数据
//调用接口或者直接查询数据库
if (1 == 1)
if (1 != 1)
{
}
//查询数据库
else
{
var matInfo = await DbHelp.db.Queryable<MatInfo>().Where(t => t.MatSn == request.MatSn).FirstAsync();
if (matInfo != null)
{
shelf.InStoreData = new MatInfoResponse()
{
materialBar = matInfo.MatSn,
materialCode = matInfo.MatCode,
materialName = matInfo.MatName,
materialQty = matInfo.MatQty,
materialSpec = matInfo.MatSpec,
batchNo = matInfo.MatBatch,
supplier = matInfo.MatSupplier,
customer = matInfo.MatCustomer,
};
return new QueryByMatSnResponse()
{
Code = 200,
Data = shelf.InStoreData,
Message = "success"
};
}
else
return new QueryByMatSnResponse()
{
Code = 201,
Data = null,
Message = $"不存在物料{request.MatSn}"
};
}
return new QueryByMatSnResponse()
{
Code = 200,
Data = new MatInfoModel(),
Message = "success"
};
#endregion
}
public async Task<ResponseBase> queryInstoreStatus(QueryByMatSnRequest request)
@ -127,7 +164,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不存在!",
Message = $"货架[{request.ShelfCode}]不存在!",
};
}
//判断当前是否是入库模式
@ -136,7 +173,7 @@ namespace WCS.BLL.Services.Service
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不在入库模式!\r\n当前为{shelf.CurentMode}",
Message = $"货架[{request.ShelfCode}]已退出入库模式!\r\n当前为{shelf.CurentMode}",
};
}
//这个时间相当于需要入库扫码后需要等待的时间

1
WCS.BLL/Services/Service/MatInventoryDetailService.cs
View File

@ -122,5 +122,6 @@ namespace WCS.BLL.Services.Service
};
}
}
}
}

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

@ -32,7 +32,7 @@ namespace WCS.BLL.Services.Service
//判断是否有单据号 没有单据号系统自动生成一个
if (string.IsNullOrEmpty(request.OrderNumber))
{
request.OrderNumber = GetOrderNumber();
request.OrderNumber = GenerateOrderNumber();
}
Console.WriteLine(DateTime.Now);
//保存数据
@ -128,7 +128,7 @@ namespace WCS.BLL.Services.Service
//判断是否有单据号 没有单据号系统自动生成一个
if (string.IsNullOrEmpty(request.OrderNumber))
{
request.OrderNumber = GetOrderNumber();
request.OrderNumber = GenerateOrderNumber();
}
#region 保存数据
@ -267,6 +267,7 @@ namespace WCS.BLL.Services.Service
.Where(t => t.OrderId == outOrder.Id)
.ToListAsync();
#endregion
var orderDetail = await orderDetailTask;
var orderMatDetail = await orderMatDetailTask;
return new ResponseCommon()
@ -282,8 +283,7 @@ namespace WCS.BLL.Services.Service
}
private string GetOrderNumber()
private string GenerateOrderNumber()
{
var orderNumber = "PD" + DateTime.Now.ToString("yyyyMMddHHmmss");
return orderNumber;
@ -291,6 +291,7 @@ namespace WCS.BLL.Services.Service
public async Task<ResponseBase> GoInOutstore(GetOutOrderDetailRequest request)
{
//先找到所有物料
//分组 按物料找到对应得货架编码
@ -308,8 +309,8 @@ namespace WCS.BLL.Services.Service
public async Task<ResponseBase> GoOutOutstore(GetOutOrderDetailRequest request)
{
//找到出库单号一致的货架列表
var shelves = ShelfManager.Shelves.Where(t => t.OutOrderNumber == request.OrderNumber)
//找到正在出对应出库单的货架
var shelves = ShelfManager.Shelves.Where(t => t.OrderNumber == request.OrderNumber)
.ToList();
//退出出库模式
shelves.ForEach(t =>

712
WCS.BLL/Services/Service/StockTakingService.cs Normal file
View File

@ -0,0 +1,712 @@
using Microsoft.Data.SqlClient;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.Stocktaking;
namespace WCS.BLL.Services.Service
{
public class StockTakingService : IStockTakingService
{
#region SysStockTakingOrder
public async Task<ResponseBase> SysStockTakingOrder(SysStockTakingOrderRequest request)
{
//先判断盘点单据号是否已存在（避免前端多次提交后生成多个的情况）
var stocktakingOrder = await DbHelp.db.Queryable<StockTakingOrder>()
.Where(t => t.StocktakingOrderNumber == request.StocktakingOrderNumber)
.FirstAsync();
if (stocktakingOrder != null)
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：盘点单据{stocktakingOrder.StocktakingOrderNumber}已存在！"
};
else
{
//分成三类
switch (request.StocktakingOrderType)
{
case "shelfCodes":
return await SysStockTakingOrderByShelfCodes(request);
case "matCodes":
return await SysStockTakingOrderByMatCodes(request);
case "snList":
return await SysStockTakingOrderSnList(request);
default:
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：[{request.StocktakingOrderType}]不支持的操作！!"
};
}
}
}
public async Task<ResponseBase> SysStockTakingOrderByShelfCodes(SysStockTakingOrderRequest request)
{
//校验参数
if (request.List == null || request.List.Count == 0)
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：缺少必要参数"
};
//先判断是否有这些货架
var shelfs = ShelfManager.Shelves
.Where(t => request.List.Contains(t.ShelfCode))
.ToList();
if (shelfs.Count < request.List.Count)
{
foreach (var shelf in shelfs)
{
request.List.RemoveAll(t => t == shelf.ShelfCode);
}
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：货架[{string.Join(",", request.List)}]不存在！"
};
}
try
{
//获取库存数据 生成盘点单据
var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
.Includes(t => t.StoreInfo)
.Where(t => request.List.Contains(t.StoreInfo.ShelfCode))
.ToListAsync();
if (inventoryDetails == null || inventoryDetails.Count == 0)
{
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：未找到需要盘点的库存数据！"
};
}
await DbHelp.db.BeginTranAsync();
//盘点单据保存
var stockTakingOrder = new StockTakingOrder()
{
StocktakingOrderNumber = request.StocktakingOrderNumber,
StocktakingOrderSource = request.StocktakingOrderSource,
CreateUser = request.UserName
};
var stockTakingOrderId = await DbHelp.db.Insertable(stockTakingOrder).ExecuteReturnIdentityAsync();
stockTakingOrder.Id = stockTakingOrderId;
//盘点物料明细保存
foreach (var inventoryDetail in inventoryDetails)
{
var stockTakingOrderMatDetail = new StockTakingOrderMatDetail()
{
StocktakingOrderId = stockTakingOrderId,
StocktakingOrderNumber = request.StocktakingOrderNumber,
StoreId = inventoryDetail.StoreId,
StoreCode = inventoryDetail.StoreCode,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
MatBatch = inventoryDetail.MatBatch,
MatSpec = inventoryDetail.MatSpec,
MatQty = inventoryDetail.MatQty,
MatCustomer = inventoryDetail.MatCustomer,
MatSupplier = inventoryDetail.MatSupplier,
IsStocktaking = false,
StocktakingQty = inventoryDetail.MatQty,
UpdateUser = request.UserName
};
await DbHelp.db.Insertable(stockTakingOrderMatDetail).ExecuteReturnIdentityAsync();
}
await DbHelp.db.CommitTranAsync();
return new SysStockTakingOrderResponse()
{
Data = new SysStockTakingOrderData() { StocktakingOrderNumber = request.StocktakingOrderNumber },
Code = 200,
Message = $"Success"
};
}
catch (Exception ex)
{
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：{ex.Message}"
};
}
}
public async Task<ResponseBase> SysStockTakingOrderByMatCodes(SysStockTakingOrderRequest request)
{
//校验参数
if (request.List == null || request.List.Count == 0)
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：缺少必要参数"
};
//获取库存数据 生成盘点单据
var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
.Where(t => request.List.Contains(t.MatCode))
.ToListAsync();
if (inventoryDetails == null || inventoryDetails.Count == 0)
{
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：未找到需要盘点的库存数据！"
};
}
try
{
await DbHelp.db.BeginTranAsync();
//盘点单据保存
var stockTakingOrder = new StockTakingOrder()
{
StocktakingOrderNumber = request.StocktakingOrderNumber,
StocktakingOrderSource = request.StocktakingOrderSource,
CreateUser = request.UserName
};
var stockTakingOrderId = await DbHelp.db.Insertable(stockTakingOrder).ExecuteReturnIdentityAsync();
stockTakingOrder.Id = stockTakingOrderId;
//盘点物料明细保存
foreach (var inventoryDetail in inventoryDetails)
{
var stockTakingOrderMatDetail = new StockTakingOrderMatDetail()
{
StocktakingOrderId = stockTakingOrderId,
StocktakingOrderNumber = request.StocktakingOrderNumber,
StoreId = inventoryDetail.StoreId,
StoreCode = inventoryDetail.StoreCode,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
MatBatch = inventoryDetail.MatBatch,
MatSpec = inventoryDetail.MatSpec,
MatQty = inventoryDetail.MatQty,
MatCustomer = inventoryDetail.MatCustomer,
MatSupplier = inventoryDetail.MatSupplier,
IsStocktaking = false,
StocktakingQty = inventoryDetail.MatQty,
UpdateUser = request.UserName
};
await DbHelp.db.Insertable(stockTakingOrderMatDetail).ExecuteReturnIdentityAsync();
}
await DbHelp.db.CommitTranAsync();
return new SysStockTakingOrderResponse()
{
Data = new SysStockTakingOrderData() { StocktakingOrderNumber = request.StocktakingOrderNumber },
Code = 200,
Message = $"Success"
};
}
catch (Exception ex)
{
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：{ex.Message}"
};
}
}
public async Task<ResponseBase> SysStockTakingOrderSnList(SysStockTakingOrderRequest request)
{
//校验参数
if (request.List == null || request.List.Count == 0)
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：缺少必要参数"
};
//获取库存数据 生成盘点单据
var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
.Where(t => request.List.Contains(t.MatSN))
.ToListAsync();
if (inventoryDetails == null || inventoryDetails.Count == 0)
{
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：未找到需要盘点的库存数据！"
};
}
try
{
await DbHelp.db.BeginTranAsync();
//盘点单据保存
var stockTakingOrder = new StockTakingOrder()
{
StocktakingOrderNumber = request.StocktakingOrderNumber,
StocktakingOrderSource = request.StocktakingOrderSource,
CreateUser = request.UserName
};
var stockTakingOrderId = await DbHelp.db.Insertable(stockTakingOrder).ExecuteReturnIdentityAsync();
stockTakingOrder.Id = stockTakingOrderId;
//盘点物料明细保存
foreach (var inventoryDetail in inventoryDetails)
{
var stockTakingOrderMatDetail = new StockTakingOrderMatDetail()
{
StocktakingOrderId = stockTakingOrderId,
StocktakingOrderNumber = request.StocktakingOrderNumber,
StoreId = inventoryDetail.StoreId,
StoreCode = inventoryDetail.StoreCode,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
MatBatch = inventoryDetail.MatBatch,
MatSpec = inventoryDetail.MatSpec,
MatQty = inventoryDetail.MatQty,
MatCustomer = inventoryDetail.MatCustomer,
MatSupplier = inventoryDetail.MatSupplier,
IsStocktaking = false,
StocktakingQty = inventoryDetail.MatQty,
UpdateUser = request.UserName
};
await DbHelp.db.Insertable(stockTakingOrderMatDetail).ExecuteReturnIdentityAsync();
}
await DbHelp.db.CommitTranAsync();
return new SysStockTakingOrderResponse()
{
Data = new SysStockTakingOrderData() { StocktakingOrderNumber = request.StocktakingOrderNumber },
Code = 200,
Message = $"Success"
};
}
catch (Exception ex)
{
return new SysStockTakingOrderResponse()
{
Code = 201,
Message = $"操作失败：{ex.Message}"
};
}
}
#endregion
public async Task<PageQueryResponse<StockTakingOrder>> getStockTakingOrders(GetStockTakingOrdersRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<StockTakingOrder>()
.WhereIF(!string.IsNullOrEmpty(request.StocktakingOrderNumber), t => t.StocktakingOrderNumber.Contains(request.StocktakingOrderNumber));
switch (request.StocktakingOrderStatus)
{
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.未盘点:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == DbModels.StocktakingOrderStatus.未盘点);
break;
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.部分盘点:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == DbModels.StocktakingOrderStatus.部分盘点);
break;
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.已提交:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == DbModels.StocktakingOrderStatus.已提交);
break;
case Model.ApiModel.Stocktaking.StocktakingOrderStatus.盘点完成:
recordsQueryable = recordsQueryable.Where(t => t.StocktakingOrderStatus == DbModels.StocktakingOrderStatus.盘点完成);
break;
default:
break;
}
var totalCount = await recordsQueryable.CountAsync();
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.Select<StockTakingOrder>()
.ToListAsync();
//生成序号
for (int i = 0; i < records.Count; i++)
{
records[i].RowNumber = (request.PageNumber - 1) * 10 + i + 1;
}
return new PageQueryResponse<StockTakingOrder>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<StockTakingOrder>()
{
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<StockTakingOrder>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<ResponseBase> getStockTakingOrderMatDetail(GetStockTakingOrderMatDetailRequest request)
{
#region 查询盘点单
StockTakingOrder order = null;
if (request.StockTakingOrderId != 0)
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：不存在Id为{request.StockTakingOrderId}的出库单！",
};
}
}
else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
.FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
};
}
}
else
{
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：缺少必要参数！",
};
}
#endregion
//查询物料明细
var stockTakingOrderMatDetail = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.StocktakingOrderId == order.Id)
.ToListAsync();
return new ResponseCommon<List<StockTakingOrderMatDetail>>()
{
Code = 200,
Message = "success",
Data = stockTakingOrderMatDetail
};
}
public async Task<ResponseBase> startStockTakingOrder(GetStockTakingOrderMatDetailRequest request)
{
try
{
#region 查询盘点单
StockTakingOrder order = null;
if (request.StockTakingOrderId != 0)
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
};
}
}
else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
.FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
};
}
}
else
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：缺少必要参数！",
};
}
#endregion
#region 查询物料明细
//查询物料明细
var stockTakingOrderMatDetail = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.StocktakingOrderId == order.Id)
.ToListAsync();
//TO DO 货架按物料进入盘点模式
var shelf = ShelfManager.Shelves.First();
shelf.GoInStocktaking();
shelf.OrderNumber = order.StocktakingOrderNumber;
#endregion
return new ResponseCommon()
{
Code = 200,
Message = $"success",
Data = shelf.ShelfCode
};
}
catch (Exception ex)
{
return new ResponseCommon()
{
Code = 300,
Message = $"操作失败，{ex.Message}",
};
}
}
public async Task<ResponseBase> endStockTakingOrder(GetStockTakingOrderMatDetailRequest request)
{
try
{
#region 查询盘点单
StockTakingOrder order = null;
if (request.StockTakingOrderId != 0)
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
};
}
}
else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
.FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
};
}
}
else
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：缺少必要参数！",
};
}
#endregion
#region 查询当前盘点盘已启动的货架
var shelfs = ShelfManager.Shelves.Where(t => t.CurentMode == HardWare.Mode.盘点模式 && t.OrderNumber == order.StocktakingOrderNumber).ToList();
shelfs.ForEach(t =>
{
t.GoOutStocktaking();
});
#endregion
return new ResponseCommon()
{
Code = 200,
Message = $"success",
Data = shelfs.Select(t => t.ShelfCode).ToList(),
};
}
catch (Exception ex)
{
return new ResponseCommon()
{
Code = 300,
Message = $"操作失败，{ex.Message}",
};
}
}
public async Task<ResponseBase> queryMatInfoInStocktakingOrder(QueryMatInfoInStocktakingOrderRequest request)
{
//判断是否有这个物料
var storeInfo = 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)
{
return new ResponseCommon()
{
Code = 201,
Message = $"不存在物料[{request.MatSN}]",
};
}
//判断货架是否进入入库模式
var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == storeInfo.ShelfCode).FirstOrDefault();
if (shelf == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"物料[{request.MatSN}不是本次需要盘点的物料！！！]",
};
}
//进入入库模式的那个单据是否有对应的单据明细
var stockTakingOrder = await DbHelp.db.Queryable<StockTakingOrder>()
.Where(t => t.StocktakingOrderNumber == shelf.OrderNumber)
.FirstAsync();
if (stockTakingOrder == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"未找到对应盘点单据{shelf.OrderNumber}",
};
}
//返回具体的单据信息
var stockTakinbgOrder = await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.StocktakingOrderId == stockTakingOrder.Id)
.Where(t => t.MatSN == request.MatSN)
.FirstAsync();
return new ResponseCommon<StockTakingOrderMatDetail>()
{
Code = 200,
Message = "success",
Data = stockTakinbgOrder
};
}
public async Task<ResponseBase> comfirmStocktakingOrder(ComfirmStocktakingOrderRequest request)
{
//获取盘点物料明细
var stockTakingMatDetail =await DbHelp.db.Queryable<StockTakingOrderMatDetail>()
.Where(t => t.Id == request.Id)
.FirstAsync();
if (stockTakingMatDetail == null)
{
return new ResponseCommon()
{
Code = 201,
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)
{
try
{
#region 查询盘点单
StockTakingOrder order = null;
if (request.StockTakingOrderId != 0)
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.Id == request.StockTakingOrderId).FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在Id为{request.StockTakingOrderId}的出库单！",
};
}
}
else if (!string.IsNullOrEmpty(request.StockTakingOrderNumber))
{
order = await DbHelp.db.Queryable<StockTakingOrder>().Where(t => t.StocktakingOrderNumber == request.StockTakingOrderNumber)
.FirstAsync();
if (order == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：不存在单据号为{request.StockTakingOrderNumber}的出库单！",
};
}
}
else
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：缺少必要参数！",
};
}
#endregion
#region 判断单据状态
if (order.StocktakingOrderStatus != DbModels.StocktakingOrderStatus.已提交)
{
return new ResponseCommon()
{
Code = 201,
Message = $"单据已提交，请勿重复提交！",
};
}
else if (order.StocktakingOrderStatus != DbModels.StocktakingOrderStatus.盘点完成)
{
return new ResponseCommon()
{
Code = 201,
Message = $"单据未盘点完成！！！",
};
}
#endregion
//To do 进行提交！
return new ResponseCommon()
{
Code = 200,
Message = $"success",
};
}
catch (Exception ex)
{
return new ResponseCommon()
{
Code = 300,
Message = $"操作失败，{ex.Message}",
};
}
}
}
}