public void DirectOutput(RobotPack pack)
{
// send a output response to every PMR conencted and matching tenant.
foreach (IConverterStream stream in this.converterStreamList)
{
if (pack.TenantID != stream.TenantID)
{
continue;
}
StockOutputRequest stockOutputRequest = new StockOutputRequest(stream);
stockOutputRequest.ID = "1"; // is always 1
stockOutputRequest.TenantID = pack.TenantID;
int machineLocation;
if (int.TryParse(pack.MachineLocation, out machineLocation))
{
stockOutputRequest.Source = machineLocation;
}
stockOutputRequest.Destination = 100;
stockOutputRequest.Order = new StockOutputOrder();
stockOutputRequest.Order.OutputNumber = 1;
StockOutputOrderItem orderItem = new StockOutputOrderItem();
orderItem.RobotArticleCode = pack.RobotArticleCode;
orderItem.PackID = pack.ID;
if (pack.SubItemQuantity == 0)
{
orderItem.RequestedQuantity = 1;
}
else
{
orderItem.RequestedSubItemQuantity = pack.SubItemQuantity;
}
stockOutputRequest.Order.Items.Add(orderItem);
// create SimulatorOutputOrder to handle output result.
SimulatorOutputOrder outputOrder = new SimulatorOutputOrder(
this.stock,
this.simulatorTenant,
this.simulatorStockLocation,
stockOutputRequest,
OutputResult.Normal,
this.enableAutoReply,
this.converterStreamList);
outputOrder.OutputOrderUpdated += this.OutputOrder_OutputOrderUpdated;
this.orderList.Add(outputOrder);
this.DoOutputOrderListUpdated();
}
}
/// <summary>
/// Translates this object instance into a Mosaic message.
/// </summary>
/// <param name="converterStream">The converter stream instance which request the message conversion.</param>
/// <returns>
/// The Mosaic message representation of this object.
/// </returns>
public virtual MosaicMessage ToMosaicMessage(IConverterStream converterStream)
{
StockOutputMessage msg = new StockOutputMessage(converterStream);
msg.ID = this.Id;
msg.Source = this.Source;
msg.Destination = this.Destination;
msg.Order = new StockOutputOrder();
if (this.Details == null)
{
return(null);
}
msg.Order.Priority = TypeConverter.ConvertOutputPriority(this.Details.Priority);
msg.Order.OutputNumber = TypeConverter.ConvertInt(this.Details.OutputDestination);
msg.Order.State = TypeConverter.ConvertOrderState(this.Details.Status);
if (this.Article != null)
{
foreach (var article in this.Article)
{
var item = new StockOutputOrderItem()
{
RobotArticleCode = TextConverter.UnescapeInvalidXmlChars(article.Id)
};
if (article.Pack != null)
{
foreach (var pack in article.Pack)
{
item.Packs.Add(new StockOutputOrderItemPack()
{
ID = (long)TypeConverter.ConvertULong(pack.Id),
BatchNumber = TextConverter.UnescapeInvalidXmlChars(pack.BatchNumber),
ExternalID = TextConverter.UnescapeInvalidXmlChars(pack.ExternalId),
ExpiryDate = TypeConverter.ConvertDate(pack.ExpiryDate)
});
}
}
msg.Order.Items.Add(item);
}
}
return(msg);
}
private List <RobotPack> GetStock(StockOutputOrderItem stockOutputOrderItem, string tenantID)
{
var articleCode = String.IsNullOrWhiteSpace(stockOutputOrderItem.RobotArticleCode) ?
stockOutputOrderItem.PISArticleCode : stockOutputOrderItem.RobotArticleCode;
StockProduct productStock = this.stock.GetStockProduct(articleCode);
if (productStock != null)
{
return(productStock.GetPackList(
stockOutputOrderItem.BatchNumber,
stockOutputOrderItem.ExternalID,
stockOutputOrderItem.MachineLocation,
stockOutputOrderItem.StockLocationID,
stockOutputOrderItem.PackID,
tenantID));
}
else
{
return(new List <RobotPack>());
}
}
private void dataGridViewOutputOrderItems_RowEnter(object sender, DataGridViewCellEventArgs e)
{
StockOutputOrderItem selectedItem = (StockOutputOrderItem)dataGridViewOutputOrderItems.Rows[e.RowIndex].DataBoundItem;
dataGridViewOutputDispensedPack.DataSource = new BindingSource(selectedItem.Packs, "");
}
private List <StockOutputOrderItemPack> GetOrderItemFromStock(
StockOutputMessage stockOutputMessage,
StockOutputOrderItem stockOutputOrderItem,
List <RobotPack> availableStock,
List <RobotPack> usedStock)
{
List <StockOutputOrderItemPack> result = new List <StockOutputOrderItemPack>();
StorageSystemArticleInformation articleInformation = this.stock.ArticleInformationList.GetArticleInformation(string.IsNullOrWhiteSpace(stockOutputOrderItem.RobotArticleCode) ?
stockOutputOrderItem.PISArticleCode : stockOutputOrderItem.RobotArticleCode, false);
string pickedBatchNumber = String.Empty;
int subIemQuantityInStock = 0;
// if possible pick a pack that match exactly the requested subquantity.
foreach (RobotPack availablePack in availableStock)
{
if (stockOutputOrderItem.ProcessedSubItemQuantity < stockOutputOrderItem.RequestedSubItemQuantity)
{
if (availablePack.SubItemQuantity == stockOutputOrderItem.RequestedSubItemQuantity)
{
stockOutputOrderItem.ProcessedSubItemQuantity += availablePack.SubItemQuantity;
result.Add(this.GetOrderItemPackFromStock(
stockOutputMessage.Order,
articleInformation,
availablePack));
usedStock.Add(availablePack);
pickedBatchNumber = availablePack.BatchNumber;
}
}
subIemQuantityInStock += availablePack.SubItemQuantity;
}
// update available stock
foreach (RobotPack usedPack in usedStock)
{
if (availableStock.Contains(usedPack))
{
availableStock.Remove(usedPack);
}
}
// Normal picking.
foreach (RobotPack availablePack in availableStock)
{
if (availablePack.SubItemQuantity == 0)
{
// Full pack
if ((stockOutputOrderItem.ProcessedQuantity < stockOutputOrderItem.RequestedQuantity) &&
(!stockOutputOrderItem.SingleBatchNumber || (pickedBatchNumber == availablePack.BatchNumber) || (String.IsNullOrEmpty(pickedBatchNumber))))
{
stockOutputOrderItem.ProcessedQuantity++;
result.Add(this.GetOrderItemPackFromStock(
stockOutputMessage.Order,
articleInformation,
availablePack));
usedStock.Add(availablePack);
pickedBatchNumber = availablePack.BatchNumber;
}
else
{
// if we don't have enough open pack in stock, add full packs
if (subIemQuantityInStock < stockOutputOrderItem.RequestedSubItemQuantity)
{
if (articleInformation.MaxSubItemQuantity != 0)
{
if ((stockOutputOrderItem.ProcessedSubItemQuantity < stockOutputOrderItem.RequestedSubItemQuantity) &&
(!stockOutputOrderItem.SingleBatchNumber || (pickedBatchNumber == availablePack.BatchNumber)))
{
stockOutputOrderItem.ProcessedSubItemQuantity += articleInformation.MaxSubItemQuantity;
result.Add(this.GetOrderItemPackFromStock(
stockOutputMessage.Order,
articleInformation,
availablePack));
usedStock.Add(availablePack);
pickedBatchNumber = availablePack.BatchNumber;
}
}
else
{
if ((stockOutputOrderItem.ProcessedSubItemQuantity < stockOutputOrderItem.RequestedSubItemQuantity) &&
(!stockOutputOrderItem.SingleBatchNumber || (pickedBatchNumber == availablePack.BatchNumber)))
{
stockOutputOrderItem.ProcessedQuantity += 1;
result.Add(this.GetOrderItemPackFromStock(
stockOutputMessage.Order,
articleInformation,
availablePack));
usedStock.Add(availablePack);
pickedBatchNumber = availablePack.BatchNumber;
}
break;
}
}
}
}
else
{
// Open pack
if ((stockOutputOrderItem.ProcessedSubItemQuantity < stockOutputOrderItem.RequestedSubItemQuantity) &&
(!stockOutputOrderItem.SingleBatchNumber || (pickedBatchNumber == availablePack.BatchNumber)))
{
stockOutputOrderItem.ProcessedSubItemQuantity += availablePack.SubItemQuantity;
result.Add(this.GetOrderItemPackFromStock(
stockOutputMessage.Order,
articleInformation,
availablePack));
usedStock.Add(availablePack);
pickedBatchNumber = availablePack.BatchNumber;
}
}
if ((stockOutputOrderItem.ProcessedQuantity >= stockOutputOrderItem.RequestedQuantity) &&
(stockOutputOrderItem.ProcessedSubItemQuantity >= stockOutputOrderItem.RequestedSubItemQuantity))
{
break;
}
}
// update available stock
foreach (RobotPack usedPack in usedStock)
{
if (availableStock.Contains(usedPack))
{
availableStock.Remove(usedPack);
}
}
return(result);
}
