예제 #1
0
 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);
     }
 }
예제 #2
0
 public function __construct()
 {
     // load database configuration from CodeIgniter
     require_once APPPATH . 'config/development/database.php';
     // Set up class loading. You could use different autoloaders, provided by your favorite framework,
     // if you want to.
     require_once APPPATH . 'libraries/Doctrine/Common/ClassLoader.php';
     $doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . 'libraries');
     $doctrineClassLoader->register();
     $entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/"));
     $entitiesClassLoader->register();
     $proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/proxies');
     $proxiesClassLoader->register();
     // Set up caches
     $config = new Configuration();
     $cache = new ArrayCache();
     $config->setMetadataCacheImpl($cache);
     $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models/Entities'));
     $config->setMetadataDriverImpl($driverImpl);
     $config->setQueryCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     // Proxy configuration
     $config->setProxyDir(APPPATH . '/models/proxies');
     $config->setProxyNamespace('Proxies');
     // Set up logger
     $logger = new EchoSQLLogger();
     $config->setSQLLogger($logger);
     $config->setAutoGenerateProxyClasses(TRUE);
     // Database connection information
     $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']);
     // Create EntityManager
     $this->em = EntityManager::create($connectionOptions, $config);
 }
예제 #3
0
 public function __construct()
 {
     // load database configuration from CodeIgniter
     require_once APPPATH . 'config/database.php';
     // Set up class loading. You could use different autoloaders, provided by your favorite framework,
     // if you want to.
     //require_once APPPATH.'libraries/Doctrine/Common/ClassLoader.php';
     // We use the Composer Autoloader instead - just set
     // $config['composer_autoload'] = TRUE; in application/config/config.php
     //require_once APPPATH.'vendor/autoload.php';
     //A Doctrine Autoloader is needed to load the models
     $entitiesClassLoader = new ClassLoader('Entities', APPPATH . "models");
     $entitiesClassLoader->register();
     // Set up caches
     $config = new Configuration();
     $cache = new ArrayCache();
     $config->setMetadataCacheImpl($cache);
     $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models/Entities'));
     $config->setMetadataDriverImpl($driverImpl);
     $config->setQueryCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     // Proxy configuration
     $config->setProxyDir(APPPATH . '/models/proxies');
     $config->setProxyNamespace('Proxies');
     // Set up logger
     $logger = new EchoSQLLogger();
     $config->setSQLLogger($logger);
     $config->setAutoGenerateProxyClasses(TRUE);
     // Database connection information
     $connectionOptions = array('driver' => 'pdo_mysql', 'user' => 'dev_pila', 'password' => 'damienludothomas', 'host' => 'localhost', 'dbname' => 'tradr');
     // Create EntityManager
     $this->em = EntityManager::create($connectionOptions, $config);
 }
예제 #4
0
 public static function createEntityManager($database)
 {
     $config = new Doctrine\ORM\Configuration();
     // annotations
     $annotationDriver = $config->newDefaultAnnotationDriver(array(APP_DIR . '/Model', NEURON_DIR . '/Model'));
     $config->setMetadataDriverImpl($annotationDriver);
     // proxy
     $config->setProxyNamespace('Neuron\\Proxy');
     $config->setProxyDir(TEMP_DIR);
     // cache
     $cache = Environment::isProduction() ? new NetteDoctrineCache() : new Doctrine\Common\Cache\ArrayCache();
     $config->setMetadataCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     // debugbar
     $config->setSQLLogger(Doctrine2Panel::getAndRegister());
     // entity manager
     $em = Doctrine\ORM\EntityManager::create((array) $database, $config);
     $evm = $em->getEventManager();
     $evm->addEventSubscriber(new Doctrine\DBAL\Event\Listeners\MysqlSessionInit("utf8", "utf8_czech_ci"));
     $evm->addEventSubscriber(new ValidationSubscriber());
     $evm->addEventSubscriber(new CacheSubscriber());
     $neonParser = new \Nette\NeonParser();
     $aliases = $neonParser->parse(file_get_contents(APP_DIR . "/entityClassAliases.neon"));
     $evm->addEventSubscriber(new \Neuron\Model\Doctrine\EntityClassAliasesSubscriber($aliases));
     return $em;
 }
예제 #5
0
 public function __construct()
 {
     // load database configuration from CodeIgniter
     if (!file_exists($file_path = APPPATH . 'config/' . ENVIRONMENT . '/database.php') && !file_exists($file_path = APPPATH . 'config/database.php')) {
         throw new Exception('The configuration file database.php does not exist.');
     }
     require $file_path;
     $entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/"));
     $entitiesClassLoader->register();
     $proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/Proxies');
     $proxiesClassLoader->register();
     // Set up caches
     $config = new Configuration();
     $cache = new ArrayCache();
     $config->setMetadataCacheImpl($cache);
     $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models/Entities'));
     $config->setMetadataDriverImpl($driverImpl);
     $config->setQueryCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     // Proxy configuration
     $config->setProxyDir(APPPATH . '/models/Proxies');
     $config->setProxyNamespace('Proxies');
     // Set up logger
     $logger = new EchoSQLLogger();
     $config->setSQLLogger($logger);
     $config->setAutoGenerateProxyClasses(true);
     // Database connection information
     $connectionOptions = $this->convertDbConfig($db['default']);
     // Create EntityManager
     $this->em = EntityManager::create($connectionOptions, $config);
 }
예제 #6
0
 protected static function setUpEntityManager()
 {
     $config = new Configuration();
     $config->setSQLLogger(null);
     $config->setAutoGenerateProxyClasses(true);
     $config->setProxyDir(\sys_get_temp_dir());
     $config->setProxyNamespace('Proxies');
     $config->setMetadataDriverImpl(static::getMetadataDriverImpl());
     $config->setQueryCacheImpl(new ArrayCache());
     $config->setMetadataCacheImpl(new ArrayCache());
     $dbPath = __DIR__ . '/../db.sqlite';
     if (file_exists($dbPath)) {
         unlink($dbPath);
     }
     $connection = ['driver' => 'pdo_sqlite', 'path' => $dbPath];
     // Event listeners
     $interfaces = DoctrineBundleMapping::getDefaultImplementations();
     $evm = new EventManager();
     // Resolve entity target subscriber
     $rtel = new ResolveTargetEntityListener();
     foreach ($interfaces as $model => $implementation) {
         $rtel->addResolveTargetEntity($model, $implementation, []);
     }
     $evm->addEventSubscriber($rtel);
     // Load metadata subscriber
     $lm = new LoadMetadataSubscriber([], $interfaces);
     $evm->addEventSubscriber($lm);
     static::$em = EntityManager::create($connection, $config, $evm);
 }
예제 #7
0
 /**
  * @param EntityManagerInterface $em
  * @param Configuration          $configuration
  */
 public function register(EntityManagerInterface $em, Configuration $configuration)
 {
     if ($this->debugbar->hasCollector('doctrine')) {
         $debugStack = $this->debugbar->getCollector('doctrine')->getDebugStack();
     } else {
         $debugStack = new DebugStack();
         $this->debugbar->addCollector(new DoctrineCollector($debugStack));
     }
     $configuration->setSQLLogger($debugStack);
 }
예제 #8
0
파일: Doctrine.php 프로젝트: rexmac/zyndax
 /**
  * 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;
 }
예제 #9
0
파일: Doctrine.php 프로젝트: epixa/Epixa
 /**
  * Sets up the doctrine configuration, caching, and entity manager
  * 
  * @return EntityManager
  */
 public function init()
 {
     $options = $this->getOptions();
     if (!isset($options['connection'])) {
         throw new ConfigException('No doctrine connection settings set');
     }
     $connection = $options['connection'];
     if (!isset($options['proxy'])) {
         throw new ConfigException('No doctrine proxy settings set');
     }
     if (!isset($options['proxy']['directory'])) {
         throw new ConfigException('You must set a proxy directory');
     }
     $proxyDirectory = $options['proxy']['directory'];
     $proxyNamespace = 'Epixa\\Proxy';
     if (isset($options['proxy']['namespace'])) {
         $proxyNamespace = $options['proxy']['namespace'];
     }
     $autoGenerateProxies = true;
     if (isset($options['proxy']['autoGenerate'])) {
         $autoGenerateProxies = $options['proxy']['autoGenerate'];
     }
     if (isset($options['cacheClass'])) {
         $cache = new $options['cacheClass']();
     } else {
         $cache = new \Doctrine\Common\Cache\ArrayCache();
     }
     $entityPaths = array();
     if (isset($options['entityPaths'])) {
         $entityPaths = $options['entityPaths'];
     }
     $logger = null;
     if (isset($options['loggerClass'])) {
         $logger = new $options['loggerClass']();
     }
     $config = new Configuration();
     $config->setMetadataCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     $driverImpl = $config->newDefaultAnnotationDriver($entityPaths);
     $config->setMetadataDriverImpl($driverImpl);
     $config->setProxyDir($proxyDirectory);
     $config->setProxyNamespace($proxyNamespace);
     $config->setAutoGenerateProxyClasses($autoGenerateProxies);
     if ($logger) {
         $config->setSQLLogger($logger);
     }
     return EntityManager::create($connection, $config);
 }
 public function testCreateSQLLoggerWithPreviousExistingLoggerChainsLoggers()
 {
     $originalLogger = $this->getMock('Doctrine\\DBAL\\Logging\\SQLLogger');
     $originalLogger->expects($this->once())->method('startQuery')->with($this->equalTo('test query'));
     $injectedLogger = $this->getMock('Doctrine\\DBAL\\Logging\\DebugStack');
     $injectedLogger->expects($this->once())->method('startQuery')->with($this->equalTo('test query'));
     $configuration = new ORMConfiguration();
     $configuration->setSQLLogger($originalLogger);
     $this->services->setService('doctrine.configuration.orm_default', $configuration);
     $this->services->setService('custom_logger', $injectedLogger);
     $this->services->setService('Config', array('doctrine' => array('sql_logger_collector' => array('orm_default' => array('sql_logger' => 'custom_logger')))));
     $this->factory->createService($this->services);
     /* @var $logger \Doctrine\DBAL\Logging\SQLLogger */
     $logger = $configuration->getSQLLogger();
     $logger->startQuery('test query');
 }
예제 #11
0
 public function __construct()
 {
     // load database configuration and custom config from CodeIgniter
     require APPPATH . 'config/database.php';
     // Set up class loading.
     require_once APPPATH . 'libraries/Doctrine/Common/ClassLoader.php';
     $doctrineClassLoader = new \Doctrine\Common\ClassLoader('Doctrine', APPPATH . 'libraries');
     $doctrineClassLoader->register();
     $entitiesClassLoader = new \Doctrine\Common\ClassLoader('models', rtrim(APPPATH, '/'));
     $entitiesClassLoader->register();
     $proxiesClassLoader = new \Doctrine\Common\ClassLoader('Proxies', APPPATH . 'models');
     $proxiesClassLoader->register();
     $symfonyClassLoader = new \Doctrine\Common\ClassLoader('Symfony', APPPATH . 'libraries/Doctrine');
     $symfonyClassLoader->register();
     // Choose caching method based on application mode
     if (ENVIRONMENT == 'production') {
         $cache = new \Doctrine\Common\Cache\ApcCache();
     } else {
         $cache = new \Doctrine\Common\Cache\ArrayCache();
     }
     // Set some configuration options
     $config = new Configuration();
     // Metadata driver
     $driverImpl = $config->newDefaultAnnotationDriver(APPPATH . 'models');
     $config->setMetadataDriverImpl($driverImpl);
     // Caching
     $config->setMetadataCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     // Proxies
     $config->setProxyDir(APPPATH . 'models/Proxies');
     $config->setProxyNamespace('Proxies');
     if (ENVIRONMENT == 'development') {
         $config->setAutoGenerateProxyClasses(TRUE);
     } else {
         $config->setAutoGenerateProxyClasses(FALSE);
     }
     // SQL query logger
     if (DEBUGGING) {
         $logger = new \Doctrine\DBAL\Logging\EchoSQLLogger();
         $config->setSQLLogger($logger);
     }
     // Database connection information
     $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database'], 'charset' => $db['default']['char_set'], 'driverOptions' => array('charset' => $db['default']['char_set']));
     // Create EntityManager
     $this->em = EntityManager::create($connectionOptions, $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;
 }
예제 #13
0
 public function __construct()
 {
     // Load configuration from CI - make sure to check for environment-specific config
     if (defined('ENVIRONMENT') and file_exists(APPPATH . 'config/' . ENVIRONMENT . '/database.php')) {
         require_once APPPATH . 'config/' . ENVIRONMENT . '/database.php';
     } else {
         require_once APPPATH . 'config/database.php';
     }
     // set up class loading. We don't have to use Doctrine's here
     require_once APPPATH . 'libraries/Doctrine/Common/ClassLoader.php';
     $doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . 'libraries');
     $doctrineClassLoader->register();
     $entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, '/'));
     $entitiesClassLoader->register();
     $proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/proxies');
     $proxiesClassLoader->register();
     // Set up caches
     $config = new Configuration();
     $cache = new ArrayCache();
     $config->setMetadataCacheImpl($cache);
     $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models/Entities'));
     $config->setMetadataDriverImpl($driverImpl);
     $config->setQueryCacheImpl($cache);
     // This line appears twice in documentationl not sure if needed?
     $config->setQueryCacheImpl($cache);
     // Proxy configuration
     $config->setProxyDir(APPPATH . '/models/proxies');
     $config->setProxyNamespace('Proxies');
     // Set up logger
     $logger = new EchoSQLLogger();
     $config->setSQLLogger($logger);
     $config->setAutoGenerateProxyClasses(TRUE);
     // DB Connection
     $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']);
     // Create EntityManager
     $this->em = EntityManager::create($connectionOptions, $config);
 }
 public function setUp()
 {
     $reader = new AnnotationReader();
     $driver = new AnnotationDriver($reader);
     $driver->addPaths(array(__DIR__ . '/Fixtures'));
     $config = new Configuration();
     $config->setMetadataCacheImpl(new ArrayCache());
     $config->setQueryCacheImpl(new ArrayCache());
     $config->setProxyDir(sys_get_temp_dir());
     $config->setProxyNamespace('SimpleThings\\EntityAudit\\Tests\\Proxies');
     $config->setMetadataDriverImpl($driver);
     $conn = array('driver' => $GLOBALS['DOCTRINE_DRIVER'], 'memory' => $GLOBALS['DOCTRINE_MEMORY'], 'dbname' => $GLOBALS['DOCTRINE_DATABASE'], 'user' => $GLOBALS['DOCTRINE_USER'], 'password' => $GLOBALS['DOCTRINE_PASSWORD'], 'host' => $GLOBALS['DOCTRINE_HOST']);
     if (isset($GLOBALS['DOCTRINE_PATH'])) {
         $conn['path'] = $GLOBALS['DOCTRINE_PATH'];
     }
     $auditConfig = new AuditConfiguration();
     $auditConfig->setCurrentUsername("beberlei");
     $auditConfig->setAuditedEntityClasses($this->auditedEntities);
     $auditConfig->setGlobalIgnoreColumns(array('ignoreme'));
     $this->auditManager = new AuditManager($auditConfig);
     $this->auditManager->registerEvents($evm = new EventManager());
     if (php_sapi_name() == 'cli' && isset($_SERVER['argv']) && (in_array('-v', $_SERVER['argv']) || in_array('--verbose', $_SERVER['argv']))) {
         $config->setSQLLogger(new EchoSQLLogger());
     }
     $this->em = EntityManager::create($conn, $config, $evm);
     $schemaTool = new SchemaTool($this->em);
     $em = $this->em;
     try {
         $schemaTool->createSchema(array_map(function ($value) use($em) {
             return $em->getClassMetadata($value);
         }, $this->schemaEntities));
     } catch (\Exception $e) {
         if ($GLOBALS['DOCTRINE_DRIVER'] != 'pdo_mysql' || !($e instanceof \PDOException && strpos($e->getMessage(), 'Base table or view already exists') !== false)) {
             throw $e;
         }
     }
 }
예제 #15
0
use Doctrine\ORM\Tools\Console\ConsoleRunner;
use Doctrine\Common\ClassLoader, Doctrine\ORM\Configuration, Doctrine\ORM\EntityManager, Doctrine\Common\Cache\ArrayCache, Doctrine\DBAL\Logging\EchoSQLLogger;
define('APPPATH', dirname(__FILE__) . DIRECTORY_SEPARATOR);
require_once APPPATH . 'libraries/Doctrine/Common/ClassLoader.php';
$doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . 'libraries');
$doctrineClassLoader->register();
$entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/"));
$entitiesClassLoader->register();
$proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/proxies');
$proxiesClassLoader->register();
// Set up caches
$config = new Configuration();
$cache = new ArrayCache();
$config->setMetadataCacheImpl($cache);
//$driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH.'models/Entities'));
//$config->setMetadataDriverImpl($driverImpl);
$config->setMetadataDriverImpl(new Doctrine\ORM\Mapping\Driver\XmlDriver(APPPATH . 'models'));
$config->setQueryCacheImpl($cache);
$config->setQueryCacheImpl($cache);
// Proxy configuration
$config->setProxyDir(APPPATH . '/models/proxies');
$config->setProxyNamespace('Proxies');
// Set up logger
$logger = new EchoSQLLogger();
$config->setSQLLogger($logger);
$config->setAutoGenerateProxyClasses(TRUE);
// Database connection information
$connectionOptions = array('driver' => 'pdo_mysql', 'user' => 'root', 'password' => 'fp87694fbr', 'host' => 'localhost', 'dbname' => 'mostratec');
// Create EntityManager
$em = EntityManager::create($connectionOptions, $config);
return ConsoleRunner::createHelperSet($em);
 /**
  * @codeCoverageIgnore
  * Returns a new ORM Configuration.
  *
  * @param  array $options Optional, the options to create the new Configuration
  * @return Configuration
  */
 private static function getORMConfiguration(array $options = array(), LoggerInterface $logger = null, ContainerInterface $container = null)
 {
     $config = new Configuration();
     $driverImpl = $config->newDefaultAnnotationDriver([], false);
     $config->setMetadataDriverImpl($driverImpl);
     if (isset($options['proxy_dir'])) {
         $config->setProxyDir($options['proxy_dir']);
     }
     if (isset($options['proxy_ns'])) {
         $config->setProxyNamespace($options['proxy_ns']);
     }
     if (isset($options['orm'])) {
         if (isset($options['orm']['proxy_namespace'])) {
             $config->setProxyNamespace($options['orm']['proxy_namespace']);
         }
         if (isset($options['orm']['proxy_dir'])) {
             $config->setProxyDir($options['orm']['proxy_dir']);
         }
         if (isset($options['orm']['auto_generate_proxy_classes'])) {
             $config->setAutoGenerateProxyClasses($options['orm']['auto_generate_proxy_classes']);
         }
         if (isset($options['orm']['metadata_cache_driver']) && is_array($options['orm']['metadata_cache_driver'])) {
             if (isset($options['orm']['metadata_cache_driver']['type'])) {
                 if ('service' === $options['orm']['metadata_cache_driver']['type'] && isset($options['orm']['metadata_cache_driver']['id'])) {
                     $serviceId = str_replace('@', '', $options['orm']['metadata_cache_driver']['id']);
                     if (null !== $container && $container->has($serviceId)) {
                         $config->setMetadataCacheImpl($container->get($serviceId));
                     }
                 }
             }
         }
         if (isset($options['orm']['query_cache_driver']) && is_array($options['orm']['query_cache_driver'])) {
             if (isset($options['orm']['query_cache_driver']['type'])) {
                 if ('service' === $options['orm']['query_cache_driver']['type'] && isset($options['orm']['query_cache_driver']['id'])) {
                     $serviceId = str_replace('@', '', $options['orm']['query_cache_driver']['id']);
                     if (null !== $container && $container->has($serviceId)) {
                         $config->setQueryCacheImpl($container->get($serviceId));
                     }
                 }
             }
         }
     }
     if ($logger instanceof SQLLogger) {
         $config->setSQLLogger($logger);
     }
     return self::addCustomFunctions($config, $options);
 }
예제 #17
0
파일: Bootstrap.php 프로젝트: rukzuk/rukzuk
 protected function _initDoctrine()
 {
     $appDoctrineConfig = $this->getOption('doctrine');
     $classLoader = new DoctrineClassLoader('Doctrine');
     $classLoader->setIncludePath(realpath(APPLICATION_PATH . '/../library'));
     $classLoader->register();
     $config = new DoctrineConfiguration();
     if (isset($appDoctrineConfig['cache'])) {
         switch ($appDoctrineConfig['cache']) {
             case 'array':
                 $cache = new DoctrineArrayCache();
                 break;
             case 'apc':
                 $cache = new DoctrineApcCache();
                 break;
         }
         $config->setQueryCacheImpl($cache);
         $config->setMetadataCacheImpl($cache);
     }
     $proxyDir = empty($appDoctrineConfig['proxyDir']) ? APPLICATION_PATH . '/../library/Orm/Proxies' : $appDoctrineConfig['proxyDir'];
     $config->setProxyDir(realpath($proxyDir));
     $config->setProxyNamespace('Orm\\Proxies');
     $config->setAutoGenerateProxyClasses(false);
     $config->setEntityNamespaces(array('Orm\\Entity'));
     $config->setMetadataDriverImpl(new \Doctrine\ORM\Mapping\Driver\StaticPHPDriver(realpath(APPLICATION_PATH . '/../library/Orm/Entity')));
     //$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
     $config->setSQLLogger(null);
     $db = $this->getResource('db');
     $dbConfig = $db->getConfig();
     $connectionOptions = array('pdo' => $db->getConnection(), 'dbname' => $dbConfig['dbname']);
     $entityManager = DoctrineEntityManager::create($connectionOptions, $config);
     $entityManager->getConnection()->getConfiguration()->setSQLLogger(null);
     Registry::setEntityManager($entityManager);
     return $entityManager;
 }
예제 #18
0
 /**
  * Setup SQL logger.
  *
  * @param \Doctrine\ORM\Configuration $config
  * @param array                       $options
  */
 protected static function setupSQLLogger(Configuration &$config, array $options)
 {
     if ($options['sql_logger']) {
         $config->setSQLLogger($options['sql_logger']);
     }
 }
 /**
  * {@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;
 }
예제 #20
0
 /**
  * @param EntityManagerInterface $em
  * @param Configuration          $configuration
  */
 public function register(EntityManagerInterface $em, Configuration $configuration)
 {
     $debugStack = new DebugStack();
     $configuration->setSQLLogger($debugStack);
     $this->clockwork->addDataSource(new DoctrineDataSource($debugStack, $em->getConnection()->getDriver()->getName()));
 }
예제 #21
0
 /**
  * @param EntityManagerInterface $em
  * @param Configuration          $configuration
  */
 public function register(EntityManagerInterface $em, Configuration $configuration)
 {
     $logger = new DoctrineFileLogger($this->logger);
     $configuration->setSQLLogger($logger);
 }
예제 #22
0
 /**
  * {@inheritDoc}
  */
 protected function loadInstance()
 {
     $opts = $this->opts;
     $config = new DoctrineConfiguration();
     // proxies
     $config->setAutoGenerateProxyClasses($opts['auto_generate_proxies']);
     $config->setProxyDir($opts['proxy_dir']);
     $config->setProxyNamespace($opts['proxy_namespace']);
     // entity namespaces
     $config->setEntityNamespaces($opts['entity_namespaces']);
     // add custom functions
     $config->setCustomDatetimeFunctions($opts['custom_datetime_functions']);
     $config->setCustomStringFunctions($opts['custom_string_functions']);
     $config->setCustomNumericFunctions($opts['custom_numeric_functions']);
     // custom queries
     foreach ($opts['named_queries'] as $query) {
         $config->addNamedQuery($query['name'], $query['dql']);
     }
     foreach ($opts['named_native_queries'] as $query) {
         $config->addNamedNativeQuery($query['name'], $query['sql'], new $query['rsm']());
     }
     // caching
     $config->setQueryCacheImpl($this->queryCache);
     $config->setMetadataCacheImpl($this->metadataCache);
     $config->setResultCacheImpl($this->metadataCache);
     // logger
     $config->setSQLLogger($this->logger);
     // finally, the driver
     $config->setMetadataDriverImpl($this->metadataDriver);
     $this->instance = $config;
 }
예제 #23
0
 protected function setupLogging(ServiceLocatorInterface $services, Configuration $config, $spec, $name)
 {
     $profiler = new Profiler($name);
     $profiler->getEventManager()->setSharedManager($services->get('SharedEventManager'));
     $profiler->setIsLogging($spec['log_sql']);
     $config->setSQLLogger($profiler);
 }
예제 #24
0
파일: EchoLogger.php 프로젝트: Devitek/orm
 /**
  * @param EntityManagerInterface $em
  * @param Configuration          $configuration
  */
 public function register(EntityManagerInterface $em, Configuration $configuration)
 {
     $configuration->setSQLLogger(new EchoSQLLogger());
 }
예제 #25
0
 public function __construct()
 {
     // load database configuration from CodeIgniter
     require_once APPPATH . 'config/database.php';
     include_once APPPATH . 'third_party/Doctrine/vendor/autoload.php';
     // load the entities
     $entityClassLoader = new ClassLoader('Entity', APPPATH . 'models');
     $entityClassLoader->register();
     // load the proxy entities
     $proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models');
     $proxiesClassLoader->register();
     // Set up the configuration
     $config = new Configuration();
     // Set up caches
     if (ENVIRONMENT == 'development') {
         // set environment in index.php
         // set up simple array caching for development mode
         $cacheDriver = new \Doctrine\Common\Cache\ArrayCache();
     } else {
         // set up caching with APC for production mode
         $redis = new Redis();
         $redis->connect('redis_host', 'redis_port');
         $cacheDriver = new \Doctrine\Common\Cache\RedisCache();
         $cacheDriver->setRedis($redis);
     }
     $config->setMetadataCacheImpl($cacheDriver);
     $config->setQueryCacheImpl($cacheDriver);
     $driverImpl = $config->newDefaultAnnotationDriver(APPPATH . 'models/Entity');
     $config->setMetadataDriverImpl($driverImpl);
     // Proxy configuration
     $config->setProxyDir(APPPATH . '/models/Proxies');
     $config->setProxyNamespace('Proxies');
     // Set up logger
     if (ENVIRONMENT == 'development') {
         $logger = new \Doctrine\DBAL\Logging\EchoSQLLogger();
         $config->setSQLLogger($logger);
     }
     $config->setAutoGenerateProxyClasses(true);
     // only for development
     $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database'], 'charset' => $db['default']['char_set'], 'driverOptions' => array('charset' => $db['default']['char_set']));
     $this->em = EntityManager::create($connectionOptions, $config);
     //        $connection_options = array(
     //            'driver'        => 'pdo_mysql',
     //            'user'          => $db['default']['username'],
     //            'password'      => $db['default']['password'],
     //            'host'          => $db['default']['hostname'],
     //            'dbname'        => $db['default']['database'],
     //            'charset'       => $db['default']['char_set'],
     //            'driverOptions' => array(
     //                'charset'   => $db['default']['char_set'],
     //            ),
     //        );
     //
     //        // With this configuration, your model files need to be in application/models/Entity
     //        // e.g. Creating a new Entity\User loads the class from application/models/Entity/User.php
     //        $models_namespace = 'Entity';
     //        $models_path = APPPATH . 'models';
     //        $proxies_dir = APPPATH . 'models/Proxies';
     //        $metadata_paths = array(APPPATH . 'models/Entity');
     //
     //        // Set $dev_mode to TRUE to disable caching while you develop
     //        $dev_mode = true;
     //
     //        // If you want to use a different metadata driver, change createAnnotationMetadataConfiguration
     //        // to createXMLMetadataConfiguration or createYAMLMetadataConfiguration.
     //        $config = Setup::createAnnotationMetadataConfiguration($metadata_paths, $dev_mode, $proxies_dir);
     //        $this->em = EntityManager::create($connection_options, $config);
     //
     //        $loader = new ClassLoader($models_namespace, $models_path);
     //        $loader->register();
 }
예제 #26
0
 /**
  * Initializes the doctrine framework and
  * sets all required configuration options.
  * 
  * @param none
  * @return nothing
  */
 public static function initializeDoctrine()
 {
     $config = new Configuration();
     $driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__));
     $config->setMetadataDriverImpl($driverImpl);
     $connectionOptions = PartKeepr::createConnectionOptionsFromConfig();
     switch (strtolower(PartKeeprConfiguration::getOption("partkeepr.cache.implementation", "default"))) {
         case "apc":
             $cache = new \Doctrine\Common\Cache\ApcCache();
             break;
         case "xcache":
             if (php_sapi_name() !== "cli") {
                 $cache = new \Doctrine\Common\Cache\XcacheCache();
             } else {
                 // For CLI SAPIs, revert to the ArrayCache as Xcache spits out strange warnings when running in CLI.
                 $cache = new \Doctrine\Common\Cache\ArrayCache();
             }
             break;
         case "memcache":
             $memcache = new \Memcache();
             $memcache->connect(PartKeeprConfiguration::getOption("partkeepr.cache.memcache.host", "localhost"), PartKeeprConfiguration::getOption("partkeepr.cache.memcache.port", "11211"));
             $cache = new \Doctrine\Common\Cache\MemcacheCache();
             $cache->setMemcache($memcache);
             break;
         case "default":
         case "auto":
             if (extension_loaded("xcache")) {
                 $cache = new \Doctrine\Common\Cache\XcacheCache();
             } else {
                 if (extension_loaded("apc")) {
                     $cache = new \Doctrine\Common\Cache\ApcCache();
                 } else {
                     $cache = new \Doctrine\Common\Cache\ArrayCache();
                 }
             }
             break;
         case "none":
             $cache = new \Doctrine\Common\Cache\ArrayCache();
             break;
     }
     $config->setMetadataCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     $config->setProxyDir(self::getRootDirectory() . '/data/proxies');
     $config->setProxyNamespace('Proxies');
     $config->setEntityNamespaces(self::getEntityClasses());
     $config->setAutoGenerateProxyClasses(false);
     if (PartKeeprConfiguration::getOption("partkeepr.database.echo_sql_log", false) === true) {
         $logger = new \Doctrine\DBAL\Logging\EchoSQLLogger();
         $config->setSQLLogger($logger);
     }
     self::$entityManager = EntityManager::create($connectionOptions, $config);
 }
예제 #27
0
 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']);
     });
 }
 /**
  * Configures the metadata configuration instance.
  *
  * @param Configuration $configuration
  * @param array                       $doctrineConfig
  *
  * @throws ORMException
  */
 protected function configureMetadataConfiguration(Configuration $configuration, array $doctrineConfig)
 {
     if (isset($doctrineConfig['filters'])) {
         foreach ($doctrineConfig['filters'] as $name => $filter) {
             $configuration->addFilter($name, $filter['class']);
         }
     }
     if (isset($doctrineConfig['logger'])) {
         $configuration->setSQLLogger($doctrineConfig['logger']);
     }
     if (isset($doctrineConfig['proxy']) && isset($doctrineConfig['proxy']['auto_generate'])) {
         $configuration->setAutoGenerateProxyClasses($doctrineConfig['proxy']['auto_generate']);
     }
     if (isset($doctrineConfig['proxy']) && isset($doctrineConfig['proxy']['namespace'])) {
         $configuration->setProxyNamespace($doctrineConfig['proxy']['namespace']);
     }
     if (isset($doctrineConfig['repository'])) {
         $configuration->setDefaultRepositoryClassName($doctrineConfig['repository']);
     }
     $namingStrategy = array_get($doctrineConfig, 'naming_strategy', 'Nord\\Lumen\\Doctrine\\ORM\\NamingStrategy');
     $configuration->setNamingStrategy(new $namingStrategy());
 }
 /**
  * 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;
 }
예제 #30
0
	/**
	 * Initializes the doctrine framework and
	 * sets all required configuration options.
	 * 
	 * @param none
	 * @return nothing
	 */
	public static function initializeDoctrine () {
		
		
		$config = new Configuration;
		
		$driverImpl = $config->newDefaultAnnotationDriver(
			array(__DIR__)
			//array(__DIR__."/Session")
			
			);
		$config->setMetadataDriverImpl($driverImpl);
		
		$connectionOptions = array(
		    'driver' => 	PartKeeprConfiguration::getOption("partkeepr.database.driver","pdo_mysql"),
			'dbname' => 	PartKeeprConfiguration::getOption("partkeepr.database.dbname", "partkeepr"),
			'user' => 		PartKeeprConfiguration::getOption("partkeepr.database.username", "partkeepr"),
			'password' => 	PartKeeprConfiguration::getOption("partkeepr.database.password", "partkeepr"),
			'host' => 		PartKeeprConfiguration::getOption("partkeepr.database.hostname", "localhost")
		);
		
		$cache = new \Doctrine\Common\Cache\ApcCache();
		$config->setMetadataCacheImpl($cache);

		$config->setQueryCacheImpl($cache);
		
		$config->setProxyDir(dirname(dirname(dirname(__DIR__))) . '/Proxies');
		$config->setProxyNamespace('Proxies');
		$config->setEntityNamespaces(self::getEntityClasses());
		$config->setAutoGenerateProxyClasses(false);
		
		if (PartKeeprConfiguration::getOption("partkeepr.database.echo_sql_log", false) === true) {
			$logger = new \Doctrine\DBAL\Logging\EchoSQLLogger();
			$config->setSQLLogger($logger);
		}
		
		self::$entityManager = EntityManager::create($connectionOptions, $config);
	}