/** * Enable this listener for the given entity * This will apply the number generator when this entity will be flushed. * * @param SequenceSubjectInterface $subject */ public function enableEntity(SequenceSubjectInterface $subject) { $this->entitiesEnabled[spl_object_hash($subject)] = $subject; if (!$this->listenerEnabled) { $this->eventManager->addEventListener(Events::preFlush, $this); $this->listenerEnabled = true; } }
/** * @return DoctrineEventManager */ public function configureEventManager() { $eventConfiguration = $this->configuration->get('events'); foreach ($eventConfiguration['listeners'] as $listener => $events) { $this->eventManager->addEventListener((array) $events, new $listener()); } foreach ($eventConfiguration['subscribers'] as $subscriber) { $this->eventManager->addEventSubscriber(new $subscriber()); } return $this->eventManager; }
public static function getEntityManager($smart = FALSE, $path_to_entity = null, $proxyPath = null, $proxyNamespace = null) { if (empty(self::$em)) { if ($path_to_entity === NULL) { //$path_to_entity = PATH_ROOT . '/' . Sokol::getApp()->name . '/Entity'; $path_to_entity = PATH_ROOT . '/Entity'; } $isDev = Sokol::getApp()->isDev; $connectionParams = Sokol::getConfig('db'); //---Table Prefix--- $tablePrefix = !empty($connectionParams['tablePrefix']) ? $connectionParams['tablePrefix'] : null; if ($tablePrefix) { $evm = new EventManager(); $tablePrefix = new TablePrefix($tablePrefix); $evm->addEventListener(Events::loadClassMetadata, $tablePrefix); } //---/Table Prefix--- if ($smart) { self::$em = self::getEmSmart($path_to_entity, $isDev, $connectionParams, $evm); } else { if ($proxyPath === NULL) { $proxyPath = PATH_ROOT . '/' . Sokol::getApp()->name . '/Proxy'; } if ($proxyNamespace === NULL) { $proxyNamespace = Sokol::getApp()->getNamespace() . '\\Proxy'; } self::$em = self::getEm($path_to_entity, $isDev, $connectionParams, $evm, $proxyPath, $proxyNamespace); } //подключаем тип данных "html" Type::addType('html', 'Sokol\\Doctrine\\Extension\\HtmlType'); self::$em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('db_html', 'html'); } return self::$em; }
/** * Executa as configurações iniciais e prepara o a entidade responsáveç * da biblioteca escolhida para ORM. */ public function init() { $config = Config::getInstance(); $paths = [SYS_ROOT . 'App' . DS . 'Models' . DS]; $dev_mode = $config->get('database.debug'); $conn_params = $this->loadConfiguration(); $doctrine_config = Setup::createAnnotationMetadataConfiguration($paths, $dev_mode); if ($config->get('cache.cache')) { try { $cache = Cache::getInstance(); if ($cache instanceof Cache) { $doctrine_config->setResultCacheImpl($cache->getDriver()); } } catch (\Exception $e) { $error = new Error(); $error->log($e); } } $proxy_dir = SYS_ROOT . 'App' . DS . 'Models' . DS . 'Proxies'; if (!is_dir($proxy_dir)) { if (mkdir($proxy_dir)) { $doctrine_config->setProxyDir($proxy_dir); } } $prefix = $config->get('database.connection.table_prefix'); if ($prefix != '') { $evm = new EventManager(); $table_prefix = new DoctrineTablePrefix($prefix); $evm->addEventListener(Events::loadClassMetadata, $table_prefix); $this->entityManager = EntityManager::create($conn_params, $doctrine_config, $evm); } else { $this->entityManager = EntityManager::create($conn_params, $doctrine_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); }; } }
/** * @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; }
/** * {@inheritdoc} */ public static function create($conn, Configuration $config, EventManager $eventManager = null) { if (!$config->getMetadataDriverImpl()) { throw ORMException::missingMappingDriverImpl(); } switch (true) { case is_array($conn): if (!$eventManager) { $eventManager = new EventManager(); } if (isset($conn['prefix']) && $conn['prefix']) { $eventManager->addEventListener(Events::loadClassMetadata, new TablePrefix($conn['prefix'])); } $conn = \Doctrine\DBAL\DriverManager::getConnection($conn, $config, $eventManager); break; case $conn instanceof Connection: if ($eventManager !== null && $conn->getEventManager() !== $eventManager) { throw ORMException::mismatchedEventManager(); } break; default: throw new \InvalidArgumentException("Invalid argument: " . $conn); } return new self($conn, $config, $conn->getEventManager()); }
public function testEventArgsNamespaceTest() { $listener = new ListenerStub(); $manager = new EventManager(); $manager->addEventListener(\Doctrine\MongoDB\Events::preConnect, $listener); $connection = new Connection(null, [], null, $manager); $connection->initialize(); }
/** * * @return \Doctrine\Common\EventManager */ protected function getEvent() { $options = config('database')['connections']['mysql']; $evm = new EventManager(); $tablePrefix = new \PanGuKTD\LaravelDoctrineORM\Listeners\TablePrefixListener($options['prefix']); $evm->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $tablePrefix); return $evm; }
/** * Add doctrine event manager lifecycle listener * @param $events Array of Event constants to listen to * @param object $listener The listener object. * @throws \Exception * @return $this */ public function addLifecycleEventListener($events = array(), $listener) { if (empty($this->entityManager)) { throw new \Exception('Please establish the entity manager connection using getEntityManager prior to adding event listeners'); } $this->eventManager->addEventListener($events, $listener); return $this; }
protected function setUp() { $ev = new EventManager(); $ev->addEventListener(Events::prePersist, new \stdClass()); $lr = new ListenerResolver(); $this->md = new ClassMetadata('Test'); $this->md->documentListeners[Events::prePersist] = []; $this->md->lifecycleCallbacks[Events::prePersist] = []; $this->li = new ListenersInvoker($ev, $lr); }
/** * @return EntityManager */ private static function createEntityManager() { $config = \Doctrine\ORM\Tools\Setup::createConfiguration(true); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver([__DIR__ . '/../../../../src/Driver/Doctrine/ORM/Entity', __DIR__ . '/Entity'], false)); $rtel = new ResolveTargetEntityListener(); $rtel->addResolveTargetEntity('FOS\\Message\\Model\\PersonInterface', 'FOS\\Message\\Tests\\Driver\\Doctrine\\ORM\\Entity\\TestPerson', []); $evm = new EventManager(); $evm->addEventListener(Events::loadClassMetadata, $rtel); $dbParams = ['driver' => 'pdo_sqlite', 'path' => self::$dbFile]; return \Doctrine\ORM\EntityManager::create($dbParams, $config, $evm); }
/** * Create an entity manager * * @param array $params Parameters * @return object Entity manager * @filter */ protected function createEntityManager() { $configuration = Setup::createAnnotationMetadataConfiguration([$this->_config['models']], Environment::is('development'), $this->_config['proxies'], isset($this->_config['cache']) ? call_user_func($this->_config['cache']) : null); $configuration->setProxyNamespace($this->_config['proxyNamespace']); $eventManager = new EventManager(); $eventManager->addEventListener([Events::postLoad, Events::prePersist, Events::preUpdate], $this); $connection = $this->connectionSettings; $params = compact('connection', 'configuration', 'eventManager'); return $this->_filter(__METHOD__, $params, function ($self, $params) { return EntityManager::create($params['connection'], $params['configuration'], $params['eventManager']); }); }
public static function setUpBeforeClass() { self::$connection = new MysqlPersistentConnection(); $params = self::$connection->getConnectionParams(); $configuration = Setup::createConfiguration(true); $event_manager = new EventManager(); $annotation_reader = new AnnotationReader(); $configuration->setMetadataDriverImpl(new AnnotationDriver($annotation_reader, [__DIR__ . '/Entity'])); $annotation_metadata_provider = new EntityAnnotationMetadataProvider($annotation_reader); $mutation_metadata_provider = new EntityMutationMetadataProvider($annotation_reader); $entity_changed_listener = new EntityChangedListener($annotation_metadata_provider, $mutation_metadata_provider); $mutation_resolver = new MutationResolver($annotation_metadata_provider); $mutation_listener = new MutationListener($mutation_resolver); $event_manager->addEventListener('prePersist', $entity_changed_listener); $event_manager->addEventListener('preFlush', $entity_changed_listener); $event_manager->addEventListener('entityChanged', $mutation_listener); self::$entity_manager = EntityManager::create($params, $configuration, $event_manager); $metadata = self::$entity_manager->getMetadataFactory()->getAllMetadata(); $schema_tool = new SchemaTool(self::$entity_manager); $schema_tool->createSchema($metadata); }
public function testConnectDispatchEvent() { $listenerMock = $this->getMock('ConnectDispatchEventListener', array('postConnect')); $listenerMock->expects($this->once())->method('postConnect'); $eventManager = new EventManager(); $eventManager->addEventListener(array(Events::postConnect), $listenerMock); $driverMock = $this->getMock('Doctrine\\DBAL\\Driver'); $driverMock->expects($this->at(0))->method('connect'); $platform = new Mocks\MockPlatform(); $conn = new Connection(array('platform' => $platform), $driverMock, new Configuration(), $eventManager); $conn->connect(); }
protected function createEntityManager() { $eventManager = new EventManager(); $eventManager->addEventListener(array('preTestSetUp'), $this); $config = new \Doctrine\ORM\Configuration(); $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver()); $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('DoctrineExtensions\\Types\\Proxies'); $conn = array('driver' => 'pdo_sqlite', 'memory' => true); return EntityManager::create($conn, $config, $eventManager); }
public function __construct(Configuration $configuration = null, $isDevMode = true, $tablePrefixString = 'AM_') { if ($configuration === null) { $configuration = new Configuration(); } $doctrineConfig = Doctrine\ORM\Tools\Setup::createAnnotationMetadataConfiguration($configuration->getEntityPaths(), $isDevMode); $conn = array('pdo' => $configuration->getPDOInstance()); $tablePrefix = new TablePrefix($tablePrefixString); $eventManager = new Doctrine\Common\EventManager(); $eventManager->addEventListener(Doctrine\ORM\Events::loadClassMetadata, $tablePrefix); $this->entityManager = Doctrine\ORM\EntityManager::create($conn, $doctrineConfig, $eventManager); $this->classes = $this->entityManager->getMetadataFactory()->getAllMetadata(); $this->schemaTool = new Doctrine\ORM\Tools\SchemaTool($this->entityManager); }
/** * @return \Doctrine\ORM\EntityManager */ protected function createEntityManager() { $eventManager = new EventManager(); $eventManager->addEventListener(array("preTestSetUp"), new SchemaSetupListener()); $driver = new SimplifiedXmlDriver(array(__DIR__ . '/../Resources/config/doctrine' => 'Tbbc\\MoneyBundle\\Entity')); // create config object $config = new Configuration(); $config->setMetadataCacheImpl(new ArrayCache()); $config->setMetadataDriverImpl($driver); $config->setProxyDir(__DIR__ . '/TestProxies'); $config->setProxyNamespace('Tbbc\\MoneyBundle\\Tests\\TestProxies'); $config->setAutoGenerateProxyClasses(true); //$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger()); // create entity manager return EntityManager::create(array('driver' => 'pdo_sqlite', 'path' => "/tmp/sqlite-tbbc-money-test.db"), $config, $eventManager); }
private function registerEntityManager() { $this->app->singleton('Doctrine\\ORM\\EntityManager', function ($app) { $config = $app['config']['doctrine::doctrine']; $metadata = Setup::createAnnotationMetadataConfiguration($config['metadata'], $app['config']['app.debug'], $config['proxy']['directory'], $app['Mitch\\LaravelDoctrine\\CacheManager']->getCache($config['cache_provider']), $config['simple_annotations']); $metadata->addFilter('trashed', 'Mitch\\LaravelDoctrine\\Filters\\TrashedFilter'); $metadata->setAutoGenerateProxyClasses($config['proxy']['auto_generate']); $metadata->setDefaultRepositoryClassName($config['repository']); $metadata->setSQLLogger($config['logger']); if (isset($config['proxy']['namespace'])) { $metadata->setProxyNamespace($config['proxy']['namespace']); } $eventManager = new EventManager(); $eventManager->addEventListener(Events::onFlush, new SoftDeletableListener()); $entityManager = EntityManager::create($this->getDatabaseConfig($app['config']), $metadata, $eventManager); $entityManager->getFilters()->enable('trashed'); return $entityManager; }); $this->app->singleton('Doctrine\\ORM\\EntityManagerInterface', 'Doctrine\\ORM\\EntityManager'); }
public function createEntityManager($smart = false, array $conn, array $paths, $isDevMode = false, $proxyDir = null, $proxyNamespace = null) { //--- Cache --- $cache = $isDevMode ? new ArrayCache() : ApcCache(); //--- /END Cache --- // //--- Config // $config = new Configuration(); // if($cache){ // $config->setMetadataCacheImpl($cache); // } // $driverImpl = $config->newDefaultAnnotationDriver($paths); // $config->setMetadataDriverImpl($driverImpl); // if($cache){ // $config->setQueryCacheImpl($cache); // } // $config->setProxyDir($proxyDir); // $config->setProxyNamespace($proxyNamespace); //--- /END Config //--- EventManager --- $eventManager = null; if (!empty($conn['tablePrefix'])) { $eventManager = new EventManager(); $tablePrefix = new TablePrefix($conn['tablePrefix']); $eventManager->addEventListener(Events::loadClassMetadata, $tablePrefix); } //--- /END EventManager --- if ($smart) { $em = $this->createEmSmart($conn, $paths, $isDevMode, $proxyDir, $cache, $eventManager); } else { $em = $this->createEm($conn, $paths, $isDevMode, $proxyDir, $cache, $eventManager, $proxyNamespace); } //подключаем тип данных "html" Type::addType('html', 'Phpnik\\Core\\DoctrineExtensions\\HtmlType'); $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('db_html', 'html'); return $em; }
/** * Add configured event subscribers and listeners to the event manager * * @return EventManager * @throws \TYPO3\Flow\Persistence\Exception\IllegalObjectTypeException */ protected function buildEventManager() { $eventManager = new EventManager(); if (isset($this->settings['doctrine']['eventSubscribers']) && is_array($this->settings['doctrine']['eventSubscribers'])) { foreach ($this->settings['doctrine']['eventSubscribers'] as $subscriberClassName) { $subscriber = $this->objectManager->get($subscriberClassName); if (!$subscriber instanceof EventSubscriber) { throw new IllegalObjectTypeException('Doctrine eventSubscribers must extend class \\Doctrine\\Common\\EventSubscriber, ' . $subscriberClassName . ' fails to do so.', 1366018193); } $eventManager->addEventSubscriber($subscriber); } } if (isset($this->settings['doctrine']['eventListeners']) && is_array($this->settings['doctrine']['eventListeners'])) { foreach ($this->settings['doctrine']['eventListeners'] as $listenerOptions) { $listener = $this->objectManager->get($listenerOptions['listener']); $eventManager->addEventListener($listenerOptions['events'], $listener); } } return $eventManager; }
/** * @return $this */ public function connect() { // Prevent to connect twice if ($this->entityManager) { return $this; } $applicationDir = $this->core->getApplicationDir(); $this->createModuleDirCache(); $cache = $this->cache->getCacheProvider(); $config = new \Doctrine\ORM\Configuration(); $config->setMetadataCacheImpl($cache); $config->addCustomStringFunction('MD5', '\\DoctrineExtensions\\Query\\Mysql\\Md5'); $config->addCustomStringFunction('ACOS', '\\DoctrineExtensions\\Query\\Mysql\\Acos'); $config->addCustomStringFunction('ASIN', '\\DoctrineExtensions\\Query\\Mysql\\Asin'); $config->addCustomStringFunction('ATAN', '\\DoctrineExtensions\\Query\\Mysql\\Atan'); $config->addCustomStringFunction('ATAN2', '\\DoctrineExtensions\\Query\\Mysql\\Atan2'); $config->addCustomStringFunction('BINARY', '\\DoctrineExtensions\\Query\\Mysql\\Binary'); $config->addCustomStringFunction('CHARLENGTH', '\\DoctrineExtensions\\Query\\Mysql\\CharLength'); $config->addCustomStringFunction('CONCATWS', '\\DoctrineExtensions\\Query\\Mysql\\ConcatWs'); $config->addCustomStringFunction('COS', '\\DoctrineExtensions\\Query\\Mysql\\Cos'); $config->addCustomStringFunction('COT', '\\DoctrineExtensions\\Query\\Mysql\\COT'); $config->addCustomStringFunction('COUNTIF', '\\DoctrineExtensions\\Query\\Mysql\\CountIf'); $config->addCustomStringFunction('CRC32', '\\DoctrineExtensions\\Query\\Mysql\\Crc32'); $config->addCustomStringFunction('DATE', '\\DoctrineExtensions\\Query\\Mysql\\Date'); $config->addCustomStringFunction('DATEADD', '\\DoctrineExtensions\\Query\\Mysql\\DateAdd'); $config->addCustomStringFunction('DATEDIFF', '\\DoctrineExtensions\\Query\\Mysql\\DateFormat'); $config->addCustomStringFunction('DAY', '\\DoctrineExtensions\\Query\\Mysql\\Day'); $config->addCustomStringFunction('DEGREES', '\\DoctrineExtensions\\Query\\Mysql\\Degrees'); $config->addCustomStringFunction('FIELD', '\\DoctrineExtensions\\Query\\Mysql\\Field'); $config->addCustomStringFunction('FINDINSET', '\\DoctrineExtensions\\Query\\Mysql\\FindInSet'); $config->addCustomStringFunction('GROUPCONCAT', '\\DoctrineExtensions\\Query\\Mysql\\GroupConcat'); $config->addCustomStringFunction('HOUR', '\\DoctrineExtensions\\Query\\Mysql\\Hour'); $config->addCustomStringFunction('IFELSE', '\\DoctrineExtensions\\Query\\Mysql\\IfElse'); $config->addCustomStringFunction('IFNULL', '\\DoctrineExtensions\\Query\\Mysql\\IfNUll'); $config->addCustomStringFunction('MATCHAGAINST', '\\DoctrineExtensions\\Query\\Mysql\\MatchAgainst'); $config->addCustomStringFunction('MONTH', '\\DoctrineExtensions\\Query\\Mysql\\Month'); $config->addCustomStringFunction('NULLIF', '\\DoctrineExtensions\\Query\\Mysql\\NullIf'); $config->addCustomStringFunction('PI', '\\DoctrineExtensions\\Query\\Mysql\\Pi'); $config->addCustomStringFunction('RADIANS', '\\DoctrineExtensions\\Query\\Mysql\\Radians'); $config->addCustomStringFunction('RAND', '\\DoctrineExtensions\\Query\\Mysql\\Rand'); $config->addCustomStringFunction('REGEXP', '\\DoctrineExtensions\\Query\\Mysql\\Regexp'); $config->addCustomStringFunction('ROUND', '\\DoctrineExtensions\\Query\\Mysql\\Round'); $config->addCustomStringFunction('SHA1', '\\DoctrineExtensions\\Query\\Mysql\\Sha1'); $config->addCustomStringFunction('SHA2', '\\DoctrineExtensions\\Query\\Mysql\\Sha2'); $config->addCustomStringFunction('SIN', '\\DoctrineExtensions\\Query\\Mysql\\Sin'); $config->addCustomStringFunction('STRTODATE', '\\DoctrineExtensions\\Query\\Mysql\\StrToDate'); $config->addCustomStringFunction('TAN', '\\DoctrineExtensions\\Query\\Mysql\\Tan'); $config->addCustomStringFunction('TIMESTAMPDIFF', '\\DoctrineExtensions\\Query\\Mysql\\TimestampDiff'); $config->addCustomStringFunction('WEEK', '\\DoctrineExtensions\\Query\\Mysql\\Week'); $config->addCustomStringFunction('YEAR', '\\DoctrineExtensions\\Query\\Mysql\\Year'); if (!defined('ENV') || ENV === \Fraym\Core::ENV_DEVELOPMENT) { $config->setAutoGenerateProxyClasses(true); } $modelDirs = $this->getModuleDirCache(); \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader(function ($class) { return class_exists($class, true); }); $annotationReader = new \Doctrine\Common\Annotations\AnnotationReader(); $this->cachedAnnotationReader = new \Doctrine\Common\Annotations\CachedReader($annotationReader, $cache); $this->annotationDriver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($this->cachedAnnotationReader, $modelDirs); /** * Ignore PHP-DI Annotation */ $annotationReader->addGlobalIgnoredName('Injectable'); $annotationReader->addGlobalIgnoredName('Inject'); $config->setMetadataDriverImpl($this->annotationDriver); $config->setQueryCacheImpl($cache); $config->setResultCacheImpl($cache); $config->setProxyDir($applicationDir . DIRECTORY_SEPARATOR . CACHE_DOCTRINE_PROXY_PATH); $config->setProxyNamespace('Proxies'); $this->fetchMode = \PDO::FETCH_OBJ; $tablePrefix = new TablePrefix(DB_TABLE_PREFIX); $this->eventManager = new \Doctrine\Common\EventManager(); $this->eventManager->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $tablePrefix); $this->entityManager = \Doctrine\ORM\EntityManager::create($this->connectionOptions, $config, $this->eventManager); $this->pdo = $this->entityManager->getConnection(); $this->pdo->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string'); $driverChain = new \Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain(); \Gedmo\DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $this->cachedAnnotationReader); $this->eventManager->addEventListener([\Doctrine\ORM\Events::preRemove, \Doctrine\ORM\Events::postRemove, \Doctrine\ORM\Events::prePersist, \Doctrine\ORM\Events::postPersist, \Doctrine\ORM\Events::preUpdate, \Doctrine\ORM\Events::postUpdate, \Doctrine\ORM\Events::postLoad, \Doctrine\ORM\Events::onFlush], $this->eventListener); return $this; }
/** * Creates an entity manager. * * @param array $dbConnectionParameters Parameters used to connect to the database * @param string $tablePrefix Table prefix to use (optional) * @return \Doctrine\ORM\EntityManager */ protected function createEntityManager($dbConnectionParameters, $tablePrefix = null) { // get table prefix set during installation if not provided if ($tablePrefix === null) { $tablePrefix = $this->getInstaller()->getInstallationParameter('db.tablePrefix', ''); } // initialize Doctrine configuration $config = Setup::createAnnotationMetadataConfiguration(array(sprintf('%s/Modules/Core/Model/Entities', ABLERON_APP_DIR)), false, ABLERON_ROOT_DIR . '/generated/doctrine-proxies', new ArrayCache()); // set namespace alias $config->addEntityNamespace('Core', 'Ableron\\Modules\\Core\\Model\\Entities'); // configure event manager $eventManager = new EventManager(); // handle table prefix if ($tablePrefix !== '') { $eventManager->addEventListener(Events::loadClassMetadata, new TablePrefixDoctrineExtension($tablePrefix)); } // set up Doctrine's EntityManager return EntityManager::create($dbConnectionParameters, $config, $eventManager); }
/** * @return EventManager */ protected function createEventManager() { $eventManager = new EventManager(); // Trap doctrine events, to support entity table prefix if ($prefix = config('doctrine.connection.prefix')) { $eventManager->addEventListener(Events::loadClassMetadata, new TablePrefix($prefix)); } return $eventManager; }
public function testGetAlterTableSqlDispatchEvent() { $events = array('onSchemaAlterTable', 'onSchemaAlterTableAddColumn', 'onSchemaAlterTableRemoveColumn', 'onSchemaAlterTableChangeColumn', 'onSchemaAlterTableRenameColumn'); $listenerMock = $this->getMock('GetAlterTableSqlDispatchEvenListener', $events); $listenerMock->expects($this->once())->method('onSchemaAlterTable'); $listenerMock->expects($this->once())->method('onSchemaAlterTableAddColumn'); $listenerMock->expects($this->once())->method('onSchemaAlterTableRemoveColumn'); $listenerMock->expects($this->once())->method('onSchemaAlterTableChangeColumn'); $listenerMock->expects($this->once())->method('onSchemaAlterTableRenameColumn'); $eventManager = new EventManager(); $events = array(Events::onSchemaAlterTable, Events::onSchemaAlterTableAddColumn, Events::onSchemaAlterTableRemoveColumn, Events::onSchemaAlterTableChangeColumn, Events::onSchemaAlterTableRenameColumn); $eventManager->addEventListener($events, $listenerMock); $this->_platform->setEventManager($eventManager); $tableDiff = new TableDiff('mytable'); $tableDiff->addedColumns['added'] = new \Doctrine\DBAL\Schema\Column('added', \Doctrine\DBAL\Types\Type::getType('integer'), array()); $tableDiff->removedColumns['removed'] = new \Doctrine\DBAL\Schema\Column('removed', \Doctrine\DBAL\Types\Type::getType('integer'), array()); $tableDiff->changedColumns['changed'] = new \Doctrine\DBAL\Schema\ColumnDiff('changed', new \Doctrine\DBAL\Schema\Column('changed2', \Doctrine\DBAL\Types\Type::getType('string'), array()), array()); $tableDiff->renamedColumns['renamed'] = new \Doctrine\DBAL\Schema\Column('renamed2', \Doctrine\DBAL\Types\Type::getType('integer'), array()); $this->_platform->getAlterTableSQL($tableDiff); }
public function __construct(EventManager $evm) { $evm->addEventListener(array(self::postGenerateSchemaTable), $this); }
public function testUpdate() { $query = ['a']; $newObj = ['b']; $options = ['c']; $modifiedQuery = ['d']; $modifiedNewObj = ['e']; $modifiedOptions = ['f']; // This listener will modify the data and options. $preUpdateListener = new PreUpdateListener($modifiedQuery, $modifiedNewObj, $modifiedOptions); $eventManager = new EventManager(); $eventManager->addEventListener([Events::preUpdate], $preUpdateListener); // Ensure that the modified pipeline and options are sent to the doAggregate call. $collection = $this->getMockCollection($eventManager, ['doUpdate' => [$modifiedQuery, $modifiedNewObj, $modifiedOptions]]); $collection->update($query, $newObj, $options); }
/** * Creates the global entity manager. * * @return \Doctrine\ORM\EntityManager */ private function createEntityManager() { // find all modules and plugins that should be handled by the entity manager $managedModules = Application::getModuleManager()->getModules(); $managedPlugins = Application::getPluginManager()->getPlugins(); // initialize Doctrine configuration //TODO: Implement caching correctly (APC, memcached, XCache, ...); see \Doctrine\ORM\Tools\Setup::createConfiguration() $config = Setup::createAnnotationMetadataConfiguration($this->getEntityDirectories($managedModules, $managedPlugins), false, ABLERON_DOCTRINE_PROXY_DIR, null); // register namespace aliases for managed modules foreach ($managedModules as $managedModule) { $config->addEntityNamespace($managedModule->getNamespace(), sprintf('Ableron\\Modules\\%s\\Model\\Entities', $managedModule->getNamespace())); } // register namespace aliases for managed plugins foreach ($managedPlugins as $managedPlugin) { $config->addEntityNamespace($managedPlugin->getNamespace(), sprintf('Ableron\\Plugins\\%s\\Model\\Entities', $managedPlugin->getNamespace())); } // configure event manager $eventManager = new EventManager(); // handle table prefix if (Application::getContext()->getSetting('doctrine.tablePrefix') !== '') { $eventManager->addEventListener(Events::loadClassMetadata, new TablePrefixDoctrineExtension(Application::getContext()->getSetting('doctrine.tablePrefix'))); } // set up Doctrine's EntityManager return EntityManager::create(Application::getContext()->getSetting('doctrine.dbConnectionParameters'), $config, $eventManager); }
/** * setup configuration for Doctrine ORM * * @param array $db_config array config for override the default configuration. */ public function setupConfigurationOrm(array $db_config = []) { // setup entity paths. // @todo [cms][modules] load models path from modules folder where module is enabled on certain site in db. Pending: decide to use Doctrine ORM or Spot ORM first. $paths = []; $fs = new \League\Flysystem\Filesystem(new \League\Flysystem\Adapter\Local(MODULE_PATH)); $modules = $fs->listContents(); if (is_array($modules)) { foreach ($modules as $module) { if (is_array($module) && array_key_exists('path', $module)) { $module_dirs = $fs->listContents($module['path']); if (is_array($module_dirs)) { foreach ($module_dirs as $module_dir) { if (is_array($module_dir) && array_key_exists('type', $module_dir) && $module_dir['type'] == 'dir' && array_key_exists('path', $module_dir) && array_key_exists('basename', $module_dir) && $module_dir['basename'] == 'Models') { $paths[] = MODULE_PATH . DS . $module_dir['path']; } } // endforeach; unset($module_dir); } unset($module_dirs); } } // endforeach; unset($module); } unset($fs, $modules); // setup isDevmode. $config = new SystemConfig(); $config->load('app'); $is_devMode = $config->get('debug', 'app'); //setup connection configuration. if (empty($db_config)) { $config->load('db'); $db_params = $config->get('ALL', 'db'); $table_prefix = $db_params['table_prefix']; unset($config, $db_params['table_prefix']); } else { // incase that there is overriden configuration. $db_params = $db_config; if (is_array($db_config)) { if (array_key_exists('table_prefix', $db_config)) { $table_prefix = $db_config['table_prefix']; } if (array_key_exists('table_siteid_prefix', $db_config)) { $table_siteid_prefix = $db_config['table_siteid_prefix']; } } unset($db_params['table_prefix'], $db_params['table_siteid_prefix']); } $evm = new EventManager(); $table_prefix_class = new TablePrefix($table_prefix, isset($table_siteid_prefix) ? $table_siteid_prefix : ''); $evm->addEventListener(Events::loadClassMetadata, $table_prefix_class); unset($table_prefix, $table_prefix_class); $doctrine_config = Setup::createAnnotationMetadataConfiguration($paths, $is_devMode); $doctrine_config->setSQLLogger(new \System\Libraries\Db\Logger()); $this->EntityManager = EntityManager::create($db_params, $doctrine_config, $evm); unset($db_params, $doctrine_config, $evm, $is_devMode); }
/** * Configures the Doctrine event manager instance. * * @param array $doctrineConfig * @param EventManager $eventManager */ protected function configureEventManager(array $doctrineConfig, EventManager $eventManager) { if (isset($doctrineConfig['event_listeners'])) { foreach ($doctrineConfig['event_listeners'] as $name => $listener) { $eventManager->addEventListener($listener['events'], new $listener['class']()); } } }