Adds a method to call after service initialization.
|
public addMethodCall ( string $method, array $arguments = [] ) : |
||
| $method | string | The method name to call |
| $arguments | array | An array of arguments to pass to the method call |
| return | The current instance | |
/**
* @param string $name
* @param array $config
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
*
* @return \Symfony\Component\DependencyInjection\Reference
*/
private function getConnectionReference($name, array $config, ContainerBuilder $container)
{
if (isset($config['connection_id'])) {
return new Reference($config['connection_id']);
}
$host = $config['host'];
$port = $config['port'];
$connClass = '%doctrine_cache.redis.connection.class%';
$connId = sprintf('doctrine_cache.services.%s_redis.connection', $name);
$connDef = new Definition($connClass);
$connParams = array($host, $port);
if (isset($config['timeout'])) {
$connParams[] = $config['timeout'];
}
$connDef->setPublic(false);
$connDef->addMethodCall('connect', $connParams);
if (isset($config['password'])) {
$password = $config['password'];
$connDef->addMethodCall('auth', array($password));
}
if (isset($config['database'])) {
$database = (int) $config['database'];
$connDef->addMethodCall('select', array($database));
}
$container->setDefinition($connId, $connDef);
return new Reference($connId);
}
/**
* Creates a new Guzzle client definition
*
* @param string $name Client name
* @param array $config Client configuration
* @param ContainerBuilder $container Service container
*
* @throws \LogicException
*/
private function newGuzzleClient($name, array $config, ContainerBuilder $container)
{
$client = new Definition('Guzzle\\Service\\Description\\ServiceDescription');
$client->setFactory(['Guzzle\\Service\\Description\\ServiceDescription', 'factory']);
if (!isset($config['description']['name'])) {
$config['description']['name'] = $name;
}
$client->addArgument($config['description']);
// Add the service to the container
$serviceName = sprintf('lsw_guzzle.%s', $name);
$container->setDefinition($serviceName, $client);
$client = new Definition('Guzzle\\Service\\Client');
$client->setFactory(['Guzzle\\Service\\Client', 'factory']);
$client->addArgument($config['config']);
$client->addMethodCall('setDescription', array(new Reference($serviceName)));
$client->addMethodCall('addSubscriber', array(new Reference('lsw_guzzle.log_plugin')));
if (isset($config['config']['json_objects']) && $config['config']['json_objects']) {
$client->addMethodCall('addSubscriber', array(new Reference('lsw_guzzle.json_objects_plugin')));
}
if ($container->hasDefinition('lsw_guzzle.command_history_plugin')) {
$client->addMethodCall('addSubscriber', array(new Reference('lsw_guzzle.command_history_plugin')));
}
// Add the service to the container
$serviceName = sprintf('guzzle.%s', $name);
$container->setDefinition($serviceName, $client);
}
protected function loadQueues()
{
$qmDefinition = null;
if ($this->container->hasDefinition($this->queueManagerService)) {
$qmDefinition = $this->container->findDefinition($this->queueManagerService);
}
foreach ($this->config['queues'] as $key => $consumer) {
if (!isset($this->config['connections'][$consumer['connection']])) {
throw new \RuntimeException("SQS queue '{$key}' can not use connection '{$consumer['connection']}' because it is not defined in the connections section");
}
$pDefinition = new Definition('%kaliop_queueing.sqs.producer.class%', array($this->config['connections'][$consumer['connection']]));
$pDefinition->addMethodCall('setQueueUrl', array($consumer['queue_options']['name']));
$name = sprintf('kaliop_queueing.sqs.%s_producer', $key);
$this->container->setDefinition($name, $pDefinition);
$cDefinition = new Definition('%kaliop_queueing.sqs.consumer.class%', array($this->config['connections'][$consumer['connection']]));
$cDefinition->addMethodCall('setQueueUrl', array($consumer['queue_options']['name']))->addMethodCall('setCallback', array(new Reference($consumer['callback'])));
if (count($consumer['queue_options']['routing_keys'])) {
$cDefinition->addMethodCall('setRoutingKey', array(reset($consumer['queue_options']['routing_keys'])));
}
if ($consumer['queue_options']['max_messages_per_request'] > 1) {
$cDefinition->addMethodCall('setRequestBatchSize', array($consumer['queue_options']['max_messages_per_request']));
}
$name = sprintf('kaliop_queueing.sqs.%s_consumer', $key);
$this->container->setDefinition($name, $cDefinition);
//if (!$consumer['auto_setup_fabric']) {
// $definition->addMethodCall('disableAutoSetupFabric');
//}
if ($qmDefinition) {
$qmDefinition->addMethodCall('registerQueue', array($key));
}
}
}
protected function createRpcServer($connection)
{
$rpcServer = new Definition('%rezzza_jobflow.rabbitmq.rpc_server.class%', array($connection));
$rpcServer->addMethodCall('initServer', array('jobflow'));
$rpcServer->addMethodCall('setCallback', array(new Reference('rezzza_jobflow.rabbitmq.worker')));
return $rpcServer;
}
/**
* Check if load adds parameters to container as expected.
*
* @param array $parameters
* @param array $expectedConnections
* @param array $expectedManagers
*
* @dataProvider getData
*/
public function testLoad($parameters, $expectedConnections, $expectedManagers)
{
$container = new ContainerBuilder();
class_exists('testClass') ?: eval('class testClass {}');
$container->setParameter('kernel.bundles', ['testBundle' => 'testClass']);
$container->setParameter('kernel.cache_dir', '');
$container->setParameter('kernel.debug', true);
$extension = new ONGRElasticsearchExtension();
$extension->load($parameters, $container);
if ($parameters['elasticsearch']['managers']['test']['debug']) {
$reflection = new \ReflectionClass($this);
$dir = dirname($reflection->getFileName()) . DIRECTORY_SEPARATOR . 'customDir';
$handler = new Definition('ONGR\\ElasticsearchBundle\\Logger\\Handler\\CollectionHandler', []);
$logger = new Definition('Monolog\\Logger', ['tracer', [$handler]]);
$collector = new Definition('ONGR\\ElasticsearchBundle\\DataCollector\\ElasticsearchDataCollector');
$collector->addMethodCall('setManagers', [new Parameter('es.managers')]);
$collector->addMethodCall('addLogger', [new Reference('es.logger.trace')]);
$collector->addTag('data_collector', ['template' => 'ONGRElasticsearchBundle:Profiler:profiler.html.twig', 'id' => 'es']);
$this->assertEquals($collector, $container->getDefinition('es.collector'));
$this->assertEquals($logger, $container->getDefinition('es.logger.trace'));
$this->assertEquals(new DirectoryResource($dir), $container->getResources()[1]);
}
$this->assertEquals($expectedConnections, $container->getParameter('es.connections'), 'Incorrect connections parameter.');
$this->assertEquals($expectedManagers, $container->getParameter('es.managers'), 'Incorrect managers parameter');
$this->assertTrue($container->hasDefinition('es.metadata_collector'), 'Container should have MetadataCollector definition set.');
}
protected function loadConsumers()
{
$qmDefinition = null;
if ($this->container->hasDefinition($this->queueManagerService)) {
$qmDefinition = $this->container->findDefinition($this->queueManagerService);
}
foreach ($this->config['consumers'] as $key => $consumer) {
if (!isset($this->config['connections'][$consumer['connection']])) {
throw new \RuntimeException("Stomp consumer '{$key}' can not use connection '{$consumer['connection']}' because it is not defined in the connections section");
}
$connectionDefinition = $this->config['connections'][$consumer['connection']];
$cDefinition = new Definition('%kaliop_queueing.stomp.consumer.class%', array($connectionDefinition));
$cDefinition->addMethodCall('setSubscriptionName', array($consumer['subscription_options']['name']))->addMethodCall('setStompQueueName', array($consumer['queue_options']['name']))->addMethodCall('setCallback', array(new Reference($consumer['callback'])));
if (count($consumer['subscription_options']['routing_keys'])) {
$cDefinition->addMethodCall('setRoutingKey', array(reset($consumer['subscription_options']['routing_keys'])));
}
$name = sprintf('kaliop_queueing.stomp.%s_consumer', $key);
$this->container->setDefinition($name, $cDefinition);
//if (!$consumer['auto_setup_fabric']) {
// $definition->addMethodCall('disableAutoSetupFabric');
//}
if ($qmDefinition) {
$qmDefinition->addMethodCall('registerConsumer', array($key));
}
}
}
protected function handleConfiguration($config, ContainerBuilder $container)
{
if (!isset($config['features'])) {
return;
}
if (!$container->hasDefinition('hotflo_feature_toggle.feature_container')) {
return;
}
$featureToggleContainerDefinition = $container->findDefinition('hotflo_feature_toggle.feature_toggle_container');
foreach ($config['toggles'] as $toggle => $properties) {
if ($properties['type'] == 'service') {
$container->setAlias('hotflo_feature_toggle.toggle.' . $toggle, $properties['service']);
} else {
if (!class_exists($properties['class'])) {
throw new InvalidConfigurationException(sprintf('Class \'%s\' not found.', $properties['class']));
}
$toggleDefinition = new Definition($properties['class']);
$toggleDefinition->addArgument($properties['options']);
$container->setDefinition('hotflo_feature_toggle.toggle.' . $toggle, $toggleDefinition);
}
$featureToggleContainerDefinition->addMethodCall('addFeatureToggle', [new Reference('hotflo_feature_toggle.toggle.' . $toggle), $toggle]);
}
$featureContainerDefinition = $container->findDefinition('hotflo_feature_toggle.feature_container');
foreach ($config['features'] as $feature => $properties) {
$featureDefinition = new Definition('JoshuaEstes\\Component\\FeatureToggle\\Feature');
$featureDefinition->addArgument($properties['options']);
$featureDefinition->addMethodCall('setKey', [$feature]);
$featureDefinition->addMethodCall('setToggle', [new Reference('hotflo_feature_toggle.toggle.' . $properties['toggle'])]);
$container->setDefinition('hotflo_feature_toggle.feature.' . $feature, $featureDefinition);
$featureContainerDefinition->addMethodCall('addFeature', [new Reference('hotflo_feature_toggle.feature.' . $feature)]);
}
}
/**
* Apply the default values required by the AdminInterface to the Admin service definition
*
* @param \Symfony\Component\DependencyInjection\Definition $definition
* @param array $attributes
* @return \Symfony\Component\DependencyInjection\Definition
*/
public function applyDefaults(Definition $definition, array $attributes = array())
{
$definition->setScope(ContainerInterface::SCOPE_PROTOTYPE);
$manager_type = $attributes[0]['manager_type'];
if (!$definition->hasMethodCall('setModelManager')) {
$definition->addMethodCall('setModelManager', array(new Reference(sprintf('sonata.admin.manager.%s', $manager_type))));
}
if (!$definition->hasMethodCall('setFormContractor')) {
$definition->addMethodCall('setFormContractor', array(new Reference(sprintf('sonata.admin.builder.%s_form', $manager_type))));
}
if (!$definition->hasMethodCall('setListBuilder')) {
$definition->addMethodCall('setListBuilder', array(new Reference(sprintf('sonata.admin.builder.%s_list', $manager_type))));
}
if (!$definition->hasMethodCall('setDatagridBuilder')) {
$definition->addMethodCall('setDatagridBuilder', array(new Reference(sprintf('sonata.admin.builder.%s_datagrid', $manager_type))));
}
if (!$definition->hasMethodCall('setTranslator')) {
$definition->addMethodCall('setTranslator', array(new Reference('translator')));
}
if (!$definition->hasMethodCall('setConfigurationPool')) {
$definition->addMethodCall('setConfigurationPool', array(new Reference('sonata.admin.pool')));
}
if (!$definition->hasMethodCall('setRouter')) {
$definition->addMethodCall('setRouter', array(new Reference('router')));
}
if (!$definition->hasMethodCall('setLabel')) {
$label = isset($attributes[0]['label']) ? $attributes[0]['label'] : '-';
$definition->addMethodCall('setLabel', array($label));
}
$definition->addMethodCall('configure');
return $definition;
}
/**
* @param string $name
* @param array $config
* @param ContainerBuilder $container
*
* @return $this
*/
protected function registerConnection(ContainerBuilder $container, $config, $name = 'default')
{
$config += ['cache' => null, 'class' => 'Phppro\\Sdk\\Connection\\DefaultConnection'];
$def = new Definition($config['class'], [$config]);
$def->addMethodCall('setEventDispatcher', [new Reference('event_dispatcher')]);
switch ($config['cache']) {
case null:
case 'none':
break;
case 'memory':
$def->addMethodCall('setCache', [new Reference('sdk.cache.memory')]);
break;
case 'session':
$def->addMethodCall('setCache', [new Reference('sdk.cache.session')]);
break;
case 'redis':
$def->addMethodCall('setCache', [new Reference('sdk.cache.redis')]);
break;
default:
throw new InvalidConfigurationException(sprintf("Unsupported SDK cache type '%s'", $config['cache']), 500);
}
$def->addTag('sdk.connection', ['connection' => $name]);
$container->setDefinition('sdk.connection.' . $name, $def);
return $this;
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$immutableProperties = array_merge($config['content_immutable_properties'], array('linkedToSite', 'deleted'));
$container->setParameter('open_orchestra_model.content.immutable_properties', $immutableProperties);
foreach ($config['fixtures_interface'] as $command => $content) {
$container->setParameter('open_orchestra_model.fixtures_interface.' . $command, $content);
}
$container->setParameter('open_orchestra_model.fixtures.command', array_keys($config['fixtures_interface']));
foreach ($config['document'] as $class => $content) {
if (is_array($content)) {
$container->setParameter('open_orchestra_model.document.' . $class . '.class', $content['class']);
if (array_key_exists('repository', $content)) {
$definition = new Definition($content['repository'], array($content['class']));
$definition->setFactory(array(new Reference('doctrine.odm.mongodb.document_manager'), 'getRepository'));
$definition->addMethodCall('setAggregationQueryBuilder', array(new Reference('doctrine_mongodb.odm.default_aggregation_query')));
if (method_exists($content['repository'], 'setFilterTypeManager')) {
$definition->addMethodCall('setFilterTypeManager', array(new Reference('open_orchestra_pagination.filter_type.manager')));
}
$container->setDefinition('open_orchestra_model.repository.' . $class, $definition);
}
}
}
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('listener.yml');
$loader->load('validator.yml');
$loader->load('manager.yml');
$loader->load('saver.yml');
$loader->load('form.yml');
$loader->load('transformer.yml');
$loader->load('helper.yml');
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
foreach ($container->findTaggedServiceIds('snc_redis.connection_parameters') as $id => $attr) {
$clientAlias = $attr[0]['clientAlias'];
$parameterDefinition = $container->getDefinition($id);
$parameters = $parameterDefinition->getArgument(0);
if ($parameters['logging']) {
$optionId = sprintf('snc_redis.client.%s_options', $clientAlias);
$option = $container->getDefinition($optionId);
if (1 < count($option->getArguments())) {
throw new \RuntimeException('Please check the predis option arguments.');
}
$arguments = $option->getArgument(0);
$connectionFactoryId = sprintf('snc_redis.%s_connectionfactory', $clientAlias);
$connectionFactoryDef = new Definition($container->getParameter('snc_redis.connection_factory.class'));
$connectionFactoryDef->setPublic(false);
$connectionFactoryDef->addArgument(new Reference(sprintf('snc_redis.client.%s_profile', $clientAlias)));
$connectionFactoryDef->addMethodCall('setConnectionWrapperClass', array($container->getParameter('snc_redis.connection_wrapper.class')));
$connectionFactoryDef->addMethodCall('setLogger', array(new Reference('snc_redis.logger')));
$container->setDefinition($connectionFactoryId, $connectionFactoryDef);
$arguments['connections'] = new Reference($connectionFactoryId);
$option->replaceArgument(0, $arguments);
}
}
}
/**
* @param Definition $definition
* @param string $id
* @param array $tags
*/
protected function addConnection(Definition $definition, $id, $tags)
{
$definition->addMethodCall('setRequestFactory', [new Reference('ms.rpc.request_factory')]);
$definition->addMethodCall('setResponseFactory', [new Reference('ms.rpc.response_factory')]);
$definition->addMethodCall('setSerializer', [new Reference('serializer')]);
$definition->setLazy(true);
}
public function load(array $configs, ContainerBuilder $container)
{
$loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
$config = array();
foreach ($configs as $subConfig) {
$config = array_merge($config, $subConfig);
}
foreach ($config['email'] as $alias => $options) {
$optionId = sprintf('rage_notification.email.%s.message', $alias);
$optionDef = new Definition($container->getParameter('rage_notification.email_message.class'));
$optionDef->setShared(false);
$optionDef->addArgument(new Reference('mailer'));
$optionDef->addArgument(new Reference('templating'));
if (!empty($options['from'])) {
$optionDef->addMethodCall('setFrom', [$options['from']]);
}
if (!empty($options['reply_to'])) {
$optionDef->addMethodCall('setReplyTo', [$options['reply_to']]);
}
if (!empty($options['embed_images'])) {
$optionDef->addMethodCall('setEmbedImages', [$options['embed_images']['url'], $options['embed_images']['path']]);
}
if (!empty($options['template_path'])) {
$optionDef->addMethodCall('setTemplatePath', [$options['template_path']]);
}
if (!empty($options['css_file'])) {
$optionDef->addMethodCall('setCssFile', [$options['css_file']]);
}
$container->setDefinition($optionId, $optionDef);
if ($alias === 'default') {
$container->setAlias('rage_notification.email.message', $optionId);
}
}
}
/**
* @param array $config config
*
* @return Definition
*/
private function buildProcessorCollection(ContainerBuilder $container)
{
$collection = new Definition('Dokapi\\Processor\\Collection');
if ($container->getParameter('dokapi.swagger.processors.raw_php')) {
$collection->addMethodCall('loadDefaultProcessors');
}
$processors = $container->getParameter('dokapi.swagger.processors.customs');
if ($container->getParameter('dokapi.swagger.processors.annotation')) {
$processors[] = 'Dokapi\\DokapiRest\\Processor\\Annotation\\ApiProcessor';
$processors[] = 'Dokapi\\DokapiRest\\Processor\\Annotation\\DataTypePropertyProcessor';
$processors[] = 'Dokapi\\DokapiRest\\Processor\\Annotation\\ModelProcessor';
$processors[] = 'Dokapi\\DokapiRest\\Processor\\Annotation\\OperationProcessor';
$processors[] = 'Dokapi\\DokapiRest\\Processor\\Annotation\\ResourceProcessor';
$processors[] = 'Dokapi\\DokapiRest\\Processor\\Annotation\\ResponseProcessor';
}
if ($container->getParameter('dokapi.swagger.processors.fos_rest')) {
if ($index = array_search('Dokapi\\DokapiRest\\Processor\\Annotation\\ResourceProcessor', $processors)) {
//conflicts with annotation for fos_rest integration.
unset($processors[$index]);
}
$processors[] = '@dokapi.fos_rest.processor.route';
}
if ($container->getParameter('dokapi.swagger.processor.api_distributor.enable')) {
$processors[] = '@dokapi.processor.api_distributor';
}
foreach ($processors as $processor) {
if (strpos($processor, '@') === 0) {
$processor = new Reference(substr($processor, 1));
} else {
$processor = new Definition($processor);
}
$collection->addMethodCall('add', array($processor));
}
return $collection;
}
private function loadRegistrationSubscriber(ContainerBuilder $container, array $config)
{
$definition = new Definition();
if (array_key_exists('class', $config)) {
$definition->setClass($config['class']);
} else {
$definition->setClass('Tahoe\\Bundle\\MultiTenancyBundle\\EventSubscriber\\RegistrationSubscriber');
}
$definition->addTag('kernel.event_subscriber');
if (array_key_exists('manager', $config)) {
$definition->addArgument(new Reference($config['manager']));
} else {
$definition->addArgument(new Reference('tahoe.multi_tenancy.registration_manager'));
}
if (array_key_exists('router', $config)) {
$definition->addMethodCall('setRouter', array(new Reference($config['router'])));
} else {
$definition->addMethodCall('setRouter', array(new Reference('tahoe.multi_tenancy.tenant_aware_router')));
}
if (array_key_exists('redirect_route', $config)) {
$container->setParameter(sprintf("%s.registration_subscriber.redirect_route", $this->getAlias()), $config['redirect_route']);
} else {
// default parameter
$container->setParameter(sprintf("%s.registration_subscriber.redirect_route", $this->getAlias()), 'dashboard');
}
// we add the definition to the container
$container->setDefinition('tahoe.multi_tenancy.registration_subscriber', $definition);
}
/**
* @param integer $id
* @param array $attributes
*
* @throws \InvalidArgumentException if fee calculator is improperly tagged
*/
private function fillCalculatorsArray($id, array $attributes)
{
if (!isset($attributes[0]['calculator']) || !isset($attributes[0]['label'])) {
throw new \InvalidArgumentException('Tagged fee calculators needs to have `fee_calculator` and `label` attributes.');
}
$name = $attributes[0]['calculator'];
$this->calculators[$name] = $attributes[0]['label'];
$this->registry->addMethodCall('register', array($name, new Reference($id)));
}
/**
* @param Definition $definition
* @param array $config
*/
private function configureDefinition(Definition $definition, array $config)
{
foreach ($config['servers'] as $currentServer) {
$currentServer = explode(':', $currentServer, 2);
$definition->addMethodCall('addServer', $currentServer);
}
$definition->addMethodCall('setTimeout', array($config['timeout']));
$definition->setScope('prototype');
}
/**
* @api
* @param array $config
* @param string $serviceId
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
* @return void
*/
public function createFacebookAdapterService(array $config, $serviceId, ContainerBuilder $container)
{
$definition = new Definition('Laelaps\\Bundle\\Facebook\\FacebookAdapter');
$definition->addArgument(['appId' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_APPLICATION_ID], 'secret' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_SECRET], 'fileUpload' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_FILE_UPLOAD], 'trustForwarded' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_TRUST_PROXY_HEADERS]]);
$definition->addArgument(new Reference('session'));
$definition->addArgument($config[FacebookAdapterConfiguration::CONFIG_NODE_NAME_ADAPTER_SESSION_NAMESPACE]);
$definition->addMethodCall('setContainer', [new Reference('service_container')]);
$definition->addMethodCall('staticSetContainer', [new Reference('service_container')]);
$container->setDefinition($serviceId, $definition);
}
/**
* @param Definition $definition
* @param ContainerBuilder $container
* @param array $attributes
*/
private function processTagAttributes(Definition $definition, ContainerBuilder $container, array $attributes)
{
if (isset($attributes[self::CRUD_TAG_ATTRIBUTE_OBJECT_MANAGER])) {
$objectManagerDefinition = $container->findDefinition($attributes[self::CRUD_TAG_ATTRIBUTE_OBJECT_MANAGER]);
$definition->addMethodCall(self::CRUD_METHOD_REGISTER_OBJECT_MANAGER, array($objectManagerDefinition));
}
if (isset($attributes[self::CRUD_TAG_ATTRIBUTE_LABEL])) {
$definition->addMethodCall(self::CRUD_METHOD_LABEL, array($attributes[self::CRUD_TAG_ATTRIBUTE_LABEL]));
}
}
/**
* @param ContainerBuilder $container
* @param $resourceName
* @param $configName
* @param $options
* @param bool $isSubResource
* @return Definition
*/
private function newApiResourceDefinition(ContainerBuilder $container, $resourceName, $configName, $options, $isSubResource = false)
{
$definition = new Definition(ApiResource::class);
$definition->setArguments([$resourceName, $options]);
$definition->setPublic(false);
$definition->addMethodCall('setConfigName', [$configName]);
if ($isSubResource) {
$definition->addMethodCall('setType', [ApiResource::SUB_RESOURCE]);
}
return $definition;
}
/**
* @test
*/
public function it_copies_method_calls_that_set_fallback_locales_to_theme_translator()
{
$symfonyTranslatorDefinition = new Definition();
$symfonyTranslatorDefinition->addMethodCall('setFallbackLocales', ['pl_PL']);
$symfonyTranslatorDefinition->addMethodCall('setFallbackLocales', ['en_US']);
$this->setDefinition('translator.default', $symfonyTranslatorDefinition);
$this->setDefinition('sylius.theme.translation.translator', new Definition());
$this->compile();
$this->assertContainerBuilderHasServiceDefinitionWithMethodCall('sylius.theme.translation.translator', 'setFallbackLocales', ['pl_PL']);
$this->assertContainerBuilderHasServiceDefinitionWithMethodCall('sylius.theme.translation.translator', 'setFallbackLocales', ['en_US']);
}
public function definitionProvider()
{
$definitionWithNoMethodCalls = new Definition();
$definitionWithTwoMethodCalls = new Definition();
$method = 'add';
$argumentsOfFirstCall = array('argument of first call');
$definitionWithTwoMethodCalls->addMethodCall($method, $argumentsOfFirstCall);
$argumentsOfSecondCall = array('argument of second call');
$definitionWithTwoMethodCalls->addMethodCall($method, $argumentsOfSecondCall);
$otherArguments = array('some other argument');
return array(array($definitionWithNoMethodCalls, $method, array(), false), array($definitionWithTwoMethodCalls, $method, $argumentsOfFirstCall, true), array($definitionWithTwoMethodCalls, $method, $argumentsOfSecondCall, true), array($definitionWithTwoMethodCalls, $method, $otherArguments, false));
}
protected function createServices($config, ContainerBuilder $container)
{
$definition = new Definition('%goetas.fop.processor.class%');
$definition->setArguments(array($config['executable']));
if ($config["config"] !== null) {
$definition->addMethodCall("setConfigurationFile", array($config["config"]));
}
if ($config["java"] !== null) {
$definition->addMethodCall("setJavaExecutable", array($config["config"]));
}
$definition->setPublic(true);
$container->setDefinition("goetas.fop", $definition);
}
/**
* Load the cache action configuration
*
* @param ContainerBuilder $container The container
* @param string $cacheService The cache service to use
* @param boolean $debug Is debug mode activated ?
* @param string $env Kernel env
*/
protected function loadActionCacheConfiguration(ContainerBuilder $container, $cacheService, $debug, $env)
{
if (!$container->hasParameter('m6.listener.cache_action.excludekeys')) {
$container->setParameter('m6.listener.cache_action.excludekeys', array('_template', '_cache', '_method'));
}
$definition = new Definition('%m6.action_cache.listener.class%');
$definition->addArgument($debug);
$definition->addArgument($env);
$definition->addMethodCall('setCacheService', array(new Reference($cacheService)));
$definition->addMethodCall('setCacheKeyExclude', array($container->getParameter('m6.listener.cache_action.excludekeys')));
$definition->addTag('kernel.event_subscriber');
$container->setDefinition('m6.action_cache.listener', $definition);
}
protected function injectKnownDependencies(Definition $definition)
{
$class = $definition->getClass();
$r = new \ReflectionClass($class);
if ($r->implementsInterface('RP\\CommonBundle\\CommandBus\\CommandHandler\\EntityManagerAwareInterface')) {
$definition->addMethodCall('setEntityManager', [new Reference('doctrine.orm.default_entity_manager')]);
}
if ($r->implementsInterface('RP\\CommonBundle\\CommandBus\\CommandHandler\\CommandBusAwareInterface')) {
$definition->addMethodCall('setCommandBus', [new Reference('rp.command_bus')]);
}
if ($r->implementsInterface('RP\\CommonBundle\\CommandBus\\CommandHandler\\EventDispatcherAwareInterface')) {
$definition->addMethodCall('setEventDispatcher', [new Reference('event_dispatcher')]);
}
}
/**
* @param array $config
* @return Definition
*/
protected function getManagerService(array $config)
{
$definition = new Definition('Bcn\\Extension\\RabbitMq\\Manager', array(new Reference('rabbitmq.channel')));
foreach ($config['exchanges'] as $name => $parameters) {
$definition->addMethodCall('addExchange', array($this->getExchangeDefinition($name, $parameters)));
}
foreach ($config['queues'] as $name => $parameters) {
$definition->addMethodCall('addQueue', array($this->getQueueDefinition($name, $parameters)));
}
foreach ($config['bindings'] as $parameters) {
$definition->addMethodCall('bind', array($parameters['exchange'], $parameters['queue']));
}
return $definition;
}
/**
* {@inheritdoc}
*/
protected function loadInternal(array $configs, ContainerBuilder $container)
{
$alias = $this->getAlias();
$container->setParameter('sb_event_queue.default_name', $configs['default_name']);
$container->setParameter('sb_event_queue.storage_path', $configs['storage_path']);
$storageReference = new Reference('sb_queue.storage');
$dispatcherReference = new Reference('event_dispatcher');
$definition = new Definition($configs['class']['dispatcher']);
$definition->addMethodCall('setName', [$configs['default_name']]);
$definition->addMethodCall('setStorage', [$storageReference]);
$definition->addMethodCall('setDispatcher', [$dispatcherReference]);
$container->setDefinition($alias, $definition);
$container->setAlias($configs['service_name'], $alias);
}
/**
* @param ApiResource $apiResource
*/
protected function addActions(ApiResource $apiResource)
{
$options = $this->getOptionsForApiResource($apiResource);
$def = $this->getDefinitionForApiResource($apiResource);
foreach ($this->getActionsForApiResource($apiResource) as $actionName) {
$class = Inflector::classify($actionName);
$actionClass = "BiteCodes\\RestApiGeneratorBundle\\Api\\Actions\\{$class}";
$action = new Definition($actionClass);
$action->addArgument(new Reference('router'));
$action->addMethodCall('setSecurityExpression', [$options['routes'][$actionName]['security']]);
$action->addMethodCall('setSerializationGroups', [$options['routes'][$actionName]['serialization_groups']]);
$this->container->set('bite_codes.rest_api_generator.action.' . $apiResource->getName() . '.' . Inflector::tableize($actionName), $action);
$def->addMethodCall('addAction', [$action]);
}
}
/**
* {@inheritdoc}
*/
protected function addRepository(ContainerBuilder $container, MetadataInterface $metadata)
{
$reflection = new \ReflectionClass($metadata->getClass('model'));
$translatableInterface = TranslatableInterface::class;
$translatable = interface_exists($translatableInterface) && $reflection->implementsInterface($translatableInterface);
$repositoryClassParameterName = sprintf('%s.repository.%s.class', $metadata->getApplicationName(), $metadata->getName());
$repositoryClass = $translatable ? TranslatableResourceRepository::class : EntityRepository::class;
if ($container->hasParameter($repositoryClassParameterName)) {
$repositoryClass = $container->getParameter($repositoryClassParameterName);
}
if ($metadata->hasClass('repository')) {
$repositoryClass = $metadata->getClass('repository');
}
$repositoryReflection = new \ReflectionClass($repositoryClass);
$definition = new Definition($repositoryClass);
$definition->setArguments([new Reference($metadata->getServiceId('manager')), $this->getClassMetadataDefinition($metadata)]);
$definition->setLazy(!$repositoryReflection->isFinal());
if ($metadata->hasParameter('translation')) {
$translatableRepositoryInterface = TranslatableResourceRepositoryInterface::class;
$translationConfig = $metadata->getParameter('translation');
if (interface_exists($translatableRepositoryInterface) && $repositoryReflection->implementsInterface($translatableRepositoryInterface)) {
if (isset($translationConfig['fields'])) {
$definition->addMethodCall('setTranslatableFields', [$translationConfig['fields']]);
}
}
}
$container->setDefinition($metadata->getServiceId('repository'), $definition);
}
/**
* @param ContainerBuilder $container
* @param Definition $mailerDefinition
*/
protected function registerOutboundMessageTransformers(ContainerBuilder $container, Definition $mailerDefinition)
{
$transformerTag = 'everlution.email.outbound.message_transformer';
foreach ($container->findTaggedServiceIds($transformerTag) as $id => $attributes) {
$mailerDefinition->addMethodCall('addMessageTransformer', array(new Reference($id)));
}
}
