acc08d26999271cdf61f2d478e25b7e401bd5d75
[moodle.git] / admin / uploaduser.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Bulk user registration script from a comma separated file
19  *
20  * @package    core
21  * @subpackage admin
22  * @copyright  2004 onwards Martin Dougiamas (http://dougiamas.com)
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 require('../config.php');
27 require_once($CFG->libdir.'/adminlib.php');
28 require_once($CFG->libdir.'/csvlib.class.php');
29 require_once($CFG->dirroot.'/user/profile/lib.php');
30 require_once($CFG->dirroot.'/group/lib.php');
31 require_once($CFG->dirroot.'/cohort/lib.php');
32 require_once('uploaduserlib.php');
33 require_once('uploaduser_form.php');
35 $iid         = optional_param('iid', '', PARAM_INT);
36 $previewrows = optional_param('previewrows', 10, PARAM_INT);
38 @set_time_limit(60*60); // 1 hour should be enough
39 raise_memory_limit(MEMORY_HUGE);
41 require_login();
42 admin_externalpage_setup('uploadusers');
43 require_capability('moodle/site:uploadusers', get_context_instance(CONTEXT_SYSTEM));
45 $struserrenamed             = get_string('userrenamed', 'admin');
46 $strusernotrenamedexists    = get_string('usernotrenamedexists', 'error');
47 $strusernotrenamedmissing   = get_string('usernotrenamedmissing', 'error');
48 $strusernotrenamedoff       = get_string('usernotrenamedoff', 'error');
49 $strusernotrenamedadmin     = get_string('usernotrenamedadmin', 'error');
51 $struserupdated             = get_string('useraccountupdated', 'admin');
52 $strusernotupdated          = get_string('usernotupdatederror', 'error');
53 $strusernotupdatednotexists = get_string('usernotupdatednotexists', 'error');
54 $strusernotupdatedadmin     = get_string('usernotupdatedadmin', 'error');
56 $struseruptodate            = get_string('useraccountuptodate', 'admin');
58 $struseradded               = get_string('newuser');
59 $strusernotadded            = get_string('usernotaddedregistered', 'error');
60 $strusernotaddederror       = get_string('usernotaddederror', 'error');
62 $struserdeleted             = get_string('userdeleted', 'admin');
63 $strusernotdeletederror     = get_string('usernotdeletederror', 'error');
64 $strusernotdeletedmissing   = get_string('usernotdeletedmissing', 'error');
65 $strusernotdeletedoff       = get_string('usernotdeletedoff', 'error');
66 $strusernotdeletedadmin     = get_string('usernotdeletedadmin', 'error');
68 $strcannotassignrole        = get_string('cannotassignrole', 'error');
70 $struserauthunsupported     = get_string('userauthunsupported', 'error');
71 $stremailduplicate          = get_string('useremailduplicate', 'error');
73 $strinvalidpasswordpolicy   = get_string('invalidpasswordpolicy', 'error');
74 $errorstr                   = get_string('error');
76 $returnurl = new moodle_url('/admin/uploaduser.php');
77 $bulknurl  = new moodle_url('/admin/user/user_bulk.php');
79 $today = time();
80 $today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
82 // array of all valid fields for validation
83 $STD_FIELDS = array('id', 'firstname', 'lastname', 'username', 'email',
84         'city', 'country', 'lang', 'timezone', 'mailformat',
85         'maildisplay', 'maildigest', 'htmleditor', 'ajax', 'autosubscribe',
86         'institution', 'department', 'idnumber', 'skype',
87         'msn', 'aim', 'yahoo', 'icq', 'phone1', 'phone2', 'address',
88         'url', 'description', 'descriptionformat', 'password',
89         'auth',        // watch out when changing auth type or using external auth plugins!
90         'oldusername', // use when renaming users - this is the original username
91         'deleted',     // 1 means delete user
92     );
94 $PRF_FIELDS = array();
96 if ($prof_fields = $DB->get_records('user_info_field')) {
97     foreach ($prof_fields as $prof_field) {
98         $PRF_FIELDS[] = 'profile_field_'.$prof_field->shortname;
99     }
101 unset($prof_fields);
103 if (empty($iid)) {
104     $mform1 = new admin_uploaduser_form1();
106     if ($formdata = $mform1->get_data()) {
107         $iid = csv_import_reader::get_new_iid('uploaduser');
108         $cir = new csv_import_reader($iid, 'uploaduser');
110         $content = $mform1->get_file_content('userfile');
112         $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
113         unset($content);
115         if ($readcount === false) {
116             print_error('csvloaderror', '', $returnurl);
117         } else if ($readcount == 0) {
118             print_error('csvemptyfile', 'error', $returnurl);
119         }
120         // test if columns ok
121         $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
122         // continue to form2
124     } else {
125         echo $OUTPUT->header();
127         echo $OUTPUT->heading_with_help(get_string('uploadusers', 'admin'), 'uploadusers', 'admin');
129         $mform1->display();
130         echo $OUTPUT->footer();
131         die;
132     }
133 } else {
134     $cir = new csv_import_reader($iid, 'uploaduser');
135     $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
138 $mform2 = new admin_uploaduser_form2(null, array('columns'=>$filecolumns, 'data'=>array('iid'=>$iid, 'previewrows'=>$previewrows)));
140 // If a file has been uploaded, then process it
141 if ($formdata = $mform2->is_cancelled()) {
142     $cir->cleanup(true);
143     redirect($returnurl);
145 } else if ($formdata = $mform2->get_data()) {
146     // Print the header
147     echo $OUTPUT->header();
148     echo $OUTPUT->heading(get_string('uploadusersresult', 'admin'));
150     $optype = $formdata->uutype;
152     $updatetype        = isset($formdata->uuupdatetype) ? $formdata->uuupdatetype : 0;
153     $createpasswords   = (!empty($formdata->uupasswordnew) and $optype != UU_USER_UPDATE);
154     $updatepasswords   = (!empty($formdata->uupasswordold)  and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC and ($updatetype == UU_UPDATE_FILEOVERRIDE or $updatetype == UU_UPDATE_ALLOVERRIDE));
155     $allowrenames      = (!empty($formdata->uuallowrenames) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
156     $allowdeletes      = (!empty($formdata->uuallowdeletes) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
157     $bulk              = $formdata->uubulk;
158     $noemailduplicates = $formdata->uunoemailduplicates;
159     $standardusernames = $formdata->uustandardusernames;
160     $resetpasswords    = isset($formdata->uuforcepasswordchange) ? $formdata->uuforcepasswordchange : UU_PWRESET_NONE;
162     // verification moved to two places: after upload and into form2
163     $usersnew      = 0;
164     $usersupdated  = 0;
165     $usersuptodate = 0; //not printed yet anywhere
166     $userserrors   = 0;
167     $deletes       = 0;
168     $deleteerrors  = 0;
169     $renames       = 0;
170     $renameerrors  = 0;
171     $usersskipped  = 0;
172     $weakpasswords = 0;
174     // caches
175     $ccache         = array(); // course cache - do not fetch all courses here, we  will not probably use them all anyway!
176     $cohorts        = array();
177     $rolecache      = uu_allowed_roles_cache(); // roles lookup cache
178     $manualcache    = array(); // cache of used manual enrol plugins in each course
179     $supportedauths = uu_supported_auths(); // officially supported plugins that are enabled
181     // we use only manual enrol plugin here, if it is disabled no enrol is done
182     if (enrol_is_enabled('manual')) {
183         $manual = enrol_get_plugin('manual');
184     } else {
185         $manual = NULL;
186     }
188     // clear bulk selection
189     if ($bulk) {
190         $SESSION->bulk_users = array();
191     }
193     // init csv import helper
194     $cir->init();
195     $linenum = 1; //column header is first line
197     // init upload progress tracker
198     $upt = new uu_progress_tracker();
199     $upt->start(); // start table
201     while ($line = $cir->next()) {
202         $upt->flush();
203         $linenum++;
205         $upt->track('line', $linenum);
207         $user = new stdClass();
209         // add fields to user object
210         foreach ($line as $keynum => $value) {
211             if (!isset($filecolumns[$keynum])) {
212                 // this should not happen
213                 continue;
214             }
215             $key = $filecolumns[$keynum];
216             if (strpos($key, 'profile_field_') === 0) {
217                 //NOTE: bloody mega hack alert!!
218                 if (isset($USER->$key) and is_array($USER->$key)) {
219                     // this must be some hacky field that is abusing arrays to store content and format
220                     $user->$key = array();
221                     $user->$key['text']   = $value;
222                     $user->$key['format'] = FORMAT_MOODLE;
223                 } else {
224                     $user->$key = $value;
225                 }
226             } else {
227                 $user->$key = $value;
228             }
230             if (in_array($key, $upt->columns)) {
231                 // default value in progress tracking table, can be changed later
232                 $upt->track($key, s($value), 'normal');
233             }
234         }
235         if (!isset($user->username)) {
236             // prevent warnings bellow
237             $user->username = '';
238         }
240         if ($optype == UU_USER_ADDNEW or $optype == UU_USER_ADDINC) {
241             // user creation is a special case - the username may be constructed from templates using firstname and lastname
242             // better never try this in mixed update types
243             $error = false;
244             if (!isset($user->firstname) or $user->firstname === '') {
245                 $upt->track('status', get_string('missingfield', 'error', 'firstname'), 'error');
246                 $upt->track('firstname', $errorstr, 'error');
247                 $error = true;
248             }
249             if (!isset($user->lastname) or $user->lastname === '') {
250                 $upt->track('status', get_string('missingfield', 'error', 'lastname'), 'error');
251                 $upt->track('lastname', $errorstr, 'error');
252                 $error = true;
253             }
254             if ($error) {
255                 $userserrors++;
256                 continue;
257             }
258             // we require username too - we might use template for it though
259             if (empty($user->username) and !empty($formdata->username)) {
260                 $user->username = uu_process_template($formdata->username, $user);
261                 $upt->track('username', s($user->username));
262             }
263         }
265         // normalize username
266         $originalusername = $user->username;
267         if ($standardusernames) {
268             $user->username = clean_param($user->username, PARAM_USERNAME);
269         }
271         // make sure we really have username
272         if (empty($user->username)) {
273             $upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
274             $upt->track('username', $errorstr, 'error');
275             $userserrors++;
276             continue;
277         } else if ($user->username === 'guest') {
278             $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
279             $userserrors++;
280             continue;
281         }
283         if ($existinguser = $DB->get_record('user', array('username'=>$user->username, 'mnethostid'=>$CFG->mnet_localhost_id))) {
284             $upt->track('id', $existinguser->id, 'normal', false);
285         }
287         // find out in username incrementing required
288         if ($existinguser and $optype == UU_USER_ADDINC) {
289             $user->username = uu_increment_username($user->username);
290             $existinguser = false;
291         }
293         // notify about nay username changes
294         if ($originalusername !== $user->username) {
295             $upt->track('username', '', 'normal', false); // clear previous
296             $upt->track('username', s($originalusername).'-->'.s($user->username), 'info');
297         } else {
298             $upt->track('username', s($user->username), 'normal', false);
299         }
301         // add default values for remaining fields
302         $formdefaults = array();
303         foreach ($STD_FIELDS as $field) {
304             if (isset($user->$field)) {
305                 continue;
306             }
307             // all validation moved to form2
308             if (isset($formdata->$field)) {
309                 // process templates
310                 $user->$field = uu_process_template($formdata->$field, $user);
311                 $formdefaults[$field] = true;
312                 if (in_array($field, $upt->columns)) {
313                     $upt->track($field, s($user->$field), 'normal');
314                 }
315             }
316         }
317         foreach ($PRF_FIELDS as $field) {
318             if (isset($user->$field)) {
319                 continue;
320             }
321             if (isset($formdata->$field)) {
322                 // process templates
323                 $user->$field = uu_process_template($formdata->$field, $user);
324                 $formdefaults[$field] = true;
325             }
326         }
328         // delete user
329         if (!empty($user->deleted)) {
330             if (!$allowdeletes) {
331                 $usersskipped++;
332                 $upt->track('status', $strusernotdeletedoff, 'warning');
333                 continue;
334             }
335             if ($existinguser) {
336                 if (is_siteadmin($existinguser->id)) {
337                     $upt->track('status', $strusernotdeletedadmin, 'error');
338                     $deleteerrors++;
339                     continue;
340                 }
341                 if (delete_user($existinguser)) {
342                     $upt->track('status', $struserdeleted);
343                     $deletes++;
344                 } else {
345                     $upt->track('status', $strusernotdeletederror, 'error');
346                     $deleteerrors++;
347                 }
348             } else {
349                 $upt->track('status', $strusernotdeletedmissing, 'error');
350                 $deleteerrors++;
351             }
352             continue;
353         }
354         // we do not need the deleted flag anymore
355         unset($user->deleted);
357         // renaming requested?
358         if (!empty($user->oldusername) ) {
359             if (!$allowrenames) {
360                 $usersskipped++;
361                 $upt->track('status', $strusernotrenamedoff, 'warning');
362                 continue;
363             }
365             if ($existinguser) {
366                 $upt->track('status', $strusernotrenamedexists, 'error');
367                 $renameerrors++;
368                 continue;
369             }
371             if ($user->username === 'guest') {
372                 $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
373                 $renameerrors++;
374                 continue;
375             }
377             if ($standardusernames) {
378                 $oldusername = clean_param($user->oldusername, PARAM_USERNAME);
379             } else {
380                 $oldusername = $user->oldusername;
381             }
383             // no guessing when looking for old username, it must be exact match
384             if ($olduser = $DB->get_record('user', array('username'=>$oldusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
385                 $upt->track('id', $olduser->id, 'normal', false);
386                 if (is_siteadmin($olduser->id)) {
387                     $upt->track('status', $strusernotrenamedadmin, 'error');
388                     $renameerrors++;
389                     continue;
390                 }
391                 $DB->set_field('user', 'username', $user->username, array('id'=>$olduser->id));
392                 $upt->track('username', '', 'normal', false); // clear previous
393                 $upt->track('username', s($oldusername).'-->'.s($user->username), 'info');
394                 $upt->track('status', $struserrenamed);
395                 $renames++;
396             } else {
397                 $upt->track('status', $strusernotrenamedmissing, 'error');
398                 $renameerrors++;
399                 continue;
400             }
401             $existinguser = $olduser;
402             $existinguser->username = $user->username;
403         }
405         // can we process with update or insert?
406         $skip = false;
407         switch ($optype) {
408             case UU_USER_ADDNEW:
409                 if ($existinguser) {
410                     $usersskipped++;
411                     $upt->track('status', $strusernotadded, 'warning');
412                     $skip = true;
413                 }
414                 break;
416             case UU_USER_ADDINC:
417                 if ($existinguser) {
418                     //this should not happen!
419                     $upt->track('status', $strusernotaddederror, 'error');
420                     $userserrors++;
421                     $skip = true;
422                 }
423                 break;
425             case UU_USER_ADD_UPDATE:
426                 break;
428             case UU_USER_UPDATE:
429                 if (!$existinguser) {
430                     $usersskipped++;
431                     $upt->track('status', $strusernotupdatednotexists, 'warning');
432                     $skip = true;
433                 }
434                 break;
436             default:
437                 // unknown type
438                 $skip = true;
439         }
441         if ($skip) {
442             continue;
443         }
445         if ($existinguser) {
446             $user->id = $existinguser->id;
448             $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$existinguser->id)), s($existinguser->username)), 'normal', false);
450             if (is_siteadmin($user->id)) {
451                 $upt->track('status', $strusernotupdatedadmin, 'error');
452                 $userserrors++;
453                 continue;
454             }
456             $existinguser->timemodified = time();
457             // do NOT mess with timecreated or firstaccess here!
459             //load existing profile data
460             profile_load_data($existinguser);
462             $upt->track('auth', $existinguser->auth, 'normal', false);
464             $doupdate = false;
466             if ($updatetype != UU_UPDATE_NOCHANGES) {
467                 if (!empty($user->auth) and $user->auth !== $existinguser->auth) {
468                     $upt->track('auth', s($existinguser->auth).'-->'.s($user->auth), 'info', false);
469                     $existinguser->auth = $user->auth;
470                     if (!isset($supportedauths[$user->auth])) {
471                         $upt->track('auth', $struserauthunsupported, 'warning');
472                     }
473                 }
474                 $allcolumns = array_merge($STD_FIELDS, $PRF_FIELDS);
475                 foreach ($allcolumns as $column) {
476                     if ($column === 'username' or $column === 'password' or $column === 'auth') {
477                         // these can not be changed here
478                         continue;
479                     }
480                     if (!property_exists($user, $column) or !property_exists($existinguser, $column)) {
481                         // this should never happen
482                         continue;
483                     }
484                     if ($updatetype == UU_UPDATE_MISSING) {
485                         if (!is_null($existinguser->$column) and $existinguser->$column !== '') {
486                             continue;
487                         }
488                     } else if ($updatetype == UU_UPDATE_ALLOVERRIDE) {
489                         // we override everything
491                     } else if ($updatetype == UU_UPDATE_FILEOVERRIDE) {
492                         if (!empty($formdefaults[$column])) {
493                             // do not override with form defaults
494                             continue;
495                         }
496                     }
497                     if ($existinguser->$column !== $user->$column) {
498                         if ($column === 'email') {
499                             if ($DB->record_exists('user', array('email'=>$user->email))) {
500                                 if ($noemailduplicates) {
501                                     $upt->track('email', $stremailduplicate, 'error');
502                                     $upt->track('status', $strusernotupdated, 'error');
503                                     $userserrors++;
504                                     continue 2;
505                                 } else {
506                                     $upt->track('email', $stremailduplicate, 'warning');
507                                 }
508                             }
509                             if (!validate_email($user->email)) {
510                                 $upt->track('email', get_string('invalidemail'), 'warning');
511                             }
512                         }
514                         if (in_array($column, $upt->columns)) {
515                             $upt->track($column, s($existinguser->$column).'-->'.s($user->$column), 'info', false);
516                         }
517                         $existinguser->$column = $user->$column;
518                         $doupdate = true;
519                     }
520                 }
521             }
523             try {
524                 $auth = get_auth_plugin($existinguser->auth);
525             } catch (Exception $e) {
526                 $upt->track('auth', get_string('userautherror', 'error', s($existinguser->auth)), 'error');
527                 $upt->track('status', $strusernotupdated, 'error');
528                 $userserrors++;
529                 continue;
530             }
531             $isinternalauth = $auth->is_internal();
533             // changing of passwords is a special case
534             // do not force password changes for external auth plugins!
535             $oldpw = $existinguser->password;
536             if (!$isinternalauth) {
537                 $existinguser->password = 'not cached';
538                 $upt->track('password', '-', 'normal', false);
539                 // clean up prefs
540                 unset_user_preference('create_password', $existinguser);
541                 unset_user_preference('auth_forcepasswordchange', $existinguser);
543             } else if (!empty($user->password)) {
544                 if ($updatepasswords) {
545                     $errmsg = null;
546                     $weak = !check_password_policy($user->password, $errmsg);
547                     if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
548                         if ($weak) {
549                             $weakpasswords++;
550                             $upt->track('password', $strinvalidpasswordpolicy, 'warning');
551                         }
552                         set_user_preference('auth_forcepasswordchange', 1, $existinguser);
553                     } else {
554                         unset_user_preference('auth_forcepasswordchange', $existinguser);
555                     }
556                     unset_user_preference('create_password', $existinguser); // no need to create password any more
557                     $existinguser->password = hash_internal_user_password($user->password);
558                     $upt->track('password', $user->password, 'normal', false);
559                 } else {
560                     // do not print password when not changed
561                     $upt->track('password', '', 'normal', false);
562                 }
563             }
565             if ($doupdate or $existinguser->password !== $oldpw) {
566                 // we want only users that were really updated
568                 $DB->update_record('user', $existinguser);
570                 $upt->track('status', $struserupdated);
571                 $usersupdated++;
572                 // save custom profile fields data from csv file
573                 profile_save_data($existinguser);
575                 events_trigger('user_updated', $existinguser);
577                 if ($bulk == UU_BULK_UPDATED or $bulk == UU_BULK_ALL) {
578                     if (!in_array($user->id, $SESSION->bulk_users)) {
579                         $SESSION->bulk_users[] = $user->id;
580                     }
581                 }
583             } else {
584                 // no user information changed
585                 $upt->track('status', $struseruptodate);
586                 $usersuptodate++;
588                 if ($bulk == UU_BULK_ALL) {
589                     if (!in_array($user->id, $SESSION->bulk_users)) {
590                         $SESSION->bulk_users[] = $user->id;
591                     }
592                 }
593             }
595         } else {
596             // save the new user to the database
597             $user->confirmed    = 1;
598             $user->timemodified = time();
599             $user->timecreated  = time();
600             $user->mnethostid   = $CFG->mnet_localhost_id; // we support ONLY local accounts here, sorry
602             if (empty($user->auth)) {
603                 $user->auth = 'manual';
604             }
605             $upt->track('auth', $user->auth, 'normal', false);
607             // do not insert record if new auth plugin does not exist!
608             try {
609                 $auth = get_auth_plugin($user->auth);
610             } catch (Exception $e) {
611                 $upt->track('auth', get_string('userautherror', 'error', s($user->auth)), 'error');
612                 $upt->track('status', $strusernotaddederror, 'error');
613                 $userserrors++;
614                 continue;
615             }
616             if (!isset($supportedauths[$user->auth])) {
617                 $upt->track('auth', $struserauthunsupported, 'warning');
618             }
620             $isinternalauth = $auth->is_internal();
622             if (empty($user->email)) {
623                 $upt->track('email', get_string('invalidemail'), 'error');
624                 $upt->track('status', $strusernotaddederror, 'error');
625                 $userserrors++;
626                 continue;
628             } else if ($DB->record_exists('user', array('email'=>$user->email))) {
629                 if ($noemailduplicates) {
630                     $upt->track('email', $stremailduplicate, 'error');
631                     $upt->track('status', $strusernotaddederror, 'error');
632                     $userserrors++;
633                     continue;
634                 } else {
635                     $upt->track('email', $stremailduplicate, 'warning');
636                 }
637             }
638             if (!validate_email($user->email)) {
639                 $upt->track('email', get_string('invalidemail'), 'warning');
640             }
642             $forcechangepassword = false;
644             if ($isinternalauth) {
645                 if (empty($user->password)) {
646                     if ($createpasswords) {
647                         $user->password = 'to be generated';
648                         $upt->track('password', '', 'normal', false);
649                         $upt->track('password', get_string('uupasswordcron', 'admin'), 'warning', false);
650                     } else {
651                         $upt->track('password', '', 'normal', false);
652                         $upt->track('password', get_string('missingfield', 'error', 'password'), 'error');
653                         $upt->track('status', $strusernotaddederror, 'error');
654                         $userserrors++;
655                         continue;
656                     }
657                 } else {
658                     $errmsg = null;
659                     $weak = !check_password_policy($user->password, $errmsg);
660                     if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
661                         if ($weak) {
662                             $weakpasswords++;
663                             $upt->track('password', $strinvalidpasswordpolicy, 'warning');
664                         }
665                         $forcechangepassword = true;
666                     }
667                     $user->password = hash_internal_user_password($user->password);
668                 }
669             } else {
670                 $user->password = 'not cached';
671                 $upt->track('password', '-', 'normal', false);
672             }
674             // create user - insert_record ignores any extra properties
675             $user->id = $DB->insert_record('user', $user);
676             $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$user->id)), s($user->username)), 'normal', false);
678             // save custom profile fields data
679             profile_save_data($user);
681             if ($forcechangepassword) {
682                 set_user_preference('auth_forcepasswordchange', 1, $user);
683             }
684             if ($user->password === 'to be generated') {
685                 set_user_preference('create_password', 1, $user);
686             }
688             $upt->track('status', $struseradded);
689             $upt->track('id', $user->id, 'normal', false);
690             $usersnew++;
692             // make sure user context exists
693             get_context_instance(CONTEXT_USER, $user->id);
695             events_trigger('user_created', $user);
697             if ($bulk == UU_BULK_NEW or $bulk == UU_BULK_ALL) {
698                 if (!in_array($user->id, $SESSION->bulk_users)) {
699                     $SESSION->bulk_users[] = $user->id;
700                 }
701             }
702         }
705         // add to cohort first, it might trigger enrolments indirectly - do NOT create cohorts here!
706         foreach ($filecolumns as $column) {
707             if (!preg_match('/^cohort\d+$/', $column)) {
708                 continue;
709             }
711             if (!empty($user->$column)) {
712                 $addcohort = $user->$column;
713                 if (!isset($cohorts[$addcohort])) {
714                     if (is_number($addcohort)) {
715                         // only non-numeric idnumbers!
716                         $cohort = $DB->get_record('cohort', array('id'=>$addcohort));
717                     } else {
718                         $cohort = $DB->get_record('cohort', array('idnumber'=>$addcohort));
719                     }
721                     if (empty($cohort)) {
722                         $cohorts[$addcohort] = get_string('unknowncohort', 'core_cohort', s($addcohort));
723                     } else if (!empty($cohort->component)) {
724                         // cohorts synchronised with external sources must not be modified!
725                         $cohorts[$addcohort] = get_string('external', 'core_cohort');
726                     } else {
727                         $cohorts[$addcohort] = $cohort;
728                     }
729                 }
731                 if (is_object($cohorts[$addcohort])) {
732                     $cohort = $cohorts[$addcohort];
733                     if (!$DB->record_exists('cohort_members', array('cohortid'=>$cohort->id, 'userid'=>$user->id))) {
734                         cohort_add_member($cohort->id, $user->id);
735                         // we might add special column later, for now let's abuse enrolments
736                         $upt->track('enrolments', get_string('useradded', 'core_cohort', s($cohort->name)));
737                     }
738                 } else {
739                     // error message
740                     $upt->track('enrolments', $cohorts[$addcohort], 'error');
741                 }
742             }
743         }
746         // find course enrolments, groups, roles/types and enrol periods
747         // this is again a special case, we always do this for any updated or created users
748         foreach ($filecolumns as $column) {
749             if (!preg_match('/^course\d+$/', $column)) {
750                 continue;
751             }
752             $i = substr($column, 6);
754             if (empty($user->{'course'.$i})) {
755                 continue;
756             }
757             $shortname = $user->{'course'.$i};
758             if (!array_key_exists($shortname, $ccache)) {
759                 if (!$course = $DB->get_record('course', array('shortname'=>$shortname), 'id, shortname')) {
760                     $upt->track('enrolments', get_string('unknowncourse', 'error', s($shortname)), 'error');
761                     continue;
762                 }
763                 $ccache[$shortname] = $course;
764                 $ccache[$shortname]->groups = null;
765             }
766             $courseid      = $ccache[$shortname]->id;
767             $coursecontext = get_context_instance(CONTEXT_COURSE, $courseid);
768             if (!isset($manualcache[$courseid])) {
769                 $manualcache[$courseid] = false;
770                 if ($manual) {
771                     if ($instances = enrol_get_instances($courseid, false)) {
772                         foreach ($instances as $instance) {
773                             if ($instance->enrol === 'manual') {
774                                 $manualcache[$courseid] = $instance;
775                                 break;
776                             }
777                         }
778                     }
779                 }
780             }
782             if ($manual and $manualcache[$courseid]) {
784                 // find role
785                 $rid = false;
786                 if (!empty($user->{'role'.$i})) {
787                     $addrole = $user->{'role'.$i};
788                     if (array_key_exists($addrole, $rolecache)) {
789                         $rid = $rolecache[$addrole]->id;
790                     } else {
791                         $upt->track('enrolments', get_string('unknownrole', 'error', s($addrole)), 'error');
792                         continue;
793                     }
795                 } else if (!empty($user->{'type'.$i})) {
796                     // if no role, then find "old" enrolment type
797                     $addtype = $user->{'type'.$i};
798                     if ($addtype < 1 or $addtype > 3) {
799                         $upt->track('enrolments', $strerror.': typeN = 1|2|3', 'error');
800                         continue;
801                     } else if (empty($formdata->{'uulegacy'.$addtype})) {
802                         continue;
803                     } else {
804                         $rid = $formdata->{'uulegacy'.$addtype};
805                     }
806                 } else {
807                     // no role specified, use the default from manual enrol plugin
808                     $rid = $manualcache[$courseid]->roleid;
809                 }
811                 if ($rid) {
812                     // find duration
813                     $timeend   = 0;
814                     if (!empty($user->{'enrolperiod'.$i})) {
815                         $duration = (int)$user->{'enrolperiod'.$i} * 60*60*24; // convert days to seconds
816                         if ($duration > 0) { // sanity check
817                             $timeend = $today + $duration;
818                         }
819                     }
821                     $manual->enrol_user($manualcache[$courseid], $user->id, $rid, $today, $timeend);
823                     $a = new stdClass();
824                     $a->course = $shortname;
825                     $a->role   = $rolecache[$rid]->name;
826                     $upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
827                 }
828             }
830             // find group to add to
831             if (!empty($user->{'group'.$i})) {
832                 // make sure user is enrolled into course before adding into groups
833                 if (!is_enrolled($coursecontext, $user->id)) {
834                     $upt->track('enrolments', get_string('addedtogroupnotenrolled', '', $user->{'group'.$i}), 'error');
835                     continue;
836                 }
837                 //build group cache
838                 if (is_null($ccache[$shortname]->groups)) {
839                     $ccache[$shortname]->groups = array();
840                     if ($groups = groups_get_all_groups($courseid)) {
841                         foreach ($groups as $gid=>$group) {
842                             $ccache[$shortname]->groups[$gid] = new stdClass();
843                             $ccache[$shortname]->groups[$gid]->id   = $gid;
844                             $ccache[$shortname]->groups[$gid]->name = $group->name;
845                             if (!is_numeric($group->name)) { // only non-numeric names are supported!!!
846                                 $ccache[$shortname]->groups[$group->name] = new stdClass();
847                                 $ccache[$shortname]->groups[$group->name]->id   = $gid;
848                                 $ccache[$shortname]->groups[$group->name]->name = $group->name;
849                             }
850                         }
851                     }
852                 }
853                 // group exists?
854                 $addgroup = $user->{'group'.$i};
855                 if (!array_key_exists($addgroup, $ccache[$shortname]->groups)) {
856                     // if group doesn't exist,  create it
857                     $newgroupdata = new stdClass();
858                     $newgroupdata->name = $addgroup;
859                     $newgroupdata->courseid = $ccache[$shortname]->id;
860                     if ($ccache[$shortname]->groups[$addgroup]->id = groups_create_group($newgroupdata)){
861                         $ccache[$shortname]->groups[$addgroup]->name = $newgroupdata->name;
862                     } else {
863                         $upt->track('enrolments', get_string('unknowngroup', 'error', s($addgroup)), 'error');
864                         continue;
865                     }
866                 }
867                 $gid   = $ccache[$shortname]->groups[$addgroup]->id;
868                 $gname = $ccache[$shortname]->groups[$addgroup]->name;
870                 try {
871                     if (groups_add_member($gid, $user->id)) {
872                         $upt->track('enrolments', get_string('addedtogroup', '', s($gname)));
873                     }  else {
874                         $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
875                     }
876                 } catch (moodle_exception $e) {
877                     $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
878                     continue;
879                 }
880             }
881         }
882     }
883     $upt->close(); // close table
885     $cir->close();
886     $cir->cleanup(true);
888     echo $OUTPUT->box_start('boxwidthnarrow boxaligncenter generalbox', 'uploadresults');
889     echo '<p>';
890     if ($optype != UU_USER_UPDATE) {
891         echo get_string('userscreated', 'admin').': '.$usersnew.'<br />';
892     }
893     if ($optype == UU_USER_UPDATE or $optype == UU_USER_ADD_UPDATE) {
894         echo get_string('usersupdated', 'admin').': '.$usersupdated.'<br />';
895     }
896     if ($allowdeletes) {
897         echo get_string('usersdeleted', 'admin').': '.$deletes.'<br />';
898         echo get_string('deleteerrors', 'admin').': '.$deleteerrors.'<br />';
899     }
900     if ($allowrenames) {
901         echo get_string('usersrenamed', 'admin').': '.$renames.'<br />';
902         echo get_string('renameerrors', 'admin').': '.$renameerrors.'<br />';
903     }
904     if ($usersskipped) {
905         echo get_string('usersskipped', 'admin').': '.$usersskipped.'<br />';
906     }
907     echo get_string('usersweakpassword', 'admin').': '.$weakpasswords.'<br />';
908     echo get_string('errors', 'admin').': '.$userserrors.'</p>';
909     echo $OUTPUT->box_end();
911     if ($bulk) {
912         echo $OUTPUT->continue_button($bulknurl);
913     } else {
914         echo $OUTPUT->continue_button($returnurl);
915     }
916     echo $OUTPUT->footer();
917     die;
920 // Print the header
921 echo $OUTPUT->header();
923 echo $OUTPUT->heading(get_string('uploaduserspreview', 'admin'));
925 // NOTE: this is JUST csv processing preview, we must not prevent import from here if there is something in the file!!
926 //       this was intended for validation of csv formatting and encoding, not filtering the data!!!!
927 //       we definitely must not process the whole file!
929 // preview table data
930 $data = array();
931 $cir->init();
932 $linenum = 1; //column header is first line
933 while ($linenum <= $previewrows and $fields = $cir->next()) {
934     $linenum++;
935     $rowcols = array();
936     $rowcols['line'] = $linenum;
937     foreach($fields as $key => $field) {
938         $rowcols[$filecolumns[$key]] = s($field);
939     }
940     $rowcols['status'] = array();
942     if (isset($rowcols['username'])) {
943         $stdusername = clean_param($rowcols['username'], PARAM_USERNAME);
944         if ($rowcols['username'] !== $stdusername) {
945             $rowcols['status'][] = get_string('invalidusernameupload');
946         }
947         if ($userid = $DB->get_field('user', 'id', array('username'=>$stdusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
948             $rowcols['username'] = html_writer::link(new moodle_url('/user/profile.php', array('id'=>$userid)), $rowcols['username']);
949         }
950     } else {
951         $rowcols['status'][] = get_string('missingusername');
952     }
954     if (isset($rowcols['email'])) {
955         if (!validate_email($rowcols['email'])) {
956             $rowcols['status'][] = get_string('invalidemail');
957         }
958         if ($DB->record_exists('user', array('email'=>$rowcols['email']))) {
959             $rowcols['status'][] = $stremailduplicate;
960         }
961     }
963     if (isset($rowcols['city'])) {
964         $rowcols['city'] = trim($rowcols['city']);
965         if (empty($rowcols['city'])) {
966             $rowcols['status'][] = get_string('fieldrequired', 'error', 'city');
967         }
968     }
970     $rowcols['status'] = implode('<br />', $rowcols['status']);
971     $data[] = $rowcols;
973 if ($fields = $cir->next()) {
974     $data[] = array_fill(0, count($fields) + 2, '...');
976 $cir->close();
978 $table = new html_table();
979 $table->id = "uupreview";
980 $table->attributes['class'] = 'generaltable';
981 $table->tablealign = 'center';
982 $table->summary = get_string('uploaduserspreview', 'admin');
983 $table->head = array();
984 $table->data = $data;
986 $table->head[] = get_string('uucsvline', 'admin');
987 foreach ($filecolumns as $column) {
988     $table->head[] = $column;
990 $table->head[] = get_string('status');
992 echo html_writer::tag('div', html_writer::table($table), array('class'=>'flexible-wrap'));
994 /// Print the form
996 $mform2->display();
997 echo $OUTPUT->footer();
998 die;