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 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);
}
}
/***
* 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 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);
}
/// <summary>
/// Creates providers for the demands through stock, productionOrders or purchases
/// </summary>
/// <param name="demand"></param>
/// <param name="task"></param>
/// <param name="simulationId"></param>
/// <returns>ProductionOrder to fulfill the demand, ProductionOrder is null if there was enough in stock</returns>
public List <ProductionOrder> NetRequirement(IDemandToProvider demand, MrpTask task, int simulationId)
{
//Todo: search for available POs
var stock = _context.Stocks.Include(a => a.DemandStocks)
.Single(a => a.ArticleForeignKey == demand.ArticleId);
var plannedStock = _context.GetPlannedStock(stock, demand);
var productionOrders = new List <ProductionOrder>();
var stockProvider = _context.TryCreateStockReservation(demand);
var time = _context.SimulationConfigurations.Single(a => a.Id == simulationId).Time;
//if the article has no children it has to be purchased
var children = _context.ArticleBoms.Where(a => a.ArticleParentId == demand.ArticleId).ToList();
if (children.Any())
{
//if the plannedStock is below zero, articles have to be produced for its negative amount
if (plannedStock < 0)
{
var fittingProductionOrders = _context.CheckForProductionOrders(demand, -plannedStock, _context.SimulationConfigurations.Single(a => a.Id == simulationId).Time);
var amount = -plannedStock;
if (fittingProductionOrders != null)
{
foreach (var fittingProductionOrder in fittingProductionOrders)
{
var availableAmount = _context.GetAvailableAmountFromProductionOrder(fittingProductionOrder);
var provider = _context.CreateDemandProviderProductionOrder(demand, fittingProductionOrder,
availableAmount < -plannedStock ? availableAmount : -plannedStock);
//productionOrders.Add(fittingProductionOrder);
_context.AssignProductionOrderToDemandProvider(fittingProductionOrder, provider);
amount -= availableAmount < -plannedStock ? availableAmount : -plannedStock;
if (amount == 0)
{
return(productionOrders);
}
}
}
if (amount > 0)
{
var pos = _context.CreateChildProductionOrders(demand, amount, simulationId);
productionOrders.AddRange(pos);
}
}
}
else if (plannedStock < stock.Min)
{
_context.CreatePurchaseDemand(demand, stock.Max - stock.Min, _context.SimulationConfigurations.Single(a => a.Id == simulationId).Time);
}
if (stock.Min <= 0 || plannedStock >= stock.Min || demand.GetType() == typeof(DemandStock))
{
return(productionOrders);
}
if (_context.Demands.OfType <DemandStock>()
.Any(a => a.ArticleId == demand.ArticleId &&
a.State != State.Finished))
{
return(productionOrders);
}
var demandStock = plannedStock < 0 ? _context.CreateStockDemand(demand, stock, stock.Min) : _context.CreateStockDemand(demand, stock, stock.Min - plannedStock);
//call processMrp to plan and schedule the stockDemand
_processMrp.RunRequirementsAndTermination(demandStock, task, simulationId);
return(productionOrders);
}
private bool CheckNeedForward(IDemandToProvider demand, int simulationId)
{
var pows = new List <ProductionOrderWorkSchedule>();
return(demand.GetType() == typeof(DemandStock) || _context.GetWorkSchedulesFromDemand(demand, ref pows).Any(a => a.StartBackward < _context.SimulationConfigurations.Single(b => b.Id == simulationId).Time));
}