/** * @param MappingDriver $driver */ public function __construct(MappingDriver $driver) { $this->setDriver($driver); $this->chain = new MappingDriverChain(); $this->chain->setDefaultDriver($this->getDriver()); $this->boot(); }
/** * * @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator * @return object */ public function createService(ServiceLocatorInterface $serviceLocator) { $manifest = $serviceLocator->get('manifest'); $extension = $serviceLocator->get('extension.odmcore'); $config = new Configuration(); $config->setProxyDir($extension->getProxyDir()); $config->setProxyNamespace('Proxies'); $config->setHydratorDir($extension->getHydratorDir()); $config->setHydratorNamespace('Hydrators'); $config->setDefaultDB($extension->getDefaultDb()); $config->setClassMetadataFactoryName($extension->getClassMetadataFactory()); $config->setMetadataCacheImpl(new ArrayCache()); //create driver chain $chain = new MappingDriverChain(); foreach ($manifest->getModels() as $namespace => $path) { $driver = new AnnotationDriver(new AnnotationReader(), $path); $chain->addDriver($driver, $namespace); } $config->setMetadataDriverImpl($chain); //register filters foreach ($extension->getFilters() as $name => $class) { $config->addFilter($name, $class); } //create event manager $eventManager = new EventManager(); foreach ($manifest->getSubscribers() as $subscriber) { $eventManager->addEventSubscriber($serviceLocator->get($subscriber)); } //register annotations AnnotationRegistry::registerLoader(function ($className) { return class_exists($className); }); $conn = new Connection(null, array(), $config); return ModelManager::create($conn, $config, $eventManager); }
/** * Get entity manager. * * @return EntityManagerInterface */ protected function getEntityManager() { if (null === $this->entityManager) { $params = ['driver' => 'pdo_sqlite', 'memory' => true]; $cache = new ArrayCache(); /** @var AnnotationReader $reader */ $reader = new CachedReader(new AnnotationReader(), $cache); $annotationDriver = new AnnotationDriver($reader, [__DIR__ . '/../../../src/ORM']); $driverChain = new MappingDriverChain(); $driverChain->addDriver($annotationDriver, Commander::ENTITY_NAMESPACE); DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $reader); $config = new Configuration(); $config->setAutoGenerateProxyClasses(true); $config->setProxyDir(sys_get_temp_dir()); $config->setProxyNamespace(Commander::ENTITY_NAMESPACE); $config->setMetadataDriverImpl($driverChain); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setHydrationCacheImpl($cache); $timestampableListener = new TimestampableListener(); $timestampableListener->setAnnotationReader($annotationDriver->getReader()); $eventManager = new EventManager(); $eventManager->addEventSubscriber($timestampableListener); $entityManager = EntityManager::create($params, $config, $eventManager); $schemaTool = new SchemaTool($entityManager); $schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata()); $this->entityManager = $entityManager; } return $this->entityManager; }
/** * @group DDC-706 */ public function testIsTransient() { $driver1 = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver'); $chain = new MappingDriverChain(); $chain->addDriver($driver1, 'Doctrine\\Tests\\Models\\CMS'); $this->assertTrue($chain->isTransient('stdClass'), "stdClass isTransient"); }
/** * @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; }
/** * * @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator * @return object */ public function createService(ServiceLocatorInterface $serviceLocator) { $manifest = $serviceLocator->get('manifest'); $config = new Configuration(); $config->setProxyDir(__DIR__ . '/../../../../Proxies'); $config->setProxyNamespace('Proxies'); $config->setHydratorDir(__DIR__ . '/../../../../Hydrators'); $config->setHydratorNamespace('Hydrators'); $config->setDefaultDB(self::DEFAULT_DB); $config->setMetadataCacheImpl(new ArrayCache()); //create driver chain $chain = new MappingDriverChain(); foreach ($manifest['documents'] as $namespace => $path) { $driver = new AnnotationDriver(new AnnotationReader(), $path); $chain->addDriver($driver, $namespace); } $config->setMetadataDriverImpl($chain); //register filters foreach ($manifest['filters'] as $name => $class) { $config->addFilter($name, $class); } //create event manager $eventManager = new EventManager(); foreach ($manifest['subscribers'] as $subscriber) { $eventManager->addEventSubscriber($serviceLocator->get($subscriber)); } //register annotations AnnotationRegistry::registerLoader(function ($className) { return class_exists($className); }); $conn = new Connection(null, array(), $config); return DocumentManager::create($conn, $config, $eventManager); }
public function register(Application $app) { $app['orm.em.paths'] = $app->share(function () { return array(); }); $app['orm.event_manager'] = $app->share(function () use($app) { return new EventManager(); }); $app['orm.config'] = $app->share(function () use($app) { return Setup::createConfiguration($app['debug']); }); $app['orm.anotation_reader'] = $app->share(function () use($app) { $annotationReader = new AnnotationReader(); $cache = $app['orm.config']->getMetadataCacheImpl(); return new CachedReader($annotationReader, $cache); }); $app['orm.default_anotation_driver'] = $app->share(function () use($app) { AnnotationRegistry::registerFile($app['vendor_dir'] . '/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); return new AnnotationDriver($app['orm.anotation_reader'], $app['orm.em.paths']); }); $app['orm.em'] = $app->share(function () use($app) { $annotationReader = $app['orm.anotation_reader']; $eventManager = $app['orm.event_manager']; $driverChain = new MappingDriverChain(); $driverChain->setDefaultDriver($app['orm.default_anotation_driver']); DoctrineExtensions::registerMappingIntoDriverChainORM($driverChain, $annotationReader); $loggableListener = new LoggableListener(); $loggableListener->setAnnotationReader($annotationReader); $loggableListener->setUsername('admin'); $eventManager->addEventSubscriber($loggableListener); $config = $app['orm.config']; $config->setMetadataDriverImpl($driverChain); return EntityManager::create($app['db.default_options'], $config, $eventManager); }); }
/** * Register the application services. * * @return void */ public function register() { $this->registerSession(); $chain = new DriverChain(); // Bind the annotation driver $chain->addDriver($this->getAnnotationDriver(), 'App'); $this->addCommandsToArtisan(); $this->addHelpersToArtisan(); }
/** * {@inheritdoc} */ public function register(Container $app) { // @todo crear DoctrineOrmManagerRegistryProvider // o poner en boot estos servicios $app->extend('form.extensions', function ($extensions, $app) { $extensions[] = new DoctrineOrmExtension($app['doctrine']); return $extensions; }); $app['doctrine.orm.validator.unique_validator'] = function ($app) { return new UniqueEntityValidator($app['doctrine']); }; if (!isset($app['validator.validator_service_ids'])) { $app['validator.validator_service_ids'] = []; } $app['validator.validator_service_ids'] = array_merge($app['validator.validator_service_ids'], ['doctrine.orm.validator.unique' => 'doctrine.orm.validator.unique_validator']); $app->extend('validator.object_initializers', function (array $objectInitializers, $app) { $objectInitializers[] = new DoctrineInitializer($app['doctrine']); return $objectInitializers; }); $app['doctrine'] = function ($app) { return new ManagerRegistry($app); }; $app['orm.em'] = function ($app) { $em = EntityManager::create($app['db'], $app['orm.config'], $app['db.event_manager']); return $em; }; // Entity manager alias $app['em'] = function ($app) { return $app['orm.em']; }; $app['orm.config'] = function ($app) { $config = new Configuration(); // @todo path! $config->setProxyDir(sprintf('%s/../../../../../../var/cache/doctrine/proxies', __DIR__)); $config->setProxyNamespace('DoctrineProxies'); $config->setAutoGenerateProxyClasses($app['debug']); // The strongly recommended FALSE in production $chain = new MappingDriverChain(); // Pulsar $path = realpath(sprintf('%s/../Entity', __DIR__)); $driver = $config->newDefaultAnnotationDriver((array) $path, false); $chain->addDriver($driver, 'Pulsar\\Entity'); // App $path = realpath(sprintf('%s/../../../../../../src/App', __DIR__)); $driver = $config->newDefaultAnnotationDriver((array) $path, false); $chain->addDriver($driver, 'App\\Entity'); $config->setMetadataCacheImpl($app['orm.cache']); $config->setMetadataDriverImpl($chain); return $config; }; $app['orm.cache'] = function () { return new ArrayCache(); }; }
public function testFromMetadataDriver() { $reader = new AnnotationReader(); $locator = new SymfonyFileLocator(array(), '.yml'); $omDriver = new MappingDriverChain(); $omDriver->addDriver(new ORMAnnotationDriver($reader), 'Prezent\\Tests\\Fixture\\Foo'); $omDriver->addDriver(new ORMYamlDriver($locator), 'Prezent\\Tests\\Fixture\\Bar'); $expected = new DriverChain(array(new AnnotationDriver($reader), new YamlDriver($locator))); $driver = DoctrineAdapter::fromMetadataDriver($omDriver); $this->assertEquals($expected, $driver); }
/** * Creates the entity manager for the application. * * @param Configuration $config * @param string $modelPath * @return AnnotationDriver */ public function factory(Configuration $config, $modelPath) { $annotationDriver = new AnnotationDriver($config->getAnnotationsReader(), array($modelPath, $config->getAttributeDir())); // create a driver chain for metadata reading $driverChain = new MappingDriverChain(); // register annotation driver for our application $driverChain->addDriver($annotationDriver, 'Shopware\\Models\\'); $driverChain->addDriver($annotationDriver, 'Shopware\\CustomModels\\'); $config->setMetadataDriverImpl($driverChain); return $annotationDriver; }
public function testDefaultDriverGetAllClassNames() { $companyDriver = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver'); $defaultDriver = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver'); $chain = new MappingDriverChain(); $companyDriver->expects($this->once())->method('getAllClassNames')->will($this->returnValue(array('Doctrine\\Tests\\Models\\Company\\Foo'))); $defaultDriver->expects($this->once())->method('getAllClassNames')->will($this->returnValue(array('Other\\Class'))); $chain->setDefaultDriver($defaultDriver); $chain->addDriver($companyDriver, 'Doctrine\\Tests\\Models\\Company'); $classNames = $chain->getAllClassNames(); $this->assertEquals(array('Doctrine\\Tests\\Models\\Company\\Foo', 'Other\\Class'), $classNames); }
/** * Get mapping driver. * * @return MappingDriver */ public function getMappingDriver() { if (null === $this->mappingDriver) { /** @var AnnotationReader $reader */ $reader = new CachedReader(new AnnotationReader(), $this->cache); $annotationDriver = new AnnotationDriver($reader, [__DIR__ . '/../ORM']); $driverChain = new MappingDriverChain(); $driverChain->addDriver($annotationDriver, Commander::ENTITY_NAMESPACE); DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $reader); $this->mappingDriver = $driverChain; } return $this->mappingDriver; }
private function loadPhpcrOdm() { $this['psi_content_type.storage.doctrine.phpcr_odm.property_encoder'] = function ($container) { return new PropertyEncoder('psict', 'https://github.com/psiphp/content-type'); }; $this['psi_content_type.storage.doctrine.phpcr_odm.field_mapper'] = function ($container) { return new FieldMapper($container['psi_content_type.storage.doctrine.phpcr_odm.property_encoder'], $container['psi_content_type.field_loader']); }; $this['psi_content_type.storage.doctrine.phpcr_odm.collection_updater'] = function ($container) { return new CollectionIdentifierUpdater($container['psi_content_type.metadata.factory'], $container['psi_content_type.storage.doctrine.phpcr_odm.property_encoder']); }; $this['doctrine_phpcr.document_manager'] = function ($container) { $registerNodeTypes = false; // automatically setup the schema if the db doesn't exist yet. if (!file_exists($container['config']['db_path'])) { if (!file_exists($dir = dirname($container['config']['db_path']))) { mkdir($dir); } $connection = $container['dbal.connection']; $schema = new RepositorySchema(); foreach ($schema->toSql($connection->getDatabasePlatform()) as $sql) { $connection->exec($sql); } $registerNodeTypes = true; } // register the phpcr session $factory = new RepositoryFactoryDoctrineDBAL(); $repository = $factory->getRepository(['jackalope.doctrine_dbal_connection' => $container['dbal.connection']]); $session = $repository->login(new SimpleCredentials(null, null), 'default'); if ($registerNodeTypes) { $typeRegistrator = new NodeTypeRegistrator(); $typeRegistrator->registerNodeTypes($session); $ctTypeRegistrator = new CtNodeTypeRegistrator($container['psi_content_type.storage.doctrine.phpcr_odm.property_encoder']); $ctTypeRegistrator->registerNodeTypes($session); } // annotation driver $annotationDriver = new AnnotationDriver($container['annotation_reader'], [__DIR__ . '/../../vendor/doctrine/phpcr-odm/lib/Doctrine/ODM/PHPCR/Document', __DIR__ . '/Example']); $xmlDriver = new XmlDriver([__DIR__ . '/mappings']); $annotationDriver = new AnnotationDriver($container['annotation_reader'], [__DIR__ . '/../../vendor/doctrine/phpcr-odm/lib/Doctrine/ODM/PHPCR/Document', __DIR__ . '/Example']); $chain = new MappingDriverChain(); $chain->addDriver($annotationDriver, 'Psi\\Bridge\\ContentType\\Doctrine\\PhpcrOdm\\Tests\\Functional\\Example'); $chain->addDriver($xmlDriver, 'Psi\\Component\\ContentType\\Tests\\Functional\\Example\\Model'); $chain->addDriver($annotationDriver, 'Doctrine'); $config = new Configuration(); $config->setMetadataDriverImpl($chain); $manager = DocumentManager::create($session, $config); $manager->getEventManager()->addEventSubscriber(new MetadataSubscriber($container['psi_content_type.metadata.factory'], $container['psi_content_type.field_loader'], $container['psi_content_type.storage.doctrine.phpcr_odm.field_mapper'])); $manager->getEventManager()->addEventSubscriber(new CollectionSubscriber($container['psi_content_type.metadata.factory'], $container['psi_content_type.storage.doctrine.phpcr_odm.property_encoder'])); return $manager; }; }
/** * @return MappingDriver */ protected function getMetadataDriverImpl(Configuration $config) { $rootDir = realpath(__DIR__ . '/../../../..'); if (false === $rootDir || false === is_file($rootDir . '/Gateway.php')) { throw new \RuntimeException('Cannot guess Payum root dir.'); } $driver = new MappingDriverChain(); $xmlDriver = new SimplifiedXmlDriver(array($rootDir . '/Bridge/Doctrine/Resources/mapping' => 'Payum\\Core\\Model')); $driver->addDriver($xmlDriver, 'Payum\\Core\\Model'); $rc = new \ReflectionClass('Payum\\Core\\Tests\\Mocks\\Entity\\TestModel'); $annotationDriver = $config->newDefaultAnnotationDriver(array(dirname($rc->getFileName())), false); $driver->addDriver($annotationDriver, 'Payum\\Core\\Tests\\Mocks\\Entity'); return $driver; }
/** * @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; }
/** * @return MappingDriver */ 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 SimplifiedXmlDriver(array($rootDir . '/src/Payum/Bridge/Doctrine/Resources/mapping' => 'Payum\\Bridge\\Doctrine\\Entity')); $driver->addDriver($xmlDriver, 'Payum\\Bridge\\Doctrine\\Entity'); $rc = new \ReflectionClass('\\Doctrine\\ORM\\Mapping\\Driver\\AnnotationDriver'); AnnotationRegistry::registerFile(dirname($rc->getFileName()) . '/DoctrineAnnotations.php'); $annotationDriver = new AnnotationDriver(new AnnotationReader(), array($rootDir . '/examples/Payum/Examples/Entity')); $driver->addDriver($annotationDriver, 'Payum\\Examples\\Entity'); return $driver; }
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; }); }
/** * {@inheritdoc} */ public function isTransient($className) { if (array_key_exists($className, $this->isTransientCache)) { return $this->isTransientCache[$className]; } $this->isTransientCache[$className] = parent::isTransient($className); return $this->isTransientCache[$className]; }
/** * Hooks only superclass metadata mapping drivers * into given $driverChain of drivers for ODM MongoDB * * @param MappingDriverChain $driverChain * @param Reader|null $reader */ public static function registerAbstractMappingIntoDriverChainMongodbODM(MappingDriverChain $driverChain, Reader $reader = null) { self::registerAnnotations(); if (!$reader) { $reader = new CachedReader(new AnnotationReader(), new ArrayCache()); } $annotationDriver = new DriverMongodbODM\AnnotationDriver($reader, array(__DIR__ . '/Translatable/Document/MappedSuperclass', __DIR__ . '/Loggable/Document/MappedSuperclass')); $driverChain->addDriver($annotationDriver, 'Gedmo'); }
/** * Create a \Doctrine\ORM\Configuration based on the config given. * If no config are given the method will try to get the config from the configuration file. * * @return \Doctrine\ORM\Configuration */ public function configureDoctrine() { $configuredCache = $this->cache->configureCache(); $configuredDriver = $this->mapping->configureDriver($configuredCache); foreach ($this->configuration->get('namespaces') as $namespace) { $this->driverChain->addDriver($configuredDriver->getMetadataDriverImpl(), $namespace); } $configuredDriver->setMetadataDriverImpl($this->driverChain); // Implement maximum caching $configuredDriver->setMetadataCacheImpl($configuredCache); $configuredDriver->setHydrationCacheImpl($configuredCache); $configuredDriver->setQueryCacheImpl($configuredCache); $configuredDriver->setResultCacheImpl($configuredCache); $proxyConfiguration = $this->configuration->get('proxy'); // Set proxies and proxie-prefix $configuredDriver->setProxyNamespace($proxyConfiguration['namespace']); $configuredDriver->setAutoGenerateProxyClasses($proxyConfiguration['generate']); return $configuredDriver; }
private function createDriverChain(Configuration $config) { switch ($this->config['driver']) { case self::DRIVER_ANNOTATION: $driver = $config->newDefaultAnnotationDriver($this->config['paths'], true); break; case self::DRIVER_XML: $driver = new XmlDriver($this->config['paths']); break; case self::DRIVER_YAML: $driver = new YamlDriver($this->config['paths']); break; default: throw new Exception\InvalidDriver('Valid driver types are: annotation, yaml, xml'); } $chain = new MappingDriverChain(); $chain->setDefaultDriver($driver); return $chain; }
public function loadDoctrineConfiguration(Application $app) { $app['db.orm.config'] = $app->share(function () use($app) { $cache = $app['db.orm.cache']; $config = new ORMConfiguration(); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $chain = new MappingDriverChain(); foreach ((array) $app['db.orm.entities'] as $entity) { switch ($entity['type']) { case 'default': case 'annotation': $driver = $config->newDefaultAnnotationDriver((array) $entity['path'], false); $chain->addDriver($driver, $entity['namespace']); break; case 'yml': $driver = new YamlDriver((array) $entity['path']); $driver->setFileExtension('.yml'); $chain->addDriver($driver, $entity['namespace']); break; case 'xml': $driver = new XmlDriver((array) $entity['path'], $entity['namespace']); $driver->setFileExtension('.xml'); $chain->addDriver($driver, $entity['namespace']); break; default: throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $entity['type'])); break; } } $config->setMetadataDriverImpl($chain); $config->setProxyDir($app['db.orm.proxies_dir']); $config->setProxyNamespace($app['db.orm.proxies_namespace']); $config->setAutoGenerateProxyClasses($app['db.orm.auto_generate_proxies']); $config->addCustomHydrationMode('SimpleArrayHydrator', 'App\\Provider\\SimpleArrayHydrator'); // автолоад прокси $proxyDir = $app['db.orm.proxies_dir']; $proxyNamespace = $app['db.orm.proxies_namespace']; Autoloader::register($proxyDir, $proxyNamespace); return $config; }); }
/** * Enable Gedmo Doctrine Extensions * * @param array $namespaces * @param bool $all */ public function bootGedmoExtensions($namespaces = ['App'], $all = true) { if ($all) { DoctrineExtensions::registerMappingIntoDriverChainORM($this->chain, $this->reader); } else { DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($this->chain, $this->reader); } $driver = $this->metadata->getMetadataDriverImpl(); foreach ($namespaces as $namespace) { $this->chain->addDriver($driver, $namespace); } $this->metadata->setMetadataDriverImpl($this->chain); $this->dispatcher->fire('doctrine.driver-chain::booted', [$driver, $this->chain]); }
/** * Creates the driver chain based on the default driver type. The chain can be retrieved * later and added to (for example, in other Tonis packages). * * @param Configuration $ormConfig * @param array|Configuration $config * @return MappingDriverChain */ private static function createDriverChain(Configuration $ormConfig, array $config) { $chain = new MappingDriverChain(); $paths = $config['driver']['paths']; if (empty($paths)) { return $chain; } switch ($config['driver']['type']) { case self::DRIVER_ANNOTATION: $driver = $ormConfig->newDefaultAnnotationDriver($paths, $config['driver']['simple']); break; case self::DRIVER_XML: $driver = new XmlDriver($paths); break; case self::DRIVER_YAML: $driver = new YamlDriver($paths); break; default: throw new Exception\InvalidDriver('Valid driver types are: annotation, yaml, xml'); } $chain->setDefaultDriver($driver); return $chain; }
/** * {@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); }
private function loadConfiguration(ContainerBuilder $container, $config) { $definition = new Definition('Doctrine\\ORM\\Configuration'); $definition->addMethodCall('setProxyDir', array(sys_get_temp_dir())); $definition->addMethodCall('setProxyNamespace', array('Proxy')); $definition->addMethodCall('setAutoGenerateProxyClasses', array(true)); $definition->addMethodCall('setClassMetadataFactoryName', array('Doctrine\\ORM\\Mapping\\ClassMetadataFactory')); $driver = new MappingDriverChain(); $mappings = array(); foreach ($config['mappings'] as $namespace => $classes) { $driver->addDriver(new AnnotationDriver(new AnnotationReader(), $mappings), $namespace); // $driver->addDriver(new XmlDriver($mappings), $namespace); foreach ($classes as $class) { $mappings[] = realpath(sprintf("%s/../../../../../../../%s", __DIR__, $class)); } } $definition->addMethodCall('setMetadataDriverImpl', array($driver)); $definition->addMethodCall('newDefaultAnnotationDriver', array()); $definition->addMethodCall('setDefaultRepositoryClassName', array('Doctrine\\ORM\\EntityRepository')); $definition->addMethodCall('setQuoteStrategy', array(new DefaultQuoteStrategy())); $definition->addMethodCall('setNamingStrategy', array(new DefaultNamingStrategy())); $definition->addMethodCall('setRepositoryFactory', array(new DefaultRepositoryFactory())); $container->setDefinition('doctrine.configuration', $definition); }
/** * @group DDC-1412 */ public function testDefaultDriver() { $companyDriver = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver'); $dafaultDriver = $this->getMock('Doctrine\\Common\\Persistence\\Mapping\\Driver\\MappingDriver'); $entityClassName = 'Doctrine\\Tests\\ORM\\Mapping\\DriverChainEntity'; $managerClassName = 'Doctrine\\Tests\\Models\\Company\\CompanyManager'; $chain = new MappingDriverChain(); $companyDriver->expects($this->never())->method('loadMetadataForClass'); $companyDriver->expects($this->once())->method('isTransient')->with($this->equalTo($managerClassName))->will($this->returnValue(false)); $dafaultDriver->expects($this->never())->method('loadMetadataForClass'); $dafaultDriver->expects($this->once())->method('isTransient')->with($this->equalTo($entityClassName))->will($this->returnValue(true)); $this->assertNull($chain->getDefaultDriver()); $chain->setDefaultDriver($dafaultDriver); $chain->addDriver($companyDriver, 'Doctrine\\Tests\\Models\\Company'); $this->assertSame($dafaultDriver, $chain->getDefaultDriver()); $this->assertTrue($chain->isTransient($entityClassName)); $this->assertFalse($chain->isTransient($managerClassName)); }
protected function createEntityManager() { $driverChain = new MappingDriverChain(); $config = Setup::createConfiguration($this->debugEnabled); $useSimpleAnnotationReader = false; foreach ($this->mappings as $key => $mapping) { $driver = null; if ($mapping['type'] == 'xml') { if (isset($mapping['extension'])) { $driver = new XmlDriver(array($mapping['doctrine']), $mapping['extension']); } else { $driver = new XmlDriver(array($mapping['doctrine'])); } } else { if ($mapping['type'] == 'yaml') { if (isset($mapping['extension'])) { $driver = new YamlDriver(array($mapping['doctrine']), $mapping['extension']); } else { $driver = new YamlDriver(array($mapping['doctrine'])); } } else { if ($mapping['type'] == 'annotation') { $paths = array(); if (isset($mapping['doctrine'])) { $paths[] = $mapping['doctrine']; } $driver = $config->newDefaultAnnotationDriver($paths, $useSimpleAnnotationReader); } } } if ($driver) { $driverChain->addDriver($driver, $mapping['namespace']); } } // default to annotations if (empty($this->mappings)) { $driverChain = $config->newDefaultAnnotationDriver(array(), $useSimpleAnnotationReader); } $config->setMetadataDriverImpl($driverChain); $entityManager = EntityManager::create($this->connection, $config); return $entityManager; }
<?php /** vendor/bin/doctrine looks for a config/cli-config.php file in the project - so that's why this is here **/ /** If the bootstrap (Aurex.php) sees this variable, don't 'run' the HTTP front-controller **/ $cli = true; require_once __DIR__ . '/vendor/autoload.php'; require_once __DIR__ . '/web/index.php'; use Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain, Symfony\Component\Console\Application as CliApplication, Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper, Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper, UseAllFive\Command\LoadDataFixturesDoctrineCommand, Doctrine\Common\Annotations\AnnotationRegistry, Doctrine\ORM\Mapping\Driver\AnnotationDriver, Doctrine\Common\Annotations\AnnotationReader, Symfony\Component\Console\Helper\HelperSet, Doctrine\ORM\Mapping\Driver\DatabaseDriver, Doctrine\ORM\Tools\Console\Command, Doctrine\DBAL\Connection, Doctrine\DBAL\Version; /** @var Connection $db The above bootstrap creates the app object for us */ $db = $aurex['db']; /** @var Doctrine\ORM\EntityManager $em The entity manager */ $em = $aurex['orm.em']; $driver = new DatabaseDriver($db->getSchemaManager()); $driver->setNamespace('Aurex\\Application\\Entity\\'); $annotationsFile = __DIR__ . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'; AnnotationRegistry::registerFile($annotationsFile); $driverChain = new MappingDriverChain(); $driverChain->addDriver(new AnnotationDriver(new AnnotationReader(), [__DIR__ . '/lib/Application/Model/Entity']), 'Aurex\\Application\\Model\\Entity\\'); $em->getConfiguration()->setMetadataDriverImpl($driverChain); /** @var Symfony\Component\Console\Application $cli */ $cli = new CliApplication('Doctrine Command Line Interface', Version::VERSION); $cli->setCatchExceptions(true); $cli->setHelperSet(new HelperSet(['db' => new ConnectionHelper($em->getConnection()), 'em' => new EntityManagerHelper($em)])); $cli->addCommands([new Command\GenerateRepositoriesCommand(), new Command\GenerateEntitiesCommand(), new Command\ConvertMappingCommand(), new Command\ValidateSchemaCommand(), new Command\SchemaTool\CreateCommand(), new Command\SchemaTool\UpdateCommand(), new Command\GenerateProxiesCommand(), new LoadDataFixturesDoctrineCommand()]); $cli->run();