public function testSetGetEntityNamespace()
{
$this->configuration->addEntityNamespace('TestNamespace', __NAMESPACE__);
$this->assertSame(__NAMESPACE__, $this->configuration->getEntityNamespace('TestNamespace'));
$namespaces = array('OtherNamespace' => __NAMESPACE__);
$this->configuration->setEntityNamespaces($namespaces);
$this->assertSame($namespaces, $this->configuration->getEntityNamespaces());
$this->setExpectedException('Doctrine\\ORM\\ORMException');
$this->configuration->getEntityNamespace('NonExistingNamespace');
}
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;
}
/**
* @return Configuration
*/
public static function createTestConfiguration()
{
$config = new Configuration();
$config->setEntityNamespaces(array('SymfonyTestsDoctrine' => 'Symfony\\Bridge\\Doctrine\\Tests\\Fixtures'));
$config->setAutoGenerateProxyClasses(true);
$config->setProxyDir(\sys_get_temp_dir());
$config->setProxyNamespace('SymfonyTests\\Doctrine');
$config->setMetadataDriverImpl(new AnnotationDriver(new AnnotationReader()));
$config->setQueryCacheImpl(new ArrayCache());
$config->setMetadataCacheImpl(new ArrayCache());
return $config;
}
/**
* Creates the EntityManager instance.
*
* @return \Doctrine\ORM\EntityManager
*/
protected static function createEntityManager()
{
$config = new DoctrineConfiguration();
// entity namespaces for the test environment
$namespaces = array('BedRest\\TestFixtures\\Models\\Company' => TESTS_BASEDIR . '/BedRest/TestFixtures/Models/Company/');
$config->setEntityNamespaces(array_keys($namespaces));
// basic Proxy config
$config->setProxyDir(TESTS_BASEDIR . '/BedRest/TestFixtures/Proxies');
$config->setProxyNamespace('BedRest\\TestFixtures\\Proxies');
// ArrayCache, to avoid persistent caching in test environment
$config->setMetadataCacheImpl(new ArrayCache());
// basic AnnotationDriver configuration for parsing Doctrine annotations
$metaDriver = new AnnotationDriver(new AnnotationReader());
$metaDriver->addPaths(array_values($namespaces));
$config->setMetadataDriverImpl($metaDriver);
// create the EntityManager
$connectionOptions = array('driver' => 'pdo_sqlite', 'path' => TESTS_BASEDIR . '/test_db.sqlite');
$em = EntityManager::create($connectionOptions, $config);
self::$doctrineEntityManager = $em;
}
public static function gerEntityManager()
{
$loader1 = new ClassLoader('Models', __DIR__ . '/../Models');
$loader1->register();
$loader2 = new ClassLoader('ModelsProxy', __DIR__ . '/../Models');
$loader2->register();
//Configuration
$config = new Configuration();
$cache = new Cache();
$config->setQueryCacheImpl($cache);
$config->setProxyDir(__DIR__ . '/../Models');
$config->setProxyNamespace('ModelsProxy');
$config->setEntityNamespaces(array('Models'));
$config->setAutoGenerateProxyClasses(TRUE);
AnnotationRegistry::registerFile(__DIR__ . "/../../vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php");
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new \Doctrine\Common\Annotations\AnnotationReader(), array(__DIR__ . '/../Models'));
$config->setMetadataDriverImpl($driver);
$config->setMetadataCacheImpl($cache);
$dbConf = self::getDataBaseParams();
//getting EntityManager
$entityManager = EntityManager::create($dbConf, $config);
return $entityManager;
}
/**
* {@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;
}
/**
* {@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;
}
/**
* 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);
}
/**
* {@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;
}
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;
}
/**
* Entidades::configuracion()
*
* Genera el proceso de configuracion y preparacion
* de los directorios de las entidades
*
* @return object
*/
private function configuracion()
{
$confg = new Configuration();
$confg->setMetadataDriverImpl($confg->newDefaultAnnotationDriver($this->dirEntidades));
$confg->setMetadataCacheImpl(new ArrayCache());
$confg->setProxyDir($this->dirProxy);
$confg->setProxyNamespace('Proxy');
$confg->setAutoGenerateProxyClasses(true);
$confg->setEntityNamespaces(array('Entidades\\' . $this->conexion . '\\' => $this->dirEntidades));
$this->entityManager($confg);
}
/**
* 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);
}
protected function setupMetadata(Configuration $config, $spec)
{
$driverImpl = $config->newDefaultAnnotationDriver($spec['metadata_paths'], $spec['simple_annotation']);
$config->setMetadataDriverImpl($driverImpl);
$config->setEntityNamespaces($spec['entity_namespaces']);
}
use Doctrine\ORM\Tools\Setup;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Configuration;
use Doctrine\Common\Cache\ArrayCache as Cache;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\ClassLoader;
$loader = new ClassLoader('Models', __DIR__ . '/src/Models');
$loader->register();
$loader = new ClassLoader('ModelsProxy', __DIR__ . '/src/Models');
$loader->register();
//Configuration
$config = new Configuration();
$cache = new Cache();
$config->setQueryCacheImpl($cache);
$config->setProxyDir(__DIR__ . '/src/Models');
$config->setProxyNamespace('ModelsProxy');
$config->setEntityNamespaces(array('Models'));
$config->setAutoGenerateProxyClasses(TRUE);
AnnotationRegistry::registerFile(__DIR__ . "/vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php");
$driver = new Doctrine\ORM\Mapping\Driver\AnnotationDriver(new Doctrine\Common\Annotations\AnnotationReader(), array(__DIR__ . '/src/Models'));
$config->setMetadataDriverImpl($driver);
$config->setMetadataCacheImpl($cache);
$confgFile = __DIR__ . '/src/minichat3des.ini';
if (file_exists($confgFile)) {
$db = parse_ini_file($confgFile);
$connectionOptions = array('driver' => $db['driver'], 'host' => $db['host'], 'user' => $db['user'], 'password' => $db['password'], 'dbname' => $db['dbname']);
} else {
echo 'Arquivo .ini de configuração não encontrado!';
}
//getting EntityManager
$entityManager = EntityManager::create($connectionOptions, $config);
