public function initialize($parameters = array())
 {
     parent::initialize($parameters);
     $schema = $this->getParameter('schema');
     $connectionName = $this->getParameter('name');
     $connectionOptions = $this->getParameter('options');
     $plugins = (array) $this->getParameter('plugins');
     $config = new \Doctrine\ORM\Configuration();
     $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
     $configuration = sfProjectConfiguration::getActive();
     $paths = array();
     if ($schema) {
         $paths[] = $schema;
     }
     $paths[] = realpath(__DIR__ . '/../config/doctrine');
     $paths[] = realpath(sfConfig::get('sf_config_dir') . '/doctrine');
     $enabledPlugins = $configuration->getPlugins();
     foreach ($configuration->getAllPluginPaths() as $plugin => $path) {
         if (!in_array($plugin, $enabledPlugins) || !in_array($plugin, $plugins)) {
             continue;
         }
         $paths[] = $path . '/config/doctrine';
     }
     $paths = array_unique($paths);
     $config->setMetadataDriverImpl(new YamlDriver($paths));
     $config->setProxyDir(sfConfig::get('sf_lib_dir') . '/Proxies');
     $config->setProxyNamespace('Proxies');
     $configuration = sfProjectConfiguration::getActive();
     if (sfConfig::get('sf_debug')) {
         $config->setSqlLogger(new sfDoctrineSqlLogger($configuration->getEventDispatcher()));
     }
     $method = sprintf('configureDoctrineConnection%s', $connectionName);
     $methodExists = method_exists($configuration, $method);
     if (method_exists($configuration, 'configureDoctrineConnection') && !$methodExists) {
         $configuration->configureDoctrineConnection($config);
     } else {
         if ($methodExists) {
             $configuration->{$method}($config);
         }
     }
     $this->em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);
     if (method_exists($configuration, 'configureEntityManager')) {
         $configuration->configureEntityManager($this->em);
     }
     ActiveEntity::setEntityManager($this->em);
     // ODM MongoDB
     $config = new Doctrine\ODM\MongoDB\Configuration();
     $config->setProxyDir(sfConfig::get('sf_lib_dir') . '/Proxies');
     $config->setProxyNamespace('Proxies');
     $reader = new Doctrine\Common\Annotations\AnnotationReader();
     $reader->setDefaultAnnotationNamespace('Doctrine\\ODM\\MongoDB\\Mapping\\');
     $config->setMetadataDriverImpl(new Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver($reader, sfConfig::get('sf_lib_dir') . DIRECTORY_SEPARATOR . 'Documents'));
     $this->dm = Doctrine\ODM\MongoDB\DocumentManager::create(new \Doctrine\ODM\MongoDB\Mongo(), $config);
 }
Exemplo n.º 2
0
$driverImpl = new \Doctrine\ORM\Mapping\Driver\YamlDriver(ASCMS_MODEL_PATH . '/yml');
$chainDriverImpl->addDriver($driverImpl, 'Cx\\Model');
$driverImpl = new \Doctrine\ORM\Mapping\Driver\YamlDriver(ASCMS_CORE_PATH . '/ContentManager/Model/Yaml');
$chainDriverImpl->addDriver($driverImpl, 'Cx\\Core\\ContentManager');
//loggable stuff
$loggableDriverImpl = $config->newDefaultAnnotationDriver(array(UPDATE_CORE, $doctrineDir . 'Gedmo/Loggable/Entity'));
$chainDriverImpl->addDriver($loggableDriverImpl, 'Gedmo\\Loggable');
$loggableListener = new \Cx\Update\core\LoggableListener();
$evm->addEventSubscriber($loggableListener);
\Env::set('loggableListener', $loggableListener);
//tree stuff
$treeListener = new \Gedmo\Tree\TreeListener();
$evm->addEventSubscriber($treeListener);
$config->setMetadataDriverImpl($chainDriverImpl);
//table prefix
$prefixListener = new \DoctrineExtension\TablePrefixListener($_DBCONFIG['tablePrefix']);
$evm->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $prefixListener);
//page listener for unique slugs
$pageListener = new PageEventListener();
$evm->addEventListener(\Doctrine\ORM\Events::preUpdate, $pageListener);
$evm->addEventListener(\Doctrine\ORM\Events::onFlush, $pageListener);
$evm->addEventListener(\Doctrine\ORM\Events::postPersist, $pageListener);
$evm->addEventListener(\Doctrine\ORM\Events::preRemove, $pageListener);
$config->setSqlLogger(new \Cx\Lib\DBG\DoctrineSQLLogger());
$em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config, $evm);
//resolve enum, set errors
$conn = $em->getConnection();
$conn->setCharset($_DBCONFIG['charset']);
$conn->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
$conn->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string');
Env::setEm($em);
 /**
  * @param array $options
  * @return \Doctrine\ORM\EntityManager
  */
 protected function _createEntityManager()
 {
     $options = $this->_options;
     $cache = $this->_setupCache($options);
     if (!isset($options['proxyDir']) || !file_exists($options['proxyDir'])) {
         throw new ZendX_Doctrine2_Exception("No Doctrine2 'proxyDir' option was given, but is required.");
     }
     if (!isset($options['proxyNamespace'])) {
         $options['proxyNamespace'] = 'MyProject/Proxies';
     }
     if (!isset($options['autoGenerateProxyClasses'])) {
         $options['autoGenerateProxyClasses'] = true;
     }
     if (!isset($options['useCExtension'])) {
         $options['useCExtension'] = false;
     }
     $eventManager = new \Doctrine\Common\EventManager();
     $config = new \Doctrine\ORM\Configuration();
     $config->setMetadataCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     $config->setProxyDir($options['proxyDir']);
     $config->setProxyNamespace($options['proxyNamespace']);
     $config->setUseCExtension((bool) $options['useCExtension']);
     if (!isset($options['connectionOptions']) || !is_array($options['connectionOptions'])) {
         throw new ZendX_Doctrine2_Exception("Invalid Doctrine DBAL Connection Options given.");
     }
     $connectionOptions = $options['connectionOptions'];
     if (isset($options['sqllogger'])) {
         if (is_string($options['sqllogger']) && class_exists($options['sqllogger'])) {
             $logger = new $options['sqllogger']();
             if (!$logger instanceof \Doctrine\DBAL\Logging\SqlLogger) {
                 throw new ZendX_Doctrine2_Exception("Invalid SqlLogger class specified, has to implement \\Doctrine\\DBAL\\Logging\\SqlLogger");
             }
             $config->setSqlLogger($logger);
         } else {
             throw new ZendX_Doctrine2_Exception("Invalid SqlLogger configuration specified, have to give class string.");
         }
     }
     $conn = \Doctrine\DBAL\DriverManager::getConnection($connectionOptions, $config, $eventManager);
     $this->_setupMetadataDriver($options, $config, $cache, $conn);
     $em = \Doctrine\ORM\EntityManager::create($conn, $config, $eventManager);
     $registry = Zend_Registry::getInstance();
     $registry->em = $em;
     return $em;
 }
Exemplo n.º 4
0
 /**
  * Returns the doctrine entity manager
  * @return \Doctrine\ORM\EntityManager
  */
 public function getEntityManager()
 {
     if ($this->em) {
         return $this->em;
     }
     $config = new \Doctrine\ORM\Configuration();
     //$config->setResultCacheImpl($this->cacheDriver);
     $config->setMetadataCacheImpl($this->cacheDriver);
     $config->setQueryCacheImpl($this->cacheDriver);
     $config->setProxyDir(ASCMS_MODEL_PROXIES_PATH);
     $config->setProxyNamespace('Cx\\Model\\Proxies');
     /**
      * This should be set to true if workbench is present and active.
      * Just checking for workbench.config is not really a good solution.
      * Since ConfigurationFactory used by EM caches auto generation
      * config value, there's no possibility to set this later.
      */
     $config->setAutoGenerateProxyClasses(file_exists(ASCMS_DOCUMENT_ROOT . '/workbench.config'));
     $connectionOptions = array('pdo' => $this->getPdoConnection(), 'dbname' => $this->db->getName());
     $evm = new \Doctrine\Common\EventManager();
     $chainDriverImpl = new \Doctrine\ORM\Mapping\Driver\DriverChain();
     $driverImpl = new \Cx\Core\Model\Controller\YamlDriver(array(ASCMS_CORE_PATH . '/Core' . '/Model/Yaml'));
     $chainDriverImpl->addDriver($driverImpl, 'Cx');
     //loggable stuff
     $loggableDriverImpl = $config->newDefaultAnnotationDriver(ASCMS_LIBRARY_PATH . '/doctrine/Gedmo/Loggable/Entity');
     $chainDriverImpl->addDriver($loggableDriverImpl, 'Gedmo\\Loggable');
     $this->loggableListener = new \Cx\Core\Model\Model\Event\LoggableListener();
     $this->loggableListener->setUsername('currently_loggedin_user');
     // in real world app the username should be loaded from session, example:
     // Session::getInstance()->read('user')->getUsername();
     $evm->addEventSubscriber($this->loggableListener);
     $cx = \Cx\Core\Core\Controller\Cx::instanciate();
     $sluggableDriverImpl = $config->newDefaultAnnotationDriver($cx->getCodeBaseLibraryPath() . '/doctrine/Gedmo/Sluggable');
     $chainDriverImpl->addDriver($sluggableDriverImpl, 'Gedmo\\Sluggable');
     $sluggableListener = new \Gedmo\Sluggable\SluggableListener();
     // you should set the used annotation reader to listener,
     // to avoid creating new one for mapping drivers
     //$sluggableListener->setAnnotationReader($cachedAnnotationReader);
     $evm->addEventSubscriber($sluggableListener);
     $timestampableDriverImpl = $config->newDefaultAnnotationDriver($cx->getCodeBaseLibraryPath() . '/doctrine/Gedmo/Timestampable');
     $chainDriverImpl->addDriver($timestampableDriverImpl, 'Gedmo\\Timestampable');
     $timestampableListener = new \Gedmo\Timestampable\TimestampableListener();
     //$timestampableListener->setAnnotationReader($cachedAnnotationReader);
     $evm->addEventSubscriber($timestampableListener);
     // Note that LANG_ID and other language constants/variables
     // have not been set yet!
     // $langCode = \FWLanguage::getLanguageCodeById(LANG_ID);
     // \DBG::log("LANG_ID ".LANG_ID.", language code: $langCode");
     // -> LOG: LANG_ID LANG_ID, language code:
     $translatableDriverImpl = $config->newDefaultAnnotationDriver($cx->getCodeBaseLibraryPath() . '/doctrine/Gedmo/Translatable/Entity');
     $chainDriverImpl->addDriver($translatableDriverImpl, 'Gedmo\\Translatable');
     // RK: Note:
     // This might have been renamed in newer versions:
     //$translationListener = new \Gedmo\Translatable\TranslatableListener();
     // In this Doctrine version, it is present as:
     $this->translationListener = new \Gedmo\Translatable\TranslationListener();
     // current translation locale should be set from session
     // or hook later into the listener,
     // but *before the entity manager is flushed*
     // TODO: Set default locale from the default language?
     //$this->translationListener->setDefaultLocale('de_ch');
     // Set the current locale (e.g. from the active language)
     // wherever that's required.
     //$translationListener->setTranslatableLocale('de_ch');
     //$translationListener->setAnnotationReader($cachedAnnotationReader);
     $evm->addEventSubscriber($this->translationListener);
     // RK: Note:
     // This is apparently not yet present in this Doctrine version:
     //$sortableListener = new \Gedmo\Sortable\SortableListener();
     //$sortableListener->setAnnotationReader($cachedAnnotationReader);
     //$evm->addEventSubscriber($sortableListener);
     //tree stuff
     $treeListener = new \Gedmo\Tree\TreeListener();
     $evm->addEventSubscriber($treeListener);
     $config->setMetadataDriverImpl($chainDriverImpl);
     //table prefix
     $prefixListener = new \DoctrineExtension\TablePrefixListener($this->db->getTablePrefix());
     $evm->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $prefixListener);
     $config->setSqlLogger(new \Cx\Lib\DBG\DoctrineSQLLogger());
     $em = \Cx\Core\Model\Controller\EntityManager::create($connectionOptions, $config, $evm);
     //resolve enum, set errors
     $conn = $em->getConnection();
     $conn->setCharset($this->db->getCharset());
     $conn->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
     $conn->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string');
     $this->em = $em;
     return $this->em;
 }
Exemplo n.º 5
0
 /**
  * Returns the doctrine entity manager
  * @return \Doctrine\ORM\EntityManager 
  */
 public function getEntityManager()
 {
     if ($this->em) {
         return $this->em;
     }
     global $objCache;
     $config = new \Doctrine\ORM\Configuration();
     $userCacheEngine = $objCache->getUserCacheEngine();
     if (!$objCache->getUserCacheActive()) {
         $userCacheEngine = \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_OFF;
     }
     $arrayCache = new \Doctrine\Common\Cache\ArrayCache();
     switch ($userCacheEngine) {
         case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_APC:
             $cache = new \Doctrine\Common\Cache\ApcCache();
             $cache->setNamespace($this->db->getName() . '.' . $this->db->getTablePrefix());
             break;
         case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_MEMCACHE:
             $memcache = $objCache->getMemcache();
             if ($memcache instanceof \Memcache) {
                 $cache = new \Doctrine\Common\Cache\MemcacheCache();
                 $cache->setMemcache($memcache);
             } elseif ($memcache instanceof \Memcached) {
                 $cache = new \Doctrine\Common\Cache\MemcachedCache();
                 $cache->setMemcache($memcache);
             }
             $cache->setNamespace($this->db->getName() . '.' . $this->db->getTablePrefix());
             break;
         case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_XCACHE:
             $cache = new \Doctrine\Common\Cache\XcacheCache();
             $cache->setNamespace($this->db->getName() . '.' . $this->db->getTablePrefix());
             break;
         case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_FILESYSTEM:
             $cache = new \Cx\Core_Modules\Cache\Controller\Doctrine\CacheDriver\FileSystemCache(ASCMS_CACHE_PATH);
             break;
         default:
             $cache = $arrayCache;
             break;
     }
     \Env::set('cache', $cache);
     //$config->setResultCacheImpl($cache);
     $config->setMetadataCacheImpl($cache);
     $config->setQueryCacheImpl($cache);
     $config->setProxyDir(ASCMS_MODEL_PROXIES_PATH);
     $config->setProxyNamespace('Cx\\Model\\Proxies');
     /**
      * This should be set to true if workbench is present and active.
      * Just checking for workbench.config is not really a good solution.
      * Since ConfigurationFactory used by EM caches auto generation
      * config value, there's no possibility to set this later.
      */
     $config->setAutoGenerateProxyClasses(file_exists(ASCMS_DOCUMENT_ROOT . '/workbench.config'));
     $connectionOptions = array('pdo' => $this->getPdoConnection(), 'dbname' => $this->db->getName());
     $evm = new \Doctrine\Common\EventManager();
     $chainDriverImpl = new \Doctrine\ORM\Mapping\Driver\DriverChain();
     $driverImpl = new \Cx\Core\Model\Controller\YamlDriver(array(ASCMS_CORE_PATH . '/Core' . '/Model/Yaml'));
     $chainDriverImpl->addDriver($driverImpl, 'Cx');
     //loggable stuff
     $loggableDriverImpl = $config->newDefaultAnnotationDriver(ASCMS_LIBRARY_PATH . '/doctrine/Gedmo/Loggable/Entity');
     $chainDriverImpl->addDriver($loggableDriverImpl, 'Gedmo\\Loggable');
     $this->loggableListener = new \Cx\Core\Model\Model\Event\LoggableListener();
     $this->loggableListener->setUsername('currently_loggedin_user');
     // in real world app the username should be loaded from session, example:
     // Session::getInstance()->read('user')->getUsername();
     $evm->addEventSubscriber($this->loggableListener);
     //tree stuff
     $treeListener = new \Gedmo\Tree\TreeListener();
     $evm->addEventSubscriber($treeListener);
     $config->setMetadataDriverImpl($chainDriverImpl);
     //table prefix
     $prefixListener = new \DoctrineExtension\TablePrefixListener($this->db->getTablePrefix());
     $evm->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $prefixListener);
     $config->setSqlLogger(new \Cx\Lib\DBG\DoctrineSQLLogger());
     $em = \Cx\Core\Model\Controller\EntityManager::create($connectionOptions, $config, $evm);
     //resolve enum, set errors
     $conn = $em->getConnection();
     $conn->setCharset($this->db->getCharset());
     $conn->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
     $conn->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string');
     $this->em = $em;
     return $this->em;
 }