private void VerifyQuantities(IDbTransactionData dbTransactionData, bool isArchive)
{
foreach (var demandToProvider in dbTransactionData.DemandToProviderGetAll())
{
Demand demand = dbTransactionData.DemandsGetById(demandToProvider.GetDemandId());
Provider provider =
dbTransactionData.ProvidersGetById(demandToProvider.GetProviderId());
// every quantity > 0
Assert.True(demand.GetQuantity().IsGreaterThan(Quantity.Null()));
Assert.True(provider.GetQuantity().IsGreaterThan(Quantity.Null()));
Assert.True(demandToProvider.GetQuantity().IsGreaterThan(Quantity.Null()));
// demand's quantity == provider's quantity
Assert.True(demand.GetQuantity().Equals(provider.GetQuantity()));
// demand's quantity == demandToProvider's quantity
Assert.True(demand.GetQuantity().Equals(demandToProvider.GetQuantity()));
// provider's quantity == demandToProvider's quantity
Assert.True(provider.GetQuantity().Equals(demandToProvider.GetQuantity()));
}
foreach (var providerToDemand in dbTransactionData.ProviderToDemandGetAll())
{
Demand demand = dbTransactionData.DemandsGetById(providerToDemand.GetDemandId());
Provider provider =
dbTransactionData.ProvidersGetById(providerToDemand.GetProviderId());
// this is a special case, doc can be found at TODO
if (provider == null && demand.GetType() == typeof(StockExchangeDemand) && isArchive)
{
continue;
}
// every quantity > 0
Assert.True(demand.GetQuantity().IsGreaterThan(Quantity.Null()));
Assert.True(provider.GetQuantity().IsGreaterThan(Quantity.Null()));
Assert.True(providerToDemand.GetQuantity().IsGreaterThan(Quantity.Null()));
if (provider.GetType() == typeof(StockExchangeProvider))
{
// stockExchangeProvider's quantity >= providerToDemand's quantity
Assert.True(
provider.GetQuantity().IsGreaterThanOrEqualTo(providerToDemand.GetQuantity()));
}
else if (provider.GetType() == typeof(ProductionOrder))
{
// no condition
}
else if (provider.GetType() == typeof(PurchaseOrderPart))
{
Assert.True(false, "This arrow is not allowed.");
}
else
{
Assert.True(false, "Unexpected type.");
}
}
}
public void DemandsDelete(Demand demand)
{
if (demand.GetType() == typeof(ProductionOrderBom))
{
_productionOrderBoms.Remove((ProductionOrderBom)demand);
}
else if (demand.GetType() == typeof(StockExchangeDemand))
{
_stockExchangeDemands.Remove((StockExchangeDemand)demand);
}
else if (demand.GetType() == typeof(CustomerOrderPart))
{
_customerOrderParts.Remove((CustomerOrderPart)demand);
}
else
{
throw new MrpRunException("This type is unknown.");
}
}
public void TestParentsDueTimeIsGreaterThanOrEqualToChildsDueTime(
string testConfigurationFileName)
{
// init
InitThisTest(testConfigurationFileName);
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.ReloadTransactionData();
foreach (var demandToProvider in dbTransactionData.DemandToProviderGetAll())
{
Demand parentDemand =
dbTransactionData.DemandsGetById(demandToProvider.GetDemandId());
if (parentDemand.GetType() == typeof(CustomerOrderPart))
{
continue;
}
Provider childProvider =
dbTransactionData.ProvidersGetById(demandToProvider.GetProviderId());
DueTime parentDueTime = parentDemand.GetStartTimeBackward();
DueTime childDueTime = childProvider.GetEndTimeBackward();
Assert.True(parentDueTime.IsGreaterThanOrEqualTo(childDueTime),
"ParentDemand's dueTime cannot be smaller than childProvider's dueTime.");
}
foreach (var providerToDemand in dbTransactionData.ProviderToDemandGetAll())
{
Provider parentProvider =
dbTransactionData.ProvidersGetById(providerToDemand.GetProviderId());
Demand childDemand =
dbTransactionData.DemandsGetById(providerToDemand.GetDemandId());
DueTime parentDueTime = parentProvider.GetStartTimeBackward();
DueTime childDueTime = childDemand.GetEndTimeBackward();
Assert.True(parentDueTime.IsGreaterThanOrEqualTo(childDueTime),
"ParentProvider's dueTime cannot be smaller than childDemand's dueTime.");
}
}
public EntityCollector Satisfy(Demand demand, Quantity demandedQuantity)
{
// SE:I --> satisfy by orders (PuOP/PrOBom)
if (demand.GetType() == typeof(StockExchangeDemand))
{
if (demand.GetArticle().ToBuild)
{
return(_productionManager.Satisfy(demand, demandedQuantity));
}
else
{
return(_purchaseManager.Satisfy(demand, demandedQuantity));
}
}
// COP or PrOB --> satisfy by SE:W
else
{
return(_stockManager.Satisfy(demand, demandedQuantity));
}
}
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);
}
public void TestApplyConfirmationsArchive(string testConfigurationFileName)
{
InitThisTest(testConfigurationFileName);
IDbTransactionData dbTransactionDataArchive =
ZppConfiguration.CacheManager.GetDbTransactionDataArchive();
IAggregator aggregator = new Aggregator(dbTransactionDataArchive);
// ZPP should only use the archive for the rest of the test
ZppConfiguration.CacheManager.UseArchiveForGetters();
// Ein CustomerOrderParts darf kein Kind haben und muss beendet sein
Ids customerOrderIds = new Ids();
foreach (var demand in dbTransactionDataArchive.CustomerOrderPartGetAll())
{
CustomerOrderPart customerOrderPart = (CustomerOrderPart)demand;
customerOrderIds.Add(customerOrderPart.GetCustomerOrderId());
Providers childs = aggregator.GetAllChildProvidersOf(customerOrderPart);
Assert.False(childs.Any());
Assert.True(customerOrderPart.IsFinished());
}
// Ein PurchaseOrderPart darf kein Elter haben und muss beendet sein.
Ids purchaseOrderIds = new Ids();
foreach (var demand in dbTransactionDataArchive.PurchaseOrderPartGetAll())
{
PurchaseOrderPart purchaseOrderPart = (PurchaseOrderPart)demand;
purchaseOrderIds.Add(purchaseOrderPart.GetPurchaseOrderId());
Assert.True(purchaseOrderPart.IsFinished());
Demands demands = aggregator.GetAllParentDemandsOf(demand);
Assert.True(demands == null || demands.Any() == false);
}
// Für jede CustomerOrder muss es mind. noch ein CustomerOrderPart geben.
foreach (var customerOrder in dbTransactionDataArchive.CustomerOrderGetAll())
{
Assert.True(customerOrderIds.Contains(customerOrder.GetId()));
}
// Für jede PurchaseOrder muss es mind. noch ein PurchaseOrderPart geben.
foreach (var purchaseOrder in dbTransactionDataArchive.PurchaseOrderGetAll())
{
Assert.True(purchaseOrderIds.Contains(purchaseOrder.GetId()));
}
// Ein StockExchangeProvider muss mind. ein Kind haben.
foreach (var stockExchangeProvider in dbTransactionDataArchive.StockExchangeProvidersGetAll())
{
Demands childs = aggregator.GetAllChildDemandsOf(stockExchangeProvider);
Assert.True(childs.Any());
}
// Ein StockExchangeDemand muss beendet und geschlossen sein.
foreach (var stockExchangeDemand in dbTransactionDataArchive.StockExchangeDemandsGetAll())
{
bool isOpen = OpenDemandManager.IsOpen((StockExchangeDemand)stockExchangeDemand);
Assert.True(stockExchangeDemand.IsFinished() && isOpen == false);
}
// Eine ProductionOrder muss beendet sein und für eine ProductionOrder
// muss es mind. eine Operation geben.
Ids productionOrderIds = new Ids();
Ids operationIds = new Ids();
foreach (var operation in dbTransactionDataArchive.ProductionOrderOperationGetAll())
{
Id productionOrderId = operation.GetProductionOrderId();
if (productionOrderIds.Contains(productionOrderId) == false)
{
productionOrderIds.Add(productionOrderId);
}
operationIds.Add(operation.GetId());
}
foreach (var provider in dbTransactionDataArchive.ProductionOrderGetAll())
{
ProductionOrder productionOrder = (ProductionOrder)provider;
Assert.True(productionOrder.DetermineProductionOrderState()
.Equals(State.Finished));
Assert.True(productionOrderIds.Contains(productionOrder.GetId()));
}
// Für jede ProductionOrderBom muss die dazugehörige Operation da sein.
foreach (var demand in dbTransactionDataArchive.ProductionOrderBomGetAll())
{
ProductionOrderBom productionOrderBom = (ProductionOrderBom)demand;
operationIds.Contains(productionOrderBom.GetProductionOrderOperationId());
}
// Für jeden DemandToProvider und ProviderToDemand müssen die dazugehörigen
// Demands und Provider existieren.
foreach (var demandToProvider in dbTransactionDataArchive.DemandToProviderGetAll())
{
Demand demand = dbTransactionDataArchive.DemandsGetById(demandToProvider.GetDemandId());
Provider provider =
dbTransactionDataArchive.ProvidersGetById(demandToProvider.GetProviderId());
Assert.NotNull(demand);
Assert.NotNull(provider);
}
foreach (var providerToDemand in dbTransactionDataArchive.ProviderToDemandGetAll())
{
Demand demand = dbTransactionDataArchive.DemandsGetById(providerToDemand.GetDemandId());
Provider provider =
dbTransactionDataArchive.ProvidersGetById(providerToDemand.GetProviderId());
Assert.NotNull(demand);
if (demand.GetType() == typeof(StockExchangeDemand) && provider == null)
{
// no check for notNull, because stockExchangeProviders can be inconsistent TODO doc
}
else
{
Assert.NotNull(provider);
}
}
}
/**
* Assumptions:
* - IDemand: T_CustomerOrderPart (COP), T_ProductionOrderBom (PrOB), T_StockExchange (SE:I)
* - IProvider: T_PurchaseOrderPart (PuOP), T_ProductionOrder (PrO), T_StockExchange (SE:W)
*
* Verifies that,
* for demand (parent) --> provider (child) direction following takes effect:
* - COP --> SE:W
* - PrOB --> SE:W
* - SE:I --> PuOP | PrO
*
* for provider (parent) --> demand (child) direction following takes effect:
* - PuOP --> NONE
* - PrO --> PrOB
* - SE:W --> SE:I
*
* where SE:I = StockExchangeDemand
* and SE:W = StockExchangeProvider
* TODO: remove StockExchangeType from T_StockExchange since it's exactly specified by Withdrawal/Insert
*
* TODO: add a new Quality to test: check that NONE is only if it's defined in upper connections
* (e.g. after a PrO MUST come another Demand )
*/
private void VerifyEdgeTypes(IDbTransactionData dbTransactionData, bool isArchive)
{
IDictionary <Type, Type[]> allowedEdges = new Dictionary <Type, Type[]>()
{
// demand --> provider
{
typeof(CustomerOrderPart),
new Type[]
{
typeof(StockExchangeProvider)
}
},
{
typeof(ProductionOrderBom), new Type[]
{
typeof(StockExchangeProvider)
}
},
{
typeof(StockExchangeDemand),
new Type[] { typeof(PurchaseOrderPart), typeof(ProductionOrder) }
},
// provider --> demand
{
typeof(PurchaseOrderPart),
new Type[] { }
},
{
typeof(ProductionOrder),
new Type[] { typeof(ProductionOrderBom) }
},
{
typeof(StockExchangeProvider),
new Type[] { typeof(StockExchangeDemand) }
}
};
// verify edgeTypes
foreach (var demandToProvider in dbTransactionData.DemandToProviderGetAll())
{
Demand demand = dbTransactionData.DemandsGetById(demandToProvider.GetDemandId());
Provider provider =
dbTransactionData.ProvidersGetById(demandToProvider.GetProviderId());
Assert.True(allowedEdges[demand.GetType()].Contains(provider.GetType()),
$"This is no valid edge: {demand.GetType()} --> {provider.GetType()}");
}
foreach (var providerToDemand in dbTransactionData.ProviderToDemandGetAll())
{
Demand demand = dbTransactionData.DemandsGetById(providerToDemand.GetDemandId());
Provider provider =
dbTransactionData.ProvidersGetById(providerToDemand.GetProviderId());
// this is a special case, doc can be found at TODO
if (provider == null && demand.GetType() == typeof(StockExchangeDemand) && isArchive)
{
continue;
}
Assert.True(allowedEdges[provider.GetType()].Contains(demand.GetType()),
$"This is no valid edge: {provider.GetType()} --> {demand.GetType()}");
}
}
