source: moodle/trunk/fuentes/admin/tool/uploaduser/index.php @ 1331

Last change on this file since 1331 was 1331, checked in by jrpelegrina, 3 years ago

Updated to moodle 3.0.3

File size: 51.7 KB
Line 
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/>.
16
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 */
25
26require('../../../config.php');
27require_once($CFG->libdir.'/adminlib.php');
28require_once($CFG->libdir.'/csvlib.class.php');
29require_once($CFG->dirroot.'/user/profile/lib.php');
30require_once($CFG->dirroot.'/user/lib.php');
31require_once($CFG->dirroot.'/group/lib.php');
32require_once($CFG->dirroot.'/cohort/lib.php');
33require_once('locallib.php');
34require_once('user_form.php');
35
36$iid         = optional_param('iid', '', PARAM_INT);
37$previewrows = optional_param('previewrows', 10, PARAM_INT);
38
39core_php_time_limit::raise(60*60); // 1 hour should be enough
40raise_memory_limit(MEMORY_HUGE);
41
42require_login();
43admin_externalpage_setup('tooluploaduser');
44require_capability('moodle/site:uploadusers', context_system::instance());
45
46$struserrenamed             = get_string('userrenamed', 'tool_uploaduser');
47$strusernotrenamedexists    = get_string('usernotrenamedexists', 'error');
48$strusernotrenamedmissing   = get_string('usernotrenamedmissing', 'error');
49$strusernotrenamedoff       = get_string('usernotrenamedoff', 'error');
50$strusernotrenamedadmin     = get_string('usernotrenamedadmin', 'error');
51
52$struserupdated             = get_string('useraccountupdated', 'tool_uploaduser');
53$strusernotupdated          = get_string('usernotupdatederror', 'error');
54$strusernotupdatednotexists = get_string('usernotupdatednotexists', 'error');
55$strusernotupdatedadmin     = get_string('usernotupdatedadmin', 'error');
56
57$struseruptodate            = get_string('useraccountuptodate', 'tool_uploaduser');
58
59$struseradded               = get_string('newuser');
60$strusernotadded            = get_string('usernotaddedregistered', 'error');
61$strusernotaddederror       = get_string('usernotaddederror', 'error');
62
63$struserdeleted             = get_string('userdeleted', 'tool_uploaduser');
64$strusernotdeletederror     = get_string('usernotdeletederror', 'error');
65$strusernotdeletedmissing   = get_string('usernotdeletedmissing', 'error');
66$strusernotdeletedoff       = get_string('usernotdeletedoff', 'error');
67$strusernotdeletedadmin     = get_string('usernotdeletedadmin', 'error');
68
69$strcannotassignrole        = get_string('cannotassignrole', 'error');
70
71$struserauthunsupported     = get_string('userauthunsupported', 'error');
72$stremailduplicate          = get_string('useremailduplicate', 'error');
73
74$strinvalidpasswordpolicy   = get_string('invalidpasswordpolicy', 'error');
75$errorstr                   = get_string('error');
76
77$stryes                     = get_string('yes');
78$strno                      = get_string('no');
79$stryesnooptions = array(0=>$strno, 1=>$stryes);
80
81$returnurl = new moodle_url('/admin/tool/uploaduser/index.php');
82$bulknurl  = new moodle_url('/admin/user/user_bulk.php');
83
84$today = time();
85$today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
86
87// array of all valid fields for validation
88$STD_FIELDS = array('id', 'username', 'email',
89        'city', 'country', 'lang', 'timezone', 'mailformat',
90        'maildisplay', 'maildigest', 'htmleditor', 'autosubscribe',
91        'institution', 'department', 'idnumber', 'skype',
92        'msn', 'aim', 'yahoo', 'icq', 'phone1', 'phone2', 'address',
93        'url', 'description', 'descriptionformat', 'password',
94        'auth',        // watch out when changing auth type or using external auth plugins!
95        'oldusername', // use when renaming users - this is the original username
96        'suspended',   // 1 means suspend user account, 0 means activate user account, nothing means keep as is for existing users
97        'deleted',     // 1 means delete user
98        'mnethostid',  // Can not be used for adding, updating or deleting of users - only for enrolments, groups, cohorts and suspending.
99    );
100// Include all name fields.
101$STD_FIELDS = array_merge($STD_FIELDS, get_all_user_name_fields());
102
103$PRF_FIELDS = array();
104
105if ($proffields = $DB->get_records('user_info_field')) {
106    foreach ($proffields as $key => $proffield) {
107        $profilefieldname = 'profile_field_'.$proffield->shortname;
108        $PRF_FIELDS[] = $profilefieldname;
109        // Re-index $proffields with key as shortname. This will be
110        // used while checking if profile data is key and needs to be converted (eg. menu profile field)
111        $proffields[$profilefieldname] = $proffield;
112        unset($proffields[$key]);
113    }
114}
115
116if (empty($iid)) {
117    $mform1 = new admin_uploaduser_form1();
118
119    if ($formdata = $mform1->get_data()) {
120        $iid = csv_import_reader::get_new_iid('uploaduser');
121        $cir = new csv_import_reader($iid, 'uploaduser');
122
123        $content = $mform1->get_file_content('userfile');
124
125        $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
126        $csvloaderror = $cir->get_error();
127        unset($content);
128
129        if (!is_null($csvloaderror)) {
130            print_error('csvloaderror', '', $returnurl, $csvloaderror);
131        }
132        // test if columns ok
133        $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
134        // continue to form2
135
136    } else {
137        echo $OUTPUT->header();
138
139        echo $OUTPUT->heading_with_help(get_string('uploadusers', 'tool_uploaduser'), 'uploadusers', 'tool_uploaduser');
140
141        $mform1->display();
142        echo $OUTPUT->footer();
143        die;
144    }
145} else {
146    $cir = new csv_import_reader($iid, 'uploaduser');
147    $filecolumns = uu_validate_user_upload_columns($cir, $STD_FIELDS, $PRF_FIELDS, $returnurl);
148}
149
150$mform2 = new admin_uploaduser_form2(null, array('columns'=>$filecolumns, 'data'=>array('iid'=>$iid, 'previewrows'=>$previewrows)));
151
152// If a file has been uploaded, then process it
153if ($formdata = $mform2->is_cancelled()) {
154    $cir->cleanup(true);
155    redirect($returnurl);
156
157} else if ($formdata = $mform2->get_data()) {
158    // Print the header
159    echo $OUTPUT->header();
160    echo $OUTPUT->heading(get_string('uploadusersresult', 'tool_uploaduser'));
161
162    $optype = $formdata->uutype;
163
164    $updatetype        = isset($formdata->uuupdatetype) ? $formdata->uuupdatetype : 0;
165    $createpasswords   = (!empty($formdata->uupasswordnew) and $optype != UU_USER_UPDATE);
166    $updatepasswords   = (!empty($formdata->uupasswordold)  and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC and ($updatetype == UU_UPDATE_FILEOVERRIDE or $updatetype == UU_UPDATE_ALLOVERRIDE));
167    $allowrenames      = (!empty($formdata->uuallowrenames) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
168    $allowdeletes      = (!empty($formdata->uuallowdeletes) and $optype != UU_USER_ADDNEW and $optype != UU_USER_ADDINC);
169    $allowsuspends     = (!empty($formdata->uuallowsuspends));
170    $bulk              = $formdata->uubulk;
171    $noemailduplicates = empty($CFG->allowaccountssameemail) ? 1 : $formdata->uunoemailduplicates;
172    $standardusernames = $formdata->uustandardusernames;
173    $resetpasswords    = isset($formdata->uuforcepasswordchange) ? $formdata->uuforcepasswordchange : UU_PWRESET_NONE;
174
175    // verification moved to two places: after upload and into form2
176    $usersnew      = 0;
177    $usersupdated  = 0;
178    $usersuptodate = 0; //not printed yet anywhere
179    $userserrors   = 0;
180    $deletes       = 0;
181    $deleteerrors  = 0;
182    $renames       = 0;
183    $renameerrors  = 0;
184    $usersskipped  = 0;
185    $weakpasswords = 0;
186
187    // caches
188    $ccache         = array(); // course cache - do not fetch all courses here, we  will not probably use them all anyway!
189    $cohorts        = array();
190    $rolecache      = uu_allowed_roles_cache(); // Course roles lookup cache.
191    $sysrolecache   = uu_allowed_sysroles_cache(); // System roles lookup cache.
192    $manualcache    = array(); // cache of used manual enrol plugins in each course
193    $supportedauths = uu_supported_auths(); // officially supported plugins that are enabled
194
195    // we use only manual enrol plugin here, if it is disabled no enrol is done
196    if (enrol_is_enabled('manual')) {
197        $manual = enrol_get_plugin('manual');
198    } else {
199        $manual = NULL;
200    }
201
202    // clear bulk selection
203    if ($bulk) {
204        $SESSION->bulk_users = array();
205    }
206
207    // init csv import helper
208    $cir->init();
209    $linenum = 1; //column header is first line
210
211    // init upload progress tracker
212    $upt = new uu_progress_tracker();
213    $upt->start(); // start table
214
215    while ($line = $cir->next()) {
216        $upt->flush();
217        $linenum++;
218
219        $upt->track('line', $linenum);
220
221        $user = new stdClass();
222
223        // add fields to user object
224        foreach ($line as $keynum => $value) {
225            if (!isset($filecolumns[$keynum])) {
226                // this should not happen
227                continue;
228            }
229            $key = $filecolumns[$keynum];
230            if (strpos($key, 'profile_field_') === 0) {
231                //NOTE: bloody mega hack alert!!
232                if (isset($USER->$key) and is_array($USER->$key)) {
233                    // this must be some hacky field that is abusing arrays to store content and format
234                    $user->$key = array();
235                    $user->{$key['text']}   = $value;
236                    $user->{$key['format']} = FORMAT_MOODLE;
237                } else {
238                    $user->$key = trim($value);
239                }
240            } else {
241                $user->$key = trim($value);
242            }
243
244            if (in_array($key, $upt->columns)) {
245                // default value in progress tracking table, can be changed later
246                $upt->track($key, s($value), 'normal');
247            }
248        }
249        if (!isset($user->username)) {
250            // prevent warnings below
251            $user->username = '';
252        }
253
254        if ($optype == UU_USER_ADDNEW or $optype == UU_USER_ADDINC) {
255            // user creation is a special case - the username may be constructed from templates using firstname and lastname
256            // better never try this in mixed update types
257            $error = false;
258            if (!isset($user->firstname) or $user->firstname === '') {
259                $upt->track('status', get_string('missingfield', 'error', 'firstname'), 'error');
260                $upt->track('firstname', $errorstr, 'error');
261                $error = true;
262            }
263            if (!isset($user->lastname) or $user->lastname === '') {
264                $upt->track('status', get_string('missingfield', 'error', 'lastname'), 'error');
265                $upt->track('lastname', $errorstr, 'error');
266                $error = true;
267            }
268            if ($error) {
269                $userserrors++;
270                continue;
271            }
272            // we require username too - we might use template for it though
273            if (empty($user->username) and !empty($formdata->username)) {
274                $user->username = uu_process_template($formdata->username, $user);
275                $upt->track('username', s($user->username));
276            }
277        }
278
279        // normalize username
280        $originalusername = $user->username;
281        if ($standardusernames) {
282            $user->username = clean_param($user->username, PARAM_USERNAME);
283        }
284
285        // make sure we really have username
286        if (empty($user->username)) {
287            $upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
288            $upt->track('username', $errorstr, 'error');
289            $userserrors++;
290            continue;
291        } else if ($user->username === 'guest') {
292            $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
293            $userserrors++;
294            continue;
295        }
296
297        if ($user->username !== clean_param($user->username, PARAM_USERNAME)) {
298            $upt->track('status', get_string('invalidusername', 'error', 'username'), 'error');
299            $upt->track('username', $errorstr, 'error');
300            $userserrors++;
301        }
302
303        if (empty($user->mnethostid)) {
304            $user->mnethostid = $CFG->mnet_localhost_id;
305        }
306
307        if ($existinguser = $DB->get_record('user', array('username'=>$user->username, 'mnethostid'=>$user->mnethostid))) {
308            $upt->track('id', $existinguser->id, 'normal', false);
309        }
310
311        if ($user->mnethostid == $CFG->mnet_localhost_id) {
312            $remoteuser = false;
313
314            // Find out if username incrementing required.
315            if ($existinguser and $optype == UU_USER_ADDINC) {
316                $user->username = uu_increment_username($user->username);
317                $existinguser = false;
318            }
319
320        } else {
321            if (!$existinguser or $optype == UU_USER_ADDINC) {
322                $upt->track('status', get_string('errormnetadd', 'tool_uploaduser'), 'error');
323                $userserrors++;
324                continue;
325            }
326
327            $remoteuser = true;
328
329            // Make sure there are no changes of existing fields except the suspended status.
330            foreach ((array)$existinguser as $k => $v) {
331                if ($k === 'suspended') {
332                    continue;
333                }
334                if (property_exists($user, $k)) {
335                    $user->$k = $v;
336                }
337                if (in_array($k, $upt->columns)) {
338                    if ($k === 'password' or $k === 'oldusername' or $k === 'deleted') {
339                        $upt->track($k, '', 'normal', false);
340                    } else {
341                        $upt->track($k, s($v), 'normal', false);
342                    }
343                }
344            }
345            unset($user->oldusername);
346            unset($user->password);
347            $user->auth = $existinguser->auth;
348        }
349
350        // notify about nay username changes
351        if ($originalusername !== $user->username) {
352            $upt->track('username', '', 'normal', false); // clear previous
353            $upt->track('username', s($originalusername).'-->'.s($user->username), 'info');
354        } else {
355            $upt->track('username', s($user->username), 'normal', false);
356        }
357
358        // add default values for remaining fields
359        $formdefaults = array();
360        foreach ($STD_FIELDS as $field) {
361            if (isset($user->$field)) {
362                continue;
363            }
364            // all validation moved to form2
365            if (isset($formdata->$field)) {
366                // process templates
367                $user->$field = uu_process_template($formdata->$field, $user);
368                $formdefaults[$field] = true;
369                if (in_array($field, $upt->columns)) {
370                    $upt->track($field, s($user->$field), 'normal');
371                }
372            }
373        }
374        foreach ($PRF_FIELDS as $field) {
375            if (isset($user->$field)) {
376                continue;
377            }
378            if (isset($formdata->$field)) {
379                // process templates
380                $user->$field = uu_process_template($formdata->$field, $user);
381
382                // Form contains key and later code expects value.
383                // Convert key to value for required profile fields.
384                require_once($CFG->dirroot.'/user/profile/field/'.$proffields[$field]->datatype.'/field.class.php');
385                $profilefieldclass = 'profile_field_'.$proffields[$field]->datatype;
386                $profilefield = new $profilefieldclass($proffields[$field]->id);
387                if (method_exists($profilefield, 'convert_external_data')) {
388                    $user->$field = $profilefield->edit_save_data_preprocess($user->$field, null);
389                }
390
391                $formdefaults[$field] = true;
392            }
393        }
394
395        // delete user
396        if (!empty($user->deleted)) {
397            if (!$allowdeletes or $remoteuser) {
398                $usersskipped++;
399                $upt->track('status', $strusernotdeletedoff, 'warning');
400                continue;
401            }
402            if ($existinguser) {
403                if (is_siteadmin($existinguser->id)) {
404                    $upt->track('status', $strusernotdeletedadmin, 'error');
405                    $deleteerrors++;
406                    continue;
407                }
408                if (delete_user($existinguser)) {
409                    $upt->track('status', $struserdeleted);
410                    $deletes++;
411                } else {
412                    $upt->track('status', $strusernotdeletederror, 'error');
413                    $deleteerrors++;
414                }
415            } else {
416                $upt->track('status', $strusernotdeletedmissing, 'error');
417                $deleteerrors++;
418            }
419            continue;
420        }
421        // we do not need the deleted flag anymore
422        unset($user->deleted);
423
424        // renaming requested?
425        if (!empty($user->oldusername) ) {
426            if (!$allowrenames) {
427                $usersskipped++;
428                $upt->track('status', $strusernotrenamedoff, 'warning');
429                continue;
430            }
431
432            if ($existinguser) {
433                $upt->track('status', $strusernotrenamedexists, 'error');
434                $renameerrors++;
435                continue;
436            }
437
438            if ($user->username === 'guest') {
439                $upt->track('status', get_string('guestnoeditprofileother', 'error'), 'error');
440                $renameerrors++;
441                continue;
442            }
443
444            if ($standardusernames) {
445                $oldusername = clean_param($user->oldusername, PARAM_USERNAME);
446            } else {
447                $oldusername = $user->oldusername;
448            }
449
450            // no guessing when looking for old username, it must be exact match
451            if ($olduser = $DB->get_record('user', array('username'=>$oldusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
452                $upt->track('id', $olduser->id, 'normal', false);
453                if (is_siteadmin($olduser->id)) {
454                    $upt->track('status', $strusernotrenamedadmin, 'error');
455                    $renameerrors++;
456                    continue;
457                }
458                $DB->set_field('user', 'username', $user->username, array('id'=>$olduser->id));
459                $upt->track('username', '', 'normal', false); // clear previous
460                $upt->track('username', s($oldusername).'-->'.s($user->username), 'info');
461                $upt->track('status', $struserrenamed);
462                $renames++;
463            } else {
464                $upt->track('status', $strusernotrenamedmissing, 'error');
465                $renameerrors++;
466                continue;
467            }
468            $existinguser = $olduser;
469            $existinguser->username = $user->username;
470        }
471
472        // can we process with update or insert?
473        $skip = false;
474        switch ($optype) {
475            case UU_USER_ADDNEW:
476                if ($existinguser) {
477                    $usersskipped++;
478                    $upt->track('status', $strusernotadded, 'warning');
479                    $skip = true;
480                }
481                break;
482
483            case UU_USER_ADDINC:
484                if ($existinguser) {
485                    //this should not happen!
486                    $upt->track('status', $strusernotaddederror, 'error');
487                    $userserrors++;
488                    $skip = true;
489                }
490                break;
491
492            case UU_USER_ADD_UPDATE:
493                break;
494
495            case UU_USER_UPDATE:
496                if (!$existinguser) {
497                    $usersskipped++;
498                    $upt->track('status', $strusernotupdatednotexists, 'warning');
499                    $skip = true;
500                }
501                break;
502
503            default:
504                // unknown type
505                $skip = true;
506        }
507
508        if ($skip) {
509            continue;
510        }
511
512        if ($existinguser) {
513            $user->id = $existinguser->id;
514
515            $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$existinguser->id)), s($existinguser->username)), 'normal', false);
516            $upt->track('suspended', $stryesnooptions[$existinguser->suspended] , 'normal', false);
517            $upt->track('auth', $existinguser->auth, 'normal', false);
518
519            if (is_siteadmin($user->id)) {
520                $upt->track('status', $strusernotupdatedadmin, 'error');
521                $userserrors++;
522                continue;
523            }
524
525            $existinguser->timemodified = time();
526            // do NOT mess with timecreated or firstaccess here!
527
528            //load existing profile data
529            profile_load_data($existinguser);
530
531            $doupdate = false;
532            $dologout = false;
533
534            if ($updatetype != UU_UPDATE_NOCHANGES and !$remoteuser) {
535                if (!empty($user->auth) and $user->auth !== $existinguser->auth) {
536                    $upt->track('auth', s($existinguser->auth).'-->'.s($user->auth), 'info', false);
537                    $existinguser->auth = $user->auth;
538                    if (!isset($supportedauths[$user->auth])) {
539                        $upt->track('auth', $struserauthunsupported, 'warning');
540                    }
541                    $doupdate = true;
542                    if ($existinguser->auth === 'nologin') {
543                        $dologout = true;
544                    }
545                }
546                $allcolumns = array_merge($STD_FIELDS, $PRF_FIELDS);
547                foreach ($allcolumns as $column) {
548                    if ($column === 'username' or $column === 'password' or $column === 'auth' or $column === 'suspended') {
549                        // these can not be changed here
550                        continue;
551                    }
552                    if (!property_exists($user, $column) or !property_exists($existinguser, $column)) {
553                        continue;
554                    }
555                    if ($updatetype == UU_UPDATE_MISSING) {
556                        if (!is_null($existinguser->$column) and $existinguser->$column !== '') {
557                            continue;
558                        }
559                    } else if ($updatetype == UU_UPDATE_ALLOVERRIDE) {
560                        // we override everything
561
562                    } else if ($updatetype == UU_UPDATE_FILEOVERRIDE) {
563                        if (!empty($formdefaults[$column])) {
564                            // do not override with form defaults
565                            continue;
566                        }
567                    }
568                    if ($existinguser->$column !== $user->$column) {
569                        if ($column === 'email') {
570                            if ($DB->record_exists('user', array('email'=>$user->email))) {
571                                if ($noemailduplicates) {
572                                    $upt->track('email', $stremailduplicate, 'error');
573                                    $upt->track('status', $strusernotupdated, 'error');
574                                    $userserrors++;
575                                    continue 2;
576                                } else {
577                                    $upt->track('email', $stremailduplicate, 'warning');
578                                }
579                            }
580                            if (!validate_email($user->email)) {
581                                $upt->track('email', get_string('invalidemail'), 'warning');
582                            }
583                        }
584
585                        if ($column === 'lang') {
586                            if (empty($user->lang)) {
587                                // Do not change to not-set value.
588                                continue;
589                            } else if (clean_param($user->lang, PARAM_LANG) === '') {
590                                $upt->track('status', get_string('cannotfindlang', 'error', $user->lang), 'warning');
591                                continue;
592                            }
593                        }
594
595                        if (in_array($column, $upt->columns)) {
596                            $upt->track($column, s($existinguser->$column).'-->'.s($user->$column), 'info', false);
597                        }
598                        $existinguser->$column = $user->$column;
599                        $doupdate = true;
600                    }
601                }
602            }
603
604            try {
605                $auth = get_auth_plugin($existinguser->auth);
606            } catch (Exception $e) {
607                $upt->track('auth', get_string('userautherror', 'error', s($existinguser->auth)), 'error');
608                $upt->track('status', $strusernotupdated, 'error');
609                $userserrors++;
610                continue;
611            }
612            $isinternalauth = $auth->is_internal();
613
614            // deal with suspending and activating of accounts
615            if ($allowsuspends and isset($user->suspended) and $user->suspended !== '') {
616                $user->suspended = $user->suspended ? 1 : 0;
617                if ($existinguser->suspended != $user->suspended) {
618                    $upt->track('suspended', '', 'normal', false);
619                    $upt->track('suspended', $stryesnooptions[$existinguser->suspended].'-->'.$stryesnooptions[$user->suspended], 'info', false);
620                    $existinguser->suspended = $user->suspended;
621                    $doupdate = true;
622                    if ($existinguser->suspended) {
623                        $dologout = true;
624                    }
625                }
626            }
627
628            // changing of passwords is a special case
629            // do not force password changes for external auth plugins!
630            $oldpw = $existinguser->password;
631
632            if ($remoteuser) {
633                // Do not mess with passwords of remote users.
634
635            } else if (!$isinternalauth) {
636                $existinguser->password = AUTH_PASSWORD_NOT_CACHED;
637                $upt->track('password', '-', 'normal', false);
638                // clean up prefs
639                unset_user_preference('create_password', $existinguser);
640                unset_user_preference('auth_forcepasswordchange', $existinguser);
641
642            } else if (!empty($user->password)) {
643                if ($updatepasswords) {
644                    // Check for passwords that we want to force users to reset next
645                    // time they log in.
646                    $errmsg = null;
647                    $weak = !check_password_policy($user->password, $errmsg);
648                    if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
649                        if ($weak) {
650                            $weakpasswords++;
651                            $upt->track('password', $strinvalidpasswordpolicy, 'warning');
652                        }
653                        set_user_preference('auth_forcepasswordchange', 1, $existinguser);
654                    } else {
655                        unset_user_preference('auth_forcepasswordchange', $existinguser);
656                    }
657                    unset_user_preference('create_password', $existinguser); // no need to create password any more
658
659                    // Use a low cost factor when generating bcrypt hash otherwise
660                    // hashing would be slow when uploading lots of users. Hashes
661                    // will be automatically updated to a higher cost factor the first
662                    // time the user logs in.
663                    $existinguser->password = hash_internal_user_password($user->password, true);
664                    $upt->track('password', $user->password, 'normal', false);
665                } else {
666                    // do not print password when not changed
667                    $upt->track('password', '', 'normal', false);
668                }
669            }
670
671            if ($doupdate or $existinguser->password !== $oldpw) {
672                // We want only users that were really updated.
673                user_update_user($existinguser, false, false);
674
675                $upt->track('status', $struserupdated);
676                $usersupdated++;
677
678                if (!$remoteuser) {
679                    // pre-process custom profile menu fields data from csv file
680                    $existinguser = uu_pre_process_custom_profile_data($existinguser);
681                    // save custom profile fields data from csv file
682                    profile_save_data($existinguser);
683                }
684
685                if ($bulk == UU_BULK_UPDATED or $bulk == UU_BULK_ALL) {
686                    if (!in_array($user->id, $SESSION->bulk_users)) {
687                        $SESSION->bulk_users[] = $user->id;
688                    }
689                }
690
691                // Trigger event.
692                \core\event\user_updated::create_from_userid($existinguser->id)->trigger();
693
694            } else {
695                // no user information changed
696                $upt->track('status', $struseruptodate);
697                $usersuptodate++;
698
699                if ($bulk == UU_BULK_ALL) {
700                    if (!in_array($user->id, $SESSION->bulk_users)) {
701                        $SESSION->bulk_users[] = $user->id;
702                    }
703                }
704            }
705
706            if ($dologout) {
707                \core\session\manager::kill_user_sessions($existinguser->id);
708            }
709
710        } else {
711            // save the new user to the database
712            $user->confirmed    = 1;
713            $user->timemodified = time();
714            $user->timecreated  = time();
715            $user->mnethostid   = $CFG->mnet_localhost_id; // we support ONLY local accounts here, sorry
716
717            if (!isset($user->suspended) or $user->suspended === '') {
718                $user->suspended = 0;
719            } else {
720                $user->suspended = $user->suspended ? 1 : 0;
721            }
722            $upt->track('suspended', $stryesnooptions[$user->suspended], 'normal', false);
723
724            if (empty($user->auth)) {
725                $user->auth = 'manual';
726            }
727            $upt->track('auth', $user->auth, 'normal', false);
728
729            // do not insert record if new auth plugin does not exist!
730            try {
731                $auth = get_auth_plugin($user->auth);
732            } catch (Exception $e) {
733                $upt->track('auth', get_string('userautherror', 'error', s($user->auth)), 'error');
734                $upt->track('status', $strusernotaddederror, 'error');
735                $userserrors++;
736                continue;
737            }
738            if (!isset($supportedauths[$user->auth])) {
739                $upt->track('auth', $struserauthunsupported, 'warning');
740            }
741
742            $isinternalauth = $auth->is_internal();
743
744            if (empty($user->email)) {
745                $upt->track('email', get_string('invalidemail'), 'error');
746                $upt->track('status', $strusernotaddederror, 'error');
747                $userserrors++;
748                continue;
749
750            } else if ($DB->record_exists('user', array('email'=>$user->email))) {
751                if ($noemailduplicates) {
752                    $upt->track('email', $stremailduplicate, 'error');
753                    $upt->track('status', $strusernotaddederror, 'error');
754                    $userserrors++;
755                    continue;
756                } else {
757                    $upt->track('email', $stremailduplicate, 'warning');
758                }
759            }
760            if (!validate_email($user->email)) {
761                $upt->track('email', get_string('invalidemail'), 'warning');
762            }
763
764            if (empty($user->lang)) {
765                $user->lang = '';
766            } else if (clean_param($user->lang, PARAM_LANG) === '') {
767                $upt->track('status', get_string('cannotfindlang', 'error', $user->lang), 'warning');
768                $user->lang = '';
769            }
770
771            $forcechangepassword = false;
772
773            if ($isinternalauth) {
774                if (empty($user->password)) {
775                    if ($createpasswords) {
776                        $user->password = 'to be generated';
777                        $upt->track('password', '', 'normal', false);
778                        $upt->track('password', get_string('uupasswordcron', 'tool_uploaduser'), 'warning', false);
779                    } else {
780                        $upt->track('password', '', 'normal', false);
781                        $upt->track('password', get_string('missingfield', 'error', 'password'), 'error');
782                        $upt->track('status', $strusernotaddederror, 'error');
783                        $userserrors++;
784                        continue;
785                    }
786                } else {
787                    $errmsg = null;
788                    $weak = !check_password_policy($user->password, $errmsg);
789                    if ($resetpasswords == UU_PWRESET_ALL or ($resetpasswords == UU_PWRESET_WEAK and $weak)) {
790                        if ($weak) {
791                            $weakpasswords++;
792                            $upt->track('password', $strinvalidpasswordpolicy, 'warning');
793                        }
794                        $forcechangepassword = true;
795                    }
796                    // Use a low cost factor when generating bcrypt hash otherwise
797                    // hashing would be slow when uploading lots of users. Hashes
798                    // will be automatically updated to a higher cost factor the first
799                    // time the user logs in.
800                    $user->password = hash_internal_user_password($user->password, true);
801                }
802            } else {
803                $user->password = AUTH_PASSWORD_NOT_CACHED;
804                $upt->track('password', '-', 'normal', false);
805            }
806
807            $user->id = user_create_user($user, false, false);
808            $upt->track('username', html_writer::link(new moodle_url('/user/profile.php', array('id'=>$user->id)), s($user->username)), 'normal', false);
809
810            // pre-process custom profile menu fields data from csv file
811            $user = uu_pre_process_custom_profile_data($user);
812            // save custom profile fields data
813            profile_save_data($user);
814
815            if ($forcechangepassword) {
816                set_user_preference('auth_forcepasswordchange', 1, $user);
817            }
818            if ($user->password === 'to be generated') {
819                set_user_preference('create_password', 1, $user);
820            }
821
822            // Trigger event.
823            \core\event\user_created::create_from_userid($user->id)->trigger();
824
825            $upt->track('status', $struseradded);
826            $upt->track('id', $user->id, 'normal', false);
827            $usersnew++;
828
829            // make sure user context exists
830            context_user::instance($user->id);
831
832            if ($bulk == UU_BULK_NEW or $bulk == UU_BULK_ALL) {
833                if (!in_array($user->id, $SESSION->bulk_users)) {
834                    $SESSION->bulk_users[] = $user->id;
835                }
836            }
837        }
838
839
840        // add to cohort first, it might trigger enrolments indirectly - do NOT create cohorts here!
841        foreach ($filecolumns as $column) {
842            if (!preg_match('/^cohort\d+$/', $column)) {
843                continue;
844            }
845
846            if (!empty($user->$column)) {
847                $addcohort = $user->$column;
848                if (!isset($cohorts[$addcohort])) {
849                    if (is_number($addcohort)) {
850                        // only non-numeric idnumbers!
851                        $cohort = $DB->get_record('cohort', array('id'=>$addcohort));
852                    } else {
853                        $cohort = $DB->get_record('cohort', array('idnumber'=>$addcohort));
854                        if (empty($cohort) && has_capability('moodle/cohort:manage', context_system::instance())) {
855                            // Cohort was not found. Create a new one.
856                            $cohortid = cohort_add_cohort((object)array(
857                                'idnumber' => $addcohort,
858                                'name' => $addcohort,
859                                'contextid' => context_system::instance()->id
860                            ));
861                            $cohort = $DB->get_record('cohort', array('id'=>$cohortid));
862                        }
863                    }
864
865                    if (empty($cohort)) {
866                        $cohorts[$addcohort] = get_string('unknowncohort', 'core_cohort', s($addcohort));
867                    } else if (!empty($cohort->component)) {
868                        // cohorts synchronised with external sources must not be modified!
869                        $cohorts[$addcohort] = get_string('external', 'core_cohort');
870                    } else {
871                        $cohorts[$addcohort] = $cohort;
872                    }
873                }
874
875                if (is_object($cohorts[$addcohort])) {
876                    $cohort = $cohorts[$addcohort];
877                    if (!$DB->record_exists('cohort_members', array('cohortid'=>$cohort->id, 'userid'=>$user->id))) {
878                        cohort_add_member($cohort->id, $user->id);
879                        // we might add special column later, for now let's abuse enrolments
880                        $upt->track('enrolments', get_string('useradded', 'core_cohort', s($cohort->name)));
881                    }
882                } else {
883                    // error message
884                    $upt->track('enrolments', $cohorts[$addcohort], 'error');
885                }
886            }
887        }
888
889
890        // find course enrolments, groups, roles/types and enrol periods
891        // this is again a special case, we always do this for any updated or created users
892        foreach ($filecolumns as $column) {
893            if (preg_match('/^sysrole\d+$/', $column)) {
894
895                if (!empty($user->$column)) {
896                    $sysrolename = $user->$column;
897                    if ($sysrolename[0] == '-') {
898                        $removing = true;
899                        $sysrolename = substr($sysrolename, 1);
900                    } else {
901                        $removing = false;
902                    }
903
904                    if (array_key_exists($sysrolename, $sysrolecache)) {
905                        $sysroleid = $sysrolecache[$sysrolename]->id;
906                    } else {
907                        $upt->track('enrolments', get_string('unknownrole', 'error', s($sysrolename)), 'error');
908                        continue;
909                    }
910
911                    if ($removing) {
912                        if (user_has_role_assignment($user->id, $sysroleid, SYSCONTEXTID)) {
913                            role_unassign($sysroleid, $user->id, SYSCONTEXTID);
914                            $upt->track('enrolments', get_string('unassignedsysrole',
915                                    'tool_uploaduser', $sysrolecache[$sysroleid]->name));
916                        }
917                    } else {
918                        if (!user_has_role_assignment($user->id, $sysroleid, SYSCONTEXTID)) {
919                            role_assign($sysroleid, $user->id, SYSCONTEXTID);
920                            $upt->track('enrolments', get_string('assignedsysrole',
921                                    'tool_uploaduser', $sysrolecache[$sysroleid]->name));
922                        }
923                    }
924                }
925
926                continue;
927            }
928            if (!preg_match('/^course\d+$/', $column)) {
929                continue;
930            }
931            $i = substr($column, 6);
932
933            if (empty($user->{'course'.$i})) {
934                continue;
935            }
936            $shortname = $user->{'course'.$i};
937            if (!array_key_exists($shortname, $ccache)) {
938                if (!$course = $DB->get_record('course', array('shortname'=>$shortname), 'id, shortname')) {
939                    $upt->track('enrolments', get_string('unknowncourse', 'error', s($shortname)), 'error');
940                    continue;
941                }
942                $ccache[$shortname] = $course;
943                $ccache[$shortname]->groups = null;
944            }
945            $courseid      = $ccache[$shortname]->id;
946            $coursecontext = context_course::instance($courseid);
947            if (!isset($manualcache[$courseid])) {
948                $manualcache[$courseid] = false;
949                if ($manual) {
950                    if ($instances = enrol_get_instances($courseid, false)) {
951                        foreach ($instances as $instance) {
952                            if ($instance->enrol === 'manual') {
953                                $manualcache[$courseid] = $instance;
954                                break;
955                            }
956                        }
957                    }
958                }
959            }
960
961            if ($courseid == SITEID) {
962                // Technically frontpage does not have enrolments, but only role assignments,
963                // let's not invent new lang strings here for this rarely used feature.
964
965                if (!empty($user->{'role'.$i})) {
966                    $rolename = $user->{'role'.$i};
967                    if (array_key_exists($rolename, $rolecache)) {
968                        $roleid = $rolecache[$rolename]->id;
969                    } else {
970                        $upt->track('enrolments', get_string('unknownrole', 'error', s($rolename)), 'error');
971                        continue;
972                    }
973
974                    role_assign($roleid, $user->id, context_course::instance($courseid));
975
976                    $a = new stdClass();
977                    $a->course = $shortname;
978                    $a->role   = $rolecache[$roleid]->name;
979                    $upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
980                }
981
982            } else if ($manual and $manualcache[$courseid]) {
983
984                // find role
985                $roleid = false;
986                if (!empty($user->{'role'.$i})) {
987                    $rolename = $user->{'role'.$i};
988                    if (array_key_exists($rolename, $rolecache)) {
989                        $roleid = $rolecache[$rolename]->id;
990                    } else {
991                        $upt->track('enrolments', get_string('unknownrole', 'error', s($rolename)), 'error');
992                        continue;
993                    }
994
995                } else if (!empty($user->{'type'.$i})) {
996                    // if no role, then find "old" enrolment type
997                    $addtype = $user->{'type'.$i};
998                    if ($addtype < 1 or $addtype > 3) {
999                        $upt->track('enrolments', $strerror.': typeN = 1|2|3', 'error');
1000                        continue;
1001                    } else if (empty($formdata->{'uulegacy'.$addtype})) {
1002                        continue;
1003                    } else {
1004                        $roleid = $formdata->{'uulegacy'.$addtype};
1005                    }
1006                } else {
1007                    // no role specified, use the default from manual enrol plugin
1008                    $roleid = $manualcache[$courseid]->roleid;
1009                }
1010
1011                if ($roleid) {
1012                    // Find duration and/or enrol status.
1013                    $timeend = 0;
1014                    $status = null;
1015
1016                    if (isset($user->{'enrolstatus'.$i})) {
1017                        $enrolstatus = $user->{'enrolstatus'.$i};
1018                        if ($enrolstatus == '') {
1019                            $status = null;
1020                        } else if ($enrolstatus === (string)ENROL_USER_ACTIVE) {
1021                            $status = ENROL_USER_ACTIVE;
1022                        } else if ($enrolstatus === (string)ENROL_USER_SUSPENDED) {
1023                            $status = ENROL_USER_SUSPENDED;
1024                        } else {
1025                            debugging('Unknown enrolment status.');
1026                        }
1027                    }
1028
1029                    if (!empty($user->{'enrolperiod'.$i})) {
1030                        $duration = (int)$user->{'enrolperiod'.$i} * 60*60*24; // convert days to seconds
1031                        if ($duration > 0) { // sanity check
1032                            $timeend = $today + $duration;
1033                        }
1034                    } else if ($manualcache[$courseid]->enrolperiod > 0) {
1035                        $timeend = $today + $manualcache[$courseid]->enrolperiod;
1036                    }
1037
1038                    $manual->enrol_user($manualcache[$courseid], $user->id, $roleid, $today, $timeend, $status);
1039
1040                    $a = new stdClass();
1041                    $a->course = $shortname;
1042                    $a->role   = $rolecache[$roleid]->name;
1043                    $upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
1044                }
1045            }
1046
1047            // find group to add to
1048            if (!empty($user->{'group'.$i})) {
1049                // make sure user is enrolled into course before adding into groups
1050                if (!is_enrolled($coursecontext, $user->id)) {
1051                    $upt->track('enrolments', get_string('addedtogroupnotenrolled', '', $user->{'group'.$i}), 'error');
1052                    continue;
1053                }
1054                //build group cache
1055                if (is_null($ccache[$shortname]->groups)) {
1056                    $ccache[$shortname]->groups = array();
1057                    if ($groups = groups_get_all_groups($courseid)) {
1058                        foreach ($groups as $gid=>$group) {
1059                            $ccache[$shortname]->groups[$gid] = new stdClass();
1060                            $ccache[$shortname]->groups[$gid]->id   = $gid;
1061                            $ccache[$shortname]->groups[$gid]->name = $group->name;
1062                            if (!is_numeric($group->name)) { // only non-numeric names are supported!!!
1063                                $ccache[$shortname]->groups[$group->name] = new stdClass();
1064                                $ccache[$shortname]->groups[$group->name]->id   = $gid;
1065                                $ccache[$shortname]->groups[$group->name]->name = $group->name;
1066                            }
1067                        }
1068                    }
1069                }
1070                // group exists?
1071                $addgroup = $user->{'group'.$i};
1072                if (!array_key_exists($addgroup, $ccache[$shortname]->groups)) {
1073                    // if group doesn't exist,  create it
1074                    $newgroupdata = new stdClass();
1075                    $newgroupdata->name = $addgroup;
1076                    $newgroupdata->courseid = $ccache[$shortname]->id;
1077                    $newgroupdata->description = '';
1078                    $gid = groups_create_group($newgroupdata);
1079                    if ($gid){
1080                        $ccache[$shortname]->groups[$addgroup] = new stdClass();
1081                        $ccache[$shortname]->groups[$addgroup]->id   = $gid;
1082                        $ccache[$shortname]->groups[$addgroup]->name = $newgroupdata->name;
1083                    } else {
1084                        $upt->track('enrolments', get_string('unknowngroup', 'error', s($addgroup)), 'error');
1085                        continue;
1086                    }
1087                }
1088                $gid   = $ccache[$shortname]->groups[$addgroup]->id;
1089                $gname = $ccache[$shortname]->groups[$addgroup]->name;
1090
1091                try {
1092                    if (groups_add_member($gid, $user->id)) {
1093                        $upt->track('enrolments', get_string('addedtogroup', '', s($gname)));
1094                    }  else {
1095                        $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
1096                    }
1097                } catch (moodle_exception $e) {
1098                    $upt->track('enrolments', get_string('addedtogroupnot', '', s($gname)), 'error');
1099                    continue;
1100                }
1101            }
1102        }
1103    }
1104    $upt->close(); // close table
1105
1106    $cir->close();
1107    $cir->cleanup(true);
1108
1109    echo $OUTPUT->box_start('boxwidthnarrow boxaligncenter generalbox', 'uploadresults');
1110    echo '<p>';
1111    if ($optype != UU_USER_UPDATE) {
1112        echo get_string('userscreated', 'tool_uploaduser').': '.$usersnew.'<br />';
1113    }
1114    if ($optype == UU_USER_UPDATE or $optype == UU_USER_ADD_UPDATE) {
1115        echo get_string('usersupdated', 'tool_uploaduser').': '.$usersupdated.'<br />';
1116    }
1117    if ($allowdeletes) {
1118        echo get_string('usersdeleted', 'tool_uploaduser').': '.$deletes.'<br />';
1119        echo get_string('deleteerrors', 'tool_uploaduser').': '.$deleteerrors.'<br />';
1120    }
1121    if ($allowrenames) {
1122        echo get_string('usersrenamed', 'tool_uploaduser').': '.$renames.'<br />';
1123        echo get_string('renameerrors', 'tool_uploaduser').': '.$renameerrors.'<br />';
1124    }
1125    if ($usersskipped) {
1126        echo get_string('usersskipped', 'tool_uploaduser').': '.$usersskipped.'<br />';
1127    }
1128    echo get_string('usersweakpassword', 'tool_uploaduser').': '.$weakpasswords.'<br />';
1129    echo get_string('errors', 'tool_uploaduser').': '.$userserrors.'</p>';
1130    echo $OUTPUT->box_end();
1131
1132    if ($bulk) {
1133        echo $OUTPUT->continue_button($bulknurl);
1134    } else {
1135        echo $OUTPUT->continue_button($returnurl);
1136    }
1137    echo $OUTPUT->footer();
1138    die;
1139}
1140
1141// Print the header
1142echo $OUTPUT->header();
1143
1144echo $OUTPUT->heading(get_string('uploaduserspreview', 'tool_uploaduser'));
1145
1146// NOTE: this is JUST csv processing preview, we must not prevent import from here if there is something in the file!!
1147//       this was intended for validation of csv formatting and encoding, not filtering the data!!!!
1148//       we definitely must not process the whole file!
1149
1150// preview table data
1151$data = array();
1152$cir->init();
1153$linenum = 1; //column header is first line
1154$noerror = true; // Keep status of any error.
1155while ($linenum <= $previewrows and $fields = $cir->next()) {
1156    $linenum++;
1157    $rowcols = array();
1158    $rowcols['line'] = $linenum;
1159    foreach($fields as $key => $field) {
1160        $rowcols[$filecolumns[$key]] = s(trim($field));
1161    }
1162    $rowcols['status'] = array();
1163
1164    if (isset($rowcols['username'])) {
1165        $stdusername = clean_param($rowcols['username'], PARAM_USERNAME);
1166        if ($rowcols['username'] !== $stdusername) {
1167            $rowcols['status'][] = get_string('invalidusernameupload');
1168        }
1169        if ($userid = $DB->get_field('user', 'id', array('username'=>$stdusername, 'mnethostid'=>$CFG->mnet_localhost_id))) {
1170            $rowcols['username'] = html_writer::link(new moodle_url('/user/profile.php', array('id'=>$userid)), $rowcols['username']);
1171        }
1172    } else {
1173        $rowcols['status'][] = get_string('missingusername');
1174    }
1175
1176    if (isset($rowcols['email'])) {
1177        if (!validate_email($rowcols['email'])) {
1178            $rowcols['status'][] = get_string('invalidemail');
1179        }
1180        if ($DB->record_exists('user', array('email'=>$rowcols['email']))) {
1181            $rowcols['status'][] = $stremailduplicate;
1182        }
1183    }
1184
1185    if (isset($rowcols['city'])) {
1186        $rowcols['city'] = $rowcols['city'];
1187    }
1188    // Check if rowcols have custom profile field with correct data and update error state.
1189    $noerror = uu_check_custom_profile_data($rowcols) && $noerror;
1190    $rowcols['status'] = implode('<br />', $rowcols['status']);
1191    $data[] = $rowcols;
1192}
1193if ($fields = $cir->next()) {
1194    $data[] = array_fill(0, count($fields) + 2, '...');
1195}
1196$cir->close();
1197
1198$table = new html_table();
1199$table->id = "uupreview";
1200$table->attributes['class'] = 'generaltable';
1201$table->tablealign = 'center';
1202$table->summary = get_string('uploaduserspreview', 'tool_uploaduser');
1203$table->head = array();
1204$table->data = $data;
1205
1206$table->head[] = get_string('uucsvline', 'tool_uploaduser');
1207foreach ($filecolumns as $column) {
1208    $table->head[] = $column;
1209}
1210$table->head[] = get_string('status');
1211
1212echo html_writer::tag('div', html_writer::table($table), array('class'=>'flexible-wrap'));
1213
1214// Print the form if valid values are available
1215if ($noerror) {
1216    $mform2->display();
1217}
1218echo $OUTPUT->footer();
1219die;
1220
Note: See TracBrowser for help on using the repository browser.