/**
* 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);
}