/** * @return EntityManager */ protected function getEntityManager() { if (null !== $this->em) { return $this->em; } $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $config->setQueryCacheImpl(new ArrayCache()); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setAutoGenerateProxyClasses(ProxyFactory::AUTOGENERATE_EVAL); $config->setProxyNamespace('SimpleThings\\EntityAudit\\Tests\\Proxies'); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(array(realpath(__DIR__ . '/Fixtures/Core'), realpath(__DIR__ . '/Fixtures/Issue'), realpath(__DIR__ . '/Fixtures/Relation')), false)); Gedmo\DoctrineExtensions::registerAnnotations(); $connection = $this->_getConnection(); // get rid of more global state $evm = $connection->getEventManager(); foreach ($evm->getListeners() as $event => $listeners) { foreach ($listeners as $listener) { $evm->removeEventListener(array($event), $listener); } } $this->em = EntityManager::create($connection, $config); if (isset($this->customTypes) and is_array($this->customTypes)) { foreach ($this->customTypes as $customTypeName => $customTypeClass) { if (!Type::hasType($customTypeName)) { Type::addType($customTypeName, $customTypeClass); } $this->em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('db_' . $customTypeName, $customTypeName); } } return $this->em; }
/** * * @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; }
/** * @param ContainerInterface $container * * @return EntityManagerInterface * @throws ORMException */ public function __invoke(ContainerInterface $container) { $config = $container->has('config') ? $container->get('config') : []; $proxyDir = isset($config['doctrine']['orm']['proxy_dir']) ? $config['doctrine']['orm']['proxy_dir'] : 'data/cache/EntityProxy'; $proxyNamespace = isset($config['doctrine']['orm']['proxy_namespace']) ? $config['doctrine']['orm']['proxy_namespace'] : 'EntityProxy'; $autoGenerateProxyClasses = isset($config['doctrine']['orm']['auto_generate_proxy_classes']) ? $config['doctrine']['orm']['auto_generate_proxy_classes'] : false; $underscoreNamingStrategy = isset($config['doctrine']['orm']['underscore_naming_strategy']) ? $config['doctrine']['orm']['underscore_naming_strategy'] : false; $entityPaths = isset($config['doctrine']['orm']['entity_paths']) ? $config['doctrine']['orm']['entity_paths'] : ['src']; // Doctrine ORM $doctrine = new Configuration(); $doctrine->setProxyDir($proxyDir); $doctrine->setProxyNamespace($proxyNamespace); $doctrine->setAutoGenerateProxyClasses($autoGenerateProxyClasses); if ($underscoreNamingStrategy) { $doctrine->setNamingStrategy(new UnderscoreNamingStrategy()); } // Cache $cache = $container->get(Cache::class); $doctrine->setQueryCacheImpl($cache); $doctrine->setResultCacheImpl($cache); $doctrine->setMetadataCacheImpl($cache); // ORM mapping by Annotation AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); if (class_exists(DoctrineExtensions::class)) { DoctrineExtensions::registerAnnotations(); } $cachedAnnotationReader = new CachedReader(new AnnotationReader(), $cache); $driver = new AnnotationDriver($cachedAnnotationReader, $entityPaths); $doctrine->setMetadataDriverImpl($driver); $eventManager = new EventManager(); if (isset($config['doctrine']['orm']['event_subscribers'])) { foreach ($config['doctrine']['orm']['event_subscribers'] as $subscriber) { $subscriberInstance = $container->get($subscriber); if ($subscriberInstance instanceof MappedEventSubscriber) { $subscriberInstance->setAnnotationReader($cachedAnnotationReader); } $eventManager->addEventSubscriber($subscriberInstance); } } $entityManager = EntityManager::create($config['doctrine']['connection']['orm_default'], $doctrine, $eventManager); // Types Type::addType('uuid', UuidType::class); $entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('uuid', 'uuid'); if (isset($config['doctrine']['orm']['types'])) { foreach ($config['doctrine']['orm']['types'] as $type => $class) { Type::addType($type, $class); } } return $entityManager; }
private function setupOrms() { $app = $this; // Override "orm.cache.configurer" service provided for benefiting // of "phraseanet.cache-service" $app['orm.cache.configurer'] = $app->protect(function ($name, Configuration $config, $options) use($app) { /** @var Manager $service */ $service = $app['phraseanet.cache-service']; $config->setMetadataCacheImpl($service->factory('ORM_metadata', $app['orm.cache.driver'], $app['orm.cache.options'])); $config->setQueryCacheImpl($service->factory('ORM_query', $app['orm.cache.driver'], $app['orm.cache.options'])); $config->setResultCacheImpl($service->factory('ORM_result', $app['orm.cache.driver'], $app['orm.cache.options'])); $config->setHydrationCacheImpl($service->factory('ORM_hydration', $app['orm.cache.driver'], $app['orm.cache.options'])); }); $app['orm.proxies_dir'] = $app['root.path'] . '/resources/proxies'; $app['orm.auto_generate_proxies'] = $app['debug']; $app['orm.proxies_namespace'] = 'Alchemy\\Phrasea\\Model\\Proxies'; $this['orm.ems'] = $this->share($this->extend('orm.ems', function (\Pimple $ems, $app) { GedmoExtension::registerAnnotations(); foreach ($ems->keys() as $key) { $app['orm.annotation.register']($key); $connection = $ems[$key]->getConnection(); $app['connection.pool.manager']->add($connection); $types = $app['orm.ems.options'][$key]['types']; $app['dbal.type.register']($connection, $types); } return $ems; })); }
/** * @inheritdoc */ public function start() { parent::start(); $connectionConfig = $this->config('connection'); if (!empty($connectionConfig) && is_array($connectionConfig)) { // Setup Doctrine. Largely borrowed from // https://github.com/l3pp4rd/DoctrineExtensions/blob/master/doc/annotations.md#em-setup // Register Doctrine default annotations. AnnotationRegistry::registerFile($this->getEngine()->getSiteInfo()->getSiteRoot() . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); // Setup annotation metadata cache if ($this->getEngine()->getEnvironmentInfo()->isDevMode() || !$this->getEngine()->config('memcache.enabled')) { $cache = new ArrayCache(); } else { $cache = new MemcacheCache(); $cache->setMemcache($this->getEngine()->getMemcache()); } // Setup annotation metadata reader and driver /** @var AnnotationReader $cachedAnnotationReader (for all intents and purposes...) */ $cachedAnnotationReader = new CachedReader(new AnnotationReader(), $cache); $this->driverChain = new MappingDriverChain(); $this->annotationDriver = new AnnotationDriver($cachedAnnotationReader, array($this->getEngine()->getApplicationInfo()->getSitegearRoot())); // Setup Gedmo extension annotations \Gedmo\DoctrineExtensions::registerAnnotations(); $this->driverChain->addDriver($this->annotationDriver, 'Gedmo'); // Setup Sitegear extension annotations // TODO Make model-providing modules declare their own namespaces $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\Customer\\Model'); $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\News\\Model'); $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\Locations\\Model'); $this->driverChain->addDriver($this->annotationDriver, 'Sitegear\\Module\\Products\\Model'); // Create the entity manager configuration, with proxy generation, cached metadata and lowercase-underscore // database naming convention. $entityManagerConfig = new Configuration(); // TODO Make this a temp directory set in the engine config $entityManagerConfig->setProxyDir(sys_get_temp_dir()); // TODO Configurable namespace and naming strategy $entityManagerConfig->setProxyNamespace('Proxy'); $entityManagerConfig->setAutoGenerateProxyClasses($this->getEngine()->getEnvironmentInfo()->isDevMode()); $entityManagerConfig->setMetadataDriverImpl($this->driverChain); $entityManagerConfig->setMetadataCacheImpl($cache); $entityManagerConfig->setQueryCacheImpl($cache); $entityManagerConfig->setNamingStrategy(new UnderscoreNamingStrategy(CASE_LOWER)); // Setup event subscribers. $eventManager = new EventManager(); foreach ($this->config('orm.subscribers') as $subscriberConfig) { /** @var \Doctrine\Common\EventSubscriber $subscriber */ $subscriber = TypeUtilities::buildTypeCheckedObject($subscriberConfig['class'], 'event subscriber', null, array('\\Doctrine\\Common\\EventSubscriber'), isset($subscriberConfig['arguments']) ? $subscriberConfig['arguments'] : array()); if ($subscriber instanceof MappedEventSubscriber) { /** @var MappedEventSubscriber $subscriber */ $subscriber->setAnnotationReader($cachedAnnotationReader); } $eventManager->addEventSubscriber($subscriber); } // Create the entity manager using the configured connection parameters. $this->entityManager = EntityManager::create($this->config('connection'), $entityManagerConfig, $eventManager); // Register the JSON custom data type. This has to be done last, when the entity manager has a connection. foreach ($this->config('dbal.types') as $key => $className) { Type::addType($key, $className); $this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping(preg_replace('/^.*\\\\(.*?)$/', '$1', $className), $key); } } else { throw new \DomainException('<h1>Incorrect or Missing Configuration</h1><p>You have attempted to use the Doctrine module in your site, but you have not provided all the required connection parameters in your configuration file.</p><p>Please rectify this by providing connection parameters ("driver", "dbname", plus normally "username" and "password") or disabling the Doctrine module.</p>'); } }
use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader; use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory; use Symfony\Component\Serializer\Normalizer\PropertyNormalizer; use Dflydev\Silex\Provider\DoctrineOrm\DoctrineOrmServiceProvider; $app = new Application(); $app['profiling.start'] = microtime(true); $app->register(new MonologServiceProvider(), ['monolog.logfile' => __DIR__ . '/../var/logs/prod.log', 'monolog.level' => Logger::ERROR]); $app->register(new ServiceControllerServiceProvider()); $app->register(new SerializerServiceProvider()); $app['serializer.normalizers'] = $app->share(function () { return [new PropertyNormalizer(new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader())))]; }); $app->register(new DoctrineServiceProvider(), ['db.options' => ['driver' => 'pdo_mysql', 'host' => 'localhost', 'dbname' => 'gis', 'user' => 'root', 'password' => 'test', 'charset' => 'utf8mb4']]); $app->register(new DoctrineOrmServiceProvider(), ['orm.proxies_dir' => __DIR__ . '/Gis/Proxy', 'orm.default_cache' => 'apc', 'orm.em.options' => ['mappings' => [['type' => 'annotation', 'namespace' => 'Gis\\Entity', 'path' => __DIR__ . '/Gis/Entity', 'use_simple_annotation_reader' => false]]], 'orm.custom.functions.numeric' => ['DISTANCE' => 'Gis\\Doctrine\\Query\\Mysql\\Distance']]); $app->register(new UrlGeneratorServiceProvider()); $app->get('/', function () use($app) { return $app->redirect('/api/v1'); }); $apiProvider = new ApiProvider(); $app->register($apiProvider); $app->mount('/api/v1', $apiProvider); $app->error(function (\Exception $e, $code) use($app) { $app['monolog']->addError($e->getMessage()); $app['monolog']->addError($e->getTraceAsString()); return new Response($app['serializer']->serialize(ResponseMeta::error($e->getMessage()), $app['request']->getRequestFormat('json')), Response::HTTP_INTERNAL_SERVER_ERROR); }); AnnotationRegistry::registerFile(__DIR__ . '/../vendor/symfony/serializer/Annotation/Groups.php'); DoctrineExtensions::registerAnnotations(); $treeListener = new TreeListener(); $app['db.event_manager']->addEventSubscriber($treeListener); return $app;