/**
* @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']);
});
}
/**
* 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());
}
});
}
/**
* 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();
}
/**
* 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);
}
/**
*
* @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;
}
/**
* @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);
}
/**
* 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 static function create(Connection $conn = null, Configuration $config = null, EventManager $eventManager = null)
{
if (is_null($config)) {
$config = new \Doctrine\ODM\MongoDB\Configuration();
$config->setProxyDir(__DIR__ . '/../Proxies');
$config->setProxyNamespace('Doctrine\\Tests\\Proxies');
$config->setHydratorDir(__DIR__ . '/../Hydrators');
$config->setHydratorNamespace('Doctrine\\Tests\\Hydrators');
$config->setMetadataDriverImpl(\Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver::create());
}
if (is_null($eventManager)) {
$eventManager = new \Doctrine\Common\EventManager();
}
return new DocumentManagerMock($conn, $config, $eventManager);
}
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;
});
}
public function testHasGetMetadata_NamespaceSeperatorIsNotNormalized()
{
require_once __DIR__ . "/Documents/GlobalNamespaceDocument.php";
$driver = AnnotationDriver::create(__DIR__ . '/Documents');
$dm = $this->getMockDocumentManager($driver);
$cmf = new ClassMetadataFactory();
$cmf->setConfiguration($dm->getConfiguration());
$cmf->setDocumentManager($dm);
$m1 = $cmf->getMetadataFor("DoctrineGlobal_Article");
$h1 = $cmf->hasMetadataFor("DoctrineGlobal_Article");
$h2 = $cmf->hasMetadataFor("\\DoctrineGlobal_Article");
$m2 = $cmf->getMetadataFor("\\DoctrineGlobal_Article");
$this->assertNotSame($m1, $m2);
$this->assertFalse($h2);
$this->assertTrue($h1);
}
/**
* @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']);
}
/**
* 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');
}
/**
* @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;
<?php
use Doctrine\Common\ClassLoader;
use Doctrine\MongoDB\Connection;
use Doctrine\ODM\MongoDB\Configuration;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver;
$file = __DIR__ . '/../../vendor/autoload.php';
if (!file_exists($file)) {
throw new RuntimeException('Install dependencies to run the sandbox.');
}
require_once $file;
AnnotationDriver::registerAnnotationClasses();
$classLoader = new ClassLoader('Documents', __DIR__);
$classLoader->register();
$config = new Configuration();
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(__DIR__ . '/Hydrators');
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB('doctrine_odm_sandbox');
// $config->setLoggerCallable(function(array $log) { print_r($log); });
// $config->setMetadataCacheImpl(new Doctrine\Common\Cache\ApcCache());
$config->setMetadataDriverImpl(AnnotationDriver::create(__DIR__ . '/Documents'));
$dm = DocumentManager::create(new Connection(), $config);
