/**
* Control the main setup process
*
* @param array $data
* $data['data'] Data (array or ...) to store
* $data['file'] File to store
* $data['var_name'] Name of the data array or ...
* $data['type'] Data type
*/
function perform($data = FALSE)
{
// include PEAR Config class
include_once SF_BASE_DIR . 'modules/common/PEAR/Config.php';
$c = new Config();
$root =& $c->parseConfig($data['data'], $data['type']);
// save the modified config array
$c->writeConfig($data['file'], $data['type'], array('name' => $data['var_name']));
}
/**
* Control the main setup process
*
* @param array $data
*/
function perform($data)
{
// include PEAR Config class
include_once SF_BASE_DIR . 'modules/common/PEAR/Config.php';
$c = new Config();
$root =& $c->parseConfig($data, 'PHPArray');
// save the modified config array
$c->writeConfig(SF_BASE_DIR . 'modules/common/config/config.php', 'PHPArray', array('name' => 'this->B->sys'));
}
public function WriteSettings($configFilePath, $mergedSettings)
{
$this->CreateBackup($configFilePath);
if (!array_key_exists(Configuration::SETTINGS, $mergedSettings)) {
$mergedSettings = array(Configuration::SETTINGS => $mergedSettings);
}
$config = new Config();
$config->parseConfig($mergedSettings, 'PHPArray');
$config->writeConfig($configFilePath, 'PHPArray', $mergedSettings);
$this->AddErrorReporting($configFilePath);
}
function configureTestFromArray($aConfigurationEntries, $configFilename)
{
$config = new Config();
$configContainer =& $config->parseConfig(CONFIG_TEMPLATE, 'inifile');
foreach ($aConfigurationEntries as $configurationEntry) {
$aConfigurationEntry = explode("=", $configurationEntry);
list($configurationKey, $configurationValue) = $aConfigurationEntry;
list($sectionName, $variableName) = explode('.', $configurationKey);
$section =& $configContainer->getItem('section', $sectionName);
$section->setDirective($variableName, $configurationValue);
}
$config->writeConfig($configFilename, 'inifile');
}
function config()
{
if ($_POST) {
// Use the config lib to convert $_POST into something writable
$conf = Config::prepareConfigToWrite($_POST);
// Update config
Config::writeConfig($conf);
// Set flash message
Application::flash('success', 'App config updated!');
// Force redirect to reload app with new config
header('Location: ' . $_SERVER['HTTP_REFERER']);
exit;
}
$this->loadView('admin/config', null, 'admin');
}
/**
* Control the main setup process
*
* @param array $data
* $data['data'] Data (array or ...) to store
* $data['file'] File to store
* $data['var_name'] Name of the data array or ...
* $data['type'] Data type
* $data['reload'] Reload page if true
*
* @param array $data
*/
function perform(&$data)
{
// include PEAR Config class
include_once SF_BASE_DIR . 'modules/common/PEAR/Config.php';
$c = new Config();
$root =& $c->parseConfig($data['data'], $data['type']);
// save the modified config array
$c->writeConfig($data['file'], $data['type'], array('name' => $data['var_name']));
if ($data['reload'] == TRUE) {
// reload page
@header('Location: ' . SF_BASE_LOCATION . '/' . SF_CONTROLLER . '?' . SF_ADMIN_CODE . '=1');
exit;
}
return SF_IS_VALID_ACTION;
}
/**
* test to ensure that special characters
* are written and read correctly
* IniCommented config class should quote all special chars
* except backslash and single quote
*
* note: parse_ini_file() will break array on double quote
*
*/
function test_iniFile()
{
$min = 32;
$max = 126;
for ($i = $min; $i <= $max; $i++) {
if ($i == 34 || $i == 36) {
// '"' (any version) and '$' (5.3) break the test
continue;
}
$aIni = array();
$aIni['test1'][$i] = 'test' . chr($i);
$aIni['test2'][$i] = chr($i) . 'test';
$aIni['test3'][$i] = 'te' . chr($i) . 'st';
$ini = MAX_PATH . '/var/test_' . $i . '.ini';
$oConfig = new Config();
$oConfig->parseConfig($aIni, 'phpArray');
$this->assertTrue($oConfig->writeConfig($ini, 'IniCommented'));
$aResult = @parse_ini_file($ini, true);
$this->assertEqual($aResult['test1'][$i], $aIni['test1'][$i], 'ERROR:' . $i);
$this->assertEqual($aResult['test2'][$i], $aIni['test2'][$i], 'ERROR:' . $i);
$this->assertEqual($aResult['test3'][$i], $aIni['test3'][$i], 'ERROR:' . $i);
@unlink($ini);
}
}
/**
* A method to write the configuration file for plugin. Also creates "fake"
* configuration files when required by multi-host installations.
*
* @static
* @param array $aConfig The configuration array to save as a configuration file.
* @param string $module The plugin module name (i.e. /plugins/module directory).
* @param string $package An optional plugin package name (i.e. /plugins/module/package
* directory). If not given, writes the module level
* configuration file path.
* @param string $name An optional plugin name (i.e. /plugins/module/package/plugin.plugin.php).
* If not given, writes the package level configuration file, or
* the module level configuration file, depending on the $package
* parameter.
* @return boolean True on success, false otherwise.
*/
function writePluginConfig($aConfig, $module, $package = null, $name = null)
{
$conf = $GLOBALS['_MAX']['CONF'];
// Prepare the config file for writing, using the delivery engine
// host as the hostname for the "real" config file
$url = @parse_url('http://' . $conf['webpath']['delivery']);
if (!isset($url['host'])) {
return false;
}
$deliveryHost = $url['host'];
$configFileName = MAX_Plugin::getConfigFileName($module, $package, $name, false, $deliveryHost);
if (!file_exists($configFileName)) {
MAX_Plugin::copyDefaultConfig($module, $package, $name);
}
// Create a new config class, parse the config array, and write to disk
$oConfig = new Config();
$oConfig->parseConfig($aConfig, 'phpArray');
$result = $oConfig->writeConfig($configFileName, 'inifile');
if ($result == false || PEAR::isError($result)) {
return false;
}
// Check the other possible host names, and write out the fake
// configuration files if different
$url = @parse_url('http://' . $conf['webpath']['admin']);
if (isset($url['host'])) {
$adminHost = $url['host'];
if ($adminHost != $deliveryHost) {
// Create fake file for this host
$configFileName = MAX_Plugin::getConfigFileName($module, $package, $name, false, $adminHost);
$aConfig = array('realConfig' => $deliveryHost);
$oConfig = new Config();
$oConfig->parseConfig($aConfig, 'phpArray');
if (!$oConfig->writeConfig($configFileName, 'inifile')) {
return false;
}
}
}
$url = @parse_url('http://' . $conf['webpath']['deliverySSL']);
if (isset($url['host'])) {
$deliverySslHost = $url['host'];
if ($deliverySslHost != $deliveryHost) {
// Create fake file for this host
$configFileName = MAX_Plugin::getConfigFileName($module, $package, $name, false, $deliverySslHost);
$aConfig = array('realConfig' => $deliveryHost);
$oConfig = new Config();
$oConfig->parseConfig($aConfig, 'phpArray');
if (!$oConfig->writeConfig($configFileName, 'inifile')) {
return false;
}
}
}
return true;
}
if (!empty($_POST)) {
require_once 'includes/config.php';
require_once 'includes/database.php';
$config = new Config();
$db = new Database();
if ($config->checkPostData($_POST)) {
// if (!$db->createDatabase($_POST)) {
// $error = "The database could not be created, please verify your settings.";
// } else
if (!$db->createTable($_POST)) {
$error = "The database tables could not be created, please verify your settings.";
} else {
if (!$db->createAdmin($_POST)) {
$error = "The admin details could not be saved. Please verify.";
} else {
if (!$config->writeConfig($_POST)) {
$error = "The configuration file could not be written, \n please chmod the files to 0777";
} else {
if (!$config->createExtraction($_POST['base_url'])) {
$error = "The extraction js file could not be written, \n please chmod the files to 0777";
}
}
}
}
if (!isset($error)) {
header('Location: ' . $redirect_url . 'status.php?status=1');
exit;
}
} else {
$error = "Please fill out all the fields";
}
// Parses and writes an existing php array $conf
$conf['storage']['driver'] = 'sql';
$conf['storage']['params']['phptype'] = 'mysql';
$conf['storage']['params']['hostspec'] = 'localhost';
$conf['storage']['params']['username'] = '******';
$conf['storage']['params']['password'] = '******';
$conf['menu']['apps'] = array('imp', 'turba');
$conf['stdcontent']['para'][0] = 'This is really cool !';
$conf['stdcontent']['para'][1] = 'It just rocks...';
$c = new Config();
$root =& $c->parseConfig($conf, 'phparray');
$storage =& $root->getItem('section', 'storage');
$storage->removeItem();
$root->addItem($storage);
echo '<pre>' . $root->toString('phparray', array('name' => 'test')) . '</pre>';
if ($c->writeConfig('/tmp/Config_Test.php', 'phparray', array('name' => 'test')) === true) {
echo 'Config written into /tmp/Config_Test.php';
}
// Making a php ini file with $storage only
$ini = new Config();
$iniRoot =& $ini->getRoot();
$iniRoot->addItem($storage);
$comment =& new Config_Container('comment', null, 'This is the php ini version of storage');
$iniRoot->addItem($comment, 'top');
$iniRoot->createBlank('after', $comment);
echo '<pre>' . $iniRoot->toString('inicommented') . '</pre>';
// Gonna make an array with it
echo '<pre>';
var_dump($iniRoot->toArray());
echo '</pre>';
// Now, I'll parse you php.ini file and make it a php array
function writeDefaultConfigFile($configPath, $configFile, $newHost)
{
$file = $configPath . '/default' . $configFile . '.conf.php';
if (!OA_Admin_Settings::isConfigWritable($file)) {
return false;
}
$aConfig = array('realConfig' => $newHost);
$oConfig = new Config();
$oConfigContainer =& $oConfig->parseConfig($aConfig, 'phpArray');
$oConfigContainer->createComment('*** DO NOT REMOVE THE LINE ABOVE ***', 'top');
$oConfigContainer->createComment('<' . '?php exit; ?>', 'top');
return $oConfig->writeConfig($file, 'IniCommented');
}
/**
* Creating the config file
*
* @param array $answers The $answers passed over from the run() method.
*
* @return bool True on success, otherwise false.
*/
function setupEnvironment($answers)
{
$this->_ui->outputData('Writing config file');
$config = new Config();
$root = $config->getRoot();
$root->createItem('directive', strtoupper('path_include'), '@php-dir@');
foreach ($this->settings as $setting) {
$root->createItem('directive', strtoupper($setting), $answers[$setting]);
}
$error_check = $config->writeConfig($this->_config_file, 'phpconstants', array('name' => 'config'));
if (PEAR::isError($error_check)) {
$this->_ui->outputData($error_check->getMessage());
return false;
}
$this->_ui->outputData('Config file written: ' . $this->_config_file);
return true;
}
/**
* A method to write a .links.ini file.
*
* @param string $file_links The path to the .links.ini file.
* @param array $link_array An array of all the links
* @return mixed PEAR_Error on error or true if ok.
*
* Array
* (
* [acls] => Array
* (
* [bannerid] => Array
* (
* [table] => banners
* [field] => bannerid
* )
*
* )
*
* )
*
* or
*
* Array
* (
* [acls] => Array
* (
* [bannerid] => banners:bannerid
*
* )
*
* )
*
*/
function writeLinksDotIni($file_links, $link_array)
{
$links = new Config();
$root =& $links->parseConfig($file_links, 'inifile');
$root = $root->toArray();
$root = $root['root'];
foreach ($link_array as $table => $array) {
foreach ($array as $k => $v) {
if (is_array($v)) {
$array[$k] = "{$v['table']}:{$v['field']}";
}
}
if (count($array)) {
$root[$table] = $array;
} else {
unset($root[$table]);
}
}
ksort($root);
$links = new Config();
$links->parseConfig($root, 'phparray');
return $links->writeConfig($file_links, 'inifile');
}
/**
* Create config for adm
*
*/
public function createAdmConfig($servarray)
{
//check for the directory structure
if (!file_exists($this->objConfig->getcontentBasePath() . 'adm/')) {
mkdir($this->objConfig->getcontentBasePath() . 'adm/', 0777);
}
// write the server list file
$cfile = $this->objConfig->getcontentBasePath() . 'adm/adm.xml';
if (!file_exists($cfile)) {
$conf = new Config_Container('section', 'adm');
//$servarray['name']);
$conf_serv =& $conf->createSection($servarray['name']);
$conf_serv->createDirective('servername', $servarray['name']);
$conf_serv->createDirective('serverapiurl', $servarray['url']);
$conf_serv->createDirective('serveremail', $servarray['email']);
$conf_serv->createDirective('regtime', date('r'));
$config = new Config();
$config->setRoot($conf);
// write the container to an XML document
$config->writeConfig($cfile, 'XML');
} else {
// update the xml with the new server
$root =& $config->parseConfig($cfile, 'XML', array('name' => 'adm'));
log_debug($root);
$conf_serv =& $root->createSection($servarray['name']);
$conf_serv->createDirective('servername', $servarray['name']);
$conf_serv->createDirective('serverapiurl', $servarray['url']);
$conf_serv->createDirective('serveremail', $servarray['email']);
$conf_serv->createDirective('regtime', date('r'));
$config = new Config();
$config->setRoot($root);
// write the container to an XML document
$config->writeConfig($cfile, 'XML');
}
}
/**
* Saves the folders into a config file that can be edited by hand.
* If you don't specify the config file, it will be determined
* automatically.
* Values that are NULL won't be saved.
*
* @param string $strFile The file to save the data into
* (ini file)
* @param boolean $bSaveAllSettings If all settings shall be saved
* that can be loaded, or only that settings,
* that have been retrieved by the user
*
* @return mixed True on success, PEAR_Error on failure
*
* @access public
*/
function saveToFile($strFile = null, $bSaveAllSettings = true)
{
$conf =& new Config_Container('section', 'paths');
if ($bSaveAllSettings) {
foreach ($this->arSettings as $strSetting) {
$strFunction = 'get' . $strSetting;
$strValue = $this->{$strFunction}();
$conf->createDirective(strtolower($strSetting), $strValue);
}
} else {
foreach ($this->arCache as $strId => $strValue) {
$conf->createDirective($strId, $strValue);
}
}
$config = new Config();
$config->setRoot($conf);
return $config->writeConfig($this->getDefaultConfigFile(), 'inifile');
}
