Add a new default annotation driver with a correctly configured annotation reader.
|
public newDefaultAnnotationDriver ( array $paths = [] ) : |
||
| $paths | array | |
| return | ||
/**
* @return DocumentManager
*/
private function connect()
{
$config = new Configuration();
$config->setProxyDir($this->app['cache']['doctrine'] . '/mongodb/proxy');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir($this->app['cache']['doctrine'] . '/mongodb/hydrators');
$config->setHydratorNamespace('Hydrators');
$anno = [];
foreach ($this->config['modules'] as $app) {
$dir = $this->app['BASE_DIR'] . $this->app['Modules'] . $app . '/Document';
if (file_exists($dir)) {
$anno[] = $dir;
}
}
$driverImpl = $config->newDefaultAnnotationDriver($anno);
$config->setMetadataDriverImpl($driverImpl);
$config->setDefaultDB($this->config['database']['name']);
$config->setDefaultCommitOptions(array('safe' => true, 'fsync' => true));
return DocumentManager::create(new Connection($this->config['database']['host']), $config);
}
/**
* Inits MongoDB ODM
*
* @return EntityManager|null
* @throws InvalidArgumentException
*/
private function initODMMongoDB()
{
$options = $this->getOptions();
if (isset($options['odm']['mongoDb'])) {
$odmOptions = $options['odm']['mongoDb'];
$this->assertProxyConfiguration($odmOptions);
$this->assertHydratorConfiguration($odmOptions);
$config = new MongoDBConfiguration();
$config->setMetadataCacheImpl($this->getCache($odmOptions, 'metadataCache'));
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver($this->getAnnotationDirectories($odmOptions)));
$config->setProxyDir(realpath($odmOptions['proxyDir']));
$config->setProxyNamespace($odmOptions['proxyNamespace']);
$config->setAutoGenerateProxyClasses((bool) isset($odmOptions['autoGenerateProxyClasses']) ? $odmOptions['autoGenerateProxyClasses'] : true);
$config->setHydratorDir(realpath($odmOptions['hydratorDir']));
$config->setHydratorNamespace($odmOptions['hydratorNamespace']);
$config->setAutoGenerateHydratorClasses((bool) isset($odmOptions['autoGenerateHydratorClasses']) ? $odmOptions['autoGenerateHydratorClasses'] : true);
if (isset($odmOptions['defaultDb'])) {
$config->setDefaultDB($odmOptions['defaultDb']);
}
return MongoDBDocumentManager::create(null, $config);
}
}
<?php
require "vendor/.composer/autoload.php";
use Doctrine\Common\ClassLoader, Doctrine\ODM\MongoDB\Configuration, Doctrine\Common\Annotations\AnnotationReader, Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver, Doctrine\ODM\MongoDB\DocumentManager, Doctrine\MongoDB\Connection;
$config = new Configuration();
$config->setProxyDir(__DIR__ . '/cache');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(__DIR__ . '/cache');
$config->setHydratorNamespace('Hydrators');
$annotationDriver = $config->newDefaultAnnotationDriver(array(__DIR__ . '/Documents'));
$config->setMetadataDriverImpl($annotationDriver);
AnnotationDriver::registerAnnotationClasses();
$dm = DocumentManager::create(new Connection(), $config);
// Document classes
$classLoader = new ClassLoader('Documents', __DIR__);
$classLoader->register();
// Get data
$captors = json_decode(file_get_contents('http://lights.theodo.fr/'), true);
var_dump($captors);
// Save data
$measurement = new \Documents\Measurement($captors);
$dm->persist($measurement);
$dm->flush();
var_dump($measurement);
// Find one method 1
$measurement = $dm->createQueryBuilder('Documents\\Measurement')->field('datetime')->equals($measurement->datetime)->getQuery()->getSingleResult();
var_dump($measurement);
// Find one method 2
$measurement = $dm->getRepository('Documents\\Measurement')->findOneBy(array('datetime' => $measurement->datetime));
var_dump($measurement);
// Updating an object
private function getTestDocumentManager()
{
$configuration = new ODMConfiguration();
$configuration->setHydratorDir(__DIR__);
$configuration->setHydratorNamespace('TestHydrator');
$configuration->setProxyDir(__DIR__);
$configuration->setProxyNamespace('TestProxy');
$configuration->setMetadataDriverImpl($configuration->newDefaultAnnotationDriver());
$conn = new Connection(null, array(), $configuration);
return DocumentManager::create($conn, $configuration);
}
/**
* (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];
});
}
