Merge branch 'w09_MDL-26564_20_uploadusers' of git://github.com/skodak/moodle
[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('uploaduserlib.php');
32 require_once('uploaduser_form.php');
34 $iid         = optional_param('iid', '', PARAM_INT);
35 $previewrows = optional_param('previewrows', 10, PARAM_INT);
37 @set_time_limit(60*60); // 1 hour should be enough
38 raise_memory_limit(MEMORY_HUGE);
40 require_login();
41 admin_externalpage_setup('uploadusers');
42 require_capability('moodle/site:uploadusers', get_context_instance(CONTEXT_SYSTEM));
44 $struserrenamed             = get_string('userrenamed', 'admin');
45 $strusernotrenamedexists    = get_string('usernotrenamedexists', 'error');
46 $strusernotrenamedmissing   = get_string('usernotrenamedmissing', 'error');
47 $strusernotrenamedoff       = get_string('usernotrenamedoff', 'error');
48 $strusernotrenamedadmin     = get_string('usernotrenamedadmin', 'error');
50 $struserupdated             = get_string('useraccountupdated', 'admin');
51 $strusernotupdated          = get_string('usernotupdatederror', 'error');
52 $strusernotupdatednotexists = get_string('usernotupdatednotexists', 'error');
53 $strusernotupdatedadmin     = get_string('usernotupdatedadmin', 'error');
55 $struseruptodate            = get_string('useraccountuptodate', 'admin');
57 $struseradded               = get_string('newuser');
58 $strusernotadded            = get_string('usernotaddedregistered', 'error');
59 $strusernotaddederror       = get_string('usernotaddederror', 'error');
61 $struserdeleted             = get_string('userdeleted', 'admin');
62 $strusernotdeletederror     = get_string('usernotdeletederror', 'error');
63 $strusernotdeletedmissing   = get_string('usernotdeletedmissing', 'error');
64 $strusernotdeletedoff       = get_string('usernotdeletedoff', 'error');
65 $strusernotdeletedadmin     = get_string('usernotdeletedadmin', 'error');
67 $strcannotassignrole        = get_string('cannotassignrole', 'error');
69 $struserauthunsupported     = get_string('userauthunsupported', 'error');
70 $stremailduplicate          = get_string('useremailduplicate', 'error');
72 $strinvalidpasswordpolicy   = get_string('invalidpasswordpolicy', 'error');
73 $errorstr                   = get_string('error');
75 $returnurl = new moodle_url('/admin/uploaduser.php');
76 $bulknurl  = new moodle_url('/admin/user/user_bulk.php');
78 $today = time();
79 $today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
81 // array of all valid fields for validation
82 $STD_FIELDS = array('id', 'firstname', 'lastname', 'username', 'email',
83         'city', 'country', 'lang', 'timezone', 'mailformat',
84         'maildisplay', 'maildigest', 'htmleditor', 'ajax', 'autosubscribe',
85         'institution', 'department', 'idnumber', 'skype',
86         'msn', 'aim', 'yahoo', 'icq', 'phone1', 'phone2', 'address',
87         'url', 'description', 'descriptionformat', 'password',
88         'auth',        // watch out when changing auth type or using external auth plugins!
89         'oldusername', // use when renaming users - this is the original username
90         'deleted',     // 1 means delete user
91     );
93 $PRF_FIELDS = array();
95 if ($prof_fields = $DB->get_records('user_info_field')) {
96     foreach ($prof_fields as $prof_field) {
97         $PRF_FIELDS[] = 'profile_field_'.$prof_field->shortname;
98     }
99 }
100 unset($prof_fields);
102 if (empty($iid)) {
103     $mform1 = new admin_uploaduser_form1();
105     if ($formdata = $mform1->get_data()) {
106         $iid = csv_import_reader::get_new_iid('uploaduser');
107         $cir = new csv_import_reader($iid, 'uploaduser');
109         $content = $mform1->get_file_content('userfile');
111         $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
112         unset($content);
114         if ($readcount === false) {
115             print_error('csvloaderror', '', $returnurl);
116         } else if ($readcount == 0) {
117             print_error('csvemptyfile', 'error', $returnurl);
118         }
119         // test if columns ok
120         $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
121         // continue to form2
123     } else {
124         echo $OUTPUT->header();
126         echo $OUTPUT->heading_with_help(get_string('uploadusers', 'admin'), 'uploadusers', 'admin');
128         $mform1->display();
129         echo $OUTPUT->footer();
130         die;
131     }
132 } else {
133     $cir = new csv_import_reader($iid, 'uploaduser');
134     $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
137 $mform2 = new admin_uploaduser_form2(null, array('columns'=>$filecolumns, 'data'=>array('iid'=>$iid, 'previewrows'=>$previewrows)));
139 // If a file has been uploaded, then process it
140 if ($formdata = $mform2->is_cancelled()) {
141     $cir->cleanup(true);
142     redirect($returnurl);
144 } else if ($formdata = $mform2->get_data()) {
145     // Print the header
146     echo $OUTPUT->header();
147     echo $OUTPUT->heading(get_string('uploadusersresult', 'admin'));
149     $optype = $formdata->uutype;
151     $updatetype        = isset($formdata->uuupdatetype) ? $formdata->uuupdatetype : 0;
152     $createpasswords   = (!empty($formdata->uupasswordnew) and $optype != UU_USER_UPDATE);
153     $updatepasswords   = (!empty($formdata->uupasswordold)  and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC and ($updatetype == UU_UPDATE_FILEOVERRIDE or $updatetype == UU_UPDATE_ALLOVERRIDE));
154     $allowrenames      = (!empty($formdata->uuallowrenames) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
155     $allowdeletes      = (!empty($formdata->uuallowdeletes) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
156     $bulk              = $formdata->uubulk;
157     $noemailduplicates = $formdata->uunoemailduplicates;
158     $standardusernames = $formdata->uustandardusernames;
159     $resetpasswords    = isset($formdata->uuforcepasswordchange) ? $formdata->uuforcepasswordchange : UU_PWRESET_NONE;
161     // verification moved to two places: after upload and into form2
162     $usersnew      = 0;
163     $usersupdated  = 0;
164     $usersuptodate = 0; //not printed yet anywhere
165     $userserrors   = 0;
166     $deletes       = 0;
167     $deleteerrors  = 0;
168     $renames       = 0;
169     $renameerrors  = 0;
170     $usersskipped  = 0;
171     $weakpasswords = 0;
173     // caches
174     $ccache         = array(); // course cache - do not fetch all courses here, we  will not probably use them all anyway!
175     $rolecache      = uu_allowed_roles_cache(); // roles lookup cache
176     $manualcache    = array(); // cache of used manual enrol plugins in each course
177     $supportedauths = uu_supported_auths(); // officially supported plugins that are enabled
179     // we use only manual enrol plugin here, if it is disabled no enrol is done
180     if (enrol_is_enabled('manual')) {
181         $manual = enrol_get_plugin('manual');
182     } else {
183         $manual = NULL;
184     }
186     // clear bulk selection
187     if ($bulk) {
188         $SESSION->bulk_users = array();
189     }
191     // init csv import helper
192     $cir->init();
193     $linenum = 1; //column header is first line
195     // init upload progress tracker
196     $upt = new uu_progress_tracker();
197     $upt->start(); // start table
199     while ($line = $cir->next()) {
200         $upt->flush();
201         $linenum++;
203         $upt->track('line', $linenum);
205         $user = new stdClass();
207         // add fields to user object
208         foreach ($line as $keynum => $value) {
209             if (!isset($filecolumns[$keynum])) {
210                 // this should not happen
211                 continue;
212             }
213             $key = $filecolumns[$keynum];
214             if (strpos($key, 'profile_field_') === 0) {
215                 //NOTE: bloody mega hack alert!!
216                 if (isset($USER->$key) and is_array($USER->$key)) {
217                     // this must be some hacky field that is abusing arrays to store content and format
218                     $user->$key = array();
219                     $user->$key['text']   = $value;
220                     $user->$key['format'] = FORMAT_MOODLE;
221                 } else {
222                     $user->$key = $value;
223                 }
224             } else {
225                 $user->$key = $value;
226             }
228             if (in_array($key, $upt->columns)) {
229                 // default value in progress tracking table, can be changed later
230                 $upt->track($key, s($value), 'normal');
231             }
232         }
233         if (!isset($user->username)) {
234             // prevent warnings bellow
235             $user->username = '';
236         }
238         if ($optype == UU_USER_ADDNEW or $optype == UU_USER_ADDINC) {
239             // user creation is a special case - the username may be constructed from templates using firstname and lastname
240             // better never try this in mixed update types
241             $error = false;
242             if (!isset($user->firstname) or $user->firstname === '') {
243                 $upt->track('status', get_string('missingfield', 'error', 'firstname'), 'error');
244                 $upt->track('firstname', $errorstr, 'error');
245                 $error = true;
246             }
247             if (!isset($user->lastname) or $user->lastname === '') {
248                 $upt->track('status', get_string('missingfield', 'error', 'lastname'), 'error');
249                 $upt->track('lastname', $errorstr, 'error');
250                 $error = true;
251             }
252             if ($error) {
253                 $userserrors++;
254                 continue;
255             }
256             // we require username too - we might use template for it though
257             if (empty($user->username) and !empty($formdata->username)) {
258                 $user->username = uu_process_template($formdata->username, $user);
259                 $upt->track('username', s($user->username));
260             }
261         }
263         // normalize username
264         $originalusername = $user->username;
265         if ($standardusernames) {
266             $user->username = clean_param($user->username, PARAM_USERNAME);
267         }
269         // make sure we really have username
270         if (empty($user->username)) {
271             $upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
272             $upt->track('username', $errorstr, 'error');
273             $userserrors++;
274             continue;
275         } else if ($user->username === 'guest') {
276             $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
277             $userserrors++;
278             continue;
279         }
281         if ($existinguser = $DB->get_record('user', array('username'=>$user->username, 'mnethostid'=>$CFG->mnet_localhost_id))) {
282             $upt->track('id', $existinguser->id, 'normal', false);
283         }
285         // find out in username incrementing required
286         if ($existinguser and $optype == UU_USER_ADDINC) {
287             $user->username = uu_increment_username($user->username);
288             $existinguser = false;
289         }
291         // notify about nay username changes
292         if ($originalusername !== $user->username) {
293             $upt->track('username', '', 'normal', false); // clear previous
294             $upt->track('username', s($originalusername).'-->'.s($user->username), 'info');
295         } else {
296             $upt->track('username', s($user->username), 'normal', false);
297         }
299         // add default values for remaining fields
300         $formdefaults = array();
301         foreach ($STD_FIELDS as $field) {
302             if (isset($user->$field)) {
303                 continue;
304             }
305             // all validation moved to form2
306             if (isset($formdata->$field)) {
307                 // process templates
308                 $user->$field = uu_process_template($formdata->$field, $user);
309                 $formdefaults[$field] = true;
310             }
311         }
312         foreach ($PRF_FIELDS as $field) {
313             if (isset($user->$field)) {
314                 continue;
315             }
316             if (isset($formdata->$field)) {
317                 // process templates
318                 $user->$field = uu_process_template($formdata->$field, $user);
319                 $formdefaults[$field] = true;
320             }
321         }
323         // delete user
324         if (!empty($user->deleted)) {
325             if (!$allowdeletes) {
326                 $usersskipped++;
327                 $upt->track('status', $strusernotdeletedoff, 'warning');
328                 continue;
329             }
330             if ($existinguser) {
331                 if (is_siteadmin($existinguser->id)) {
332                     $upt->track('status', $strusernotdeletedadmin, 'error');
333                     $deleteerrors++;
334                     continue;
335                 }
336                 if (delete_user($existinguser)) {
337                     $upt->track('status', $struserdeleted);
338                     $deletes++;
339                 } else {
340                     $upt->track('status', $strusernotdeletederror, 'error');
341                     $deleteerrors++;
342                 }
343             } else {
344                 $upt->track('status', $strusernotdeletedmissing, 'error');
345                 $deleteerrors++;
346             }
347             continue;
348         }
349         // we do not need the deleted flag anymore
350         unset($user->deleted);
352         // renaming requested?
353         if (!empty($user->oldusername) ) {
354             if (!$allowrenames) {
355                 $usersskipped++;
356                 $upt->track('status', $strusernotrenamedoff, 'warning');
357                 continue;
358             }
360             if ($existinguser) {
361                 $upt->track('status', $strusernotrenamedexists, 'error');
362                 $renameerrors++;
363                 continue;
364             }
366             if ($user->username === 'guest') {
367                 $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
368                 $renameerrors++;
369                 continue;
370             }
372             if ($standardusernames) {
373                 $oldusername = clean_param($user->oldusername, PARAM_USERNAME);
374             } else {
375                 $oldusername = $user->oldusername;
376             }
378             // no guessing when looking for old username, it must be exact match
379             if ($olduser = $DB->get_record('user', array('username'=>$oldusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
380                 $upt->track('id', $olduser->id, 'normal', false);
381                 if (is_siteadmin($olduser->id)) {
382                     $upt->track('status', $strusernotrenamedadmin, 'error');
383                     $renameerrors++;
384                     continue;
385                 }
386                 $DB->set_field('user', 'username', $user->username, array('id'=>$olduser->id));
387                 $upt->track('username', '', 'normal', false); // clear previous
388                 $upt->track('username', s($oldusername).'-->'.s($user->username), 'info');
389                 $upt->track('status', $struserrenamed);
390                 $renames++;
391             } else {
392                 $upt->track('status', $strusernotrenamedmissing, 'error');
393                 $renameerrors++;
394                 continue;
395             }
396             $existinguser = $olduser;
397             $existinguser->username = $user->username;
398         }
400         // can we process with update or insert?
401         $skip = false;
402         switch ($optype) {
403             case UU_USER_ADDNEW:
404                 if ($existinguser) {
405                     $usersskipped++;
406                     $upt->track('status', $strusernotadded, 'warning');
407                     $skip = true;
408                 }
409                 break;
411             case UU_USER_ADDINC:
412                 if ($existinguser) {
413                     //this should not happen!
414                     $upt->track('status', $strusernotaddederror, 'error');
415                     $userserrors++;
416                     $skip = true;
417                 }
418                 break;
420             case UU_USER_ADD_UPDATE:
421                 break;
423             case UU_USER_UPDATE:
424                 if (!$existinguser) {
425                     $usersskipped++;
426                     $upt->track('status', $strusernotupdatednotexists, 'warning');
427                     $skip = true;
428                 }
429                 break;
431             default:
432                 // unknown type
433                 $skip = true;
434         }
436         if ($skip) {
437             continue;
438         }
440         if ($existinguser) {
441             $user->id = $existinguser->id;
443             $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$existinguser->id)), s($existinguser->username)), 'normal', false);
445             if (is_siteadmin($user->id)) {
446                 $upt->track('status', $strusernotupdatedadmin, 'error');
447                 $userserrors++;
448                 continue;
449             }
451             $existinguser->timemodified = time();
452             // do NOT mess with timecreated or firstaccess here!
454             //load existing profile data
455             profile_load_data($existinguser);
457             $upt->track('auth', $existinguser->auth, 'normal', false);
459             $doupdate = false;
461             if ($updatetype != UU_UPDATE_NOCHANGES) {
462                 if (!empty($user->auth) and $user->auth !== $existinguser->auth) {
463                     $upt->track('auth', s($existinguser->auth).'-->'.s($user->auth), 'info', false);
464                     $existinguser->auth = $user->auth;
465                     if (!isset($supportedauths[$user->auth])) {
466                         $upt->track('auth', $struserauthunsupported, 'warning');
467                     }
468                 }
469                 $allcolumns = array_merge($STD_FIELDS, $PRF_FIELDS);
470                 foreach ($allcolumns as $column) {
471                     if ($column === 'username' or $column === 'password' or $column === 'auth') {
472                         // these can not be changed here
473                         continue;
474                     }
475                     if (!property_exists($user, $column) or !property_exists($existinguser, $column)) {
476                         // this should never happen
477                         continue;
478                     }
479                     if ($updatetype == UU_UPDATE_MISSING) {
480                         if (!is_null($existinguser->$column) and $existinguser->$column !== '') {
481                             continue;
482                         }
483                     } else if ($updatetype == UU_UPDATE_ALLOVERRIDE) {
484                         // we override everything
486                     } else if ($updatetype == UU_UPDATE_FILEOVERRIDE) {
487                         if (!empty($formdefaults[$column])) {
488                             // do not override with form defaults
489                             continue;
490                         }
491                     }
492                     if ($existinguser->$column !== $user->$column) {
493                         if ($column === 'email') {
494                             if ($DB->record_exists('user', array('email'=>$user->email))) {
495                                 if ($noemailduplicates) {
496                                     $upt->track('email', $stremailduplicate, 'error');
497                                     $upt->track('status', $strusernotupdated, 'error');
498                                     $userserrors++;
499                                     continue 2;
500                                 } else {
501                                     $upt->track('email', $stremailduplicate, 'warning');
502                                 }
503                             }
504                             if (!validate_email($user->email)) {
505                                 $upt->track('email', get_string('invalidemail'), 'warning');
506                             }
507                         }
509                         if (in_array($column, $upt->columns)) {
510                             $upt->track($column, s($existinguser->$column).'-->'.s($user->$column), 'info', false);
511                         }
512                         $existinguser->$column = $user->$column;
513                         $doupdate = true;
514                     }
515                 }
516             }
518             try {
519                 $auth = get_auth_plugin($existinguser->auth);
520             } catch (Exception $e) {
521                 $upt->track('auth', get_string('userautherror', 'error', s($existinguser->auth)), 'error');
522                 $upt->track('status', $strusernotupdated, 'error');
523                 $userserrors++;
524                 continue;
525             }
526             $isinternalauth = $auth->is_internal();
528             // changing of passwords is a special case
529             // do not force password changes for external auth plugins!
530             $oldpw = $existinguser->password;
531             if (!$isinternalauth) {
532                 $existinguser->password = 'not cached';
533                 $upt->track('password', '-', 'normal', false);
534                 // clean up prefs
535                 unset_user_preference('create_password', $existinguser);
536                 unset_user_preference('auth_forcepasswordchange', $existinguser);
538             } else if (!empty($user->password)) {
539                 if ($updatepasswords) {
540                     $errmsg = null;
541                     $weak = !check_password_policy($user->password, $errmsg);
542                     if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
543                         if ($weak) {
544                             $weakpasswords++;
545                             $upt->track('password', $strinvalidpasswordpolicy, 'warning');
546                         }
547                         set_user_preference('auth_forcepasswordchange', 1, $existinguser);
548                     } else {
549                         unset_user_preference('auth_forcepasswordchange', $existinguser);
550                     }
551                     unset_user_preference('create_password', $existinguser); // no need to create password any more
552                     $existinguser->password = hash_internal_user_password($user->password);
553                     $upt->track('password', $user->password, 'normal', false);
554                 } else {
555                     // do not print password when not changed
556                     $upt->track('password', '', 'normal', false);
557                 }
558             }
560             if ($doupdate or $existinguser->password !== $oldpw) {
561                 // we want only users that were really updated
563                 $DB->update_record('user', $existinguser);
565                 $upt->track('status', $struserupdated);
566                 $usersupdated++;
567                 // save custom profile fields data from csv file
568                 profile_save_data($existinguser);
570                 events_trigger('user_updated', $existinguser);
572                 if ($bulk == UU_BULK_UPDATED or $bulk == UU_BULK_ALL) {
573                     if (!in_array($user->id, $SESSION->bulk_users)) {
574                         $SESSION->bulk_users[] = $user->id;
575                     }
576                 }
578             } else {
579                 // no user information changed
580                 $upt->track('status', $struseruptodate);
581                 $usersuptodate++;
583                 if ($bulk == UU_BULK_ALL) {
584                     if (!in_array($user->id, $SESSION->bulk_users)) {
585                         $SESSION->bulk_users[] = $user->id;
586                     }
587                 }
588             }
590         } else {
591             // save the new user to the database
592             $user->confirmed    = 1;
593             $user->timemodified = time();
594             $user->timecreated  = time();
595             $user->mnethostid   = $CFG->mnet_localhost_id; // we support ONLY local accounts here, sorry
597             if (empty($user->auth)) {
598                 $user->auth = 'manual';
599             }
600             $upt->track('auth', $user->auth, 'normal', false);
602             // do not insert record if new auth plugin does not exist!
603             try {
604                 $auth = get_auth_plugin($user->auth);
605             } catch (Exception $e) {
606                 $upt->track('auth', get_string('userautherror', 'error', s($user->auth)), 'error');
607                 $upt->track('status', $strusernotaddederror, 'error');
608                 $userserrors++;
609                 continue;
610             }
611             if (!isset($supportedauths[$user->auth])) {
612                 $upt->track('auth', $struserauthunsupported, 'warning');
613             }
615             $isinternalauth = $auth->is_internal();
617             if ($DB->record_exists('user', array('email'=>$user->email))) {
618                 if ($noemailduplicates) {
619                     $upt->track('email', $stremailduplicate, 'error');
620                     $upt->track('status', $strusernotaddederror, 'error');
621                     $userserrors++;
622                     continue;
623                 } else {
624                     $upt->track('email', $stremailduplicate, 'warning');
625                 }
626             }
627             if (!validate_email($user->email)) {
628                 $upt->track('email', get_string('invalidemail'), 'warning');
629             }
631             $forcechangepassword = false;
633             if ($isinternalauth) {
634                 if (empty($user->password)) {
635                     if ($createpasswords) {
636                         $user->password = 'to be generated';
637                         $upt->track('password', '', 'normal', false);
638                         $upt->track('password', get_string('uupasswordcron', 'admin'), 'warning', false);
639                     } else {
640                         $upt->track('password', '', 'normal', false);
641                         $upt->track('password', get_string('missingfield', 'error', 'password'), 'error');
642                         $upt->track('status', $strusernotaddederror, 'error');
643                         $userserrors++;
644                         continue;
645                     }
646                 } else {
647                     $errmsg = null;
648                     $weak = !check_password_policy($user->password, $errmsg);
649                     if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
650                         if ($weak) {
651                             $weakpasswords++;
652                             $upt->track('password', $strinvalidpasswordpolicy, 'warning');
653                         }
654                         $forcechangepassword = true;
655                     }
656                     $user->password = hash_internal_user_password($user->password);
657                 }
658             } else {
659                 $user->password = 'not cached';
660                 $upt->track('password', '-', 'normal', false);
661             }
663             // create user - insert_record ignores any extra properties
664             $user->id = $DB->insert_record('user', $user);
665             $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$user->id)), s($user->username)), 'normal', false);
667             // save custom profile fields data
668             profile_save_data($user);
670             if ($forcechangepassword) {
671                 set_user_preference('auth_forcepasswordchange', 1, $user);
672             }
673             if ($user->password === 'to be generated') {
674                 set_user_preference('create_password', 1, $user);
675             }
677             $upt->track('status', $struseradded);
678             $upt->track('id', $user->id, 'normal', false);
679             $usersnew++;
681             // make sure user context exists
682             get_context_instance(CONTEXT_USER, $user->id);
684             events_trigger('user_created', $user);
686             if ($bulk == UU_BULK_NEW or $bulk == UU_BULK_ALL) {
687                 if (!in_array($user->id, $SESSION->bulk_users)) {
688                     $SESSION->bulk_users[] = $user->id;
689                 }
690             }
691         }
693         // find course enrolments, groups, roles/types and enrol periods
694         // this is again a special case, we always do this for any updated or created users
695         foreach ($filecolumns as $column) {
696             if (!preg_match('/^course\d+$/', $column)) {
697                 continue;
698             }
699             $i = substr($column, 6);
701             if (empty($user->{'course'.$i})) {
702                 continue;
703             }
704             $shortname = $user->{'course'.$i};
705             if (!array_key_exists($shortname, $ccache)) {
706                 if (!$course = $DB->get_record('course', array('shortname'=>$shortname), 'id, shortname')) {
707                     $upt->track('enrolments', get_string('unknowncourse', 'error', s($shortname)), 'error');
708                     continue;
709                 }
710                 $ccache[$shortname] = $course;
711                 $ccache[$shortname]->groups = null;
712             }
713             $courseid      = $ccache[$shortname]->id;
714             $coursecontext = get_context_instance(CONTEXT_COURSE, $courseid);
715             if (!isset($manualcache[$courseid])) {
716                 $manualcache[$courseid] = false;
717                 if ($manual) {
718                     if ($instances = enrol_get_instances($courseid, false)) {
719                         foreach ($instances as $instance) {
720                             if ($instance->enrol === 'manual') {
721                                 $manualcache[$courseid] = $instance;
722                                 break;
723                             }
724                         }
725                     }
726                 }
727             }
729             if ($manual and $manualcache[$courseid]) {
731                 // find role
732                 $rid = false;
733                 if (!empty($user->{'role'.$i})) {
734                     $addrole = $user->{'role'.$i};
735                     if (array_key_exists($addrole, $rolecache)) {
736                         $rid = $rolecache[$addrole]->id;
737                     } else {
738                         $upt->track('enrolments', get_string('unknownrole', 'error', s($addrole)), 'error');
739                         continue;
740                     }
742                 } else if (!empty($user->{'type'.$i})) {
743                     // if no role, then find "old" enrolment type
744                     $addtype = $user->{'type'.$i};
745                     if ($addtype < 1 or $addtype > 3) {
746                         $upt->track('enrolments', $strerror.': typeN = 1|2|3', 'error');
747                         continue;
748                     } else if (empty($formdata->{'uulegacy'.$addtype})) {
749                         continue;
750                     } else {
751                         $rid = $formdata->{'uulegacy'.$addtype};
752                     }
753                 } else {
754                     // no role specified, use the default from manual enrol plugin
755                     $rid = $manualcache[$courseid]->roleid;
756                 }
758                 if ($rid) {
759                     // find duration
760                     $timeend   = 0;
761                     if (!empty($user->{'enrolperiod'.$i})) {
762                         $duration = (int)$user->{'enrolperiod'.$i} * 60*60*24; // convert days to seconds
763                         if ($duration > 0) { // sanity check
764                             $timeend = $today + $duration;
765                         }
766                     }
768                     $manual->enrol_user($manualcache[$courseid], $user->id, $rid, $today, $timeend, true);
770                     $a = new stdClass();
771                     $a->course = $shortname;
772                     $a->role   = $rolecache[$rid]->name;
773                     $upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
774                 }
775             }
777             // find group to add to
778             if (!empty($user->{'group'.$i})) {
779                 // make sure user is enrolled into course before adding into groups
780                 if (!is_enrolled($coursecontext, $user->id)) {
781                     $upt->track('enrolments', get_string('addedtogroupnotenrolled', '', $user->{'group'.$i}), 'error');
782                     continue;
783                 }
784                 //build group cache
785                 if (is_null($ccache[$shortname]->groups)) {
786                     $ccache[$shortname]->groups = array();
787                     if ($groups = groups_get_all_groups($courseid)) {
788                         foreach ($groups as $gid=>$group) {
789                             $ccache[$shortname]->groups[$gid] = new stdClass();
790                             $ccache[$shortname]->groups[$gid]->id   = $gid;
791                             $ccache[$shortname]->groups[$gid]->name = $group->name;
792                             if (!is_numeric($group->name)) { // only non-numeric names are supported!!!
793                                 $ccache[$shortname]->groups[$group->name] = new stdClass();
794                                 $ccache[$shortname]->groups[$group->name]->id   = $gid;
795                                 $ccache[$shortname]->groups[$group->name]->name = $group->name;
796                             }
797                         }
798                     }
799                 }
800                 // group exists?
801                 $addgroup = $user->{'group'.$i};
802                 if (!array_key_exists($addgroup, $ccache[$shortname]->groups)) {
803                     // if group doesn't exist,  create it
804                     $newgroupdata = new stdClass();
805                     $newgroupdata->name = $addgroup;
806                     $newgroupdata->courseid = $ccache[$shortname]->id;
807                     if ($ccache[$shortname]->groups[$addgroup]->id = groups_create_group($newgroupdata)){
808                         $ccache[$shortname]->groups[$addgroup]->name = $newgroupdata->name;
809                     } else {
810                         $upt->track('enrolments', get_string('unknowngroup', 'error', s($addgroup)), 'error');
811                         continue;
812                     }
813                 }
814                 $gid   = $ccache[$shortname]->groups[$addgroup]->id;
815                 $gname = $ccache[$shortname]->groups[$addgroup]->name;
817                 try {
818                     if (groups_add_member($gid, $user->id)) {
819                         $upt->track('enrolments', get_string('addedtogroup', '', s($gname)));
820                     }  else {
821                         $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
822                     }
823                 } catch (moodle_exception $e) {
824                     $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
825                     continue;
826                 }
827             }
828         }
829     }
830     $upt->close(); // close table
832     $cir->close();
833     $cir->cleanup(true);
835     echo $OUTPUT->box_start('boxwidthnarrow boxaligncenter generalbox', 'uploadresults');
836     echo '<p>';
837     if ($optype != UU_USER_UPDATE) {
838         echo get_string('userscreated', 'admin').': '.$usersnew.'<br />';
839     }
840     if ($optype == UU_USER_UPDATE or $optype == UU_USER_ADD_UPDATE) {
841         echo get_string('usersupdated', 'admin').': '.$usersupdated.'<br />';
842     }
843     if ($allowdeletes) {
844         echo get_string('usersdeleted', 'admin').': '.$deletes.'<br />';
845         echo get_string('deleteerrors', 'admin').': '.$deleteerrors.'<br />';
846     }
847     if ($allowrenames) {
848         echo get_string('usersrenamed', 'admin').': '.$renames.'<br />';
849         echo get_string('renameerrors', 'admin').': '.$renameerrors.'<br />';
850     }
851     if ($usersskipped) {
852         echo get_string('usersskipped', 'admin').': '.$usersskipped.'<br />';
853     }
854     echo get_string('usersweakpassword', 'admin').': '.$weakpasswords.'<br />';
855     echo get_string('errors', 'admin').': '.$userserrors.'</p>';
856     echo $OUTPUT->box_end();
858     if ($bulk) {
859         echo $OUTPUT->continue_button($bulknurl);
860     } else {
861         echo $OUTPUT->continue_button($returnurl);
862     }
863     echo $OUTPUT->footer();
864     die;
867 // Print the header
868 echo $OUTPUT->header();
870 echo $OUTPUT->heading(get_string('uploaduserspreview', 'admin'));
872 // NOTE: this is JUST csv processing preview, we must not prevent import from here if there is something in the file!!
873 //       this was intended for validation of csv formatting and encoding, not filtering the data!!!!
874 //       we definitely must not process the whole file!
876 // preview table data
877 $data = array();
878 $cir->init();
879 $linenum = 1; //column header is first line
880 while ($linenum <= $previewrows and $fields = $cir->next()) {
881     $linenum++;
882     $rowcols = array();
883     $rowcols['line'] = $linenum;
884     foreach($fields as $key => $field) {
885         $rowcols[$filecolumns[$key]] = s($field);
886     }
887     $rowcols['status'] = array();
889     if (isset($rowcols['username'])) {
890         $stdusername = clean_param($rowcols['username'], PARAM_USERNAME);
891         if ($rowcols['username'] !== $stdusername) {
892             $rowcols['status'][] = get_string('invalidusernameupload');
893         }
894         if ($userid = $DB->get_field('user', 'id', array('username'=>$stdusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
895             $rowcols['username'] = html_writer::link(new moodle_url('/user/profile.php', array('id'=>$userid)), $rowcols['username']);
896         }
897     } else {
898         $rowcols['status'][] = get_string('missingusername');
899     }
901     if (!validate_email($rowcols['email'])) {
902         $rowcols['status'][] = get_string('invalidemail');
903     }
904     if ($DB->record_exists('user', array('email'=>$rowcols['email']))) {
905         $rowcols['status'][] = $stremailduplicate;
906     }
907     $rowcols['status'] = implode('<br />', $rowcols['status']);
908     $data[] = $rowcols;
910 if ($fields = $cir->next()) {
911     $data[] = array_fill(0, count($fields) + 2, '...');
913 $cir->close();
915 $table = new html_table();
916 $table->id = "uupreview";
917 $table->attributes['class'] = 'generaltable';
918 $table->tablealign = 'center';
919 $table->summary = get_string('uploaduserspreview', 'admin');
920 $table->head = array();
921 $table->data = $data;
923 $table->head[] = get_string('uucsvline', 'admin');
924 foreach ($filecolumns as $column) {
925     $table->head[] = $column;
927 $table->head[] = get_string('status');
929 echo html_writer::tag('div', html_writer::table($table), array('class'=>'flexible-wrap'));
931 /// Print the form
933 $mform2->display();
934 echo $OUTPUT->footer();
935 die;