/** * Delete groups * * @param array $groupids array of group ids * @since Moodle 2.2 */ public static function delete_groups($groupids) { global $CFG, $DB; require_once "{$CFG->dirroot}/group/lib.php"; $params = self::validate_parameters(self::delete_groups_parameters(), array('groupids' => $groupids)); $transaction = $DB->start_delegated_transaction(); foreach ($params['groupids'] as $groupid) { // validate params $groupid = validate_param($groupid, PARAM_INT); if (!($group = groups_get_group($groupid, '*', IGNORE_MISSING))) { // silently ignore attempts to delete nonexisting groups continue; } // now security checks $context = context_course::instance($group->courseid, IGNORE_MISSING); try { self::validate_context($context); } catch (Exception $e) { $exceptionparam = new stdClass(); $exceptionparam->message = $e->getMessage(); $exceptionparam->courseid = $group->courseid; throw new moodle_exception('errorcoursecontextnotvalid', 'webservice', '', $exceptionparam); } require_capability('moodle/course:managegroups', $context); groups_delete_group($group); } $transaction->allow_commit(); }
public function test_validate_param() { try { $param = validate_param('11a', PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } $param = validate_param('11', PARAM_INT); $this->assertSame(11, $param); try { $param = validate_param(null, PARAM_INT, false); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } $param = validate_param(null, PARAM_INT, true); $this->assertSame(null, $param); try { $param = validate_param(array(), PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } try { $param = validate_param(new stdClass(), PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } $param = validate_param('1.0', PARAM_FLOAT); $this->assertSame(1.0, $param); // Make sure valid floats do not cause exception. validate_param(1.0, PARAM_FLOAT); validate_param(10, PARAM_FLOAT); validate_param('0', PARAM_FLOAT); validate_param('119813454.545464564564546564545646556564465465456465465465645645465645645645', PARAM_FLOAT); validate_param('011.1', PARAM_FLOAT); validate_param('11', PARAM_FLOAT); validate_param('+.1', PARAM_FLOAT); validate_param('-.1', PARAM_FLOAT); validate_param('1e10', PARAM_FLOAT); validate_param('.1e+10', PARAM_FLOAT); validate_param('1E-1', PARAM_FLOAT); try { $param = validate_param('1,2', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } try { $param = validate_param('', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } try { $param = validate_param('.', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } try { $param = validate_param('e10', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } try { $param = validate_param('abc', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (moodle_exception $ex) { $this->assertInstanceOf('invalid_parameter_exception', $ex); } }
function test_validate_param() { try { $param = validate_param('11a', PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param('11', PARAM_INT); $this->assertEqual($param, 11); } catch (invalid_parameter_exception $ex) { $this->fail('invalid_parameter_exception not expected'); } try { $param = validate_param(null, PARAM_INT, false); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param(null, PARAM_INT, true); $this->assertTrue($param === null); } catch (invalid_parameter_exception $ex) { $this->fail('invalid_parameter_exception expected'); } try { $param = validate_param(array(), PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param(new stdClass(), PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } }
/** * Updates a reference to the external resource and all files that use it * * This function is called after synchronisation of an external file and updates the * contenthash, filesize and status of all files that reference this external file * as well as time last synchronised. * * @param int $referencefileid * @param int $lastsync * @param int $lifetime argument not used any more, liefetime is returned by repository * @param string $contenthash * @param int $filesize * @param int $status 0 if ok or 666 if source is missing * @param int $timemodified last time modified of the source, if known */ public function update_references($referencefileid, $lastsync, $lifetime, $contenthash, $filesize, $status, $timemodified = null) { global $DB; $referencefileid = clean_param($referencefileid, PARAM_INT); $lastsync = clean_param($lastsync, PARAM_INT); validate_param($contenthash, PARAM_TEXT, NULL_NOT_ALLOWED); $filesize = clean_param($filesize, PARAM_INT); $status = clean_param($status, PARAM_INT); $params = array('contenthash' => $contenthash, 'filesize' => $filesize, 'status' => $status, 'referencefileid' => $referencefileid, 'timemodified' => $timemodified); $DB->execute('UPDATE {files} SET contenthash = :contenthash, filesize = :filesize, status = :status ' . ($timemodified ? ', timemodified = :timemodified' : '') . ' WHERE referencefileid = :referencefileid', $params); $data = array('id' => $referencefileid, 'lastsync' => $lastsync); $DB->update_record('files_reference', (object) $data); }
/** * Clean response * If a response attribute is unknown from the description, we just ignore the attribute. * If a response attribute is incorrect, invalid_response_exception is thrown. * Note: this function is similar to validate parameters, however it is distinct because * parameters validation must be distinct from cleaning return values. * * @param external_description $description description of the return values * @param mixed $response the actual response * @return mixed response with added defaults for optional items, invalid_response_exception thrown if any problem found * @author 2010 Jerome Mouneyrac * @since Moodle 2.0 */ public static function clean_returnvalue(external_description $description, $response) { if ($description instanceof external_value) { if (is_array($response) or is_object($response)) { throw new invalid_response_exception('Scalar type expected, array or object received.'); } if ($description->type == PARAM_BOOL) { // special case for PARAM_BOOL - we want true/false instead of the usual 1/0 - we can not be too strict here ;-) if (is_bool($response) or $response === 0 or $response === 1 or $response === '0' or $response === '1') { return (bool) $response; } } $debuginfo = 'Invalid external api response: the value is "' . $response . '", the server was expecting "' . $description->type . '" type'; try { return validate_param($response, $description->type, $description->allownull, $debuginfo); } catch (invalid_parameter_exception $e) { //proper exception name, to be recursively catched to build the path to the faulty attribut throw new invalid_response_exception($e->debuginfo); } } else { if ($description instanceof external_single_structure) { if (!is_array($response) && !is_object($response)) { throw new invalid_response_exception('Only arrays/objects accepted. The bad value is: \'' . print_r($response, true) . '\''); } // Cast objects into arrays. if (is_object($response)) { $response = (array) $response; } $result = array(); foreach ($description->keys as $key => $subdesc) { if (!array_key_exists($key, $response)) { if ($subdesc->required == VALUE_REQUIRED) { throw new invalid_response_exception('Error in response - Missing following required key in a single structure: ' . $key); } if ($subdesc instanceof external_value) { if ($subdesc->required == VALUE_DEFAULT) { try { $result[$key] = self::clean_returnvalue($subdesc, $subdesc->default); } catch (invalid_response_exception $e) { //build the path to the faulty attribut throw new invalid_response_exception($key . " => " . $e->getMessage() . ': ' . $e->debuginfo); } } } } else { try { $result[$key] = self::clean_returnvalue($subdesc, $response[$key]); } catch (invalid_response_exception $e) { //build the path to the faulty attribut throw new invalid_response_exception($key . " => " . $e->getMessage() . ': ' . $e->debuginfo); } } unset($response[$key]); } return $result; } else { if ($description instanceof external_multiple_structure) { if (!is_array($response)) { throw new invalid_response_exception('Only arrays accepted. The bad value is: \'' . print_r($response, true) . '\''); } $result = array(); foreach ($response as $param) { $result[] = self::clean_returnvalue($description->content, $param); } return $result; } else { throw new invalid_response_exception('Invalid external api response description'); } } } }
/** * Delete cohorts * * @param array $cohortids * @return null * @since Moodle 2.5 */ public static function delete_cohorts($cohortids) { global $CFG, $DB; require_once "{$CFG->dirroot}/cohort/lib.php"; $params = self::validate_parameters(self::delete_cohorts_parameters(), array('cohortids' => $cohortids)); $transaction = $DB->start_delegated_transaction(); foreach ($params['cohortids'] as $cohortid) { // Validate params. $cohortid = validate_param($cohortid, PARAM_INT); $cohort = $DB->get_record('cohort', array('id' => $cohortid), '*', MUST_EXIST); // Now security checks. $context = context::instance_by_id($cohort->contextid, MUST_EXIST); if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) { throw new invalid_parameter_exception('Invalid context'); } self::validate_context($context); require_capability('moodle/cohort:manage', $context); cohort_delete_cohort($cohort); } $transaction->allow_commit(); return null; }
/** * Clean response * If a response attribute is unknown from the description, we just ignore the attribute. * If a response attribute is incorrect, invalid_response_exception is thrown. * Note: this function is similar to validate parameters, however it is distinct because * parameters validation must be distinct from cleaning return values. * @param external_description $description description of the return values * @param mixed $response the actual response * @return mixed response with added defaults for optional items, invalid_response_exception thrown if any problem found */ public static function clean_returnvalue(external_description $description, $response) { if ($description instanceof external_value) { if (is_array($response) or is_object($response)) { throw new invalid_response_exception(get_string('errorscalartype', 'webservice')); } if ($description->type == PARAM_BOOL) { // special case for PARAM_BOOL - we want true/false instead of the usual 1/0 - we can not be too strict here ;-) if (is_bool($response) or $response === 0 or $response === 1 or $response === '0' or $response === '1') { return (bool) $response; } } return validate_param($response, $description->type, $description->allownull, get_string('errorinvalidresponseapi', 'webservice')); } else { if ($description instanceof external_single_structure) { if (!is_array($response)) { throw new invalid_response_exception(get_string('erroronlyarray', 'webservice')); } $result = array(); foreach ($description->keys as $key => $subdesc) { if (!array_key_exists($key, $response)) { if ($subdesc->required == VALUE_REQUIRED) { throw new webservice_parameter_exception('errorresponsemissingkey', $key); } if ($subdesc instanceof external_value) { if ($subdesc->required == VALUE_DEFAULT) { try { $result[$key] = self::clean_returnvalue($subdesc, $subdesc->default); } catch (Exception $e) { throw new webservice_parameter_exception('invalidextresponse', $key . " (" . $e->debuginfo . ")"); } } } } else { try { $result[$key] = self::clean_returnvalue($subdesc, $response[$key]); } catch (Exception $e) { //it's ok to display debug info as here the information is useful for ws client/dev throw new webservice_parameter_exception('invalidextresponse', $key . " (" . $e->debuginfo . ")"); } } unset($response[$key]); } return $result; } else { if ($description instanceof external_multiple_structure) { if (!is_array($response)) { throw new invalid_response_exception(get_string('erroronlyarray', 'webservice')); } $result = array(); foreach ($response as $param) { $result[] = self::clean_returnvalue($description->content, $param); } return $result; } else { throw new invalid_response_exception(get_string('errorinvalidresponsedesc', 'webservice')); } } } }
function test_validate_param() { try { $param = validate_param('11a', PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param('11', PARAM_INT); $this->assertEquals($param, 11); } catch (invalid_parameter_exception $ex) { $this->fail('invalid_parameter_exception not expected'); } try { $param = validate_param(null, PARAM_INT, false); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param(null, PARAM_INT, true); $this->assertTrue($param===null); } catch (invalid_parameter_exception $ex) { $this->fail('invalid_parameter_exception expected'); } try { $param = validate_param(array(), PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param(new stdClass, PARAM_INT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param('1.0', PARAM_FLOAT); $this->assertSame(1.0, $param); // Make sure valid floats do not cause exception. validate_param(1.0, PARAM_FLOAT); validate_param(10, PARAM_FLOAT); validate_param('0', PARAM_FLOAT); validate_param('119813454.545464564564546564545646556564465465456465465465645645465645645645', PARAM_FLOAT); validate_param('011.1', PARAM_FLOAT); validate_param('11', PARAM_FLOAT); validate_param('+.1', PARAM_FLOAT); validate_param('-.1', PARAM_FLOAT); validate_param('1e10', PARAM_FLOAT); validate_param('.1e+10', PARAM_FLOAT); validate_param('1E-1', PARAM_FLOAT); $this->assertTrue(true); } catch (invalid_parameter_exception $ex) { $this->fail('Valid float notation not accepted'); } try { $param = validate_param('1,2', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param('', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param('.', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param('e10', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } try { $param = validate_param('abc', PARAM_FLOAT); $this->fail('invalid_parameter_exception expected'); } catch (invalid_parameter_exception $ex) { $this->assertTrue(true); } }
/** * Validates the data. * * Developers can implement addition validation by defining a method as follows. Note that * the method MUST return a lang_string() when there is an error, and true when the data is valid. * * protected function validate_propertyname($value) { * if ($value !== 'My expected value') { * return new lang_string('invaliddata', 'error'); * } * return true * } * * It is OK to use other properties in your custom validation methods when you need to, however note * they might not have been validated yet, so try not to rely on them too much. * * Note that the validation methods should be protected. Validating just one field is not * recommended because of the possible dependencies between one field and another,also the * field ID can be used to check whether the object is being updated or created. * * When validating foreign keys the persistent should only check that the associated model * exists. The validation methods should not be used to check for a change in that relationship. * The API method setting the attributes on the model should be responsible for that. * E.g. On a course model, the method validate_categoryid will check that the category exists. * However, if a course can never be moved outside of its category it would be up to the calling * code to ensure that the category ID will not be altered. * * @return array|true Returns true when the validation passed, or an array of properties with errors. */ public final function validate() { global $CFG; // Before validate hook. $this->before_validate(); // If this object has not been validated yet. if ($this->validated !== true) { $errors = array(); $properties = static::properties_definition(); foreach ($properties as $property => $definition) { // Get the data, bypassing the potential custom getter which could alter the data. $value = $this->get($property); // Check if the property is required. if ($value === null && static::is_property_required($property)) { $errors[$property] = new lang_string('requiredelement', 'form'); continue; } // Check that type of value is respected. try { if ($definition['type'] === PARAM_BOOL && $value === false) { // Validate_param() does not like false with PARAM_BOOL, better to convert it to int. $value = 0; } validate_param($value, $definition['type'], $definition['null']); } catch (invalid_parameter_exception $e) { $errors[$property] = static::get_property_error_message($property); continue; } // Check that the value is part of a list of allowed values. if (isset($definition['choices']) && !in_array($value, $definition['choices'])) { $errors[$property] = static::get_property_error_message($property); continue; } // Call custom validation method. $method = 'validate_' . $property; if (method_exists($this, $method)) { // Warn the developers when they are doing something wrong. if ($CFG->debugdeveloper) { $reflection = new ReflectionMethod($this, $method); if (!$reflection->isProtected()) { throw new coding_exception('The method ' . get_class($this) . '::' . $method . ' should be protected.'); } } $valid = $this->{$method}($value); if ($valid !== true) { if (!$valid instanceof lang_string) { throw new coding_exception('Unexpected error message.'); } $errors[$property] = $valid; continue; } } } $this->validated = true; $this->errors = $errors; } return empty($this->errors) ? true : $this->errors; }
/** * Validates submitted value, comparing it to a description. If anything is incorrect * invalid_return_value_exception is thrown. Also casts the values to the type specified in * the description. * * @param external_description $description description of parameters or null if no return value * @param mixed $value the actual values * @return mixed params with added defaults for optional items * @throws invalid_return_value_exception */ public static function validate_and_cast_values($description, $value) { if (is_null($description)){ return; } if ($description instanceof external_value) { if (is_array($value) or is_object($value)) { throw new invalid_return_value_exception('Scalar type expected, array or object received.'); } if ($description->type == PARAM_BOOL) { // special case for PARAM_BOOL - we want true/false instead of the usual 1/0 - we can not be too strict here ;-) if (is_bool($value) or $value === 0 or $value === 1 or $value === '0' or $value === '1') { return (bool)$value; } } return validate_param($value, $description->type, $description->allownull, 'Invalid external api parameter'); } else if ($description instanceof external_single_structure) { if (!is_array($value)) { throw new invalid_return_value_exception('Only arrays accepted.'); } $result = array(); foreach ($description->keys as $key=>$subdesc) { if (!array_key_exists($key, $value)) { if ($subdesc->required == VALUE_REQUIRED) { throw new invalid_return_value_exception('Missing required key in single structure: '.$key); } if ($subdesc instanceof external_value) { if ($subdesc->required == VALUE_DEFAULT) { $result[$key] = self::validate_and_cast_values($subdesc, $subdesc->default); } } } else { $result[$key] = self::validate_and_cast_values($subdesc, $value[$key]); } unset($value[$key]); } return (object)$result; } else if ($description instanceof external_multiple_structure) { if (!is_array($value)) { throw new invalid_return_value_exception('Only arrays accepted.'); } $result = array(); foreach ($value as $param) { $result[] = self::validate_and_cast_values($description->content, $param); } return $result; } else { throw new invalid_return_value_exception('Invalid external api description.'); } }
/** * Validate user data. * * This method just validates each user field and return an array of errors. It doesn't clean the data, * the methods clean() and clean_field() should be used for this purpose. * * @param stdClass|array $data user data object or array to be validated. * @return array|true $errors array of errors found on the user object, true if the validation passed. */ public static function validate($data) { // Get all user profile fields definition. self::fill_properties_cache(); foreach ($data as $property => $value) { try { if (isset(self::$propertiescache[$property])) { validate_param($value, self::$propertiescache[$property]['type'], self::$propertiescache[$property]['null']); } // Check that the value is part of a list of allowed values. if (!empty(self::$propertiescache[$property]['choices']) && !isset(self::$propertiescache[$property]['choices'][$value])) { throw new invalid_parameter_exception($value); } } catch (invalid_parameter_exception $e) { $errors[$property] = $e->getMessage(); } } return empty($errors) ? true : $errors; }
/** * Get the signup required settings and profile fields. * * @param string $username username * @param string $password plain text password * @param string $firstname the first name(s) of the user * @param string $lastname the family name of the user * @param string $email a valid and unique email address * @param string $city home city of the user * @param string $country home country code * @param string $recaptchachallengehash recaptcha challenge hash * @param string $recaptcharesponse recaptcha response * @param array $customprofilefields user custom fields (also known as user profile fields) * @param string $redirect Site url to redirect the user after confirmation * @return array settings and possible warnings * @since Moodle 3.2 * @throws moodle_exception * @throws invalid_parameter_exception */ public static function signup_user($username, $password, $firstname, $lastname, $email, $city = '', $country = '', $recaptchachallengehash = '', $recaptcharesponse = '', $customprofilefields = array(), $redirect = '') { global $CFG, $PAGE; $warnings = array(); $params = self::validate_parameters(self::signup_user_parameters(), array('username' => $username, 'password' => $password, 'firstname' => $firstname, 'lastname' => $lastname, 'email' => $email, 'city' => $city, 'country' => $country, 'recaptchachallengehash' => $recaptchachallengehash, 'recaptcharesponse' => $recaptcharesponse, 'customprofilefields' => $customprofilefields, 'redirect' => $redirect)); // We need this to make work the format text functions. $context = context_system::instance(); $PAGE->set_context($context); self::check_signup_enabled(); // Validate profile fields param types. $allowedfields = profile_get_signup_fields(); $fieldproperties = array(); $fieldsrequired = array(); foreach ($allowedfields as $field) { $fieldproperties[$field->object->inputname] = $field->object->get_field_properties(); if ($field->object->is_required()) { $fieldsrequired[$field->object->inputname] = true; } } foreach ($params['customprofilefields'] as $profilefield) { if (!array_key_exists($profilefield['name'], $fieldproperties)) { throw new invalid_parameter_exception('Invalid field' . $profilefield['name']); } list($type, $allownull) = $fieldproperties[$profilefield['name']]; validate_param($profilefield['value'], $type, $allownull); // Remove from the potential required list. if (isset($fieldsrequired[$profilefield['name']])) { unset($fieldsrequired[$profilefield['name']]); } } if (!empty($fieldsrequired)) { throw new invalid_parameter_exception('Missing required parameters: ' . implode(',', array_keys($fieldsrequired))); } // Validate the data sent. $data = $params; $data['email2'] = $data['email']; unset($data['recaptcharesponse']); unset($data['customprofilefields']); // Add profile fields data. foreach ($params['customprofilefields'] as $profilefield) { // First, check if the value is a json (some profile fields like text area uses an array for sending data). $datadecoded = json_decode($profilefield['value'], true); if (is_array($datadecoded) && json_last_error() == JSON_ERROR_NONE) { $data[$profilefield['name']] = $datadecoded; } else { $data[$profilefield['name']] = $profilefield['value']; } } $errors = signup_validate_data($data, array()); // Validate recaptcha. if (signup_captcha_enabled()) { require_once $CFG->libdir . '/recaptchalib.php'; $response = recaptcha_check_answer($CFG->recaptchaprivatekey, getremoteaddr(), $params['recaptchachallengehash'], $params['recaptcharesponse'], true); if (!$response->is_valid) { $errors['recaptcharesponse'] = $response->error; } } if (!empty($errors)) { foreach ($errors as $itemname => $message) { $warnings[] = array('item' => $itemname, 'itemid' => 0, 'warningcode' => 'fielderror', 'message' => s($message)); } $result = array('success' => false, 'warnings' => $warnings); } else { // Save the user. $user = signup_setup_new_user((object) $data); $authplugin = get_auth_plugin('email'); // Check if we should redirect the user once the user is confirmed. $confirmationurl = null; if (!empty($params['redirect'])) { // Pass via moodle_url to fix thinks like admin links. $redirect = new moodle_url($params['redirect']); $confirmationurl = new moodle_url('/login/confirm.php', array('redirect' => $redirect->out())); } $authplugin->user_signup_with_confirmation($user, false, $confirmationurl); $result = array('success' => true, 'warnings' => array()); } return $result; }
require_once $CFG->libdir . '/adminlib.php'; $help = "Search and replace text throughout the whole database.\n\nOptions:\n--search=STRING String to search for.\n--replace=STRING String to replace with.\n--shorten Shorten result if necessary.\n--non-interactive Perform the replacement without confirming.\n-h, --help Print out this help.\n\nExample:\n\$ sudo -u www-data /usr/bin/php admin/tool/replace/cli/replace.php --search=//oldsitehost --replace=//newsitehost\n"; list($options, $unrecognized) = cli_get_params(array('search' => null, 'replace' => null, 'shorten' => false, 'non-interactive' => false, 'help' => false), array('h' => 'help')); if ($options['help'] || $options['search'] === null || $options['replace'] === null) { echo $help; exit(0); } if (!$DB->replace_all_text_supported()) { cli_error(get_string('notimplemented', 'tool_replace')); } if (empty($options['shorten']) && core_text::strlen($options['search']) < core_text::strlen($options['replace'])) { cli_error(get_string('cannotfit', 'tool_replace')); } try { $search = validate_param($options['search'], PARAM_RAW); $replace = validate_param($options['replace'], PARAM_RAW); } catch (invalid_parameter_exception $e) { cli_error(get_string('invalidcharacter', 'tool_replace')); } if (!$options['non-interactive']) { echo get_string('excludedtables', 'tool_replace') . "\n\n"; echo get_string('notsupported', 'tool_replace') . "\n\n"; $prompt = get_string('cliyesnoprompt', 'admin'); $input = cli_input($prompt, '', array(get_string('clianswerno', 'admin'), get_string('cliansweryes', 'admin'))); if ($input == get_string('clianswerno', 'admin')) { exit(1); } } if (!db_replace($search, $replace)) { cli_heading(get_string('error')); exit(1);
/** * Cleans the grades data and maps the userid to the internal id. * * @param array $grades An array user grade details. * @throws invalid_parameter_exception if $param is not of given type * @return array|null */ protected static function validate_grades($grades) { global $DB; if (!$grades or $grades == "null") { return null; } // The following are the variables that can be passed via grades. // We ignore any other variables. $allowed = array('userid' => PARAM_TEXT, 'rawgrade' => PARAM_FLOAT, 'identity_type' => PARAM_ALPHA); $details = array(); // Check type of each parameter. foreach ($allowed as $var => $type) { if (isset($grades[$var]) and $grades[$var] !== '') { $details[$var] = validate_param($grades[$var], $type); } } // Map userID to numerical userID if required. $idtype = !empty($details['identity_type']) ? $details['identity_type'] : null; if (!$idtype or $idtype != 'lti') { $userid = $DB->get_field('user', 'id', array('username' => $details['userid'])); if ($userid !== false) { $details['userid'] = $userid; } } return $details; }
/** * Validate the rule config. * * @param string $value The value to validate. * @return bool */ public function validate_config($value) { $compids = array(); $config = json_decode($value); if ($config === null || !isset($config->base) || !isset($config->competencies)) { return false; } if (!isset($config->base->points)) { return false; } try { $requiredpoints = validate_param($config->base->points, PARAM_INT); } catch (\invalid_parameter_exception $e) { return false; } if ($requiredpoints < 1) { return false; } $totalpoints = 0; // Validate the competency info. foreach ($config->competencies as $competency) { // Cannot include self. if ($competency->id == $this->competency->get_id()) { return false; } // Check for duplicates. if (in_array($competency->id, $compids)) { return false; } // Check for required fields. if (!isset($competency->id) || !isset($competency->points) || !isset($competency->required)) { return false; } // Validate the parameters. try { validate_param($competency->id, PARAM_INT); $points = validate_param($competency->points, PARAM_INT); validate_param($competency->required, PARAM_BOOL); } catch (\invalid_parameter_exception $e) { return false; } $totalpoints += $points; if ($points < 0) { return false; } $compids[] = $competency->id; } // No competencies, that's strange. if (empty($compids)) { return false; } // Impossible to reach the points required. if ($requiredpoints > $totalpoints) { return false; } // Check that all the competencies are children of the competency. // We may want to relax this check at a later stage if we want to allow competencies // to be linked throughout the whole framework. return $this->competency->is_parent_of($compids); }