/// <summary>
/// Set Start- and Endtime for ProductionOrderWorkSchedules for the given OrderPart excluding capacities in a forward schedule
/// </summary>
/// <param name="demand"></param>
public void ForwardScheduling(IDemandToProvider demand)
{
var productionOrderWorkSchedules = new List <ProductionOrderWorkSchedule>();
_context.GetWorkSchedulesFromDemand(demand, ref productionOrderWorkSchedules);
productionOrderWorkSchedules =
productionOrderWorkSchedules.OrderByDescending(a => a.ProductionOrderId).ThenBy(b => b.HierarchyNumber).ToList();
foreach (var workSchedule in productionOrderWorkSchedules)
{
var hierarchy = -1;
foreach (var schedule in workSchedule.ProductionOrder.ProductionOrderWorkSchedule)
{
if (schedule.HierarchyNumber < workSchedule.HierarchyNumber && schedule.HierarchyNumber > hierarchy)
{
hierarchy = schedule.HierarchyNumber;
}
}
//if no hierarchy has been found
if (hierarchy == -1)
{
workSchedule.StartForward = SetForwardTimeFromChild(workSchedule);
}
else
{
workSchedule.StartForward = _context.ProductionOrderWorkSchedules.AsNoTracking().Single(a =>
(a.HierarchyNumber == hierarchy) &&
(a.ProductionOrderId == workSchedule.ProductionOrderId)).EndForward;
}
workSchedule.EndForward = workSchedule.StartForward + workSchedule.Duration;
_context.ProductionOrderWorkSchedules.Update(workSchedule);
_context.SaveChanges();
}
}
/// <summary>
/// Deepseach thorugh tree to Return all Workschedules Related to one Order.
/// </summary>
/// <param name="demandRequester"></param>
/// <param name="productionOrderWorkSchedule"></param>
/// <returns>List of ProductionOrderWorkSchedules - Attention May Include Dupes Through Complex Backlinks !</returns>
public List <ProductionOrderWorkSchedule> GetWorkSchedulesFromDemand(IDemandToProvider demandRequester, ref List <ProductionOrderWorkSchedule> productionOrderWorkSchedule)
{
foreach (var item in demandRequester.DemandProvider.OfType <DemandProviderProductionOrder>())
{
var productionOrders = ProductionOrders
.Include(x => x.ProductionOrderWorkSchedule)
.ThenInclude(x => x.MachineGroup)
.Include(x => x.ProductionOrderWorkSchedule)
.ThenInclude(x => x.Machine)
.Include(x => x.ProductionOrderBoms)
.ThenInclude(x => x.DemandProductionOrderBoms)
.ThenInclude(x => x.DemandProvider)
.FirstOrDefault(x => x.Id == item.ProductionOrderId);
productionOrderWorkSchedule.AddRange(productionOrders.ProductionOrderWorkSchedule);
foreach (var po in productionOrders.ProductionOrderBoms)
{
foreach (var dpob in po.DemandProductionOrderBoms)
{
GetWorkSchedulesFromDemand(dpob, ref productionOrderWorkSchedule);
}
}
}
return(productionOrderWorkSchedule);
}
private int GetDueTime(IDemandToProvider demand)
{
demand = _context.Demands.Single(a => a.Id == demand.Id);
var latestEnd = 0;
if (demand.State == State.ForwardScheduleExists)
{
/*long version of the below line
* foreach (var provider in demand.DemandProvider)
* {
* if (provider.GetType() == typeof(DemandProviderProductionOrder))
* {
* foreach (var schedule in ((DemandProviderProductionOrder)provider).ProductionOrder.ProductionOrderWorkSchedule)
* {
* if (schedule.EndForward > latestEnd) latestEnd = schedule.EndForward;
* }
*
* }
* }*/
latestEnd = (from provider in demand.DemandProvider where provider.GetType() == typeof(DemandProviderProductionOrder)
from schedule in ((DemandProviderProductionOrder)provider).ProductionOrder.ProductionOrderWorkSchedule
select schedule.EndForward).Concat(new[] { latestEnd }).Max();
return(latestEnd);
}
demand = _context.Demands.AsNoTracking().Include(a => a.DemandRequester).Single(a => a.Id == demand.Id);
if (demand.DemandRequesterId != null && demand.DemandRequester.GetType() == typeof(DemandOrderPart))
{
return(_context.OrderParts.Include(a => a.Order).Single(a => a.Id == ((DemandOrderPart)demand.DemandRequester).OrderPartId).Order.DueTime);
}
if (demand.DemandRequesterId == null && demand.GetType() == typeof(DemandOrderPart))
{
return(_context.OrderParts.Include(a => a.Order).Single(a => a.Id == ((DemandOrderPart)demand).OrderPartId).Order.DueTime);
}
return(999999);
}
public PurchasePart CreatePurchase(IDemandToProvider demand, decimal amount)
{
var articleToPurchase = ArticleToBusinessPartners.Single(a => a.ArticleId == demand.ArticleId);
var purchase = new Purchase()
{
BusinessPartnerId = articleToPurchase.BusinessPartnerId,
DueTime = articleToPurchase.DueTime,
};
//amount to be purchased has to be raised to fit the packsize
amount = Math.Ceiling(amount / articleToPurchase.PackSize) * articleToPurchase.PackSize;
var purchasePart = new PurchasePart()
{
ArticleId = demand.ArticleId,
Quantity = (int)amount,
DemandProviderPurchaseParts = new List <DemandProviderPurchasePart>(),
PurchaseId = purchase.Id,
};
purchase.PurchaseParts = new List <PurchasePart>()
{
purchasePart
};
Purchases.Add(purchase);
PurchaseParts.Add(purchasePart);
SaveChanges();
return(purchasePart);
}
private void SatisfyRequest(IDemandToProvider demand, int simulationId, ProductionDomainContext evaluationContext)
{
var amount = demand.Quantity;
//if anything is in stock, create demand
amount = TryAssignStockReservation(demand, amount);
if (amount == 0)
{
return;
}
//search for purchase
amount = TryAssignPurchase(demand, amount);
if (amount == 0)
{
return;
}
//find matching productionOrders
amount = TryFindProductionOrders(demand, amount);
if (amount != 0)
{
SaveContext(evaluationContext);
amount = TryAssignStockReservation(demand, amount);
amount = TryAssignPurchase(demand, amount);
amount = TryFindProductionOrders(demand, amount);
throw new NotSupportedException("logical error: still unsatisfied Requests!");
}
foreach (var dppo in demand.DemandProvider.OfType <DemandProviderProductionOrder>())
{
CallChildrenSatisfyRequest(dppo.ProductionOrder, simulationId, evaluationContext);
}
}
//Todo: check logic
public void CreatePurchaseDemand(IDemandToProvider demand, decimal amount, int time)
{
if (NeedToRefill(demand, amount))
{
var providerPurchasePart = new DemandProviderPurchasePart()
{
Quantity = amount,
ArticleId = demand.ArticleId,
DemandRequesterId = demand.Id,
State = State.Created,
};
Demands.Add(providerPurchasePart);
CreatePurchase(demand, amount, providerPurchasePart, time);
Demands.Update(providerPurchasePart);
}
else
{
var providerStock = new DemandProviderStock()
{
Quantity = amount,
ArticleId = demand.ArticleId,
DemandRequesterId = demand.Id,
State = State.Created,
StockId = Stocks.Single(a => a.ArticleForeignKey == demand.ArticleId).Id
};
Demands.Add(providerStock);
}
SaveChanges();
}
/// <summary>
/// Run requirements planning and backward/forward termination.
/// </summary>
/// <param name="demand"></param>
/// <param name="task"></param>
/// <param name="simulationId"></param>
public void RunRequirementsAndTermination(IDemandToProvider demand, MrpTask task, int simulationId)
{
if (demand.State == State.Created)
{
ExecutePlanning(demand, task, simulationId);
if (demand.State != State.Finished)
{
demand.State = State.ProviderExist;
}
_context.Update(demand);
_context.SaveChanges();
_messageHub.SendToAllClients("Requirements planning completed.");
}
if (task == MrpTask.All || task == MrpTask.Backward)
{
_scheduling.BackwardScheduling(demand);
demand.State = State.BackwardScheduleExists;
_context.Update(demand);
_context.SaveChanges();
_messageHub.SendToAllClients("Backward schedule exists.");
}
if (task == MrpTask.All && CheckNeedForward(demand, simulationId) || task == MrpTask.Forward)
{
//schedules forward and then backward again with the finish of the forward algorithm
_scheduling.ForwardScheduling(demand);
demand.State = State.ForwardScheduleExists;
_context.Update(demand);
_context.SaveChanges();
_scheduling.BackwardScheduling(demand);
_messageHub.SendToAllClients("Forward schedule exists.");
}
_context.SaveChanges();
}
private void SetStartEndFromTermination(IDemandToProvider demand)
{ //Todo: replace provider.first()
var schedules = _context.ProductionOrderWorkSchedules
.Include(a => a.ProductionOrder)
.ThenInclude(a => a.DemandProviderProductionOrders)
.ThenInclude(a => a.DemandRequester)
.Where(a => a.ProductionOrder.DemandProviderProductionOrders.First().DemandRequester.DemandRequesterId == demand.Id ||
a.ProductionOrder.DemandProviderProductionOrders.First().DemandRequesterId == demand.Id)
.ToList();
foreach (var schedule in schedules)
{
//if forward was calculated take forward, else take from backward termination
if (schedule.EndForward - schedule.StartForward > 0)
{
schedule.End = schedule.EndForward;
schedule.Start = schedule.StartForward;
}
else
{
schedule.End = schedule.EndBackward;
schedule.Start = schedule.StartBackward;
}
_context.ProductionOrderWorkSchedules.Update(schedule);
_context.SaveChanges();
}
}
public bool NeedToRefill(IDemandToProvider demand, decimal amount)
{
var purchasedAmount = GetAmountBought(demand.ArticleId);
var neededAmount = GetReserved(demand.ArticleId);
var stockMin = Stocks.Single(a => a.ArticleForeignKey == demand.ArticleId).Min;
return(purchasedAmount - neededAmount - amount < stockMin);
}
private int GetActivitySlack(IDemandToProvider demandRequester, int simulationId)
{
var dueTime = 999999;
if (demandRequester.DemandProvider != null)
{
dueTime = _context.GetDueTimeByOrder((DemandToProvider)demandRequester);
}
return(dueTime - _context.SimulationConfigurations.Single(a => a.Id == simulationId).Time);
}
public void AssignProviderToDemand(IDemandToProvider demand, DemandToProvider provider)
{
if (demand.DemandProvider == null)
{
demand.DemandProvider = new List <DemandToProvider>();
}
demand.DemandProvider.Add(provider);
Update(demand);
SaveChanges();
}
/// <summary>
/// Set Start- and Endtime for ProductionOrderWorkSchedules for the given OrderPart excluding capacities in a backward schedule
/// </summary>
/// <param name="demand"></param>
public void BackwardScheduling(IDemandToProvider demand)
{
var productionOrderWorkSchedules = new List <ProductionOrderWorkSchedule>();
_context.GetWorkSchedulesFromDemand(demand, ref productionOrderWorkSchedules);
productionOrderWorkSchedules = productionOrderWorkSchedules.OrderBy(a => a.ProductionOrderId).ThenByDescending(b => b.HierarchyNumber).ToList();
foreach (var workSchedule in productionOrderWorkSchedules)
{
// set transition time relating to machine group.
var transitionTime = Calculations.GetTransitionTimeForWorkSchedule(workSchedule);
//Set hierarchy to something high that every workSchedule found will overwrite this value
var hierarchyParent = _context.GetHierarchyParent(workSchedule);
//if no hierarchy has been found
if (hierarchyParent == null)
{
if (demand.State == State.ForwardScheduleExists)
{
workSchedule.EndForward = SetBackwardTimeFromParent(workSchedule, demand.State);
}
else
{
workSchedule.EndBackward = SetBackwardTimeFromParent(workSchedule, demand.State);
}
}
else
{
if (demand.State == State.ForwardScheduleExists)
{
workSchedule.EndForward = _context.ProductionOrderWorkSchedules.Single(a =>
(a.HierarchyNumber == hierarchyParent.HierarchyNumber) &&
(a.ProductionOrderId == workSchedule.ProductionOrderId)).StartForward;
}
else
{
workSchedule.EndBackward = _context.ProductionOrderWorkSchedules.Single(a =>
(a.HierarchyNumber == hierarchyParent.HierarchyNumber) &&
(a.ProductionOrderId == workSchedule.ProductionOrderId)).StartBackward;
}
}
if (demand.State == State.ForwardScheduleExists)
{
workSchedule.StartForward = workSchedule.EndForward - workSchedule.Duration - transitionTime;
workSchedule.EndForward = workSchedule.StartForward + workSchedule.Duration;
}
else
{
workSchedule.StartBackward = workSchedule.EndBackward - workSchedule.Duration - transitionTime;
workSchedule.EndBackward = workSchedule.StartBackward + workSchedule.Duration;
}
}
_context.ProductionOrderWorkSchedules.UpdateRange(productionOrderWorkSchedules);
_context.SaveChanges();
}
private int CopyDemandsAndPows(IDemandToProvider dop, TimeTable <ISimulationItem> timetable, int simulationId, int simulationNumber)
{
var providerlist = dop.DemandProvider.OfType <DemandProviderProductionOrder>().ToList();
var counter = 0;
while (providerlist.Any())
{
var provider = providerlist.First();
foreach (var pob in provider.ProductionOrder.ProductionOrderBoms.ToList())
{
foreach (var dpob in pob.DemandProductionOrderBoms.ToList())
{
CopyDemandsAndPows(dpob, timetable, simulationId, simulationNumber);
}
if (!pob.DemandProductionOrderBoms.Any())
{
_context.ProductionOrderBoms.Remove(pob);
}
}
provider = _context.Demands.OfType <DemandProviderProductionOrder>().Single(a => a.Id == provider.Id);
if (provider.ProductionOrder.DemandProviderProductionOrders.Any(a => a.Id != provider.Id))
{
_context.Demands.Remove(_context.Demands.Single(a => a.Id == provider.Id));
var po = _context.ProductionOrders.Single(a => a.Id == provider.ProductionOrderId);
po.DemandProviderProductionOrders.Remove(provider);
_context.Update(po);
}
else
{
var items = new List <PowsSimulationItem>();
foreach (var schedule in provider.ProductionOrder.ProductionOrderWorkSchedule.ToList())
{
_context.ProductionOrderWorkSchedules.Remove(schedule);
var itemList = timetable.Items.OfType <PowsSimulationItem>()
.Where(a => a.ProductionOrderWorkScheduleId == schedule.Id).ToList();
if (!itemList.Any())
{
continue;
}
items.Add(itemList.First());
timetable.Items.Remove(itemList.First());
counter++;
}
FillSimulationWorkSchedules(items, simulationId, simulationNumber, 0);
_context.ProductionOrders.Remove(provider.ProductionOrder);
_context.Demands.Remove(provider);
_context.Demands.Remove(provider.DemandRequester);
}
_context.SaveChanges();
providerlist.RemoveAt(0);
}
return(counter);
}
public ProductionOrder CreateProductionOrder(IDemandToProvider demand, int duetime, int simulationId)
{
var productionOrder = new ProductionOrder()
{
ArticleId = demand.Article.Id,
Quantity = SimulationConfigurations.Single(a => a.Id == simulationId).Lotsize,
Duetime = duetime
};
ProductionOrders.Add(productionOrder);
SaveChanges();
return(productionOrder);
}
public DemandProviderProductionOrder CreateProviderProductionOrder(IDemandToProvider demand, ProductionOrder productionOrder, decimal amount)
{
var dppo = new DemandProviderProductionOrder()
{
ArticleId = demand.ArticleId,
Quantity = amount,
ProductionOrderId = productionOrder.Id,
DemandRequesterId = demand.DemandRequesterId,
};
Add(dppo);
SaveChanges();
return(dppo);
}
public DemandProviderPurchasePart CreateDemandProviderPurchasePart(IDemandToProvider demand, PurchasePart purchase, decimal amount)
{
var dppp = new DemandProviderPurchasePart()
{
ArticleId = demand.ArticleId,
Quantity = amount,
PurchasePartId = purchase.Id,
DemandRequesterId = demand.Id,
};
Add(dppp);
SaveChanges();
return(dppp);
}
public DemandProviderStock CreateDemandProviderStock(IDemandToProvider demand, decimal amount)
{
var dps = new DemandProviderStock()
{
ArticleId = demand.ArticleId,
Quantity = amount,
StockId = Stocks.Single(a => a.ArticleForeignKey == demand.ArticleId).Id,
DemandRequesterId = demand.Id,
State = State.Created
};
Add(dps);
SaveChanges();
return(dps);
}
private decimal TryAssignPurchase(IDemandToProvider demand, decimal amount)
{
var purchaseParts = _context.PurchaseParts.Where(a => a.State != State.Finished && a.ArticleId == demand.ArticleId).ToList();
var amountAlreadyReserved = purchaseParts.Select(a => a.DemandProviderPurchaseParts.Sum(b => b.Quantity)).Sum();
var amountReservable = purchaseParts.Select(a => a.Quantity).Sum() - amountAlreadyReserved;
if (amountReservable == 0)
{
return(amount);
}
var amountReserving = amountReservable > amount ? amount : amountReservable;
_context.CreateDemandProviderStock(demand, amountReserving);
amount -= amountReserving;
return(amount);
}
private decimal TryAssignStockReservation(IDemandToProvider demand, decimal amount)
{
var articleStock = _context.Stocks.AsNoTracking().Single(a => a.ArticleForeignKey == demand.ArticleId).Current;
if (articleStock <= 0)
{
return(amount);
}
var provider = _context.TryCreateStockReservation(demand);
if (provider != null)
{
amount -= provider.Quantity;
}
return(amount);
}
public DemandStock CreateStockDemand(IDemandToProvider demand, Stock stock, decimal amount)
{
var demandStock = new DemandStock()
{
Quantity = amount,
Article = demand.Article,
ArticleId = demand.ArticleId,
State = State.Created,
DemandProvider = new List <DemandToProvider>(),
StockId = stock.Id,
};
Demands.Add(demandStock);
SaveChanges();
return(demandStock);
}
public void ExecutePlanning(IDemandToProvider demand, MrpTask task, int simulationId)
{
//creates Provider for the needs
var productionOrders = _demandForecast.NetRequirement(demand, task, simulationId);
if (demand.State != State.Finished)
{
demand.State = State.ProviderExist;
}
var articleBoms = _context.ArticleBoms
.Include(a => a.ArticleChild)
.ThenInclude(a => a.ArticleBoms)
.ToList();
//If there was enough in stock this does not have to be produced
if (!productionOrders.Any())
{
return;
}
foreach (var productionOrder in productionOrders)
{
//if the ProductionOrder was just created, initialize concrete WorkSchedules for the ProductionOrders
if (productionOrder.ProductionOrderWorkSchedule == null ||
!productionOrder.ProductionOrderWorkSchedule.Any())
{
_context.CreateProductionOrderWorkSchedules(productionOrder);
}
var children = articleBoms.Where(a => a.ArticleParentId == productionOrder.ArticleId)
.ToList();
if (!children.Any())
{
return;
}
foreach (var child in children)
{
//create Requester
var dpob = _context.CreateDemandProductionOrderBom(child.ArticleChildId, productionOrder.Quantity * (int)child.Quantity);
//create Production-BOM
_context.TryCreateProductionOrderBoms(dpob, productionOrder, simulationId);
//call this method recursively for a depth-first search
ExecutePlanning(dpob, task, simulationId);
}
}
}
public List <ProductionOrder> CheckForProductionOrders(IDemandToProvider demand, decimal amount, int timer)
{
var possibleProductionOrders = new List <ProductionOrder>();
var perfectFittingProductionOrders = new List <ProductionOrder>();
var pos = ProductionOrders.Include(b => b.ProductionOrderWorkSchedule)
.Include(a => a.DemandProviderProductionOrders)
.Where(a => a.ArticleId == demand.ArticleId &&
(GetLatestEndFromProductionOrder(a) == null ||
GetLatestEndFromProductionOrder(a) == 0 ||
GetLatestEndFromProductionOrder(a) >= timer)).ToList();
foreach (var po in pos)
{
var availableAmount = GetAvailableAmountFromProductionOrder(po);
if (availableAmount == amount)
{
perfectFittingProductionOrders.Add(po);
}
else if (availableAmount > 0)
{
possibleProductionOrders.Add(po);
}
}
if (!possibleProductionOrders.Any())
{
return(null);
}
if (perfectFittingProductionOrders.Any())
{
return new List <ProductionOrder>()
{
GetEarliestProductionOrder(perfectFittingProductionOrders)
}
}
;
var list = new List <ProductionOrder>();
while (amount > 0 && possibleProductionOrders.Any())
{
list.Add(GetEarliestProductionOrder(possibleProductionOrders));
possibleProductionOrders.Remove(list.Last());
amount -= GetAvailableAmountFromProductionOrder(list.Last());
}
return(list);
}
/***
* Requirements
* */
/*
* /// <summary>
* /// Creates stock reservation if possible
* /// </summary>
* /// <param name="stock"></param>
* /// <param name="demand"></param>
* public void TryCreateStockReservation(Stock stock, IDemandToProvider demand)
* {
* var stockReservations = GetReserved(demand.ArticleId);
* var bought = GetAmountBought(demand.ArticleId);
* //get the current amount of free available articles
* var current = stock.Current + bought - stockReservations;
* decimal quantity;
* //either reserve all that are in stock or the amount needed
* quantity = demand.Quantity > current ? current : demand.Quantity;
* if (quantity == 0) return;
* var demandProviderStock = new DemandProviderStock()
* {
* ArticleId = stock.ArticleForeignKey,
* Quantity = quantity,
* DemandRequesterId = demand.DemandRequesterId ?? demand.Id,
* StockId = stock.Id
* };
* Demands.Add(demandProviderStock);
* SaveChanges();
* }*/
public List <ProductionOrder> CreateChildProductionOrders(IDemandToProvider demand, decimal amount, int simulationId)
{
ProductionOrderBom bom = null;
if (demand.GetType() == typeof(DemandProductionOrderBom))
{
bom = ProductionOrderBoms.FirstOrDefault(a => a.Id == ((DemandProductionOrderBom)demand).ProductionOrderBomId);
}
var lotsize = SimulationConfigurations.Single(a => a.Id == simulationId).Lotsize;
var productionOrders = new List <ProductionOrder>();
/*decimal bomQuantity;
* if (bom != null)
* bomQuantity = ArticleBoms.AsNoTracking().Single(a => a.ArticleChildId == demand.ArticleId &&
* a.ArticleParentId == bom.ProductionOrderParent.ArticleId).Quantity * lotsize;
* else
* bomQuantity = ArticleBoms.AsNoTracking().Single(a =>a.ArticleChildId == demand.ArticleId &&
* a.ArticleParentId == null).Quantity * lotsize;
*/
while (amount > 0)// || bomQuantity > 0)
{
var productionOrder = CreateProductionOrder(demand, GetDueTimeByOrder(demand), simulationId);
if (amount > 0)
{
var demandProviderProductionOrder = CreateDemandProviderProductionOrder(demand, productionOrder,
amount > lotsize ? lotsize : amount);
//if the article has a parent create a relationship
if (bom != null)
{
demandProviderProductionOrder.DemandRequesterId = demand.Id;
Demands.Update(demandProviderProductionOrder);
}
}
SaveChanges();
amount -= lotsize;
//bomQuantity -= lotsize;
productionOrders.Add(productionOrder);
}
return(productionOrders);
}
public DemandProviderStock TryCreateStockReservation(IDemandToProvider demand)
{
var stock = Stocks.Single(a => a.ArticleForeignKey == demand.ArticleId);
var stockReservations = GetReserved(demand.ArticleId);
var bought = GetAmountBought(demand.ArticleId);
var justProduced = Demands.OfType <DemandProductionOrderBom>()
.Where(a => (a.State != State.Finished || a.ProductionOrderBom.ProductionOrderParent.ProductionOrderWorkSchedule.All(b => b.ProducingState == ProducingState.Created || b.ProducingState == ProducingState.Waiting)) &&
a.ArticleId == demand.ArticleId &&
a.DemandProvider.Any() &&
a.DemandProvider.All(b => b.State == State.Finished)).Sum(a => a.Quantity);
//get the current amount of free available articles
var current = stock.Current + bought - stockReservations - justProduced;
decimal quantity;
//either reserve all that are in stock or the amount needed
quantity = demand.Quantity > current ? current : demand.Quantity;
return(quantity <= 0 ? null : CreateDemandProviderStock(demand, quantity));
}
public DemandProviderProductionOrder CreateDemandProviderProductionOrder(IDemandToProvider demand, ProductionOrder productionOrder, decimal amount)
{
var demandProviderProductionOrder = new DemandProviderProductionOrder()
{
Quantity = amount,
Article = demand.Article,
ArticleId = demand.ArticleId,
ProductionOrderId = productionOrder.Id,
DemandRequesterId = demand.Id
};
Demands.Add(demandProviderProductionOrder);
if (productionOrder.DemandProviderProductionOrders == null)
{
productionOrder.DemandProviderProductionOrders = new List <DemandProviderProductionOrder>();
}
productionOrder.DemandProviderProductionOrders.Add(demandProviderProductionOrder);
SaveChanges();
return(demandProviderProductionOrder);
}
public decimal GetPlannedStock(Stock stock, IDemandToProvider demand)
{
var amountReserved = GetReserved(demand.ArticleId);
var amountBought = 0;
var articlesBought = PurchaseParts.Where(a => a.ArticleId == demand.ArticleId && a.State != State.Finished);
foreach (var articleBought in articlesBought)
{
amountBought += articleBought.Quantity;
}
//just produced articles have a reason and parents they got produced for so they cannot be reserved by another requester
var amountJustProduced = Demands.OfType <DemandProductionOrderBom>()
.Where(a => (a.State != State.Finished || a.ProductionOrderBom.ProductionOrderParent.ProductionOrderWorkSchedule.All(b => b.ProducingState == ProducingState.Created || b.ProducingState == ProducingState.Waiting)) &&
a.ArticleId == demand.ArticleId &&
a.DemandProvider.Any() &&
a.DemandProvider.All(b => b.State == State.Finished)).Sum(a => a.Quantity);
//plannedStock is the amount of this article in stock after taking out the amount needed
var plannedStock = stock.Current + amountBought - demand.Quantity - amountReserved - amountJustProduced;
return(plannedStock);
}
public ProductionOrderBom TryCreateProductionOrderBoms(IDemandToProvider demand, ProductionOrder parentProductionOrder, int simulationId)
{
if (parentProductionOrder == null)
{
return(null);
}
var lotsize = SimulationConfigurations.Single(a => a.Id == simulationId).Lotsize;
var quantity = demand.Quantity > lotsize ? lotsize : demand.Quantity;
var pob = new ProductionOrderBom()
{
Quantity = quantity,
ProductionOrderParentId = parentProductionOrder.Id
};
Add(pob);
SaveChanges();
if (demand.GetType() == typeof(DemandProductionOrderBom))
{
AssignDemandProviderToProductionOrderBom((DemandProductionOrderBom)demand, pob);
}
return(pob);
}
private decimal TryFindProductionOrders(IDemandToProvider demand, decimal amount)
{
var possibleMatchingProductionOrders = _context.ProductionOrders.Where(a => a.ArticleId == demand.ArticleId && a.ProductionOrderWorkSchedule.Any(b => b.ProducingState != ProducingState.Finished)).ToList();
while (amount > 0 && possibleMatchingProductionOrders.Any())
{
var earliestProductionOrder = _context.GetEarliestProductionOrder(possibleMatchingProductionOrders);
var availableAmountFromProductionOrder = _context.GetAvailableAmountFromProductionOrder(earliestProductionOrder);
if (availableAmountFromProductionOrder == 0)
{
possibleMatchingProductionOrders.Remove(possibleMatchingProductionOrders.Find(a => a.Id == earliestProductionOrder.Id));
continue;
}
var provider = _context.CreateProviderProductionOrder(demand, earliestProductionOrder, amount >= availableAmountFromProductionOrder ? availableAmountFromProductionOrder : amount);
var duetime = _context.GetDueTimeByOrder(demand);
if (provider.ProductionOrder.DemandProviderProductionOrders.Count == 1)
{
provider.ProductionOrder.Duetime = duetime;
}
else if (provider.ProductionOrder.Duetime > duetime)
{
provider.ProductionOrder.Duetime = duetime;
}
_context.AssignProviderToDemand(demand, provider);
_context.AssignProductionOrderToDemandProvider(earliestProductionOrder, provider);
if (amount > availableAmountFromProductionOrder)
{
amount -= availableAmountFromProductionOrder;
}
else
{
amount = 0;
}
possibleMatchingProductionOrders.ToList().Remove(earliestProductionOrder);
}
return(amount);
}
public int GetDueTimeByOrder(IDemandToProvider demand)
{
if (demand.GetType() == typeof(DemandOrderPart))
{
demand = Demands.OfType <DemandOrderPart>().Include(a => a.OrderPart).ThenInclude(b => b.Order).ToList().Single(a => a.Id == demand.Id);
return(((DemandOrderPart)demand).OrderPart.Order.DueTime);
}
if (demand.GetType() == typeof(DemandStock))
{
return(int.MaxValue);
}
if (demand.GetType() != typeof(DemandProductionOrderBom))
{
return(int.MaxValue);
}
{
demand =
Demands.AsNoTracking().OfType <DemandProductionOrderBom>()
.Include(a => a.ProductionOrderBom)
.ThenInclude(b => b.ProductionOrderParent)
.Single(c => c.Id == demand.Id);
return(((DemandProductionOrderBom)demand).ProductionOrderBom.ProductionOrderParent.Duetime);
}
}
public bool HasChildren(IDemandToProvider demand)
{
return(ArticleBoms.Any(a => a.ArticleParentId == demand.ArticleId));
}
