public function __construct()
{
require APPPATH . 'config/database.php';
$dbParams = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database'], 'charset' => $db['default']['char_set'], 'driverOptions' => array('charset' => $db['default']['char_set']));
$isDevMode = true;
$config = new Configuration();
$setup = new Setup();
$config = $setup->createAnnotationMetadataConfiguration(array(APPPATH . "models"), $isDevMode);
$config = $setup->createYAMLMetadataConfiguration(array(APPPATH . "models/Yaml"), $isDevMode);
$this->em = EntityManager::create($dbParams, $config);
}
public static function getConfig($appName, $modelNames = null)
{
$mappingDriver = new Tinebase_Record_DoctrineMappingDriver();
if (!$modelNames) {
$modelNames = array();
foreach ($mappingDriver->getAllClassNames() as $modelName) {
$modelConfig = $modelName::getConfiguration();
if ($modelConfig->getApplName() == $appName) {
$modelNames[] = $modelName;
}
}
}
$tableNames = array();
foreach ($modelNames as $modelName) {
$modelConfig = $modelName::getConfiguration();
if (!$mappingDriver->isTransient($modelName)) {
throw new Setup_Exception('Model not yet doctrine2 ready');
}
$tableNames[] = SQL_TABLE_PREFIX . Tinebase_Helper::array_value('name', $modelConfig->getTable());
}
$config = Setup::createConfiguration();
$config->setMetadataDriverImpl($mappingDriver);
$config->setFilterSchemaAssetsExpression('/' . implode('|', $tableNames) . '/');
return $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 __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)
{
$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 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);
}
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;
}
/**
* @return EntityManager
*/
public function getEntityManager()
{
if (!$this->entityManager instanceof EntityManager) {
$this->entityManager = EntityManager::create($this->getConfiguration()->get('database'), Setup::createAnnotationMetadataConfiguration([$this->rootPath . '/src/Classes/Entities/', __DIR__ . '/Domain/Entities/'], true));
}
return $this->entityManager;
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$dbName = $input->getArgument('dbname');
$path = $input->getOption('path');
$extensionKey = $input->getOption('extension-key');
$connectionParams = array('dbname' => $dbName, 'user' => $input->getOption('user'), 'password' => $input->getOption('password'), 'host' => $input->getOption('host'), 'driver' => $input->getOption('driver'), 'port' => $input->getOption('port'));
$config = Setup::createAnnotationMetadataConfiguration(array('.'), false);
$em = EntityManager::create($connectionParams, $config);
$em->getConfiguration()->setMetadataDriverImpl(new \Doctrine\ORM\Mapping\Driver\DatabaseDriver($em->getConnection()->getSchemaManager()));
$cmf = new DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
if (is_null($extensionKey)) {
$extensionKey = $dbName;
if (self::DEFAULT_PATH != $path) {
$extensionKey = array_pop(explode(DIRECTORY_SEPARATOR, $path));
}
}
$exporter = new ExtbaseExporter($cmf);
$exporter->setExtensionKey($extensionKey);
$exporter->setPath($input->getOption('path'));
self::mapDefaultInputOptions($exporter, $input);
$output->writeln(sprintf('Exporting database schema "<info>%s</info>".', $dbName));
$result = $exporter->exportJson();
foreach ($exporter->getLogs() as $log) {
$output->writeln($log);
}
return $result ? 0 : 1;
}
private function __construct()
{
$settings = Setup::getSettings();
$config = \Doctrine\ORM\Tools\Setup::createXMLMetadataConfiguration([__DIR__ . '/../Mapper', 'Bh/Mapper'], $settings['DevMode']);
$conn = array('driver' => 'pdo_mysql', 'user' => $settings['DbUser'], 'password' => $settings['DbPass'], 'dbname' => $settings['DbName']);
self::$entityManager = \Doctrine\ORM\EntityManager::create($conn, $config);
}
public function __construct($sm, $params = array())
{
$this->sm = $sm;
$path = $sm->get('pegase.core.path');
foreach ($params['entities_folders'] as $i => $f) {
$params['entities_folders'][$i] = $path->get_path($f);
}
$this->db_params = $params['database'];
$isDevMode = true;
$config = Setup::createAnnotationMetadataConfiguration($params['entities_folders'], $isDevMode);
$this->em = EntityManager::create($params['database'], $config);
/*
// on vérifie la validité des mappings
$validator = new SchemaValidator($this->em);
$errors = $validator->validateMapping();
if(count($errors) > 0) {
// Lots of errors!
echo implode("\n\n", $errors);
}
else
echo "Les mappings sont ok.\n";
*/
$this->schema = new Schema($sm, $this);
$this->database = new Database($sm, $this);
$this->entity = new Entity($sm, $this);
}
/**
* This method is used to add an entity manager to the doctrine service.
* @param $id string The id you would like to store with the entity manager.
* @param ulfberht\module\doctrine\config $config The doctrine configuration for
* the entity manager.
* @return void
*/
public function addEntityManager($id, config $config)
{
$development = $config->develop ? true : false;
$cache = $config->enableCache ? new ArrayCache() : null;
//setup type of metadata reading
switch ($config->type) {
case 'annotation':
$docConfig = Setup::createAnnotationMetadataConfiguration($config->paths, $development, null, $cache);
break;
case 'xml':
$docConfig = Setup::createXMLMetadataConfiguration($config->paths, $development, null, $cache);
break;
case 'yaml':
$docConfig = Setup::createYAMLMetadataConfiguration($config->paths, $development, null, $cache);
break;
}
//setup caching
if (!is_null($cache)) {
$docConfig->setQueryCacheImpl($cache);
$docConfig->setMetadataCacheImpl($cache);
}
//setup database connection
$dbConnInfo = array('driver' => $config->database->driver, 'host' => $config->database->host, 'dbname' => $config->database->name, 'user' => $config->database->user, 'password' => $config->database->password);
//store entity manager
$this->_doctrineEntityMangers[$id] = EntityManager::create($dbConnInfo, $docConfig);
}
public function __construct()
{
$this->setRoot("/var/www/html/uan/");
$this->setEntidade(array($this->getRoot() . "models/"));
$this->setIsDevMode(true);
$mode = "DESENVOLVIMENTO";
$config = Setup::createAnnotationMetadataConfiguration($this->getEntidade(), $this->getIsDevMode(), NULL, NULL, FALSE);
if ($mode == "DESENVOLVIMENTO") {
$cache = new \Doctrine\Common\Cache\ArrayCache();
} else {
$cache = new \Doctrine\Common\Cache\ApcCache();
}
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
$driverImpl = $config->newDefaultAnnotationDriver($this->getRoot() . 'models/');
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
$config->setProxyDir($this->getRoot() . 'proxies/');
$config->setProxyNamespace('proxies');
if ($mode == "DESENVOLVIMENTO") {
$config->setAutoGenerateProxyClasses(true);
} else {
$config->setAutoGenerateProxyClasses(false);
}
$config = Setup::createAnnotationMetadataConfiguration($this->getEntidade(), $this->getIsDevMode(), NULL, NULL, FALSE);
$dbParams = array('driver' => 'pdo_mysql', 'user' => 'root', 'password' => '', 'dbname' => 'ceafie', 'charset' => 'utf8', 'driverOptions' => array(1002 => 'SET NAMES utf8'));
$this->em = EntityManager::create($dbParams, $config);
$loader = new ClassLoader('Entity', __DIR__ . '/models');
$loader->register();
}
public function __construct()
{
$yamlParser = new Parser();
$dbParams = $yamlParser->parse(file_get_contents(__DIR__ . '/parameters.yml'));
$config = Setup::createAnnotationMetadataConfiguration(array(__DIR__ . '/../Entity'), true);
$this->em = EntityManager::create($dbParams['database'], $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);
};
}
}
protected function setUp()
{
$pathToEntities = [__DIR__ . '/Entity'];
$isDevMode = true;
$connectionParams = array('user' => 'user', 'password' => 'password', 'driver' => 'pdo_sqlite', 'memory' => true);
$config = Setup::createConfiguration($isDevMode);
$driver = new AnnotationDriver(new AnnotationReader(), $pathToEntities);
AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driver);
$this->em = EntityManager::create($connectionParams, $config);
/*
* Устанавливаем фикстуры, знаю что можно это сделать более универсально, но ... в данном контексте мне больше и не надо
*/
$conn = $this->em->getConnection();
$conn->exec("CREATE TABLE clients (id INTEGER PRIMARY KEY, name TEXT, surname TEXT);");
$conn->exec("CREATE TABLE authors (id INTEGER PRIMARY KEY, name TEXT, surname TEXT);");
$conn->exec("CREATE TABLE books (id INTEGER, owner_id INTEGER, name TEXT, surname TEXT, CONSTRAINT 'pk' PRIMARY KEY (id, owner_id));");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Nikita','Sapogov')");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Alex','Ivanov')");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Sura','Soir')");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Vasya','Poliakocv')");
$conn->exec("INSERT INTO books (id, owner_id, name) VALUES (1,1,'SuperBookNAme')");
$conn->exec("INSERT INTO books (id, owner_id, name) VALUES (2,15,'SuperBookNAme2')");
$conn->exec("INSERT INTO books (id, owner_id, name) VALUES (3,3,'SuperBookNAme3')");
}
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);
}
/**
* Initializes the database (once).
*
* @throws \Doctrine\DBAL\DBALException
* @throws \Doctrine\ORM\ORMException
* @throws \Doctrine\ORM\Tools\ToolsException
*/
protected function setUp()
{
if (null === static::$_conn) {
$dbPath = __DIR__ . '/../../../db.sqlite';
if (file_exists($dbPath)) {
unlink($dbPath);
}
$params = ['driver' => 'pdo_sqlite', 'path' => $dbPath];
static::$_conn = DriverManager::getConnection($params);
static::$_conn->getConfiguration()->setSQLLogger(null);
}
if (null === static::$_em) {
$paths = [__DIR__ . '/../../../../../src/Ekyna/Commerce/Bridge/Doctrine/ORM/Resources/mapping'];
$isDevMode = true;
$config = Setup::createXMLMetadataConfiguration($paths, $isDevMode);
$em = EntityManager::create(static::$_conn, $config);
$classes = [];
foreach (static::$_classes as $class) {
array_push($classes, $em->getClassMetadata($class));
}
$schemaTool = new SchemaTool($em);
$schemaTool->dropSchema($classes);
$schemaTool->createSchema($classes);
// Load fixtures
$loader = new Loader();
$loader->loadFromDirectory(__DIR__ . '/../../../../../src/Ekyna/Commerce/Bridge/Doctrine/Fixtures');
$purger = new ORMPurger();
$executor = new ORMExecutor($em, $purger);
$executor->execute($loader->getFixtures());
static::$_em = $em;
}
}
/**
* @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 function setUp()
{
// register our custom type
if (!Type::hasType('hstore')) {
Type::addType('hstore', 'EasyBib\\Doctrine\\Types\\Hstore');
}
$isDevMode = true;
$doctrineConfig = Setup::createAnnotationMetadataConfiguration(array(__DIR__ . '/Entity'), $isDevMode);
// database configuration parameters
$rootTestsFolder = dirname(dirname(dirname(dirname(__DIR__))));
$this->isTravis = getenv("TRAVIS");
if (file_exists($rootTestsFolder . '/db-config.php')) {
$dbConfig = (include $rootTestsFolder . '/db-config.php');
} elseif (false !== $this->isTravis) {
$dbConfig = (include $rootTestsFolder . '/db-config-travisci.php');
} else {
throw new \RuntimeException("No database configuration found.");
}
// create the entity manager
$this->em = EntityManager::create($dbConfig, $doctrineConfig);
// enable 'hstore'
$this->em->getConnection()->exec("CREATE EXTENSION IF NOT EXISTS hstore");
// register type with DBAL
$this->em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('hstore', 'hstore');
// make the PersistentObject happy
PersistentObject::setObjectManager($this->em);
// create table
$this->setUpSchema($this->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()
{
$this->conn = $this->getSqliteConnection();
$this->config = Setup::createXMLMetadataConfiguration(array(__DIR__ . '/_files'), true);
$this->entityManager = EntityManager::create($this->conn, $this->config);
$this->ormProvider = new OrmSchemaProvider($this->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 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']);
}
/**
* Just for internal use, could be overridden in child classes
* User $em property in case if you need EntityManager
*
* @return EntityManagerMock
*/
protected function getEntityManagerInstanceMock()
{
$this->config = Setup::createAnnotationMetadataConfiguration(array('./Fixtures'), true);
$this->config->setQuoteStrategy(new QuotingStrategy());
$conn = array('driverClass' => 'Luxifer\\Tests\\Mocks\\DriverMock', 'wrapperClass' => 'Luxifer\\Tests\\Mocks\\ConnectionMock', 'user' => 'john', 'password' => 'wayne');
$conn = DriverManager::getConnection($conn, $this->config);
$this->config->setProxyDir(__DIR__ . '/Proxies');
$this->config->setProxyNamespace('Luxifer\\Tests\\Proxies');
$this->config->addCustomDatetimeFunction('date', 'Luxifer\\DQL\\Datetime\\Date');
$this->config->addCustomDatetimeFunction('datediff', 'Luxifer\\DQL\\Datetime\\DateDiff');
$this->config->addCustomDatetimeFunction('day', 'Luxifer\\DQL\\Datetime\\Day');
$this->config->addCustomDatetimeFunction('dayofmonth', 'Luxifer\\DQL\\Datetime\\DayOfMonth');
$this->config->addCustomDatetimeFunction('week', 'Luxifer\\DQL\\Datetime\\Week');
$this->config->addCustomDatetimeFunction('dayofweek', 'Luxifer\\DQL\\Datetime\\DayOfWeek');
$this->config->addCustomDatetimeFunction('dayofyear', 'Luxifer\\DQL\\Datetime\\DayOfYear');
$this->config->addCustomDatetimeFunction('hour', 'Luxifer\\DQL\\Datetime\\Hour');
$this->config->addCustomDatetimeFunction('minute', 'Luxifer\\DQL\\Datetime\\Minute');
$this->config->addCustomDatetimeFunction('month', 'Luxifer\\DQL\\Datetime\\Month');
$this->config->addCustomDatetimeFunction('quarter', 'Luxifer\\DQL\\Datetime\\Quarter');
$this->config->addCustomDatetimeFunction('second', 'Luxifer\\DQL\\Datetime\\Second');
$this->config->addCustomDatetimeFunction('time', 'Luxifer\\DQL\\Datetime\\Time');
$this->config->addCustomDatetimeFunction('year', 'Luxifer\\DQL\\Datetime\\Year');
$this->config->addCustomDatetimeFunction('convert_tz', 'Luxifer\\DQL\\Datetime\\ConvertTZ');
$this->config->addCustomDatetimeFunction('date_format', 'Luxifer\\DQL\\Datetime\\DateFormat');
$this->config->addCustomDatetimeFunction('concat_ws', 'Luxifer\\DQL\\String\\ConcatWs');
return EntityManagerMock::create($conn, $this->config);
}
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));
}
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 __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');
}
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 function buildProdConfig()
{
$proxies = dirname(__FILE__) . DS . 'proxies';
$config = Setup::createXMLMetadataConfiguration($this->paths, false, $proxies);
$config->setProxyNamespace('Infrastructure\\Persistence\\Doctrine\\Proxies');
return $config;
}
