/// <summary>
/// Startup with Creating Dispo Agent for current Item.
/// </summary>
/// <param name="agent"></param>
/// <param name="orderItem"></param>
public void StartOrder(T_CustomerOrderPart orderItem)
{
// create Request Item
_fArticle = orderItem.ToRequestItem(requester: Agent.Context.Self, currentTime: Agent.CurrentTime);
// Tell Guardian to create Dispo Agent
var agentSetup = AgentSetup.Create(agent: Agent, behaviour: DispoAgent.Behaviour.Factory.Get(simType: Agent.Behaviour.SimulationType));
var instruction = Guardian.Instruction.CreateChild.Create(setup: agentSetup, target: ((IAgent)Agent).Guardian, source: Agent.Context.Self);
Agent.Send(instruction: instruction);
// init end
}
internal void RequestArticle(FArticle requestArticle)
{
// Save Request Item.
_fArticle = requestArticle;
Agent.DebugMessage($"{_fArticle.Article.Name} {_fArticle.Key} is Requested to Produce.");
// get related Storage Agent
Agent.Send(instruction: Directory.Instruction
.RequestAgent
.Create(discriminator: requestArticle.Article.Name
, target: Agent.ActorPaths.StorageDirectory.Ref));
}
private void UpdateOrder(FArticle item)
{
var toUpdate = simulationOrders.SingleOrDefault(predicate: x => x.OriginId == item.CustomerOrderId);
if (toUpdate == null)
{
throw new Exception(message: "OrderNotFound during Order update from Contract Collector Agent");
}
toUpdate.State = DB.Enums.State.Finished;
toUpdate.FinishingTime = (int)item.FinishedAt;
}
public static void PublishUpdateArticleProvider(Agent agent, FArticle article)
{
var pub = new FUpdateSimulationWorkProvider(fArticleProviderKeys: article.ProviderList
, requestAgentId: article.OriginRequester.Path.Uid.ToString()
, requestAgentName: article.OriginRequester.Path.Name
//, originRequesterId: article.OriginRequester.Path.Uid.ToString()
//, originRequesterName: article.OriginRequester.Path.Uid.ToString()
, isHeadDemand: article.IsHeadDemand
, customerOrderId: article.CustomerOrderId);
agent.Context.System.EventStream.Publish(@event: pub);
}
/// <summary>
/// Startup with Creating Dispo Agent for current Item.
/// </summary>
/// <param name="agent"></param>
/// <param name="orderItem"></param>
public void StartOrder(T_CustomerOrderPart orderItem)
{
// create Request Item
_fArticle = orderItem.ToRequestItem(requester: Agent.Context.Self
, customerDue: orderItem.CustomerOrder.DueTime
, remainingDuration: 0
, currentTime: Agent.CurrentTime);
Agent.DebugMessage(msg: $"Start Order");
Agent.Send(DirectoryAgent.Directory.Instruction.Central.ForwardAddOrder.Create(_fArticle,
Agent.ActorPaths.StorageDirectory.Ref));
}
public static int CalculateRequiredQuantity(FArticle fArticle)
{
var quantityMaterials = fArticle.Article.ArticleBoms.Count(x =>
x.ArticleChild.ArticleType.Name == "Material" || x.ArticleChild.ArticleType.Name == "Consumable");
var quantityProducts = fArticle.Article.ArticleBoms.Where(x =>
x.ArticleChild.ArticleType.Name == "Assembly" || x.ArticleChild.ArticleType.Name == "Product")
.Sum(x => x.Quantity);
var quantityAll = quantityMaterials + quantityProducts;
return(Convert.ToInt32(quantityAll));
}
internal FStockReservation MakeReservationFor(FArticle request)
{
var inStock = false;
var quantity = 0;
var time = request.DueTime;
var withdraw = _stockManager.StockExchanges
.Where(predicate: x => x.RequiredOnTime <= request.DueTime &&
x.State != State.Finished &&
x.ExchangeType == ExchangeType.Withdrawal)
.Sum(selector: x => x.Quantity);
// Element is NOT in Stock
// Create Purchase if Required.
var purchaseOpen = _stockManager.StockExchanges
.Any(predicate: x => x.State != State.Finished && x.ExchangeType == ExchangeType.Insert);
var required = ((_stockManager.Current - withdraw - request.Quantity));
if (required < _stockManager.Stock.Min && _stockManager.Article.ToPurchase && !purchaseOpen)
{
var timeToDelivery = CreatePurchase(stockElement: _stockManager.Stock);
time = Agent.CurrentTime + timeToDelivery;
purchaseOpen = true;
Agent.DebugMessage(msg: $"Created purchase for {_stockManager.Article.Name}");
}
// Create Reservation Item
if (required > 0)
{
inStock = true;
quantity = request.Quantity;
//TODO Check Correctness
_stockManager.GetProviderGuidsFor(new Quantity(request.Quantity));
}
var stockReservation = new FStockReservation(quantity: quantity, isPurchased: purchaseOpen, isInStock: inStock, dueTime: time, trackingId: request.StockExchangeId);
//Create Stockexchange for Reservation
_stockManager.StockExchanges.Add(
item: new T_StockExchange
{
TrackingGuid = request.StockExchangeId,
StockId = _stockManager.Id,
ExchangeType = ExchangeType.Withdrawal,
Quantity = request.Quantity,
Time = (int)(Agent.CurrentTime),
State = stockReservation.IsInStock ? State.Finished : State.Created,
RequiredOnTime = (int)request.DueTime,
}
);
return(stockReservation);
}
private void RequestArticle(FArticle requestItem)
{
Agent.DebugMessage(msg: " requests Article " + _stockManager.Name + " from Agent: " + Agent.Sender.Path.Name);
// try to make Reservation
var item = requestItem.UpdateStockExchangeId(i: Guid.NewGuid()).UpdateDispoRequester(r: Agent.Sender);
var stockReservation = MakeReservationFor(request: item);
if (!stockReservation.IsInStock || item.Article.ToBuild)
{
// add to Request queue if not in Stock
_requestedArticles.Add(item: item);
}
// Create Callback
Agent.Send(instruction: Dispo.Instruction.ResponseFromStock.Create(message: stockReservation, target: Agent.Sender));
}
/// <summary>
///
/// </summary>
/// <param name="agent"></param>
/// <param name="fArticle"></param>
public void TryFinishOrder(FArticleProvider fArticleProvider)
{
Agent.DebugMessage(msg: "Ready to Deliver");
//var localItem = Agent.Get<FRequestItem>(REQUEST_ITEM);
_fArticle = _fArticle.UpdateFinishedAt(f: Agent.CurrentTime);
// try to Finish if time has come
if (Agent.CurrentTime >= _fArticle.DueTime)
{
_fArticle = _fArticle.SetProvided;
Agent.DebugMessage(msg: $"Article delivered in time {_fArticle.DueTime == Agent.CurrentTime} {fArticleProvider.ArticleName} {fArticleProvider.ArticleKey} due: {_fArticle.DueTime} current: {Agent.CurrentTime}! ");
Agent.Send(instruction: Dispo.Instruction.WithdrawArticleFromStock.Create(message: fArticleProvider.ArticleKey, target: Agent.Sender));
Agent.Send(instruction: Supervisor.Instruction.OrderProvided.Create(message: _fArticle, target: Agent.ActorPaths.SystemAgent.Ref));
Agent.VirtualChildren.Remove(item: Agent.Sender);
Agent.TryToFinish();
}
}
/// <summary>
///
/// </summary>
/// <param name="agent"></param>
/// <param name="fArticle"></param>
public void TryFinishOrder(FCentralProvideOrder order)
{
Agent.DebugMessage(msg: "Ready to Deliver");
//var localItem = Agent.Get<FRequestItem>(REQUEST_ITEM);
// try to Finish if time has come
if (Agent.CurrentTime >= _fArticle.DueTime)
{
_fArticle = _fArticle.SetProvided
.UpdateFinishedAt(Agent.CurrentTime)
.UpdateProvidedAt(order.MaterialFinishedAt);
Agent.DebugMessage(msg: $"Article delivered in time {_fArticle.DueTime == Agent.CurrentTime} {order.MaterialName} {order.MaterialId} due: {_fArticle.DueTime} current: {Agent.CurrentTime}!");
Agent.Send(instruction: DirectoryAgent.Directory.Instruction.Central.ForwardWithdrawMaterial.Create(new FCentralStockPostings.FCentralStockPosting(order.MaterialId, 1), target: Agent.ActorPaths.StorageDirectory.Ref));
Agent.Send(instruction: Supervisor.Instruction.OrderProvided.Create(message: _fArticle, target: Agent.ActorPaths.SystemAgent.Ref));
Agent.VirtualChildren.Remove(item: Agent.Sender);
Agent.TryToFinish();
}
}
internal void CreateJobsFromArticle(FArticle fArticle)
{
var lastDue = fArticle.DueTime;
var sumOperationDurations = fArticle.RemainingDuration;
var numberOfOperations = fArticle.Article.Operations.Count();
var operationCounter = 0;
foreach (var operation in fArticle.Article.Operations.OrderByDescending(keySelector: x => x.HierarchyNumber))
{
operationCounter++;
var fJob = operation.ToOperationItem(dueTime: lastDue
, customerDue: fArticle.CustomerDue
, productionAgent: Agent.Context.Self
, firstOperation: (operationCounter == numberOfOperations)
, currentTime: Agent.CurrentTime
, remainingWork: sumOperationDurations);
Agent.DebugMessage(
msg:
$"Origin {fArticle.Article.Name} CustomerDue: {fArticle.CustomerDue} remainingDuration: {fArticle.RemainingDuration} Created operation: {operation.Name} | Prio {fJob.Priority.Invoke(Agent.CurrentTime)} | Remaining Work {sumOperationDurations} " +
$"| BackwardStart {fJob.BackwardStart} | BackwardEnd:{fJob.BackwardEnd} Key: {fJob.Key} ArticleKey: {fArticle.Key}" +
$"Precondition test: {operation.Name} | {fJob.StartConditions.PreCondition} ? {operationCounter} == {numberOfOperations} " +
$"| Key: {fJob.Key} ArticleKey: {fArticle.Key}", CustomLogger.SCHEDULING, LogLevel.Warn);
sumOperationDurations += operation.Duration;
lastDue = fJob.BackwardStart - operation.AverageTransitionDuration;
OperationManager.AddOperation(fJob);
// send update to collector
var pub = new FCreateSimulationJob(job: fJob
, jobType: JobType.OPERATION
, customerOrderId: fArticle.CustomerOrderId.ToString()
, isHeadDemand: fArticle.IsHeadDemand
, fArticleKey: fArticle.Key
, fArticleName: fArticle.Article.Name
, productionAgent: this.Agent.Name
, articleType: fArticle.Article.ArticleType.Name
, start: fJob.Start
, end: fJob.End);
Agent.Context.System.EventStream.Publish(@event: pub);
}
_articleToProduce = fArticle;
SetForwardScheduling();
}
public static FArticle ToRequestItem(this M_ArticleBom articleBom, FArticle requestItem, IActorRef requester, long currentTime)
{
return(new FArticle(
key: Guid.NewGuid()
, dueTime: requestItem.DueTime
, creationTime: currentTime
, isProvided: false
, quantity: Convert.ToInt32(value: articleBom.Quantity)
, article: articleBom.ArticleChild
, customerOrderId: requestItem.CustomerOrderId
, isHeadDemand: false
, stockExchangeId: Guid.Empty
, storageAgent: ActorRefs.NoSender
, originRequester: requester
, dispoRequester: ActorRefs.Nobody
, providerList: new List <Guid>()
, finishedAt: 0
));
}
private void ProvideOrder(FArticle finishedArticle)
{
if (finishedArticle.DueTime >= finishedArticle.FinishedAt)
{
Collector.messageHub.SendToAllClients(msg: $"Oder No: {finishedArticle.OriginRequester} finished {finishedArticle.Article.Name} in time at {Collector.Time}");
Collector.messageHub.SendToClient(listener: "orderListener", msg: totalOrders.ToString());
inTime++;
}
else
{
Collector.messageHub.SendToAllClients(msg: $"Oder No: {finishedArticle.OriginRequester} finished {finishedArticle.Article.Name} too late at {Collector.Time}");
toLate++;
}
UpdateOrder(item: finishedArticle);
openOrderParts--;
finishedOrderParts++;
totalOrders++;
}
internal void CreateJobsFromArticle(FArticle fArticle)
{
var lastDue = fArticle.DueTime;
var numberOfOperations = fArticle.Article.Operations.Count();
var operationCounter = 0;
foreach (var operation in fArticle.Article.Operations.OrderByDescending(keySelector: x => x.HierarchyNumber))
{
operationCounter++;
var fJob = operation.ToOperationItem(dueTime: lastDue
, productionAgent: Agent.Context.Self
, firstOperation: (operationCounter == numberOfOperations)
, currentTime: Agent.CurrentTime);
Agent.DebugMessage(
msg:
$"Created operation: {operation.Name} | BackwardStart {fJob.BackwardStart} | BackwardEnd:{fJob.BackwardEnd} Key: {fJob.Key} ArticleKey: {fArticle.Key}");
Agent.DebugMessage(
msg:
$"Precondition test: {operation.Name} | {fJob.StartConditions.PreCondition} ? {operationCounter} == {numberOfOperations} | Key: {fJob.Key} ArticleKey: {fArticle.Key}");
lastDue = fJob.BackwardStart - operation.AverageTransitionDuration;
OperationManager.AddOperation(fJob);
// send update to collector
var pub = new FCreateSimulationWork(operation: fJob
, customerOrderId: fArticle.CustomerOrderId.ToString()
, isHeadDemand: fArticle.IsHeadDemand
, fArticleKey: fArticle.Key
, fArticleName: fArticle.Article.Name
, articleType: fArticle.Article.ArticleType.Name);
Agent.Context.System.EventStream.Publish(@event: pub);
}
_articleToProduce = fArticle;
SetForwardScheduling();
}
public static StartProduction Create(FArticle message, IActorRef target)
{
return(new StartProduction(message: message, target: target));
}
/// <summary>
/// Element to calculate the latest returned forward schedule and provides a check to test if all required schedules for this article are returned.
/// </summary>
/// <param name="fArticle">required Article Type in ArticleBom.Child !</param>
public ForwardScheduleTimeCalculator(FArticle fArticle)
{
RequiredQuantity = CalculateRequiredQuantity(fArticle: fArticle);
}
/// <summary>
/// Check if all required schedules returned
/// </summary>
/// <param name="fArticle"></param>
/// <returns></returns>
internal bool AllRequirementsFullFilled(FArticle fArticle)
{
return(ForwardScheduledEndingTimes.Count == RequiredQuantity);
}
public static RequestArticle Create(FArticle message, IActorRef target)
{
return(new RequestArticle(message: message, target: target));
}
public ArticleProvider(IActorRef provider, FArticle article)
{
Provider = provider;
Article = article;
}
public static AddOrder Create(FArticle message, IActorRef target)
{
return(new AddOrder(message: message, target: target));
}
public static OrderProvided Create(FArticle message, IActorRef target)
{
return(new OrderProvided(message: message, target: target));
}
public static ISimulationMessage Create(FArticle requestItem, IActorRef target, bool logThis)
{
return(new Finish(message: requestItem, target: target, logThis: logThis));
}
private void ForwardAddOrder(FArticle fArticle)
{
var actorRef = StorageManager.GetHubActorRefBy(fArticle.Article.Id.ToString());
Agent.Send(Storage.Instruction.Central.AddOrder.Create(fArticle, actorRef));
}
public void Add(IActorRef dispoRef, FArticle fArticle)
{
DispoToArticleRelation.Add(new ArticleProvider(dispoRef, fArticle));
}
private void AddOrder(FArticle fArticle)
{
_requestedArticles.Add(fArticle);
}
public static FCreateSimulationJob ToSimulationJob(this FOperation fOperation, string jobType, FArticle fArticle, string productionAgent)
{
var simulationJob = new FCreateSimulationJob(
key: fOperation.Key.ToString()
, dueTime: fOperation.DueTime
, articleName: fOperation.Operation.Article.Name
, operationName: fOperation.Operation.Name
, operationHierarchyNumber: fOperation.Operation.HierarchyNumber
, operationDuration: fOperation.Operation.Duration
, requiredCapabilityName: fOperation.Operation.ResourceCapability.Name
, jobType: jobType.ToString()
, customerOrderId: fArticle.CustomerOrderId.ToString()
, isHeadDemand: fArticle.IsHeadDemand
, fArticleKey: fArticle.Key
, fArticleName: fArticle.Article.Name
, productionAgent: productionAgent
, articleType: fArticle.Article.ArticleType.Name
, start: fOperation.Start
, end: fOperation.End
);
return(simulationJob);
}
