/**
         * // Entferne alle Pfeile auf StockExchangeProvider zeigend
         *  // Entferne alle Pfeile von StockExchangeDemands weg zeigend
         *  //  --> übrig beleiben Pfeile zwischen StockExchangeProvider und StockExchangeDemands
         */
        private static void RemoveArrowsBelowStockExchangeDemandsAndAboveStockExchangeProviders(
            IDbTransactionData dbTransactionData, IAggregator aggregator)
        {
            List <ILinkDemandAndProvider> stockExchangeLinks = new List <ILinkDemandAndProvider>();

            foreach (var stockExchangeDemand in dbTransactionData.StockExchangeDemandsGetAll())
            {
                List <ILinkDemandAndProvider> fromStockExchanges =
                    aggregator.GetArrowsFrom(stockExchangeDemand);
                if (fromStockExchanges != null)
                {
                    stockExchangeLinks.AddRange(fromStockExchanges);
                }
            }

            foreach (var stockExchangeProvider in dbTransactionData.StockExchangeProvidersGetAll())
            {
                List <ILinkDemandAndProvider> toStockExchanges =
                    aggregator.GetArrowsTo(stockExchangeProvider);
                if (toStockExchanges != null)
                {
                    stockExchangeLinks.AddRange(toStockExchanges);
                }
            }

            dbTransactionData.DeleteAllFrom(stockExchangeLinks);
        }
        private static void HandleProductionOrderIsFinished(ProductionOrder productionOrder,
                                                            IAggregator aggregator, IDbTransactionData dbTransactionData)
        {
            IDbTransactionData dbTransactionDataArchive =
                ZppConfiguration.CacheManager.GetDbTransactionDataArchive();

            // archive operations
            ArchiveOperations(dbTransactionData, dbTransactionDataArchive, aggregator,
                              productionOrder);

            // collect demands Or providers
            List <IDemandOrProvider> demandOrProvidersToArchive =
                CreateProductionOrderSubGraph(false, productionOrder, aggregator);

            // delete & archive all collected entities
            foreach (var demandOrProvider in demandOrProvidersToArchive)
            {
                // arrow outside mus be removed
                List <ILinkDemandAndProvider> demandAndProviderLinks;
                if (demandOrProvider.GetType() == typeof(ProductionOrder))
                {
                    // archive only link from ProductionOrder
                    demandAndProviderLinks = aggregator.GetArrowsFrom(demandOrProvider);
                    dbTransactionDataArchive.AddAllFrom(demandAndProviderLinks);
                    dbTransactionData.DeleteAllFrom(demandAndProviderLinks);
                    demandAndProviderLinks = aggregator.GetArrowsTo(demandOrProvider);
                    dbTransactionData.DeleteAllFrom(demandAndProviderLinks);
                }
                else if (demandOrProvider.GetType() == typeof(ProductionOrderBom))
                {
                    // archive only link to ProductionOrderBom
                    demandAndProviderLinks = aggregator.GetArrowsTo(demandOrProvider);
                    dbTransactionDataArchive.AddAllFrom(demandAndProviderLinks);
                    dbTransactionData.DeleteAllFrom(demandAndProviderLinks);
                    demandAndProviderLinks = aggregator.GetArrowsFrom(demandOrProvider);
                    dbTransactionData.DeleteAllFrom(demandAndProviderLinks);
                }
                else
                {
                    throw new MrpRunException("In this case not possible");
                }


                dbTransactionDataArchive.AddA(demandOrProvider);
                dbTransactionData.DeleteA(demandOrProvider);
            }
        }
        private static void ArchiveFinishedCustomerOrderPartsAndDeleteTheirArrows(
            IDbTransactionData dbTransactionData, IAggregator aggregator)
        {
            Demands copyOfCustomerOrderParts = new Demands();

            copyOfCustomerOrderParts.AddAll(dbTransactionData.CustomerOrderPartGetAll());
            foreach (var demand in copyOfCustomerOrderParts)
            {
                CustomerOrderPart customerOrderPart = (CustomerOrderPart)demand;
                if (customerOrderPart.IsFinished())
                {
                    ArchiveCustomerOrder(customerOrderPart.GetCustomerOrderId());
                    // archive cop
                    List <ILinkDemandAndProvider> arrows =
                        aggregator.GetArrowsFrom(customerOrderPart);
                    dbTransactionData.DeleteAllFrom(arrows);
                    ArchiveDemandOrProvider(customerOrderPart, dbTransactionData, aggregator,
                                            false);
                }
            }
        }
        private static void ArchiveFinishedPurchaseOrderPartsAndDeleteTheirArrows(
            IDbTransactionData dbTransactionData, IAggregator aggregator)
        {
            Providers copyOfPurchaseOrderParts = new Providers();

            copyOfPurchaseOrderParts.AddAll(dbTransactionData.PurchaseOrderPartGetAll());
            foreach (var purchaseOrderPart in copyOfPurchaseOrderParts)
            {
                if (purchaseOrderPart.IsFinished())
                {
                    // delete arrow
                    List <ILinkDemandAndProvider> arrows =
                        aggregator.GetArrowsFrom(purchaseOrderPart);
                    if (arrows != null)
                    {
                        dbTransactionData.DeleteAllFrom(arrows);
                    }

                    // archive purchaseOrderPart
                    ArchiveDemandOrProvider(purchaseOrderPart, dbTransactionData, aggregator,
                                            false);
                }
            }
        }