f249f1dd9ca349ebff21ed617595521802693da9
[moodle.git] / admin / tool / uploaduser / index.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    tool
21  * @subpackage uploaduser
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('locallib.php');
33 require_once('user_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('tooluploaduser');
43 require_capability('moodle/site:uploadusers', context_system::instance());
45 $struserrenamed             = get_string('userrenamed', 'tool_uploaduser');
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', 'tool_uploaduser');
52 $strusernotupdated          = get_string('usernotupdatederror', 'error');
53 $strusernotupdatednotexists = get_string('usernotupdatednotexists', 'error');
54 $strusernotupdatedadmin     = get_string('usernotupdatedadmin', 'error');
56 $struseruptodate            = get_string('useraccountuptodate', 'tool_uploaduser');
58 $struseradded               = get_string('newuser');
59 $strusernotadded            = get_string('usernotaddedregistered', 'error');
60 $strusernotaddederror       = get_string('usernotaddederror', 'error');
62 $struserdeleted             = get_string('userdeleted', 'tool_uploaduser');
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 $stryes                     = get_string('yes');
77 $strno                      = get_string('no');
78 $stryesnooptions = array(0=>$strno, 1=>$stryes);
80 $returnurl = new moodle_url('/admin/tool/uploaduser/index.php');
81 $bulknurl  = new moodle_url('/admin/user/user_bulk.php');
83 $today = time();
84 $today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
86 // array of all valid fields for validation
87 $STD_FIELDS = array('id', 'firstname', 'lastname', 'username', 'email',
88         'city', 'country', 'lang', 'timezone', 'mailformat',
89         'maildisplay', 'maildigest', 'htmleditor', 'autosubscribe',
90         'institution', 'department', 'idnumber', 'skype',
91         'msn', 'aim', 'yahoo', 'icq', 'phone1', 'phone2', 'address',
92         'url', 'description', 'descriptionformat', 'password',
93         'auth',        // watch out when changing auth type or using external auth plugins!
94         'oldusername', // use when renaming users - this is the original username
95         'suspended',   // 1 means suspend user account, 0 means activate user account, nothing means keep as is for existing users
96         'deleted',     // 1 means delete user
97         'mnethostid',  // Can not be used for adding, updating or deleting of users - only for enrolments, groups, cohorts and suspending.
98     );
100 $PRF_FIELDS = array();
102 if ($prof_fields = $DB->get_records('user_info_field')) {
103     foreach ($prof_fields as $prof_field) {
104         $PRF_FIELDS[] = 'profile_field_'.$prof_field->shortname;
105     }
107 unset($prof_fields);
109 if (empty($iid)) {
110     $mform1 = new admin_uploaduser_form1();
112     if ($formdata = $mform1->get_data()) {
113         $iid = csv_import_reader::get_new_iid('uploaduser');
114         $cir = new csv_import_reader($iid, 'uploaduser');
116         $content = $mform1->get_file_content('userfile');
118         $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
119         unset($content);
121         if ($readcount === false) {
122             print_error('csvloaderror', '', $returnurl);
123         } else if ($readcount == 0) {
124             print_error('csvemptyfile', 'error', $returnurl);
125         }
126         // test if columns ok
127         $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
128         // continue to form2
130     } else {
131         echo $OUTPUT->header();
133         echo $OUTPUT->heading_with_help(get_string('uploadusers', 'tool_uploaduser'), 'uploadusers', 'tool_uploaduser');
135         $mform1->display();
136         echo $OUTPUT->footer();
137         die;
138     }
139 } else {
140     $cir = new csv_import_reader($iid, 'uploaduser');
141     $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
144 $mform2 = new admin_uploaduser_form2(null, array('columns'=>$filecolumns, 'data'=>array('iid'=>$iid, 'previewrows'=>$previewrows)));
146 // If a file has been uploaded, then process it
147 if ($formdata = $mform2->is_cancelled()) {
148     $cir->cleanup(true);
149     redirect($returnurl);
151 } else if ($formdata = $mform2->get_data()) {
152     // Print the header
153     echo $OUTPUT->header();
154     echo $OUTPUT->heading(get_string('uploadusersresult', 'tool_uploaduser'));
156     $optype = $formdata->uutype;
158     $updatetype        = isset($formdata->uuupdatetype) ? $formdata->uuupdatetype : 0;
159     $createpasswords   = (!empty($formdata->uupasswordnew) and $optype != UU_USER_UPDATE);
160     $updatepasswords   = (!empty($formdata->uupasswordold)  and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC and ($updatetype == UU_UPDATE_FILEOVERRIDE or $updatetype == UU_UPDATE_ALLOVERRIDE));
161     $allowrenames      = (!empty($formdata->uuallowrenames) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
162     $allowdeletes      = (!empty($formdata->uuallowdeletes) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
163     $allowsuspends     = (!empty($formdata->uuallowsuspends));
164     $bulk              = $formdata->uubulk;
165     $noemailduplicates = $formdata->uunoemailduplicates;
166     $standardusernames = $formdata->uustandardusernames;
167     $resetpasswords    = isset($formdata->uuforcepasswordchange) ? $formdata->uuforcepasswordchange : UU_PWRESET_NONE;
169     // verification moved to two places: after upload and into form2
170     $usersnew      = 0;
171     $usersupdated  = 0;
172     $usersuptodate = 0; //not printed yet anywhere
173     $userserrors   = 0;
174     $deletes       = 0;
175     $deleteerrors  = 0;
176     $renames       = 0;
177     $renameerrors  = 0;
178     $usersskipped  = 0;
179     $weakpasswords = 0;
181     // caches
182     $ccache         = array(); // course cache - do not fetch all courses here, we  will not probably use them all anyway!
183     $cohorts        = array();
184     $rolecache      = uu_allowed_roles_cache(); // roles lookup cache
185     $manualcache    = array(); // cache of used manual enrol plugins in each course
186     $supportedauths = uu_supported_auths(); // officially supported plugins that are enabled
188     // we use only manual enrol plugin here, if it is disabled no enrol is done
189     if (enrol_is_enabled('manual')) {
190         $manual = enrol_get_plugin('manual');
191     } else {
192         $manual = NULL;
193     }
195     // clear bulk selection
196     if ($bulk) {
197         $SESSION->bulk_users = array();
198     }
200     // init csv import helper
201     $cir->init();
202     $linenum = 1; //column header is first line
204     // init upload progress tracker
205     $upt = new uu_progress_tracker();
206     $upt->start(); // start table
208     while ($line = $cir->next()) {
209         $upt->flush();
210         $linenum++;
212         $upt->track('line', $linenum);
214         $user = new stdClass();
216         // add fields to user object
217         foreach ($line as $keynum => $value) {
218             if (!isset($filecolumns[$keynum])) {
219                 // this should not happen
220                 continue;
221             }
222             $key = $filecolumns[$keynum];
223             if (strpos($key, 'profile_field_') === 0) {
224                 //NOTE: bloody mega hack alert!!
225                 if (isset($USER->$key) and is_array($USER->$key)) {
226                     // this must be some hacky field that is abusing arrays to store content and format
227                     $user->$key = array();
228                     $user->$key['text']   = $value;
229                     $user->$key['format'] = FORMAT_MOODLE;
230                 } else {
231                     $user->$key = $value;
232                 }
233             } else {
234                 $user->$key = $value;
235             }
237             if (in_array($key, $upt->columns)) {
238                 // default value in progress tracking table, can be changed later
239                 $upt->track($key, s($value), 'normal');
240             }
241         }
242         if (!isset($user->username)) {
243             // prevent warnings below
244             $user->username = '';
245         }
247         if ($optype == UU_USER_ADDNEW or $optype == UU_USER_ADDINC) {
248             // user creation is a special case - the username may be constructed from templates using firstname and lastname
249             // better never try this in mixed update types
250             $error = false;
251             if (!isset($user->firstname) or $user->firstname === '') {
252                 $upt->track('status', get_string('missingfield', 'error', 'firstname'), 'error');
253                 $upt->track('firstname', $errorstr, 'error');
254                 $error = true;
255             }
256             if (!isset($user->lastname) or $user->lastname === '') {
257                 $upt->track('status', get_string('missingfield', 'error', 'lastname'), 'error');
258                 $upt->track('lastname', $errorstr, 'error');
259                 $error = true;
260             }
261             if ($error) {
262                 $userserrors++;
263                 continue;
264             }
265             // we require username too - we might use template for it though
266             if (empty($user->username) and !empty($formdata->username)) {
267                 $user->username = uu_process_template($formdata->username, $user);
268                 $upt->track('username', s($user->username));
269             }
270         }
272         // normalize username
273         $originalusername = $user->username;
274         if ($standardusernames) {
275             $user->username = clean_param($user->username, PARAM_USERNAME);
276         }
278         // make sure we really have username
279         if (empty($user->username)) {
280             $upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
281             $upt->track('username', $errorstr, 'error');
282             $userserrors++;
283             continue;
284         } else if ($user->username === 'guest') {
285             $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
286             $userserrors++;
287             continue;
288         }
290         if ($user->username !== clean_param($user->username, PARAM_USERNAME)) {
291             $upt->track('status', get_string('invalidusername', 'error', 'username'), 'error');
292             $upt->track('username', $errorstr, 'error');
293             $userserrors++;
294         }
296         if (empty($user->mnethostid)) {
297             $user->mnethostid = $CFG->mnet_localhost_id;
298         }
300         if ($existinguser = $DB->get_record('user', array('username'=>$user->username, 'mnethostid'=>$user->mnethostid))) {
301             $upt->track('id', $existinguser->id, 'normal', false);
302         }
304         if ($user->mnethostid == $CFG->mnet_localhost_id) {
305             $remoteuser = false;
307             // Find out if username incrementing required.
308             if ($existinguser and $optype == UU_USER_ADDINC) {
309                 $user->username = uu_increment_username($user->username);
310                 $existinguser = false;
311             }
313         } else {
314             if (!$existinguser or $optype == UU_USER_ADDINC) {
315                 $upt->track('status', get_string('errormnetadd', 'tool_uploaduser'), 'error');
316                 $userserrors++;
317                 continue;
318             }
320             $remoteuser = true;
322             // Make sure there are no changes of existing fields except the suspended status.
323             foreach ((array)$existinguser as $k => $v) {
324                 if ($k === 'suspended') {
325                     continue;
326                 }
327                 if (property_exists($user, $k)) {
328                     $user->$k = $v;
329                 }
330                 if (in_array($k, $upt->columns)) {
331                     if ($k === 'password' or $k === 'oldusername' or $k === 'deleted') {
332                         $upt->track($k, '', 'normal', false);
333                     } else {
334                         $upt->track($k, s($v), 'normal', false);
335                     }
336                 }
337             }
338             unset($user->oldusername);
339             unset($user->password);
340             $user->auth = $existinguser->auth;
341         }
343         // notify about nay username changes
344         if ($originalusername !== $user->username) {
345             $upt->track('username', '', 'normal', false); // clear previous
346             $upt->track('username', s($originalusername).'-->'.s($user->username), 'info');
347         } else {
348             $upt->track('username', s($user->username), 'normal', false);
349         }
351         // add default values for remaining fields
352         $formdefaults = array();
353         foreach ($STD_FIELDS as $field) {
354             if (isset($user->$field)) {
355                 continue;
356             }
357             // all validation moved to form2
358             if (isset($formdata->$field)) {
359                 // process templates
360                 $user->$field = uu_process_template($formdata->$field, $user);
361                 $formdefaults[$field] = true;
362                 if (in_array($field, $upt->columns)) {
363                     $upt->track($field, s($user->$field), 'normal');
364                 }
365             }
366         }
367         foreach ($PRF_FIELDS as $field) {
368             if (isset($user->$field)) {
369                 continue;
370             }
371             if (isset($formdata->$field)) {
372                 // process templates
373                 $user->$field = uu_process_template($formdata->$field, $user);
374                 $formdefaults[$field] = true;
375             }
376         }
378         // delete user
379         if (!empty($user->deleted)) {
380             if (!$allowdeletes or $remoteuser) {
381                 $usersskipped++;
382                 $upt->track('status', $strusernotdeletedoff, 'warning');
383                 continue;
384             }
385             if ($existinguser) {
386                 if (is_siteadmin($existinguser->id)) {
387                     $upt->track('status', $strusernotdeletedadmin, 'error');
388                     $deleteerrors++;
389                     continue;
390                 }
391                 if (delete_user($existinguser)) {
392                     $upt->track('status', $struserdeleted);
393                     $deletes++;
394                 } else {
395                     $upt->track('status', $strusernotdeletederror, 'error');
396                     $deleteerrors++;
397                 }
398             } else {
399                 $upt->track('status', $strusernotdeletedmissing, 'error');
400                 $deleteerrors++;
401             }
402             continue;
403         }
404         // we do not need the deleted flag anymore
405         unset($user->deleted);
407         // renaming requested?
408         if (!empty($user->oldusername) ) {
409             if (!$allowrenames) {
410                 $usersskipped++;
411                 $upt->track('status', $strusernotrenamedoff, 'warning');
412                 continue;
413             }
415             if ($existinguser) {
416                 $upt->track('status', $strusernotrenamedexists, 'error');
417                 $renameerrors++;
418                 continue;
419             }
421             if ($user->username === 'guest') {
422                 $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
423                 $renameerrors++;
424                 continue;
425             }
427             if ($standardusernames) {
428                 $oldusername = clean_param($user->oldusername, PARAM_USERNAME);
429             } else {
430                 $oldusername = $user->oldusername;
431             }
433             // no guessing when looking for old username, it must be exact match
434             if ($olduser = $DB->get_record('user', array('username'=>$oldusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
435                 $upt->track('id', $olduser->id, 'normal', false);
436                 if (is_siteadmin($olduser->id)) {
437                     $upt->track('status', $strusernotrenamedadmin, 'error');
438                     $renameerrors++;
439                     continue;
440                 }
441                 $DB->set_field('user', 'username', $user->username, array('id'=>$olduser->id));
442                 $upt->track('username', '', 'normal', false); // clear previous
443                 $upt->track('username', s($oldusername).'-->'.s($user->username), 'info');
444                 $upt->track('status', $struserrenamed);
445                 $renames++;
446             } else {
447                 $upt->track('status', $strusernotrenamedmissing, 'error');
448                 $renameerrors++;
449                 continue;
450             }
451             $existinguser = $olduser;
452             $existinguser->username = $user->username;
453         }
455         // can we process with update or insert?
456         $skip = false;
457         switch ($optype) {
458             case UU_USER_ADDNEW:
459                 if ($existinguser) {
460                     $usersskipped++;
461                     $upt->track('status', $strusernotadded, 'warning');
462                     $skip = true;
463                 }
464                 break;
466             case UU_USER_ADDINC:
467                 if ($existinguser) {
468                     //this should not happen!
469                     $upt->track('status', $strusernotaddederror, 'error');
470                     $userserrors++;
471                     $skip = true;
472                 }
473                 break;
475             case UU_USER_ADD_UPDATE:
476                 break;
478             case UU_USER_UPDATE:
479                 if (!$existinguser) {
480                     $usersskipped++;
481                     $upt->track('status', $strusernotupdatednotexists, 'warning');
482                     $skip = true;
483                 }
484                 break;
486             default:
487                 // unknown type
488                 $skip = true;
489         }
491         if ($skip) {
492             continue;
493         }
495         if ($existinguser) {
496             $user->id = $existinguser->id;
498             $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$existinguser->id)), s($existinguser->username)), 'normal', false);
499             $upt->track('suspended', $stryesnooptions[$existinguser->suspended] , 'normal', false);
501             if (is_siteadmin($user->id)) {
502                 $upt->track('status', $strusernotupdatedadmin, 'error');
503                 $userserrors++;
504                 continue;
505             }
507             $existinguser->timemodified = time();
508             // do NOT mess with timecreated or firstaccess here!
510             //load existing profile data
511             profile_load_data($existinguser);
513             $upt->track('auth', $existinguser->auth, 'normal', false);
515             $doupdate = false;
516             $dologout = false;
518             if ($updatetype != UU_UPDATE_NOCHANGES and !$remoteuser) {
519                 if (!empty($user->auth) and $user->auth !== $existinguser->auth) {
520                     $upt->track('auth', s($existinguser->auth).'-->'.s($user->auth), 'info', false);
521                     $existinguser->auth = $user->auth;
522                     if (!isset($supportedauths[$user->auth])) {
523                         $upt->track('auth', $struserauthunsupported, 'warning');
524                     }
525                     $doupdate = true;
526                     if ($existinguser->auth === 'nologin') {
527                         $dologout = true;
528                     }
529                 }
530                 $allcolumns = array_merge($STD_FIELDS, $PRF_FIELDS);
531                 foreach ($allcolumns as $column) {
532                     if ($column === 'username' or $column === 'password' or $column === 'auth' or $column === 'suspended') {
533                         // these can not be changed here
534                         continue;
535                     }
536                     if (!property_exists($user, $column) or !property_exists($existinguser, $column)) {
537                         // this should never happen
538                         continue;
539                     }
540                     if ($updatetype == UU_UPDATE_MISSING) {
541                         if (!is_null($existinguser->$column) and $existinguser->$column !== '') {
542                             continue;
543                         }
544                     } else if ($updatetype == UU_UPDATE_ALLOVERRIDE) {
545                         // we override everything
547                     } else if ($updatetype == UU_UPDATE_FILEOVERRIDE) {
548                         if (!empty($formdefaults[$column])) {
549                             // do not override with form defaults
550                             continue;
551                         }
552                     }
553                     if ($existinguser->$column !== $user->$column) {
554                         if ($column === 'email') {
555                             if ($DB->record_exists('user', array('email'=>$user->email))) {
556                                 if ($noemailduplicates) {
557                                     $upt->track('email', $stremailduplicate, 'error');
558                                     $upt->track('status', $strusernotupdated, 'error');
559                                     $userserrors++;
560                                     continue 2;
561                                 } else {
562                                     $upt->track('email', $stremailduplicate, 'warning');
563                                 }
564                             }
565                             if (!validate_email($user->email)) {
566                                 $upt->track('email', get_string('invalidemail'), 'warning');
567                             }
568                         }
570                         if ($column === 'lang') {
571                             if (empty($user->lang)) {
572                                 // Do not change to not-set value.
573                                 continue;
574                             } else if (clean_param($user->lang, PARAM_LANG) === '') {
575                                 $upt->track('status', get_string('cannotfindlang', 'error', $user->lang), 'warning');
576                                 continue;
577                             }
578                         }
580                         if (in_array($column, $upt->columns)) {
581                             $upt->track($column, s($existinguser->$column).'-->'.s($user->$column), 'info', false);
582                         }
583                         $existinguser->$column = $user->$column;
584                         $doupdate = true;
585                     }
586                 }
587             }
589             try {
590                 $auth = get_auth_plugin($existinguser->auth);
591             } catch (Exception $e) {
592                 $upt->track('auth', get_string('userautherror', 'error', s($existinguser->auth)), 'error');
593                 $upt->track('status', $strusernotupdated, 'error');
594                 $userserrors++;
595                 continue;
596             }
597             $isinternalauth = $auth->is_internal();
599             // deal with suspending and activating of accounts
600             if ($allowsuspends and isset($user->suspended) and $user->suspended !== '') {
601                 $user->suspended = $user->suspended ? 1 : 0;
602                 if ($existinguser->suspended != $user->suspended) {
603                     $upt->track('suspended', '', 'normal', false);
604                     $upt->track('suspended', $stryesnooptions[$existinguser->suspended].'-->'.$stryesnooptions[$user->suspended], 'info', false);
605                     $existinguser->suspended = $user->suspended;
606                     $doupdate = true;
607                     if ($existinguser->suspended) {
608                         $dologout = true;
609                     }
610                 }
611             }
613             // changing of passwords is a special case
614             // do not force password changes for external auth plugins!
615             $oldpw = $existinguser->password;
617             if ($remoteuser) {
618                 // Do not mess with passwords of remote users.
620             } else if (!$isinternalauth) {
621                 $existinguser->password = 'not cached';
622                 $upt->track('password', '-', 'normal', false);
623                 // clean up prefs
624                 unset_user_preference('create_password', $existinguser);
625                 unset_user_preference('auth_forcepasswordchange', $existinguser);
627             } else if (!empty($user->password)) {
628                 if ($updatepasswords) {
629                     $errmsg = null;
630                     $weak = !check_password_policy($user->password, $errmsg);
631                     if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
632                         if ($weak) {
633                             $weakpasswords++;
634                             $upt->track('password', $strinvalidpasswordpolicy, 'warning');
635                         }
636                         set_user_preference('auth_forcepasswordchange', 1, $existinguser);
637                     } else {
638                         unset_user_preference('auth_forcepasswordchange', $existinguser);
639                     }
640                     unset_user_preference('create_password', $existinguser); // no need to create password any more
641                     $existinguser->password = hash_internal_user_password($user->password);
642                     $upt->track('password', $user->password, 'normal', false);
643                 } else {
644                     // do not print password when not changed
645                     $upt->track('password', '', 'normal', false);
646                 }
647             }
649             if ($doupdate or $existinguser->password !== $oldpw) {
650                 // we want only users that were really updated
652                 $DB->update_record('user', $existinguser);
654                 $upt->track('status', $struserupdated);
655                 $usersupdated++;
657                 if (!$remoteuser) {
658                     // pre-process custom profile menu fields data from csv file
659                     $existinguser = uu_pre_process_custom_profile_data($existinguser);
660                     // save custom profile fields data from csv file
661                     profile_save_data($existinguser);
662                 }
664                 events_trigger('user_updated', $existinguser);
666                 if ($bulk == UU_BULK_UPDATED or $bulk == UU_BULK_ALL) {
667                     if (!in_array($user->id, $SESSION->bulk_users)) {
668                         $SESSION->bulk_users[] = $user->id;
669                     }
670                 }
672             } else {
673                 // no user information changed
674                 $upt->track('status', $struseruptodate);
675                 $usersuptodate++;
677                 if ($bulk == UU_BULK_ALL) {
678                     if (!in_array($user->id, $SESSION->bulk_users)) {
679                         $SESSION->bulk_users[] = $user->id;
680                     }
681                 }
682             }
684             if ($dologout) {
685                 session_kill_user($existinguser->id);
686             }
688         } else {
689             // save the new user to the database
690             $user->confirmed    = 1;
691             $user->timemodified = time();
692             $user->timecreated  = time();
693             $user->mnethostid   = $CFG->mnet_localhost_id; // we support ONLY local accounts here, sorry
695             if (!isset($user->suspended) or $user->suspended === '') {
696                 $user->suspended = 0;
697             } else {
698                 $user->suspended = $user->suspended ? 1 : 0;
699             }
700             $upt->track('suspended', $stryesnooptions[$user->suspended], 'normal', false);
702             if (empty($user->auth)) {
703                 $user->auth = 'manual';
704             }
705             $upt->track('auth', $user->auth, 'normal', false);
707             // do not insert record if new auth plugin does not exist!
708             try {
709                 $auth = get_auth_plugin($user->auth);
710             } catch (Exception $e) {
711                 $upt->track('auth', get_string('userautherror', 'error', s($user->auth)), 'error');
712                 $upt->track('status', $strusernotaddederror, 'error');
713                 $userserrors++;
714                 continue;
715             }
716             if (!isset($supportedauths[$user->auth])) {
717                 $upt->track('auth', $struserauthunsupported, 'warning');
718             }
720             $isinternalauth = $auth->is_internal();
722             if (empty($user->email)) {
723                 $upt->track('email', get_string('invalidemail'), 'error');
724                 $upt->track('status', $strusernotaddederror, 'error');
725                 $userserrors++;
726                 continue;
728             } else if ($DB->record_exists('user', array('email'=>$user->email))) {
729                 if ($noemailduplicates) {
730                     $upt->track('email', $stremailduplicate, 'error');
731                     $upt->track('status', $strusernotaddederror, 'error');
732                     $userserrors++;
733                     continue;
734                 } else {
735                     $upt->track('email', $stremailduplicate, 'warning');
736                 }
737             }
738             if (!validate_email($user->email)) {
739                 $upt->track('email', get_string('invalidemail'), 'warning');
740             }
742             if (empty($user->lang)) {
743                 $user->lang = '';
744             } else if (clean_param($user->lang, PARAM_LANG) === '') {
745                 $upt->track('status', get_string('cannotfindlang', 'error', $user->lang), 'warning');
746                 $user->lang = '';
747             }
749             $forcechangepassword = false;
751             if ($isinternalauth) {
752                 if (empty($user->password)) {
753                     if ($createpasswords) {
754                         $user->password = 'to be generated';
755                         $upt->track('password', '', 'normal', false);
756                         $upt->track('password', get_string('uupasswordcron', 'tool_uploaduser'), 'warning', false);
757                     } else {
758                         $upt->track('password', '', 'normal', false);
759                         $upt->track('password', get_string('missingfield', 'error', 'password'), 'error');
760                         $upt->track('status', $strusernotaddederror, 'error');
761                         $userserrors++;
762                         continue;
763                     }
764                 } else {
765                     $errmsg = null;
766                     $weak = !check_password_policy($user->password, $errmsg);
767                     if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
768                         if ($weak) {
769                             $weakpasswords++;
770                             $upt->track('password', $strinvalidpasswordpolicy, 'warning');
771                         }
772                         $forcechangepassword = true;
773                     }
774                     $user->password = hash_internal_user_password($user->password);
775                 }
776             } else {
777                 $user->password = 'not cached';
778                 $upt->track('password', '-', 'normal', false);
779             }
781             // create user - insert_record ignores any extra properties
782             $user->id = $DB->insert_record('user', $user);
783             $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$user->id)), s($user->username)), 'normal', false);
785             // pre-process custom profile menu fields data from csv file
786             $user = uu_pre_process_custom_profile_data($user);
787             // save custom profile fields data
788             profile_save_data($user);
790             if ($forcechangepassword) {
791                 set_user_preference('auth_forcepasswordchange', 1, $user);
792             }
793             if ($user->password === 'to be generated') {
794                 set_user_preference('create_password', 1, $user);
795             }
797             $upt->track('status', $struseradded);
798             $upt->track('id', $user->id, 'normal', false);
799             $usersnew++;
801             // make sure user context exists
802             context_user::instance($user->id);
804             events_trigger('user_created', $user);
806             if ($bulk == UU_BULK_NEW or $bulk == UU_BULK_ALL) {
807                 if (!in_array($user->id, $SESSION->bulk_users)) {
808                     $SESSION->bulk_users[] = $user->id;
809                 }
810             }
811         }
814         // add to cohort first, it might trigger enrolments indirectly - do NOT create cohorts here!
815         foreach ($filecolumns as $column) {
816             if (!preg_match('/^cohort\d+$/', $column)) {
817                 continue;
818             }
820             if (!empty($user->$column)) {
821                 $addcohort = $user->$column;
822                 if (!isset($cohorts[$addcohort])) {
823                     if (is_number($addcohort)) {
824                         // only non-numeric idnumbers!
825                         $cohort = $DB->get_record('cohort', array('id'=>$addcohort));
826                     } else {
827                         $cohort = $DB->get_record('cohort', array('idnumber'=>$addcohort));
828                     }
830                     if (empty($cohort)) {
831                         $cohorts[$addcohort] = get_string('unknowncohort', 'core_cohort', s($addcohort));
832                     } else if (!empty($cohort->component)) {
833                         // cohorts synchronised with external sources must not be modified!
834                         $cohorts[$addcohort] = get_string('external', 'core_cohort');
835                     } else {
836                         $cohorts[$addcohort] = $cohort;
837                     }
838                 }
840                 if (is_object($cohorts[$addcohort])) {
841                     $cohort = $cohorts[$addcohort];
842                     if (!$DB->record_exists('cohort_members', array('cohortid'=>$cohort->id, 'userid'=>$user->id))) {
843                         cohort_add_member($cohort->id, $user->id);
844                         // we might add special column later, for now let's abuse enrolments
845                         $upt->track('enrolments', get_string('useradded', 'core_cohort', s($cohort->name)));
846                     }
847                 } else {
848                     // error message
849                     $upt->track('enrolments', $cohorts[$addcohort], 'error');
850                 }
851             }
852         }
855         // find course enrolments, groups, roles/types and enrol periods
856         // this is again a special case, we always do this for any updated or created users
857         foreach ($filecolumns as $column) {
858             if (!preg_match('/^course\d+$/', $column)) {
859                 continue;
860             }
861             $i = substr($column, 6);
863             if (empty($user->{'course'.$i})) {
864                 continue;
865             }
866             $shortname = $user->{'course'.$i};
867             if (!array_key_exists($shortname, $ccache)) {
868                 if (!$course = $DB->get_record('course', array('shortname'=>$shortname), 'id, shortname')) {
869                     $upt->track('enrolments', get_string('unknowncourse', 'error', s($shortname)), 'error');
870                     continue;
871                 }
872                 $ccache[$shortname] = $course;
873                 $ccache[$shortname]->groups = null;
874             }
875             $courseid      = $ccache[$shortname]->id;
876             $coursecontext = context_course::instance($courseid);
877             if (!isset($manualcache[$courseid])) {
878                 $manualcache[$courseid] = false;
879                 if ($manual) {
880                     if ($instances = enrol_get_instances($courseid, false)) {
881                         foreach ($instances as $instance) {
882                             if ($instance->enrol === 'manual') {
883                                 $manualcache[$courseid] = $instance;
884                                 break;
885                             }
886                         }
887                     }
888                 }
889             }
891             if ($manual and $manualcache[$courseid]) {
893                 // find role
894                 $rid = false;
895                 if (!empty($user->{'role'.$i})) {
896                     $addrole = $user->{'role'.$i};
897                     if (array_key_exists($addrole, $rolecache)) {
898                         $rid = $rolecache[$addrole]->id;
899                     } else {
900                         $upt->track('enrolments', get_string('unknownrole', 'error', s($addrole)), 'error');
901                         continue;
902                     }
904                 } else if (!empty($user->{'type'.$i})) {
905                     // if no role, then find "old" enrolment type
906                     $addtype = $user->{'type'.$i};
907                     if ($addtype < 1 or $addtype > 3) {
908                         $upt->track('enrolments', $strerror.': typeN = 1|2|3', 'error');
909                         continue;
910                     } else if (empty($formdata->{'uulegacy'.$addtype})) {
911                         continue;
912                     } else {
913                         $rid = $formdata->{'uulegacy'.$addtype};
914                     }
915                 } else {
916                     // no role specified, use the default from manual enrol plugin
917                     $rid = $manualcache[$courseid]->roleid;
918                 }
920                 if ($rid) {
921                     // find duration
922                     $timeend   = 0;
923                     if (!empty($user->{'enrolperiod'.$i})) {
924                         $duration = (int)$user->{'enrolperiod'.$i} * 60*60*24; // convert days to seconds
925                         if ($duration > 0) { // sanity check
926                             $timeend = $today + $duration;
927                         }
928                     } else if ($manualcache[$courseid]->enrolperiod > 0) {
929                         $timeend = $today + $manualcache[$courseid]->enrolperiod;
930                     }
932                     $manual->enrol_user($manualcache[$courseid], $user->id, $rid, $today, $timeend);
934                     $a = new stdClass();
935                     $a->course = $shortname;
936                     $a->role   = $rolecache[$rid]->name;
937                     $upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
938                 }
939             }
941             // find group to add to
942             if (!empty($user->{'group'.$i})) {
943                 // make sure user is enrolled into course before adding into groups
944                 if (!is_enrolled($coursecontext, $user->id)) {
945                     $upt->track('enrolments', get_string('addedtogroupnotenrolled', '', $user->{'group'.$i}), 'error');
946                     continue;
947                 }
948                 //build group cache
949                 if (is_null($ccache[$shortname]->groups)) {
950                     $ccache[$shortname]->groups = array();
951                     if ($groups = groups_get_all_groups($courseid)) {
952                         foreach ($groups as $gid=>$group) {
953                             $ccache[$shortname]->groups[$gid] = new stdClass();
954                             $ccache[$shortname]->groups[$gid]->id   = $gid;
955                             $ccache[$shortname]->groups[$gid]->name = $group->name;
956                             if (!is_numeric($group->name)) { // only non-numeric names are supported!!!
957                                 $ccache[$shortname]->groups[$group->name] = new stdClass();
958                                 $ccache[$shortname]->groups[$group->name]->id   = $gid;
959                                 $ccache[$shortname]->groups[$group->name]->name = $group->name;
960                             }
961                         }
962                     }
963                 }
964                 // group exists?
965                 $addgroup = $user->{'group'.$i};
966                 if (!array_key_exists($addgroup, $ccache[$shortname]->groups)) {
967                     // if group doesn't exist,  create it
968                     $newgroupdata = new stdClass();
969                     $newgroupdata->name = $addgroup;
970                     $newgroupdata->courseid = $ccache[$shortname]->id;
971                     $newgroupdata->description = '';
972                     $gid = groups_create_group($newgroupdata);
973                     if ($gid){
974                         $ccache[$shortname]->groups[$addgroup] = new stdClass();
975                         $ccache[$shortname]->groups[$addgroup]->id   = $gid;
976                         $ccache[$shortname]->groups[$addgroup]->name = $newgroupdata->name;
977                     } else {
978                         $upt->track('enrolments', get_string('unknowngroup', 'error', s($addgroup)), 'error');
979                         continue;
980                     }
981                 }
982                 $gid   = $ccache[$shortname]->groups[$addgroup]->id;
983                 $gname = $ccache[$shortname]->groups[$addgroup]->name;
985                 try {
986                     if (groups_add_member($gid, $user->id)) {
987                         $upt->track('enrolments', get_string('addedtogroup', '', s($gname)));
988                     }  else {
989                         $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
990                     }
991                 } catch (moodle_exception $e) {
992                     $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
993                     continue;
994                 }
995             }
996         }
997     }
998     $upt->close(); // close table
1000     $cir->close();
1001     $cir->cleanup(true);
1003     echo $OUTPUT->box_start('boxwidthnarrow boxaligncenter generalbox', 'uploadresults');
1004     echo '<p>';
1005     if ($optype != UU_USER_UPDATE) {
1006         echo get_string('userscreated', 'tool_uploaduser').': '.$usersnew.'<br />';
1007     }
1008     if ($optype == UU_USER_UPDATE or $optype == UU_USER_ADD_UPDATE) {
1009         echo get_string('usersupdated', 'tool_uploaduser').': '.$usersupdated.'<br />';
1010     }
1011     if ($allowdeletes) {
1012         echo get_string('usersdeleted', 'tool_uploaduser').': '.$deletes.'<br />';
1013         echo get_string('deleteerrors', 'tool_uploaduser').': '.$deleteerrors.'<br />';
1014     }
1015     if ($allowrenames) {
1016         echo get_string('usersrenamed', 'tool_uploaduser').': '.$renames.'<br />';
1017         echo get_string('renameerrors', 'tool_uploaduser').': '.$renameerrors.'<br />';
1018     }
1019     if ($usersskipped) {
1020         echo get_string('usersskipped', 'tool_uploaduser').': '.$usersskipped.'<br />';
1021     }
1022     echo get_string('usersweakpassword', 'tool_uploaduser').': '.$weakpasswords.'<br />';
1023     echo get_string('errors', 'tool_uploaduser').': '.$userserrors.'</p>';
1024     echo $OUTPUT->box_end();
1026     if ($bulk) {
1027         echo $OUTPUT->continue_button($bulknurl);
1028     } else {
1029         echo $OUTPUT->continue_button($returnurl);
1030     }
1031     echo $OUTPUT->footer();
1032     die;
1035 // Print the header
1036 echo $OUTPUT->header();
1038 echo $OUTPUT->heading(get_string('uploaduserspreview', 'tool_uploaduser'));
1040 // NOTE: this is JUST csv processing preview, we must not prevent import from here if there is something in the file!!
1041 //       this was intended for validation of csv formatting and encoding, not filtering the data!!!!
1042 //       we definitely must not process the whole file!
1044 // preview table data
1045 $data = array();
1046 $cir->init();
1047 $linenum = 1; //column header is first line
1048 $noerror = true; // Keep status of any error.
1049 while ($linenum <= $previewrows and $fields = $cir->next()) {
1050     $linenum++;
1051     $rowcols = array();
1052     $rowcols['line'] = $linenum;
1053     foreach($fields as $key => $field) {
1054         $rowcols[$filecolumns[$key]] = s($field);
1055     }
1056     $rowcols['status'] = array();
1058     if (isset($rowcols['username'])) {
1059         $stdusername = clean_param($rowcols['username'], PARAM_USERNAME);
1060         if ($rowcols['username'] !== $stdusername) {
1061             $rowcols['status'][] = get_string('invalidusernameupload');
1062         }
1063         if ($userid = $DB->get_field('user', 'id', array('username'=>$stdusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
1064             $rowcols['username'] = html_writer::link(new moodle_url('/user/profile.php', array('id'=>$userid)), $rowcols['username']);
1065         }
1066     } else {
1067         $rowcols['status'][] = get_string('missingusername');
1068     }
1070     if (isset($rowcols['email'])) {
1071         if (!validate_email($rowcols['email'])) {
1072             $rowcols['status'][] = get_string('invalidemail');
1073         }
1074         if ($DB->record_exists('user', array('email'=>$rowcols['email']))) {
1075             $rowcols['status'][] = $stremailduplicate;
1076         }
1077     }
1079     if (isset($rowcols['city'])) {
1080         $rowcols['city'] = trim($rowcols['city']);
1081         if (empty($rowcols['city'])) {
1082             $rowcols['status'][] = get_string('fieldrequired', 'error', 'city');
1083         }
1084     }
1085     // Check if rowcols have custom profile field with correct data and update error state.
1086     $noerror = uu_check_custom_profile_data($rowcols) && $noerror;
1087     $rowcols['status'] = implode('<br />', $rowcols['status']);
1088     $data[] = $rowcols;
1090 if ($fields = $cir->next()) {
1091     $data[] = array_fill(0, count($fields) + 2, '...');
1093 $cir->close();
1095 $table = new html_table();
1096 $table->id = "uupreview";
1097 $table->attributes['class'] = 'generaltable';
1098 $table->tablealign = 'center';
1099 $table->summary = get_string('uploaduserspreview', 'tool_uploaduser');
1100 $table->head = array();
1101 $table->data = $data;
1103 $table->head[] = get_string('uucsvline', 'tool_uploaduser');
1104 foreach ($filecolumns as $column) {
1105     $table->head[] = $column;
1107 $table->head[] = get_string('status');
1109 echo html_writer::tag('div', html_writer::table($table), array('class'=>'flexible-wrap'));
1111 // Print the form if valid values are available
1112 if ($noerror) {
1113     $mform2->display();
1115 echo $OUTPUT->footer();
1116 die;