Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

956 lines (832 sloc) 39.469 kb
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Bulk user registration script from a comma separated file
*
* @package core
* @subpackage admin
* @copyright 2004 onwards Martin Dougiamas (http://dougiamas.com)
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
require('../config.php');
require_once($CFG->libdir.'/adminlib.php');
require_once($CFG->libdir.'/csvlib.class.php');
require_once($CFG->dirroot.'/user/profile/lib.php');
require_once($CFG->dirroot.'/group/lib.php');
require_once('uploaduserlib.php');
require_once('uploaduser_form.php');
$iid = optional_param('iid', '', PARAM_INT);
$previewrows = optional_param('previewrows', 10, PARAM_INT);
@set_time_limit(60*60); // 1 hour should be enough
raise_memory_limit(MEMORY_HUGE);
require_login();
admin_externalpage_setup('uploadusers');
require_capability('moodle/site:uploadusers', get_context_instance(CONTEXT_SYSTEM));
$struserrenamed = get_string('userrenamed', 'admin');
$strusernotrenamedexists = get_string('usernotrenamedexists', 'error');
$strusernotrenamedmissing = get_string('usernotrenamedmissing', 'error');
$strusernotrenamedoff = get_string('usernotrenamedoff', 'error');
$strusernotrenamedadmin = get_string('usernotrenamedadmin', 'error');
$struserupdated = get_string('useraccountupdated', 'admin');
$strusernotupdated = get_string('usernotupdatederror', 'error');
$strusernotupdatednotexists = get_string('usernotupdatednotexists', 'error');
$strusernotupdatedadmin = get_string('usernotupdatedadmin', 'error');
$struseruptodate = get_string('useraccountuptodate', 'admin');
$struseradded = get_string('newuser');
$strusernotadded = get_string('usernotaddedregistered', 'error');
$strusernotaddederror = get_string('usernotaddederror', 'error');
$struserdeleted = get_string('userdeleted', 'admin');
$strusernotdeletederror = get_string('usernotdeletederror', 'error');
$strusernotdeletedmissing = get_string('usernotdeletedmissing', 'error');
$strusernotdeletedoff = get_string('usernotdeletedoff', 'error');
$strusernotdeletedadmin = get_string('usernotdeletedadmin', 'error');
$strcannotassignrole = get_string('cannotassignrole', 'error');
$struserauthunsupported = get_string('userauthunsupported', 'error');
$stremailduplicate = get_string('useremailduplicate', 'error');
$strinvalidpasswordpolicy = get_string('invalidpasswordpolicy', 'error');
$errorstr = get_string('error');
$returnurl = new moodle_url('/admin/uploaduser.php');
$bulknurl = new moodle_url('/admin/user/user_bulk.php');
$today = time();
$today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
// array of all valid fields for validation
$STD_FIELDS = array('id', 'firstname', 'lastname', 'username', 'email',
'city', 'country', 'lang', 'timezone', 'mailformat',
'maildisplay', 'maildigest', 'htmleditor', 'ajax', 'autosubscribe',
'institution', 'department', 'idnumber', 'skype',
'msn', 'aim', 'yahoo', 'icq', 'phone1', 'phone2', 'address',
'url', 'description', 'descriptionformat', 'password',
'auth', // watch out when changing auth type or using external auth plugins!
'oldusername', // use when renaming users - this is the original username
'deleted', // 1 means delete user
);
$PRF_FIELDS = array();
if ($prof_fields = $DB->get_records('user_info_field')) {
foreach ($prof_fields as $prof_field) {
$PRF_FIELDS[] = 'profile_field_'.$prof_field->shortname;
}
}
unset($prof_fields);
if (empty($iid)) {
$mform1 = new admin_uploaduser_form1();
if ($formdata = $mform1->get_data()) {
$iid = csv_import_reader::get_new_iid('uploaduser');
$cir = new csv_import_reader($iid, 'uploaduser');
$content = $mform1->get_file_content('userfile');
$readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
unset($content);
if ($readcount === false) {
print_error('csvloaderror', '', $returnurl);
} else if ($readcount == 0) {
print_error('csvemptyfile', 'error', $returnurl);
}
// test if columns ok
$filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
// continue to form2
} else {
echo $OUTPUT->header();
echo $OUTPUT->heading_with_help(get_string('uploadusers', 'admin'), 'uploadusers', 'admin');
$mform1->display();
echo $OUTPUT->footer();
die;
}
} else {
$cir = new csv_import_reader($iid, 'uploaduser');
$filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
}
$mform2 = new admin_uploaduser_form2(null, array('columns'=>$filecolumns, 'data'=>array('iid'=>$iid, 'previewrows'=>$previewrows)));
// If a file has been uploaded, then process it
if ($formdata = $mform2->is_cancelled()) {
$cir->cleanup(true);
redirect($returnurl);
} else if ($formdata = $mform2->get_data()) {
// Print the header
echo $OUTPUT->header();
echo $OUTPUT->heading(get_string('uploadusersresult', 'admin'));
$optype = $formdata->uutype;
$updatetype = isset($formdata->uuupdatetype) ? $formdata->uuupdatetype : 0;
$createpasswords = (!empty($formdata->uupasswordnew) and $optype != UU_USER_UPDATE);
$updatepasswords = (!empty($formdata->uupasswordold) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC and ($updatetype == UU_UPDATE_FILEOVERRIDE or $updatetype == UU_UPDATE_ALLOVERRIDE));
$allowrenames = (!empty($formdata->uuallowrenames) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
$allowdeletes = (!empty($formdata->uuallowdeletes) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
$bulk = $formdata->uubulk;
$noemailduplicates = $formdata->uunoemailduplicates;
$standardusernames = $formdata->uustandardusernames;
$resetpasswords = isset($formdata->uuforcepasswordchange) ? $formdata->uuforcepasswordchange : UU_PWRESET_NONE;
// verification moved to two places: after upload and into form2
$usersnew = 0;
$usersupdated = 0;
$usersuptodate = 0; //not printed yet anywhere
$userserrors = 0;
$deletes = 0;
$deleteerrors = 0;
$renames = 0;
$renameerrors = 0;
$usersskipped = 0;
$weakpasswords = 0;
// caches
$ccache = array(); // course cache - do not fetch all courses here, we will not probably use them all anyway!
$rolecache = uu_allowed_roles_cache(); // roles lookup cache
$manualcache = array(); // cache of used manual enrol plugins in each course
$supportedauths = uu_supported_auths(); // officially supported plugins that are enabled
// we use only manual enrol plugin here, if it is disabled no enrol is done
if (enrol_is_enabled('manual')) {
$manual = enrol_get_plugin('manual');
} else {
$manual = NULL;
}
// clear bulk selection
if ($bulk) {
$SESSION->bulk_users = array();
}
// init csv import helper
$cir->init();
$linenum = 1; //column header is first line
// init upload progress tracker
$upt = new uu_progress_tracker();
$upt->start(); // start table
while ($line = $cir->next()) {
$upt->flush();
$linenum++;
$upt->track('line', $linenum);
$user = new stdClass();
// add fields to user object
foreach ($line as $keynum => $value) {
if (!isset($filecolumns[$keynum])) {
// this should not happen
continue;
}
$key = $filecolumns[$keynum];
if (strpos($key, 'profile_field_') === 0) {
//NOTE: bloody mega hack alert!!
if (isset($USER->$key) and is_array($USER->$key)) {
// this must be some hacky field that is abusing arrays to store content and format
$user->$key = array();
$user->$key['text'] = $value;
$user->$key['format'] = FORMAT_MOODLE;
} else {
$user->$key = $value;
}
} else {
$user->$key = $value;
}
if (in_array($key, $upt->columns)) {
// default value in progress tracking table, can be changed later
$upt->track($key, s($value), 'normal');
}
}
if (!isset($user->username)) {
// prevent warnings bellow
$user->username = '';
}
if ($optype == UU_USER_ADDNEW or $optype == UU_USER_ADDINC) {
// user creation is a special case - the username may be constructed from templates using firstname and lastname
// better never try this in mixed update types
$error = false;
if (!isset($user->firstname) or $user->firstname === '') {
$upt->track('status', get_string('missingfield', 'error', 'firstname'), 'error');
$upt->track('firstname', $errorstr, 'error');
$error = true;
}
if (!isset($user->lastname) or $user->lastname === '') {
$upt->track('status', get_string('missingfield', 'error', 'lastname'), 'error');
$upt->track('lastname', $errorstr, 'error');
$error = true;
}
if ($error) {
$userserrors++;
continue;
}
// we require username too - we might use template for it though
if (empty($user->username) and !empty($formdata->username)) {
$user->username = uu_process_template($formdata->username, $user);
$upt->track('username', s($user->username));
}
}
// normalize username
$originalusername = $user->username;
if ($standardusernames) {
$user->username = clean_param($user->username, PARAM_USERNAME);
}
// make sure we really have username
if (empty($user->username)) {
$upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
$upt->track('username', $errorstr, 'error');
$userserrors++;
continue;
} else if ($user->username === 'guest') {
$upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
$userserrors++;
continue;
}
if ($existinguser = $DB->get_record('user', array('username'=>$user->username, 'mnethostid'=>$CFG->mnet_localhost_id))) {
$upt->track('id', $existinguser->id, 'normal', false);
}
// find out in username incrementing required
if ($existinguser and $optype == UU_USER_ADDINC) {
$user->username = uu_increment_username($user->username);
$existinguser = false;
}
// notify about nay username changes
if ($originalusername !== $user->username) {
$upt->track('username', '', 'normal', false); // clear previous
$upt->track('username', s($originalusername).'-->'.s($user->username), 'info');
} else {
$upt->track('username', s($user->username), 'normal', false);
}
// add default values for remaining fields
$formdefaults = array();
foreach ($STD_FIELDS as $field) {
if (isset($user->$field)) {
continue;
}
// all validation moved to form2
if (isset($formdata->$field)) {
// process templates
$user->$field = uu_process_template($formdata->$field, $user);
$formdefaults[$field] = true;
if (in_array($field, $upt->columns)) {
$upt->track($field, s($user->$field), 'normal');
}
}
}
foreach ($PRF_FIELDS as $field) {
if (isset($user->$field)) {
continue;
}
if (isset($formdata->$field)) {
// process templates
$user->$field = uu_process_template($formdata->$field, $user);
$formdefaults[$field] = true;
}
}
// delete user
if (!empty($user->deleted)) {
if (!$allowdeletes) {
$usersskipped++;
$upt->track('status', $strusernotdeletedoff, 'warning');
continue;
}
if ($existinguser) {
if (is_siteadmin($existinguser->id)) {
$upt->track('status', $strusernotdeletedadmin, 'error');
$deleteerrors++;
continue;
}
if (delete_user($existinguser)) {
$upt->track('status', $struserdeleted);
$deletes++;
} else {
$upt->track('status', $strusernotdeletederror, 'error');
$deleteerrors++;
}
} else {
$upt->track('status', $strusernotdeletedmissing, 'error');
$deleteerrors++;
}
continue;
}
// we do not need the deleted flag anymore
unset($user->deleted);
// renaming requested?
if (!empty($user->oldusername) ) {
if (!$allowrenames) {
$usersskipped++;
$upt->track('status', $strusernotrenamedoff, 'warning');
continue;
}
if ($existinguser) {
$upt->track('status', $strusernotrenamedexists, 'error');
$renameerrors++;
continue;
}
if ($user->username === 'guest') {
$upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
$renameerrors++;
continue;
}
if ($standardusernames) {
$oldusername = clean_param($user->oldusername, PARAM_USERNAME);
} else {
$oldusername = $user->oldusername;
}
// no guessing when looking for old username, it must be exact match
if ($olduser = $DB->get_record('user', array('username'=>$oldusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
$upt->track('id', $olduser->id, 'normal', false);
if (is_siteadmin($olduser->id)) {
$upt->track('status', $strusernotrenamedadmin, 'error');
$renameerrors++;
continue;
}
$DB->set_field('user', 'username', $user->username, array('id'=>$olduser->id));
$upt->track('username', '', 'normal', false); // clear previous
$upt->track('username', s($oldusername).'-->'.s($user->username), 'info');
$upt->track('status', $struserrenamed);
$renames++;
} else {
$upt->track('status', $strusernotrenamedmissing, 'error');
$renameerrors++;
continue;
}
$existinguser = $olduser;
$existinguser->username = $user->username;
}
// can we process with update or insert?
$skip = false;
switch ($optype) {
case UU_USER_ADDNEW:
if ($existinguser) {
$usersskipped++;
$upt->track('status', $strusernotadded, 'warning');
$skip = true;
}
break;
case UU_USER_ADDINC:
if ($existinguser) {
//this should not happen!
$upt->track('status', $strusernotaddederror, 'error');
$userserrors++;
$skip = true;
}
break;
case UU_USER_ADD_UPDATE:
break;
case UU_USER_UPDATE:
if (!$existinguser) {
$usersskipped++;
$upt->track('status', $strusernotupdatednotexists, 'warning');
$skip = true;
}
break;
default:
// unknown type
$skip = true;
}
if ($skip) {
continue;
}
if ($existinguser) {
$user->id = $existinguser->id;
$upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$existinguser->id)), s($existinguser->username)), 'normal', false);
if (is_siteadmin($user->id)) {
$upt->track('status', $strusernotupdatedadmin, 'error');
$userserrors++;
continue;
}
$existinguser->timemodified = time();
// do NOT mess with timecreated or firstaccess here!
//load existing profile data
profile_load_data($existinguser);
$upt->track('auth', $existinguser->auth, 'normal', false);
$doupdate = false;
if ($updatetype != UU_UPDATE_NOCHANGES) {
if (!empty($user->auth) and $user->auth !== $existinguser->auth) {
$upt->track('auth', s($existinguser->auth).'-->'.s($user->auth), 'info', false);
$existinguser->auth = $user->auth;
if (!isset($supportedauths[$user->auth])) {
$upt->track('auth', $struserauthunsupported, 'warning');
}
}
$allcolumns = array_merge($STD_FIELDS, $PRF_FIELDS);
foreach ($allcolumns as $column) {
if ($column === 'username' or $column === 'password' or $column === 'auth') {
// these can not be changed here
continue;
}
if (!property_exists($user, $column) or !property_exists($existinguser, $column)) {
// this should never happen
continue;
}
if ($updatetype == UU_UPDATE_MISSING) {
if (!is_null($existinguser->$column) and $existinguser->$column !== '') {
continue;
}
} else if ($updatetype == UU_UPDATE_ALLOVERRIDE) {
// we override everything
} else if ($updatetype == UU_UPDATE_FILEOVERRIDE) {
if (!empty($formdefaults[$column])) {
// do not override with form defaults
continue;
}
}
if ($existinguser->$column !== $user->$column) {
if ($column === 'email') {
if ($DB->record_exists('user', array('email'=>$user->email))) {
if ($noemailduplicates) {
$upt->track('email', $stremailduplicate, 'error');
$upt->track('status', $strusernotupdated, 'error');
$userserrors++;
continue 2;
} else {
$upt->track('email', $stremailduplicate, 'warning');
}
}
if (!validate_email($user->email)) {
$upt->track('email', get_string('invalidemail'), 'warning');
}
}
if (in_array($column, $upt->columns)) {
$upt->track($column, s($existinguser->$column).'-->'.s($user->$column), 'info', false);
}
$existinguser->$column = $user->$column;
$doupdate = true;
}
}
}
try {
$auth = get_auth_plugin($existinguser->auth);
} catch (Exception $e) {
$upt->track('auth', get_string('userautherror', 'error', s($existinguser->auth)), 'error');
$upt->track('status', $strusernotupdated, 'error');
$userserrors++;
continue;
}
$isinternalauth = $auth->is_internal();
// changing of passwords is a special case
// do not force password changes for external auth plugins!
$oldpw = $existinguser->password;
if (!$isinternalauth) {
$existinguser->password = 'not cached';
$upt->track('password', '-', 'normal', false);
// clean up prefs
unset_user_preference('create_password', $existinguser);
unset_user_preference('auth_forcepasswordchange', $existinguser);
} else if (!empty($user->password)) {
if ($updatepasswords) {
$errmsg = null;
$weak = !check_password_policy($user->password, $errmsg);
if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
if ($weak) {
$weakpasswords++;
$upt->track('password', $strinvalidpasswordpolicy, 'warning');
}
set_user_preference('auth_forcepasswordchange', 1, $existinguser);
} else {
unset_user_preference('auth_forcepasswordchange', $existinguser);
}
unset_user_preference('create_password', $existinguser); // no need to create password any more
$existinguser->password = hash_internal_user_password($user->password);
$upt->track('password', $user->password, 'normal', false);
} else {
// do not print password when not changed
$upt->track('password', '', 'normal', false);
}
}
if ($doupdate or $existinguser->password !== $oldpw) {
// we want only users that were really updated
$DB->update_record('user', $existinguser);
$upt->track('status', $struserupdated);
$usersupdated++;
// save custom profile fields data from csv file
profile_save_data($existinguser);
events_trigger('user_updated', $existinguser);
if ($bulk == UU_BULK_UPDATED or $bulk == UU_BULK_ALL) {
if (!in_array($user->id, $SESSION->bulk_users)) {
$SESSION->bulk_users[] = $user->id;
}
}
} else {
// no user information changed
$upt->track('status', $struseruptodate);
$usersuptodate++;
if ($bulk == UU_BULK_ALL) {
if (!in_array($user->id, $SESSION->bulk_users)) {
$SESSION->bulk_users[] = $user->id;
}
}
}
} else {
// save the new user to the database
$user->confirmed = 1;
$user->timemodified = time();
$user->timecreated = time();
$user->mnethostid = $CFG->mnet_localhost_id; // we support ONLY local accounts here, sorry
if (empty($user->auth)) {
$user->auth = 'manual';
}
$upt->track('auth', $user->auth, 'normal', false);
// do not insert record if new auth plugin does not exist!
try {
$auth = get_auth_plugin($user->auth);
} catch (Exception $e) {
$upt->track('auth', get_string('userautherror', 'error', s($user->auth)), 'error');
$upt->track('status', $strusernotaddederror, 'error');
$userserrors++;
continue;
}
if (!isset($supportedauths[$user->auth])) {
$upt->track('auth', $struserauthunsupported, 'warning');
}
$isinternalauth = $auth->is_internal();
if (empty($user->email)) {
$upt->track('email', get_string('invalidemail'), 'error');
$upt->track('status', $strusernotaddederror, 'error');
$userserrors++;
continue;
} else if ($DB->record_exists('user', array('email'=>$user->email))) {
if ($noemailduplicates) {
$upt->track('email', $stremailduplicate, 'error');
$upt->track('status', $strusernotaddederror, 'error');
$userserrors++;
continue;
} else {
$upt->track('email', $stremailduplicate, 'warning');
}
}
if (!validate_email($user->email)) {
$upt->track('email', get_string('invalidemail'), 'warning');
}
$forcechangepassword = false;
if ($isinternalauth) {
if (empty($user->password)) {
if ($createpasswords) {
$user->password = 'to be generated';
$upt->track('password', '', 'normal', false);
$upt->track('password', get_string('uupasswordcron', 'admin'), 'warning', false);
} else {
$upt->track('password', '', 'normal', false);
$upt->track('password', get_string('missingfield', 'error', 'password'), 'error');
$upt->track('status', $strusernotaddederror, 'error');
$userserrors++;
continue;
}
} else {
$errmsg = null;
$weak = !check_password_policy($user->password, $errmsg);
if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
if ($weak) {
$weakpasswords++;
$upt->track('password', $strinvalidpasswordpolicy, 'warning');
}
$forcechangepassword = true;
}
$user->password = hash_internal_user_password($user->password);
}
} else {
$user->password = 'not cached';
$upt->track('password', '-', 'normal', false);
}
// create user - insert_record ignores any extra properties
$user->id = $DB->insert_record('user', $user);
$upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$user->id)), s($user->username)), 'normal', false);
// save custom profile fields data
profile_save_data($user);
if ($forcechangepassword) {
set_user_preference('auth_forcepasswordchange', 1, $user);
}
if ($user->password === 'to be generated') {
set_user_preference('create_password', 1, $user);
}
$upt->track('status', $struseradded);
$upt->track('id', $user->id, 'normal', false);
$usersnew++;
// make sure user context exists
get_context_instance(CONTEXT_USER, $user->id);
events_trigger('user_created', $user);
if ($bulk == UU_BULK_NEW or $bulk == UU_BULK_ALL) {
if (!in_array($user->id, $SESSION->bulk_users)) {
$SESSION->bulk_users[] = $user->id;
}
}
}
// find course enrolments, groups, roles/types and enrol periods
// this is again a special case, we always do this for any updated or created users
foreach ($filecolumns as $column) {
if (!preg_match('/^course\d+$/', $column)) {
continue;
}
$i = substr($column, 6);
if (empty($user->{'course'.$i})) {
continue;
}
$shortname = $user->{'course'.$i};
if (!array_key_exists($shortname, $ccache)) {
if (!$course = $DB->get_record('course', array('shortname'=>$shortname), 'id, shortname')) {
$upt->track('enrolments', get_string('unknowncourse', 'error', s($shortname)), 'error');
continue;
}
$ccache[$shortname] = $course;
$ccache[$shortname]->groups = null;
}
$courseid = $ccache[$shortname]->id;
$coursecontext = get_context_instance(CONTEXT_COURSE, $courseid);
if (!isset($manualcache[$courseid])) {
$manualcache[$courseid] = false;
if ($manual) {
if ($instances = enrol_get_instances($courseid, false)) {
foreach ($instances as $instance) {
if ($instance->enrol === 'manual') {
$manualcache[$courseid] = $instance;
break;
}
}
}
}
}
if ($manual and $manualcache[$courseid]) {
// find role
$rid = false;
if (!empty($user->{'role'.$i})) {
$addrole = $user->{'role'.$i};
if (array_key_exists($addrole, $rolecache)) {
$rid = $rolecache[$addrole]->id;
} else {
$upt->track('enrolments', get_string('unknownrole', 'error', s($addrole)), 'error');
continue;
}
} else if (!empty($user->{'type'.$i})) {
// if no role, then find "old" enrolment type
$addtype = $user->{'type'.$i};
if ($addtype < 1 or $addtype > 3) {
$upt->track('enrolments', $strerror.': typeN = 1|2|3', 'error');
continue;
} else if (empty($formdata->{'uulegacy'.$addtype})) {
continue;
} else {
$rid = $formdata->{'uulegacy'.$addtype};
}
} else {
// no role specified, use the default from manual enrol plugin
$rid = $manualcache[$courseid]->roleid;
}
if ($rid) {
// find duration
$timeend = 0;
if (!empty($user->{'enrolperiod'.$i})) {
$duration = (int)$user->{'enrolperiod'.$i} * 60*60*24; // convert days to seconds
if ($duration > 0) { // sanity check
$timeend = $today + $duration;
}
}
$manual->enrol_user($manualcache[$courseid], $user->id, $rid, $today, $timeend);
$a = new stdClass();
$a->course = $shortname;
$a->role = $rolecache[$rid]->name;
$upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
}
}
// find group to add to
if (!empty($user->{'group'.$i})) {
// make sure user is enrolled into course before adding into groups
if (!is_enrolled($coursecontext, $user->id)) {
$upt->track('enrolments', get_string('addedtogroupnotenrolled', '', $user->{'group'.$i}), 'error');
continue;
}
//build group cache
if (is_null($ccache[$shortname]->groups)) {
$ccache[$shortname]->groups = array();
if ($groups = groups_get_all_groups($courseid)) {
foreach ($groups as $gid=>$group) {
$ccache[$shortname]->groups[$gid] = new stdClass();
$ccache[$shortname]->groups[$gid]->id = $gid;
$ccache[$shortname]->groups[$gid]->name = $group->name;
if (!is_numeric($group->name)) { // only non-numeric names are supported!!!
$ccache[$shortname]->groups[$group->name] = new stdClass();
$ccache[$shortname]->groups[$group->name]->id = $gid;
$ccache[$shortname]->groups[$group->name]->name = $group->name;
}
}
}
}
// group exists?
$addgroup = $user->{'group'.$i};
if (!array_key_exists($addgroup, $ccache[$shortname]->groups)) {
// if group doesn't exist, create it
$newgroupdata = new stdClass();
$newgroupdata->name = $addgroup;
$newgroupdata->courseid = $ccache[$shortname]->id;
if ($ccache[$shortname]->groups[$addgroup]->id = groups_create_group($newgroupdata)){
$ccache[$shortname]->groups[$addgroup]->name = $newgroupdata->name;
} else {
$upt->track('enrolments', get_string('unknowngroup', 'error', s($addgroup)), 'error');
continue;
}
}
$gid = $ccache[$shortname]->groups[$addgroup]->id;
$gname = $ccache[$shortname]->groups[$addgroup]->name;
try {
if (groups_add_member($gid, $user->id)) {
$upt->track('enrolments', get_string('addedtogroup', '', s($gname)));
} else {
$upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
}
} catch (moodle_exception $e) {
$upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
continue;
}
}
}
}
$upt->close(); // close table
$cir->close();
$cir->cleanup(true);
echo $OUTPUT->box_start('boxwidthnarrow boxaligncenter generalbox', 'uploadresults');
echo '<p>';
if ($optype != UU_USER_UPDATE) {
echo get_string('userscreated', 'admin').': '.$usersnew.'<br />';
}
if ($optype == UU_USER_UPDATE or $optype == UU_USER_ADD_UPDATE) {
echo get_string('usersupdated', 'admin').': '.$usersupdated.'<br />';
}
if ($allowdeletes) {
echo get_string('usersdeleted', 'admin').': '.$deletes.'<br />';
echo get_string('deleteerrors', 'admin').': '.$deleteerrors.'<br />';
}
if ($allowrenames) {
echo get_string('usersrenamed', 'admin').': '.$renames.'<br />';
echo get_string('renameerrors', 'admin').': '.$renameerrors.'<br />';
}
if ($usersskipped) {
echo get_string('usersskipped', 'admin').': '.$usersskipped.'<br />';
}
echo get_string('usersweakpassword', 'admin').': '.$weakpasswords.'<br />';
echo get_string('errors', 'admin').': '.$userserrors.'</p>';
echo $OUTPUT->box_end();
if ($bulk) {
echo $OUTPUT->continue_button($bulknurl);
} else {
echo $OUTPUT->continue_button($returnurl);
}
echo $OUTPUT->footer();
die;
}
// Print the header
echo $OUTPUT->header();
echo $OUTPUT->heading(get_string('uploaduserspreview', 'admin'));
// NOTE: this is JUST csv processing preview, we must not prevent import from here if there is something in the file!!
// this was intended for validation of csv formatting and encoding, not filtering the data!!!!
// we definitely must not process the whole file!
// preview table data
$data = array();
$cir->init();
$linenum = 1; //column header is first line
while ($linenum <= $previewrows and $fields = $cir->next()) {
$linenum++;
$rowcols = array();
$rowcols['line'] = $linenum;
foreach($fields as $key => $field) {
$rowcols[$filecolumns[$key]] = s($field);
}
$rowcols['status'] = array();
if (isset($rowcols['username'])) {
$stdusername = clean_param($rowcols['username'], PARAM_USERNAME);
if ($rowcols['username'] !== $stdusername) {
$rowcols['status'][] = get_string('invalidusernameupload');
}
if ($userid = $DB->get_field('user', 'id', array('username'=>$stdusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
$rowcols['username'] = html_writer::link(new moodle_url('/user/profile.php', array('id'=>$userid)), $rowcols['username']);
}
} else {
$rowcols['status'][] = get_string('missingusername');
}
if (isset($rowcols['email'])) {
if (!validate_email($rowcols['email'])) {
$rowcols['status'][] = get_string('invalidemail');
}
if ($DB->record_exists('user', array('email'=>$rowcols['email']))) {
$rowcols['status'][] = $stremailduplicate;
}
}
if (isset($rowcols['city'])) {
$rowcols['city'] = trim($rowcols['city']);
if (empty($rowcols['city'])) {
$rowcols['status'][] = get_string('fieldrequired', 'error', 'city');
}
}
$rowcols['status'] = implode('<br />', $rowcols['status']);
$data[] = $rowcols;
}
if ($fields = $cir->next()) {
$data[] = array_fill(0, count($fields) + 2, '...');
}
$cir->close();
$table = new html_table();
$table->id = "uupreview";
$table->attributes['class'] = 'generaltable';
$table->tablealign = 'center';
$table->summary = get_string('uploaduserspreview', 'admin');
$table->head = array();
$table->data = $data;
$table->head[] = get_string('uucsvline', 'admin');
foreach ($filecolumns as $column) {
$table->head[] = $column;
}
$table->head[] = get_string('status');
echo html_writer::tag('div', html_writer::table($table), array('class'=>'flexible-wrap'));
/// Print the form
$mform2->display();
echo $OUTPUT->footer();
die;
Jump to Line
Something went wrong with that request. Please try again.