/** * Returns true if the file is a valid upload, after making it go through all * our tests. * * @param upload An FileUpload object containing information about the file * @return Returns true if it is valid or a negative value meaning an error otherwise: * <ul><li>ERROR_UPLOAD_TOO_BIG (-1): The file bigger than the maximum allowed size</li> * <li>ERROR_FORBIDDEN_EXTENSION: The file has a forbidden extension.</li></ul> */ function validate($upload) { $config =& Config::getConfig(); $forbiddenFilesStr = $config->getValue("upload_forbidden_files"); $maxUploadSize = $config->getValue("maximum_file_upload_size"); // check if we received an object of the right type, or else just quit if ($upload == null) { return false; } // first of all, check the size if ($maxUploadSize != 0 && $upload->getSize() > $maxUploadSize) { return UPLOAD_VALIDATOR_ERROR_UPLOAD_TOO_BIG; } // return true if there's nothing to do if (empty($forbiddenFilesStr) || !$forbiddenFilesStr) { return true; } // check if the filename extension is forbidden or not $fileName = basename($upload->getFileName()); foreach (explode(" ", $forbiddenFilesStr) as $file) { if (Glob::myFnmatch($file, $fileName)) { return UPLOAD_VALIDATOR_ERROR_FORBIDDEN_EXTENSION; } } return true; }
public function testGetConfig() { $this->baseDir->expects($this->any())->method('getRelativePath')->will($this->returnCallback(function ($path) { return 'relative/' . $path; })); $this->baseDir->expects($this->any())->method('readFile')->will($this->returnCallback(function ($file) { return $file . ' content'; })); $fileOne = $this->getMock('\\Magento\\Framework\\View\\File', array(), array(), '', false); $fileOne->expects($this->once())->method('getFilename')->will($this->returnValue('file_one.js')); $fileOne->expects($this->once())->method('getModule')->will($this->returnValue('Module_One')); $fileTwo = $this->getMock('\\Magento\\Framework\\View\\File', array(), array(), '', false); $fileTwo->expects($this->once())->method('getFilename')->will($this->returnValue('file_two.js')); $theme = $this->getMockForAbstractClass('\\Magento\\Framework\\View\\Design\\ThemeInterface'); $this->design->expects($this->once())->method('getDesignTheme')->will($this->returnValue($theme)); $this->fileSource->expects($this->once())->method('getFiles')->with($theme, Config::CONFIG_FILE_NAME)->will($this->returnValue(array($fileOne, $fileTwo))); $expected = <<<expected (function(require){ relative/%s/paths-updater.js content (function() { relative/file_one.js content require.config(mageUpdateConfigPaths(config, 'Module_One')) })(); (function() { relative/file_two.js content require.config(mageUpdateConfigPaths(config, '')) })(); })(require); expected; $actual = $this->object->getConfig(); $this->assertStringMatchesFormat($expected, $actual); }
function perform() { // update the plugin configurations to blog setting $config =& Config::getConfig(); $config->setValue("plugin_moblog_mailserver", $this->_mailServer); $config->setValue("plugin_moblog_port", $this->_port); $config->setValue("plugin_moblog_username", $this->_userName); $config->setValue("plugin_moblog_password", $this->_password); $config->setValue("plugin_moblog_pseudobatch", $this->_pseudoBatch); if (!$config->save()) { $this->_view = new AdminMoblogBatchPluginSettingsView($this->_blogInfo); $this->_view->setErrorMessage($this->_locale->tr("error_updating_settings")); $this->setCommonData(); return false; } // if everything went ok... $this->_session->setValue("blogInfo", $this->_blogInfo); $this->saveSession(); $this->_view = new AdminMoblogBatchPluginSettingsView($this->_blogInfo); $this->_view->setSuccessMessage($this->_locale->tr("moblog_settings_saved_ok")); $this->setCommonData(); // clear the cache CacheControl::resetBlogCache($this->_blogInfo->getId()); return true; }
/** * Constructor. * * @param actionInfo An ActionInfo object as provided by the constroller * @param request A valid HTTP request */ function AdminAction($actionInfo, $request) { $this->Action($actionInfo, $request); // get information about the session $session = HttpVars::getSession(); $this->_session = $session["SessionInfo"]; $this->_config =& Config::getConfig(); // get the information about the user and quit if we don't have it... $this->_getUserInfo(); if ($this->_userInfo == "") { header("HTTP/1.0 403 Forbidden"); print $this->mustAuthenticatePage(); die; } // do the same with the information about the blog $this->_getBlogInfo(); if ($this->_blogInfo == "") { if ($this->_actionInfo->getActionParamValue() != "blogSelect") { header("HTTP/1.0 403 Forbidden"); print $this->mustAuthenticatePage(); die; } } // prepare the plugin manager in case we'd like to throw events $this->_pm =& PluginManager::getPluginManager(); // fetch the site locale $this->_locale =& $this->getLocale(); $users =& new Users(); $this->_userBlogs = $users->getUsersBlogs($this->_userInfo->getId(), BLOG_STATUS_ACTIVE); }
public function configureTemplateAction() { $CC_CONFIG = Config::getConfig(); $baseUrl = Application_Common_OsPath::getBaseDir(); $this->view->headScript()->appendFile($baseUrl . 'js/airtime/playouthistory/configuretemplate.js?' . $CC_CONFIG['airtime_version'], 'text/javascript'); $this->view->headLink()->appendStylesheet($baseUrl . 'css/history_styles.css?' . $CC_CONFIG['airtime_version']); try { $templateId = $this->_getParam('id'); $historyService = new Application_Service_HistoryService(); $template = $historyService->loadTemplate($templateId); $templateType = $template["type"]; $supportedTypes = $historyService->getSupportedTemplateTypes(); if (!in_array($templateType, $supportedTypes)) { throw new Exception("Error: {$templateType} is not supported."); } $getMandatoryFields = "mandatory" . ucfirst($templateType) . "Fields"; $mandatoryFields = $historyService->{$getMandatoryFields}(); $this->view->template_id = $templateId; $this->view->template_name = $template["name"]; $this->view->template_fields = $template["fields"]; $this->view->template_type = $templateType; $this->view->fileMD = $historyService->getFileMetadataTypes(); $this->view->fields = $historyService->getFieldTypes(); $this->view->required_fields = $mandatoryFields; $this->view->configured = $historyService->getConfiguredTemplateIds(); } catch (Exception $e) { Logging::info("Error?"); Logging::info($e); Logging::info($e->getMessage()); $this->_forward('index', 'playouthistorytemplate'); } }
function perform() { // fetch the data $this->_userName = $this->_request->getValue("userName"); $this->_userEmail = $this->_request->getValue("userEmail"); // try to see if there is a user who has this username and uses the // given mailbox as the email address $users = new Users(); $userInfo = $users->getUserInfoFromUsername($this->_userName); // if the user doesn't exist, quit if (!$userInfo) { $this->_view = new SummaryView("resetpassword"); $this->_form->setFieldValidationStatus("userName", false); $this->setCommonData(true); return false; } // if the user exists but this is not his/her mailbox, then quit too if ($userInfo->getEmail() != $this->_userEmail) { $this->_view = new SummaryView("resetpassword"); $this->_form->setFieldValidationStatus("userEmail", false); $this->setCommonData(true); return false; } // if everything's fine, then send out the email message with a request to // reset the password $requestHash = SummaryTools::calculatePasswordResetHash($userInfo); $config =& Config::getConfig(); $baseUrl = $config->getValue("base_url"); $resetUrl = $baseUrl . "/summary.php?op=setNewPassword&a={$requestHash}&b=" . md5($userInfo->getUsername()); SummaryTools::sendResetEmail($userInfo, $resetUrl); $this->_view = new SummaryMessageView($this->_locale->tr("password_reset_message_sent_ok")); $this->setCommonData(); return true; }
function render() { // call the render method in the main view class... it will take care of sending the headers // for us and so on... parent::render(); // if there is no resource to send... then we can quit right away! if ($this->_resource == null) { return; } // let's see if we really need to send some data or not... // send also some headers that will help caching, if configured to do so $config =& Config::getConfig(); $useCaching = $config->getValue('resource_server_http_cache_enabled'); if ($useCaching) { // send the "Last-Modified" header $resDate = $this->_resource->getTimestamp(); $lastModified = $resDate->getDate(DATE_FORMAT_UNIXTIME); $cacheLifetime = $config->getValue('resource_server_http_cache_lifetime', DEFAULT_HTTP_CACHE_LIFETIME); // check if we have to resent the data and if not, then we're done! if (HttpCache::httpConditional($lastModified, $cacheLifetime)) { exit; } } // if we need to send something, then let's do it now and finish if ($this->_mode == RESOURCE_VIEW_MODE_PREVIEW) { print $this->_resource->getPreview(); } elseif ($this->_mode == RESOURCE_VIEW_MODE_MEDIUM) { print $this->_resource->getMediumSizePreview(); } else { while ($chunk =& $this->_resource->getDataChunk(RESOURCE_DEFAULT_CHUNK_SIZE)) { echo $chunk; } } return true; }
/** * Constructor. * * @param templateFile Complete path to the template file we are going to render */ function Template($templateFile) { // initialize logging $this->log =& LoggerManager::getLogger("default"); // create the Smarty object and set the security values $this->Smarty(); $this->caching = false; //$this->cache_lifetime = $cacheLifetime; $config =& Config::getConfig(); $this->cache_dir = $config->getValue('temp_folder'); $this->_templateFile = $templateFile; // enable the security settings $this->php_handling = false; // code is not allowed in the templates by default, unless specified otherwise /*if( $config->getValue( 'allow_php_code_in_templates', false )) $this->security = true; else $this->security = false;*/ $this->security = (bool) (!$config->getValue('allow_php_code_in_templates', false)); //$this->security = true; $this->secure_dir = array("./templates/admin", "./templates/"); // default folders $this->compile_dir = $config->getValue('temp_folder'); $this->template_dir = $config->getValue('template_folder'); $this->compile_check = $config->getValue('template_compile_check', true); // this helps if php is running in 'safe_mode' $this->use_sub_dirs = false; // register dynamic block for every template instance $this->register_block('dynamic', 'smarty_block_dynamic', false); }
public function init() { $CC_CONFIG = Config::getConfig(); // Set the method for the display form to POST $this->setMethod('post'); $this->setDecorators(array(array('ViewScript', array('viewScript' => 'form/login.phtml')))); // Add username element $this->addElement('text', 'username', array('label' => _('Username:'******'class' => 'input_text', 'required' => true, 'value' => isset($CC_CONFIG['demo']) && $CC_CONFIG['demo'] == 1 ? 'admin' : '', 'filters' => array('StringTrim'), 'validators' => array('NotEmpty'), 'decorators' => array('ViewHelper'))); // Add password element $this->addElement('password', 'password', array('label' => _('Password:'******'class' => 'input_text', 'required' => true, 'value' => isset($CC_CONFIG['demo']) && $CC_CONFIG['demo'] == 1 ? 'admin' : '', 'filters' => array('StringTrim'), 'validators' => array('NotEmpty'), 'decorators' => array('ViewHelper'))); $locale = new Zend_Form_Element_Select("locale"); $locale->setLabel(_("Language:")); $locale->setMultiOptions(Application_Model_Locale::getLocales()); $locale->setDecorators(array('ViewHelper')); $this->addElement($locale); $recaptchaNeeded = false; if (Application_Model_LoginAttempts::getAttempts($_SERVER['REMOTE_ADDR']) >= 3) { $recaptchaNeeded = true; } if ($recaptchaNeeded) { // recaptcha $this->addRecaptcha(); } // Add the submit button $this->addElement('submit', 'submit', array('ignore' => true, 'label' => _('Login'), 'class' => 'ui-button ui-widget ui-state-default ui-button-text-only center', 'decorators' => array('ViewHelper'))); }
/** * Test the fetch of just one configuration key */ public function testGetConfigOneKey() { $path = __DIR__ . '/' . $this->path; $config = new Config($path); $result = $config->getConfig('event/add'); $this->assertTrue($result instanceof \Psecio\Invoke\RouteContainer); }
function unpack($file, $destFolder) { // get the paths where tar and gz are $config =& Config::getConfig(); $tarPath = $config->getValue("path_to_tar"); if ($tarPath == "") { $tarPath = DEFAULT_TAR_PATH; } $gzipPath = $config->getValue("path_to_gzip"); if ($gzipPath == "") { $gzipPath = DEFAULT_GZIP_PATH; } // and now build the command //$file = escapeshellarg($file); //$destFolder = escapeshellarg($destFolder); // // :DANGER: // what if the user voluntarily sets the path of gzip and tar // to something else? we are doing no checks here to make sure that // the user is giving us a valid commnand so... how could we make // sure that it'll work? // $cmd = "{$gzipPath} -dc {$file} | {$tarPath} xv -C {$destFolder}"; $result = exec($cmd, $output, $retval); // // :KLUDGE: // apparently, we should get something in $retval but there's nothing // to the only way I've found to check if the command finished // successfully was checking if the $output array is full or empty // if (empty($output)) { return false; } return true; }
public static function GetMonitStatus($p_ip) { $CC_CONFIG = Config::getConfig(); $monit_user = $CC_CONFIG['monit_user']; $monit_password = $CC_CONFIG['monit_password']; $url = "http://{$p_ip}:2812/_status?format=xml"; $ch = curl_init(); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_USERPWD, "{$monit_user}:{$monit_password}"); //wait a max of 3 seconds before aborting connection attempt curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3); $result = curl_exec($ch); $info = curl_getinfo($ch); curl_close($ch); $docRoot = null; if ($result !== FALSE && $info["http_code"] === 200) { if ($result != "") { $xmlDoc = new DOMDocument(); $xmlDoc->loadXML($result); $docRoot = $xmlDoc->documentElement; } } return $docRoot; }
/** * Checks whether incoming comments are not bigger than our configurable threshold, via * the 'maximum_comment_size' config setting * * @return A PipelineResult object */ function filter() { // check if we're posting a comment $request = $this->_pipelineRequest->getHttpRequest(); if ($request->getValue("op") != "AddComment") { return new PipelineResult(); } // get the value of the maximum size of a comment, in bytes $config =& Config::getConfig(); $maxSize = $config->getValue("maximum_comment_size"); // if it's 0 or negative, it can be as big // as needed if ($maxSize <= 0) { return new PipelineResult(); } // otherwise, let's check $commentSize = strlen($request->getValue("commentText")); $topicSize = strlen($request->getValue("commentTopic")); if ($commentSize >= $maxSize || $topicSize >= $maxSize) { $result = new PipelineResult(false, COMMENT_FILTER_MAXIMUM_SIZE_EXCEEDED, "The comment is too big"); return $result; } $result = new PipelineResult(); return $result; }
protected static function write($type, $msg) { $config = \Config::getConfig(); $error_level = $config->get('log_level', self::HAYATE_LOG_OFF); if ($type <= $error_level) { $logdir = $config->get('log_dir', FALSE); try { if (is_dir($logdir) || @mkdir($logdir)) { $filename = rtrim($logdir, '\\//') . '/log-' . date('Y-m-d') . '.log'; $logfile = new \SplFileObject($filename, 'a'); self::header($type, $logfile); if (!is_string($msg)) { $msg = print_r($msg, TRUE); } $logfile->fwrite($msg); self::footer($logfile); } else { throw new \Exception(sprintf(_('Log directory %s does not exists and could not be created.'), $logdir)); } } catch (\Exception $ex) { if (!isset($filename)) { $filename = 'not found'; } trigger_error(sprintf(_('Failed to write to log file: "%s", %s'), $filename, $ex->getMessage()), E_USER_NOTICE); } } }
public static function setModuleMessages($moduleName = '', $prefix = 'ms_') { $prefix = strtolower($prefix); $moduleName = strtolower($moduleName); $lang = Config::getConfig('LANG'); if ($moduleName == '' || $moduleName == 'core') { $root = Config::getConfig('CORE_ROOT'); $prefix .= 'core_'; } else { $root = Config::getConfig('PACKAGES_ROOT') . $moduleName . '/'; $prefix .= $moduleName . '_'; } $dir = $root . 'loc/' . $lang . '/'; if (is_dir($dir)) { if ($dh = opendir($dir)) { while (($file = readdir($dh)) !== false) { if ($file != '.' && $file != '..') { $arMessages = array(); require_once $dir . $file; foreach ($arMessages as $field => $text) { static::$arMessage[strtoupper($prefix) . strtoupper($field)] = $text; } } } closedir($dh); } } }
/** * Goes through the array of files and processes them accordingly. * The result is an array of the appropiate Resource class that has been * created using the ResourceFactory class. * * @return An array of Upload objects that have already been moved to a safer * location. */ function process($destinationFolder) { // first, check if the upload feature is available $config =& Config::getConfig(); if (!$config->getValue("uploads_enabled")) { return FILE_UPLOADS_NOT_ENABLED; } // array used to store the files that have already been saved $uploads = array(); if ($destinationFolder[strlen($destinationFolder - 1)] != "/") { $destinationFolder .= "/"; } foreach ($this->_files as $file) { $upload = new FileUpload($file); $fileName = $upload->getFileName(); if ($this->my_move_uploaded_file($upload->getTmpName(), $destinationFolder . $fileName)) { $upload->setFolder($destinationFolder); $upload->setError(0); } else { $upload->setError(1); } array_push($uploads, $upload); } return $uploads; }
function render() { // load some configuration settings $config =& Config::getConfig(); $mailServer = $config->getValue("plugin_moblog_mailserver"); $port = $config->getValue("plugin_moblog_port"); if ($port == "") { $port = "110"; } $userName = $config->getValue("plugin_moblog_username"); $password = $config->getValue("plugin_moblog_password"); $pseudoBatch = $config->getValue("plugin_moblog_pseudobatch"); if ($pseudoBatch == "") { $pseudoBatch = "Off"; } $lastUpdate = $config->getValue("plugin_moblog_lastupdate"); // create a view and export the settings to the template $this->setValue("mailServer", $mailServer); $this->setValue("port", $port); $this->setValue("userName", $userName); $this->setValue("password", $password); $this->setValue("pseudoBatch", $pseudoBatch); $this->setValue("lastUpdate", $lastUpdate); parent::render(); }
public function passwordRestoreAction() { $CC_CONFIG = Config::getConfig(); $baseUrl = Application_Common_OsPath::getBaseDir(); $this->view->headScript()->appendFile($baseUrl . 'js/airtime/login/password-restore.js?' . $CC_CONFIG['airtime_version'], 'text/javascript'); $request = $this->getRequest(); Application_Model_Locale::configureLocalization($request->getcookie('airtime_locale', 'en_CA')); if (!Application_Model_Preference::GetEnableSystemEmail()) { $this->_redirect('login'); } else { //uses separate layout without a navigation. $this->_helper->layout->setLayout('login'); $form = new Application_Form_PasswordRestore(); $request = $this->getRequest(); if ($request->isPost() && $form->isValid($request->getPost())) { if (is_null($form->username->getValue()) || $form->username->getValue() == '') { $user = CcSubjsQuery::create()->filterByDbEmail($form->email->getValue())->findOne(); } else { $user = CcSubjsQuery::create()->filterByDbEmail($form->email->getValue())->filterByDbLogin($form->username->getValue())->findOne(); } if (!empty($user)) { $auth = new Application_Model_Auth(); $success = $auth->sendPasswordRestoreLink($user, $this->view); if ($success) { $this->_helper->redirector('password-restore-after', 'login'); } else { $form->email->addError($this->view->translate(_("Email could not be sent. Check your mail server settings and ensure it has been configured properly."))); } } else { $form->email->addError($this->view->translate(_("Given email not found."))); } } $this->view->form = $form; } }
function PasswordValidator() { $this->Validator(); $config =& Config::getConfig(); $this->addRule(new NonEmptyRule()); $this->addRule(new RangeRule($config->getValue("minimum_password_length", MIN_PASSWORD_LENGTH_DEFAULT), 32)); }
/** * logs a simple message to the log file, using the "debug" priority */ function Log($message) { $config =& Config::getConfig(); if ($config->getValue("moblog_logging_enabled")) { $logger =& LoggerManager::getLogger(); $logger->debug($message); } }
public function updateVariables() { $CC_CONFIG = Config::getConfig(); $isDemo = isset($CC_CONFIG['demo']) && $CC_CONFIG['demo'] == 1; $master_dj_connection_url = Application_Model_Preference::GetMasterDJSourceConnectionURL(); $live_dj_connection_url = Application_Model_Preference::GetLiveDJSourceConnectionURL(); $this->setDecorators(array(array('ViewScript', array('viewScript' => 'form/preferences_livestream.phtml', 'master_dj_connection_url' => $master_dj_connection_url, 'live_dj_connection_url' => $live_dj_connection_url, 'isDemo' => $isDemo)))); }
/** * @covers ::__construct * @dataProvider constructorProvider */ public function testConstructor($args, $bucket_name, $sqs_url, $send_to_s3) { $configuration = new Config($args, $bucket_name, $sqs_url, $send_to_s3); $this->assertSame($args, $configuration->getConfig()); $this->assertSame($bucket_name, $configuration->getBucketName()); $this->assertSame($sqs_url, $configuration->getSqsUrl()); $this->assertSame($send_to_s3, $configuration->getSendToS3()); }
public function __construct() { require_once './config/Config.php'; $config = Config::getConfig(); if (self::$conn == null) { self::$conn = mysqli_connect($config['host'], $config['username'], $config['password'], $config['dbname']); } }
public function setPassword($password) { $Config = Config::getConfig(); if ($Config->useHashedPasswords === true) { $this->password = sha1($password . $Config->authSalt); } else { $this->password = $password; } }
protected function isMethod() { $str = Config::getConfig('method'); $methods = explode(',', $str); if (!in_array($this->request->method, $methods)) { $message = StatusCodeManager::getTranslation('405'); throw new ZebraStatusException($message, '405'); } }
public static function record($str, $priority, $scope = "") { $pid = getmypid(); if (self::$recordMode == NULL) { $mode = Config::getConfig('mode'); self::$recordMode = RecordModeFactory::getRecord($mode); } self::$recordMode->record($str, "WARN", $scope); }
/** * The constructor only initializes the validator and depending on the * value of check_email_address_validity, it will also add a EmailDnsRule * rule to check for the validity of the mailbox in the given email server */ function EmailValidator() { $this->Validator(); $this->addRule(new EmailFormatRule()); $config =& Config::getConfig(); if ($config->getValue("check_email_address_validity")) { $this->addRule(new EmailDnsRule()); } }
/** * Fetches the information for this blog from the database since we are going to need it * almost everywhere. */ function _getBlogInfo() { // see if we're using subdomains $config =& Config::getConfig(); if ($config->getValue("subdomains_enabled")) { $subdomainInfo = Subdomains::getSubdomainInfoFromRequest(); if ($subdomainInfo["username"] != "" && $this->_request->getValue('blogUserName') == "") { $this->_request->setValue('blogUserName', $subdomainInfo["username"]); } if ($subdomainInfo["blogname"] != "" && $this->_request->getValue('blogName') == "") { $this->_request->setValue('blogName', $subdomainInfo["blogname"]); } } $blogId = $this->_request->getValue('blogId'); $blogName = $this->_request->getValue('blogName'); $userId = $this->_request->getValue('userId'); $userName = $this->_request->getValue('blogUserName'); // if there is a "blogId" parameter, it takes precedence over the // "user" parameter. if (!$blogId && !$blogName) { // check if there was a user parameter if (!empty($userName)) { // if so, check to which blogs the user belongs $users = new Users(); $userInfo = $users->getUserInfoFromUsername($userName); // if the user exists and is valid... if ($userInfo) { $userBlogs = $users->getUsersBlogs($userInfo->getId(), BLOG_STATUS_ACTIVE); // check if he or she belogs to any blog. If he or she does, simply // get the first one (any better rule for this?) if (!empty($userBlogs)) { $blogId = $userBlogs[0]->getId(); } else { $blogId = $this->_config->getValue('default_blog_id'); } } else { $blogId = $this->_config->getValue('default_blog_id'); } } else { // if there is no user parameter, we take the blogId from the session if ($this->_session->getValue('blogId') != '') { $blogId = $this->_session->getValue('blogId'); } else { // get the default blog id from the database $blogId = $this->_config->getValue('default_blog_id'); } } } // fetch the BlogInfo object $blogs = new Blogs(); if ($blogId) { $this->_blogInfo = $blogs->getBlogInfo($blogId); } else { $this->_blogInfo = $blogs->getBlogInfoByName($blogName); } }
public function checkAuth() { $CC_CONFIG = Config::getConfig(); $api_key = $this->_getParam('api_key'); if (!in_array($api_key, $CC_CONFIG["apiKey"]) && is_null(Zend_Auth::getInstance()->getStorage()->read())) { header('HTTP/1.0 401 Unauthorized'); print _('You are not allowed to access this resource.'); exit; } }
function UsernameValidator() { $this->Validator(); $this->addRule(new NonEmptyRule()); $this->addRule(new RegExpRule(ONLY_ALPHANUMERIC_REGEXP)); $config =& Config::getConfig(); $forbiddenUsernames = $config->getValue("forbidden_usernames", ""); $forbiddenUsernamesArray = explode(" ", $forbiddenUsernames); $this->addRule(new FilteredWordsRule($forbiddenUsernamesArray)); }