admin/uploaduser.php

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