568 lines
25 KiB
PHP
568 lines
25 KiB
PHP
<?php
|
|
|
|
namespace FOS\ElasticaBundle\DependencyInjection;
|
|
|
|
use Symfony\Component\HttpKernel\DependencyInjection\Extension;
|
|
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
|
|
use Symfony\Component\DependencyInjection\ContainerAwareInterface;
|
|
use Symfony\Component\DependencyInjection\ContainerBuilder;
|
|
use Symfony\Component\DependencyInjection\Definition;
|
|
use Symfony\Component\DependencyInjection\DefinitionDecorator;
|
|
use Symfony\Component\DependencyInjection\Reference;
|
|
use Symfony\Component\Config\FileLocator;
|
|
use InvalidArgumentException;
|
|
|
|
class FOSElasticaExtension extends Extension
|
|
{
|
|
protected $indexConfigs = array();
|
|
protected $typeFields = array();
|
|
protected $loadedDrivers = array();
|
|
protected $serializerConfig = array();
|
|
|
|
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('config.xml');
|
|
|
|
if (empty($config['clients']) || empty($config['indexes'])) {
|
|
throw new InvalidArgumentException('You must define at least one client and one index');
|
|
}
|
|
|
|
if (empty($config['default_client'])) {
|
|
$keys = array_keys($config['clients']);
|
|
$config['default_client'] = reset($keys);
|
|
}
|
|
|
|
if (empty($config['default_index'])) {
|
|
$keys = array_keys($config['indexes']);
|
|
$config['default_index'] = reset($keys);
|
|
}
|
|
|
|
$clientIdsByName = $this->loadClients($config['clients'], $container);
|
|
$this->serializerConfig = isset($config['serializer']) ? $config['serializer'] : null;
|
|
$indexIdsByName = $this->loadIndexes($config['indexes'], $container, $clientIdsByName, $config['default_client']);
|
|
$indexRefsByName = array_map(function($id) {
|
|
return new Reference($id);
|
|
}, $indexIdsByName);
|
|
|
|
$this->loadIndexManager($indexRefsByName, $container);
|
|
$this->loadResetter($this->indexConfigs, $container);
|
|
|
|
$container->setAlias('fos_elastica.client', sprintf('fos_elastica.client.%s', $config['default_client']));
|
|
$container->setAlias('fos_elastica.index', sprintf('fos_elastica.index.%s', $config['default_index']));
|
|
|
|
$this->createDefaultManagerAlias($config['default_manager'], $container);
|
|
}
|
|
|
|
public function getConfiguration(array $config, ContainerBuilder $container)
|
|
{
|
|
return new Configuration($config);
|
|
}
|
|
|
|
/**
|
|
* Loads the configured clients.
|
|
*
|
|
* @param array $clients An array of clients configurations
|
|
* @param ContainerBuilder $container A ContainerBuilder instance
|
|
* @return array
|
|
*/
|
|
protected function loadClients(array $clients, ContainerBuilder $container)
|
|
{
|
|
$clientIds = array();
|
|
foreach ($clients as $name => $clientConfig) {
|
|
$clientId = sprintf('fos_elastica.client.%s', $name);
|
|
$clientDef = new Definition('%fos_elastica.client.class%', array($clientConfig));
|
|
$logger = $clientConfig['servers'][0]['logger'];
|
|
if (false !== $logger) {
|
|
$clientDef->addMethodCall('setLogger', array(new Reference($logger)));
|
|
}
|
|
$clientDef->addTag('fos_elastica.client');
|
|
|
|
$container->setDefinition($clientId, $clientDef);
|
|
|
|
$clientIds[$name] = $clientId;
|
|
}
|
|
|
|
return $clientIds;
|
|
}
|
|
|
|
/**
|
|
* Loads the configured indexes.
|
|
*
|
|
* @param array $indexes An array of indexes configurations
|
|
* @param ContainerBuilder $container A ContainerBuilder instance
|
|
* @param array $clientIdsByName
|
|
* @param $defaultClientName
|
|
* @param $serializerConfig
|
|
* @throws \InvalidArgumentException
|
|
* @return array
|
|
*/
|
|
protected function loadIndexes(array $indexes, ContainerBuilder $container, array $clientIdsByName, $defaultClientName)
|
|
{
|
|
$indexIds = array();
|
|
foreach ($indexes as $name => $index) {
|
|
if (isset($index['client'])) {
|
|
$clientName = $index['client'];
|
|
if (!isset($clientIdsByName[$clientName])) {
|
|
throw new InvalidArgumentException(sprintf('The elastica client with name "%s" is not defined', $clientName));
|
|
}
|
|
} else {
|
|
$clientName = $defaultClientName;
|
|
}
|
|
|
|
$clientId = $clientIdsByName[$clientName];
|
|
$indexId = sprintf('fos_elastica.index.%s', $name);
|
|
$indexName = isset($index['index_name']) ? $index['index_name'] : $name;
|
|
$indexDefArgs = array($indexName);
|
|
$indexDef = new Definition('%fos_elastica.index.class%', $indexDefArgs);
|
|
$indexDef->setFactoryService($clientId);
|
|
$indexDef->setFactoryMethod('getIndex');
|
|
$container->setDefinition($indexId, $indexDef);
|
|
$typePrototypeConfig = isset($index['type_prototype']) ? $index['type_prototype'] : array();
|
|
$indexIds[$name] = $indexId;
|
|
$this->indexConfigs[$name] = array(
|
|
'index' => new Reference($indexId),
|
|
'name_or_alias' => $indexName,
|
|
'config' => array(
|
|
'mappings' => array()
|
|
)
|
|
);
|
|
if ($index['finder']) {
|
|
$this->loadIndexFinder($container, $name, $indexId);
|
|
}
|
|
if (!empty($index['settings'])) {
|
|
$this->indexConfigs[$name]['config']['settings'] = $index['settings'];
|
|
}
|
|
if ($index['use_alias']) {
|
|
$this->indexConfigs[$name]['use_alias'] = true;
|
|
}
|
|
|
|
$this->loadTypes(isset($index['types']) ? $index['types'] : array(), $container, $name, $indexId, $typePrototypeConfig);
|
|
}
|
|
|
|
return $indexIds;
|
|
}
|
|
|
|
/**
|
|
* Loads the configured index finders.
|
|
*
|
|
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
|
|
* @param string $name The index name
|
|
* @param string $indexId The index service identifier
|
|
* @return string
|
|
*/
|
|
protected function loadIndexFinder(ContainerBuilder $container, $name, $indexId)
|
|
{
|
|
/* Note: transformer services may conflict with "collection.index", if
|
|
* an index and type names were "collection" and an index, respectively.
|
|
*/
|
|
$transformerId = sprintf('fos_elastica.elastica_to_model_transformer.collection.%s', $name);
|
|
$transformerDef = new DefinitionDecorator('fos_elastica.elastica_to_model_transformer.collection');
|
|
$container->setDefinition($transformerId, $transformerDef);
|
|
|
|
$finderId = sprintf('fos_elastica.finder.%s', $name);
|
|
$finderDef = new DefinitionDecorator('fos_elastica.finder');
|
|
$finderDef->replaceArgument(0, new Reference($indexId));
|
|
$finderDef->replaceArgument(1, new Reference($transformerId));
|
|
|
|
$container->setDefinition($finderId, $finderDef);
|
|
|
|
return $finderId;
|
|
}
|
|
|
|
/**
|
|
* Loads the configured types.
|
|
*
|
|
* @param array $types An array of types configurations
|
|
* @param ContainerBuilder $container A ContainerBuilder instance
|
|
* @param $indexName
|
|
* @param $indexId
|
|
* @param array $typePrototypeConfig
|
|
* @param $serializerConfig
|
|
*/
|
|
protected function loadTypes(array $types, ContainerBuilder $container, $indexName, $indexId, array $typePrototypeConfig)
|
|
{
|
|
foreach ($types as $name => $type) {
|
|
$type = self::deepArrayUnion($typePrototypeConfig, $type);
|
|
$typeId = sprintf('%s.%s', $indexId, $name);
|
|
$typeDefArgs = array($name);
|
|
$typeDef = new Definition('%fos_elastica.type.class%', $typeDefArgs);
|
|
$typeDef->setFactoryService($indexId);
|
|
$typeDef->setFactoryMethod('getType');
|
|
if ($this->serializerConfig) {
|
|
$callbackDef = new Definition($this->serializerConfig['callback_class']);
|
|
$callbackId = sprintf('%s.%s.serializer.callback', $indexId, $name);
|
|
|
|
$typeDef->addMethodCall('setSerializer', array(array(new Reference($callbackId), 'serialize')));
|
|
$callbackDef->addMethodCall('setSerializer', array(new Reference($this->serializerConfig['serializer'])));
|
|
if (isset($type['serializer']['groups'])) {
|
|
$callbackDef->addMethodCall('setGroups', array($type['serializer']['groups']));
|
|
}
|
|
if (isset($type['serializer']['version'])) {
|
|
$callbackDef->addMethodCall('setVersion', array($type['serializer']['version']));
|
|
}
|
|
$callbackClassImplementedInterfaces = class_implements($this->serializerConfig['callback_class']); // PHP < 5.4 friendly
|
|
if (isset($callbackClassImplementedInterfaces['Symfony\Component\DependencyInjection\ContainerAwareInterface'])) {
|
|
$callbackDef->addMethodCall('setContainer', array(new Reference('service_container')));
|
|
}
|
|
|
|
$container->setDefinition($callbackId, $callbackDef);
|
|
|
|
$typeDef->addMethodCall('setSerializer', array(array(new Reference($callbackId), 'serialize')));
|
|
}
|
|
$container->setDefinition($typeId, $typeDef);
|
|
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name] = array(
|
|
"_source" => array("enabled" => true), // Add a default setting for empty mapping settings
|
|
);
|
|
|
|
if (isset($type['_id'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_id'] = $type['_id'];
|
|
}
|
|
if (isset($type['_source'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_source'] = $type['_source'];
|
|
}
|
|
if (isset($type['_boost'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_boost'] = $type['_boost'];
|
|
}
|
|
if (isset($type['_routing'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_routing'] = $type['_routing'];
|
|
}
|
|
if (isset($type['mappings']) && !empty($type['mappings'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['properties'] = $type['mappings'];
|
|
$typeName = sprintf('%s/%s', $indexName, $name);
|
|
$this->typeFields[$typeName] = $type['mappings'];
|
|
}
|
|
if (isset($type['_parent'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_parent'] = array('type' => $type['_parent']['type']);
|
|
$typeName = sprintf('%s/%s', $indexName, $name);
|
|
$this->typeFields[$typeName]['_parent'] = $type['_parent'];
|
|
}
|
|
if (isset($type['persistence'])) {
|
|
$this->loadTypePersistenceIntegration($type['persistence'], $container, $typeDef, $indexName, $name);
|
|
}
|
|
if (isset($type['index_analyzer'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['index_analyzer'] = $type['index_analyzer'];
|
|
}
|
|
if (isset($type['search_analyzer'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['search_analyzer'] = $type['search_analyzer'];
|
|
}
|
|
if (isset($type['index'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['index'] = $type['index'];
|
|
}
|
|
if (isset($type['_all'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_all'] = $type['_all'];
|
|
}
|
|
if (isset($type['_timestamp'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_timestamp'] = $type['_timestamp'];
|
|
}
|
|
if (isset($type['_ttl'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_ttl'] = $type['_ttl'];
|
|
}
|
|
if (!empty($type['dynamic_templates'])) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['dynamic_templates'] = array();
|
|
foreach ($type['dynamic_templates'] as $templateName => $templateData) {
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['dynamic_templates'][] = array($templateName => $templateData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merges two arrays without reindexing numeric keys.
|
|
*
|
|
* @param array $array1 An array to merge
|
|
* @param array $array2 An array to merge
|
|
*
|
|
* @return array The merged array
|
|
*/
|
|
static protected function deepArrayUnion($array1, $array2)
|
|
{
|
|
foreach ($array2 as $key => $value) {
|
|
if (is_array($value) && isset($array1[$key]) && is_array($array1[$key])) {
|
|
$array1[$key] = self::deepArrayUnion($array1[$key], $value);
|
|
} else {
|
|
$array1[$key] = $value;
|
|
}
|
|
}
|
|
|
|
return $array1;
|
|
}
|
|
|
|
/**
|
|
* Loads the optional provider and finder for a type
|
|
*
|
|
* @param array $typeConfig
|
|
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
|
|
* @param \Symfony\Component\DependencyInjection\Definition $typeDef
|
|
* @param $indexName
|
|
* @param $typeName
|
|
*/
|
|
protected function loadTypePersistenceIntegration(array $typeConfig, ContainerBuilder $container, Definition $typeDef, $indexName, $typeName)
|
|
{
|
|
$this->loadDriver($container, $typeConfig['driver']);
|
|
|
|
$elasticaToModelTransformerId = $this->loadElasticaToModelTransformer($typeConfig, $container, $indexName, $typeName);
|
|
$modelToElasticaTransformerId = $this->loadModelToElasticaTransformer($typeConfig, $container, $indexName, $typeName);
|
|
$objectPersisterId = $this->loadObjectPersister($typeConfig, $typeDef, $container, $indexName, $typeName, $modelToElasticaTransformerId);
|
|
|
|
if (isset($typeConfig['provider'])) {
|
|
$this->loadTypeProvider($typeConfig, $container, $objectPersisterId, $typeDef, $indexName, $typeName);
|
|
}
|
|
if (isset($typeConfig['finder'])) {
|
|
$this->loadTypeFinder($typeConfig, $container, $elasticaToModelTransformerId, $typeDef, $indexName, $typeName);
|
|
}
|
|
if (isset($typeConfig['listener'])) {
|
|
$this->loadTypeListener($typeConfig, $container, $objectPersisterId, $typeDef, $indexName, $typeName);
|
|
}
|
|
}
|
|
|
|
protected function loadElasticaToModelTransformer(array $typeConfig, ContainerBuilder $container, $indexName, $typeName)
|
|
{
|
|
if (isset($typeConfig['elastica_to_model_transformer']['service'])) {
|
|
return $typeConfig['elastica_to_model_transformer']['service'];
|
|
}
|
|
/* Note: transformer services may conflict with "prototype.driver", if
|
|
* the index and type names were "prototype" and a driver, respectively.
|
|
*/
|
|
$abstractId = sprintf('fos_elastica.elastica_to_model_transformer.prototype.%s', $typeConfig['driver']);
|
|
$serviceId = sprintf('fos_elastica.elastica_to_model_transformer.%s.%s', $indexName, $typeName);
|
|
$serviceDef = new DefinitionDecorator($abstractId);
|
|
$serviceDef->addTag('fos_elastica.elastica_to_model_transformer', array('type' => $typeName, 'index' => $indexName));
|
|
|
|
// Doctrine has a mandatory service as first argument
|
|
$argPos = ('propel' === $typeConfig['driver']) ? 0 : 1;
|
|
|
|
$serviceDef->replaceArgument($argPos, $typeConfig['model']);
|
|
$serviceDef->replaceArgument($argPos + 1, array(
|
|
'hydrate' => $typeConfig['elastica_to_model_transformer']['hydrate'],
|
|
'identifier' => $typeConfig['identifier'],
|
|
'ignore_missing' => $typeConfig['elastica_to_model_transformer']['ignore_missing'],
|
|
'query_builder_method' => $typeConfig['elastica_to_model_transformer']['query_builder_method']
|
|
));
|
|
$container->setDefinition($serviceId, $serviceDef);
|
|
|
|
return $serviceId;
|
|
}
|
|
|
|
protected function loadModelToElasticaTransformer(array $typeConfig, ContainerBuilder $container, $indexName, $typeName)
|
|
{
|
|
if (isset($typeConfig['model_to_elastica_transformer']['service'])) {
|
|
return $typeConfig['model_to_elastica_transformer']['service'];
|
|
}
|
|
|
|
if ($this->serializerConfig) {
|
|
$abstractId = sprintf('fos_elastica.model_to_elastica_identifier_transformer');
|
|
} else {
|
|
$abstractId = sprintf('fos_elastica.model_to_elastica_transformer');
|
|
}
|
|
|
|
$serviceId = sprintf('fos_elastica.model_to_elastica_transformer.%s.%s', $indexName, $typeName);
|
|
$serviceDef = new DefinitionDecorator($abstractId);
|
|
$serviceDef->replaceArgument(0, array(
|
|
'identifier' => $typeConfig['identifier']
|
|
));
|
|
$container->setDefinition($serviceId, $serviceDef);
|
|
|
|
return $serviceId;
|
|
}
|
|
|
|
protected function loadObjectPersister(array $typeConfig, Definition $typeDef, ContainerBuilder $container, $indexName, $typeName, $transformerId)
|
|
{
|
|
$arguments = array(
|
|
$typeDef,
|
|
new Reference($transformerId),
|
|
$typeConfig['model'],
|
|
);
|
|
|
|
if ($this->serializerConfig) {
|
|
$abstractId = 'fos_elastica.object_serializer_persister';
|
|
$callbackId = sprintf('%s.%s.serializer.callback', $this->indexConfigs[$indexName]['index'], $typeName);
|
|
$arguments[] = array(new Reference($callbackId), 'serialize');
|
|
} else {
|
|
$abstractId = 'fos_elastica.object_persister';
|
|
$arguments[] = $this->typeFields[sprintf('%s/%s', $indexName, $typeName)];
|
|
}
|
|
$serviceId = sprintf('fos_elastica.object_persister.%s.%s', $indexName, $typeName);
|
|
$serviceDef = new DefinitionDecorator($abstractId);
|
|
foreach ($arguments as $i => $argument) {
|
|
$serviceDef->replaceArgument($i, $argument);
|
|
}
|
|
|
|
$container->setDefinition($serviceId, $serviceDef);
|
|
|
|
return $serviceId;
|
|
}
|
|
|
|
protected function loadTypeProvider(array $typeConfig, ContainerBuilder $container, $objectPersisterId, $typeDef, $indexName, $typeName)
|
|
{
|
|
if (isset($typeConfig['provider']['service'])) {
|
|
return $typeConfig['provider']['service'];
|
|
}
|
|
/* Note: provider services may conflict with "prototype.driver", if the
|
|
* index and type names were "prototype" and a driver, respectively.
|
|
*/
|
|
$providerId = sprintf('fos_elastica.provider.%s.%s', $indexName, $typeName);
|
|
$providerDef = new DefinitionDecorator('fos_elastica.provider.prototype.' . $typeConfig['driver']);
|
|
$providerDef->addTag('fos_elastica.provider', array('index' => $indexName, 'type' => $typeName));
|
|
$providerDef->replaceArgument(0, new Reference($objectPersisterId));
|
|
$providerDef->replaceArgument(1, $typeConfig['model']);
|
|
// Propel provider can simply ignore Doctrine-specific options
|
|
$providerDef->replaceArgument(2, array_diff_key($typeConfig['provider'], array('service' => 1)));
|
|
$container->setDefinition($providerId, $providerDef);
|
|
|
|
return $providerId;
|
|
}
|
|
|
|
protected function loadTypeListener(array $typeConfig, ContainerBuilder $container, $objectPersisterId, $typeDef, $indexName, $typeName)
|
|
{
|
|
if (isset($typeConfig['listener']['service'])) {
|
|
return $typeConfig['listener']['service'];
|
|
}
|
|
/* Note: listener services may conflict with "prototype.driver", if the
|
|
* index and type names were "prototype" and a driver, respectively.
|
|
*/
|
|
$abstractListenerId = sprintf('fos_elastica.listener.prototype.%s', $typeConfig['driver']);
|
|
$listenerId = sprintf('fos_elastica.listener.%s.%s', $indexName, $typeName);
|
|
$listenerDef = new DefinitionDecorator($abstractListenerId);
|
|
$listenerDef->replaceArgument(0, new Reference($objectPersisterId));
|
|
$listenerDef->replaceArgument(1, $typeConfig['model']);
|
|
$listenerDef->replaceArgument(3, $typeConfig['identifier']);
|
|
$listenerDef->replaceArgument(2, $this->getDoctrineEvents($typeConfig));
|
|
switch ($typeConfig['driver']) {
|
|
case 'orm': $listenerDef->addTag('doctrine.event_subscriber'); break;
|
|
case 'mongodb': $listenerDef->addTag('doctrine_mongodb.odm.event_subscriber'); break;
|
|
}
|
|
if (isset($typeConfig['listener']['is_indexable_callback'])) {
|
|
$callback = $typeConfig['listener']['is_indexable_callback'];
|
|
|
|
if (is_array($callback)) {
|
|
list($class) = $callback + array(null);
|
|
if (is_string($class) && !class_exists($class)) {
|
|
$callback[0] = new Reference($class);
|
|
}
|
|
}
|
|
|
|
$listenerDef->addMethodCall('setIsIndexableCallback', array($callback));
|
|
}
|
|
$container->setDefinition($listenerId, $listenerDef);
|
|
|
|
return $listenerId;
|
|
}
|
|
|
|
/**
|
|
* Map Elastica to Doctrine events for the current driver
|
|
*/
|
|
private function getDoctrineEvents(array $typeConfig)
|
|
{
|
|
// Flush always calls depending on actions scheduled in lifecycle listeners
|
|
$typeConfig['listener']['flush'] = true;
|
|
|
|
switch ($typeConfig['driver']) {
|
|
case 'orm':
|
|
$eventsClass = '\Doctrine\ORM\Events';
|
|
break;
|
|
case 'mongodb':
|
|
$eventsClass = '\Doctrine\ODM\MongoDB\Events';
|
|
break;
|
|
default:
|
|
throw new InvalidArgumentException(sprintf('Cannot determine events for driver "%s"', $typeConfig['driver']));
|
|
break;
|
|
}
|
|
|
|
$events = array();
|
|
$eventMapping = array(
|
|
'insert' => array(constant($eventsClass.'::postPersist')),
|
|
'update' => array(constant($eventsClass.'::postUpdate')),
|
|
'delete' => array(constant($eventsClass.'::preRemove')),
|
|
'flush' => array($typeConfig['listener']['immediate'] ? constant($eventsClass.'::preFlush') : constant($eventsClass.'::postFlush'))
|
|
);
|
|
|
|
foreach ($eventMapping as $event => $doctrineEvents) {
|
|
if (isset($typeConfig['listener'][$event]) && $typeConfig['listener'][$event]) {
|
|
$events = array_merge($events, $doctrineEvents);
|
|
}
|
|
}
|
|
|
|
return $events;
|
|
}
|
|
|
|
protected function loadTypeFinder(array $typeConfig, ContainerBuilder $container, $elasticaToModelId, $typeDef, $indexName, $typeName)
|
|
{
|
|
if (isset($typeConfig['finder']['service'])) {
|
|
$finderId = $typeConfig['finder']['service'];
|
|
} else {
|
|
$finderId = sprintf('fos_elastica.finder.%s.%s', $indexName, $typeName);
|
|
$finderDef = new DefinitionDecorator('fos_elastica.finder');
|
|
$finderDef->replaceArgument(0, $typeDef);
|
|
$finderDef->replaceArgument(1, new Reference($elasticaToModelId));
|
|
$container->setDefinition($finderId, $finderDef);
|
|
}
|
|
|
|
$managerId = sprintf('fos_elastica.manager.%s', $typeConfig['driver']);
|
|
$managerDef = $container->getDefinition($managerId);
|
|
$arguments = array( $typeConfig['model'], new Reference($finderId));
|
|
if (isset($typeConfig['repository'])) {
|
|
$arguments[] = $typeConfig['repository'];
|
|
}
|
|
$managerDef->addMethodCall('addEntity', $arguments);
|
|
|
|
return $finderId;
|
|
}
|
|
|
|
/**
|
|
* Loads the index manager
|
|
*
|
|
* @param array $indexRefsByName
|
|
* @param ContainerBuilder $container
|
|
**/
|
|
protected function loadIndexManager(array $indexRefsByName, ContainerBuilder $container)
|
|
{
|
|
$managerDef = $container->getDefinition('fos_elastica.index_manager');
|
|
$managerDef->replaceArgument(0, $indexRefsByName);
|
|
$managerDef->replaceArgument(1, new Reference('fos_elastica.index'));
|
|
}
|
|
|
|
/**
|
|
* Loads the resetter
|
|
*
|
|
* @param array $indexConfigs
|
|
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
|
|
*/
|
|
protected function loadResetter(array $indexConfigs, ContainerBuilder $container)
|
|
{
|
|
$resetterDef = $container->getDefinition('fos_elastica.resetter');
|
|
$resetterDef->replaceArgument(0, $indexConfigs);
|
|
}
|
|
|
|
protected function loadDriver(ContainerBuilder $container, $driver)
|
|
{
|
|
if (in_array($driver, $this->loadedDrivers)) {
|
|
return;
|
|
}
|
|
$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
|
|
$loader->load($driver.'.xml');
|
|
$this->loadedDrivers[] = $driver;
|
|
}
|
|
|
|
protected function createDefaultManagerAlias($defaultManager, ContainerBuilder $container)
|
|
{
|
|
if (0 == count($this->loadedDrivers)) {
|
|
return;
|
|
}
|
|
|
|
if (count($this->loadedDrivers) > 1
|
|
&& in_array($defaultManager, $this->loadedDrivers)
|
|
) {
|
|
$defaultManagerService = $defaultManager;
|
|
} else {
|
|
$defaultManagerService = $this->loadedDrivers[0];
|
|
}
|
|
|
|
$container->setAlias('fos_elastica.manager', sprintf('fos_elastica.manager.%s', $defaultManagerService));
|
|
}
|
|
}
|