/**
* Datasource constructor, creates the Configuration, Connection and DocumentManager objects
*
* ### You can pass the following configuration options
*
* - server: name of the server that will be used to connect to Mongo (default: `localhost`)
* - database: name of the database to use when connecting to Mongo (default: `cake`)
* - documentPaths: array containing a list of full path names where Document classes can be located (default: `App::path('Model')`)
* - proxyDir: full path to the directory that will contain the generated proxy classes for each document (default: `TMP . 'cache'`)
* - proxyNamespace: string representing the namespace the proxy classes will reside in (default: `Proxies`)
* - hydratorDir: directory well the hydrator classes will be generated in (default: `TMP . 'cache'`)
* - hydratorNamespace: string representing the namespace the hydrator classes will reside in (default: `Hydrators`)
*
* @param arary $config
* @param boolean $autoConnect whether this object should attempt connection on creation
* @throws MissingConnectionException if it was not possible to connect to MongoDB
*/
public function __construct($config = array(), $autoConnect = true)
{
$modelPaths = $this->_cleanupPaths(App::path('Model'));
$this->_baseConfig = array('proxyDir' => TMP . 'cache', 'proxyNamespace' => 'Proxies', 'hydratorDir' => TMP . 'cache', 'hydratorNamespace' => 'Hydrators', 'server' => 'localhost', 'database' => 'cake', 'documentPaths' => $modelPaths, 'prefix' => null);
foreach (CakePlugin::loaded() as $plugin) {
$this->_baseConfig['documentPaths'] = array_merge($this->_baseConfig['documentPaths'], $this->_cleanupPaths(App::path('Model', $plugin)));
}
parent::__construct($config);
extract($this->config, EXTR_OVERWRITE);
$configuration = new Configuration();
$configuration->setProxyDir($proxyDir);
$configuration->setProxyNamespace($proxyNamespace);
$configuration->setHydratorDir($hydratorDir);
$configuration->setHydratorNamespace($hydratorNamespace);
$configuration->setDefaultDB($database);
$configuration->setMetadataDriverImpl($this->_getMetadataReader($documentPaths));
if (Configure::read('debug') === 0) {
$configuration->setAutoGenerateHydratorClasses(false);
$configuration->setAutoGenerateProxyClasses(false);
$configuration->setMetadataCacheImpl(new ApcCache());
}
$this->configuration = $configuration;
$this->connection = new Connection($server, array(), $configuration);
$this->documentManager = DocumentManager::create($this->connection, $configuration);
$this->documentManager->getEventManager()->addEventListener(array(Events::prePersist, Events::preUpdate, Events::preRemove, Events::postPersist, Events::postUpdate, Events::postRemove), $this);
try {
if ($autoConnect) {
$this->connect();
}
} catch (Exception $e) {
throw new MissingConnectionException(array('class' => get_class($this)));
}
$this->setupLogger();
}
/**
*
* @param array $config
* @return DocumentManager
*/
public static function createDocumentManager($config, Container $container)
{
$configuration = new Configuration();
if (is_null($config['eventManager'])) {
$evm = new EventManager();
} else {
$evm = $config['eventManager'];
}
$configuration->setProxyDir($config['proxyDir']);
$configuration->setProxyNamespace($config['proxyNamespace']);
$configuration->setHydratorDir($config['hydratorDir']);
$configuration->setHydratorNamespace($config['hydratorNamespace']);
$configuration->setAutoGenerateHydratorClasses($config['autoGenerateHydratorClasses']);
$configuration->setAutoGenerateProxyClasses($config['autoGenerateProxyClasses']);
if (isset($config['metaDataCache'])) {
$metadataCache = $config['metaDataCache'];
} else {
$metadataCache = new $config['metaDataCacheClass']();
$metadataCache->setNamespace($config['cachePrefix']);
}
$configuration->setMetadataCacheImpl($metadataCache);
AnnotationDriver::registerAnnotationClasses();
$reader = new AnnotationReader();
if ($config['cacheAnnotations'] == TRUE) {
$reader = new CachedReader($reader, $metadataCache, $config['debug']);
}
if ($config['indexAnnotations'] == TRUE) {
$reader = new IndexedReader($reader);
}
if (class_exists(\Gedmo\DoctrineExtensions::class)) {
\Gedmo\DoctrineExtensions::registerAnnotations();
$configuration->addFilter('soft-deleteable', \Gedmo\SoftDeleteable\Filter\ODM\SoftDeleteableFilter::class);
foreach ($config['listeners'] as $listenerName => $enabled) {
if ($enabled) {
$listener = self::configureListener($listenerName, $reader);
$evm->addEventSubscriber($listener);
}
}
}
$driverImpl = new AnnotationDriver($reader, $config['documentsDir']);
$configuration->setMetadataDriverImpl($driverImpl);
$configuration->setDefaultDB($config['dbname']);
$logger = new Logger($config['logger'], $config['loggerPrefix']);
$configuration->setLoggerCallable([$logger, 'logQuery']);
$mongo = new MongoClient($config['uri'], $config['mongoOptions']);
$connection = new Connection($mongo);
$dm = DocumentManager::create($connection, $configuration, $evm);
foreach ($config['filters'] as $filter => $enabled) {
if ($enabled) {
$dm->getFilterCollection()->enable($filter);
}
}
return $dm;
}
private function initDm()
{
$config = new Configuration();
$conn = new Connection($this->_config->getConfigData('mongo_server'));
if (true === $this->_config->getConfigData('development_environment')) {
$cache = new ArrayCache();
$config->setAutoGenerateHydratorClasses(true);
$config->setAutoGenerateProxyClasses(true);
} else {
$cache = new ApcCache(array('prefix' => $this->_app->getConfig()->getConfigData('app_name')));
$config->setAutoGenerateHydratorClasses(false);
$config->setAutoGenerateProxyClasses(false);
}
$config->setMetadataCacheImpl($cache);
$config->setProxyDir(ROOT . DS . 'app' . DS . 'proxies');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(ROOT . DS . 'app' . DS . 'hydrators');
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB($this->_config->getConfigData('mongo_dbName'));
$config->setMetadataDriverImpl(AnnotationDriver::create(ROOT . DS . 'app' . DS . 'models'));
AnnotationDriver::registerAnnotationClasses();
$this->_dm = DocumentManager::create($conn, $config);
ServiceContainer::set()['dm'] = $this->_dm;
}
/**
* @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator
* @return \Doctrine\ODM\MongoDB\Configuration
* @throws \Exception
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
/** @var $options \DoctrineMongoODMModule\Options\Configuration */
$options = $this->getOptions($serviceLocator, 'configuration');
$config = new Configuration();
// logger
if ($options->getLogger()) {
$logger = $serviceLocator->get($options->getLogger());
$config->setLoggerCallable(array($logger, 'log'));
}
// proxies
$config->setAutoGenerateProxyClasses($options->getGenerateProxies());
$config->setProxyDir($options->getProxyDir());
$config->setProxyNamespace($options->getProxyNamespace());
// hydrators
$config->setAutoGenerateHydratorClasses($options->getGenerateHydrators());
$config->setHydratorDir($options->getHydratorDir());
$config->setHydratorNamespace($options->getHydratorNamespace());
// default db
$config->setDefaultDB($options->getDefaultDb());
// caching
$config->setMetadataCacheImpl($serviceLocator->get($options->getMetadataCache()));
// retries
$config->setRetryConnect($options->getRetryConnect());
$config->setRetryQuery($options->getRetryQuery());
// Register filters
foreach ($options->getFilters() as $alias => $class) {
$config->addFilter($alias, $class);
}
// the driver
$config->setMetadataDriverImpl($serviceLocator->get($options->getDriver()));
// metadataFactory, if set
if ($factoryName = $options->getClassMetadataFactoryName()) {
$config->setClassMetadataFactoryName($factoryName);
}
// custom types
foreach ($options->getTypes() as $name => $class) {
if (Type::hasType($name)) {
Type::overrideType($name, $class);
} else {
Type::addType($name, $class);
}
}
return $config;
}
public static function createDocumentManager(\Nette\DI\Container $container, $config)
{
$params = $container->parameters;
$configuration = new Configuration();
$configuration->setProxyDir($config['proxyDir']);
$configuration->setProxyNamespace('Proxies');
$configuration->setHydratorDir($config['hydratorDir']);
$configuration->setHydratorNamespace('Hydrators');
$isProductionMode = $params['productionMode'];
$configuration->setAutoGenerateHydratorClasses(!$isProductionMode);
$configuration->setAutoGenerateProxyClasses(!$isProductionMode);
$metadataCache = new $config['metaDataCacheClass']();
$metadataCache->setNamespace($config['cachePrefix']);
$configuration->setMetadataCacheImpl($metadataCache);
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(VENDORS_DIR . '/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/Mapping/Annotations/DoctrineAnnotations.php');
$reader = new AnnotationReader();
$driverImpl = new AnnotationDriver($reader, $config['documentsDir']);
$configuration->setMetadataDriverImpl($driverImpl);
$configuration->setDefaultDB($config['dbname']);
$mongo = new \Mongo($config['uri'], array('connect' => true));
$connection = new Connection($mongo);
$dm = \Doctrine\ODM\MongoDB\DocumentManager::create($connection, $configuration);
return $dm;
}
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;
});
}
/**
* 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);
}
}
/**
* (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];
});
}
/**
* {@inheritdoc}
*/
public function register(Application $app)
{
// if true debug queries , regenerate proxies and hydrators.
$app['odm.debug'] = function ($app) {
return $app['debug'];
};
// connection config
$app['odm.connection.configuration'] = $app->share(function ($app) {
$config = new ConnectionConfiguration();
if ($app['odm.debug'] === TRUE && isset($app['logger']) && isset($app['odm.connection.logger'])) {
$config->setLoggerCallable($app['odm.connection.log_function']);
}
return $config;
});
// log function
$app['odm.connection.log_function'] = $app->protect(function ($msg) use($app) {
return $app['odm.connection.logger']->logQuery($msg);
});
//if (class_exists('Doctrine\Bundle\MongoDBBundle\Logger\Logger')) {
//logger
$app['odm.connection.logger'] = $app->share(function ($app) {
return new Logger($app['logger']);
});
//}
// server connection string
$app['odm.connection.server'] = "";
// mongo client connection options
$app['odm.connection.options'] = array('connect' => TRUE);
// mongo client connection
$app['odm.connection'] = $app->share(function ($app) {
$conn = new Connection($app["odm.connection.server"], $app['odm.connection.options'], $app['odm.connection.configuration']);
return $conn;
});
// multiple document managers
$app['odm.manager_registry'] = $app->share(function ($app) {
return new ManagerRegistry("manager_registry", array('default' => $app['odm.connection']), array('default' => $app['odm.dm']), "default", "default");
});
// default document manager
$app['odm.dm'] = $app->share(function ($app) {
foreach ($app['odm.driver.configs'] as $name => $options) {
$driver = DoctrineODMMongoDBServiceProvider::getMetadataDriver($options['type'], $options['path']);
$app['odm.chain_driver']->addDriver($driver, $options['namespace']);
if ($name === "default") {
$app['odm.chain_driver']->setDefaultDriver($driver);
}
}
$app['odm.config']->setMetadataDriverImpl($app['odm.chain_driver']);
$dm = DocumentManager::create($app['odm.connection'], $app['odm.config']);
# fix the proxy serialization bug @TODO fix it
$proxies = glob($app['odm.proxy_dir'] . "/__CG__*.php");
foreach ($proxies as $proxy) {
require $proxy;
}
/* @var DocumentManager $dm */
return $dm;
});
// proxy classes dir
$app['odm.proxy_dir'] = function () {
return sys_get_temp_dir();
};
// proxy classes namespace
$app['odm.proxy_namespace'] = 'Proxies';
// hydrators dir
$app['odm.hydrator_dir'] = function () {
return sys_get_temp_dir();
};
// hydrator namespace
$app['odm.hydrator_namespace'] = 'Hydrators';
// main document manager driver
$app['odm.chain_driver'] = $app->share(function ($app) {
return new MappingDriverChain();
});
// driver configs
$app['odm.driver.configs'] = array();
// main manager config
$app['odm.config'] = $app->share(function ($app) {
$config = new Configuration();
$config->setProxyDir($app['odm.proxy_dir']);
$config->setProxyNamespace($app['odm.proxy_namespace']);
$config->setHydratorDir($app['odm.hydrator_dir']);
$config->setHydratorNamespace($app['odm.hydrator_namespace']);
$config->setAutoGenerateHydratorClasses($app['odm.debug']);
$config->setAutoGenerateProxyClasses($app['odm.debug']);
$config->setDefaultDB($app['odm.connection.dbname']);
return $config;
});
// if you want to manage mongo db through the $app[console] , execute this function
$app['odm.boot_commands'] = $app->protect(function () use($app) {
$app["console"]->getHelperSet()->set(new DocumentManagerHelper($app["odm.dm"]));
$app['console']->add(new InfoDoctrineODMCommand());
$app["console"]->add(new MongoCommand\QueryCommand());
$app["console"]->add(new MongoCommand\GenerateDocumentsCommand());
$app["console"]->add(new MongoCommand\GenerateHydratorsCommand());
$app["console"]->add(new MongoCommand\GenerateProxiesCommand());
$app["console"]->add(new MongoCommand\GenerateRepositoriesCommand());
$app["console"]->add(new MongoCommand\ClearCache\MetadataCommand());
$app["console"]->add(new MongoCommand\Schema\CreateCommand());
$app["console"]->add(new MongoCommand\Schema\DropCommand());
$app["console"]->add(new MongoCommand\Schema\UpdateCommand());
});
// unique document validator service
$app['doctrine_odm.mongodb.unique'] = $app->share(function ($app) {
return new UniqueEntityValidator($app['odm.manager_registry']);
});
}
