Factory method to create EntityManager instances.
|
public static create ( mixed $conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager = null ) : |
||
| $conn | mixed | An array with the connection parameters or an existing Connection instance. |
| $config | Doctrine\ORM\Configuration | The Configuration instance to use. |
| $eventManager | Doctrine\Common\EventManager | The EventManager instance to use. |
| return | The created EntityManager. | |
/**
* Because the EntityManager gets closed when there's an error, it needs to
* be created again
*
* @return EntityManager
* @throws ORMException
*/
protected function getEntityManager()
{
if (!$this->em) {
$this->em = $this->getContainer()->get('doctrine.orm.entity_manager');
}
if (!$this->em->isOpen()) {
$this->em = $this->em->create($this->em->getConnection(), $this->em->getConfiguration());
}
return $this->em;
}
public function hydrate(Jarvis $app)
{
$app['doctrine.cache'] = function () {
return new VoidCache();
};
$app['doctrine.annotation.driver'] = function () {
return new AnnotationDriver(new AnnotationReader());
};
$app['entyMgr'] = function (Jarvis $app) : EntityManagerInterface {
$settings = $app['doctrine.settings'];
$cache = $app['doctrine.cache'];
$config = Setup::createConfiguration($settings['debug'], $settings['proxies_dir'], $cache);
$driver = $app['doctrine.annotation.driver'];
if (isset($settings['entities_paths'])) {
$driver->addPaths((array) $settings['entities_paths']);
}
AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driver);
$config->setAutoGenerateProxyClasses($settings['debug']);
$config->setMetadataCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$entyMgr = EntityManager::create($settings['dbal'], $config);
if (isset($app['doctrine.orm.entyMgr.decorator']) && is_string($fqcn = $app['doctrine.orm.entyMgr.decorator']) && is_subclass_of($fqcn, EntityManagerDecorator::class)) {
$entyMgr = new $fqcn($entyMgr);
}
$entyMgr->getEventManager()->addEventListener([Events::preRemove, Events::postRemove, Events::prePersist, Events::postPersist, Events::preUpdate, Events::postUpdate, Events::postLoad, Events::preFlush, Events::onFlush, Events::postFlush, Events::onClear], new EventListener($app));
$app->broadcast(DoctrineReadyEvent::READY_EVENT, new DoctrineReadyEvent($entyMgr));
return $entyMgr;
};
$app['db_conn'] = function ($app) {
$app['entyMgr']->getConnection();
};
$app->lock(['entyMgr', 'db_conn', 'doctrine.annotation.driver']);
}
protected function getMockEntityManager()
{
$driver = $this->getMock('Doctrine\DBAL\Driver');
$driver->expects($this->once())
->method('getDatabasePlatform')
->will($this->returnValue($this->getMock('Doctrine\DBAL\Platforms\MySqlPlatform')));
$conn = $this->getMock('Doctrine\DBAL\Connection', array(), array(array(), $driver));
$conn->expects($this->once())
->method('getEventManager')
->will($this->returnValue($this->getMock('Doctrine\Common\EventManager')));
$config = $this->getMock('Doctrine\ORM\Configuration');
$config->expects($this->once())
->method('getProxyDir')
->will($this->returnValue('test'));
$config->expects($this->once())
->method('getProxyNamespace')
->will($this->returnValue('Proxies'));
$config->expects($this->once())
->method('getMetadataDriverImpl')
->will($this->returnValue($this->getMock('Doctrine\ORM\Mapping\Driver\DriverChain')));
$em = EntityManager::create($conn, $config);
return $em;
}
public function __construct()
{
try {
$conn = array("driver" => "pdo_mysql", "host" => "localhost", "port" => "3306", "user" => "root", "password" => "", "dbname" => "controle_gastos");
/*
var_dump(__DIR__);
var_dump(PP);
exit;
*/
$loader = new \Doctrine\Common\ClassLoader("Entities", __DIR__);
$loader->register();
$config = Setup::createAnnotationMetadataConfiguration(array("../../" . __DIR__ . "/app/models"), false);
$em = EntityManager::create($conn, $config);
$cmf = new DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
$em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string');
$em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
$driver = new DatabaseDriver($em->getConnection()->getSchemaManager());
$em->getConfiguration()->setMetadataDriverImpl($driver);
$metadata = $cmf->getAllMetadata();
$generator = new EntityGenerator();
$generator->setGenerateAnnotations(true);
$generator->setGenerateStubMethods(true);
$generator->setRegenerateEntityIfExists(true);
$generator->setUpdateEntityIfExists(true);
$generator->generate($metadata, "../../" . __DIR__ . "/app/models");
} catch (\Exception $e) {
throw $e;
}
}
public function _initDoctrineEntityManager()
{
$this->bootstrap(array('classLoaders'));
$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
$configuration->setMetadataDriverImpl($configuration->newDefaultAnnotationDriver($zendConfig['doctrine']['entityPath']));
// 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;
}
/**
* @return EntityManager
* @throws ServiceNotRegisteredException
*/
public static function getEntityManager()
{
if (ServiceLocator::$entityManager === null) {
ServiceLocator::$entityManager = EntityManager::create(['driver' => Config::DB_DRIVER, 'host' => Config::DB_HOST, 'dbname' => Config::DB_NAME, 'user' => Config::DB_USER, 'password' => Config::DB_PASS], Setup::createAnnotationMetadataConfiguration([__DIR__ . '/../Models'], Config::DEV_MODE, null, null, false));
}
return ServiceLocator::checkAndReturn(ServiceLocator::$entityManager);
}
public function register()
{
$this->container['object_manager'] = function () {
$development = false;
if (defined('ENVIRONMENT') && ENVIRONMENT === 'development') {
$development = true;
}
$config = new Configuration();
if ($development) {
$cache = new ArrayCache();
} else {
$cache = new ApcCache();
}
$config->setMetadataCacheImpl($cache);
$mappings = $this->container->get('config')['orm']['mappings'];
$config->setMetadataDriverImpl(new XmlDriver($mappings));
$proxyDir = $this->container->get('config')['orm']['proxy_dir'];
$config->setProxyDir($proxyDir);
$config->setQueryCacheImpl($cache);
$config->setProxyNamespace('Jirro\\ORM\\Proxies');
if ($development) {
$config->setAutoGenerateProxyClasses(true);
} else {
$config->setAutoGenerateProxyClasses(false);
}
$dbConnection = $this->container->get('db_connection');
$objectManager = ObjectManager::create($dbConnection, $config);
return $objectManager;
};
$this->container->inflector('Jirro\\Component\\ORM\\ObjectManagerAwareInterface')->invokeMethod('setObjectManager', ['object_manager']);
}
public function createService(ServiceLocatorInterface $serviceLocator)
{
$config = $serviceLocator->get('config');
// The parameters in Doctrine 2 and ZF2 are slightly different.
// Below is an example how we can reuse the db settings
$doctrineDbConfig = (array) $config['db'];
$doctrineDbConfig['driver'] = strtolower($doctrineDbConfig['driver']);
if (!isset($doctrineDbConfig['dbname'])) {
$doctrineDbConfig['dbname'] = $doctrineDbConfig['database'];
}
if (!isset($doctrineDbConfig['host'])) {
$doctrineDbConfig['host'] = $doctrineDbConfig['hostname'];
}
if (!isset($doctrineDbConfig['user'])) {
$doctrineDbConfig['user'] = $doctrineDbConfig['username'];
}
$doctrineConfig = Setup::createAnnotationMetadataConfiguration($config['doctrine']['entity_path'], true);
$entityManager = DoctrineEntityManager::create($doctrineDbConfig, $doctrineConfig);
if (isset($config['doctrine']['initializers'])) {
$eventManager = $entityManager->getEventManager();
foreach ($config['doctrine']['initializers'] as $initializer) {
$eventClass = new DoctrineEvent(new $initializer(), $serviceLocator);
$eventManager->addEventListener(\Doctrine\ORM\Events::postLoad, $eventClass);
}
}
if ($serviceLocator->has('doctrine-profiler')) {
$profiler = $serviceLocator->get('doctrine-profiler');
$entityManager->getConfiguration()->setSQLLogger($profiler);
}
return $entityManager;
}
/**
* Creates a new EntityManager instance based on the provided configuration.
*
* $factory = new Doctrine_EMFactory;
* $em = $factory->entity_manager();
*
* @param string $db_group the name of the Kohana database config group to get connection information from
*
* @return \Doctrine\ORM\EntityManager
*/
public function entity_manager($db_group = 'default')
{
$config = $this->config->load('doctrine');
// Ensure the composer autoloader is registered
require_once $config['composer_vendor_path'] . 'autoload.php';
// Create the Configuration class
$orm_config = new Configuration();
// Create the metadata driver
$driver = $this->create_annotation_driver();
$orm_config->setMetadataDriverImpl($driver);
// Configure the proxy directory and namespace
$orm_config->setProxyDir($config['proxy_dir']);
$orm_config->setProxyNamespace($config['proxy_namespace']);
if ($config->get('use_underscore_naming_strategy')) {
$naming_strategy = new UnderscoreNamingStrategy($config->get('case_underscore_naming_strategy'));
$orm_config->setNamingStrategy($naming_strategy);
}
// Configure environment-specific options
if ($this->environment === Kohana::DEVELOPMENT) {
$orm_config->setAutoGenerateProxyClasses(TRUE);
$cache = new ArrayCache();
} else {
$orm_config->setAutoGenerateProxyClasses(FALSE);
$cache = new ApcCache();
}
// Set the cache drivers
$orm_config->setMetadataCacheImpl($cache);
$orm_config->setQueryCacheImpl($cache);
// Create the Entity Manager with the database connection information
$em = EntityManager::create($this->get_connection_config($db_group), $orm_config);
$this->register_custom_types($config);
return $em;
}
/**
* @return \Doctrine\ORM\EntityManager
*/
protected function createEntityManager()
{
// event manager used to create schema before tests
$eventManager = new EventManager();
$eventManager->addEventListener(array("preTestSetUp"), new SchemaSetupListener());
// doctrine xml configs and namespaces
$configPathList = array();
if (is_dir(__DIR__ . '/../Resources/config/doctrine')) {
$dir = __DIR__ . '/../Resources/config/doctrine';
$configPathList[] = $dir;
$prefixList[$dir] = 'Kitpages\\DataGridBundle\\Entities';
}
if (is_dir(__DIR__ . '/_doctrine/config')) {
$dir = __DIR__ . '/_doctrine/config';
$configPathList[] = $dir;
$prefixList[$dir] = 'Kitpages\\DataGridBundle\\Tests\\TestEntities';
}
// create drivers (that reads xml configs)
$driver = new \Symfony\Bridge\Doctrine\Mapping\Driver\XmlDriver($configPathList);
$driver->setNamespacePrefixes($prefixList);
// create config object
$config = new Configuration();
$config->setMetadataCacheImpl(new ArrayCache());
$config->setMetadataDriverImpl($driver);
$config->setProxyDir(__DIR__ . '/TestProxies');
$config->setProxyNamespace('Kitpages\\DataGridBundle\\Tests\\TestProxies');
$config->setAutoGenerateProxyClasses(true);
//$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
// create entity manager
$em = EntityManager::create(array('driver' => 'pdo_sqlite', 'path' => "/tmp/sqlite-test.db"), $config, $eventManager);
return $em;
}
private function loadDoctrineOrm(Application $app)
{
$self = $this;
$app['db.orm.em'] = $app->share(function () use($self, $app) {
return EntityManager::create($app['db'], $app['db.orm.config']);
});
}
/**
* @param array $database
* @throws \Exception
*/
public function __construct($database = [])
{
$this->db = $database;
foreach ($this->db as $key => $db) {
$this->allDb[$key] = function () use($db) {
$db['dev'] = isset($db['dev']) && $db['dev'] ? true : false;
if (isset($db['db_url'])) {
$dbParams = array('url' => $db['db_url']);
} else {
if (!isset($db['driver']) || !isset($db['user']) || !isset($db['pass']) || !isset($db['host']) || !isset($db['db'])) {
throw new \Exception('Missing arguments for doctrine constructor');
}
$dbParams = array('driver' => $this->getDriver($db['driver']), 'user' => $db['user'], 'password' => $db['pass'], 'host' => $db['host'], 'dbname' => $db['db'], 'charset' => isset($db['charset']) ? $db['charset'] : 'utf8');
}
$evm = new EventManager();
if (isset($db['prefix'])) {
$tablePrefix = new TablePrefix($db['prefix']);
$evm->addEventListener(Events::loadClassMetadata, $tablePrefix);
}
$config = Setup::createAnnotationMetadataConfiguration($db['path'], $db['dev']);
if (!$db['dev']) {
$config->setQueryCacheImpl($db['cache']);
$config->setResultCacheImpl($db['cache']);
$config->setMetadataCacheImpl($db['cache']);
}
if (isset($db['functions']) && !empty($db['functions'])) {
$config->setCustomDatetimeFunctions($db['functions']['customDatetimeFunctions']);
$config->setCustomNumericFunctions($db['functions']['customNumericFunctions']);
$config->setCustomStringFunctions($db['functions']['customStringFunctions']);
}
return EntityManager::create($dbParams, $config, $evm);
};
}
}
public function __construct($setConfigFiles = true)
{
if ($setConfigFiles) {
$this->configFile = __DIR__ . '/../../../config.php';
$this->localConfigFile = __DIR__ . '/../../../config.local.php';
}
parent::__construct();
$isDevMode = false;
$cache = new \Doctrine\Common\Cache\FilesystemCache(__DIR__ . '/../../tmp');
$config = Setup::createConfiguration($isDevMode, __DIR__ . '/../../tmp', $cache);
$config->setProxyDir(__DIR__ . '/../../tmp');
$config->setProxyNamespace('MyProject\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$paths = [__DIR__ . '/../Entity'];
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new AnnotationReader(), $paths);
\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driver);
//$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$conn = ['driver' => 'mysqli', 'host' => '127.0.0.1', 'user' => $this->databaseFactory->getUserName(), 'password' => $this->databaseFactory->getPassword(), 'dbname' => $this->databaseFactory->getDatabaseName()];
$this->entityManager = EntityManager::create($conn, $config);
$this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
\Doctrine\DBAL\Types\Type::addType('enum', StringType::class);
$this->entityManager->getConfiguration()->addCustomStringFunction('DATE', DateFunction::class);
$this->user = $this->entityManager->createQueryBuilder()->select('u')->from(Sources\Tests\Entity\User::class, 'u');
}
public function register(Application $app)
{
$dbConnection = array('driver' => 'pdo_mysql', 'host' => 'localhost', 'user' => 'root', 'password' => 'password', 'dbname' => 'icfs');
$config = \Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration(array(__DIR__ . "/Model"), true);
$app['db.em'] = \Doctrine\ORM\EntityManager::create($dbConnection, $config);
$app->register(new \Silex\Provider\DoctrineServiceProvider(), array('db.options' => $dbConnection));
}
/**
* @param array $settings
* @param bool $debug
* @return EntityManager
* @throws \Doctrine\ORM\ORMException
*/
public static function factory($settings, $debug = true)
{
if ($debug || !function_exists('apc_fetch')) {
$cache = new ArrayCache();
} else {
$cache = new ApcCache();
}
$dbSettings = $settings['doctrine'];
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
// Do not use default Annotation driver
$driverImpl = new AnnotationDriver(new AnnotationReader(), $dbSettings['entities']);
// Allow all annotations
AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
$config->setProxyDir($dbSettings['proxy_path']);
$config->setProxyNamespace('Zaralab\\Doctrine\\Proxies');
if ($debug) {
$config->setAutoGenerateProxyClasses(true);
} else {
$config->setAutoGenerateProxyClasses(false);
}
$connectionOptions = $dbSettings['dbal'];
return EntityManager::create($connectionOptions, $config);
}
/**
* @param ServiceLocatorInterface $serviceLocator
* @return \Doctrine\ORM\EntityManager
* @throws \Doctrine\ORM\ORMException
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$config = $serviceLocator->get('config');
//set the Doctrine configuration array
$doctrineDbSettings = (array) $config['db'];
$doctrineDbSettings['driver'] = strtolower($config['db']['driver']);
$doctrineDbSettings['dbname'] = isset($config['db']['database']) ? $config['db']['database'] : null;
$doctrineDbSettings['host'] = isset($config['db']['hostname']) ? $config['db']['hostname'] : null;
$doctrineDbSettings['user'] = isset($config['db']['username']) ? $config['db']['username'] : null;
$proxyPath = isset($config['doctrine']['proxy_dir']) ? $config['doctrine']['proxy_dir'] : null;
$isDevMode = isset($config['doctrine']['is_dev_mode']) ? $config['doctrine']['is_dev_mode'] : false;
$doctrineConfig = Setup::createAnnotationMetadataConfiguration($config['doctrine']['entity_path'], $isDevMode, $proxyPath);
$doctrineConfig->setAutoGenerateProxyClasses(true);
$doctrineEntityManager = DocEManager::create($doctrineDbSettings, $doctrineConfig);
if (isset($config['doctrine']['initializers'])) {
$eventManager = $doctrineEntityManager->getEventManager();
foreach ($config['doctrine']['initializers'] as $initializer) {
$eventClass = new DoctrineEvent(new $initializer(), $serviceLocator);
$eventManager->addEventListener(\Doctrine\ORM\Events::postLoad, $eventClass);
}
}
if ($doctrineDbSettings['driver'] == 'pdo_sqlite') {
//it is very important to make sure foreign keys are on with SQLite
$query = $doctrineEntityManager->createNativeQuery("pragma foreign_keys=1", new \Doctrine\ORM\Query\ResultSetMapping());
$query->execute();
}
return $doctrineEntityManager;
}
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;
}
protected static function getEntityManager($options)
{
$config = new \Doctrine\ORM\Configuration();
// Handling for class names specified as platform types.
if ($options['conn']['platform']) {
$class_obj = new \ReflectionClass($options['conn']['platform']);
$options['conn']['platform'] = $class_obj->newInstance();
}
// Special handling for the utf8mb4 type.
if ($options['conn']['driver'] == 'pdo_mysql' && $options['conn']['charset'] == 'utf8mb4') {
$options['conn']['platform'] = new \DF\Doctrine\Platform\MysqlUnicode();
}
$metadata_driver = $config->newDefaultAnnotationDriver($options['modelPath']);
$config->setMetadataDriverImpl($metadata_driver);
$cache = new \DF\Doctrine\Cache();
// $cache->setNamespace('doctrine_');
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setProxyDir($options['proxyPath']);
$config->setProxyNamespace($options['proxyNamespace']);
if (isset($options['conn']['debug']) && $options['conn']['debug']) {
$config->setSQLLogger(new \DF\Doctrine\Logger\EchoSQL());
}
$config->addFilter('softdelete', '\\DF\\Doctrine\\Filter\\SoftDelete');
$config->addCustomNumericFunction('RAND', '\\DF\\Doctrine\\Functions\\Rand');
$evm = new \Doctrine\Common\EventManager();
$em = \Doctrine\ORM\EntityManager::create($options['conn'], $config, $evm);
$em->getFilters()->enable("softdelete");
// Try the connection before rendering the page.
$em->getConnection()->connect();
return $em;
}
public function __construct($configDir, $environment = 'dev')
{
if (!@file_exists("{$configDir}/config.yml")) {
throw new \Exception("File: {$configDir}/config.yml does not exist.");
}
if (!@file_exists("{$configDir}/config_{$environment}.yml")) {
throw new \Exception("File: {$configDir}/config_{$environment}.yml does not exist.");
}
try {
$config = Yaml\Yaml::parse("{$configDir}/config.yml");
$configEnv = Yaml\Yaml::parse("{$configDir}/config_{$environment}.yml");
} catch (Yaml\Exception\ParseException $e) {
throw new \Exception($e->getMessage());
}
$this->config = Arr::merge($config, $configEnv);
$entityPaths = Arr::get($this->config, 'doctrine.entity.paths', array());
$proxiesPath = Arr::get($this->config, 'doctrine.proxy.path', '');
$proxiesNamespace = Arr::get($this->config, 'doctrine.proxy.namespace', '');
$database = Arr::get($this->config, 'doctrine.database', array());
$isDevMode = Arr::get($this->config, 'doctrine.isDevMode', TRUE);
$this->cache = new \Doctrine\Common\Cache\ArrayCache();
$this->reader = new AnnotationReader();
$this->driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($this->reader, $entityPaths);
$this->config = Setup::createAnnotationMetadataConfiguration($entityPaths, $isDevMode);
$this->config->setMetadataCacheImpl($this->cache);
$this->config->setQueryCacheImpl($this->cache);
$this->config->setMetadataDriverImpl($this->driver);
$this->config->setProxyDir($proxiesPath);
$this->config->setProxyNamespace($proxiesNamespace);
$this->config->setAutoGenerateProxyClasses($isDevMode);
$this->entityManager = EntityManager::create($database, $this->config);
$this->platform = $this->entityManager->getConnection()->getDatabasePlatform();
$this->platform->registerDoctrineTypeMapping('enum', 'string');
}
protected function setUp()
{
parent::setUp();
$this->connection = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'path' => self::SQLITE_PATH], new Configuration());
$config = Setup::createAnnotationMetadataConfiguration([__DIR__ . '/../..'], true);
$this->entityManager = EntityManager::create($this->connection, $config);
}
public function __construct(Configuration $configuration)
{
$driver = new PHPDriver(__DIR__ . '/../Mapping/');
$config = Setup::createConfiguration($configuration['debug']);
$config->setMetadataDriverImpl($driver);
$this->entityManager = EntityManager::create($configuration['database']['write_connection'], $config);
}
public function register(Application $app)
{
//Load Doctrine Configuration
$app['db.configuration'] = $app->share(function () use($app) {
AnnotationRegistry::registerAutoloadNamespace("Doctrine\\ORM\\Mapping", __DIR__ . '/../../../../../doctrine/orm/lib');
$config = new ORMConfiguration();
$cache = $app['debug'] == false ? new ApcCache() : new ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$chain = new DriverChain();
foreach ((array) $app['db.orm.entities'] as $entity) {
switch ($entity['type']) {
case 'annotation':
$reader = new AnnotationReader();
$driver = new AnnotationDriver($reader, (array) $entity['path']);
$chain->addDriver($driver, $entity['namespace']);
break;
/*case 'yml':
$driver = new YamlDriver((array)$entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array)$entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;*/
/*case 'yml':
$driver = new YamlDriver((array)$entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array)$entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;*/
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $type));
break;
}
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['db.orm.proxies_dir']);
$config->setProxyNamespace($app['db.orm.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['db.orm.auto_generate_proxies']);
return $config;
});
//Set Defaut Configuration
$defaults = array('entities' => array(array('type' => 'annotation', 'path' => 'Entity', 'namespace' => 'Entity')), 'proxies_dir' => 'cache/doctrine/Proxy', 'proxies_namespace' => 'DoctrineProxy', 'auto_generate_proxies' => true);
foreach ($defaults as $key => $value) {
if (!isset($app['db.orm.' . $key])) {
$app['db.orm.' . $key] = $value;
}
}
$self = $this;
$app['db.orm.em'] = $app->share(function () use($self, $app) {
return EntityManager::create($app['db'], $app['db.configuration']);
});
}
public function register(Application $app)
{
$app['orm.em.paths'] = $app->share(function () {
return array();
});
$app['orm.event_manager'] = $app->share(function () use($app) {
return new EventManager();
});
$app['orm.config'] = $app->share(function () use($app) {
return Setup::createConfiguration($app['debug']);
});
$app['orm.anotation_reader'] = $app->share(function () use($app) {
$annotationReader = new AnnotationReader();
$cache = $app['orm.config']->getMetadataCacheImpl();
return new CachedReader($annotationReader, $cache);
});
$app['orm.default_anotation_driver'] = $app->share(function () use($app) {
AnnotationRegistry::registerFile($app['vendor_dir'] . '/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
return new AnnotationDriver($app['orm.anotation_reader'], $app['orm.em.paths']);
});
$app['orm.em'] = $app->share(function () use($app) {
$annotationReader = $app['orm.anotation_reader'];
$eventManager = $app['orm.event_manager'];
$driverChain = new MappingDriverChain();
$driverChain->setDefaultDriver($app['orm.default_anotation_driver']);
DoctrineExtensions::registerMappingIntoDriverChainORM($driverChain, $annotationReader);
$loggableListener = new LoggableListener();
$loggableListener->setAnnotationReader($annotationReader);
$loggableListener->setUsername('admin');
$eventManager->addEventSubscriber($loggableListener);
$config = $app['orm.config'];
$config->setMetadataDriverImpl($driverChain);
return EntityManager::create($app['db.default_options'], $config, $eventManager);
});
}
public function __invoke(ContainerInterface $container)
{
if (!$container->has(Configuration::class) || !$container->has(EventManager::class) || !$container->has(Connection::class)) {
throw new ContainerNotRegisteredException('Doctrine\\Common\\EventManager::class,
Doctrine\\ORM\\Configuration::class and Doctrine\\DBAL\\Connection::class
must be registered in the container');
}
$config = $container->has('config') ? $container->get('config') : [];
$underscoreNamingStrategy = isset($config['doctrine']['orm']['underscore_naming_strategy']) ? $config['doctrine']['orm']['underscore_naming_strategy'] : false;
/** @var Configuration $configuration */
$configuration = $container->get(Configuration::class);
$configuration->setProxyDir(isset($config['doctrine']['orm']['proxy_dir']) ? $config['doctrine']['orm']['proxy_dir'] : 'data/cache/EntityProxy');
$configuration->setProxyNamespace(isset($config['doctrine']['orm']['proxy_namespace']) ? $config['doctrine']['orm']['proxy_namespace'] : 'EntityProxy');
$configuration->setAutoGenerateProxyClasses(isset($config['doctrine']['orm']['auto_generate_proxy_classes']) ? $config['doctrine']['orm']['auto_generate_proxy_classes'] : false);
// ORM mapping by Annotation
AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$driver = new AnnotationDriver(new AnnotationReader(), ['data/cache/doctrine']);
$configuration->setMetadataDriverImpl($driver);
// Cache
$cache = $container->get(Cache::class);
$configuration->setQueryCacheImpl($cache);
$configuration->setResultCacheImpl($cache);
$configuration->setMetadataCacheImpl($cache);
return EntityManager::create($container->get(Connection::class), $configuration, $container->get(EventManager::class));
}
/**
* Initialize Doctrine
* @return Doctrine_Manager
*/
public function _initDoctrine()
{
// include and register Doctrine's class loader
require_once 'Doctrine/Common/ClassLoader.php';
$classLoader = new \Doctrine\Common\ClassLoader('Doctrine', APPLICATION_PATH . '/../library/');
$classLoader->register();
// create the Doctrine configuration
$config = new \Doctrine\ORM\Configuration();
// setting the cache ( to ArrayCache. Take a look at
// the Doctrine manual for different options ! )
$cache = new \Doctrine\Common\Cache\ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
// choosing the driver for our database schema
// we'll use annotations
$driver = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/models');
$config->setMetadataDriverImpl($driver);
// set the proxy dir and set some options
$config->setProxyDir(APPLICATION_PATH . '/models/Proxies');
$config->setAutoGenerateProxyClasses(true);
$config->setProxyNamespace('App\\Proxies');
// now create the entity manager and use the connection
// settings we defined in our application.ini
$connectionSettings = $this->getOption('doctrine');
$conn = array('driver' => $connectionSettings['conn']['driv'], 'user' => $connectionSettings['conn']['user'], 'password' => $connectionSettings['conn']['pass'], 'dbname' => $connectionSettings['conn']['dbname'], 'host' => $connectionSettings['conn']['host']);
$entityManager = \Doctrine\ORM\EntityManager::create($conn, $config);
// push the entity manager into our registry for later use
$registry = Zend_Registry::getInstance();
$registry->entitymanager = $entityManager;
return $entityManager;
}
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);
}
public function setUp()
{
$this->_oldEntityManager = \SoliantEntityAudit\Module::getModuleOptions()->getEntityManager();
$this->_oldAuditedClassNames = \SoliantEntityAudit\Module::getModuleOptions()->getAuditedClassNames();
$this->_oldJoinClasses = \SoliantEntityAudit\Module::getModuleOptions()->resetJoinClasses();
$isDevMode = false;
$config = Setup::createConfiguration($isDevMode, null, null);
$chain = new DriverChain();
// Use ZFC User for authentication tests
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuser'), 'ZfcUser\\Entity');
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuserdoctrineorm'), 'ZfcUserDoctrineORM\\Entity');
$chain->addDriver(new StaticPHPDriver(__DIR__ . "/../Models"), 'SoliantEntityAuditTest\\Models\\LogRevision');
$chain->addDriver(new AuditDriver('.'), 'SoliantEntityAudit\\Entity');
$config->setMetadataDriverImpl($chain);
// Replace entity manager
$moduleOptions = \SoliantEntityAudit\Module::getModuleOptions();
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$moduleOptions->setAuditedClassNames(array('SoliantEntityAuditTest\\Models\\LogRevision\\Album' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Performer' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Song' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\SingleCoverArt' => array()));
$entityManager = EntityManager::create($conn, $config);
$moduleOptions->setEntityManager($entityManager);
$schemaTool = new SchemaTool($entityManager);
// Add auditing listener
$entityManager->getEventManager()->addEventSubscriber(new LogRevision());
$sql = $schemaTool->getUpdateSchemaSql($entityManager->getMetadataFactory()->getAllMetadata());
#print_r($sql);die();
$schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata());
$this->_em = $entityManager;
}
public function register(Application $app)
{
$paths = array(realpath($app['config']['doctrine']['paths']['entity']));
$isDevMode = $app['config']['doctrine']['devMode'];
$config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode, null, null, false);
$app['doctrine'] = EntityManager::create($app['config']['doctrine']['db'], $config);
}
private function initDB()
{
require_once APPPATH . 'config/database.php';
// Database connection information
$dbParams = array('driver' => 'pdo_mysql', 'user' => "helpie38_neo", 'password' => "x#rnoPA;P}74", 'host' => "localhost", 'dbname' => "helpie38_main");
$path = array(APPPATH . 'BusinessLogic/Models/Entities');
$config = Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration($path, true);
$config->addEntityNamespace("Entities", 'BusinessLogic\\Models\\Entities');
// $config->setResultCacheImpl(new \Doctrine\Common\Cache\ApcCache());
// $config->setQueryCacheImpl(new \Doctrine\Common\Cache\ApcCache());
// $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ApcCache());
//$config->setProxyDir("NeoMvc/Proxy");
//$config->setProxyNamespace("Proxy");
// $config->setResultCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
// $config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
// $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
require_once APPPATH . "libraries/UVd/DoctrineFunction/DateFormat.php";
$config->addCustomStringFunction("DATE_FORMAT", "\\UVd\\DoctrineFunction\\DateFormat");
$config->setAutoGenerateProxyClasses(true);
$em = EntityManager::create($dbParams, $config);
try {
// $this->updateSchema($em);
} catch (\Exception $e) {
echo $e->getMessage();
}
return $em;
}
public static function _init_manager($connection)
{
$settings = static::connection_settings($connection);
$config = new \Doctrine\ORM\Configuration();
$cache = static::_init_cache($settings);
if ($cache) {
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
}
$config->setProxyDir($settings['proxy_dir']);
$config->setProxyNamespace($settings['proxy_namespace']);
$config->setAutoGenerateProxyClasses(\Arr::get($settings, 'auto_generate_proxy_classes', false));
$config->setMetadataDriverImpl(static::_init_metadata($config, $settings));
$EventManager = new \Doctrine\Common\EventManager();
static::$_managers[$connection] = \Doctrine\ORM\EntityManager::create($settings['connection'], $config, $EventManager);
if (!empty($settings['profiling'])) {
static::$_managers[$connection]->getConnection()->getConfiguration()->setSQLLogger(new Doctrine\Logger($connection));
}
// Connection init callback
if (!empty($settings['init_callback'])) {
// If array merge combined this numeric array, grab last two array elements as the real callback
if (is_array($settings['init_callback']) && count($settings['init_callback']) > 2) {
$settings['init_callback'] = array_slice($settings['init_callback'], -2);
}
call_user_func($settings['init_callback'], static::$_managers[$connection], $connection);
}
}
