/**
* @param ContainerInterface $container
* @return EntityManager
*/
public function __invoke(ContainerInterface $container)
{
$config = $container->has('config') ? $container->get('config') : [];
if (!isset($config['doctrine'])) {
throw new ServiceNotCreatedException('Missing Doctrine configuration');
}
$config = $config['doctrine'];
$proxyDir = isset($config['proxy_dir']) ? $config['proxy_dir'] : 'data/DoctrineORM/Proxy';
$proxyNamespace = isset($config['proxy_namespace']) ? $config['proxy_namespace'] : 'DoctrineORM/Proxy';
$autoGenerateProxyClasses = isset($config['configuration']['auto_generate_proxy_classes']) ? $config['configuration']['auto_generate_proxy_classes'] : false;
$underscoreNamingStrategy = isset($config['configuration']['underscore_naming_strategy']) ? $config['configuration']['underscore_naming_strategy'] : false;
// Doctrine ORM
$doctrine = new Configuration();
$doctrine->setProxyDir($proxyDir);
$doctrine->setProxyNamespace($proxyNamespace);
$doctrine->setAutoGenerateProxyClasses($autoGenerateProxyClasses);
// Naming Strategy
if ($underscoreNamingStrategy) {
$doctrine->setNamingStrategy(new UnderscoreNamingStrategy());
}
// ORM mapping by Annotation
//AnnotationRegistry::registerAutoloadNamespace($config['driver']['annotations']['class']);
AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$driver = new AnnotationDriver(new AnnotationReader(), $config['driver']['annotations']['paths']);
$doctrine->setMetadataDriverImpl($driver);
// Cache
$cache = $container->get(\Doctrine\Common\Cache\Cache::class);
$doctrine->setQueryCacheImpl($cache);
$doctrine->setResultCacheImpl($cache);
$doctrine->setMetadataCacheImpl($cache);
// EntityManager
return EntityManager::create($config['connection']['orm_default']['params'], $doctrine);
}
/**
* Setup doctrine cache
*
* @return void
*/
protected function setDoctrineCache()
{
static::$cacheDriver = static::getCacheDriverByOptions(\XLite::getInstance()->getOptions('cache'));
$this->configuration->setMetadataCacheImpl(static::$cacheDriver);
$this->configuration->setQueryCacheImpl(static::$cacheDriver);
$this->configuration->setResultCacheImpl(static::$cacheDriver);
}
/**
* 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;
}
private function obterConfiguracao($dados)
{
$this->config = new Configuration();
// Definição do driver de mapeamento
$metadata_driver = "Doctrine\\ORM\\Mapping\\Driver\\{$dados['metadata_driver']}";
if ($dados['metadata_driver'] == "AnnotationDriver") {
$driver = $this->config->newDefaultAnnotationDriver(array(MODELO), true);
} else {
$driver = new $metadata_driver(CONFIG . DS . 'orm');
}
if (!empty($dados['map_paths'])) {
$driver->addPaths(preg_split('/, ?/', $dados['map_paths']));
}
$this->config->setMetadataDriverImpl($driver);
// Configurações de proxies
$this->config->setProxyDir(RAIZ . DS . $dados['proxy_dir']);
$this->config->setProxyNamespace($dados['proxy_namespace']);
$this->config->setAutoGenerateProxyClasses($dados['auto_proxies']);
// Definição da estratégia de caches de consultas e metadados
$metadata_cache = "Doctrine\\Common\\Cache\\{$dados['metadata_cache']}";
$query_cache = "Doctrine\\Common\\Cache\\{$dados['query_cache']}";
$result_cache = "Doctrine\\Common\\Cache\\{$dados['query_cache']}";
$this->config->setMetadataCacheImpl(new $metadata_cache());
$this->config->setQueryCacheImpl(new $query_cache());
$this->config->setResultCacheImpl(new $result_cache());
// Ferramenta de log de consultas
if (!empty($dados['sql_logger'])) {
$sql_logger = "Doctrine\\DBAL\\Logging\\{$dados['sql_logger']}";
$logger = new $sql_logger();
$this->config->setSQLLogger($logger);
}
}
public function createService(ServiceLocatorInterface $serviceLocator)
{
/** @var $options \DoctrineORMModule\Options\Configuration */
$options = $this->getOptions($serviceLocator);
$config = new Configuration();
$config->setAutoGenerateProxyClasses($options->getGenerateProxies());
$config->setProxyDir($options->getProxyDir());
$config->setProxyNamespace($options->getProxyNamespace());
$config->setEntityNamespaces($options->getEntityNamespaces());
$config->setCustomDatetimeFunctions($options->getDatetimeFunctions());
$config->setCustomStringFunctions($options->getStringFunctions());
$config->setCustomNumericFunctions($options->getNumericFunctions());
$config->setClassMetadataFactoryName($options->getClassMetadataFactoryName());
foreach ($options->getNamedQueries() as $name => $query) {
$config->addNamedQuery($name, $query);
}
foreach ($options->getNamedNativeQueries() as $name => $query) {
$config->addNamedNativeQuery($name, $query['sql'], new $query['rsm']());
}
foreach ($options->getCustomHydrationModes() as $modeName => $hydrator) {
$config->addCustomHydrationMode($modeName, $hydrator);
}
foreach ($options->getFilters() as $name => $class) {
$config->addFilter($name, $class);
}
$config->setMetadataCacheImpl($serviceLocator->get($options->getMetadataCache()));
$config->setQueryCacheImpl($serviceLocator->get($options->getQueryCache()));
$config->setResultCacheImpl($serviceLocator->get($options->getResultCache()));
$config->setHydrationCacheImpl($serviceLocator->get($options->getHydrationCache()));
$config->setMetadataDriverImpl($serviceLocator->get($options->getDriver()));
if ($namingStrategy = $options->getNamingStrategy()) {
if (is_string($namingStrategy)) {
if (!$serviceLocator->has($namingStrategy)) {
throw new InvalidArgumentException(sprintf('Naming strategy "%s" not found', $namingStrategy));
}
$config->setNamingStrategy($serviceLocator->get($namingStrategy));
} else {
$config->setNamingStrategy($namingStrategy);
}
}
if ($repositoryFactory = $options->getRepositoryFactory()) {
if (is_string($repositoryFactory)) {
if (!$serviceLocator->has($repositoryFactory)) {
throw new InvalidArgumentException(sprintf('Repository factory "%s" not found', $repositoryFactory));
}
$config->setRepositoryFactory($serviceLocator->get($repositoryFactory));
} else {
$config->setRepositoryFactory($repositoryFactory);
}
}
if ($entityListenerResolver = $options->getEntityListenerResolver()) {
if ($entityListenerResolver instanceof EntityListenerResolver) {
$config->setEntityListenerResolver($entityListenerResolver);
} else {
$config->setEntityListenerResolver($serviceLocator->get($entityListenerResolver));
}
}
$this->setupDBALConfiguration($serviceLocator, $config);
return $config;
}
public function _initDoctrineEntityManager()
{
$this->bootstrap(array('classLoaders', 'doctrineCache'));
$zendConfig = $this->getOptions();
// parameters required for connecting to the database.
// the required attributes are driver, host, user, password and dbname
$connectionParameters = $zendConfig['doctrine']['connectionParameters'];
// now initialize the configuration object
$configuration = new DoctrineConfiguration();
// the metadata cache is used to avoid parsing all mapping information every time
// the framework is initialized.
$configuration->setMetadataCacheImpl($this->getResource('doctrineCache'));
// for performance reasons, it is also recommended to use a result cache
$configuration->setResultCacheImpl($this->getResource('doctrineCache'));
// if you set this option to true, Doctrine 2 will generate proxy classes for your entities
// on the fly. This has of course impact on the performance and should therefore be disabled
// in the production environment
$configuration->setAutoGenerateProxyClasses($zendConfig['doctrine']['autoGenerateProxyClasses']);
// the directory, where your proxy classes live
$configuration->setProxyDir($zendConfig['doctrine']['proxyPath']);
// the proxy classes' namespace
$configuration->setProxyNamespace($zendConfig['doctrine']['proxyNamespace']);
// the next option tells doctrine which description language we want to use for the mapping
// information
$driver = new YamlDriver($zendConfig['doctrine']['mappingPath']);
$driver->setFileExtension('.yml');
$configuration->setMetadataDriverImpl($driver);
// next, we create an event manager
$eventManager = new DoctrineEventManager();
// now we have everything required to initialize the entity manager
$entityManager = DoctrineEntityManager::create($connectionParameters, $configuration, $eventManager);
Zend_Registry::set('em', $entityManager);
return $entityManager;
}
/**
* Setup doctrine cache
*
* @return void
*/
protected function setDoctrineCache()
{
static::$cacheDriver = new \XLite\Core\Cache();
$driver = static::$cacheDriver->getDriver();
$this->configuration->setMetadataCacheImpl($driver);
$this->configuration->setQueryCacheImpl($driver);
$this->configuration->setResultCacheImpl($driver);
}
public function setUp()
{
$configuration = new Configuration();
$configuration->setResultCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$configuration->setMetadataDriverImpl(new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new AnnotationReader(), realpath(__DIR__ . '/Models/')));
$connection = \Doctrine\DBAL\DriverManager::getConnection(array('driver' => $GLOBALS['db_type'], 'host' => $GLOBALS['db_host'], 'dbname' => $GLOBALS['db_name'], 'user' => $GLOBALS['db_username'], 'password' => $GLOBALS['db_password']));
$configuration->setMetadataCacheImpl(new \Doctrine\Common\Cache\ZendDataCache());
$this->em = new \Lynx\EntityManager($connection, $configuration);
}
public function create()
{
$debug = $this->options['debug'];
$doctrineConfig = new Configuration();
$doctrineConfig->setMetadataCacheImpl($this->cache);
$doctrineConfig->setMetadataDriverImpl($this->driver);
$doctrineConfig->setQueryCacheImpl($this->cache);
$doctrineConfig->setResultCacheImpl($this->cache);
$doctrineConfig->setProxyDir($this->options['proxy_dir']);
$doctrineConfig->setProxyNamespace($this->options['proxy_namespace']);
$doctrineConfig->setAutoGenerateProxyClasses($debug);
return $doctrineConfig;
}
/**
* @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;
}
/**
* Initializes resource
*
* @return Doctrine\ORM\EntityManager
*/
public function init()
{
$options = $this->getOptions();
$config = new Configuration();
if (APPLICATION_ENV == 'production' && function_exists('apc_fetch')) {
// @codeCoverageIgnoreStart
#extension_loaded() memcache, xcache, redis
$cache = new ApcCache();
} else {
// @codeCoverageIgnoreEnd
$cache = new ArrayCache();
}
#$driverImpl = $config->newDefaultAnnotationDriver($options['modelDirectory']);
// @todo Temporary(?) fix for using new AnnotationReader
$reader = new AnnotationReader();
#$reader->setEnableParsePhpImports(true);
$reader = new IndexedReader($reader);
$reader = new CachedReader($reader, $cache);
$driverImpl = new AnnotationDriver($reader, $options['modelDirectory']);
class_exists('Doctrine\\ORM\\Mapping\\Driver\\DoctrineAnnotations');
// Beware cache slams: http://doctrine-orm.readthedocs.org/en/2.0.x/reference/caching.html#cache-slams
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setProxyDir($options['proxyDirectory']);
$config->setProxyNamespace($options['proxyNamespace']);
$config->setAutoGenerateProxyClasses($options['autoGenerateProxyClasses']);
$config->setMetadataDriverImpl($driverImpl);
// @codeCoverageIgnoreStart
if (null !== $options['logPath']) {
$sqlLogger = new SqlLogger($options['logPath']);
$config->setSQLLogger($sqlLogger);
Zend_Registry::set('sqlLogger', $sqlLogger);
}
// @codeCoverageIgnoreEnd
$entityManager = EntityManager::create($options['connection'], $config);
Service::setEntityManager($entityManager);
// Add BLOB data type mapping
if (!Type::hasType('gzblob')) {
Type::addType('gzblob', 'Rexmac\\Zyndax\\Doctrine\\DBAL\\Type\\GzBlob');
$entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('BLOB', 'gzblob');
}
// Add IP data type mapping
if (!Type::hasType('ip')) {
Type::addType('ip', 'Rexmac\\Zyndax\\Doctrine\\DBAL\\Type\\Ip');
$entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('IP', 'ip');
}
return $entityManager;
}
public function _initDoctrine()
{
$classLoader = new ClassLoader('Doctrine');
$classLoader->register();
$config = new Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setResultCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$driverImpl = $config->newDefaultAnnotationDriver('/home/jsuggs/bbm/BBM');
$config->setMetadataDriverImpl($driverImpl);
$config->setProxyDir(PROXYDIR);
$config->setProxyNamespace('DoctrineProxies');
$connectionOptions = array('driver' => 'pdo_pgsql', 'user' => 'bbm', 'password' => 'bbm', 'host' => 'localhost', 'dbname' => 'bbm');
$em = EntityManager::create($connectionOptions, $config);
return $em;
}
/**
* @return \Doctrine\ORM\Configuration
*/
protected function getDoctrine_ConfigService()
{
$this->services['doctrine.config'] = $instance = new Configuration();
$baseDir = $this->getParameter('app.baseDir');
$cache = $this->get('app.cache');
$instance->setMetadataCacheImpl($cache);
$instance->setQueryCacheImpl($cache);
$instance->setResultCacheImpl($cache);
$instance->setProxyDir($baseDir . $this->getParameter('doctrine.proxy.dir'));
$instance->setProxyNamespace($this->getParameter('doctrine.proxy.namespace'));
$instance->setAutoGenerateProxyClasses($this->getParameter('app.devmode'));
AnnotationRegistry::registerFile($baseDir . 'vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$reader = new SimpleAnnotationReader();
$reader->addNamespace('Doctrine\\ORM\\Mapping');
$instance->setMetadataDriverImpl(new AnnotationDriver(new CachedReader($reader, $cache), array($baseDir . $this->getParameter('doctrine.entity.dir'))));
return $instance;
}
public function __construct()
{
$config = ConfigReader::readConfig('doctrine');
$doctrineConfig = new Configuration();
$cache = new Cache();
$doctrineConfig->setQueryCacheImpl($cache);
$doctrineConfig->setProxyDir($config['proxyDir']);
$doctrineConfig->setProxyNamespace('Proxy');
$doctrineConfig->setAutoGenerateProxyClasses(true);
$doctrineConfig->setResultCacheImpl($cache);
//mapping (example uses annotations, could be any of XML/YAML or plain PHP)
AnnotationRegistry::registerFile(BASE_DIR . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new \Doctrine\Common\Annotations\AnnotationReader(), array($config['entityDir']));
$doctrineConfig->setMetadataDriverImpl($driver);
$doctrineConfig->setMetadataCacheImpl($cache);
$em = EntityManager::create($config, $doctrineConfig);
$this->setEm($em);
}
private function initORM()
{
$config_pff = ServiceContainer::get('config');
if (true === $config_pff->getConfigData('development_environment')) {
$cache = new ArrayCache();
} elseif ($this->redis) {
$redis = new \Redis();
if (!$redis->connect($this->redis_host, $this->redis_port)) {
throw new PffException("Cannot connect to redis", 500);
}
if ($this->redis_password != '') {
if (!$redis->auth($this->redis_password)) {
throw new PffException("Cannot auth to redis", 500);
}
}
$cache = new RedisCache();
$cache->setRedis($redis);
$cache->setNamespace($this->_app->getConfig()->getConfigData('app_name'));
} else {
$cache = new ApcuCache();
$cache->setNamespace($this->_app->getConfig()->getConfigData('app_name'));
}
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$driverImpl = $config->newDefaultAnnotationDriver(ROOT . DS . 'app' . DS . 'models');
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
$config->setProxyDir(ROOT . DS . 'app' . DS . 'proxies');
$config->setProxyNamespace('pff\\proxies');
if (true === $config_pff->getConfigData('development_environment')) {
$config->setAutoGenerateProxyClasses(true);
$connectionOptions = $config_pff->getConfigData('databaseConfigDev');
} else {
$config->setAutoGenerateProxyClasses(false);
$connectionOptions = $config_pff->getConfigData('databaseConfig');
}
$this->db = EntityManager::create($connectionOptions, $config);
ServiceContainer::set()['dm'] = $this->db;
$platform = $this->db->getConnection()->getDatabasePlatform();
$platform->registerDoctrineTypeMapping('enum', 'string');
}
/**
* Inits ORM
*
* @return EntityManager|null
* @throws InvalidArgumentException
*/
private function initORM()
{
$options = $this->getOptions();
if (isset($options['orm'])) {
$ormOptions = $options['orm'];
if (!isset($options['dbal'])) {
throw new InvalidArgumentException('DBAL must be configured to use ORM');
}
$this->assertProxyConfiguration($ormOptions);
$config = new ORMConfiguration();
$config->setMetadataCacheImpl($this->getCache($ormOptions, 'metadataCache'));
$config->setQueryCacheImpl($this->getCache($ormOptions, 'queryCache'));
$config->setResultCacheImpl($this->getCache($ormOptions, 'resultCache'));
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver($this->getAnnotationDirectories($ormOptions)));
$config->setProxyDir(realpath($ormOptions['proxyDir']));
$config->setProxyNamespace($ormOptions['proxyNamespace']);
$config->setAutoGenerateProxyClasses((bool) isset($ormOptions['autoGenerateProxyClasses']) ? $ormOptions['autoGenerateProxyClasses'] : true);
return EntityManager::create($options['dbal'], $config);
}
}
/**
* Factory method which creates an EntityManager.
*
* @return \Doctrine\ORM\EntityManager
*/
public function create()
{
$config = new Configuration();
$config->setClassMetadataFactoryName('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\ClassMetadataFactory');
$cache = new \TYPO3\Flow\Persistence\Doctrine\CacheAdapter();
// must use ObjectManager in compile phase...
$cache->setCache($this->objectManager->get('TYPO3\\Flow\\Cache\\CacheManager')->getCache('Flow_Persistence_Doctrine'));
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$resultCache = new \TYPO3\Flow\Persistence\Doctrine\CacheAdapter();
// must use ObjectManager in compile phase...
$resultCache->setCache($this->objectManager->get('TYPO3\\Flow\\Cache\\CacheManager')->getCache('Flow_Persistence_Doctrine_Results'));
$config->setResultCacheImpl($resultCache);
if (class_exists($this->settings['doctrine']['sqlLogger'])) {
$config->setSQLLogger(new $this->settings['doctrine']['sqlLogger']());
}
$eventManager = $this->buildEventManager();
$flowAnnotationDriver = $this->objectManager->get('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\Driver\\FlowAnnotationDriver');
$config->setMetadataDriverImpl($flowAnnotationDriver);
$proxyDirectory = \TYPO3\Flow\Utility\Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'Doctrine/Proxies'));
\TYPO3\Flow\Utility\Files::createDirectoryRecursively($proxyDirectory);
$config->setProxyDir($proxyDirectory);
$config->setProxyNamespace('TYPO3\\Flow\\Persistence\\Doctrine\\Proxies');
$config->setAutoGenerateProxyClasses(FALSE);
$entityManager = \Doctrine\ORM\EntityManager::create($this->settings['backendOptions'], $config, $eventManager);
$flowAnnotationDriver->setEntityManager($entityManager);
\Doctrine\DBAL\Types\Type::addType('objectarray', 'TYPO3\\Flow\\Persistence\\Doctrine\\DataTypes\\ObjectArray');
if (isset($this->settings['doctrine']['filters']) && is_array($this->settings['doctrine']['filters'])) {
foreach ($this->settings['doctrine']['filters'] as $filterName => $filterClass) {
$config->addFilter($filterName, $filterClass);
$entityManager->getFilters()->enable($filterName);
}
}
if (isset($this->settings['doctrine']['dql']) && is_array($this->settings['doctrine']['dql'])) {
$this->applyDqlSettingsToConfiguration($this->settings['doctrine']['dql'], $config);
}
return $entityManager;
}
public function register(Application $app)
{
$app['doctrine_orm.configuration'] = $app->share(function ($app) {
$configuration = new Configuration();
if (isset($app['doctrine_orm.metadata_cache'])) {
$configuration->setMetadataCacheImpl($app['doctrine_orm.metadata_cache']);
} else {
$configuration->setMetadataCacheImpl(new ArrayCache());
}
$driverImpl = $configuration->newDefaultAnnotationDriver($app['doctrine_orm.entities_path']);
$configuration->setMetadataDriverImpl($driverImpl);
if (isset($app['doctrine_orm.query_cache'])) {
$configuration->setQueryCacheImpl($app['doctrine_orm.query_cache']);
} else {
$configuration->setQueryCacheImpl(new ArrayCache());
}
if (isset($app['doctrine_orm.result_cache'])) {
$configuration->setResultCacheImpl($app['doctrine_orm.result_cache']);
}
$configuration->setProxyDir($app['doctrine_orm.proxies_path']);
$configuration->setProxyNamespace($app['doctrine_orm.proxies_namespace']);
$configuration->setAutogenerateProxyClasses(false);
if (isset($app['doctrine_orm.autogenerate_proxy_classes'])) {
$configuration->setAutogenerateProxyClasses($app['doctrine_orm.autogenerate_proxy_classes']);
} else {
$configuration->setAutogenerateProxyClasses(true);
}
return $configuration;
});
$app['doctrine_orm.connection'] = $app->share(function ($app) {
return DriverManager::getConnection($app['doctrine_orm.connection_parameters'], $app['doctrine_orm.configuration'], new EventManager());
});
$app['doctrine_orm.em'] = $app->share(function ($app) {
return EntityManager::create($app['doctrine_orm.connection'], $app['doctrine_orm.configuration'], $app['doctrine_orm.connection']->getEventManager());
});
}
/**
* @return \Doctrine\ORM\EntityManager
*/
protected static function getEntityManager()
{
if (null === self::$em) {
// 'path' is commented out but can be very helpful
// if used instead of 'memory' for debugging
$connection = array('driver' => 'pdo_sqlite', 'memory' => true);
$cache = new ArrayCache();
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setProxyDir(sys_get_temp_dir());
$config->setProxyNamespace('DoctrineProxies');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl(new AnnotationDriver(new IndexedReader(new AnnotationReader()), __DIR__));
// $config->setSQLLogger(new EchoSQLLogger());
self::$em = EntityManager::create($connection, $config);
$schemaTool = new SchemaTool(self::$em);
$cmf = self::$em->getMetadataFactory();
$classes = $cmf->getAllMetadata();
$schemaTool->createSchema($classes);
}
return static::$em;
}
private static function createNewEntityManager()
{
$config = new Configuration();
$driverImpl = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/Models/Entities');
$config->setMetadataDriverImpl($driverImpl);
// $config->setMetadataCacheImpl(MyCache::getInstance("_doctrine_metadata")->getCacheImplement());
// $config->setQueryCacheImpl(MyCache::getInstance("_doctrine_query_cache")->getCacheImplement());
// $config->setResultCacheImpl(MyCache::getInstance("_doctrine_result_cache")->getCacheImplement());
// $config->setHydrationCacheImpl(MyCache::getInstance("_doctrine_hydration_cache")->getCacheImplement());
$config->setMetadataCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement());
$config->setQueryCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement());
$config->setResultCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement());
$config->setHydrationCacheImpl(MyCache::getInstance("_doctrine_cache")->getCacheImplement());
$config->setProxyDir(APPLICATION_PATH . '/Models/Proxies/__CG__/');
// $config->setProxyDir(APPLICATION_PATH.'/Models/Proxies/__CG__/Models/Entities2');
$config->setAutoGenerateProxyClasses(AbstractProxyFactory::AUTOGENERATE_FILE_NOT_EXISTS);
$config->setProxyNamespace('Models\\Proxies\\');
// \My\Doc
$config->addCustomNumericFunction('RAND', 'My\\Doctrine\\DqlFunction\\Rand');
// $config->setSQLLogger(new MySQLLogger());
$connectionParams = MyDatabaseConfiguration::getConnectionParam();
$conn = DriverManager::getConnection($connectionParams);
return EntityManager::create($conn, $config);
}
<?php
/*
* @description doctrine Doctrine ORM config
* @author CawaKharkov
*/
use Doctrine\ORM\EntityManager, Doctrine\ORM\Configuration, Doctrine\Common\Cache\ArrayCache as Cache, Doctrine\Common\Annotations\AnnotationRegistry;
//configuration
$doctrineConfig = new Configuration();
$cache = new Cache();
$doctrineConfig->setQueryCacheImpl($cache);
$doctrineConfig->setProxyDir(__DIR__ . '/data/Proxy');
$doctrineConfig->setProxyNamespace('Proxy');
$doctrineConfig->setAutoGenerateProxyClasses(true);
$doctrineConfig->setResultCacheImpl($cache);
//mapping (example uses annotations, could be any of XML/YAML or plain PHP)
AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new \Doctrine\Common\Annotations\AnnotationReader(), array(__DIR__ . '/app/Entity'));
$doctrineConfig->setMetadataDriverImpl($driver);
$doctrineConfig->setMetadataCacheImpl($cache);
//getting the EntityManager
$entityManager = EntityManager::create(array('driver' => 'pdo_mysql', 'user' => 'root', 'password' => 'cawa123azs', 'dbname' => 'blog', 'charset' => 'utf8'), $doctrineConfig);
$helpers = new Symfony\Component\Console\Helper\HelperSet(array('db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($entityManager->getConnection()), 'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($entityManager)));
/**
* Creates a configuration without a metadata driver.
*
* @param bool $isDevMode
* @param string $proxyDir
* @param Cache $cache
*
* @return Configuration
*/
public static function createConfiguration($isDevMode = false, $proxyDir = null, Cache $cache = null)
{
$proxyDir = $proxyDir ?: sys_get_temp_dir();
if ($isDevMode === false && $cache === null) {
if (extension_loaded('apc')) {
$cache = new \Doctrine\Common\Cache\ApcCache();
} elseif (extension_loaded('xcache')) {
$cache = new \Doctrine\Common\Cache\XcacheCache();
} elseif (extension_loaded('memcache')) {
$memcache = new \Memcache();
$memcache->connect('127.0.0.1');
$cache = new \Doctrine\Common\Cache\MemcacheCache();
$cache->setMemcache($memcache);
} elseif (extension_loaded('redis')) {
$redis = new \Redis();
$redis->connect('127.0.0.1');
$cache = new \Doctrine\Common\Cache\RedisCache();
$cache->setRedis($redis);
} else {
$cache = new ArrayCache();
}
} elseif ($cache === null) {
$cache = new ArrayCache();
}
if ($cache instanceof CacheProvider) {
$cache->setNamespace("dc2_" . md5($proxyDir) . "_");
// to avoid collisions
}
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setProxyDir($proxyDir);
$config->setProxyNamespace('DoctrineProxies');
$config->setAutoGenerateProxyClasses($isDevMode);
return $config;
}
/**
* @param Configuration $config
*
* @throws \ThinFrame\Foundation\Exceptions\RuntimeException
*/
private function setCacheDrivers(Configuration $config)
{
if (isset($this->configuration['caching']) && is_array($this->configuration['caching'])) {
foreach ($this->configuration['caching'] as $mode => $driver) {
if (trim($driver) == '') {
continue;
}
if (is_null($cacheDriver = $this->getCacheDriver($driver))) {
throw new RuntimeException('Bad configuration for cache driver: ' . $driver);
}
switch ($mode) {
case 'result':
$config->setResultCacheImpl($cacheDriver);
break;
case 'metadata':
$config->setMetadataCacheImpl($cacheDriver);
break;
case 'query':
$config->setQueryCacheImpl($cacheDriver);
break;
case 'hydration':
$config->setHydrationCacheImpl($cacheDriver);
break;
default:
}
}
}
}
/**
* Factory method which creates an EntityManager.
*
* @return EntityManager
* @throws \TYPO3\Flow\Configuration\Exception\InvalidConfigurationException
*/
public function create()
{
$config = new Configuration();
$config->setClassMetadataFactoryName(Mapping\ClassMetadataFactory::class);
$cache = new CacheAdapter();
// must use ObjectManager in compile phase...
$cache->setCache($this->objectManager->get(CacheManager::class)->getCache('Flow_Persistence_Doctrine'));
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$resultCache = new CacheAdapter();
// must use ObjectManager in compile phase...
$resultCache->setCache($this->objectManager->get(CacheManager::class)->getCache('Flow_Persistence_Doctrine_Results'));
$config->setResultCacheImpl($resultCache);
if (is_string($this->settings['doctrine']['sqlLogger']) && class_exists($this->settings['doctrine']['sqlLogger'])) {
$configuredSqlLogger = $this->settings['doctrine']['sqlLogger'];
$sqlLoggerInstance = new $configuredSqlLogger();
if ($sqlLoggerInstance instanceof SQLLogger) {
$config->setSQLLogger($sqlLoggerInstance);
} else {
throw new InvalidConfigurationException(sprintf('TYPO3.Flow.persistence.doctrine.sqlLogger must point to a \\Doctrine\\DBAL\\Logging\\SQLLogger implementation, %s given.', get_class($sqlLoggerInstance)), 1426150388);
}
}
$eventManager = $this->buildEventManager();
$flowAnnotationDriver = $this->objectManager->get(Mapping\Driver\FlowAnnotationDriver::class);
$config->setMetadataDriverImpl($flowAnnotationDriver);
$proxyDirectory = Files::concatenatePaths(array($this->environment->getPathToTemporaryDirectory(), 'Doctrine/Proxies'));
Files::createDirectoryRecursively($proxyDirectory);
$config->setProxyDir($proxyDirectory);
$config->setProxyNamespace('TYPO3\\Flow\\Persistence\\Doctrine\\Proxies');
$config->setAutoGenerateProxyClasses(false);
// Set default host to 127.0.0.1 if there is no host configured but a dbname
if (empty($this->settings['backendOptions']['host']) && !empty($this->settings['backendOptions']['dbname'])) {
$this->settings['backendOptions']['host'] = '127.0.0.1';
}
// The following code tries to connect first, if that succeeds, all is well. If not, the platform is fetched directly from the
// driver - without version checks to the database server (to which no connection can be made) - and is added to the config
// which is then used to create a new connection. This connection will then return the platform directly, without trying to
// detect the version it runs on, which fails if no connection can be made. But the platform is used even if no connection can
// be made, which was no problem with Doctrine DBAL 2.3. And then came version-aware drivers and platforms...
$connection = DriverManager::getConnection($this->settings['backendOptions'], $config, $eventManager);
try {
$connection->connect();
} catch (ConnectionException $exception) {
$settings = $this->settings['backendOptions'];
$settings['platform'] = $connection->getDriver()->getDatabasePlatform();
$connection = DriverManager::getConnection($settings, $config, $eventManager);
}
$entityManager = EntityManager::create($connection, $config, $eventManager);
$flowAnnotationDriver->setEntityManager($entityManager);
if (isset($this->settings['doctrine']['dbal']['mappingTypes']) && is_array($this->settings['doctrine']['dbal']['mappingTypes'])) {
foreach ($this->settings['doctrine']['dbal']['mappingTypes'] as $typeName => $typeConfiguration) {
Type::addType($typeName, $typeConfiguration['className']);
$entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping($typeConfiguration['dbType'], $typeName);
}
}
if (isset($this->settings['doctrine']['filters']) && is_array($this->settings['doctrine']['filters'])) {
foreach ($this->settings['doctrine']['filters'] as $filterName => $filterClass) {
$config->addFilter($filterName, $filterClass);
$entityManager->getFilters()->enable($filterName);
}
}
if (isset($this->settings['doctrine']['dql']) && is_array($this->settings['doctrine']['dql'])) {
$this->applyDqlSettingsToConfiguration($this->settings['doctrine']['dql'], $config);
}
return $entityManager;
}
/*
* Copyright 2015 Jack Sleight <http://jacksleight.com/>
* This source file is subject to the MIT license that is bundled with this package in the file LICENCE.md.
*/
use Doctrine\ORM\Configuration;
use Doctrine\Common\EventManager;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Proxy\Autoloader;
use Chalk\Doctrine\ORM\EntityManager as ChalkEntityManager;
use Chalk\Doctrine\NamingStrategy;
use Chalk\Listener;
\Coast\Doctrine\register_dbal_types();
if (!isset($app->config->database)) {
throw new \Chalk\Exception('Database connection details are required');
}
$config = new Configuration();
$config->setNamingStrategy(new NamingStrategy());
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$config->setProxyDir($app->config->dataDir->dir('proxy'));
$config->setProxyNamespace('Chalk\\Proxy');
$config->setAutoGenerateProxyClasses(false);
$config->setQueryCacheImpl($app->cache->value());
$config->setResultCacheImpl($app->cache->value());
$config->setMetadataCacheImpl($app->cache->value());
Autoloader::register($app->config->dataDir->dir('proxy'), 'Chalk\\Proxy');
$evm = new EventManager();
$evm->addEventSubscriber(new Listener());
$em = new ChalkEntityManager(EntityManager::create($app->config->database + ['driver' => 'pdo_mysql', 'charset' => 'utf8'], $config, $evm));
$em->getConnection()->exec("SET NAMES utf8");
Toast\Wrapper::$em = $em;
return $em;
/**
* Returns an entity manager
*
* @param string $name the entity manager configuration name
*
* @return Doctrine\ORM\EntityManager
* @throws CException
*/
public function getEntityManager($name = 'default')
{
if (isset($this->_cache['em'][$name]) === true) {
return $this->_cache['em'][$name];
}
if (isset($this->entityManager[$name]) === false) {
throw new \CException(\Yii::t('wk', 'Unknown entity manager configuration "{name}"', array('{name}' => $name)));
}
$options = $this->entityManager[$name];
$conn = $this->getConnection($options['connection']);
$config = new ORM\Configuration();
unset($options['connection']);
$driver = $this->_getMappingDriver($options);
$config->setMetadataDriverImpl($driver);
// set metadata cache
if (isset($options['metadataCache']) === true) {
$config->setMetadataCacheImpl($this->getCache($options['metadataCache']));
unset($options['metadataCache']);
}
// set query cache
if (isset($options['queryCache']) === true) {
$config->setQueryCacheImpl($this->getCache($options['queryCache']));
unset($options['queryCache']);
}
// set result cache
if (isset($options['resultCache']) === true) {
$config->setResultCacheImpl($this->getCache($options['resultCache']));
unset($options['resultCache']);
}
$options['proxyDir'] = \Yii::getPathOfAlias($options['proxyDir']);
// loop through setters of remaining options
foreach ($options as $key => $value) {
$method = 'set' . ucfirst($key);
if (method_exists($config, $method) === true) {
$config->{$method}($value);
}
}
$em = ORM\EntityManager::create($conn, $config);
$this->_cache['em'][$name] = $em;
return $em;
}
public function register(Application $app)
{
$app['EM.sql-logger.file'] = $app->share(function (Application $app) {
return $app['log.path'] . '/doctrine-log.log';
});
$app['EM.sql-logger.max-files'] = 5;
$app['EM.sql-logger'] = $app->share(function (Application $app) {
$logger = new $app['monolog.logger.class']('doctrine-logger');
$logger->pushHandler(new RotatingFileHandler($app['EM.sql-logger.file'], $app['EM.sql-logger.max-files']));
return new MonologSQLLogger($logger, 'yaml');
});
$app['EM.driver'] = $app->share(function (Application $app) {
AnnotationRegistry::registerFile($app['root.path'] . '/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$annotationReader = new AnnotationReader();
$fileCacheReader = new FileCacheReader($annotationReader, $app['cache.path'] . '/doctrine', $app['debug']);
$driverChain = new MappingDriverChain();
DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $fileCacheReader);
$annotationDriver = new AnnotationDriver($annotationReader, [$app['root.path'] . '/lib/Alchemy/Phrasea/Model/Entities']);
$driverChain->addDriver($annotationDriver, 'Alchemy\\Phrasea\\Model\\Entities');
return $driverChain;
});
$app['EM.config'] = $app->share(function (Application $app) {
$config = new ORMConfiguration();
if ($app->getEnvironment() === PhraseaApplication::ENV_DEV) {
$config->setSQLLogger($app['EM.sql-logger']);
}
$config->setMetadataCacheImpl($app['phraseanet.cache-service']->factory('ORMmetadata', $app['EM.opcode-cache-type'], $app['EM.opcode-cache-options']));
$config->setQueryCacheImpl($app['phraseanet.cache-service']->factory('ORMquery', $app['EM.opcode-cache-type'], $app['EM.opcode-cache-options']));
$config->setResultCacheImpl($app['phraseanet.cache-service']->factory('ORMresult', $app['EM.cache-type'], $app['EM.cache-options']));
$config->setAutoGenerateProxyClasses($app['debug']);
$config->setMetadataDriverImpl($app['EM.driver']);
$config->setProxyDir($app['root.path'] . '/resources/proxies');
$config->setProxyNamespace('Alchemy\\Phrasea\\Model\\Proxies');
$config->setAutoGenerateProxyClasses($app['debug']);
$config->addEntityNamespace('Phraseanet', 'Alchemy\\Phrasea\\Model\\Entities');
return $config;
});
$app['EM.opcode-cache-type'] = $app->share(function (Application $app) {
if ($app['configuration.store']->isSetup()) {
return $app['conf']->get(['main', 'opcodecache', 'type']);
}
return 'ArrayCache';
});
$app['EM.opcode-cache-options'] = $app->share(function (Application $app) {
if ($app['configuration.store']->isSetup()) {
return $app['conf']->get(['main', 'opcodecache', 'options']);
}
return [];
});
$app['EM.cache-type'] = $app->share(function (Application $app) {
if ($app['configuration.store']->isSetup()) {
return $app['conf']->get(['main', 'cache', 'type']);
}
return 'ArrayCache';
});
$app['EM.cache-options'] = $app->share(function (Application $app) {
if ($app['configuration.store']->isSetup()) {
return $app['conf']->get(['main', 'cache', 'options']);
}
return [];
});
$app['EM.events-manager'] = $app->share(function (Application $app) {
$evm = new EventManager();
$evm->addEventSubscriber(new TimestampableListener());
return $evm;
});
$app['EM.dbal-conf'] = $app->share(function (Application $app) {
if ('test' === $app->getEnvironment()) {
return $app['conf']->get(['main', 'database-test']);
}
return $app['conf']->get(['main', 'database']);
});
$app['dbal.provider'] = $app->share(function (Application $app) {
return new ConnectionProvider($app['EM.config'], $app['EM.events-manager'], isset($app['task-manager.logger']) ? $app['task-manager.logger'] : $app['monolog']);
});
$app['EM'] = $app->share(function (Application $app) {
try {
$em = EntityManager::create($app['EM.dbal-conf'], $app['EM.config'], $app['EM.events-manager']);
} catch (\Exception $e) {
throw new RuntimeException("Unable to create database connection", $e->getCode(), $e);
}
$platform = $em->getConnection()->getDatabasePlatform();
$types = ['blob' => 'Alchemy\\Phrasea\\Model\\Types\\Blob', 'enum' => 'Alchemy\\Phrasea\\Model\\Types\\Blob', 'longblob' => 'Alchemy\\Phrasea\\Model\\Types\\LongBlob', 'varbinary' => 'Alchemy\\Phrasea\\Model\\Types\\VarBinary', 'binary' => 'Alchemy\\Phrasea\\Model\\Types\\Binary', 'binary_string' => 'Alchemy\\Phrasea\\Model\\Types\\BinaryString'];
foreach ($types as $type => $class) {
if (!Type::hasType($type)) {
Type::addType($type, $class);
}
$platform->registerDoctrineTypeMapping($type, $type);
}
return $em;
});
$app['EM.native-query'] = $app->share(function ($app) {
return new NativeQueryProvider($app['EM']);
});
}
/**
* {@inheritdoc}
*/
protected function createWithConfig(ContainerInterface $container, $configKey)
{
$config = $this->retrieveConfig($container, $configKey, 'configuration');
$configuration = new Configuration();
$configuration->setProxyDir($config['proxy_dir']);
$configuration->setProxyNamespace($config['proxy_namespace']);
$configuration->setAutoGenerateProxyClasses($config['auto_generate_proxy_classes']);
$configuration->setEntityNamespaces($config['entity_namespaces']);
$configuration->setCustomDatetimeFunctions($config['datetime_functions']);
$configuration->setCustomStringFunctions($config['string_functions']);
$configuration->setCustomNumericFunctions($config['numeric_functions']);
$configuration->setCustomHydrationModes($config['custom_hydration_modes']);
$configuration->setClassMetadataFactoryName($config['class_metadata_factory_name']);
foreach ($config['named_queries'] as $name => $dql) {
$configuration->addNamedQuery($name, $dql);
}
foreach ($config['named_native_queries'] as $name => $query) {
$configuration->addNamedNativeQuery($name, $query['sql'], $query['rsm']);
}
foreach ($config['filters'] as $name => $className) {
$configuration->addFilter($name, $className);
}
$configuration->setMetadataCacheImpl($this->retrieveDependency($container, $config['metadata_cache'], 'cache', CacheFactory::class));
$configuration->setQueryCacheImpl($this->retrieveDependency($container, $config['query_cache'], 'cache', CacheFactory::class));
$configuration->setResultCacheImpl($this->retrieveDependency($container, $config['result_cache'], 'cache', CacheFactory::class));
$configuration->setHydrationCacheImpl($this->retrieveDependency($container, $config['hydration_cache'], 'cache', CacheFactory::class));
$configuration->setMetadataDriverImpl($this->retrieveDependency($container, $config['driver'], 'driver', DriverFactory::class));
if (is_string($config['naming_strategy'])) {
$configuration->setNamingStrategy($container->get($config['naming_strategy']));
} elseif (null !== $config['naming_strategy']) {
$configuration->setNamingStrategy($config['naming_strategy']);
}
if (is_string($config['repository_factory'])) {
$configuration->setRepositoryFactory($container->get($config['repository_factory']));
} elseif (null !== $config['repository_factory']) {
$configuration->setRepositoryFactory($config['repository_factory']);
}
if (is_string($config['entity_listener_resolver'])) {
$configuration->setEntityListenerResolver($container->get($config['entity_listener_resolver']));
} elseif (null !== $config['entity_listener_resolver']) {
$configuration->setEntityListenerResolver($config['entity_listener_resolver']);
}
if (null !== $config['default_repository_class_name']) {
$configuration->setDefaultRepositoryClassName($config['default_repository_class_name']);
}
if ($config['second_level_cache']['enabled']) {
$regionsConfig = new RegionsConfiguration($config['second_level_cache']['default_lifetime'], $config['second_level_cache']['default_lock_lifetime']);
foreach ($config['second_level_cache']['regions'] as $regionName => $regionConfig) {
if (array_key_exists('lifetime', $regionConfig)) {
$regionsConfig->setLifetime($regionName, $regionConfig['lifetime']);
}
if (array_key_exists('lock_lifetime', $regionConfig)) {
$regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']);
}
}
$cacheFactory = new DefaultCacheFactory($regionsConfig, $configuration->getResultCacheImpl());
$cacheFactory->setFileLockRegionDirectory($config['second_level_cache']['file_lock_region_directory']);
$cacheConfiguration = new CacheConfiguration();
$cacheConfiguration->setCacheFactory($cacheFactory);
$cacheConfiguration->setRegionsConfiguration($regionsConfig);
$configuration->setSecondLevelCacheEnabled(true);
$configuration->setSecondLevelCacheConfiguration($cacheConfiguration);
}
if (is_string($config['sql_logger'])) {
$configuration->setSQLLogger($container->get($config['sql_logger']));
} elseif (null !== $config['sql_logger']) {
$configuration->setSQLLogger($config['sql_logger']);
}
return $configuration;
}
/**
* {@inheritDoc}
*
* @return Configuration
*/
public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
{
/** @var $options \DoctrineORMModule\Options\Configuration */
$options = $this->getOptions($container);
$config = new Configuration();
$config->setAutoGenerateProxyClasses($options->getGenerateProxies());
$config->setProxyDir($options->getProxyDir());
$config->setProxyNamespace($options->getProxyNamespace());
$config->setEntityNamespaces($options->getEntityNamespaces());
$config->setCustomDatetimeFunctions($options->getDatetimeFunctions());
$config->setCustomStringFunctions($options->getStringFunctions());
$config->setCustomNumericFunctions($options->getNumericFunctions());
$config->setClassMetadataFactoryName($options->getClassMetadataFactoryName());
foreach ($options->getNamedQueries() as $name => $query) {
$config->addNamedQuery($name, $query);
}
foreach ($options->getNamedNativeQueries() as $name => $query) {
$config->addNamedNativeQuery($name, $query['sql'], new $query['rsm']());
}
foreach ($options->getCustomHydrationModes() as $modeName => $hydrator) {
$config->addCustomHydrationMode($modeName, $hydrator);
}
foreach ($options->getFilters() as $name => $class) {
$config->addFilter($name, $class);
}
$config->setMetadataCacheImpl($container->get($options->getMetadataCache()));
$config->setQueryCacheImpl($container->get($options->getQueryCache()));
$config->setResultCacheImpl($container->get($options->getResultCache()));
$config->setHydrationCacheImpl($container->get($options->getHydrationCache()));
$config->setMetadataDriverImpl($container->get($options->getDriver()));
if ($namingStrategy = $options->getNamingStrategy()) {
if (is_string($namingStrategy)) {
if (!$container->has($namingStrategy)) {
throw new InvalidArgumentException(sprintf('Naming strategy "%s" not found', $namingStrategy));
}
$config->setNamingStrategy($container->get($namingStrategy));
} else {
$config->setNamingStrategy($namingStrategy);
}
}
if ($quoteStrategy = $options->getQuoteStrategy()) {
if (is_string($quoteStrategy)) {
if (!$container->has($quoteStrategy)) {
throw new InvalidArgumentException(sprintf('Quote strategy "%s" not found', $quoteStrategy));
}
$config->setQuoteStrategy($container->get($quoteStrategy));
} else {
$config->setQuoteStrategy($quoteStrategy);
}
}
if ($repositoryFactory = $options->getRepositoryFactory()) {
if (is_string($repositoryFactory)) {
if (!$container->has($repositoryFactory)) {
throw new InvalidArgumentException(sprintf('Repository factory "%s" not found', $repositoryFactory));
}
$config->setRepositoryFactory($container->get($repositoryFactory));
} else {
$config->setRepositoryFactory($repositoryFactory);
}
}
if ($entityListenerResolver = $options->getEntityListenerResolver()) {
if ($entityListenerResolver instanceof EntityListenerResolver) {
$config->setEntityListenerResolver($entityListenerResolver);
} else {
$config->setEntityListenerResolver($container->get($entityListenerResolver));
}
}
$secondLevelCache = $options->getSecondLevelCache();
if ($secondLevelCache->isEnabled()) {
$regionsConfig = new RegionsConfiguration($secondLevelCache->getDefaultLifetime(), $secondLevelCache->getDefaultLockLifetime());
foreach ($secondLevelCache->getRegions() as $regionName => $regionConfig) {
if (isset($regionConfig['lifetime'])) {
$regionsConfig->setLifetime($regionName, $regionConfig['lifetime']);
}
if (isset($regionConfig['lock_lifetime'])) {
$regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']);
}
}
// As Second Level Cache caches queries results, we reuse the result cache impl
$cacheFactory = new DefaultCacheFactory($regionsConfig, $config->getResultCacheImpl());
$cacheFactory->setFileLockRegionDirectory($secondLevelCache->getFileLockRegionDirectory());
$cacheConfiguration = new CacheConfiguration();
$cacheConfiguration->setCacheFactory($cacheFactory);
$cacheConfiguration->setRegionsConfiguration($regionsConfig);
$config->setSecondLevelCacheEnabled();
$config->setSecondLevelCacheConfiguration($cacheConfiguration);
}
if ($className = $options->getDefaultRepositoryClassName()) {
$config->setDefaultRepositoryClassName($className);
}
$this->setupDBALConfiguration($container, $config);
return $config;
}
public function register(Container $app)
{
if (!isset($app['dbs'])) {
throw new \LogicException('You must register the DoctrineServiceProvider to use the DoctrineOrmServiceProvider.');
}
if (!isset($app['caches'])) {
throw new \LogicException('You must register the DoctrineCacheServiceProvider to use the DoctrineOrmServiceProvider.');
}
$app['ems.options.initializer'] = $app->protect(function () use($app) {
static $initialized = false;
if ($initialized) {
return;
}
$initialized = true;
if (!isset($app['ems.options'])) {
$app['ems.options'] = ['default' => isset($app['orm.options']) ? $app['orm.options'] : []];
}
$app['ems.options'] = array_map(function ($options) use($app) {
return array_replace($app['orm.default_options'], $options);
}, $app['ems.options']);
if (!isset($app['ems.default'])) {
$app['ems.default'] = array_keys(array_slice($app['ems.options'], 0, 1))[0];
}
});
$app['ems'] = function (Container $app) {
$app['ems.options.initializer']();
$container = new Container();
foreach ($app['ems.options'] as $name => $options) {
if ($app['ems.default'] === $name) {
$config = $app['orm.config'];
} else {
$config = $app['ems.config'][$name];
}
$connection = $app['dbs'][$options['connection']];
$manager = $app['dbs.event_manager'][$options['connection']];
$container[$name] = function () use($connection, $config, $manager) {
return EntityManager::create($connection, $config, $manager);
};
}
return $container;
};
$app['ems.config'] = function (Container $app) {
$app['ems.options.initializer']();
$container = new Container();
foreach ($app['ems.options'] as $name => $options) {
$config = new Configuration();
$config->setProxyDir($app['orm.proxy_dir']);
$config->setProxyNamespace($app['orm.proxy_namespace']);
$config->setAutoGenerateProxyClasses($app['orm.auto_generate_proxy_classes']);
$config->setCustomStringFunctions($app['orm.custom_functions_string']);
$config->setCustomNumericFunctions($app['orm.custom_functions_numeric']);
$config->setCustomDatetimeFunctions($app['orm.custom_functions_datetime']);
$config->setMetadataCacheImpl($app['orm.cache.factory']('metadata', $options));
$config->setQueryCacheImpl($app['orm.cache.factory']('query', $options));
$config->setResultCacheImpl($app['orm.cache.factory']('result', $options));
$config->setMetadataDriverImpl($app['orm.mapping.chain']($config, $options['mappings']));
$container[$name] = $config;
}
return $container;
};
$app['orm.cache.factory'] = $app->protect(function ($type, $options) use($app) {
$type = $type . '_cache_driver';
if (!isset($options[$type])) {
$options[$type] = 'array';
}
if (!is_array($options[$type])) {
$options[$type] = ['driver' => $options[$type]];
}
$driver = $options[$type]['driver'];
$namespace = isset($options[$type]['namespace']) ? $options[$type]['namespace'] : null;
$cache = $app['cache.factory']($driver, $options);
$cache->setNamespace($namespace);
return $cache;
});
$app['orm.mapping.chain'] = $app->protect(function (Configuration $config, array $mappings) {
$chain = new MappingDriverChain();
foreach ($mappings as $mapping) {
if (!is_array($mapping)) {
throw new \InvalidArgumentException();
}
switch ($mapping['type']) {
case 'annotation':
$useSimpleAnnotationReader = isset($mapping['use_simple_annotation_reader']) ? $mapping['use_simple_annotation_reader'] : true;
$driver = $config->newDefaultAnnotationDriver($mapping['path'], $useSimpleAnnotationReader);
break;
case 'yml':
$driver = new YamlDriver($mapping['path']);
break;
default:
throw new \InvalidArgumentException();
break;
}
$chain->addDriver($driver, $mapping['namespace']);
}
return $chain;
});
$app['orm.proxy_dir'] = null;
$app['orm.proxy_namespace'] = 'Proxy';
$app['orm.auto_generate_proxy_classes'] = true;
$app['orm.custom_functions_string'] = [];
$app['orm.custom_functions_numeric'] = [];
$app['orm.custom_functions_datetime'] = [];
$app['orm.default_options'] = ['connection' => 'default', 'mappings' => []];
// shortcuts for the "first" ORM
$app['orm'] = function (Container $app) {
$ems = $app['ems'];
return $ems[$app['ems.default']];
};
$app['orm.config'] = function (Container $app) {
$ems = $app['ems.config'];
return $ems[$app['ems.default']];
};
}
