public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('html_purifier.xml');
/* Prepend the default configuration. This cannot be defined within the
* Configuration class, since the root node's children are array
* prototypes.
*
* This cache path may be suppressed by either unsetting the "default"
* configuration (relying on canBeUnset() on the prototype node) or
* setting the "Cache.SerializerPath" option to null.
*/
array_unshift($configs, array('default' => array('Cache.SerializerPath' => '%kernel.cache_dir%/htmlpurifier')));
$configs = $this->processConfiguration(new Configuration(), $configs);
$configs = array_map(array($this, 'resolveServices'), $configs);
$paths = array();
foreach ($configs as $name => $config) {
$configDefinition = new Definition('%exercise_html_purifier.config.class%');
$configDefinition->setFactoryClass('%exercise_html_purifier.config.class%');
if ('default' === $name) {
$configDefinition->setFactoryMethod('create')->addArgument($config);
} else {
$configDefinition->setFactoryMethod('inherit')->addArgument(new Reference('exercise_html_purifier.config.default'))->addMethodCall('loadArray', array($config));
}
$configId = 'exercise_html_purifier.config.' . $name;
$container->setDefinition($configId, $configDefinition);
$container->setDefinition('exercise_html_purifier.' . $name, new Definition('%exercise_html_purifier.class%', array(new Reference($configId))));
if (isset($config['Cache.SerializerPath'])) {
$paths[] = $config['Cache.SerializerPath'];
}
}
$container->setParameter('exercise_html_purifier.cache_warmer.serializer.paths', array_unique($paths));
}
protected function reflectDefinition($reflClass)
{
$definition = new Definition($reflClass->getName());
if ($annot = $this->reader->getClassAnnotation($reflClass, 'LoSo\\Symfony\\Component\\DependencyInjection\\Loader\\Annotation\\Service')) {
$id = $this->extractServiceName($reflClass, $annot);
if (isset($annot->shared)) {
$definition->setShared($annot->shared);
}
if (isset($annot->factoryMethod)) {
$definition->setFactoryMethod($annot->factoryMethod);
}
if (isset($annot->factoryService)) {
$definition->setFactoryService($annot->factoryService);
}
foreach ($annot->tags as $tag) {
$name = $tag['name'];
unset($tag['name']);
$definition->addTag($name, $tag);
}
$this->reflectProperties($reflClass, $definition);
$this->reflectMethods($reflClass, $definition);
$this->reflectConstructor($reflClass, $definition);
$this->container->setDefinition($id, $definition);
}
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$def = $container->getDefinition('socloz.nsq');
if ($config['lookupd_hosts']) {
$container->setDefinition('socloz.nsq.lookup', new Definition('nsqphp\\Lookup\\Nsqlookupd', array($config['lookupd_hosts'])));
}
$def->addMethodCall('setDelayedMessagesTopic', array($config['delayed_messages_topic']));
$def->addMethodCall('setStubMode', array($config['stub']));
foreach ($config['topics'] as $name => $conf) {
$def->addMethodCall('setTopic', array($name, $conf));
if ($conf['consumers']) {
foreach ($conf['consumers'] as $channel => $service) {
$def->addMethodCall('setTopicConsumer', array($name, $channel, new Reference($service)));
}
}
$tsd = new Definition('Socloz\\NsqBundle\\Topic\\Topic', array($name));
$tsd->setFactoryService('socloz.nsq');
$tsd->setFactoryMethod('getTopic');
$container->setDefinition('socloz.nsq.topic.' . $name, $tsd);
}
}
public function getEntityMetadataDefinition($entity, $entityManager)
{
$definition = new Definition('Doctrine\\ORM\\Mapping\\ClassMetadata');
$definition->setFactoryService($this->resolveEntityManagerId($entityManager));
$definition->setFactoryMethod('getClassMetadata');
$definition->setArguments(array($entity));
return $definition;
}
private function loadDoctrine(ContainerBuilder $container, $config)
{
$this->loadConfiguration($container, $config);
$definition = new Definition('Doctrine\\DBAL\\Connection', array(array('driver' => 'pdo_sqlite', 'memory' => true), new Reference('doctrine.configuration')));
$definition->setFactoryClass('Doctrine\\DBAL\\DriverManager');
$definition->setFactoryMethod('getConnection');
$container->setDefinition('doctrine.connection', $definition);
}
private function buildUseCaseProxyFactoryDefinition($taggedServiceName, $tagParameters)
{
$definition = $this->container->findDefinition($taggedServiceName);
$factoryDefinition = new Definition();
$factoryDefinition->setFactoryService('openclassrooms.use_case.use_case_proxy_factory');
$factoryDefinition->setFactoryMethod('create');
$factoryDefinition->setArguments(array($definition, $tagParameters[0]));
$this->container->setDefinition($taggedServiceName, $factoryDefinition);
}
private function loadDoctrine(ContainerBuilder $container, $config)
{
$this->loadConfiguration($container, $config);
$this->loadEventManager($container, $config);
$definition = new Definition('Doctrine\\ORM\\EntityManager', array(array('driver' => 'pdo_sqlite', 'memory' => true), new Reference('doctrine.configuration'), new Reference('doctrine.event_manager')));
$definition->setFactoryClass('Doctrine\\ORM\\EntityManager');
$definition->setFactoryMethod('create');
$container->setDefinition('doctrine', $definition);
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
$driver = $container->getDefinition('prezent_doctrine_translatable.driver_chain');
foreach ($container->getParameter('doctrine.entity_managers') as $name => $manager) {
$adapter = new Definition('Metadata\\Driver\\DriverInterface', array(new Reference(sprintf('doctrine.orm.%s_metadata_driver', $name))));
$adapter->setFactoryClass('Prezent\\Doctrine\\Translatable\\Mapping\\Driver\\DoctrineAdapter');
$adapter->setFactoryMethod('fromMetadataDriver');
$driver->addMethodCall('addDriver', array($adapter));
}
}
public function resolveString($value, array $resolved = array())
{
if (preg_match('/\\&([^\\&\\s]+)\\&$/', $value, $match)) {
$definition = new Definition();
$definition->setFactoryService('service_container');
$definition->setFactoryMethod('getVariable');
$definition->setArguments(array($match[1]));
return $definition;
}
return $value;
}
/**
* @group legacy
*/
public function testResolveFactoryService()
{
$container = new ContainerBuilder();
$container->register('factory', 'Factory');
$container->setAlias('factory_alias', new Alias('factory'));
$foo = new Definition();
$foo->setFactoryService('factory_alias');
$foo->setFactoryMethod('createFoo');
$container->setDefinition('foo', $foo);
$this->process($container);
$this->assertSame('factory', $foo->getFactoryService());
}
/**
* @param ContainerBuilder $container
* @param $gatewayName
* @param array $config
*
* @return Definition
*/
protected function createGateway(ContainerBuilder $container, $gatewayName, array $config)
{
$gatewayFactoryClass = $this->getPayumGatewayFactoryClass();
if (false == class_exists($gatewayFactoryClass)) {
throw new RuntimeException(sprintf('Cannot find gateway factory class. Have you installed %s or payum/payum package?', $this->getComposerPackage()));
}
$config['payum.gateway_name'] = $gatewayName;
$gateway = new Definition('Payum\\Core\\Gateway', array($config));
$gateway->setFactoryService(sprintf('payum.%s.factory', $this->getName()));
$gateway->setFactoryMethod('create');
return $gateway;
}
/**
* {@inheritDoc}
*/
public function create(ContainerBuilder $container, $resolverName, array $config)
{
$awsS3ClientDefinition = new Definition('Aws\S3\S3Client');
$awsS3ClientDefinition->setFactoryClass('Aws\S3\S3Client');
$awsS3ClientDefinition->setFactoryMethod('factory');
$awsS3ClientDefinition->addArgument($config['client_config']);
$awsS3ClientId = 'liip_imagine.cache.resolver.'.$resolverName.'.client';
$container->setDefinition($awsS3ClientId, $awsS3ClientDefinition);
$resolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.aws_s3');
$resolverDefinition->replaceArgument(0, new Reference($awsS3ClientId));
$resolverDefinition->replaceArgument(1, $config['bucket']);
$resolverDefinition->replaceArgument(2, $config['acl']);
$resolverDefinition->replaceArgument(3, array_replace($config['url_options'], $config['get_options']));
$resolverDefinition->replaceArgument(4, $config['put_options']);
$resolverId = 'liip_imagine.cache.resolver.'.$resolverName;
$container->setDefinition($resolverId, $resolverDefinition);
if (isset($config['cache_prefix'])) {
$resolverDefinition->addMethodCall('setCachePrefix', array($config['cache_prefix']));
}
if ($config['proxies']) {
$proxiedResolverId = 'liip_imagine.cache.resolver.'.$resolverName.'.proxied';
$container->setDefinition($proxiedResolverId, $resolverDefinition);
$proxyResolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.proxy');
$proxyResolverDefinition->replaceArgument(0, new Reference($proxiedResolverId));
$proxyResolverDefinition->replaceArgument(1, $config['proxies']);
$container->setDefinition($resolverId, $proxyResolverDefinition);
}
if ($config['cache']) {
$cachedResolverId = 'liip_imagine.cache.resolver.'.$resolverName.'.cached';
$container->setDefinition($cachedResolverId, $container->getDefinition($resolverId));
$cacheResolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.cache');
$cacheResolverDefinition->replaceArgument(0, new Reference($config['cache']));
$cacheResolverDefinition->replaceArgument(1, new Reference($cachedResolverId));
$container->setDefinition($resolverId, $cacheResolverDefinition);
}
$container->getDefinition($resolverId)->addTag('liip_imagine.cache.resolver', array(
'resolver' => $resolverName,
));
return $resolverId;
}
/**
* Creates a complex setting factory.
*
* The factory has a variable number of arguments.
* Dynamic settings are added as tupples: first the argument without the leading and trailing $, so that it is not
* transformed by the config resolver pass, then the argument as a string, so that it does get transformed.
*
* @param string $argumentValue The original argument ($var$/$another_var$)
* @param array $dynamicSettings Array of dynamic settings in $argumentValue
*
* @return Definition
*/
private function createFactoryDefinition($argumentValue, $dynamicSettings)
{
$definition = new Definition('stdClass', array($argumentValue));
$definition->setFactoryClass('eZ\\Bundle\\EzPublishCoreBundle\\DependencyInjection\\Configuration\\ComplexSettings\\ComplexSettingValueFactory');
$definition->setFactoryMethod('getArgumentValue');
foreach ($dynamicSettings as $dynamicSetting) {
// Trim the '$' so that the dynamic setting doesn't get transformed
$definition->addArgument(trim($dynamicSetting, '$'));
// This one will be transformed
$definition->addArgument($dynamicSetting);
}
return $definition;
}
protected function loadClientConnection($name, array $connection, ContainerBuilder $container)
{
$container->setDefinition(sprintf('doctrine_couchdb.client.%s_connection', $name), new DefinitionDecorator('doctrine_couchdb.client.connection'))->setArguments(array($connection));
if (isset($connection['logging']) && $connection['logging'] === true) {
$def = new Definition('Doctrine\\CouchDB\\HTTP\\Client');
$def->setFactoryService(sprintf('doctrine_couchdb.client.%s_connection', $name));
$def->setFactoryMethod('getHttpClient');
$def->setPublic(false);
$container->setDefinition(sprintf('doctrine_couchdb.httpclient.%s_client', $name), $def);
$def = $container->getDefinition('doctrine_couchdb.datacollector');
$def->addMethodCall('addLoggingClient', array(new Reference(sprintf('doctrine_couchdb.httpclient.%s_client', $name)), $name));
}
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$container->setParameter('kalamu_menu_service.menus', $config);
foreach ($config as $name => $infos) {
$definition = new Definition('Knp\\Menu\\MenuItem', array($name));
$definition->setFactoryService('kalamu_menu_service.menu_builder');
$definition->setFactoryMethod('createMenu');
$definition->addTag('knp_menu.menu', array('alias' => $name));
$container->setDefinition('kalamu_menu_service.menu.' . $name, $definition);
}
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
}
/**
* return from local cache or make a new one and put it in cache and then return it.
* @param ContainerBuilder $container
* @param string $contextName
* @returns Reference The service definition reference
*/
private function getServiceFactory(ContainerBuilder $container, $contextName)
{
if (!array_key_exists($contextName, $this->serviceDefinistions)) {
$def = new Definition();
$def->setClass('TechData\\ContextDiBundle\\Models\\Context');
$def->setLazy(TRUE);
$def->setFactoryService('tech_data_context_di.context_handler');
$def->setFactoryMethod('getContext');
$def->setArguments(array($contextName));
$id = 'tech_data_context_di.contexts.' . $contextName;
$container->setDefinition($id, $def);
$this->serviceDefinistions[$contextName] = new Reference($id);
}
return $this->serviceDefinistions[$contextName];
}
/**
* {@inheritDoc}
*/
protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config)
{
$gatewayDefinition = new Definition();
$gatewayDefinition->setClass('Omnipay\\Common\\GatewayInterface');
$gatewayDefinition->setFactoryService('payum.omnipay_bridge.gateway_factory');
$gatewayDefinition->setFactoryMethod('create');
$gatewayDefinition->addArgument($config['type']);
$gatewayDefinition->setPublic(true);
foreach ($config['options'] as $name => $value) {
$gatewayDefinition->addMethodCall('set' . strtoupper($name), array($value));
}
$gatewayId = 'payum.context.' . $contextName . '.gateway';
$container->setDefinition($gatewayId, $gatewayDefinition);
$paymentDefinition->addMethodCall('addApi', array(new Reference($gatewayId)));
}
public function load(array $configs, ContainerBuilder $container)
{
$configuration = $this->getConfiguration($configs, $container);
$config = $this->processConfiguration($configuration, $configs);
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('metrics.xml');
$registry = $container->getDefinition('beberlei_metrics.registry');
$registry->addMethodCall('setDefaultName', array($config['default']));
foreach ($config['collectors'] as $name => $collector) {
$def = new Definition('Beberlei\\Metrics\\Collector\\Collector');
$def->setFactoryMethod('create');
$def->setFactoryClass('%beberlei_metrics.factory.class%');
$def->setArguments(array($collector['type'], $collector));
$container->setDefinition('beberlei_metrics.collector.' . $name, $def);
$registry->addMethodCall('set', array($name, new Reference('beberlei_metrics.collector.' . $name)));
}
}
/**
* {@inheritDoc}
*/
protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config)
{
$internalConnectorDefinition = new Definition('Klarna_Checkout_ConnectorInterface');
$internalConnectorDefinition->setFactoryClass('Klarna_Checkout_Connector');
$internalConnectorDefinition->setFactoryMethod('create');
$internalConnectorDefinition->addArgument($config['secret']);
$internalConnectorId = 'payum.context.' . $contextName . '.internal_connector';
$container->setDefinition($internalConnectorId, $internalConnectorDefinition);
$connectorDefinition = new Definition('%payum.klarna.checkout.connector.class%');
$connectorDefinition->addArgument(new Reference($internalConnectorId));
$connectorDefinition->addArgument($config['merchant_id']);
$connectorDefinition->addArgument($config['sandbox'] ? Constants::BASE_URI_SANDBOX : Constants::BASE_URI_LIVE);
$connectorDefinition->addArgument(Constants::CONTENT_TYPE_V2_PLUS_JSON);
$connectorId = 'payum.context.' . $contextName . '.connector';
$container->setDefinition($connectorId, $connectorDefinition);
$paymentDefinition->addMethodCall('addApi', array(new Reference($connectorId)));
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
if (!empty($config['definitions'])) {
$container->setParameter('markup_barcode.definition.configuration', $config['definitions']);
foreach ($config['definitions'] as $name => $params) {
$generator = new Definition('%markup_barcode.generator.class%', array($name));
$generator->setFactoryService('markup_barcode.generator.provider');
$generator->setFactoryMethod('getNamedGenerator');
$container->setDefinition(sprintf('markup_barcode.generator.%s', $name), $generator);
}
} else {
$container->setParameter('markup_barcode.definition.configuration', array());
}
$loader->load('services.xml');
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$container->setParameter('lexik_monolog_browser.base_layout', $config['base_layout']);
$container->setParameter('lexik_monolog_browser.logs_per_page', $config['logs_per_page']);
$container->setParameter('lexik_monolog_browser.doctrine.table_name', $config['doctrine']['table_name']);
if (isset($config['doctrine']['connection_name'])) {
$container->setAlias('lexik_monolog_browser.doctrine_dbal.connection', sprintf('doctrine.dbal.%s_connection', $config['doctrine']['connection_name']));
}
if (isset($config['doctrine']['connection'])) {
$connectionDefinition = new Definition('Doctrine\\DBAL\\Connection', array($config['doctrine']['connection']));
$connectionDefinition->setFactoryClass('Doctrine\\DBAL\\DriverManager');
$connectionDefinition->setFactoryMethod('getConnection');
$container->setDefinition('lexik_monolog_browser.doctrine_dbal.connection', $connectionDefinition);
}
}
public function navLoad($config, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, __DIR__ . '/../Resources/config');
$loader->load('navigation.xml');
$configDir = $container->getParameter('kernel.root_dir') . '/config/';
foreach ($config as $containerName => $yamlConfigFile) {
if (!is_string($yamlConfigFile)) {
$yamlConfigFile = $containerName . '.yml';
}
$yamlConfigFile = "nav_" . $yamlConfigFile;
$yamlConfigFile = $configDir . $yamlConfigFile;
$def = new Definition("Bundle\\ZendNavigationBundle\\Navigation");
$def->setFactoryMethod('factory');
$def->addArgument(new Reference('router'));
$def->addArgument(new Reference('request'));
$def->addArgument($yamlConfigFile);
$container->setDefinition('zend.navigation.' . $containerName, $def);
}
}
public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('compat.xml');
foreach ($configs as $config) {
if (isset($config['default_layout_resource'])) {
$container->setParameter('whitewashing.zfmvccompat.default_layout_resource', $config['default_layout_resource']);
}
if (isset($config['catchall_bundles'])) {
$container->setParameter('whitewashing.zfmvccompat.catchall_bundles', $config['catchall_bundles']);
}
if (isset($config['db_conn'])) {
$def = new Definition('Zend_Db_Adapter_Abstract');
$def->setFactoryClass('Zend_Db');
$def->setFactoryMethod('factory');
$def->setArguments(array($config['db_conn']['adapter'], $config['db_conn']['params']));
$container->setDefinition('whitewashing.zfmvcompat.db', $def);
}
}
}
/**
* Process compilation of containers.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$factory = $container->findDefinition('app.doctrine.repository.factory');
$repositories = [];
foreach ($container->findTaggedServiceIds('app.repository') as $id => $params) {
foreach ($params as $param) {
$repositories[$param['class']] = $id;
$repository = $container->findDefinition($id);
$repository->replaceArgument(0, new Reference('doctrine.orm.default_entity_manager'));
$definition = new Definition();
$definition->setClass('Doctrine\\ORM\\Mapping\\ClassMetadata');
$definition->setFactoryService('doctrine.orm.default_entity_manager');
$definition->setFactoryMethod('getClassMetadata');
$definition->setArguments([$param['class']]);
$repository->replaceArgument(1, $definition);
}
}
$factory->replaceArgument(0, $repositories);
$container->findDefinition('doctrine.orm.configuration')->addMethodCall('setRepositoryFactory', [$factory]);
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$definitions = $container->findTaggedServiceIds('ongr_settings.setting_aware');
foreach ($definitions as $serviceId => $tags) {
$definition = $container->getDefinition($serviceId);
$initialTags = $definition->getTags();
$definition->clearTags();
$container->setDefinition("{$serviceId}_base", $definition);
$callMap = [];
foreach ($tags as $tag) {
$callMap[$tag['setting']] = isset($tag['method']) ? $tag['method'] : null;
}
$proxy = new Definition($definition->getClass(), [$callMap, new Reference("{$serviceId}_base")]);
$proxy->setFactoryService('ongr_settings.setting_aware_service_factory');
$proxy->setFactoryMethod('get');
unset($initialTags['ongr_settings.setting_aware']);
$proxy->setTags($initialTags);
$container->setDefinition($serviceId, $proxy);
}
}
private function getAllParameters()
{
$service = new Definition();
$service->setClass('stdClass');
$service->setAbstract(true);
$service->setFactoryClass('stdClass');
$service->setFactoryMethod('get');
$service->setFactoryService('service.fact');
$service->setFile('/file.php');
$service->setLazy(true);
$service->addMethodCall('methodCall1');
$service->addMethodCall('methodCall2', array('arg1', 'arg2'));
$service->addMethodCall('methodCall3', array(new Reference('arg.one')));
$service->setProperty('prop1', 'val1');
$service->setProperty('prop2', new Reference('prop.one'));
$service->setPublic(false);
$service->setScope('request');
$service->setSynchronized(true);
$service->setSynthetic(true);
return new ServiceElement('service.two', $service);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
if (!isset($config['table'])) {
return;
}
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$aws_config = array();
if (isset($config['aws'])) {
$aws_config = $config['aws'];
}
if (!isset($config['dynamo_client_id'])) {
$dynamoClass = $container->getParameter("dynamo_session_client.class");
$def = new Definition($dynamoClass);
$def->setFactoryClass($dynamoClass);
$def->setFactoryMethod("factory");
$def->setArguments(array($aws_config));
$container->setDefinition("dynamo_session_client", $def);
$config['dynamo_client_id'] = "dynamo_session_client";
} else {
$container->removeDefinition("dynamo_session_client");
$container->setAlias("dynamo_session_client", $config['dynamo_client_id']);
}
$container->setParameter("dynamo_session_table", $config['table']);
$container->setParameter("dynamo_session_read_capacity", $config['read_capacity']);
$container->setParameter("dynamo_session_write_capacity", $config['write_capacity']);
$dynamo_config = array('table_name' => $config['table'], 'locking_strategy' => $config['locking_strategy']);
foreach (array('automatic_gc', 'gc_batch_size', 'session_lifetime') as $key) {
if (isset($config[$key])) {
$dynamo_config[$key] = $config[$key];
}
}
$handler = $container->getDefinition("dynamo_session_handler");
$handler->setArguments(array(new Reference("dynamo_session_client"), $dynamo_config));
}
/**
* {@inheritDoc}
*/
public function createPayment(ContainerBuilder $container, $gatewayName, array $config)
{
if (isset($config['service'])) {
return new DefinitionDecorator($config['service']);
}
$config['payum.factory'] = $this->getName();
$config['payum.context'] = $gatewayName;
$payment = new Definition('Payum\\Core\\Payment', array($config));
$payment->setFactoryService('payum.payment_factory');
$payment->setFactoryMethod('create');
$captureActionClass = 'Acme\\OtherExamplesBundle\\Payum\\FooBarGateway\\Action\\CaptureAction';
$captureActionDefinition = new Definition($captureActionClass);
$captureActionDefinition->addArgument($config['username']);
$captureActionDefinition->addArgument($config['password']);
$captureActionId = 'payum.foobar_gateway.action.capture';
$container->setDefinition($captureActionId, $captureActionDefinition);
$statusActionClass = 'Acme\\OtherExamplesBundle\\Payum\\FooBarGateway\\Action\\StatusAction';
$statusActionDefinition = new Definition($statusActionClass);
$statusActionId = 'payum.foobar_gateway.action.status';
$container->setDefinition($statusActionId, $statusActionDefinition);
$payment->addMethodCall('addAction', array(new Reference($captureActionId)));
$payment->addMethodCall('addAction', array(new Reference($statusActionId)));
return $payment;
}
private function buildHandler(ContainerBuilder $container, $name, array $handler)
{
$handlerId = $this->getHandlerId($name);
$definition = new Definition(sprintf('%%monolog.handler.%s.class%%', $handler['type']));
$handler['level'] = is_int($handler['level']) ? $handler['level'] : constant('Monolog\Logger::'.strtoupper($handler['level']));
switch ($handler['type']) {
case 'service':
$container->setAlias($handlerId, $handler['id']);
return $handlerId;
case 'stream':
$definition->setArguments(array(
$handler['path'],
$handler['level'],
$handler['bubble'],
));
break;
case 'firephp':
$definition->setArguments(array(
$handler['level'],
$handler['bubble'],
));
$definition->addTag('kernel.event_listener', array('event' => 'kernel.response', 'method' => 'onKernelResponse'));
break;
case 'rotating_file':
$definition->setArguments(array(
$handler['path'],
$handler['max_files'],
$handler['level'],
$handler['bubble'],
));
break;
case 'fingers_crossed':
$handler['action_level'] = is_int($handler['action_level']) ? $handler['action_level'] : constant('Monolog\Logger::'.strtoupper($handler['action_level']));
$nestedHandlerId = $this->getHandlerId($handler['handler']);
$this->nestedHandlers[] = $nestedHandlerId;
$definition->setArguments(array(
new Reference($nestedHandlerId),
$handler['action_level'],
$handler['buffer_size'],
$handler['bubble'],
$handler['stop_buffering'],
));
break;
case 'buffer':
$nestedHandlerId = $this->getHandlerId($handler['handler']);
$this->nestedHandlers[] = $nestedHandlerId;
$definition->setArguments(array(
new Reference($nestedHandlerId),
$handler['buffer_size'],
$handler['level'],
$handler['bubble'],
));
break;
case 'group':
$references = array();
foreach ($handler['members'] as $nestedHandler) {
$nestedHandlerId = $this->getHandlerId($nestedHandler);
$this->nestedHandlers[] = $nestedHandlerId;
$references[] = new Reference($nestedHandlerId);
}
$definition->setArguments(array(
$references,
$handler['bubble'],
));
break;
case 'syslog':
$definition->setArguments(array(
$handler['ident'],
$handler['facility'],
$handler['level'],
$handler['bubble'],
));
break;
case 'swift_mailer':
if (isset($handler['email_prototype'])) {
if (!empty($handler['email_prototype']['method'])) {
$prototype = array(new Reference($handler['email_prototype']['id']), $handler['email_prototype']['method']);
} else {
$prototype = new Reference($handler['email_prototype']['id']);
}
} else {
$message = new Definition('Swift_Message');
$message->setFactoryService('mailer');
$message->setFactoryMethod('createMessage');
$message->setPublic(false);
$message->addMethodCall('setFrom', array($handler['from_email']));
$message->addMethodCall('setTo', array($handler['to_email']));
$message->addMethodCall('setSubject', array($handler['subject']));
$messageId = sprintf('%s.mail_prototype', $handlerId);
$container->setDefinition($messageId, $message);
$prototype = new Reference($messageId);
}
$definition->setArguments(array(
new Reference('mailer'),
$prototype,
$handler['level'],
$handler['bubble'],
));
break;
case 'native_mailer':
$definition->setArguments(array(
$handler['to_email'],
$handler['subject'],
$handler['from_email'],
$handler['level'],
$handler['bubble'],
));
break;
// Handlers using the constructor of AbstractHandler without adding their own arguments
case 'test':
case 'null':
case 'debug':
$definition->setArguments(array(
$handler['level'],
$handler['bubble'],
));
break;
default:
throw new \InvalidArgumentException(sprintf('Invalid handler type "%s" given for handler "%s"', $handler['type'], $name));
}
if (!empty($handler['formatter'])) {
$definition->addMethodCall('setFormatter', array(new Reference($handler['formatter'])));
}
$container->setDefinition($handlerId, $definition);
return $handlerId;
}
/**
* Resolves the definition.
*
* @param ContainerBuilder $container The ContainerBuilder
* @param DefinitionDecorator $definition
*
* @return Definition
*
* @throws \RuntimeException When the definition is invalid
*/
private function resolveDefinition(ContainerBuilder $container, DefinitionDecorator $definition)
{
if (!$container->hasDefinition($parent = $definition->getParent())) {
throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $this->currentId));
}
$parentDef = $container->getDefinition($parent);
if ($parentDef instanceof DefinitionDecorator) {
$id = $this->currentId;
$this->currentId = $parent;
$parentDef = $this->resolveDefinition($container, $parentDef);
$container->setDefinition($parent, $parentDef);
$this->currentId = $id;
}
$this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $this->currentId, $parent));
$def = new Definition();
// merge in parent definition
// purposely ignored attributes: scope, abstract, tags
$def->setClass($parentDef->getClass());
$def->setArguments($parentDef->getArguments());
$def->setMethodCalls($parentDef->getMethodCalls());
$def->setProperties($parentDef->getProperties());
$def->setAutowiringTypes($parentDef->getAutowiringTypes());
if ($parentDef->getFactoryClass(false)) {
$def->setFactoryClass($parentDef->getFactoryClass(false));
}
if ($parentDef->getFactoryMethod(false)) {
$def->setFactoryMethod($parentDef->getFactoryMethod(false));
}
if ($parentDef->getFactoryService(false)) {
$def->setFactoryService($parentDef->getFactoryService(false));
}
if ($parentDef->isDeprecated()) {
$def->setDeprecated(true, $parentDef->getDeprecationMessage('%service_id%'));
}
$def->setFactory($parentDef->getFactory());
$def->setConfigurator($parentDef->getConfigurator());
$def->setFile($parentDef->getFile());
$def->setPublic($parentDef->isPublic());
$def->setLazy($parentDef->isLazy());
// overwrite with values specified in the decorator
$changes = $definition->getChanges();
if (isset($changes['class'])) {
$def->setClass($definition->getClass());
}
if (isset($changes['factory_class'])) {
$def->setFactoryClass($definition->getFactoryClass(false));
}
if (isset($changes['factory_method'])) {
$def->setFactoryMethod($definition->getFactoryMethod(false));
}
if (isset($changes['factory_service'])) {
$def->setFactoryService($definition->getFactoryService(false));
}
if (isset($changes['factory'])) {
$def->setFactory($definition->getFactory());
}
if (isset($changes['configurator'])) {
$def->setConfigurator($definition->getConfigurator());
}
if (isset($changes['file'])) {
$def->setFile($definition->getFile());
}
if (isset($changes['public'])) {
$def->setPublic($definition->isPublic());
}
if (isset($changes['lazy'])) {
$def->setLazy($definition->isLazy());
}
if (isset($changes['deprecated'])) {
$def->setDeprecated($definition->isDeprecated(), $definition->getDeprecationMessage('%service_id%'));
}
if (isset($changes['decorated_service'])) {
$decoratedService = $definition->getDecoratedService();
if (null === $decoratedService) {
$def->setDecoratedService($decoratedService);
} else {
$def->setDecoratedService($decoratedService[0], $decoratedService[1], $decoratedService[2]);
}
}
// merge arguments
foreach ($definition->getArguments() as $k => $v) {
if (is_numeric($k)) {
$def->addArgument($v);
continue;
}
if (0 !== strpos($k, 'index_')) {
throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k));
}
$index = (int) substr($k, strlen('index_'));
$def->replaceArgument($index, $v);
}
// merge properties
foreach ($definition->getProperties() as $k => $v) {
$def->setProperty($k, $v);
}
// append method calls
if (count($calls = $definition->getMethodCalls()) > 0) {
$def->setMethodCalls(array_merge($def->getMethodCalls(), $calls));
}
// merge autowiring types
foreach ($definition->getAutowiringTypes() as $autowiringType) {
$def->addAutowiringType($autowiringType);
}
// these attributes are always taken from the child
$def->setAbstract($definition->isAbstract());
$def->setScope($definition->getScope(false), false);
$def->setShared($definition->isShared());
$def->setTags($definition->getTags());
return $def;
}
