Adds a namespace under a certain alias.
| public addDocumentNamespace ( string $alias, string $namespace ) | ||
| $alias | string | |
| $namespace | string | |
private function loadDoctrineMongoDBConfiguration(Application $app)
{
$app['doctrine.odm.mongodb.configuration'] = $app->share(function () use($app) {
$config = new Configuration();
$config->setMetadataCacheImpl($app['doctrine.odm.mongodb.metadata_cache']);
if (isset($app['doctrine.odm.mongodb.connection_options']['database'])) {
$config->setDefaultDB($app['doctrine.odm.mongodb.connection_options']['database']);
}
$chain = new MappingDriverChain();
$usingAnnotations = false;
foreach ((array) $app['doctrine.odm.mongodb.documents'] as $document) {
switch ($document['type']) {
case 'annotation':
$driver = AnnotationDriver::create((array) $document['path']);
$chain->addDriver($driver, $document['namespace']);
$usingAnnotations = true;
break;
case 'yml':
$driver = new YamlDriver((array) $document['path'], '.yml');
$chain->addDriver($driver, $document['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array) $document['path'], '.xml');
$chain->addDriver($driver, $document['namespace']);
break;
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $document['type']));
break;
}
// add namespace alias
if (isset($document['alias'])) {
$config->addDocumentNamespace($document['alias'], $document['namespace']);
}
}
if ($usingAnnotations) {
AnnotationDriver::registerAnnotationClasses();
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['doctrine.odm.mongodb.proxies_dir']);
$config->setProxyNamespace($app['doctrine.odm.mongodb.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['doctrine.odm.mongodb.auto_generate_proxies']);
$config->setHydratorDir($app['doctrine.odm.mongodb.hydrators_dir']);
$config->setHydratorNamespace($app['doctrine.odm.mongodb.hydrators_namespace']);
$config->setAutoGenerateHydratorClasses($app['doctrine.odm.mongodb.auto_generate_hydrators']);
$config->setLoggerCallable($app['doctrine.odm.mongodb.logger_callable']);
return $config;
});
}
/**
* (register hook)
*
* @param \Silex\Application $application
*/
public function register(Application $application)
{
/*
* MongoDB Connection Manager Closure.
*
* @param string $connectionKey
*
* @return \Doctrine\MongoDB\Connection
*/
$application['doctrine_mongodb.connection'] = $application->protect(function ($connectionKey = 'default') use($application) {
if (isset($application['doctrine_mongodb']['connections'][$connectionKey])) {
$connectionOptions = $application['doctrine_mongodb']['connections'][$connectionKey];
if (isset($connectionOptions['server'])) {
$server = $connectionOptions['server'];
} else {
$defaults = array('host', 'database', 'port');
$missing = array_diff_key(array_flip($defaults), $connectionOptions);
if (!empty($missing)) {
throw new \RuntimeException(sprintf('The MongoDB connection options "%s" is missing', join(', ', $missing)));
}
$server = sprintf('mongodb://%s:%s/%s', $connectionOptions['host'], $connectionOptions['port'], $connectionOptions['database']);
}
$options = isset($connectionOptions['options']) ? $connectionOptions['options'] : array();
return new Connection($server, $options, $application['doctrine_mongodb.configuration']($connectionKey));
}
throw new \InvalidArgumentException(sprintf('Unable to find the MongoDB "%s" connection options', $connectionKey));
});
/*
* MongoDB Configuration Manager Closure.
*
* @param string $configurationKey The configuration key
*
* @return Configuration
*/
$application['doctrine_mongodb.configuration'] = $application->protect(function ($configurationKey = 'default') use($application) {
$configuration = new Configuration();
$options = array('db_name' => 'default', 'proxies_dir' => sys_get_temp_dir(), 'proxies_namespace' => 'DoctrineMongoDBProxy', 'auto_generate_proxies' => true, 'hydrators_dir' => sys_get_temp_dir(), 'hydrators_namespace' => 'DoctrineMongoDBHydrator', 'metadata_cache' => '\\Doctrine\\Common\\Cache\\ArrayCache', 'auto_generate_hydrators' => true, 'logger_callable' => null);
$doctrineMongoDB = $application['doctrine_mongodb'];
foreach ($options as $key => $value) {
if (isset($doctrineMongoDB[$key])) {
$options[$key] = $doctrineMongoDB[$key];
}
}
if (isset($doctrineMongoDB['document_managers'][$configurationKey]['mapping'])) {
$mappingChain = $doctrineMongoDB['document_managers'][$configurationKey]['mapping'];
$driverChain = new MappingDriverChain();
foreach ($mappingChain as $name => $mapping) {
$namespace = isset($mapping['alias']) ? $mapping['alias'] : $name;
$configuration->addDocumentNamespace($namespace, $mapping['namespace']);
$mappingPath = (array) $mapping['path'];
$mappingNamespace = $mapping['namespace'];
$isAnnotation = false;
switch (strtolower($mapping['type'])) {
case 'annotation':
$driver = $configuration->newDefaultAnnotationDriver($mappingPath);
$isAnnotation = true;
break;
case 'xml':
$driver = new XmlDriver($mappingPath);
break;
case 'yml':
$driver = new YamlDriver($mappingPath);
break;
default:
throw new \RuntimeException(sprintf('MongoDB Mapping Type "%s" is not supported or unknown', $mapping['type']));
}
$driverChain->addDriver($driver, $mappingNamespace);
if (true === $isAnnotation) {
AnnotationDriver::registerAnnotationClasses();
}
$configuration->setMetadataDriverImpl($driverChain);
}
}
$configuration->setProxyDir($options['proxies_dir']);
$configuration->setProxyNamespace($options['proxies_namespace']);
$configuration->setAutoGenerateProxyClasses($options['auto_generate_proxies']);
$configuration->setHydratorDir($options['hydrators_dir']);
$configuration->setHydratorNamespace($options['hydrators_namespace']);
$configuration->setAutoGenerateHydratorClasses($options['auto_generate_hydrators']);
$metaDataCacheClass = $options['metadata_cache'];
if (!class_exists($metaDataCacheClass, true)) {
throw new \RuntimeException(sprintf('Unable to find the Doctrine Metadata Cache "%s"', $metaDataCacheClass));
}
$configuration->setMetadataCacheImpl(new $metaDataCacheClass());
$configuration->setDefaultDB($options['db_name']);
return $configuration;
});
/*
* The MongoDB Document Manager Closure.
*
* @param string $managerKey
*
* @return \Doctrine\Common\Persistence\ObjectManager
*/
$application['doctrine_mongodb.document_manager'] = $application->protect(function ($managerKey) use($application) {
$key = strtolower($managerKey);
$serviceKey = sprintf('doctrine_mongodb.%s_document_manager', $key);
if (!$application->offsetExists($serviceKey)) {
$application[$serviceKey] = DocumentManager::create($application['doctrine_mongodb.connection']($key), $application['doctrine_mongodb.configuration']($key));
}
return $application[$serviceKey];
});
}
