Returns true if a service definition exists under the given identifier.
public hasDefinition ( string $id ) : boolean | ||
$id | string | The service identifier |
return | boolean | true if the service definition exists, false otherwise |
/** * @param Definition $definition */ protected function processDefinition(Definition $definition) { if ($definition->isSynthetic()) { return; } if ($definition->getFactoryService() || $definition->getFactoryClass()) { return; } if ($file = $definition->getFile()) { require_once $file; } if (!class_exists($definition->getClass())) { return; } $class = new \ReflectionClass($definition->getClass()); if (!$class->implementsInterface(static::INTERFACE_CLASS)) { return; } $metadata = $this->getMetadataFactory()->getMetadataForClass($definition->getClass()); if (!$metadata instanceof ClassMetadata) { return; } $namespace = $metadata->getNamespace() ?: static::ROOT_NAMESPACE; $serviceName = static::PROVIDER_PREFIX . substr(sha1($namespace), 0, 10); if (!$this->container->hasDefinition($serviceName)) { $cacher = new Definition('Werkint\\Bundle\\CacheBundle\\Service\\CacheProvider', [$this->container->getParameter('kernel.cache_dir') . '/werkint_cache']); $cacher->setPublic(true); $cacher->addMethodCall('setNamespace', [$namespace]); $this->container->setDefinition($serviceName, $cacher); } $definition->addMethodCall('setCacheProvider', [new Reference($serviceName)]); }
public function process(ContainerBuilder $container) { if (!($container->hasDefinition('security.authentication.provider.dao') && $container->hasDefinition('security.authentication.provider.anonymous'))) { return; } $configResolverRef = new Reference('ezpublish.config.resolver'); $repositoryReference = new Reference('ezpublish.api.repository'); // Inject the Repository in the authentication provider. // We need it for checking user credentials $daoAuthenticationProviderDef = $container->findDefinition('security.authentication.provider.dao'); $daoAuthenticationProviderDef->addMethodCall('setRepository', array($repositoryReference)); $anonymousAuthenticationProviderDef = $container->findDefinition('security.authentication.provider.anonymous'); $anonymousAuthenticationProviderDef->addMethodCall('setRepository', array($repositoryReference)); $anonymousAuthenticationProviderDef->addMethodCall('setConfigResolver', array($configResolverRef)); if (!$container->hasDefinition('security.http_utils')) { return; } $httpUtilsDef = $container->findDefinition('security.http_utils'); $httpUtilsDef->addMethodCall('setSiteAccess', array(new Reference('ezpublish.siteaccess'))); if (!$container->hasDefinition('security.authentication.success_handler')) { return; } $successHandlerDef = $container->getDefinition('security.authentication.success_handler'); $successHandlerDef->addMethodCall('setConfigResolver', array($configResolverRef)); }
public function process(ContainerBuilder $container) { if (!$container->hasDefinition('translator.writer') || !$container->hasDefinition('translator.real')) { return; } $translatorRealDefinition = $container->findDefinition('translator.real'); $translatorDefinition = $container->findDefinition('translator.writer'); $translatorDefinition->replaceArgument(2, $translatorRealDefinition->getArgument(2)); foreach($translatorRealDefinition->getMethodCalls() as $methodCall) { $translatorDefinition->addMethodCall($methodCall[0], $methodCall[1]); // use resources from translator.real to add available locales if ('addResource' === $methodCall[0]) { // $methodCall[1][2] is the locale // @see FrameworkBundle\DependencyInjection\FrameworkExtension::registerTranslatorConfiguration $translatorDefinition->addMethodCall('addLocale', array($methodCall[1][2])); } } foreach($container->findTaggedServiceIds('knplabs_translator.dumper') as $id => $attributes) { $translatorDefinition->addMethodCall('addDumper', array($container->getDefinition($id))); } }
/** * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('ezpublish.chain_router')) { return; } $chainRouter = $container->getDefinition('ezpublish.chain_router'); // Enforce default router to be part of the routing chain // The default router will be given the highest priority so that it will be used by default if ($container->hasDefinition('router.default')) { $defaultRouter = $container->getDefinition('router.default'); $defaultRouter->addMethodCall('setSiteAccess', array(new Reference('ezpublish.siteaccess'))); $defaultRouter->addMethodCall('setConfigResolver', array(new Reference('ezpublish.config.resolver'))); $defaultRouter->addMethodCall('setNonSiteAccessAwareRoutes', array('%ezpublish.default_router.non_siteaccess_aware_routes%')); $defaultRouter->addMethodCall('setLegacyAwareRoutes', array('%ezpublish.default_router.legacy_aware_routes%')); $defaultRouter->addMethodCall('setSiteAccessRouter', array(new Reference('ezpublish.siteaccess_router'))); if (!$defaultRouter->hasTag('router')) { $defaultRouter->addTag('router', array('priority' => 255)); } } foreach ($container->findTaggedServiceIds('router') as $id => $attributes) { $priority = isset($attributes[0]['priority']) ? (int) $attributes[0]['priority'] : 0; // Priority range is between -255 (the lowest) and 255 (the highest) if ($priority > 255) { $priority = 255; } if ($priority < -255) { $priority = -255; } $chainRouter->addMethodCall('add', array(new Reference($id), $priority)); } }
public function testLoad() { $config = [['toggles' => ['generic' => ['type' => 'service', 'service' => 'hotflo_feature_toggle.generic_feature_toggle']], 'features' => ['my_feature' => ['toggle' => 'generic', 'options' => ['key' => 'value']], 'my_second_feature' => ['toggle' => 'generic']]]]; $this->extension->load($config, $this->container); $this->assertTrue($this->container->hasDefinition('hotflo_feature_toggle.feature.my_feature')); $this->assertTrue($this->container->hasDefinition('hotflo_feature_toggle.feature.my_second_feature')); }
public function process(ContainerBuilder $container) { // log $definition = $container->findDefinition('csa_guzzle.subscriber.log'); $logServiceId = $container->getParameter('csa_guzzle.subscriber.log.service'); if ($container->hasDefinition($logServiceId)) { $definition->replaceArgument(0, new Reference($logServiceId)); } $channel = $container->getParameter('csa_guzzle.subscriber.log.channel'); if (!empty($channel)) { $definition->clearTag('monolog.logger'); $definition->addTag('monolog.logger', array('channel' => $channel)); } // Cache $cacheServiceId = $container->getParameter('csa_guzzle.subscriber.cache.service'); if ($container->hasDefinition($cacheServiceId)) { $container->setDefinition('csa_guzzle.cache_storage', new Definition('%csa_guzzle.cache_storage.class%', array(new Reference($cacheServiceId), $container->getParameter('csa_guzzle.subscriber.cache.prefix')))); $cacheSubscriber = new Definition('%csa_guzzle.subscriber.cache.class%', array(new Reference('csa_guzzle.cache_storage'), $container->getParameter('csa_guzzle.subscriber.cache.enable'))); $cacheSubscriber->addTag('csa_guzzle.subscriber'); $container->setDefinition('csa_guzzle.subscriber.cache', $cacheSubscriber); } // get all Guzzle subscribers $subscribers = $container->findTaggedServiceIds('csa_guzzle.subscriber'); if (!count($subscribers)) { return; } // Factory $factory = $container->findDefinition('csa_guzzle.client_factory'); $arg = []; foreach ($subscribers as $subscriber => $options) { $arg[] = new Reference($subscriber); } $factory->replaceArgument(1, $arg); }
/** * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition(self::CONTENT_PROVIDER_MANAGER_SERVICE)) { return; } $contentProviderManagerDefinition = $container->getDefinition(self::CONTENT_PROVIDER_MANAGER_SERVICE); $taggedServices = $container->findTaggedServiceIds(self::CONTENT_PROVIDER_TAG); foreach ($taggedServices as $id => $attributes) { if ($container->hasDefinition($id)) { $container->getDefinition($id)->setPublic(false); } $isEnabled = true; foreach ($attributes as $attribute) { if (array_key_exists('enabled', $attribute)) { $isEnabled = !empty($attribute['enabled']); break; } } $contentProviderManagerDefinition->addMethodCall('addContentProvider', array(new Reference($id), $isEnabled)); } if ($container->hasDefinition(self::TWIG_SERVICE_KEY)) { $twig = $container->getDefinition(self::TWIG_SERVICE_KEY); $twig->addMethodCall('addGlobal', ['oro_ui_content_provider_manager', new Reference(self::CONTENT_PROVIDER_MANAGER_SERVICE)]); } }
public function process(ContainerBuilder $container) { if (!$container->hasDefinition('teckhouse_analytics.menu_builder.default')) { return; } if (!$container->hasDefinition('teckhouse_analytics.widget_manager.default')) { return; } $menuDefinition = $container->getDefinition('teckhouse_analytics.menu_builder'); $wdigetManagerDefinition = $container->getDefinition('teckhouse_analytics.widget_manager'); $taggedServices = $container->findTaggedServiceIds('teckhouse_analytics.widget'); // $config = $container->getParameter('teckhouse_analytics'); // // foreach ($taggedServices as $id => $tagAttributes) { // foreach ($tagAttributes as $attributes) { // // $widget = new Reference($id); // // $menuDefinition->addMethodCall( // 'addMenuWidgetItem', array($widget, $attributes["group"], $attributes["label"]) // ); // // $wdigetManagerDefinition->addMethodCall( // 'setWidget', array($widget, $id) // ); // } // } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('profiler')) { // the Symfony Profiler is disabled return; } $datagridEvents = [DatagridEvent\PreBuild::NAME, DatagridEvent\BuildAfter::NAME, DatagridEvent\BuildBefore::NAME, DatagridEvent\OrmResultBefore::NAME, DatagridEvent\OrmResultAfter::NAME, DatagridEvent\GridViewsLoadEvent::EVENT_NAME]; $datagridEventListeners = []; $eventListeners = $container->findTaggedServiceIds('kernel.event_listener'); foreach ($eventListeners as $serviceId => $tags) { foreach ($tags as $tag) { if (isset($tag['event']) && 0 === strpos($tag['event'], 'oro_datagrid') && !in_array($tag['event'], $datagridEvents, true)) { $datagridEventListeners[] = $serviceId; } } } $datagridEventListeners = array_unique($datagridEventListeners); foreach ($datagridEventListeners as $serviceId) { if ($container->hasDefinition($serviceId)) { $serviceDef = $container->getDefinition($serviceId); if (!$serviceDef->isLazy()) { $serviceDef->setLazy(true); } } } }
public function process(ContainerBuilder $container) { $loaderRefs = array(); $loaderAliases = array(); $exporterRefs = array(); // look for all tagged translation file loaders, inject them into the importer foreach ($container->findTaggedServiceIds('translation.loader') as $id => $attributes) { $loaderAliases[$id][] = $attributes[0]['alias']; $loaderRefs[$attributes[0]['alias']] = new Reference($id); if (isset($attributes[0]['legacy-alias'])) { $loaderAliases[$id][] = $attributes[0]['legacy-alias']; $loaderRefs[$attributes[0]['legacy-alias']] = new Reference($id); } } if ($container->hasDefinition('kunstmaan_translator.service.importer.importer')) { $container->getDefinition('kunstmaan_translator.service.importer.importer')->addMethodCall('setLoaders', array($loaderRefs)); } if ($container->hasDefinition('kunstmaan_translator.service.translator.translator')) { $container->getDefinition('kunstmaan_translator.service.translator.translator')->replaceArgument(2, $loaderAliases); } // add all exporter into the translation exporter foreach ($container->findTaggedServiceIds('translation.exporter') as $id => $attributes) { $exporterRefs[$attributes[0]['alias']] = new Reference($id); } if ($container->hasDefinition('kunstmaan_translator.service.exporter.exporter')) { $container->getDefinition('kunstmaan_translator.service.exporter.exporter')->addMethodCall('setExporters', array($exporterRefs)); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $chainProviderServiceId = $this->getChainProviderServiceId(); if (!$container->hasDefinition($chainProviderServiceId)) { return; } // find providers $providers = []; $taggedServices = $container->findTaggedServiceIds($this->getProviderTagName()); foreach ($taggedServices as $id => $attributes) { if ($container->hasDefinition($id)) { $container->getDefinition($id)->setPublic(false); } $priority = isset($attributes[0]['priority']) ? $attributes[0]['priority'] : 0; $providers[$priority][] = new Reference($id); } if (empty($providers)) { return; } // sort by priority and flatten ksort($providers); $providers = call_user_func_array('array_merge', $providers); // register $serviceDef = $container->getDefinition($chainProviderServiceId); foreach ($providers as $provider) { $serviceDef->addMethodCall('addProvider', [$provider]); } }
/** * Configure core with all admin services * * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('sfs.admin.routing_loader') || !$container->hasDefinition('sfs.admin.menu_builder')) { return; } $core = $container->getDefinition('sfs.admin.core'); $menuBuilder = $container->getDefinition('sfs.admin.menu_builder'); /** * Handles the admin Resources, connected to an entity */ $taggedServices = $container->findTaggedServiceIds('sfs_admin.resource'); foreach ($taggedServices as $id => $tagAttributes) { // id is the current admin's service name with the tag 'sfs_admin.resource' and being looped foreach ($tagAttributes as $attributes) { $container->getDefinition($id)->addMethodCall('setContainer', array(new Reference('service_container'))); $container->getDefinition($id)->addMethodCall('setFilterForm'); $core->addMethodCall('addAdmin', array($id, $attributes)); $menuBuilder->addMethodCall('addResource', array($attributes)); } } /** * */ $taggedServices = $container->findTaggedServiceIds('sfs_admin.menu.topbar'); foreach ($taggedServices as $id => $tagAttributes) { $menuBuilder->addMethodCall('addTopbarBlock', array($id)); } }
/** * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container */ public function attachProviders(ContainerBuilder $container) { #set slugify service $serviceId = $container->getParameter('bruery.media.slugify_service'); $galleryPool = $container->getDefinition('bruery.media.gallery.pool'); $galleryPool->addMethodCall('setSlugify', array(new Reference($serviceId))); $galleryHasMediaPool = $container->getDefinition('bruery.media.gallery_has_media.pool'); $galleryHasMediaPool->addMethodCall('setSlugify', array(new Reference($serviceId))); foreach ($container->findTaggedServiceIds('bruery.media.gallery_provider') as $id => $attributes) { $galleryPool->addMethodCall('addProvider', array($id, new Reference($id))); } foreach ($container->findTaggedServiceIds('bruery.media.gallery_has_media_provider') as $id => $attributes) { $galleryHasMediaPool->addMethodCall('addProvider', array($id, new Reference($id))); } $collections = $container->getParameter('bruery.media.gallery.provider.collections'); foreach ($collections as $name => $settings) { if ($settings['gallery']['provider']) { $galleryPool->addMethodCall('addCollection', array($name, $settings['gallery']['provider'], array())); if ($container->hasDefinition($settings['gallery']['provider'])) { $provider = $container->getDefinition($settings['gallery']['provider']); $provider->addMethodCall('setSlugify', array(new Reference($serviceId))); } } if ($settings['gallery_has_media']['provider']) { $galleryHasMediaPool->addMethodCall('addCollection', array($name, $settings['gallery_has_media']['provider'], $settings['gallery_has_media']['settings'])); if ($container->hasDefinition($settings['gallery_has_media']['provider'])) { $provider = $container->getDefinition($settings['gallery_has_media']['provider']); $provider->addMethodCall('setSlugify', array(new Reference($serviceId))); $provider->addMethodCall('setCategoryManager', array(new Reference('sonata.classification.manager.category'))); } } } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('rollerworks_multi_user.user_discriminator')) { return; } $requestListener = null; $authenticationListener = null; if ($container->hasDefinition('rollerworks_multi_user.listener.request')) { $requestListener = $container->getDefinition('rollerworks_multi_user.listener.request'); } if ($container->hasDefinition('rollerworks_multi_user.listener.authentication')) { $authenticationListener = $container->getDefinition('rollerworks_multi_user.listener.authentication'); } $userDiscriminator = $container->getDefinition('rollerworks_multi_user.user_discriminator'); foreach ($container->findTaggedServiceIds('rollerworks_multi_user.user_system') as $id => $attributes) { $name = $attributes[0]['alias']; if (!isset($attributes[0]['request_matcher'])) { $requestMatcher = $this->createRequestMatcher($container, $container->getParameterBag()->resolveValue($attributes[0]['path']), $container->getParameterBag()->resolveValue($attributes[0]['host'])); } else { $requestMatcher = new Reference($attributes[0]['request_matcher']); } if ($authenticationListener) { $authenticationListener->addMethodCall('addUser', array($name, $container->getParameterBag()->resolveValue($attributes[0]['class']))); } if ($requestListener) { $requestListener->addMethodCall('addUser', array($name, $requestMatcher)); } $userDiscriminator->addMethodCall('addUser', array($name, new Reference($id))); } }
/** * Process the adaptor config configuration. * * @param array $config * @param ContainerBuilder $container */ protected function loadConfigs(array $config, ContainerBuilder $container) { foreach ($config['configs'] as $name => $arguments) { if (!$arguments['enabled']) { continue; } $id = 'integrated_channel.config.memory.' . $name; if ($container->hasDefinition($id)) { continue; } // first create the options and for that we need a unique service id do { $id_options = $id . '.options.' . uniqid(); } while ($container->hasDefinition($id_options)); $definition = new Definition('%integrated_channel.config.options.class%'); $definition->setPublic(false); $definition->setArguments([$arguments['options']]); $container->setDefinition($id_options, $definition); // create the config it self $definition = new Definition('%integrated_channel.config.class%'); $definition->setArguments([$name, $arguments['adaptor'], new Reference($id_options)]); if ($arguments['channel']) { foreach ($arguments['channel'] as $channel) { $definition->addTag('integrated_channel.config', ['channel' => $channel]); } } else { $definition->addTag('integrated_channel.config'); } $container->setDefinition($id, $definition); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('templating.engine.php') && $container->hasDefinition('ivory_ck_editor.renderer')) { $definition = $container->getDefinition('sonata.formatter.twig.ck_editor'); $definition->replaceArgument(0, 'ivory_ck_editor.renderer'); } }
public function process(ContainerBuilder $container) { if ($container->hasDefinition('templating')) { return; } if ($container->hasDefinition('templating.engine.php')) { $helpers = array(); foreach ($container->findTaggedServiceIds('templating.helper') as $id => $attributes) { if (isset($attributes[0]['alias'])) { $helpers[$attributes[0]['alias']] = $id; } } $definition = $container->getDefinition('templating.engine.php'); $arguments = $definition->getArguments(); $definition->setArguments($arguments); if (count($helpers) > 0) { $definition->addMethodCall('setHelpers', array($helpers)); } } if ($container->hasDefinition('templating.engine.delegating')) { $queue = new \SplPriorityQueue(); foreach ($container->findTaggedServiceIds('templating.engine') as $id => $attributes) { $queue->insert($id, isset($attributes[0]['priority']) ? $attributes[0]['priority'] : 0); } $engines = array(); foreach ($queue as $engine) { $engines[] = $engine; } $container->getDefinition('templating.engine.delegating')->addMethodCall('setEngineIds', array($engines)); } }
/** * @param $id * * @return bool|null */ public function has($id) { if (null === $this->container) { return; } return $this->container->hasDefinition($id); }
public function process(ContainerBuilder $container) { // Cache warmer does more harm than good with Drupal. if ($container->hasDefinition('cache_warmer')) { $container->removeDefinition('cache_warmer'); } if ($container->hasAlias('cache_warmer')) { $container->removeAlias('cache_warmer'); } // When not working with symfony, we need to provide a file locator // service of our own instead of the symfony's one if (!$container->hasDefinition('file_locator') && !$container->hasAlias('file_locator')) { $container->addDefinitions(['file_locator' => (new Definition())->setClass(CustomFileLocator::class)->addArgument(new Reference('kernel'))]); } else { // We are working with fullstack, and our users might have changed // the global resource directory to somewhere safer than Drupal's // sites/SITE folder, case in which we must honnor the user's // configuration $definition = $container->getDefinition('file_locator'); $definition->setArguments([new Reference('kernel'), $container->getParameter('kernel.root_dir') . '/Resources']); } // By registering the framework bundle, we also inherit from Symfony // default URL generator, which will cause us great pain because of // Drupal routes will not be known by the framework and throw a few // exceptions. if ($container->has('router.default')) { $container->getDefinition('router.default')->setClass('MakinaCorpus\\Drupal\\Sf\\Routing\\Router'); } // When NOT in fullstack mode, we need to provide a null implementation // for the controller resolver service, else the container will be // unable to spawn the http kernel service if (!$container->has('controller_resolver')) { $container->addDefinitions(['controller_resolver' => (new Definition())->setClass('controller_resolver')]); } }
public function process(ContainerBuilder $container) { if (!$container->hasDefinition('twig')) { return; } if (class_exists('\\TFD_Environment')) { $twigEnvDefinition = $container->getDefinition('twig'); $twigEnvDefinition->setClass('MakinaCorpus\\Drupal\\Sf\\Twig\\TFD\\Environment'); if (class_exists('\\TFD_Extension')) { $twigEnvDefinition->addMethodCall('addExtension', [new Definition('TFD_Extension')]); } } // If the Twig bridge from Symfony is present and loaded, do not load // our own translation extension but Symfony's one instead: since this // commit: // // https://github.com/symfony/symfony/commit/24e9cf215590d1090b3d4acbf07e1fb44a973ca8 // // which aims to extend support to Twig 2.x, the translator extension // is not loaded by name anymore, but by class, which makes it not // possible to override, we need to use the same class name. if (class_exists('\\Symfony\\Bridge\\Twig\\Extension\\TranslationExtension')) { if ($container->hasDefinition('twig.extension.trans')) { $container->getDefinition('twig.extension.trans')->setClass(TranslationExtension::class)->setArguments([new Reference('translator')]); } } }
/** * {@inheritDoc} */ public function process(ContainerBuilder $container) { // WebHome Auth url in user bar if ($container->hasParameter('webhome_auth_url')) { $container->getDefinition('webhome.menu.user_bar')->addArgument($container->getParameter('webhome_auth_url')); } // Listener for build menu if (!$container->hasDefinition('webhome.listener.menu')) { return; } $config = $container->getExtensionConfig('ndewez_web_home_common')[0]; $menuListener = $container->getDefinition('webhome.listener.menu'); if (isset($config['menu']['getter'])) { if (!$container->hasDefinition($config['menu']['getter'])) { throw new InvalidArgumentException(sprintf('Service %s doesn\'t exists', $config['menu']['getter'])); } $menuListener->addMethodCall('setGetter', [$container->getDefinition($config['menu']['getter'])]); } if (isset($config['menu']['builder'])) { if (!$container->hasDefinition($config['menu']['builder'])) { throw new InvalidArgumentException(sprintf('Service %s doesn\'t exists', $config['menu']['builder'])); } $menuListener->addMethodCall('setBuilderMenuItems', [$container->getDefinition($config['menu']['builder'])]); } if (isset($config['menu']['builder'])) { $menuListener->addMethodCall('setUseSession', [$config['menu']['session']]); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if ($container->hasDefinition('doctrine')) { $definition = new DefinitionDecorator('dag.form.type.object_to_identifier'); $definition->addArgument(new Reference('doctrine')); $definition->addArgument('dag_entity_to_identifier'); $definition->addTag('form.type', array('alias' => 'dag_entity_to_identifier')); $container->setDefinition('dag_entity_to_identifier', $definition); } if ($container->hasDefinition('doctrine_mongodb')) { $definition = new DefinitionDecorator('dag.form.type.object_to_identifier'); $definition->addArgument(new Reference('doctrine_mongodb')); $definition->addArgument('dag_document_to_identifier'); $definition->addTag('form.type', array('alias' => 'dag_document_to_identifier')); $container->setDefinition('dag_document_to_identifier', $definition); if (!$container->hasDefinition('dag_entity_to_identifier')) { $container->setAlias('dag_entity_to_identifier', 'dag_document_to_identifier'); } } if ($container->hasDefinition('doctrine_phpcr')) { $definition = new DefinitionDecorator('dag.form.type.object_to_identifier'); $definition->addArgument(new Reference('doctrine_phpcr')); $definition->addArgument('dag_phpcr_document_to_identifier'); $definition->addTag('form.type', array('alias' => 'dag_phpcr_document_to_identifier')); $container->setDefinition('dag_phpcr_document_to_identifier', $definition); if (!$container->hasDefinition('dag_entity_to_identifier')) { $container->setAlias('dag_entity_to_identifier', 'dag_phpcr_document_to_identifier'); } } }
public function process(ContainerBuilder $container) { if (!($container->hasDefinition('fragment.listener') && $container->hasDefinition('ezpublish.decorated_fragment_renderer'))) { return null; } $fragmentListenerDef = $container->findDefinition('fragment.listener'); $fragmentListenerDef->setFactoryService('ezpublish.fragment_listener.factory')->setFactoryMethod('buildFragmentListener')->addArgument('%fragment.listener.class%'); // Looping over all fragment renderers to decorate them // This is to make sure they are siteaccess aware (siteaccess is serialized in rendered path). foreach ($container->findTaggedServiceIds('kernel.fragment_renderer') as $id => $attributes) { $renamedId = "{$id}.inner"; $definition = $container->getDefinition($id); $public = $definition->isPublic(); $tags = $definition->getTags(); $definition->setPublic(false); $container->setDefinition($renamedId, $definition); $decoratedDef = new DefinitionDecorator('ezpublish.decorated_fragment_renderer'); $decoratedDef->setArguments(array(new Reference($renamedId))); $decoratedDef->setPublic($public); $decoratedDef->setTags($tags); // Special treatment for inline fragment renderer, to fit ESI renderer constructor type hinting (forced to InlineFragmentRenderer) if ($id === 'fragment.renderer.inline') { $decoratedDef->setClass($container->getParameter('ezpublish.decorated_fragment_renderer.inline.class')); } $container->setDefinition($id, $decoratedDef); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { // loaders $loaders = array(); $loadersReferences = array(); foreach ($container->findTaggedServiceIds('translation.loader') as $id => $attributes) { $loaders[$id][] = $attributes[0]['alias']; $loadersReferences[$attributes[0]['alias']] = new Reference($id); if (isset($attributes[0]['legacy-alias'])) { $loaders[$id][] = $attributes[0]['legacy-alias']; $loadersReferences[$attributes[0]['legacy-alias']] = new Reference($id); } } if ($container->hasDefinition('lexik_translation.translator')) { $container->findDefinition('lexik_translation.translator')->replaceArgument(2, $loaders); } if ($container->hasDefinition('lexik_translation.importer.file')) { $container->findDefinition('lexik_translation.importer.file')->replaceArgument(0, $loadersReferences); } // exporters if ($container->hasDefinition('lexik_translation.exporter_collector')) { foreach ($container->findTaggedServiceIds('lexik_translation.exporter') as $id => $attributes) { $container->getDefinition('lexik_translation.exporter_collector')->addMethodCall('addExporter', array($id, new Reference($id))); } } }
public function testServices() { $this->extension->load(self::$config, $this->container); foreach (self::$services as $service) { $this->assertTrue($this->container->hasDefinition('aws.' . $service)); } }
/** * @test * @depends initialize */ public function load() { $this->extension->load($this->container, []); foreach (['behat.environment.reader', 'context.initializer'] as $id) { self::assertTrue(null !== $this->container->hasDefinition(self::KEY . '.' . $id)); } }
public function process(ContainerBuilder $container) { $issuer = $container->getParameter('jwt_iss'); $definition = $container->getDefinition('oauth2.server'); $args = $definition->getArguments(); $args['oauth2.server.storage'][] = new Reference('oauth2.storage.user_claims'); $args['oauth2.server.storage'][] = new Reference('oauth2.storage.public_key'); $args['oauth2.server.grant_types'] = array(); $args['oauth2.server.response_types'] = array('token' => new Reference('oauth2.response_types.token'), 'code' => new Reference('oauth2.response_types.code'), 'id_token' => new Reference('oauth2.response_types.id_token'), 'id_token token' => new Reference('oauth2.response_types.id_token_token'), 'code id_token' => new Reference('oauth2.response_types.code_id_token')); $definition->setArguments($args); if ($container->hasDefinition('gaufrette.jwks_fs_filesystem')) { $filesystem = new Reference('gaufrette.jwks_fs_filesystem'); $fileName = $container->getParameter('jwks_private_key_file'); $container->getDefinition('oauth2.storage.public_key')->addMethodCall('setFilesystem', array($filesystem, $fileName)); } if ($container->hasDefinition('oauth2.grant_type.authorization_code')) { $sessionState = new Reference('oidc.storage.session_state'); $container->getDefinition('oauth2.grant_type.authorization_code')->addMethodCall('setSessionStateStorage', array($sessionState)); } if ($container->hasDefinition('oauth2.storage.authorization_code')) { $sessionState = new Reference('oidc.storage.session_state'); $container->getDefinition('oauth2.storage.authorization_code')->addMethodCall('setSessionStateStorage', array($sessionState)); } if ($container->hasDefinition('oauth2.scope_manager')) { $scopes = $container->getParameter('lc_supported_scopes'); $container->getDefinition('oauth2.scope_manager')->addMethodCall('setScopes', array($scopes)); } if ($container->hasDefinition('oauth2.storage.access_token')) { $secret = $container->getParameter('secret'); $container->getDefinition('oauth2.storage.access_token')->addMethodCall('setPairwiseSubjectIdSalt', array($secret)); } }
/** * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('innomatic.chain_router')) { return; } $chainRouter = $container->getDefinition('innomatic.chain_router'); // Enforce default router to be part of the routing chain // The default router will be given the highest priority so that it will be used by default if ($container->hasDefinition('router.default')) { $defaultRouter = $container->getDefinition('router.default'); if (!$defaultRouter->hasTag('router')) { $defaultRouter->addTag('router', array('priority' => 255)); } } foreach ($container->findTaggedServiceIds('router') as $id => $attributes) { $priority = isset($attributes[0]['priority']) ? (int) $attributes[0]['priority'] : 0; // Priority range is between -255 (the lowest) and 255 (the highest) if ($priority > 255) { $priority = 255; } if ($priority < -255) { $priority = -255; } $chainRouter->addMethodCall('add', array(new Reference($id), $priority)); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if ($container->hasDefinition('run_open_code.query_resources_loader')) { $definition = $container->getDefinition('run_open_code.query_resources_loader'); $executors = array(); foreach ($container->findTaggedServiceIds('run_open_code.query_resources_loader.executor') as $id => $tags) { foreach ($tags as $attributes) { $definition->addMethodCall('registerExecutor', array(new Reference($id), $attributes['name'])); $executors[$attributes['name']] = $id; } } if (0 === count($executors)) { throw new LogicException('At least one query executor is required to be registered, none found.'); } if ($container->hasParameter('run_open_code.query_resources_loader.default_executor') && null !== $container->getParameter('run_open_code.query_resources_loader.default_executor')) { $defaultExecutor = $container->getParameter('run_open_code.query_resources_loader.default_executor'); } else { $executors = array_values($executors); $defaultExecutor = $executors[0]; } if (!$container->hasDefinition($defaultExecutor)) { throw new LogicException(sprintf('Default query executor "%s" can not be found.', $defaultExecutor)); } $definition->addMethodCall('registerExecutor', array(new Reference($defaultExecutor), 'default')); } }
public function testListenersAreNotRegisteredByDefault() { $config = ['driver' => 'doctrine']; $this->extension->load([$config], $this->container); foreach (['error_log', 'logger', 'failure'] as $listener) { $this->assertFalse($this->container->hasDefinition('bernard.listener.' . $listener)); } }