/** * Connect to MongoDb * @return DocumentManager */ public function _initDb() { $container = $this; $this['documentManager'] = $this->share(function () use($container) { $dbConfigs = $container['configs']['database']; try { if (empty($dbConfigs['user'])) { $connection_url = "mongodb://{$dbConfigs['host']}:{$dbConfigs['port']}/{$dbConfigs['name']}"; } else { $connection_url = "mongodb://{$dbConfigs['user']}:{$dbConfigs['passwd']}@{$dbConfigs['host']}:{$dbConfigs['port']}/{$dbConfigs['name']}"; } AnnotationDriver::registerAnnotationClasses(); $config = new Configuration(); $config->setProxyDir(BIN_PATH . '/src/Blueridge/Documents/Proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(BIN_PATH . '/src/Blueridge/Documents/Hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl(AnnotationDriver::create(BIN_PATH . '/src/Blueridge/Documents')); $config->setDefaultDB($dbConfigs['name']); return DocumentManager::create(new Connection($connection_url), $config); } catch (Exception $e) { error_log($e->getMessage()); } }); }
/** * @throws \RuntimeException * * @return MappingDriverChain */ protected function getMetadataDriverImpl() { $rootDir = realpath(__DIR__.'/../../../..'); if (false === $rootDir || false === is_file($rootDir.'/Payment.php')) { throw new \RuntimeException('Cannot guess Payum root dir.'); } $driver = new MappingDriverChain(); $xmlDriver = new XmlDriver( new SymfonyFileLocator( array($rootDir.'/Bridge/Doctrine/Resources/mapping' => 'Payum\Core\Model'), '.mongodb.xml' ), '.mongodb.xml' ); $driver->addDriver($xmlDriver, 'Payum\Core\Model'); AnnotationDriver::registerAnnotationClasses(); $rc = new \ReflectionClass('Payum\Core\Tests\Mocks\Document\TestModel'); $annotationDriver = new AnnotationDriver(new AnnotationReader(), array( dirname($rc->getFileName()), )); $driver->addDriver($annotationDriver, 'Payum\Core\Tests\Mocks\Document'); return $driver; }
protected function getDocumentManager() { if (is_null($this->_documentManager)) { $options = $this->getOptions(); // ODM Class $classLoader = new ClassLoader('Doctrine\\ODM\\MongoDB', APPLICATION_PATH . '/../library'); $classLoader->register(); // Common Class $classLoader = new ClassLoader('Doctrine\\Common', APPLICATION_PATH . '/../library'); $classLoader->register(); // MongoDB Class $classLoader = new ClassLoader('Doctrine\\MongoDB', APPLICATION_PATH . '/../library'); $classLoader->register(); $classLoader = new ClassLoader('Documents', $options['documentPath']); $classLoader->register(); $config = new Configuration(); $config->setProxyDir($options['proxyDir']); $config->setProxyNamespace($options['proxyNamespace']); $config->setHydratorDir($options['hydratorDir']); $config->setHydratorNamespace($options['hydratorNamespace']); $reader = new AnnotationReader(); AnnotationDriver::registerAnnotationClasses(); $config->setMetadataDriverImpl(new AnnotationDriver($reader, $options['documentPath'])); $config->setDefaultDB($options['dbname']); $this->_documentManager = DocumentManager::create(new Connection($options['server']), $config); } return $this->_documentManager; }
/** * Register the service provider. * * @return void */ public function register() { $this->app->bind('odm.documentmanager', function ($app) { $conn = Config::get('laravel-odm::connection'); return DocumentManager::create(new Connection($conn['server'], $conn['options']), App::make('odm.config')); }); $this->app->bind('odm.config', function ($app) { $conn = Config::get('laravel-odm::connection'); $dir = Config::get('laravel-odm::dir'); $config = new Configuration(); $config->setProxyDir($dir['proxy']); $config->setProxyNamespace('Proxies'); $config->setHydratorDir($dir['hydrator']); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl(App::make('odm.annotation')); $config->setDefaultDB($conn['options']['db']); return $config; }); $this->app->bind('odm.annotation', function ($app) { $dir = Config::get('laravel-odm::dir'); AnnotationDriver::registerAnnotationClasses(); $reader = new AnnotationReader(); return new AnnotationDriver($reader, $dir['document']); }); }
/** * Load all doctrine ODM configuration: */ protected function configureDoctrineODM() { // Constants define('DOCTRINE_MONGODB_DATABASE', 'hydrator-tests'); define('DOCTRINE_MONGODB_SERVER', 'mongodb://localhost:27017'); // Load annotated classes \Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver::registerAnnotationClasses(); }
/** * @return DocumentManager */ protected function createDocumentManager($server) { AnnotationDriver::registerAnnotationClasses(); $configuration = new Configuration(); $configuration->setProxyDir(sys_get_temp_dir()); $configuration->setProxyNamespace('Proxies'); $configuration->setHydratorDir(sys_get_temp_dir()); $configuration->setHydratorNamespace('Hydrators'); $configuration->setMetadataDriverImpl(AnnotationDriver::create()); return DocumentManager::create(new Connection($server), $configuration); }
/** * * @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; }
/** * Set up annotation metadata. * * @param array $options */ protected static function setupAnnotationMetadata(array $options) { AnnotationDriver::registerAnnotationClasses(); foreach ($options['annotation_files'] as $file) { AnnotationRegistry::registerFile($file); } AnnotationRegistry::registerAutoloadNamespaces($options['annotation_namespaces']); foreach ($options['annotation_autoloaders'] as $autoloader) { AnnotationRegistry::registerLoader($autoloader); } }
/** * @return \FS\SolrBundle\Solr */ public function getSolrInstance() { \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists'); \Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver::registerAnnotationClasses(); $this->solrClient = $this->setupSolrClient(); $factory = $this->setupCommandFactory(); $metaFactory = $this->setupMetaInformationFactory(); $entityMapper = $this->setupEntityMapper(); $solr = new \FS\SolrBundle\Solr($this->solrClient, $factory, $this->eventDispatcher, $metaFactory, $entityMapper); return $solr; }
/** * Creates the doctrine document mananger for working on the database * * @return DocumentManager */ protected function createDocumentManager() { AnnotationDriver::registerAnnotationClasses(); $configuration = new Configuration(); $configuration->setProxyDir($this->configuration['doctrine']['proxyDir']); $configuration->setProxyNamespace($this->configuration['doctrine']['proxyNamespace']); $configuration->setHydratorDir($this->configuration['doctrine']['hydratorDir']); $configuration->setHydratorNamespace($this->configuration['doctrine']['hydratorNamespace']); $configuration->setMetadataDriverImpl(AnnotationDriver::create()); return DocumentManager::create(new Connection($this->configuration['doctrine']['connection']['server']), $configuration); }
/** * Get configuration of database * @param String $dataBaseName * @return array */ private function getConn() { AnnotationDriver::registerAnnotationClasses(); $conn = (require self::$dir); $dataBase = (object) $conn['mongodb']; $config = new Configuration(); $config->setProxyDir($dataBase->proxy['dir']); $config->setProxyNamespace($dataBase->proxy['namespace']); $config->setHydratorDir($dataBase->hydrator['dir']); $config->setHydratorNamespace($dataBase->hydrator['namespace']); $config->setMetadataDriverImpl(AnnotationDriver::create($dataBase->entityDir)); }
public function __construct() { AnnotationDriver::registerAnnotationClasses(); $config = new Configuration(); $config->setProxyDir(app_path() . '/storage/cache/Doctrine/Proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(app_path() . '/storage/cache/Doctrine/Hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl(AnnotationDriver::create(app_path() . '/app/Model/Entity')); $config->setDefaultDB(config('database.db_name')); parent::__construct(new Connection(\Config::get('database.host')), $config); }
/** * @param array $params * @return mixed */ public function produce(array $params = array()) { $configuration = new Configuration(); $configuration->setProxyDir($params['proxy_dir']); $configuration->setProxyNamespace($params['proxy_namespace']); $configuration->setHydratorDir($params['hydrator_dir']); $configuration->setHydratorNamespace($params['hydrator_namespace']); $configuration->setDefaultDB($params['default_db']); $configuration->setMetadataDriverImpl(AnnotationDriver::create($params['document_dir'])); AnnotationDriver::registerAnnotationClasses(); return $configuration; }
/** * @throws \RuntimeException * * @return MappingDriverChain */ protected function getMetadataDriverImpl() { $rootDir = realpath(__DIR__ . '/../../../../../../'); if (false === $rootDir || false === is_dir($rootDir . '/src/Payum')) { throw new \RuntimeException('Cannot guess Payum root dir.'); } $driver = new MappingDriverChain(); $xmlDriver = new XmlDriver(new SymfonyFileLocator(array($rootDir . '/src/Payum/Bridge/Doctrine/Resources/mapping' => 'Payum\\Bridge\\Doctrine\\Document'), '.mongodb.xml'), '.mongodb.xml'); $driver->addDriver($xmlDriver, 'Payum\\Bridge\\Doctrine\\Document'); \Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver::registerAnnotationClasses(); $annotationDriver = new AnnotationDriver(new AnnotationReader(), array($rootDir . '/examples/Payum/Examples/Document')); $driver->addDriver($annotationDriver, 'Payum\\Examples\\Document'); return $driver; }
/** * * @param $config */ public function __construct($config) { $server = $config['connection'][$config['default_connection']]; $config = $config['configuration'][$config['default_connection']]; $configuration = new Configuration(); AnnotationDriver::registerAnnotationClasses(); $anotationReader = new AnnotationDriver(new AnnotationReader(), app_path('Documents')); $configuration->setProxyDir($config['proxy_dir']); $configuration->setProxyNamespace('Proxies'); $configuration->setHydratorDir($config['hydrator_dir']); $configuration->setHydratorNamespace('Hydrators'); $configuration->setMetadataDriverImpl($anotationReader); $configuration->setDefaultDB($server['dbname']); $this->dm = DocumentManager::create(new Connection(), $configuration); }
public function register(Application $app) { $app['mongo.dm'] = $app->share(function () { AnnotationDriver::registerAnnotationClasses(); $config = new Configuration(); $config->setDefaultDB('descartemap'); $config->setProxyDir(ROOT . '/var/proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(ROOT . '/var/hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl(AnnotationDriver::create(ROOT . '/var/cache/')); $dm = DocumentManager::create(new Connection(), $config); return $dm; }); }
public function setUp() { $this->app()->bind(EntityManagerInterface::class, function () { $config = new Configuration(); $config->setProxyDir(__DIR__ . '/Entities/Proxies'); $config->setProxyNamespace('Tests\\Proxy'); $config->setHydratorDir(__DIR__ . '/Entities/Hydrators'); $config->setHydratorNamespace('Tests\\Hydrators'); $config->setDefaultDB('test-base-api-php'); $config->setMetadataDriverImpl(AnnotationDriver::create(__DIR__ . '/Entities/Stubs')); $connection = new Connection(); AnnotationDriver::registerAnnotationClasses(); return EntityManager::create($connection, $config); }); }
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; }); }
/** * setup mongo-odm and load fixtures * * @return void */ public function setUp() { AnnotationDriver::registerAnnotationClasses(); $config = new Configuration(); $config->setHydratorDir('/tmp/hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setProxyDir('/tmp/proxies'); $config->setProxyNamespace('Proxies'); $config->setMetadataDriverImpl(AnnotationDriver::create(__DIR__ . '/Documents/')); $dm = DocumentManager::create(new Connection(), $config); $loader = new Loader(); $loader->addFixture(new MongoOdmFixtures()); $executor = new MongoDBExecutor($dm, new MongoDBPurger()); $executor->execute($loader->getFixtures()); $this->builder = $dm->createQueryBuilder('Graviton\\Rql\\Documents\\Foo'); }
/** * @param array $options */ public function __construct(array $options = []) { AnnotationDriver::registerAnnotationClasses(); $options = array_merge(['mongodb_url' => 'mongodb://localhost/crowi', 'password_seed' => 'this is default session secret', 'temporary_dir' => sys_get_temp_dir() . '/crowi', 'doctrine_configration' => null], $options); if (!$options['doctrine_configration'] instanceof Configuration) { $config = new Configuration(); $config->setDefaultDB(trim(parse_url($options['mongodb_url'], PHP_URL_PATH), '/')); $config->setProxyDir($options['temporary_dir'] . '/Proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir($options['temporary_dir'] . '/Hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl(AnnotationDriver::create(__DIR__ . '/Document')); $options['doctrine_configration'] = $config; } $this->dm = DocumentManager::create(new Connection($options['mongodb_url']), $options['doctrine_configration']); }
/** * @return DocumentManager */ function getDM() { static $dm; if (!isset($dm)) { $connection = new Connection(); $config = new Configuration(); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(__DIR__ . '/Hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setDefaultDB('tw-react'); $config->setMetadataDriverImpl(AnnotationDriver::create(__DIR__ . '/Documents')); AnnotationDriver::registerAnnotationClasses(); $dm = DocumentManager::create($connection, $config); } return $dm; }
private function getDocumentManager() { if (!class_exists('Doctrine\\ODM\\MongoDB\\DocumentManager')) { $this->markTestSkipped('Missing doctrine/mongodb-odm'); } $root = dirname(dirname(dirname(dirname(dirname(__DIR__))))); $config = new Configuration(); $config->setProxyDir($root . '/generate/proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir($root . '/generate/hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl(AnnotationDriver::create(dirname(__DIR__) . '/TestDocument')); AnnotationDriver::registerAnnotationClasses(); $dm = DocumentManager::create(null, $config); if (!$dm->getConnection()->connect()) { $this->markTestSkipped('Unable to connect to MongoDB'); } return $dm; }
function DocumentManager() { if (!file_exists($file = __DIR__ . '/vendor/autoload.php')) { throw new RuntimeException('Install dependencies to run this script.'); } $loader = (require_once $file); $loader->add('Documents', __DIR__); $connection = new Connection(); $config = new Configuration(); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(__DIR__ . '/Hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setDefaultDB('todos'); $config->setMetadataDriverImpl(AnnotationDriver::create(__DIR__ . '/Documents')); AnnotationDriver::registerAnnotationClasses(); $dm = DocumentManager::create($connection, $config); return $dm; }
private function __construct($mongoConfig) { $this->logger = \Logkit\Logger::ins('mongo'); AnnotationDriver::registerAnnotationClasses(); //获取ODM配置 $ODMConfig = \Yaf\Application::app()->getConfig()->ODM; if (!$ODMConfig) { throw new Exception('The ODM config not found.'); } //连接mongodb $dsn = 'mongodb://' . $mongoConfig->host . ':' . $mongoConfig->port; $options = $mongoConfig->options->toArray(); $connection = new Connection($dsn, $options); //配置ODM $config = new Configuration(); $config->setProxyDir($ODMConfig->proxiesDir); $config->setProxyNamespace('Proxies'); $config->setHydratorDir($ODMConfig->hydratorsDir); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl(AnnotationDriver::create($ODMConfig->documentsDir)); $this->ducumentManager = DocumentManager::create($connection, $config); }
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; }
/** * {@inheritDoc} */ public function createStorage($modelClass, $idProperty, array $options) { if (false == Type::hasType('object')) { Type::addType('object', 'Payum\\Core\\Bridge\\Doctrine\\Types\\ObjectType'); } $driver = new MappingDriverChain(); // payum's basic models $coreRootDir = dirname((new \ReflectionClass(GatewayInterface::class))->getFileName()); $driver->addDriver(new XmlDriver(new SymfonyFileLocator(array($coreRootDir . '/Bridge/Doctrine/Resources/mapping' => 'Payum\\Core\\Model'), '.mongodb.xml'), '.mongodb.xml'), 'Payum\\Core\\Model'); // your models $sererRootDir = dirname((new \ReflectionClass(Application::class))->getFileName()); AnnotationDriver::registerAnnotationClasses(); $driver->addDriver(new AnnotationDriver(new AnnotationReader(), array($sererRootDir . '/Model')), 'Payum\\Server\\Model'); $config = new Configuration(); $config->setProxyDir(\sys_get_temp_dir() . '/PayumServer'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(\sys_get_temp_dir() . '/PayumServer'); $config->setHydratorNamespace('Hydrators'); $config->setMetadataDriverImpl($driver); $config->setMetadataCacheImpl(new ArrayCache()); $config->setDefaultDB($options['databaseName']); $connection = new Connection($options['host'], array(), $config); return new DoctrineStorage(DocumentManager::create($connection, $config), $modelClass); }
<?php use Doctrine\Common\Annotations\AnnotationRegistry; use Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver; use Composer\Autoload\ClassLoader; /** * @var ClassLoader $loader */ $loader = (require __DIR__ . '/../vendor/autoload.php'); AnnotationRegistry::registerLoader(array($loader, 'loadClass')); AnnotationDriver::registerAnnotationClasses(); return $loader;
/** * Returns a new metadata reader driver to be used for configuring each of the document classes * found in the applications * * @param array $paths array containing a list of full path names where Document classes can be located * @return Driver */ protected function _getMetadataReader($paths) { $reader = new AnnotationReader(); $driver = new AnnotationDriver($reader, $paths); AnnotationDriver::registerAnnotationClasses(); AnnotationRegistry::registerFile(CakePlugin::path('MongoCake') . 'Lib' . DS . 'MongoCake' . DS . 'Annotation' . DS . 'Annotations.php'); return $driver; }
/** * Tenta estabelecer a conexão ao banco relacional ou de documentos. * * @return \Doctrine\ORM\EntityManager | \Doctrine\ODM\MongoDB\DocumentManager */ private function estabelecerConexao() { $tipo = explode(':', $this->_configuracao->get($this->_servidor . '.persistencia_uri')); $tipo = $tipo[0]; if (!empty($tipo)) { if ($tipo === 'mongodb') { \Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver::registerAnnotationClasses(); } $classLoader = new ClassLoader('Domain\\Entity', implode(DIRECTORY_SEPARATOR, [__APPDIR__, 'app', 'models'])); $classLoader->register(); $doctrine_models_dir = implode(DIRECTORY_SEPARATOR, [__APPDIR__, 'app', 'models']); $doctrine_entities_dir = implode(DIRECTORY_SEPARATOR, [__APPDIR__, 'app', 'models', 'Domain', 'Entity']); $doctrine_proxies_dir = implode(DIRECTORY_SEPARATOR, [__APPDIR__, 'tmp', 'models', 'Domain', 'Entity', 'Proxies']); $doctrine_hydrators_dir = implode(DIRECTORY_SEPARATOR, [__APPDIR__, 'tmp', 'models', 'Domain', 'Entity', 'Hydrators']); // cria os diretórios dos proxys e hydrators, caso não haja (necessários // para o Doctrine) if (!PROJECT_STAGE) { Arquivo::criarDiretorio($doctrine_proxies_dir); Arquivo::criarDiretorio($doctrine_hydrators_dir); } // verifica se não é MongoDB if ($tipo !== 'mongodb') { // provê algumas informações iniciais do banco de dados switch ($tipo) { case 'sqlite': $parametrosConexao = ['driver' => 'pdo_' . $tipo, 'path' => $this->_configuracao->get($this->_servidor . '.persistencia_banco')]; break; case 'mysql': $parametrosConexao = ['driver' => 'pdo_' . $tipo, 'user' => $this->_configuracao->get($this->_servidor . '.persistencia_usuario'), 'password' => $this->_configuracao->get($this->_servidor . '.persistencia_senha'), 'host' => $this->_configuracao->get($this->_servidor . '.persistencia_servidor'), 'dbname' => $this->_configuracao->get($this->_servidor . '.persistencia_banco'), \PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'' . $this->_configuracao->get($this->_servidor . '.persistencia_charset') . '\'; SET CHARACTER SET \'' . $this->_configuracao->get($this->_servidor . '.persistencia_charset') . '\'; SET character_set_connection=\'' . $this->_configuracao->get($this->_servidor . '.persistencia_charset') . '\'; SET character_set_client=\'' . $this->_configuracao->get($this->_servidor . '.persistencia_charset') . '\'; SET character_set_results=\'' . $this->_configuracao->get($this->_servidor . '.persistencia_charset') . '\';']; break; // em teste funciona para quase todos os tipos de PDO // em teste funciona para quase todos os tipos de PDO default: $parametrosConexao = ['driver' => 'pdo_' . $tipo, 'user' => $this->_configuracao->get($this->_servidor . '.persistencia_usuario'), 'password' => $this->_configuracao->get($this->_servidor . '.persistencia_senha'), 'host' => $this->_configuracao->get($this->_servidor . '.persistencia_servidor'), 'dbname' => $this->_configuracao->get($this->_servidor . '.persistencia_banco')]; break; } // cria os mapeamentos das entidades do banco de dados, caso não existam if (count(glob($doctrine_entities_dir . '/*.php')) === 0) { $configuracao = new \Doctrine\ORM\Configuration(); $configuracao->setMetadataDriverImpl($configuracao->newDefaultAnnotationDriver($doctrine_entities_dir, FALSE)); $configuracao->setProxyDir($doctrine_proxies_dir); $configuracao->setProxyNamespace('Proxies'); $entityManager = \Doctrine\ORM\EntityManager::create($parametrosConexao, $configuracao); // custom datatypes (not mapped for reverse engineering) $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string'); $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); // define namespace $driver = new \Doctrine\ORM\Mapping\Driver\DatabaseDriver($entityManager->getConnection()->getSchemaManager()); $driver->setNamespace('Domain\\Entity\\'); // define driver with namespace $entityManager->getConfiguration()->setMetadataDriverImpl($driver); $disconnectedClassMetadataFactory = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory(); $disconnectedClassMetadataFactory->setEntityManager($entityManager); $entityGenerator = new \Doctrine\ORM\Tools\EntityGenerator(); $entityGenerator->setUpdateEntityIfExists(true); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setGenerateAnnotations(true); $entityGenerator->generate($disconnectedClassMetadataFactory->getAllMetadata(), $doctrine_models_dir); } // carrega as entidades \Pudim\Arquivo::requererDiretorio($doctrine_entities_dir); $configuracao = \Doctrine\ORM\Tools\Setup::createConfiguration(!(bool) PROJECT_STAGE); $driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new \Doctrine\Common\Annotations\AnnotationReader(), $doctrine_entities_dir); // registering noop annotation autoloader - allow all annotations by default \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists'); $configuracao->setMetadataDriverImpl($driver); $configuracao->setAutoGenerateProxyClasses(!(bool) PROJECT_STAGE); $configuracao->setProxyDir($doctrine_proxies_dir); $configuracao->setProxyNamespace('Proxies'); if (PROJECT_STAGE) { $cache = new \Doctrine\Common\Cache\ArrayCache(); } else { $cache = new \Doctrine\Common\Cache\ApcCache(); } $configuracao->setMetadataCacheImpl($cache); $configuracao->setQueryCacheImpl($cache); // obtaining the entity manager (7) $eventManager = new \Doctrine\Common\EventManager(); $conexao = \Doctrine\ORM\EntityManager::create($parametrosConexao, $configuracao, $eventManager); } else { $configuracao = new \Doctrine\ODM\MongoDB\Configuration(); $metadata = AnnotationDriver::create($doctrine_entities_dir); $configuracao->setMetadataDriverImpl($metadata); $configuracao->setAutoGenerateProxyClasses(!(bool) PROJECT_STAGE); $configuracao->setProxyDir($doctrine_proxies_dir); $configuracao->setProxyNamespace('Proxies'); $configuracao->setAutoGenerateHydratorClasses(!(bool) PROJECT_STAGE); $configuracao->setHydratorDir($doctrine_hydrators_dir); $configuracao->setHydratorNamespace('Hydrators'); $configuracao->setDefaultDB($this->_configuracao->get($this->_servidor . '.persistencia_banco')); //$configuracao->setLoggerCallable(function (array $log) { print_r($log); }); $cache_uri = $this->_configuracao->get($this->_servidor . '.cache_uri'); if (PROJECT_STAGE && class_exists('Redis') && $cache_uri) { // trata o $cache_uri pois somente precisamos do servidor e a porta if (strpos($cache_uri, '//')) { $cache_uri_parts = explode('//', $cache_uri); if (strpos($cache_uri_parts[1], ':')) { list($cache_server, $cache_port) = explode(':', $cache_uri_parts[1]); } else { $cache_server = $cache_uri_parts[1]; $cache_port = '6379'; } unset($cache_uri_parts); } else { $cache_server = $cache_uri; $cache_port = '6379'; } $redis = new \Redis(); $redis->pconnect($cache_server, $cache_port); $metadataCache = new \Doctrine\Common\Cache\RedisCache(); $metadataCache->setRedis($redis); $configuracao->setMetadataCacheImpl($metadataCache); unset($cache_server, $cache_port, $redis, $metadataCache); } $conexao = new \Doctrine\MongoDB\Connection($this->_configuracao->get($this->_servidor . '.persistencia_uri')); $conexao = \Doctrine\ODM\MongoDB\DocumentManager::create($conexao, $configuracao); // FIX: Muito importante pois força a criação dos índices no aplicativo $conexao->getSchemaManager()->ensureIndexes(); } } return $conexao; }
<?php if (!file_exists($file = __DIR__ . '/../vendor/autoload.php')) { throw new RuntimeException('Install dependencies to run test suite.'); } $loader = (require $file); $loader->add('Doctrine\\ODM\\MongoDB\\Tests', __DIR__ . '/../tests'); $loader->add('Documents', __DIR__); $loader->add('Stubs', __DIR__); \Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver::registerAnnotationClasses();