/**
* SE:I --> satisfy by orders PuOP
*/
public EntityCollector Satisfy(Demand demand, Quantity demandedQuantity)
{
EntityCollector entityCollector = new EntityCollector();
M_Article article = demand.GetArticle();
DueTime dueTime = demand.GetStartTimeBackward();
if (article.ToBuild)
{
throw new MrpRunException(
"You try to create a purchaseOrderPart for a articleToBuild.");
}
// currently only one businessPartner per article TODO: This could be changing
M_ArticleToBusinessPartner articleToBusinessPartner =
_dbMasterDataCache.M_ArticleToBusinessPartnerGetAllByArticleId(article.GetId())[0];
M_BusinessPartner businessPartner =
_dbMasterDataCache.M_BusinessPartnerGetById(new Id(articleToBusinessPartner
.BusinessPartnerId));
T_PurchaseOrder purchaseOrder = new T_PurchaseOrder();
// [Name],[DueTime],[BusinessPartnerId]
purchaseOrder.DueTime = dueTime.GetValue();
purchaseOrder.BusinessPartner = businessPartner;
purchaseOrder.Name = $"PurchaseOrder{article.Name} for " +
$"businessPartner {purchaseOrder.BusinessPartner.Id}";
// init a new purchaseOderPart
T_PurchaseOrderPart tPurchaseOrderPart = new T_PurchaseOrderPart();
// [PurchaseOrderId],[ArticleId],[Quantity],[State],[ProviderId]
tPurchaseOrderPart.PurchaseOrder = purchaseOrder;
tPurchaseOrderPart.PurchaseOrderId = purchaseOrder.Id;
tPurchaseOrderPart.Article = article;
tPurchaseOrderPart.ArticleId = article.Id;
tPurchaseOrderPart.Quantity =
CalculateQuantity(articleToBusinessPartner, demandedQuantity) *
articleToBusinessPartner
.PackSize;
if (tPurchaseOrderPart.Quantity < demandedQuantity.GetValue())
{
throw new MrpRunException("You cannot purchase less than you need!");
}
tPurchaseOrderPart.State = State.Created;
PurchaseOrderPart purchaseOrderPart =
new PurchaseOrderPart(tPurchaseOrderPart, null);
T_DemandToProvider demandToProvider = new T_DemandToProvider()
{
DemandId = demand.GetId().GetValue(),
ProviderId = purchaseOrderPart.GetId().GetValue(),
Quantity = demandedQuantity.GetValue()
};
entityCollector.Add(purchaseOrderPart);
entityCollector.Add(demandToProvider);
return(entityCollector);
}
public override void Remove(Demand t)
{
ProductionOrderBom productionOrderBom = (ProductionOrderBom)t;
Id operationId = productionOrderBom.GetProductionOrderOperationId();
_operationToBom[operationId].Remove(t.GetId());
base.Remove(t);
}
/**
* COP or PrOB --> satisfy by SE:W
*/
public EntityCollector Satisfy(Demand demand, Quantity demandedQuantity)
{
EntityCollector entityCollector = new EntityCollector();
Provider stockProvider = CreateStockExchangeProvider(demand.GetArticle(),
demand.GetStartTimeBackward(), demandedQuantity);
entityCollector.Add(stockProvider);
T_DemandToProvider demandToProvider =
new T_DemandToProvider(demand.GetId(), stockProvider.GetId(), demandedQuantity);
entityCollector.Add(demandToProvider);
return(entityCollector);
}
/**
* DemandToProvider
*/
public List <ILinkDemandAndProvider> GetArrowsFrom(Demand demand)
{
if (_dbTransactionData.DemandToProviderGetAll().Contains(demand) == false)
{
return(null);
}
List <ILinkDemandAndProvider> demandToProviders = new List <ILinkDemandAndProvider>();
Ids ids = _dbTransactionData.DemandToProviderGetAll().GetByDemandId(demand.GetId());
foreach (var id in ids)
{
demandToProviders.Add(_dbTransactionData.DemandToProviderGetById(id));
}
return(demandToProviders);
}
public void AddDemand(Demand oneDemand, Quantity reservedQuantity)
{
if (_demands.GetDemandById(oneDemand.GetId()) != null)
{
throw new MrpRunException("You cannot add an already added demand.");
}
// if it has quantity that is not reserved, remember it for later reserving
if (oneDemand.GetType() == typeof(StockExchangeDemand) &&
reservedQuantity.IsSmallerThan(oneDemand.GetQuantity()))
{
_openDemands.Add(oneDemand.GetArticle(),
new OpenNode <Demand>(oneDemand, oneDemand.GetQuantity().Minus(reservedQuantity),
oneDemand.GetArticle()));
}
// save demand
_demands.Add(oneDemand);
}
/**
* SE:I --> satisfy by orders PrOBom
*/
public EntityCollector Satisfy(Demand demand, Quantity demandedQuantity)
{
if (demand.GetArticle().ToBuild == false)
{
throw new MrpRunException("Must be a build article.");
}
EntityCollector entityCollector = CreateProductionOrder(demand, demandedQuantity);
foreach (var provider in entityCollector.GetProviders())
{
T_DemandToProvider demandToProvider = new T_DemandToProvider()
{
DemandId = demand.GetId().GetValue(),
ProviderId = provider.GetId().GetValue(),
Quantity = provider.GetQuantity().GetValue()
};
entityCollector.Add(demandToProvider);
}
return(entityCollector);
}
private string ToGraphizString(Demand demand)
{
return($"\\n{demand.GetId()}: {demand.GetArticle().Name};Anzahl: {demand.GetQuantity()};"
+ $"\\nStart/End: {demand.GetStartTimeBackward()}/{demand.GetEndTimeBackward()};"
);
}
public Quantity SumReservedQuantity(Demand demand)
{
return(SumReservedQuantity(
_demandToProviderTable.Where(x => x.GetDemandId().Equals(demand.GetId()))));
}
public EntityCollector CreateDependingDemands(Provider provider)
{
if (provider.GetQuantity().IsNull())
{
return(null);
}
if (provider.GetType() != typeof(StockExchangeProvider))
{
throw new MrpRunException("This can only be called for StockExchangeProviders");
}
// try to provide by existing demand
// collects stockExchangeDemands, providerToDemands
EntityCollector entityCollector =
_openDemandManager.SatisfyProviderByOpenDemand(provider, provider.GetQuantity());
if (entityCollector == null)
{
entityCollector = new EntityCollector();
}
Quantity remainingQuantity = entityCollector.GetRemainingQuantity(provider);
if (remainingQuantity.IsGreaterThan(Quantity.Zero()))
{
LotSize.Impl.LotSize lotSizes =
new LotSize.Impl.LotSize(remainingQuantity, provider.GetArticleId());
bool isLastIteration = false;
foreach (var lotSize in lotSizes.GetLotSizes())
{
if (isLastIteration || remainingQuantity.IsNegative() ||
remainingQuantity.IsNull())
{
throw new MrpRunException("This is one iteration too many.");
}
Demand stockExchangeDemand =
StockExchangeDemand.CreateStockExchangeStockDemand(provider.GetArticleId(),
provider.GetStartTimeBackward(), lotSize);
entityCollector.Add(stockExchangeDemand);
// 3 cases
Quantity quantityOfNewCreatedDemandToReserve;
if (remainingQuantity.IsGreaterThan(lotSize))
{
quantityOfNewCreatedDemandToReserve = lotSize;
}
else if (remainingQuantity.Equals(lotSize))
{
// last iteration
isLastIteration = true;
quantityOfNewCreatedDemandToReserve = lotSize;
}
else
{
// last iteration, remaining < lotsize
isLastIteration = true;
quantityOfNewCreatedDemandToReserve = new Quantity(remainingQuantity);
// remember created demand as openDemand
_openDemandManager.AddDemand(stockExchangeDemand,
quantityOfNewCreatedDemandToReserve);
}
remainingQuantity.DecrementBy(lotSize);
if (quantityOfNewCreatedDemandToReserve.IsNegative() ||
quantityOfNewCreatedDemandToReserve.IsNull())
{
throw new MrpRunException(
$"quantityOfNewCreatedDemandToReserve cannot be negative or null: " +
$"{quantityOfNewCreatedDemandToReserve}");
}
T_ProviderToDemand providerToDemand = new T_ProviderToDemand(provider.GetId(),
stockExchangeDemand.GetId(), quantityOfNewCreatedDemandToReserve);
entityCollector.Add(providerToDemand);
}
}
return(entityCollector);
}
public bool Contains(Demand demand)
{
return(_openNodes[demand.GetArticle()].Contains(demand.GetId()));
}
public void Remove(Demand demand)
{
_openNodes[demand.GetArticle()].RemoveById(demand.GetId());
}
/**
* ProviderToDemand
*/
public Providers GetAllParentProvidersOf(Demand demand)
{
Providers providers = new Providers();
Ids ids = _dbTransactionData.ProviderToDemandGetAll().GetByDemandId(demand.GetId());
foreach (var id in ids)
{
T_ProviderToDemand providerToDemand =
_dbTransactionData.ProviderToDemandGetById(id);
providers.Add(
_dbTransactionData.ProvidersGetById(providerToDemand.GetProviderId()));
}
return(providers);
}
/**
* DemandToProvider
*/
public Providers GetAllChildProvidersOf(Demand demand)
{
Providers providers = new Providers();
Ids ids = _dbTransactionData.DemandToProviderGetAll().GetByDemandId(demand.GetId());
if (ids == null)
{
return(null);
}
foreach (var id in ids)
{
T_DemandToProvider demandToProvider =
_dbTransactionData.DemandToProviderGetById(id);
providers.Add(
_dbTransactionData.ProvidersGetById(demandToProvider.GetProviderId()));
}
return(providers);
}
public bool Contains(Demand demand)
{
return(_indexDemandId.ContainsKey(demand.GetId()));
}
