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