/// <summary>
/// 审核
/// </summary>
/// <param name="orderNo"></param>
/// <param name="errMessage"></param>
/// <returns></returns>
public bool Audit(string orderNo, out string errMessage)
{
var entity = new RepositoryFactory <SaleOrderEntity>().Repository().FindEntity("OrderNo", orderNo);
if (entity == null || entity.Status != (int)OrderStatus.WaitAudit)
{
errMessage = string.Format("订单{0}不是待审核状态，不能审核<br>", orderNo);
return(false);
}
if (entity.IsSuspended)
{
errMessage = string.Format("订单{0}已被挂起，不能操作<br>", orderNo);
return(false);
}
var orderItems = _saleOrderBLL.GetOrderItemList(entity.OrderNo);
IDatabase database = DataFactory.Database();
DbTransaction isOpenTrans = database.BeginTrans();
try
{
entity.Modify(entity.OrderId);
entity.Status = (int)OrderStatus.WaitConfirm;
bool isSuccess = _saleOrderBLL.UpdateStatus(entity, OrderStatus.WaitAudit, isOpenTrans);
if (!isSuccess)
{
throw new Exception(string.Format("订单{0}更新状态失败<br>", orderNo));
}
//foreach (var item in orderItems)
//{
// bool flag = _inventoryBll.UpdateInventoryByAllocate(entity.WarehouseId, item.ProductId, entity.MerchantId, item.Qty, isOpenTrans);
// if (!flag)
// {
// throw new Exception("更新已分配库存失败");
// }
//}
database.Commit();
errMessage = "";
return(true);
}
catch (Exception ex)
{
database.Rollback();
errMessage = ex.Message;
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="orderId"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool OrderAllocate(string orderId, out string message)
{
var order = new RepositoryFactory <SaleOrderEntity>().Repository().FindEntity("OrderId", orderId);
if (order == null)
{
message = string.Format("订单[{0}]数据异常", orderId);
return(false);
}
if (order.OutStockStatus != (int)OutStockStatus.Initial)
{
message = string.Format("订单出库状态[{0}]不是初始状态，配货失败", order.OrderNo);
return(false);
}
var orderItems = _orderBll.GetOrderItemList(order.OrderNo);
List <PickItemEntity> picks = new List <PickItemEntity>();
foreach (SaleOrderItemEntity orderItem in orderItems)
{
//待分配数量
int waitAllocateQty = orderItem.Qty;
//商品库存
var inventoryList = _inventoryLocationBLL.GetProductInventoryList(order.WarehouseId, orderItem.ProductId, true);
foreach (var inventoryEntity in inventoryList)
{
//本储位拣货数量
int pickQty = 0;
//当前储位可用数量
int availableQty = inventoryEntity.QtyOnHand - inventoryEntity.QtyAllocated -
inventoryEntity.QtySuspense;
if (availableQty >= waitAllocateQty)
{
pickQty = waitAllocateQty;
}
else
{
pickQty = availableQty;
}
var location = _locationBll.GetLocationByCode(order.WarehouseId, inventoryEntity.LocationCode);
if (location == null)
{
continue;
}
waitAllocateQty -= pickQty;
var pick = new PickItemEntity();
pick.Create();
pick.WarehouseId = order.WarehouseId;
pick.ProductId = orderItem.ProductId;
pick.LocationCode = inventoryEntity.LocationCode;
pick.ZoneCode = location.AllocZone;
pick.ToLocationCode = "PACK";
pick.OrderNo = order.OrderNo;
pick.Qty = pickQty;
picks.Add(pick);
if (waitAllocateQty == 0)
{
break;
}
}
if (waitAllocateQty > 0)
{
message = string.Format("商品[{0}]库存不足，配货失败", orderItem.ProductName);
return(false);
}
}
IDatabase database = DataFactory.Database();
DbTransaction isOpenTrans = database.BeginTrans();
try
{
order.Modify(order.OrderId);
order.OutStockStatus = (int)OutStockStatus.Allocated;
bool isSuccess = _orderBll.UpdateStatus(order, OutStockStatus.Initial, isOpenTrans);
if (!isSuccess)
{
throw new Exception("订单状态更新失败");
}
foreach (var pick in picks)
{
bool flag = _inventoryLocationBLL.UpdateInventoryByAllocate(pick.WarehouseId, pick.ProductId,
pick.LocationCode,
pick.Qty, isOpenTrans);
if (flag)
{
database.Insert(pick, isOpenTrans);
}
else
{
throw new Exception("库存占用失败");
}
}
database.Commit();
message = string.Format("订单[{0}]配货成功", order.OrderNo);
return(true);
}
catch (Exception ex)
{
database.Rollback();
message = string.Format("订单[{0}]配货失败:{1}", order.OrderNo, ex.Message);
return(false);
}
}
/// <summary>
/// 打包
/// </summary>
/// <param name="orderNo"></param>
/// <param name="packageNum"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool Package(string orderNo, int packageNum, out string message)
{
if (packageNum >= 99)
{
message = string.Format("订单[{0}]最多只能打99个包裹", orderNo);
return(false);
}
var order = new RepositoryFactory <SaleOrderEntity>().Repository().FindEntity("OrderNo", orderNo);
if (order == null)
{
message = string.Format("订单[{0}]数据异常", orderNo);
return(false);
}
if (order.OutStockStatus != (int)OutStockStatus.PickFinished)
{
message = string.Format("订单[{0}]不是拣货完成状态，不能打包", order.OrderNo);
return(false);
}
List <CartonEntity> cartons = new List <CartonEntity>();
for (int i = 1; i <= packageNum; i++)
{
CartonEntity carton = new CartonEntity();
carton.Create();
carton.CartonNum = CreateCartonNum() + i.ToString("00");
carton.WarehouseId = order.WarehouseId;
carton.MerchantId = order.MerchantId;
carton.OrderNo = order.OrderNo;
carton.ShipTypeId = order.ShipTypeId;
carton.TotalCount = packageNum;
carton.CurrentNum = i;
carton.Status = 0;
cartons.Add(carton);
}
var orderItems = _orderBll.GetOrderItemList(order.OrderNo);
IDatabase database = DataFactory.Database();
DbTransaction isOpenTrans = database.BeginTrans();
try
{
order.Modify(order.OrderId);
order.OutStockStatus = (int)OutStockStatus.Packaged;
bool isSuccess = _orderBll.UpdateStatus(order, OutStockStatus.PickFinished, isOpenTrans);
if (!isSuccess)
{
throw new Exception("订单状态更新失败");
}
foreach (SaleOrderItemEntity orderItem in orderItems)
{
bool flag = _inventoryLocationBLL.UpdateInventoryByOutStock(order.WarehouseId, InventoryLocationTransactionType.Package, orderItem.ProductId, "PACK", orderItem.Qty, isOpenTrans);
if (!flag)
{
throw new Exception("库存扣减失败");
}
}
foreach (CartonEntity carton in cartons)
{
database.Insert(carton, isOpenTrans);
_codeRuleBll.OccupyBillCode(ManageProvider.Provider.Current().UserId, CartonCodeName,
isOpenTrans);
}
database.Commit();
message = string.Format("订单[{0}]打包完成", order.OrderNo);
return(true);
}
catch (Exception ex)
{
database.Rollback();
message = string.Format("订单[{0}]打包失败:{1}", order.OrderNo, ex.Message);
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="shipTypeId"></param>
/// <param name="expressNum"></param>
/// <param name="createUserId"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool ScanExpressNum(string shipTypeId, string expressNum, string createUserId, out string message)
{
var handover = _handoverBll.GetUnPrintHandoverByShipType(shipTypeId, createUserId);
if (handover == null)
{
handover = new HandoverEntity();
handover.Create();
handover.HandoverNo = "";
handover.IsPrinted = 0;
handover.ShipTypeId = shipTypeId;
_handoverBll.Repository().Insert(handover);
}
SaleOrderEntity orderEntity = _saleOrderBll.GetSaleOrderByExpressNum(expressNum);
if (orderEntity == null)
{
message = string.Format("无效的物流单号[{0}]", expressNum);
return(false);
}
if (orderEntity.Status != (int)OrderStatus.OutStock && orderEntity.Status != (int)OrderStatus.Handover)
{
message = string.Format("订单[{0}]不是已出库或已交接状态，不能交接扫描", orderEntity.OrderNo);
return(false);
}
if (orderEntity.ShipTypeId != shipTypeId)
{
message = string.Format("物流单号[{0}]与所选物流方式不一致，不能扫描", orderEntity.ExpressNum);
return(false);
}
if (orderEntity.IsSuspended)
{
message = string.Format("订单[{0}]已被挂起，不能与配送商交接", orderEntity.OrderNo);
return(false);
}
HandoverItemEntity itemEntity = _handoverBll.GetHandOverItem(expressNum);
IDatabase database = DataFactory.Database();
DbTransaction isOpenTrans = database.BeginTrans();
try
{
var picks = _pickItemBll.GetPickItemListByOrderNo(orderEntity.OrderNo);
message = string.Empty;
if (itemEntity == null)
{
HandoverItemEntity handoverItemEntity = new HandoverItemEntity();
handoverItemEntity.Create();
handoverItemEntity.HandoverId = handover.HandoverId;
handoverItemEntity.ExpressNum = expressNum;
handoverItemEntity.OrderNo = orderEntity.OrderNo;
handoverItemEntity.ScanedTime = DateTime.Now;
_handoverItemBll.Repository().Insert(handoverItemEntity, isOpenTrans);
orderEntity.Status = (int)OrderStatus.Handover;
bool flag = _saleOrderBll.UpdateStatus(orderEntity, OrderStatus.OutStock, isOpenTrans);
if (!flag)
{
throw new Exception("修改订单状态出现异常，请重新操作");
}
//foreach (var item in picks)
//{
// bool moveIn = _inventoryLocationBLL.UpdateInventoryByMoveIn(orderEntity.WarehouseId, item.ProductId, item.ToLocationCode, item.Qty, isOpenTrans);
// if (!moveIn)
// {
// throw new Exception("更新目的储位库存失败");
// }
//}
}
else
{
if (itemEntity.HandoverId == handover.HandoverId)
{
if (_handoverBll.CancelItem(handover.HandoverId, itemEntity.ExpressNum))
{
orderEntity.Status = (int)OrderStatus.OutStock;
bool flag = _saleOrderBll.UpdateStatus(orderEntity, OrderStatus.Handover, isOpenTrans);
if (!flag)
{
throw new Exception("修改订单状态出现异常，请重新操作");
}
message = string.Format("物流单号[{0}]已取消扫描", orderEntity.ExpressNum);
}
else
{
throw new Exception(string.Format("物流单号[{0}]取消扫描失败", orderEntity.ExpressNum));
}
}
else
{
throw new Exception(string.Format("物流单号[{0}]已扫入其他交接单", orderEntity.ExpressNum));
}
//foreach (var item in picks)
//{
// bool moveIn = _inventoryLocationBLL.UpdateInventoryByMoveIn(orderEntity.WarehouseId, item.ProductId, item.ToLocationCode, -1 * item.Qty, isOpenTrans);
// if (!moveIn)
// {
// throw new Exception("更新目的储位库存失败");
// }
//}
}
database.Commit();
return(true);
}
catch (Exception ex)
{
database.Rollback();
message = string.Format("订单交接扫描异常：{0}", ex.Message);
return(false);
}
}
/// <summary>
/// 生成拣货单
/// </summary>
/// <param name="aryOrderNo"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool CreatePickMaster(string[] aryOrderNo, out string message)
{
string warehouseId = string.Empty;
List <SaleOrderEntity> orderList = new List <SaleOrderEntity>();
foreach (string orderNo in aryOrderNo)
{
var order = new RepositoryFactory <SaleOrderEntity>().Repository().FindEntity("OrderNo", orderNo);
if (order == null)
{
message = string.Format("订单[{0}]查询失败", orderNo);
return(false);
}
if (!string.IsNullOrEmpty(warehouseId) && warehouseId != order.WarehouseId)
{
message = "非同一仓库的订单不能生成拣货单";
return(false);
}
if (string.IsNullOrEmpty(warehouseId))
{
warehouseId = order.WarehouseId;
}
if (order.Status != (int)OrderStatus.WaitPick)
{
message = string.Format("订单[{0}]不是待拣货状态，不能生成拣货单", order.OrderNo);
return(false);
}
orderList.Add(order);
}
PickMasterEntity pickMaster = new PickMasterEntity();
pickMaster.Create();
pickMaster.WarehouseId = warehouseId;
pickMaster.PickNo = CreatePickMasterCode();
IDatabase database = DataFactory.Database();
DbTransaction isOpenTrans = database.BeginTrans();
try
{
foreach (SaleOrderEntity order in orderList)
{
order.Modify(order.OrderId);
order.Status = (int)OrderStatus.WaitOutStock;
bool isSuccess = _orderBll.UpdateStatus(order, OrderStatus.WaitPick, isOpenTrans);
if (!isSuccess)
{
throw new Exception("订单状态更新失败");
}
isSuccess = _pickItemBll.UpdateOrderPickNo(order.OrderNo, pickMaster.PickNo, isOpenTrans);
if (!isSuccess)
{
throw new Exception("商品库存更新失败");
}
}
database.Insert(pickMaster, isOpenTrans);
_codeRuleBll.OccupyBillCode(ManageProvider.Provider.Current().UserId, PickMasterCodeName, isOpenTrans);
database.Commit();
message = "生成拣货单成功";
return(true);
}
catch (Exception ex)
{
database.Rollback();
message = string.Format("生成拣货单失败:{0}", ex.Message);
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="billNo"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool ScanFinished(string billNo, out string message)
{
SaleOrderEntity orderEntity = billNo.ToLower().StartsWith("so")
? _orderBll.GetSaleOrder(billNo)
: _orderBll.GetSaleOrderByExpressNum(billNo);
if (orderEntity == null)
{
message = string.Format("无效的物流单号或订单号[{0}]", billNo);
return(false);
}
if (orderEntity.Status != (int)OrderStatus.WaitOutStock)
{
message = string.Format("订单[{0}]不是待拣货状态，不能出库校验", orderEntity.OrderNo);
return(false);
}
IDatabase database = DataFactory.Database();
DbTransaction isOpenTrans = database.BeginTrans();
try
{
orderEntity.Status = (int)OrderStatus.OutStock;
bool flag = _orderBll.UpdateStatus(orderEntity, OrderStatus.WaitOutStock, null);
if (!flag)
{
message = "修改订单状态出现异常，请重新操作";
return(false);
}
var picks = _pickItemBll.GetPickItemListByOrderNo(orderEntity.OrderNo);
foreach (var item in picks)
{
bool outStock1 = _inventoryLocationBLL.UpdateInventoryByOutStock(item.WarehouseId, InventoryLocationTransactionType.OutStock, item.ProductId,
item.LocationCode, item.Qty, isOpenTrans);
if (!outStock1)
{
throw new Exception(string.Format("更新储位{0}库存失败", item.LocationCode));
}
bool outStock2 = _inventoryBLL.UpdateInventoryByOutStock(orderEntity.OrderNo, InventoryTransactionType.OutStock, item.WarehouseId,
orderEntity.MerchantId, item.ProductId, item.Qty, isOpenTrans);
if (!outStock2)
{
throw new Exception("更新在库库存失败");
}
}
database.Commit();
}
catch (Exception ex)
{
database.Rollback();
message = string.Format("订单[{0}]出库校验失败:{1}", orderEntity.OrderNo, ex.Message);
return(false);
}
message = "";
return(true);
}
