2011-04-10 23:08:51 +02:00
|
|
|
<?php
|
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
namespace FOS\ElasticaBundle\DependencyInjection;
|
2011-04-10 23:08:51 +02:00
|
|
|
|
|
|
|
use Symfony\Component\HttpKernel\DependencyInjection\Extension;
|
|
|
|
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
|
|
|
|
use Symfony\Component\DependencyInjection\ContainerBuilder;
|
|
|
|
use Symfony\Component\DependencyInjection\Definition;
|
2011-04-20 22:53:59 +02:00
|
|
|
use Symfony\Component\DependencyInjection\DefinitionDecorator;
|
2011-04-13 00:15:48 +02:00
|
|
|
use Symfony\Component\DependencyInjection\Reference;
|
2011-04-10 23:08:51 +02:00
|
|
|
use Symfony\Component\Config\FileLocator;
|
2011-04-14 00:04:49 +02:00
|
|
|
use InvalidArgumentException;
|
2011-04-10 23:08:51 +02:00
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
class FOSElasticaExtension extends Extension
|
2011-04-10 23:08:51 +02:00
|
|
|
{
|
2011-12-20 17:44:39 +01:00
|
|
|
protected $indexConfigs = array();
|
|
|
|
protected $typeFields = array();
|
|
|
|
protected $loadedDrivers = array();
|
2011-04-27 09:59:04 +02:00
|
|
|
|
|
|
|
public function load(array $configs, ContainerBuilder $container)
|
|
|
|
{
|
2013-02-01 15:37:57 +01:00
|
|
|
$configuration = $this->getConfiguration($configs, $container);
|
2013-02-13 16:15:27 +01:00
|
|
|
$config = $this->processConfiguration($configuration, $configs);
|
2011-04-27 09:59:04 +02:00
|
|
|
|
|
|
|
$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);
|
|
|
|
}
|
|
|
|
|
2011-12-20 17:48:56 +01:00
|
|
|
$clientIdsByName = $this->loadClients($config['clients'], $container);
|
2013-01-10 14:05:50 +01:00
|
|
|
$indexIdsByName = $this->loadIndexes($config['indexes'], $container, $clientIdsByName, $config['default_client'], $config['serializer_id']);
|
2012-03-02 05:32:04 +01:00
|
|
|
$indexRefsByName = array_map(function($id) {
|
|
|
|
return new Reference($id);
|
2011-04-27 09:59:04 +02:00
|
|
|
}, $indexIdsByName);
|
|
|
|
|
2012-03-02 05:32:04 +01:00
|
|
|
$this->loadIndexManager($indexRefsByName, $container);
|
2012-03-02 06:28:38 +01:00
|
|
|
$this->loadResetter($this->indexConfigs, $container);
|
2011-04-27 09:59:04 +02:00
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
$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']));
|
2011-12-12 00:09:13 +01:00
|
|
|
|
2011-12-23 17:20:22 +01:00
|
|
|
$this->createDefaultManagerAlias($config['default_manager'], $container);
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
|
|
|
|
2013-02-01 15:37:57 +01:00
|
|
|
public function getConfiguration(array $config, ContainerBuilder $container)
|
|
|
|
{
|
|
|
|
return new Configuration($config);
|
|
|
|
}
|
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
/**
|
|
|
|
* Loads the configured clients.
|
|
|
|
*
|
2013-03-02 12:23:44 +01:00
|
|
|
* @param array $clients An array of clients configurations
|
2011-04-27 09:59:04 +02:00
|
|
|
* @param ContainerBuilder $container A ContainerBuilder instance
|
2013-03-02 12:23:44 +01:00
|
|
|
* @return array
|
2011-04-27 09:59:04 +02:00
|
|
|
*/
|
|
|
|
protected function loadClients(array $clients, ContainerBuilder $container)
|
|
|
|
{
|
|
|
|
$clientIds = array();
|
2011-05-11 18:21:13 +02:00
|
|
|
foreach ($clients as $name => $clientConfig) {
|
2013-03-27 18:44:06 +01:00
|
|
|
$clientDef = $container->getDefinition('fos_elastica.client');
|
2011-11-30 00:41:03 +01:00
|
|
|
$clientDef->replaceArgument(0, $clientConfig);
|
2011-10-04 17:01:38 +02:00
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
$clientId = sprintf('fos_elastica.client.%s', $name);
|
2011-10-04 17:01:38 +02:00
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
$container->setDefinition($clientId, $clientDef);
|
2011-10-04 17:01:38 +02:00
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
$clientIds[$name] = $clientId;
|
|
|
|
}
|
|
|
|
|
|
|
|
return $clientIds;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Loads the configured indexes.
|
|
|
|
*
|
2013-03-02 12:23:44 +01:00
|
|
|
* @param array $indexes An array of indexes configurations
|
2011-04-27 09:59:04 +02:00
|
|
|
* @param ContainerBuilder $container A ContainerBuilder instance
|
2013-03-02 12:23:44 +01:00
|
|
|
* @param array $clientIdsByName
|
|
|
|
* @param $defaultClientName
|
|
|
|
* @throws \InvalidArgumentException
|
|
|
|
* @return array
|
2011-04-27 09:59:04 +02:00
|
|
|
*/
|
2013-01-10 14:05:50 +01:00
|
|
|
protected function loadIndexes(array $indexes, ContainerBuilder $container, array $clientIdsByName, $defaultClientName, $serializerId)
|
2011-04-27 09:59:04 +02:00
|
|
|
{
|
|
|
|
$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;
|
|
|
|
}
|
2011-12-20 17:44:39 +01:00
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
$clientId = $clientIdsByName[$clientName];
|
2013-03-27 18:44:06 +01:00
|
|
|
$indexId = sprintf('fos_elastica.index.%s', $name);
|
2013-01-04 15:02:50 +01:00
|
|
|
$indexName = isset($index['index_name']) ? $index['index_name'] : $name;
|
|
|
|
$indexDefArgs = array($indexName);
|
2013-03-27 18:44:06 +01:00
|
|
|
$indexDef = new Definition('%fos_elastica.index.class%', $indexDefArgs);
|
2011-04-27 09:59:04 +02:00
|
|
|
$indexDef->setFactoryService($clientId);
|
|
|
|
$indexDef->setFactoryMethod('getIndex');
|
|
|
|
$container->setDefinition($indexId, $indexDef);
|
2011-04-27 22:24:29 +02:00
|
|
|
$typePrototypeConfig = isset($index['type_prototype']) ? $index['type_prototype'] : array();
|
2013-03-04 20:57:08 +01:00
|
|
|
$indexIds[$name] = $indexId;
|
2011-09-12 18:28:59 +02:00
|
|
|
$this->indexConfigs[$name] = array(
|
|
|
|
'index' => new Reference($indexId),
|
|
|
|
'config' => array(
|
|
|
|
'mappings' => array()
|
|
|
|
)
|
|
|
|
);
|
2012-01-06 22:52:49 +01:00
|
|
|
if ($index['finder']) {
|
2012-01-03 11:20:38 +01:00
|
|
|
$this->loadIndexFinder($container, $name, $indexId);
|
|
|
|
}
|
2011-09-13 12:23:27 +02:00
|
|
|
if (!empty($index['settings'])) {
|
|
|
|
$this->indexConfigs[$name]['config']['settings'] = $index['settings'];
|
|
|
|
}
|
2013-01-10 14:05:50 +01:00
|
|
|
$this->loadTypes(isset($index['types']) ? $index['types'] : array(), $container, $name, $indexId, $typePrototypeConfig, $serializerId);
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return $indexIds;
|
|
|
|
}
|
|
|
|
|
2012-01-03 11:20:38 +01:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2013-03-27 18:44:06 +01:00
|
|
|
$abstractTransformerId = 'fos_elastica.elastica_to_model_transformer.collection.prototype';
|
|
|
|
$transformerId = sprintf('fos_elastica.elastica_to_model_transformer.collection.%s', $name);
|
2012-01-03 11:20:38 +01:00
|
|
|
$transformerDef = new DefinitionDecorator($abstractTransformerId);
|
|
|
|
$container->setDefinition($transformerId, $transformerDef);
|
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
$abstractFinderId = 'fos_elastica.finder.prototype';
|
|
|
|
$finderId = sprintf('fos_elastica.finder.%s', $name);
|
2012-01-03 11:20:38 +01:00
|
|
|
$finderDef = new DefinitionDecorator($abstractFinderId);
|
|
|
|
$finderDef->replaceArgument(0, new Reference($indexId));
|
|
|
|
$finderDef->replaceArgument(1, new Reference($transformerId));
|
|
|
|
|
|
|
|
$container->setDefinition($finderId, $finderDef);
|
|
|
|
|
|
|
|
return $finderId;
|
|
|
|
}
|
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
/**
|
|
|
|
* Loads the configured types.
|
|
|
|
*
|
2013-03-02 12:23:44 +01:00
|
|
|
* @param array $types An array of types configurations
|
2011-04-27 09:59:04 +02:00
|
|
|
* @param ContainerBuilder $container A ContainerBuilder instance
|
2013-03-02 12:23:44 +01:00
|
|
|
* @param $indexName
|
|
|
|
* @param $indexId
|
|
|
|
* @param array $typePrototypeConfig
|
2011-04-27 09:59:04 +02:00
|
|
|
*/
|
2013-01-10 14:05:50 +01:00
|
|
|
protected function loadTypes(array $types, ContainerBuilder $container, $indexName, $indexId, array $typePrototypeConfig, $serializerId)
|
2011-04-27 09:59:04 +02:00
|
|
|
{
|
2013-01-10 14:05:50 +01:00
|
|
|
$serializer = $serializerId ? new Reference($serializerId) : null;
|
2011-04-27 09:59:04 +02:00
|
|
|
foreach ($types as $name => $type) {
|
2011-04-27 22:24:29 +02:00
|
|
|
$type = self::deepArrayUnion($typePrototypeConfig, $type);
|
2011-04-27 09:59:04 +02:00
|
|
|
$typeId = sprintf('%s.%s', $indexId, $name);
|
|
|
|
$typeDefArgs = array($name);
|
2013-03-27 18:44:06 +01:00
|
|
|
$typeDef = new Definition('%fos_elastica.type.class%', $typeDefArgs);
|
2011-04-27 09:59:04 +02:00
|
|
|
$typeDef->setFactoryService($indexId);
|
|
|
|
$typeDef->setFactoryMethod('getType');
|
2013-01-10 14:05:50 +01:00
|
|
|
if ($serializer) {
|
|
|
|
$typeDef->addMethodCall('setSerializer', array($serializer, $type['serializer']['groups']));
|
|
|
|
}
|
2011-04-27 09:59:04 +02:00
|
|
|
$container->setDefinition($typeId, $typeDef);
|
2012-04-02 19:53:51 +02:00
|
|
|
if (isset($type['_source'])) {
|
2012-05-24 20:13:58 +02:00
|
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_source'] = $type['_source'];
|
2012-04-02 19:53:51 +02:00
|
|
|
}
|
2012-08-09 05:49:04 +02:00
|
|
|
if (isset($type['_boost'])) {
|
|
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_boost'] = $type['_boost'];
|
|
|
|
}
|
2012-12-12 15:25:55 +01:00
|
|
|
if (isset($type['_routing'])) {
|
|
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['_routing'] = $type['_routing'];
|
|
|
|
}
|
2011-04-27 09:59:04 +02:00
|
|
|
if (isset($type['mappings'])) {
|
2012-04-02 19:53:51 +02:00
|
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['properties'] = $type['mappings'];
|
2011-09-12 18:28:59 +02:00
|
|
|
$typeName = sprintf('%s/%s', $indexName, $name);
|
2012-04-19 22:26:19 +02:00
|
|
|
$this->typeFields[$typeName] = $type['mappings'];
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
2011-12-20 17:44:39 +01:00
|
|
|
if (isset($type['persistence'])) {
|
|
|
|
$this->loadTypePersistenceIntegration($type['persistence'], $container, $typeDef, $indexName, $name);
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
2012-05-24 20:13:58 +02:00
|
|
|
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'];
|
|
|
|
}
|
2012-10-15 22:18:04 +02:00
|
|
|
if (isset($type['index'])) {
|
|
|
|
$this->indexConfigs[$indexName]['config']['mappings'][$name]['index'] = $type['index'];
|
|
|
|
}
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-27 22:24:29 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
/**
|
|
|
|
* Loads the optional provider and finder for a type
|
|
|
|
*
|
2013-03-02 12:23:44 +01:00
|
|
|
* @param array $typeConfig
|
|
|
|
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
|
|
|
|
* @param \Symfony\Component\DependencyInjection\Definition $typeDef
|
|
|
|
* @param $indexName
|
|
|
|
* @param $typeName
|
|
|
|
*/
|
2011-12-20 17:44:39 +01:00
|
|
|
protected function loadTypePersistenceIntegration(array $typeConfig, ContainerBuilder $container, Definition $typeDef, $indexName, $typeName)
|
2011-04-27 09:59:04 +02:00
|
|
|
{
|
2011-12-20 17:44:39 +01:00
|
|
|
$this->loadDriver($container, $typeConfig['driver']);
|
2011-04-27 09:59:04 +02:00
|
|
|
|
|
|
|
$elasticaToModelTransformerId = $this->loadElasticaToModelTransformer($typeConfig, $container, $indexName, $typeName);
|
|
|
|
$modelToElasticaTransformerId = $this->loadModelToElasticaTransformer($typeConfig, $container, $indexName, $typeName);
|
2011-06-07 20:13:34 +02:00
|
|
|
$objectPersisterId = $this->loadObjectPersister($typeConfig, $typeDef, $container, $indexName, $typeName, $modelToElasticaTransformerId);
|
2011-04-27 09:59:04 +02:00
|
|
|
|
|
|
|
if (isset($typeConfig['provider'])) {
|
2012-03-05 23:17:14 +01:00
|
|
|
$this->loadTypeProvider($typeConfig, $container, $objectPersisterId, $typeDef, $indexName, $typeName);
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
|
|
|
if (isset($typeConfig['finder'])) {
|
|
|
|
$this->loadTypeFinder($typeConfig, $container, $elasticaToModelTransformerId, $typeDef, $indexName, $typeName);
|
|
|
|
}
|
2011-12-20 17:48:56 +01:00
|
|
|
if (isset($typeConfig['listener'])) {
|
2011-06-07 20:13:34 +02:00
|
|
|
$this->loadTypeListener($typeConfig, $container, $objectPersisterId, $typeDef, $indexName, $typeName);
|
|
|
|
}
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
protected function loadElasticaToModelTransformer(array $typeConfig, ContainerBuilder $container, $indexName, $typeName)
|
|
|
|
{
|
|
|
|
if (isset($typeConfig['elastica_to_model_transformer']['service'])) {
|
|
|
|
return $typeConfig['elastica_to_model_transformer']['service'];
|
|
|
|
}
|
2013-03-27 18:44:06 +01:00
|
|
|
$abstractId = sprintf('fos_elastica.elastica_to_model_transformer.prototype.%s', $typeConfig['driver']);
|
|
|
|
$serviceId = sprintf('fos_elastica.elastica_to_model_transformer.%s.%s', $indexName, $typeName);
|
2011-04-27 09:59:04 +02:00
|
|
|
$serviceDef = new DefinitionDecorator($abstractId);
|
2013-03-27 18:44:06 +01:00
|
|
|
$serviceDef->addTag('fos_elastica.elastica_to_model_transformer', array('type' => $typeName, 'index' => $indexName));
|
2011-12-20 17:44:39 +01:00
|
|
|
|
|
|
|
// Doctrine has a mandatory service as first argument
|
2011-12-20 17:48:56 +01:00
|
|
|
$argPos = ('propel' === $typeConfig['driver']) ? 0 : 1;
|
2011-12-20 17:44:39 +01:00
|
|
|
|
|
|
|
$serviceDef->replaceArgument($argPos, $typeConfig['model']);
|
|
|
|
$serviceDef->replaceArgument($argPos + 1, array(
|
|
|
|
'identifier' => $typeConfig['identifier'],
|
|
|
|
'hydrate' => $typeConfig['elastica_to_model_transformer']['hydrate']
|
2011-04-27 09:59:04 +02:00
|
|
|
));
|
|
|
|
$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'];
|
|
|
|
}
|
2013-03-27 18:44:06 +01:00
|
|
|
$abstractId = sprintf('fos_elastica.model_to_elastica_transformer.prototype.auto');
|
|
|
|
$serviceId = sprintf('fos_elastica.model_to_elastica_transformer.%s.%s', $indexName, $typeName);
|
2011-04-27 09:59:04 +02:00
|
|
|
$serviceDef = new DefinitionDecorator($abstractId);
|
|
|
|
$serviceDef->replaceArgument(0, array(
|
|
|
|
'identifier' => $typeConfig['identifier']
|
|
|
|
));
|
|
|
|
$container->setDefinition($serviceId, $serviceDef);
|
|
|
|
|
|
|
|
return $serviceId;
|
|
|
|
}
|
|
|
|
|
2011-06-07 20:13:34 +02:00
|
|
|
protected function loadObjectPersister(array $typeConfig, Definition $typeDef, ContainerBuilder $container, $indexName, $typeName, $transformerId)
|
|
|
|
{
|
2013-03-27 18:44:06 +01:00
|
|
|
$abstractId = sprintf('fos_elastica.object_persister.prototype');
|
|
|
|
$serviceId = sprintf('fos_elastica.object_persister.%s.%s', $indexName, $typeName);
|
2011-06-07 20:13:34 +02:00
|
|
|
$serviceDef = new DefinitionDecorator($abstractId);
|
|
|
|
$serviceDef->replaceArgument(0, $typeDef);
|
|
|
|
$serviceDef->replaceArgument(1, new Reference($transformerId));
|
|
|
|
$serviceDef->replaceArgument(2, $typeConfig['model']);
|
2011-09-12 18:28:59 +02:00
|
|
|
$serviceDef->replaceArgument(3, $this->typeFields[sprintf('%s/%s', $indexName, $typeName)]);
|
2011-06-07 20:13:34 +02:00
|
|
|
$container->setDefinition($serviceId, $serviceDef);
|
|
|
|
|
|
|
|
return $serviceId;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected function loadTypeProvider(array $typeConfig, ContainerBuilder $container, $objectPersisterId, $typeDef, $indexName, $typeName)
|
2011-04-27 09:59:04 +02:00
|
|
|
{
|
|
|
|
if (isset($typeConfig['provider']['service'])) {
|
|
|
|
return $typeConfig['provider']['service'];
|
|
|
|
}
|
2012-03-10 00:51:08 +01:00
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
$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));
|
2012-03-10 00:51:08 +01:00
|
|
|
$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)));
|
2011-04-27 09:59:04 +02:00
|
|
|
$container->setDefinition($providerId, $providerDef);
|
|
|
|
|
|
|
|
return $providerId;
|
|
|
|
}
|
|
|
|
|
2011-06-07 20:13:34 +02:00
|
|
|
protected function loadTypeListener(array $typeConfig, ContainerBuilder $container, $objectPersisterId, $typeDef, $indexName, $typeName)
|
|
|
|
{
|
|
|
|
if (isset($typeConfig['listener']['service'])) {
|
|
|
|
return $typeConfig['listener']['service'];
|
|
|
|
}
|
2013-03-27 18:44:06 +01:00
|
|
|
$abstractListenerId = sprintf('fos_elastica.listener.prototype.%s', $typeConfig['driver']);
|
|
|
|
$listenerId = sprintf('fos_elastica.listener.%s.%s', $indexName, $typeName);
|
2011-06-07 20:13:34 +02:00
|
|
|
$listenerDef = new DefinitionDecorator($abstractListenerId);
|
|
|
|
$listenerDef->replaceArgument(0, new Reference($objectPersisterId));
|
|
|
|
$listenerDef->replaceArgument(1, $typeConfig['model']);
|
2012-01-25 20:51:10 +01:00
|
|
|
$listenerDef->replaceArgument(3, $typeConfig['identifier']);
|
2012-01-26 10:59:58 +01:00
|
|
|
$listenerDef->replaceArgument(2, $this->getDoctrineEvents($typeConfig));
|
2011-06-07 20:13:34 +02:00
|
|
|
switch ($typeConfig['driver']) {
|
|
|
|
case 'orm': $listenerDef->addTag('doctrine.event_subscriber'); break;
|
2012-10-01 17:20:52 +02:00
|
|
|
case 'mongodb': $listenerDef->addTag('doctrine_mongodb.odm.event_subscriber'); break;
|
2011-06-07 20:13:34 +02:00
|
|
|
}
|
2012-04-10 23:23:09 +02:00
|
|
|
if (isset($typeConfig['listener']['is_indexable_callback'])) {
|
2012-04-19 18:18:30 +02:00
|
|
|
$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));
|
2012-04-10 23:23:09 +02:00
|
|
|
}
|
2011-06-07 20:13:34 +02:00
|
|
|
$container->setDefinition($listenerId, $listenerDef);
|
|
|
|
|
|
|
|
return $listenerId;
|
|
|
|
}
|
|
|
|
|
2012-01-25 20:51:10 +01:00
|
|
|
private function getDoctrineEvents(array $typeConfig)
|
|
|
|
{
|
|
|
|
$events = array();
|
|
|
|
$eventMapping = array(
|
|
|
|
'insert' => array('postPersist'),
|
|
|
|
'update' => array('postUpdate'),
|
|
|
|
'delete' => array('postRemove', 'preRemove')
|
|
|
|
);
|
2012-01-26 10:59:58 +01:00
|
|
|
|
2012-01-25 20:51:10 +01:00
|
|
|
foreach ($eventMapping as $event => $doctrineEvents) {
|
|
|
|
if (isset($typeConfig['listener'][$event]) && $typeConfig['listener'][$event]) {
|
|
|
|
$events = array_merge($events, $doctrineEvents);
|
|
|
|
}
|
|
|
|
}
|
2012-01-26 10:59:58 +01:00
|
|
|
|
2012-01-25 20:51:10 +01:00
|
|
|
return $events;
|
|
|
|
}
|
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
protected function loadTypeFinder(array $typeConfig, ContainerBuilder $container, $elasticaToModelId, $typeDef, $indexName, $typeName)
|
|
|
|
{
|
|
|
|
if (isset($typeConfig['finder']['service'])) {
|
2012-11-22 11:30:13 +01:00
|
|
|
$finderId = $typeConfig['finder']['service'];
|
2013-01-30 22:24:19 +01:00
|
|
|
} else {
|
2013-03-27 18:44:06 +01:00
|
|
|
$abstractFinderId = 'fos_elastica.finder.prototype';
|
|
|
|
$finderId = sprintf('fos_elastica.finder.%s.%s', $indexName, $typeName);
|
2012-11-22 11:30:13 +01:00
|
|
|
$finderDef = new DefinitionDecorator($abstractFinderId);
|
|
|
|
$finderDef->replaceArgument(0, $typeDef);
|
|
|
|
$finderDef->replaceArgument(1, new Reference($elasticaToModelId));
|
|
|
|
$container->setDefinition($finderId, $finderDef);
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
2013-02-13 16:15:27 +01:00
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
$managerId = sprintf('fos_elastica.manager.%s', $typeConfig['driver']);
|
2012-01-25 13:10:35 +01:00
|
|
|
$managerDef = $container->getDefinition($managerId);
|
|
|
|
$arguments = array( $typeConfig['model'], new Reference($finderId));
|
|
|
|
if (isset($typeConfig['repository'])) {
|
|
|
|
$arguments[] = $typeConfig['repository'];
|
2011-12-20 17:44:39 +01:00
|
|
|
}
|
2012-01-25 13:10:35 +01:00
|
|
|
$managerDef->addMethodCall('addEntity', $arguments);
|
2011-11-12 22:10:00 +01:00
|
|
|
|
2011-04-27 09:59:04 +02:00
|
|
|
return $finderId;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Loads the index manager
|
|
|
|
*
|
2012-03-02 05:32:04 +01:00
|
|
|
* @param array $indexRefsByName
|
|
|
|
* @param ContainerBuilder $container
|
2011-04-27 09:59:04 +02:00
|
|
|
**/
|
2012-03-02 05:32:04 +01:00
|
|
|
protected function loadIndexManager(array $indexRefsByName, ContainerBuilder $container)
|
2011-04-27 09:59:04 +02:00
|
|
|
{
|
2013-03-27 18:44:06 +01:00
|
|
|
$managerDef = $container->getDefinition('fos_elastica.index_manager');
|
2012-03-02 05:32:04 +01:00
|
|
|
$managerDef->replaceArgument(0, $indexRefsByName);
|
2013-03-27 18:44:06 +01:00
|
|
|
$managerDef->replaceArgument(1, new Reference('fos_elastica.index'));
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-03-02 06:28:38 +01:00
|
|
|
* Loads the resetter
|
2011-09-12 17:33:00 +02:00
|
|
|
*
|
2013-03-02 12:23:44 +01:00
|
|
|
* @param array $indexConfigs
|
|
|
|
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
|
|
|
|
*/
|
2012-03-02 06:28:38 +01:00
|
|
|
protected function loadResetter(array $indexConfigs, ContainerBuilder $container)
|
2011-09-12 17:33:00 +02:00
|
|
|
{
|
2013-03-27 18:44:06 +01:00
|
|
|
$resetterDef = $container->getDefinition('fos_elastica.resetter');
|
2012-03-02 06:28:38 +01:00
|
|
|
$resetterDef->replaceArgument(0, $indexConfigs);
|
2011-09-12 17:33:00 +02:00
|
|
|
}
|
|
|
|
|
2011-12-20 17:44:39 +01:00
|
|
|
protected function loadDriver(ContainerBuilder $container, $driver)
|
2011-04-27 09:59:04 +02:00
|
|
|
{
|
2011-12-20 17:44:39 +01:00
|
|
|
if (in_array($driver, $this->loadedDrivers)) {
|
2011-04-27 09:59:04 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
$loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
|
|
|
|
$loader->load($driver.'.xml');
|
2011-12-20 17:44:39 +01:00
|
|
|
$this->loadedDrivers[] = $driver;
|
2011-04-27 09:59:04 +02:00
|
|
|
}
|
2011-12-23 17:20:22 +01:00
|
|
|
|
|
|
|
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];
|
|
|
|
}
|
|
|
|
|
2013-03-27 18:44:06 +01:00
|
|
|
$container->setAlias('fos_elastica.manager', sprintf('fos_elastica.manager.%s', $defaultManagerService));
|
2011-12-23 17:20:22 +01:00
|
|
|
}
|
2011-12-23 17:20:22 +01:00
|
|
|
|
2011-04-10 23:08:51 +02:00
|
|
|
}
|