/** * Initializes application modules */ public function initModules(Config $config) { $moduleLoader = new ModuleLoader($this->getDI()); //registers modules defined in modules.php file $modulesFile = $config->application->configDir . Loader::MODULE_STATIC_FILE; /** * For non-default environment modules are being dumped in each application start */ if (!file_exists($modulesFile) || $this->getDI()->get('environment') != Constants::DEFAULT_ENV) { $modules = $moduleLoader->dump($config->application->moduleDir, $config->application->configDir); } else { $modules = (require $modulesFile); } if (!is_array($modules)) { throw new InvalidModulesListException(); } $this->getApplication()->registerModules($modules); //prepares modules configurations foreach ($this->getApplication()->getModules() as $module) { $moduleConfigFile = dirname($module['path']) . DIRECTORY_SEPARATOR . 'config' . DIRECTORY_SEPARATOR . 'config.php'; if (file_exists($moduleConfigFile)) { $moduleConfig = (require $moduleConfigFile); if (is_array($moduleConfig)) { $config->merge($moduleConfig); } } } $this->getDI()->set('modules', function () { return $this->getApplication()->getModules(); }); }
/** * @param Config $config */ public function __construct(Config $config) { $this->redirectUriAuthorize = $config->get('redirectUri'); $this->clientId = $config->get('clientId'); $this->clientSecret = $config->get('clientSecret'); $this->logger = $this->getDI()->get('logger', ['auth.log']); }
public static function register(Di $di) { $environment = isset($_SERVER['PHWOOLCON_ENV']) ? $_SERVER['PHWOOLCON_ENV'] : 'production'; // @codeCoverageIgnoreStart if (is_file($cacheFile = storagePath('cache/config-' . $environment . '.php'))) { static::$config = (include $cacheFile); Config::get('app.cache_config') or static::clearCache(); return; } // @codeCoverageIgnoreEnd $defaultFiles = glob($_SERVER['PHWOOLCON_CONFIG_PATH'] . '/*.php'); $environmentFiles = glob($_SERVER['PHWOOLCON_CONFIG_PATH'] . '/' . $environment . '/*.php'); $config = new PhalconConfig(static::loadFiles($defaultFiles)); $environmentSettings = static::loadFiles($environmentFiles); $environmentSettings['environment'] = $environment; $environmentConfig = new PhalconConfig($environmentSettings); $config->merge($environmentConfig); $di->remove('config'); $di->setShared('config', $config); static::$config = $config->toArray(); Config::get('database.default') and static::loadDb($config); // @codeCoverageIgnoreStart if (Config::get('app.cache_config')) { is_dir($cacheDir = dirname($cacheFile)) or mkdir($cacheDir, 0777, true); fileSaveArray($cacheFile, static::$config, function ($content) { $replacement = <<<'EOF' $_SERVER['PHWOOLCON_ROOT_PATH'] . ' EOF; return str_replace("'{$_SERVER['PHWOOLCON_ROOT_PATH']}", $replacement, $content); }); } // @codeCoverageIgnoreEnd }
/** * Initializes the config. Reads it from its location and * stores it in the Di container for easier access * @param array $aOptions */ protected function initConfig($aOptions = array()) { $oConfig = new PhConfig(); $aSharedConfig = (require ROOT_PATH . '/config/config.php'); $oConfig->merge(new PhConfig($aSharedConfig)); $this->oDI->setShared('config', $oConfig); }
/** * Get mongo connection URI * * @param \Phalcon\Config $config * @return string */ private function getConnectUri(\Phalcon\Config $config) { if ($config->offsetExists('user') && $config->offsetExists('password')) { return "mongodb://" . $config['user'] . ":" . $config['password'] . "@" . $config['host'] . ":" . $config['port'] . "/" . $config['dbname']; } else { return "mongodb://" . $config['host'] . ":" . $config['port'] . "/" . $config['dbname']; } }
public function testFactoryShouldWorkIfCreatedFromConfigPHPArray() { $config = new Config(include INCUBATOR_FIXTURES . 'Acl/acl.php'); $factory = new MemoryFactory(); $acl = $factory->create($config->get('acl')); $this->assertInstanceOf('Phalcon\\Acl\\Adapter\\Memory', $acl); $this->assertAclIsConfiguredAsExpected($acl, $config); }
public function testConfigMerge() { $configA = new Config(['paramA' => ['paramB' => 'valueA']]); $configB = new Config(['paramA' => ['paramB' => 'valueB', 'paramC' => 'valueC']]); $configB->merge($configA); $this->assertEquals('valueA', $configB->paramA->paramB); $this->assertEquals('valueC', $configB->paramA->paramC); }
/** * Implement configurations * * @param \Phalcon\Config $config $config * @throws \Sonar\Exceptions\QueueServiceException */ public function __construct(\Phalcon\Config $config) { if ($this->beanstalkMapper === null) { try { $this->beanstalkMapper = new BeanstalkMapper($config->toArray()); } catch (BeanstalkMapperException $e) { throw new QueueServiceException($e->getMessage()); } } }
/** * Load configuration files */ protected function initConfig() { // read in config arrays $defaultConfig = (require APP_PATH . '/etc/config.php'); $localConfig = (require APP_PATH . '/etc/config.local.php'); // instantiate them into the phalcon config $config = new Config($defaultConfig); $config->merge(new Config($localConfig)); $this->di['config'] = $config; }
private function parseDefinitionArgument($argument) { if (Text::startsWith($argument, '!')) { return ['type' => 'parameter', 'value' => Arr::path($this->config->toArray(), substr($argument, 1))]; } elseif (Text::startsWith($argument, '@')) { return ['type' => 'service', 'name' => substr($argument, 1)]; } else { return ['type' => 'parameter', 'value' => $argument]; } }
protected function compareConfig(array $actual, Config $expected) { $this->assertEquals($actual, $expected->toArray()); foreach ($actual as $key => $value) { $this->assertTrue(isset($expected->{$key})); if (is_array($value)) { $this->compareConfig($value, $expected->{$key}); } } }
/** * Initial module configuration params * * @param \Phalcon\Config $config * @throws \Sonar\Exceptions\AppServiceException */ public function __construct(\Phalcon\Config $config) { if (!$this->socketService) { if (isset($config->socket) === false) { throw new AppServiceException('There is no option `socket` in your configurations'); } if ($config->offsetExists('debug') === true && boolval($config->debug) === true) { define('SONAR_VERBOSE', true); } $this->socketService = new SocketService($config); } }
/** * @param string $file */ public function load($file) { $config = $this->cache->get($file); if (null === $config) { $config = $this->factory->buildFromPath($file); $this->cache->set($file, $config->toArray()); } else { $config = new Config($config); } if ($config) { $this->config->merge($config); } return $this; }
/** * Runs the application, performing all initializations * * @return void */ public function run() { $modules = $this->_config->get('modules'); if (!$modules) { $modules = (object) []; } $di = $this->_dependencyInjector; $config = $this->_config; if (isset($this->_config->application)) { if ($this->_config->application->debug) { if (!isset($this->_config->application->useCachingInDebugMode)) { $this->_config->application->useCachingInDebugMode = false; } } } $di->set('modules', function () use($modules) { return $modules; }); // Set application event manager $eventsManager = new \Phalcon\Events\Manager(); // Init services and engine system foreach ($this->_services as $serviceName) { $service = $this->_serviceNamespace . "\\" . ucfirst($serviceName); $service = new $service($di, $eventsManager, $config); if (!$service instanceof \Engine\Application\Service\AbstractService) { throw new \Engine\Exception("Service '{$serviceName}' not instance of AbstractService"); } $service->init(); } // register enabled modules $enabledModules = []; if (!empty($modules)) { foreach ($modules as $module => $enabled) { if (!$enabled) { continue; } $moduleName = ucfirst($module); $enabledModules[$module] = array('className' => $moduleName . '\\Module', 'path' => ROOT_PATH . '/apps/modules/' . $moduleName . '/Module.php'); } if (!empty($enabledModules)) { $this->registerModules($enabledModules); } } // Set default services to the DI $this->setEventsManager($eventsManager); $di->setShared('eventsManager', $eventsManager); $di->setShared('app', $this); }
/** * \Phalcon\Config\Adapter\Ini constructor * * @param string $filePath * @throws Exception */ public function __construct($filePath) { $array = array(); if (is_string($filePath) === false) { throw new Exception('Invalid parameter type.'); } @($d = parse_ini_file($filePath, true)); if ($d === false) { throw new Exception('Configuration file ' . $filePath . " can't be loaded"); } foreach ($d as $section => $directives) { if (is_array($directives) === false || empty($directives) === true) { $array[$section] = $directives; } else { foreach ($directives as $key => $value) { if (strpos($key, '.') !== false) { isset($array[$section]) === false && ($array[$section] = array()); $array[$section] = self::_parseKey($array[$section], $key, $value); } else { $array[$section][$key] = $value; } } } } parent::__construct($array); }
public function testConfigMerge() { $config1 = new \Phalcon\Config(array("controllersDir" => "../x/y/z", "modelsDir" => "../x/y/z", "database" => array("adapter" => "Mysql", "host" => "localhost", "username" => "scott", "password" => "cheetah", "name" => "test_db", "charset" => array("primary" => "utf8"), "alternatives" => array("primary" => "latin1", "second" => "latin1")))); $config2 = new \Phalcon\Config(array("modelsDir" => "../x/y/z", "database" => array("adapter" => "Postgresql", "host" => "localhost", "username" => "peter", "options" => array("case" => "lower"), "alternatives" => array("primary" => "swedish", "third" => "american")))); $config1->merge($config2); $expected = \Phalcon\Config::__set_state(array('controllersDir' => '../x/y/z', 'modelsDir' => '../x/y/z', 'database' => \Phalcon\Config::__set_state(array('adapter' => 'Postgresql', 'host' => 'localhost', 'username' => 'peter', 'password' => 'cheetah', 'name' => 'test_db', 'charset' => \Phalcon\Config::__set_state(array('primary' => 'utf8')), 'alternatives' => \Phalcon\Config::__set_state(array('primary' => 'swedish', 'second' => 'latin1', 'third' => 'american')), 'options' => \Phalcon\Config::__set_state(array('case' => 'lower')))))); $this->assertEquals($expected, $config1); }
/** * Class constructor. * * @param string $filePath * @throws \Phalcon\Config\Exception */ public function __construct($filePath) { if (!extension_loaded("json")) { throw new Exception('Json extension not loaded'); } if (false === ($result = json_decode(file_get_contents($filePath), true))) { throw new Exception('Configuration file ' . $filePath . ' can\'t be loaded'); } parent::__construct($result); }
/** * Phalcon\Config\Adapter\Yaml * * @param string $filePath */ public function __construct($filePath, $callbacks = array()) { if (!extension_loaded('yaml')) { throw new Exception('Yaml extension not loaded'); } if (false === ($result = @yaml_parse_file($filePath, 0, $ndocs, $callbacks))) { throw new Exception('Configuration file ' . $filePath . ' can\'t be loaded'); } parent::__construct($result); }
public static function setCurrentVersion($lastVersion, $currentVersion) { if (is_null(self::$_connection)) { self::connSetup(self::$_config->get('database')); } if (!is_null(self::$_config->get('migrationsLog')) && 'database' == self::$_config->get('migrationsLog')) { self::$_connection->execute('UPDATE `phalcon_migrations` SET `version`="' . (string) $currentVersion . '" WHERE `version`="' . (string) $lastVersion . '" LIMIT 1;'); } else { file_put_contents(self::$_migrationFid, (string) $currentVersion); } }
/** * @param \Phalcon\Config|array $config */ public function build($config) { $routes = $config instanceof \Phalcon\Config ? $config->toArray() : $config; foreach ($routes as $name => $value) { $names = explode('_', $name); $value['url'] = isset($value['url']) ? $value['url'] : '/' . str_replace('_', '/', $name); // normalized url $length = strlen($value['url']); if ($value['url'][$length - 1] === '/' && $length > 1 && $this->_removeExtraSlashes) { $value['url'] = rtrim($value['url'], '/'); } $value['controller'] = isset($value['controller']) ? $value['controller'] : $names[0]; if (isset($value['action'])) { } elseif (isset($names[1])) { $value['action'] = $names[1]; } else { $value['action'] = 'index'; } $this->add($value['url'], $value)->setName($name)->via($value['method']); } }
/** * Index a single document * * @param Posts $post */ protected function doIndex(Posts $post) { $params = []; $karma = $post->number_views + ($post->votes_up - $post->votes_down) * 10 + $post->number_replies; if ($karma > 0) { $params['body'] = ['id' => $post->id, 'title' => $post->title, 'category' => $post->categories_id, 'content' => $post->content, 'karma' => $karma]; $params['index'] = $this->config->get('index', 'phosphorum'); $params['type'] = 'post'; $params['id'] = 'post-' . $post->id; $this->client->index($params); } }
protected function initLoader() { $autoload = static::$config->get('autoload'); if ($autoload) { $loader = new Loader(); if ($autoload->get('dir') instanceof Config) { $loader->registerDirs($autoload->get('dir')->toArray()); } if ($autoload->get('namespace') instanceof Config) { $loader->registerNamespaces($autoload->get('namespace')->toArray()); } $loader->register(); } }
/** * \Phalcon\Config\Adapter\Json constructor * * @param string $filePath * @throws Exception */ public function __construct($filePath) { if (is_string($filePath) === false) { throw new Exception('Invalid parameter type.'); } @($contents = file_get_contents($filePath)); if (is_string($contents) === true) { $array = json_decode($contents, true); if (json_last_error() !== \JSON_ERROR_NONE) { throw new Exception('Invalid json file.'); } parent::__construct($array); } else { throw new Exception('Unable to read json file.'); } }
/** * Resolves the DB Schema * * @param \Phalcon\Config $config * @return null|string */ public static function resolveDbSchema(Config $config) { if ($config->offsetExists('schema')) { return $config->get('schema'); } if (self::DB_ADAPTER_POSTGRESQL == $config->get('adapter')) { return 'public'; } if ($config->offsetExists('dbname')) { return $config->get('dbname'); } return null; }
/** * Resolves the DB Schema * * @param \Phalcon\Config $config * @return null|string */ public static function resolveDbSchema(Config $config) { if ($config->offsetExists('schema')) { return $config->get('schema'); } if (self::DB_ADAPTER_POSTGRESQL == $config->get('adapter')) { return 'public'; } if (self::DB_ADAPTER_SQLITE == $config->get('adapter')) { // SQLite only supports the current database, unless one is // attached. This is not the case, so don't return a schema. return null; } if ($config->offsetExists('dbname')) { return $config->get('dbname'); } return null; }
/** * Phalcon\Config\Adapter\Xml constructor * * @param string $filePath * @throws Exception */ public function __construct($filePath) { if (!extension_loaded('SimpleXML')) { throw new Exception("SimpleXML extension not loaded"); } libxml_use_internal_errors(true); $data = simplexml_load_file($filePath, 'SimpleXMLElement', LIBXML_NOCDATA); foreach (libxml_get_errors() as $error) { /** @var \LibXMLError $error */ switch ($error->code) { case LIBXML_ERR_WARNING: trigger_error($error->message, E_USER_WARNING); break; default: throw new Exception($error->message); } } libxml_use_internal_errors(false); parent::__construct(json_decode(json_encode((array) $data), true)); }
/** * Options Constructor * * @param array $options * * @throws \InvalidArgumentException If flags is not an integer */ public function __construct(array $options) { parent::__construct($options); }
/** * Returns database name * * @return mixed */ public static function getDbName() { return self::$_databaseConfig->get('dbname'); }
public function testMaintainConfigObjectReference() { $config = new Config(['basedir' => static::$basedir]); $b = new Bootstrap(self::getUserOptions(), $config, static::$di); $b->getConfig()->foo = 'bar'; $this->assertEquals('bar', $config->get('foo')); }
/** * Look for table definition modifications and apply to real table * * @param $tableName * @param $definition * * @throws \Phalcon\Db\Exception */ public function morphTable($tableName, $definition) { $defaultSchema = self::$_databaseConfig->get('dbname'); $tableExists = self::$_connection->tableExists($tableName, $defaultSchema); if (isset($definition['columns'])) { if (count($definition['columns']) == 0) { throw new DbException('Table must have at least one column'); } $fields = array(); foreach ($definition['columns'] as $tableColumn) { if (!is_object($tableColumn)) { throw new DbException('Table must have at least one column'); } /** * @var \Phalcon\Db\ColumnInterface $tableColumn * @var \Phalcon\Db\ColumnInterface[] $fields */ $fields[$tableColumn->getName()] = $tableColumn; } if ($tableExists == true) { $localFields = array(); /** * @var \Phalcon\Db\ColumnInterface[] $description * @var \Phalcon\Db\ColumnInterface[] $localFields */ $description = self::$_connection->describeColumns($tableName, $defaultSchema); foreach ($description as $field) { $localFields[$field->getName()] = $field; } foreach ($fields as $fieldName => $tableColumn) { /** * @var \Phalcon\Db\ColumnInterface $tableColumn * @var \Phalcon\Db\ColumnInterface[] $localFields */ if (!isset($localFields[$fieldName])) { self::$_connection->addColumn($tableName, $tableColumn->getSchemaName(), $tableColumn); } else { $changed = false; if ($localFields[$fieldName]->getType() != $tableColumn->getType()) { $changed = true; } if ($localFields[$fieldName]->getSize() != $tableColumn->getSize()) { $changed = true; } if ($tableColumn->isNotNull() != $localFields[$fieldName]->isNotNull()) { $changed = true; } if ($tableColumn->getDefault() != $localFields[$fieldName]->getDefault()) { $changed = true; } if ($changed == true) { self::$_connection->modifyColumn($tableName, $tableColumn->getSchemaName(), $tableColumn); } } } foreach ($localFields as $fieldName => $localField) { if (!isset($fields[$fieldName])) { self::$_connection->dropColumn($tableName, null, $fieldName); } } } else { self::$_connection->createTable($tableName, $defaultSchema, $definition); if (method_exists($this, 'afterCreateTable')) { $this->afterCreateTable(); } } } if (isset($definition['references'])) { if ($tableExists == true) { $references = array(); foreach ($definition['references'] as $tableReference) { $references[$tableReference->getName()] = $tableReference; } $localReferences = array(); $activeReferences = self::$_connection->describeReferences($tableName, $defaultSchema); foreach ($activeReferences as $activeReference) { $localReferences[$activeReference->getName()] = array('referencedTable' => $activeReference->getReferencedTable(), 'columns' => $activeReference->getColumns(), 'referencedColumns' => $activeReference->getReferencedColumns()); } foreach ($definition['references'] as $tableReference) { if (!isset($localReferences[$tableReference->getName()])) { self::$_connection->addForeignKey($tableName, $tableReference->getSchemaName(), $tableReference); } else { $changed = false; if ($tableReference->getReferencedTable() != $localReferences[$tableReference->getName()]['referencedTable']) { $changed = true; } if ($changed == false) { if (count($tableReference->getColumns()) != count($localReferences[$tableReference->getName()]['columns'])) { $changed = true; } } if ($changed == false) { if (count($tableReference->getReferencedColumns()) != count($localReferences[$tableReference->getName()]['referencedColumns'])) { $changed = true; } } if ($changed == false) { foreach ($tableReference->getColumns() as $columnName) { if (!in_array($columnName, $localReferences[$tableReference->getName()]['columns'])) { $changed = true; break; } } } if ($changed == false) { foreach ($tableReference->getReferencedColumns() as $columnName) { if (!in_array($columnName, $localReferences[$tableReference->getName()]['referencedColumns'])) { $changed = true; break; } } } if ($changed == true) { self::$_connection->dropForeignKey($tableName, $tableReference->getSchemaName(), $tableReference->getName()); self::$_connection->addForeignKey($tableName, $tableReference->getSchemaName(), $tableReference); } } } foreach ($localReferences as $referenceName => $reference) { if (!isset($references[$referenceName])) { self::$_connection->dropForeignKey($tableName, null, $referenceName); } } } } if (isset($definition['indexes'])) { if ($tableExists == true) { $indexes = array(); foreach ($definition['indexes'] as $tableIndex) { $indexes[$tableIndex->getName()] = $tableIndex; } $localIndexes = array(); $actualIndexes = self::$_connection->describeIndexes($tableName, $defaultSchema); foreach ($actualIndexes as $actualIndex) { $localIndexes[$actualIndex->getName()] = $actualIndex->getColumns(); } foreach ($definition['indexes'] as $tableIndex) { if (!isset($localIndexes[$tableIndex->getName()])) { if ($tableIndex->getName() == 'PRIMARY') { self::$_connection->addPrimaryKey($tableName, $tableColumn->getSchemaName(), $tableIndex); } else { self::$_connection->addIndex($tableName, $tableColumn->getSchemaName(), $tableIndex); } } else { $changed = false; if (count($tableIndex->getColumns()) != count($localIndexes[$tableIndex->getName()])) { $changed = true; } else { foreach ($tableIndex->getColumns() as $columnName) { if (!in_array($columnName, $localIndexes[$tableIndex->getName()])) { $changed = true; break; } } } if ($changed == true) { if ($tableIndex->getName() == 'PRIMARY') { self::$_connection->dropPrimaryKey($tableName, $tableColumn->getSchemaName()); self::$_connection->addPrimaryKey($tableName, $tableColumn->getSchemaName(), $tableIndex); } else { self::$_connection->dropIndex($tableName, $tableColumn->getSchemaName(), $tableIndex->getName()); self::$_connection->addIndex($tableName, $tableColumn->getSchemaName(), $tableIndex); } } } } foreach ($localIndexes as $indexName => $indexColumns) { if (!isset($indexes[$indexName])) { self::$_connection->dropIndex($tableName, null, $indexName); } } } } }