public void TestEveryOperationHasNeededMaterialAtStart(string testConfigurationFileName
)
{
InitTestScenario(testConfigurationFileName);
IZppSimulator zppSimulator = new ZppSimulator.impl.ZppSimulator();
// TODO: set to true once dbPersist() has an acceptable time
zppSimulator.StartTestCycle(false);
// TODO: replace this by ReloadTransactionData() once shouldPersist is enabled
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();
foreach (var operation in dbTransactionData.ProductionOrderOperationGetAll())
{
Demands productionOrderBoms = aggregator.GetProductionOrderBomsBy(operation);
foreach (var productionOrderBom in productionOrderBoms)
{
foreach (var stockExchangeProvider in aggregator.GetAllChildProvidersOf(
productionOrderBom))
{
Assert.True(operation.GetStartTime() >=
stockExchangeProvider.GetEndTimeBackward().GetValue());
}
}
}
}
public static void CreateConfirmations(SimulationInterval simulationInterval)
{
/*ISimulator simulator = new Simulator();
* simulator.ProcessCurrentInterval(simulationInterval, _orderGenerator);*/
// --> (Martin's impl) does not work correctly, use trivial impl instead TODO: Just an info for you Martin
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();
// customerOrderParts: set finished if all childs are finished
DemandToProviderGraph demandToProviderGraph = new DemandToProviderGraph();
INodes rootNodes = demandToProviderGraph.GetRootNodes();
foreach (var rootNode in rootNodes)
{
if (rootNode.GetEntity().GetType() == typeof(CustomerOrderPart))
{
CustomerOrderPart customerOrderPart = (CustomerOrderPart)rootNode.GetEntity();
customerOrderPart.SetReadOnly();
bool allChildsAreFinished = true;
foreach (var stockExchangeProvider in aggregator.GetAllChildProvidersOf(
customerOrderPart))
{
if (stockExchangeProvider.IsFinished() == false)
{
allChildsAreFinished = false;
break;
}
}
if (allChildsAreFinished)
{
customerOrderPart.SetFinished();
}
}
}
// no confirmations: some nodes has no state (PrO) or must be adapted differently (COPs)
// confirmations only for: stockExchanges, purchaseOrderParts, operations
Type[] typesToAdapt = new Type[]
{
typeof(StockExchangeDemand), typeof(StockExchangeProvider),
typeof(PurchaseOrderPart), typeof(ProductionOrderOperation)
};
// operations
AdaptState(dbTransactionData.ProductionOrderOperationGetAll(), simulationInterval,
typesToAdapt);
// demands
AdaptState(dbTransactionData.DemandsGetAll(), simulationInterval, typesToAdapt);
// provider
AdaptState(dbTransactionData.ProvidersGetAll(), simulationInterval, typesToAdapt);
}
/**
* covers parent StockExchangeProvider(and its parent CustomerOrderPart if exist), child PurchaseOrderPart if exist
* --> 3 types of subgraphs: Production, Purchase, Customer
*/
private static List <IDemandOrProvider> GetItemsOfStockExchangeDemandSubGraph(
StockExchangeDemand stockExchangeDemand, IDbTransactionData dbTransactionData,
IAggregator aggregator, bool includeStockExchangeProviderHavingMultipleChilds)
{
List <IDemandOrProvider> items = new List <IDemandOrProvider>();
items.Add(stockExchangeDemand);
Providers stockExchangeProviders =
aggregator.GetAllParentProvidersOf(stockExchangeDemand);
foreach (var stockExchangeProvider in stockExchangeProviders)
{
Demands childsOfStockExchangeProvider =
aggregator.GetAllChildDemandsOf(stockExchangeProvider);
if (includeStockExchangeProviderHavingMultipleChilds ||
childsOfStockExchangeProvider.Count() == 1)
{
items.Add(stockExchangeProvider);
Demands customerOrderParts =
aggregator.GetAllParentDemandsOf(stockExchangeProvider);
if (customerOrderParts.Count() > 1)
{
throw new MrpRunException(
"A stockExchangeProvider can only have one parent.");
}
foreach (var customerOrderPart in customerOrderParts)
{
items.Add(customerOrderPart);
}
}
}
Providers purchaseOrderParts = aggregator.GetAllChildProvidersOf(stockExchangeDemand);
if (purchaseOrderParts.Count() > 1)
{
throw new MrpRunException("A stockExchangeDemand can only have one child.");
}
foreach (var purchaseOrderPart in purchaseOrderParts)
{
items.Add(purchaseOrderPart);
}
return(items);
}
public Demands GetUnsatisfiedCustomerOrderParts()
{
Demands unsatisfiedCustomerOrderParts = new Demands();
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();
Demands customerOrderParts = dbTransactionData.CustomerOrderPartGetAll();
foreach (var customerOrderPart in customerOrderParts)
{
Providers customerOrderPartChilds =
aggregator.GetAllChildProvidersOf(customerOrderPart);
if (customerOrderPartChilds == null || customerOrderPartChilds.Any() == false)
{
unsatisfiedCustomerOrderParts.Add(customerOrderPart);
}
}
return(unsatisfiedCustomerOrderParts);
}
public static void CreateConfirmationsOld(SimulationInterval simulationInterval)
{
/*ISimulator simulator = new Simulator();
* simulator.ProcessCurrentInterval(simulationInterval, _orderGenerator);*/
// --> does not work correctly, use trivial impl instead
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();
// stockExchanges, purchaseOrderParts, operations(use PrBom instead):
// set in progress when startTime is within interval
DemandOrProviders demandOrProvidersToSetInProgress = new DemandOrProviders();
demandOrProvidersToSetInProgress.AddAll(
aggregator.GetDemandsOrProvidersWhereStartTimeIsWithinInterval(simulationInterval,
new DemandOrProviders(dbTransactionData.PurchaseOrderPartGetAll())));
demandOrProvidersToSetInProgress.AddAll(
aggregator.GetDemandsOrProvidersWhereStartTimeIsWithinInterval(simulationInterval,
new DemandOrProviders(dbTransactionData.StockExchangeDemandsGetAll())));
demandOrProvidersToSetInProgress.AddAll(
aggregator.GetDemandsOrProvidersWhereStartTimeIsWithinInterval(simulationInterval,
new DemandOrProviders(dbTransactionData.StockExchangeProvidersGetAll())));
demandOrProvidersToSetInProgress.AddAll(
aggregator.GetDemandsOrProvidersWhereStartTimeIsWithinInterval(simulationInterval,
new DemandOrProviders(dbTransactionData.ProductionOrderBomGetAll())));
foreach (var demandOrProvider in demandOrProvidersToSetInProgress)
{
demandOrProvider.SetInProgress();
demandOrProvider.SetReadOnly();
}
// stockExchanges, purchaseOrderParts, operations(use PrBom instead):
// set finished when endTime is within interval
DemandOrProviders demandOrProvidersToSetFinished = new DemandOrProviders();
demandOrProvidersToSetFinished.AddAll(
aggregator.GetDemandsOrProvidersWhereEndTimeIsWithinIntervalOrBefore(
simulationInterval,
new DemandOrProviders(dbTransactionData.PurchaseOrderPartGetAll())));
demandOrProvidersToSetFinished.AddAll(
aggregator.GetDemandsOrProvidersWhereEndTimeIsWithinIntervalOrBefore(
simulationInterval,
new DemandOrProviders(dbTransactionData.StockExchangeDemandsGetAll())));
demandOrProvidersToSetFinished.AddAll(
aggregator.GetDemandsOrProvidersWhereEndTimeIsWithinIntervalOrBefore(
simulationInterval,
new DemandOrProviders(dbTransactionData.StockExchangeProvidersGetAll())));
demandOrProvidersToSetFinished.AddAll(
aggregator.GetDemandsOrProvidersWhereEndTimeIsWithinIntervalOrBefore(
simulationInterval,
new DemandOrProviders(dbTransactionData.ProductionOrderBomGetAll())));
foreach (var demandOrProvider in demandOrProvidersToSetFinished)
{
demandOrProvider.SetFinished();
demandOrProvider.SetReadOnly();
}
// customerOrderParts: set finished if all childs are finished
DemandToProviderGraph demandToProviderGraph = new DemandToProviderGraph();
INodes rootNodes = demandToProviderGraph.GetRootNodes();
foreach (var rootNode in rootNodes)
{
if (rootNode.GetEntity().GetType() == typeof(CustomerOrderPart))
{
CustomerOrderPart customerOrderPart = (CustomerOrderPart)rootNode.GetEntity();
customerOrderPart.SetReadOnly();
bool allChildsAreFinished = true;
foreach (var stockExchangeProvider in aggregator.GetAllChildProvidersOf(
customerOrderPart))
{
if (stockExchangeProvider.IsFinished() == false)
{
allChildsAreFinished = false;
break;
}
}
if (allChildsAreFinished)
{
customerOrderPart.SetFinished();
}
}
}
// set operations readonly
foreach (var operation in dbTransactionData.ProductionOrderOperationGetAll())
{
operation.SetReadOnly();
}
// set productionOrders readonly
foreach (var productionOrder in dbTransactionData.ProductionOrderGetAll())
{
productionOrder.SetReadOnly();
}
// future SEs are still not readonly, set it so
foreach (var stockExchangeDemand in dbTransactionData.StockExchangeDemandsGetAll())
{
stockExchangeDemand.SetReadOnly();
}
foreach (var stockExchangeProvider in dbTransactionData.StockExchangeProvidersGetAll())
{
stockExchangeProvider.SetReadOnly();
}
}
/**
* Subgraph of a productionOrder includes:
* - parent (StockExchangeDemand) if includeStockExchanges true
* - childs (ProductionOrderBoms)
* - childs of childs (StockExchangeProvider) if includeStockExchanges true
*/
private static List <IDemandOrProvider> CreateProductionOrderSubGraph(
bool includeStockExchanges, ProductionOrder productionOrder, IAggregator aggregator)
{
List <IDemandOrProvider> demandOrProvidersOfProductionOrderSubGraph =
new List <IDemandOrProvider>();
demandOrProvidersOfProductionOrderSubGraph.Add(productionOrder);
if (includeStockExchanges)
{
Demands stockExchangeDemands = aggregator.GetAllParentDemandsOf(productionOrder);
if (stockExchangeDemands.Count() > 1)
{
throw new MrpRunException(
"A productionOrder can only have one parentDemand (stockExchangeDemand).");
}
demandOrProvidersOfProductionOrderSubGraph.AddRange(stockExchangeDemands);
foreach (var stockExchangeDemand in stockExchangeDemands)
{
Providers parentStockExchangeProviders =
aggregator.GetAllParentProvidersOf(stockExchangeDemand);
foreach (var parentStockExchangeProvider in parentStockExchangeProviders)
{
if (aggregator.GetAllChildDemandsOf(parentStockExchangeProvider).Count() ==
1)
{
demandOrProvidersOfProductionOrderSubGraph.Add(
parentStockExchangeProvider);
}
else
{
// stockExchangeProvider must stay
}
}
}
}
Demands productionOrderBoms = aggregator.GetAllChildDemandsOf(productionOrder);
demandOrProvidersOfProductionOrderSubGraph.AddRange(productionOrderBoms);
if (includeStockExchanges)
{
foreach (var productionOrderBom in productionOrderBoms)
{
Providers stockExchangeProvider =
aggregator.GetAllChildProvidersOf(productionOrderBom);
if (stockExchangeProvider.Count() > 1)
{
throw new MrpRunException(
"A ProductionOrderBom can only have one childProvider (stockExchangeProvider).");
}
demandOrProvidersOfProductionOrderSubGraph.AddRange(stockExchangeProvider);
}
}
return(demandOrProvidersOfProductionOrderSubGraph);
}
public void TestApplyConfirmations(string testConfigurationFileName)
{
InitThisTest(testConfigurationFileName);
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();
// Ein CustomerOrderParts darf kein Kind haben und darf nicht beendet sein
Ids customerOrderIds = new Ids();
foreach (var demand in dbTransactionData.CustomerOrderPartGetAll())
{
CustomerOrderPart customerOrderPart = (CustomerOrderPart)demand;
customerOrderIds.Add(customerOrderPart.GetCustomerOrderId());
Providers childs = aggregator.GetAllChildProvidersOf(customerOrderPart);
Assert.False(childs.Any());
Assert.False(customerOrderPart.IsFinished());
}
// Ein PurchaseOrderPart darf kein Elter haben und darf nicht beendet sein.
Ids purchaseOrderIds = new Ids();
foreach (var demand in dbTransactionData.PurchaseOrderPartGetAll())
{
PurchaseOrderPart purchaseOrderPart = (PurchaseOrderPart)demand;
purchaseOrderIds.Add(purchaseOrderPart.GetPurchaseOrderId());
Assert.False(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 dbTransactionData.CustomerOrderGetAll())
{
Assert.True(customerOrderIds.Contains(customerOrder.GetId()));
}
// Für jede PurchaseOrder muss es mind. noch ein PurchaseOrderPart geben.
foreach (var purchaseOrder in dbTransactionData.PurchaseOrderGetAll())
{
Assert.True(purchaseOrderIds.Contains(purchaseOrder.GetId()));
}
// Ein StockExchangeProvider muss mind. ein Kind haben.
foreach (var stockExchangeProvider in dbTransactionData.StockExchangeProvidersGetAll())
{
Demands childs = aggregator.GetAllChildDemandsOf(stockExchangeProvider);
Assert.True(childs.Any());
}
// Ein StockExchangeDemand darf nicht beendet und geschlossen sein.
foreach (var stockExchangeDemand in dbTransactionData.StockExchangeDemandsGetAll())
{
bool isOpen = OpenDemandManager.IsOpen((StockExchangeDemand)stockExchangeDemand);
Assert.False(stockExchangeDemand.IsFinished() && isOpen == false);
}
// Eine ProductionOrder darf nicht 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 dbTransactionData.ProductionOrderOperationGetAll())
{
Id productionOrderId = operation.GetProductionOrderId();
if (productionOrderIds.Contains(productionOrderId) == false)
{
productionOrderIds.Add(productionOrderId);
}
operationIds.Add(operation.GetId());
}
foreach (var provider in dbTransactionData.ProductionOrderGetAll())
{
ProductionOrder productionOrder = (ProductionOrder)provider;
Assert.False(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 dbTransactionData.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 dbTransactionData.DemandToProviderGetAll())
{
Demand demand = dbTransactionData.DemandsGetById(demandToProvider.GetDemandId());
Provider provider =
dbTransactionData.ProvidersGetById(demandToProvider.GetProviderId());
Assert.NotNull(demand);
Assert.NotNull(provider);
}
foreach (var providerToDemand in dbTransactionData.ProviderToDemandGetAll())
{
Demand demand = dbTransactionData.DemandsGetById(providerToDemand.GetDemandId());
Provider provider =
dbTransactionData.ProvidersGetById(providerToDemand.GetProviderId());
Assert.NotNull(demand);
Assert.NotNull(provider);
}
}
