/**
* @expectedException \OutOfBoundsException
*/
public function testGetArgumentShouldCheckBounds()
{
$def = new DefinitionDecorator('foo');
$def->setArguments(array(0 => 'foo'));
$def->replaceArgument(0, 'foo');
$def->getArgument(1);
}
/**
* {@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');
}
}
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
foreach ($container->findTaggedServiceIds('payum.storage_extension') as $id => $tagAttributes) {
foreach ($tagAttributes as $attributes) {
$paymentIds = array();
if (isset($attributes['all']) && $attributes['all']) {
$paymentIds = array_merge($paymentIds, $this->findAllPaymentIds($container));
}
if (isset($attributes['factory']) && $attributes['factory']) {
$paymentIds = array_merge($paymentIds, $this->findPaymentIdsByFactory($container, $attributes['factory']));
}
if (isset($attributes['context']) && $attributes['context']) {
$paymentIds = array_merge($paymentIds, $this->findPaymentIdsByContext($container, $attributes['context']));
}
$paymentIds = array_filter(array_unique($paymentIds));
foreach ($paymentIds as $paymentId) {
$storageExtension = new DefinitionDecorator('payum.extension.storage.prototype');
$storageExtension->replaceArgument(0, new Reference($id));
$storageExtension->setPublic(false);
if (false !== strpos($id, '.storage.')) {
$storageExtensionId = str_replace('.storage.', '.extension.storage.', $id);
} else {
throw new LogicException(sprintf('In order to add storage to extension the storage %id has to contains ".storage." inside.', $id));
}
$container->setDefinition($storageExtensionId, $storageExtension);
$payment = $container->getDefinition($paymentId);
$payment->addMethodCall('addExtension', array(new Reference($storageExtensionId), isset($attributes['prepend']) && $attributes['prepend']));
}
}
}
}
public function testSetArgument()
{
$def = new DefinitionDecorator('foo');
$this->assertEquals(array(), $def->getArguments());
$this->assertSame($def, $def->setArgument(0, 'foo'));
$this->assertEquals(array('index_0' => 'foo'), $def->getArguments());
}
/**
* Sets up handlers and registers middleware for each tagged client.
*
* @param ContainerBuilder $container
* @param array $middlewareBag
*/
private function registerMiddleware(ContainerBuilder $container, array $middlewareBag)
{
$clients = $container->findTaggedServiceIds(self::CLIENT_TAG);
foreach ($clients as $clientId => $tags) {
if (count($tags) > 1) {
throw new \LogicException('Clients should use a single \'csa_guzzle.client\' tag');
}
$clientMiddleware = $middlewareBag;
if (isset($tags[0]['middleware'])) {
$whitelist = explode(' ', $tags[0]['middleware']);
$clientMiddleware = array_filter($clientMiddleware, function ($value) use($whitelist) {
return in_array($value['alias'], $whitelist, true);
});
}
$handlerStack = new DefinitionDecorator('csa_guzzle.handler_stack');
$handlerStack->setPublic(false);
foreach ($clientMiddleware as $middleware) {
$handlerStack->addMethodCall('push', [new Reference($middleware['id']), $middleware['alias']]);
}
$clientHandlerStackId = sprintf('csa_guzzle.handler_stack.%s', $clientId);
$container->setDefinition($clientHandlerStackId, $handlerStack);
$clientDefinition = $container->findDefinition($clientId);
$arguments = $clientDefinition->getArguments();
$options = [];
if (!empty($arguments)) {
$options = array_shift($arguments);
}
$options['handler'] = new Reference($clientHandlerStackId);
array_unshift($arguments, $options);
$clientDefinition->setArguments($arguments);
}
}
/**
* {@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');
if (array_key_exists('servers', $config)) {
foreach ($config['servers'] as $id => $server) {
$container->setParameter('json_rpc.serializer.class', $server['serializer']);
$container->setParameter('json_rpc.reflection.class', $server['reflection']);
$definition = new DefinitionDecorator('json_rpc.server');
$definition->addTag('json_rpc.servers', array('resource' => $id));
foreach ($server['services'] as $service) {
$definition->addMethodCall('addService', array($service['namespace'], $service['class']));
}
$container->setDefinition(sprintf('json_rpc.server.%s', $id), $definition);
$definition = new DefinitionDecorator('json_rpc.transport.internal');
$definition->addTag('json_rpc.transports');
$definition->replaceArgument(0, new Reference(sprintf('json_rpc.server.%s', $id)));
$container->setDefinition(sprintf('json_rpc.transport.internal.%s', $id), $definition);
$definition = new DefinitionDecorator('json_rpc.client.internal');
$definition->addTag('json_rpc.clients.internal');
$definition->replaceArgument(0, new Reference(sprintf('json_rpc.transport.internal.%s', $id)));
$container->setDefinition(sprintf('json_rpc.client.internal.%s', $id), $definition);
}
}
}
/**
* @inheritdoc
*/
public function process(ContainerBuilder $container)
{
$definitions = array();
$servicesIds = $container->findTaggedServiceIds('pmd_state_machine.token_configurable');
foreach ($servicesIds as $serviceId => $tag) {
$group = isset($tag[0]['group']) ? $tag[0]['group'] : null;
$type = isset($tag[0]['type']) ? $tag[0]['type'] : null;
if (!isset($group) || !isset($type)) {
throw new \InvalidArgumentException(sprintf('Services tagged %s must have group and type defined', 'pmd_state_machine.token_configurable'));
}
$serviceDefinition = $container->getDefinition($serviceId);
$optionsId = sprintf('pmd_state_machine.behavior.%s_%s_options', $group, $type);
$optionsReference = new Reference($optionsId, ContainerInterface::NULL_ON_INVALID_REFERENCE);
// Configure options resolver
$resolverId = sprintf('pmd_state_machine.behavior.%s_%s_resolver', $group, $type);
$resolverReference = new Reference($resolverId);
$resolverDefinition = new DefinitionDecorator('pmd_state_machine.behavior_resolver.token_options_resolver');
$resolverDefinition->replaceArgument(0, $optionsReference);
// Configure configurable decorator
$configId = sprintf('pmd_state_machine.behavior.%s_%s_configurator', $group, $type);
$configDefinition = new DefinitionDecorator('pmd_state_machine.behavior.token_configurable_configurator');
$configDefinition->replaceArgument(0, $resolverReference);
$serviceDefinition->setConfigurator(array(new Reference($configId, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, false), 'configure'));
$definitions[$resolverId] = $resolverDefinition;
$definitions[$configId] = $configDefinition;
}
$container->addDefinitions($definitions);
}
/**
* Returns a definition for an asset package.
*
* @param ContainerBuilder $container Container
* @param array $httpUrls SSL assets_base_urls
* @param array $sslUrls assets_base_urls
* @param string $rootDir Directory where to look for reved assets
* @param string $summaryFile Grunt filerev summary file
* @param string $cacheDir Kernel cache dir
* @param bool $debug Debug mode?
* @param string $name Package name
*
* @return DefinitionDecorator
*/
private function createPackageDefinition(ContainerBuilder $container, array $httpUrls, array $sslUrls, $rootDir, $summaryFile, $cacheDir, $debug, $name = null)
{
if (!$httpUrls) {
$package = new DefinitionDecorator('grunt.filerev.templating.asset.path_package');
$package->setPublic(false)->setScope('request')->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
return $package;
}
if ($httpUrls == $sslUrls) {
$package = new DefinitionDecorator('grunt.filerev.templating.asset.url_package');
$package->setPublic(false)->replaceArgument(0, $sslUrls)->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
return $package;
}
$prefix = $name ? 'templating.asset.package.' . $name : 'templating.asset.default_package';
$httpPackage = new DefinitionDecorator('grunt.filerev.templating.asset.url_package');
$httpPackage->replaceArgument(0, $httpUrls)->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
$container->setDefinition($prefix . '.http', $httpPackage);
if ($sslUrls) {
$sslPackage = new DefinitionDecorator('grunt.filerev.templating.asset.url_package');
$sslPackage->replaceArgument(0, $sslUrls)->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
} else {
$sslPackage = new DefinitionDecorator('grunt.filerev.templating.asset.path_package');
$sslPackage->setScope('request')->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
}
$container->setDefinition($prefix . '.ssl', $sslPackage);
$package = new DefinitionDecorator('templating.asset.request_aware_package');
$package->setPublic(false)->setScope('request')->replaceArgument(1, $prefix . '.http')->replaceArgument(2, $prefix . '.ssl');
return $package;
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config/services'));
if ('custom' !== $config['db_driver']) {
$loader->load(sprintf('%s.xml', $config['db_driver']));
}
$this->remapParametersNamespaces($config, $container, array('' => array('db_driver' => 'abc.file_distribution.storage', 'model_manager_name' => 'abc.file_distribution.model_manager_name')));
if (!empty($config['definition'])) {
$this->loadFilesystem($config['definition'], $container, $loader, $config['db_driver']);
}
$loader->load('service.xml');
if (isset($config['filesystems'])) {
foreach ($config['filesystems'] as $name => $filesystem) {
$definitionId = 'abc.file_distribution.definition.' . $name;
$definition = new DefinitionDecorator('abc.file_distribution.definition.prototype');
$definition->addMethodCall('setType', array($filesystem['type']));
$definition->addMethodCall('setPath', array($filesystem['path']));
$definition->addMethodCall('setProperties', array($filesystem['options']));
$container->setDefinition($definitionId, $definition);
$definition = new Definition('Abc\\Filesystem\\Filesystem', array(new Reference('abc.file_distribution.adapter_factory'), new Reference($definitionId)));
$container->setDefinition('abc.file_distribution.filesystem.' . $name, $definition);
}
}
}
/**
* @param ContainerBuilder $container
*
* @throws \InvalidArgumentException
*/
public function process(ContainerBuilder $container)
{
$config = $container->getExtensionConfig('elastica')[0];
$jsonLdFrameLoader = $container->get('nemrod.elastica.jsonld.frame.loader.filesystem');
$confManager = $container->getDefinition('nemrod.elastica.config_manager');
$filiationBuilder = $container->get('nemrod.filiation.builder');
$jsonLdFrameLoader->setFiliationBuilder($filiationBuilder);
foreach ($config['indexes'] as $name => $index) {
$indexName = isset($index['index_name']) ? $index['index_name'] : $name;
foreach ($index['types'] as $typeName => $settings) {
$jsonLdFrameLoader->setEsIndex($name);
$frame = $jsonLdFrameLoader->load($settings['frame'], null, true, true, true);
$type = !empty($frame['@type']) ? $frame['@type'] : $settings['type'];
if (empty($type)) {
throw \Exception("You must provide a RDF Type.");
}
//type
$typeId = 'nemrod.elastica.type.' . $name . '.' . $typeName;
$indexId = 'nemrod.elastica.index.' . $name;
$typeDef = new DefinitionDecorator('nemrod.elastica.type.abstract');
$typeDef->replaceArgument(0, $type);
$typeDef->setFactory(array(new Reference($indexId), 'getType'));
$typeDef->addTag('nemrod.elastica.type', array('index' => $name, 'name' => $typeName, 'type' => $type));
$container->setDefinition($typeId, $typeDef);
//registering config to configManager
$confManager->addMethodCall('setTypeConfigurationArray', array($name, $typeName, $type, $frame));
}
}
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config/'));
$loader->load('services.xml');
$processor = new Processor();
$config = $processor->processConfiguration(new Configuration(), $configs);
$collection = 'in_memory';
switch (true) {
case 'redis' === $config['persistence']:
$loader->load('redis.xml');
$collection = 'predis';
$container->setParameter('qandidate.toggle.redis.namespace', $config['redis_namespace']);
$container->setAlias('qandidate.toggle.redis.client', $config['redis_client']);
break;
case 'factory' === $config['persistence']:
$collection = 'factory';
$definition = new DefinitionDecorator('qandidate.toggle.collection.in_memory');
$definition->setFactory(array(new Reference($config['collection_factory']['service_id']), $config['collection_factory']['method']));
$container->setDefinition('qandidate.toggle.collection.factory', $definition);
break;
}
$container->setAlias('qandidate.toggle.collection', 'qandidate.toggle.collection.' . $collection);
$contextFactoryService = 'qandidate.toggle.user_context_factory';
if (null !== $config['context_factory']) {
$contextFactoryService = $config['context_factory'];
}
$container->setAlias('qandidate.toggle.context_factory', $contextFactoryService);
}
/**
* Subclasses must return the id of a service which implements the
* AuthenticationProviderInterface.
*
* @param ContainerBuilder $container
* @param string $id The unique id of the firewall
* @param array $config The options array for this listener
* @param string $userProviderId The id of the user provider
*
* @return string never null, the id of the authentication provider
*/
protected function createAuthProvider(ContainerBuilder $container, $id, $config, $userProviderId)
{
$providerId = 'security.authentication.provider.appsco.' . $id;
$provider = new DefinitionDecorator('security.authentication.provider.appsco');
$provider->replaceArgument(0, new Reference($userProviderId));
$container->setDefinition($providerId, $provider);
return $providerId;
}
private function createAssetVersionStrategy($packageName, $versionStrategy)
{
$version = new DefinitionDecorator($this->namespaceService('asset.version_strategy'));
$version->addArgument($versionStrategy);
$versionId = $this->namespaceService("_package.{$packageName}.version_strategy_asset");
$this->container->setDefinition($versionId, $version);
return new Reference($versionId);
}
public function testMenu()
{
$definition = new DefinitionDecorator('lug.ui.menu.builder');
$definition->setClass($class = $this->createMenuBuilderClassMock());
$this->container->setDefinition($menuName = 'lug.ui.menu.test', $definition);
$this->compileContainer();
$this->assertInstanceOf($class, $this->container->get($menuName));
}
private function registerPayloadResolver(ContainerBuilder $container)
{
$definition = new Definition(PayloadResolver::class);
$definition->setAbstract(true);
$container->setDefinition('request_object.payload_resolver', $definition);
$implDefinition = new DefinitionDecorator('request_object.payload_resolver');
$implDefinition->setClass(HttpPayloadResolver::class);
$container->setDefinition('request_object.payload_resolver.http', $implDefinition);
}
/**
* {@inheritDoc}
*/
protected function createStorage(ContainerBuilder $container, $modelClass, array $config)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../../../Resources/config/storage'));
$loader->load('doctrine.' . $config['driver'] . '.xml');
$storage = new DefinitionDecorator(sprintf('payum.storage.doctrine.%s', $config['driver']));
$storage->setPublic(true);
$storage->replaceArgument(1, $modelClass);
return $storage;
}
/**
* {@inheritDoc}
*/
protected function createStorage(ContainerBuilder $container, $modelClass, array $config)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../../../Resources/config/storage'));
$loader->load('propel1.xml');
$storage = new DefinitionDecorator('payum.storage.propel1');
$storage->setPublic(true);
$storage->replaceArgument(0, $modelClass);
return $storage;
}
/**
* {@inheritDoc}
*/
protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config)
{
$apiDefinition = new DefinitionDecorator('payum.limonetik.api.prototype');
$apiDefinition->replaceArgument(0, array('merchantId' => $config['merchant_id'], 'key' => $config['key'], 'sandbox' => $config['sandbox']));
$apiDefinition->setPublic(true);
$apiId = 'payum.context.' . $contextName . '.api';
$container->setDefinition($apiId, $apiDefinition);
$paymentDefinition->addMethodCall('addApi', array(new Reference($apiId)));
}
/**
* {@inheritDoc}
*/
public function create(ContainerBuilder $container, $resolverName, array $config)
{
$awsS3ClientId = 'liip_imagine.cache.resolver.'.$resolverName.'.client';
$awsS3ClientDefinition = new Definition('Aws\S3\S3Client');
if (method_exists($awsS3ClientDefinition, 'setFactory')) {
$awsS3ClientDefinition->setFactory(array('Aws\S3\S3Client', 'factory'));
} else {
// to be removed when dependency on Symfony DependencyInjection is bumped to 2.6
$awsS3ClientDefinition->setFactoryClass('Aws\S3\S3Client');
$awsS3ClientDefinition->setFactoryMethod('factory');
}
$awsS3ClientDefinition->addArgument($config['client_config']);
$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 the listener.
*
* @return string
*/
protected function createListener($container, $id, $config, $userProvider)
{
$listenerId = $this->getListenerId();
$listener = new DefinitionDecorator($listenerId);
$listener->replaceArgument(2, $id);
$listenerId .= '.' . $id;
$container->setDefinition($listenerId, $listener);
return $listenerId;
}
/**
* {@inheritDoc}
*/
protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config)
{
$apiDefinition = new DefinitionDecorator('payum.paypal.express_checkout_nvp.api.prototype');
$apiDefinition->replaceArgument(0, array('username' => $config['username'], 'password' => $config['password'], 'signature' => $config['signature'], 'sandbox' => $config['sandbox']));
$apiDefinition->setPublic(true);
$apiId = 'payum.context.' . $contextName . '.api';
$container->setDefinition($apiId, $apiDefinition);
$paymentDefinition->addMethodCall('addApi', array(new Reference($apiId)));
}
/**
* {@inheritDoc}
*/
protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config)
{
$apiDefinition = new DefinitionDecorator('payum.be2bill.api.prototype');
$apiDefinition->replaceArgument(1, array('identifier' => $config['identifier'], 'password' => $config['password'], 'sandbox' => $config['sandbox']));
$apiDefinition->setPublic(true);
$apiId = 'payum.context.' . $contextName . '.api';
$container->setDefinition($apiId, $apiDefinition);
$paymentDefinition->addMethodCall('addApi', array(new Reference($apiId)));
}
protected function createLogger($channel, $loggerId, ContainerBuilder $container)
{
if (!in_array($channel, $this->channels)) {
$logger = new DefinitionDecorator('monolog.logger_prototype');
$logger->replaceArgument(0, $channel);
$container->setDefinition($loggerId, $logger);
$this->channels[] = $channel;
}
}
/**
* {@inheritDoc}
*/
public function create(ContainerBuilder $container, $loaderName, array $config)
{
$loaderDefinition = new DefinitionDecorator('liip_imagine.binary.loader.prototype.filesystem');
$loaderDefinition->replaceArgument(2, $config['data_root']);
$loaderDefinition->addTag('liip_imagine.binary.loader', array('loader' => $loaderName));
$loaderId = 'liip_imagine.binary.loader.' . $loaderName;
$container->setDefinition($loaderId, $loaderDefinition);
return $loaderId;
}
/**
* @param array $config
* @param ContainerBuilder $container
*/
private function loadArrayFormType(ContainerBuilder $container, array $config)
{
$serviceId = 'jd_form.form_type.array';
$types = ['hidden', 'text'];
foreach ($types as $type) {
$typeDef = new DefinitionDecorator($serviceId);
$typeDef->setArguments([$type, $config['delimiter']])->addTag('form.type', ['alias' => 'array_' . $type]);
$container->setDefinition($serviceId . '_' . $type, $typeDef);
}
}
/**
* {@inheritDoc}
*/
protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config)
{
$publishableKey = new DefinitionDecorator('payum.stripe.keys.prototype');
$publishableKey->replaceArgument(0, $config['publishable_key']);
$publishableKey->replaceArgument(1, $config['secret_key']);
$publishableKey->setPublic(true);
$publishableKeyId = 'payum.context.' . $contextName . '.keys';
$container->setDefinition($publishableKeyId, $publishableKey);
$paymentDefinition->addMethodCall('addApi', array(new Reference($publishableKeyId)));
}
/**
* {@inheritdoc}
*/
public function create(ContainerBuilder $container, $resolverName, array $config)
{
$resolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.web_path');
$resolverDefinition->replaceArgument(2, $config['web_root']);
$resolverDefinition->replaceArgument(3, $config['cache_prefix']);
$resolverDefinition->addTag('liip_imagine.cache.resolver', array('resolver' => $resolverName));
$resolverId = 'liip_imagine.cache.resolver.' . $resolverName;
$container->setDefinition($resolverId, $resolverDefinition);
return $resolverId;
}
private function loadSelect2Types(ContainerBuilder $container)
{
$serviceId = 'admingenerator.form.extensions.type.select2';
$select2types = array('choice', 'language', 'country', 'timezone', 'locale', 'entity', 'document', 'model', 'hidden');
foreach ($select2types as $type) {
$typeDef = new DefinitionDecorator($serviceId);
$typeDef->addArgument($type)->addTag('form.type', array('alias' => 's2a_select2_' . $type));
$container->setDefinition($serviceId . '.' . $type, $typeDef);
}
}
/**
* @param ContainerBuilder $container
* @param string $name
* @param string $options
*/
private function setupProviderService(ContainerBuilder $container, $name, $options)
{
$type = $options['type'];
unset($options['type']);
$container->setParameter("vss_oauth_extension.providers.{$name}.client_id", $options['client_id']);
$definition = new DefinitionDecorator('vss_oauth_extension.providers.generic.oauth2');
$definition->setClass("%vss_oauth_extension.providers.{$type}.class%");
$container->setDefinition('vss_oauth_extension.providers.' . $name, $definition);
$definition->replaceArgument(1, $options)->replaceArgument(2, $name);
}
protected function createListener(ContainerBuilder $container, $id, $config, $userProvider)
{
$listenerId = 'security.authentication.listener.form';
$listener = new DefinitionDecorator($listenerId);
$listener->replaceArgument(4, $id);
$listener->replaceArgument(5, $config);
$listenerId .= '.' . $id;
$container->setDefinition($listenerId, $listener);
return $listenerId;
}
