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()}"); } }