MDL-24751 fixed default memory limit when deciding to use apache_child_terminate...
[moodle.git] / admin / uploaduser.php
1 <?php
3 /// Bulk user registration script from a comma separated file
4 /// Returns list of users with their user ids
6 require('../config.php');
7 require_once($CFG->libdir.'/adminlib.php');
8 require_once($CFG->libdir.'/csvlib.class.php');
9 require_once($CFG->dirroot.'/user/profile/lib.php');
10 require_once('uploaduser_form.php');
12 $iid         = optional_param('iid', '', PARAM_INT);
13 $previewrows = optional_param('previewrows', 10, PARAM_INT);
14 $readcount   = optional_param('readcount', 0, PARAM_INT);
15 $uploadtype  = optional_param('uutype', 0, PARAM_INT);
17 define('UU_ADDNEW', 0);
18 define('UU_ADDINC', 1);
19 define('UU_ADD_UPDATE', 2);
20 define('UU_UPDATE', 3);
22 $choices = array(UU_ADDNEW    => get_string('uuoptype_addnew', 'admin'),
23                  UU_ADDINC    => get_string('uuoptype_addinc', 'admin'),
24                  UU_ADD_UPDATE => get_string('uuoptype_addupdate', 'admin'),
25                  UU_UPDATE     => get_string('uuoptype_update', 'admin'));
27 @set_time_limit(3600); // 1 hour should be enough
28 raise_memory_limit(MEMORY_EXTRA);
30 require_login();
31 admin_externalpage_setup('uploadusers');
32 require_capability('moodle/site:uploadusers', get_context_instance(CONTEXT_SYSTEM));
34 $textlib = textlib_get_instance();
35 $systemcontext = get_context_instance(CONTEXT_SYSTEM);
37 $struserrenamed             = get_string('userrenamed', 'admin');
38 $strusernotrenamedexists    = get_string('usernotrenamedexists', 'error');
39 $strusernotrenamedmissing   = get_string('usernotrenamedmissing', 'error');
40 $strusernotrenamedoff       = get_string('usernotrenamedoff', 'error');
41 $strusernotrenamedadmin     = get_string('usernotrenamedadmin', 'error');
43 $struserupdated             = get_string('useraccountupdated', 'admin');
44 $strusernotupdated          = get_string('usernotupdatederror', 'error');
45 $strusernotupdatednotexists = get_string('usernotupdatednotexists', 'error');
46 $strusernotupdatedadmin     = get_string('usernotupdatedadmin', 'error');
48 $struseradded               = get_string('newuser');
49 $strusernotadded            = get_string('usernotaddedregistered', 'error');
50 $strusernotaddederror       = get_string('usernotaddederror', 'error');
52 $struserdeleted             = get_string('userdeleted', 'admin');
53 $strusernotdeletederror     = get_string('usernotdeletederror', 'error');
54 $strusernotdeletedmissing   = get_string('usernotdeletedmissing', 'error');
55 $strusernotdeletedoff       = get_string('usernotdeletedoff', 'error');
56 $strusernotdeletedadmin     = get_string('usernotdeletedadmin', 'error');
58 $strcannotassignrole        = get_string('cannotassignrole', 'error');
59 $strduplicateusername       = get_string('duplicateusername', 'error');
61 $struserauthunsupported     = get_string('userauthunsupported', 'error');
62 $stremailduplicate          = get_string('useremailduplicate', 'error');
64 $errorstr                   = get_string('error');
66 $returnurl = $CFG->wwwroot.'/'.$CFG->admin.'/uploaduser.php';
67 $bulknurl  = $CFG->wwwroot.'/'.$CFG->admin.'/user/user_bulk.php';
69 $today = time();
70 $today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);
72 // array of all valid fields for validation
73 $STD_FIELDS = array('id', 'firstname', 'lastname', 'username', 'email',
74         'city', 'country', 'lang', 'auth', 'timezone', 'mailformat',
75         'maildisplay', 'maildigest', 'htmleditor', 'ajax', 'autosubscribe',
76         'mnethostid', 'institution', 'department', 'idnumber', 'skype',
77         'msn', 'aim', 'yahoo', 'icq', 'phone1', 'phone2', 'address',
78         'url', 'description', 'descriptionformat', 'oldusername', 'emailstop', 'deleted',
79         'password');
81 $PRF_FIELDS = array();
83 if ($prof_fields = $DB->get_records('user_info_field')) {
84     foreach ($prof_fields as $prof_field) {
85         $PRF_FIELDS[] = 'profile_field_'.$prof_field->shortname;
86     }
87     unset($prof_fields);
88 }
90 if (empty($iid)) {
91     $mform = new admin_uploaduser_form1();
93     if ($formdata = $mform->get_data()) {
94         $iid = csv_import_reader::get_new_iid('uploaduser');
95         $cir = new csv_import_reader($iid, 'uploaduser');
97         $content = $mform->get_file_content('userfile');
98         $optype = $formdata->uutype;
99         $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name, 'validate_user_upload_columns');
100         unset($content);
102         if ($readcount === false) {
103             //TODO: need more detailed error info
104             print_error('csvloaderror', '', $returnurl);
105         } else if ($readcount == 0) {
106             print_error('csvemptyfile', 'error', $returnurl);
107         }
108         // continue to form2
110     } else {
111         echo $OUTPUT->header();
113         echo $OUTPUT->heading_with_help(get_string('uploadusers', 'admin'), 'uploadusers', 'admin');
115         $mform->display();
116         echo $OUTPUT->footer();
117         die;
118     }
119 } else {
120     $cir = new csv_import_reader($iid, 'uploaduser');
123 if (!$columns = $cir->get_columns()) {
124     print_error('cannotreadtmpfile', 'error', $returnurl);
126 $mform = new admin_uploaduser_form2(null, $columns);
127 // get initial date from form1
128 $mform->set_data(array('iid'=>$iid, 'previewrows'=>$previewrows, 'readcount'=>$readcount, 'uutypelabel'=>$choices[$uploadtype], 'uutype'=>$uploadtype));
130 // If a file has been uploaded, then process it
131 if ($formdata = $mform->is_cancelled()) {
132     $cir->cleanup(true);
133     redirect($returnurl);
135 } else if ($formdata = $mform->get_data()) {
136     // Print the header
137     echo $OUTPUT->header();
138     echo $OUTPUT->heading(get_string('uploadusersresult', 'admin'));
140     $optype = $formdata->uutype;
142     $createpasswords   = (!empty($formdata->uupasswordnew) and $optype != UU_UPDATE);
143     $updatepasswords   = (!empty($formdata->uupasswordold)  and $optype != UU_ADDNEW and $optype != UU_ADDINC);
144     $allowrenames      = (!empty($formdata->uuallowrenames) and $optype != UU_ADDNEW and $optype != UU_ADDINC);
145     $allowdeletes      = (!empty($formdata->uuallowdeletes) and $optype != UU_ADDNEW and $optype != UU_ADDINC);
146     $updatetype        = isset($formdata->uuupdatetype) ? $formdata->uuupdatetype : 0;
147     $bulk              = $formdata->uubulk;
148     $noemailduplicates = $formdata->uunoemailduplicates;
150     // verification moved to two places: after upload and into form2
151     $usersnew     = 0;
152     $usersupdated = 0;
153     $userserrors  = 0;
154     $deletes      = 0;
155     $deleteerrors = 0;
156     $renames      = 0;
157     $renameerrors = 0;
158     $usersskipped = 0;
159     $weakpasswords = 0;
161     // caches
162     $ccache       = array(); // course cache - do not fetch all courses here, we  will not probably use them all anyway!
163     $rolecache    = uu_allowed_roles_cache(); // roles lookup cache
164     $manualcache  = array(); // cache of used manual enrol plugins in each course
166     $allowedauths   = uu_allowed_auths();
167     $allowedauths   = array_keys($allowedauths);
168     $availableauths = get_plugin_list('auth');
169     $availableauths = array_keys($availableauths);
171     // we use only manual enrol plugin here, if it is disabled no enrol is done
172     if (enrol_is_enabled('manual')) {
173         $manual = enrol_get_plugin('manual');
174     } else {
175         $manual = NULL;
176     }
178     // clear bulk selection
179     if ($bulk) {
180         $SESSION->bulk_users = array();
181     }
183     // init csv import helper
184     $cir->init();
185     $linenum = 1; //column header is first line
187     // init upload progress tracker
188     $upt = new uu_progress_tracker();
189     $upt->init(); // start table
191     while ($line = $cir->next()) {
192         $upt->flush();
193         $linenum++;
195         $upt->track('line', $linenum);
197         $forcechangepassword = false;
199         $user = new stdClass();
200         // by default, use the local mnet id (this may be changed in the file)
201         $user->mnethostid = $CFG->mnet_localhost_id;
202         // add fields to user object
203         foreach ($line as $key => $value) {
204             if ($value !== '') {
205                 $key = $columns[$key];
206                 // password is special field
207                 if ($key == 'password') {
208                     if ($value !== '') {
209                         $user->password = hash_internal_user_password($value);
210                         if (!empty($CFG->passwordpolicy) and !check_password_policy($value, $errmsg)) {
211                             $forcechangepassword = true;
212                             $weakpasswords++;
213                         }
214                     }
215                 } else {
216                     $user->$key = $value;
217                     if (in_array($key, $upt->columns)) {
218                         $upt->track($key, $value);
219                     }
220                 }
221             }
222         }
224         // get username, first/last name now - we need them in templates!!
225         if ($optype == UU_UPDATE) {
226             // when updating only username is required
227             if (!isset($user->username)) {
228                 $upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
229                 $upt->track('username', $errorstr, 'error');
230                 $userserrors++;
231                 continue;
232             }
234         } else {
235             $error = false;
236             // when all other ops need firstname and lastname
237             if (!isset($user->firstname) or $user->firstname === '') {
238                 $upt->track('status', get_string('missingfield', 'error', 'firstname'), 'error');
239                 $upt->track('firstname', $errorstr, 'error');
240                 $error = true;
241             }
242             if (!isset($user->lastname) or $user->lastname === '') {
243                 $upt->track('status', get_string('missingfield', 'error', 'lastname'), 'error');
244                 $upt->track('lastname', $errorstr, 'error');
245                 $error = true;
246             }
247             if ($error) {
248                 $userserrors++;
249                 continue;
250             }
251             // we require username too - we might use template for it though
252             if (!isset($user->username)) {
253                 if (!isset($formdata->username) or $formdata->username === '') {
254                     $upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
255                     $upt->track('username', $errorstr, 'error');
256                     $userserrors++;
257                     continue;
258                 } else {
259                     $user->username = process_template($formdata->username, $user);
260                     $upt->track('username', $user->username);
261                 }
262             }
263         }
265         // normalize username
266         $user->username = clean_param($user->username, PARAM_USERNAME);
268         if (empty($user->username)) {
269             $upt->track('status', get_string('missingfield', 'error', 'username'), 'error');
270             $upt->track('username', $errorstr, 'error');
271             $userserrors++;
272             continue;
273         }
275         if ($existinguser = $DB->get_record('user', array('username'=>$user->username, 'mnethostid'=>$user->mnethostid))) {
276             $upt->track('id', $existinguser->id, 'normal', false);
277         }
279         // find out in username incrementing required
280         if ($existinguser and $optype == UU_ADDINC) {
281             $oldusername = $user->username;
282             $user->username = increment_username($user->username, $user->mnethostid);
283             $upt->track('username', '', 'normal', false); // clear previous
284             $upt->track('username', $oldusername.'-->'.$user->username, 'info');
285             $existinguser = false;
286         }
288         // add default values for remaining fields
289         foreach ($STD_FIELDS as $field) {
290             if (isset($user->$field)) {
291                 continue;
292             }
293             // all validation moved to form2
294             if (isset($formdata->$field)) {
295                 // process templates
296                 $user->$field = process_template($formdata->$field, $user);
297             }
298         }
299         foreach ($PRF_FIELDS as $field) {
300             if (isset($user->$field)) {
301                 continue;
302             }
303             if (isset($formdata->$field)) {
304                 // process templates
305                 $user->$field = process_template($formdata->$field, $user);
306             }
307         }
309         // delete user
310         if (!empty($user->deleted)) {
311             if (!$allowdeletes) {
312                 $usersskipped++;
313                 $upt->track('status', $strusernotdeletedoff, 'warning');
314                 continue;
315             }
316             if ($existinguser) {
317                 if (is_siteadmin($existinguser->id)) {
318                     $upt->track('status', $strusernotdeletedadmin, 'error');
319                     $deleteerrors++;
320                     continue;
321                 }
322                 if (delete_user($existinguser)) {
323                     $upt->track('status', $struserdeleted);
324                     $deletes++;
325                 } else {
326                     $upt->track('status', $strusernotdeletederror, 'error');
327                     $deleteerrors++;
328                 }
329             } else {
330                 $upt->track('status', $strusernotdeletedmissing, 'error');
331                 $deleteerrors++;
332             }
333             continue;
334         }
335         // we do not need the deleted flag anymore
336         unset($user->deleted);
338         // renaming requested?
339         if (!empty($user->oldusername) ) {
340             $oldusername = $textlib->strtolower($user->oldusername);
341             if (!$allowrenames) {
342                 $usersskipped++;
343                 $upt->track('status', $strusernotrenamedoff, 'warning');
344                 continue;
345             }
347             if ($existinguser) {
348                 $upt->track('status', $strusernotrenamedexists, 'error');
349                 $renameerrors++;
350                 continue;
351             }
353             if ($olduser = $DB->get_record('user', array('username'=>$oldusername, 'mnethostid'=>$user->mnethostid))) {
354                 $upt->track('id', $olduser->id, 'normal', false);
355                 if (is_siteadmin($olduser->id)) {
356                     $upt->track('status', $strusernotrenamedadmin, 'error');
357                     $renameerrors++;
358                     continue;
359                 }
360                 $DB->set_field('user', 'username', $user->username, array('id'=>$olduser->id));
361                 $upt->track('username', '', 'normal', false); // clear previous
362                 $upt->track('username', $oldusername.'-->'.$user->username, 'info');
363                 $upt->track('status', $struserrenamed);
364                 $renames++;
365             } else {
366                 $upt->track('status', $strusernotrenamedmissing, 'error');
367                 $renameerrors++;
368                 continue;
369             }
370             $existinguser = $olduser;
371             $existinguser->username = $user->username;
372         }
374         // can we process with update or insert?
375         $skip = false;
376         switch ($optype) {
377             case UU_ADDNEW:
378                 if ($existinguser) {
379                     $usersskipped++;
380                     $upt->track('status', $strusernotadded, 'warning');
381                     $skip = true;
382                 }
383                 break;
385             case UU_ADDINC:
386                 if ($existinguser) {
387                     //this should not happen!
388                     $upt->track('status', $strusernotaddederror, 'error');
389                     $userserrors++;
390                     continue;
391                 }
392                 break;
394             case UU_ADD_UPDATE:
395                 break;
397             case UU_UPDATE:
398                 if (!$existinguser) {
399                     $usersskipped++;
400                     $upt->track('status', $strusernotupdatednotexists, 'warning');
401                     $skip = true;
402                 }
403                 break;
404         }
406         if ($skip) {
407             continue;
408         }
410         if ($existinguser) {
411             $user->id = $existinguser->id;
413             if (is_siteadmin($user->id)) {
414                 $upt->track('status', $strusernotupdatedadmin, 'error');
415                 $userserrors++;
416                 continue;
417             }
419             if (!$updatetype) {
420                 // no updates of existing data at all
421             } else {
422                 $existinguser->timemodified = time();
423                 if (empty($existinguser->timecreated)) {
424                     if (empty($existinguser->firstaccess)) {
425                         $existinguser->timecreated = time();
426                     } else {
427                         $existinguser->timecreated = $existinguser->firstaccess;
428                     }
429                 }
431                 //load existing profile data
432                 profile_load_data($existinguser);
434                 $allowed = array();
435                 if ($updatetype == 1) {
436                     $allowed = $columns;
437                 } else if ($updatetype == 2 or $updatetype == 3) {
438                     $allowed = array_merge($STD_FIELDS, $PRF_FIELDS);
439                 }
440                 foreach ($allowed as $column) {
441                     if ($column == 'username') {
442                         continue;
443                     }
444                     if ($column == 'password') {
445                         if (!$updatepasswords or $updatetype == 3) {
446                             continue;
447                         } else if (!empty($user->password)) {
448                             $upt->track('password', get_string('updated'));
449                             if ($forcechangepassword) {
450                                 set_user_preference('auth_forcepasswordchange', 1, $existinguser->id);
451                             }
452                         }
453                     }
454                     if ((property_exists($existinguser, $column) and property_exists($user, $column)) or in_array($column, $PRF_FIELDS)) {
455                         if ($updatetype == 3 and $existinguser->$column !== '') {
456                             //missing == non-empty only
457                             continue;
458                         }
459                         if ($existinguser->$column !== $user->$column) {
460                             if ($column == 'email') {
461                                 if ($DB->record_exists('user', array('email'=>$user->email))) {
462                                     if ($noemailduplicates) {
463                                         $upt->track('email', $stremailduplicate, 'error');
464                                         $upt->track('status', $strusernotupdated, 'error');
465                                         $userserrors++;
466                                         continue 2;
467                                     } else {
468                                         $upt->track('email', $stremailduplicate, 'warning');
469                                     }
470                                 }
471                             }
472                             if ($column != 'password' and in_array($column, $upt->columns)) {
473                                 $upt->track($column, '', 'normal', false); // clear previous
474                                 $upt->track($column, $existinguser->$column.'-->'.$user->$column, 'info');
475                             }
476                             $existinguser->$column = $user->$column;
477                         }
478                     }
479                 }
481                 // do not update record if new auth plugin does not exist!
482                 if (!in_array($existinguser->auth, $availableauths)) {
483                     $upt->track('auth', get_string('userautherror', 'error', $existinguser->auth), 'error');
484                     $upt->track('status', $strusernotupdated, 'error');
485                     $userserrors++;
486                     continue;
487                 } else if (!in_array($existinguser->auth, $allowedauths)) {
488                     $upt->track('auth', $struserauthunsupported, 'warning');
489                 }
491                 $DB->update_record('user', $existinguser);
492                 $upt->track('status', $struserupdated);
493                 $usersupdated++;
494                 // save custom profile fields data from csv file
495                 profile_save_data($existinguser);
497                 events_trigger('user_updated', $existinguser);
498             }
500             if ($bulk == 2 or $bulk == 3) {
501                 if (!in_array($user->id, $SESSION->bulk_users)) {
502                     $SESSION->bulk_users[] = $user->id;
503                 }
504             }
506         } else {
507             // save the user to the database
508             $user->confirmed = 1;
509             $user->timemodified = time();
510             $user->timecreated = time();
512             if (!$createpasswords and empty($user->password)) {
513                 $upt->track('password', get_string('missingfield', 'error', 'password'), 'error');
514                 $upt->track('status', $strusernotaddederror, 'error');
515                 $userserrors++;
516                 continue;
517             }
519             // do not insert record if new auth plguin does not exist!
520             if (isset($user->auth)) {
521                 if (!in_array($user->auth, $availableauths)) {
522                     $upt->track('auth', get_string('userautherror', 'error', $user->auth), 'error');
523                     $upt->track('status', $strusernotaddederror, 'error');
524                     $userserrors++;
525                     continue;
526                 } else if (!in_array($user->auth, $allowedauths)) {
527                     $upt->track('auth', $struserauthunsupported, 'warning');
528                 }
529             }
531             if ($DB->record_exists('user', array('email'=>$user->email))) {
532                 if ($noemailduplicates) {
533                     $upt->track('email', $stremailduplicate, 'error');
534                     $upt->track('status', $strusernotaddederror, 'error');
535                     $userserrors++;
536                     continue;
537                 } else {
538                     $upt->track('email', $stremailduplicate, 'warning');
539                 }
540             }
542             $user->id = $DB->insert_record('user', $user);
543             $info = ': ' . $user->username .' (ID = ' . $user->id . ')';
544             $upt->track('status', $struseradded);
545             $upt->track('id', $user->id, 'normal', false);
546             $usersnew++;
547             if ($createpasswords and empty($user->password)) {
548                 // passwords will be created and sent out on cron
549                 set_user_preference('create_password', 1, $user->id);
550                 set_user_preference('auth_forcepasswordchange', 1, $user->id);
551                 $upt->track('password', get_string('new'));
552             }
553             if ($forcechangepassword) {
554                 set_user_preference('auth_forcepasswordchange', 1, $user->id);
555             }
557             // save custom profile fields data
558             profile_save_data($user);
560             // make sure user context exists
561             get_context_instance(CONTEXT_USER, $user->id);
563             events_trigger('user_created', $user);
565             if ($bulk == 1 or $bulk == 3) {
566                 if (!in_array($user->id, $SESSION->bulk_users)) {
567                     $SESSION->bulk_users[] = $user->id;
568                 }
569             }
570         }
572         // find course enrolments, groups, roles/types and enrol periods
573         foreach ($columns as $column) {
574             if (!preg_match('/^course\d+$/', $column)) {
575                 continue;
576             }
577             $i = substr($column, 6);
579             if (empty($user->{'course'.$i})) {
580                 continue;
581             }
582             $shortname = $user->{'course'.$i};
583             if (!array_key_exists($shortname, $ccache)) {
584                 if (!$course = $DB->get_record('course', array('shortname'=>$shortname), 'id, shortname')) {
585                     $upt->track('enrolments', get_string('unknowncourse', 'error', $shortname), 'error');
586                     continue;
587                 }
588                 $ccache[$shortname] = $course;
589                 $ccache[$shortname]->groups = null;
590             }
591             $courseid      = $ccache[$shortname]->id;
592             $coursecontext = get_context_instance(CONTEXT_COURSE, $courseid);
593             if (!isset($manualcache[$courseid])) {
594                 if ($instances = enrol_get_instances($courseid, false)) {
595                     $manualcache[$courseid] = reset($instances);
596                 } else {
597                     $manualcache[$courseid] = false;
598                 }
599             }
601             if ($manual and $manualcache[$courseid]) {
603                 // find role
604                 $rid = false;
605                 if (!empty($user->{'role'.$i})) {
606                     $addrole = $user->{'role'.$i};
607                     if (array_key_exists($addrole, $rolecache)) {
608                         $rid = $rolecache[$addrole]->id;
609                     } else {
610                         $upt->track('enrolments', get_string('unknownrole', 'error', $addrole), 'error');
611                         continue;
612                     }
614                 } else if (!empty($user->{'type'.$i})) {
615                     // if no role, then find "old" enrolment type
616                     $addtype = $user->{'type'.$i};
617                     if ($addtype < 1 or $addtype > 3) {
618                         $upt->track('enrolments', $strerror.': typeN = 1|2|3', 'error');
619                         continue;
620                     } else if (empty($formdata->{'uulegacy'.$addtype})) {
621                         continue;
622                     } else {
623                         $rid = $formdata->{'uulegacy'.$addtype};
624                     }
625                 } else {
626                     // no role specified, use the default from manual enrol plugin
627                     $rid = $manualcache[$courseid]->roleid;
628                 }
630                 if ($rid) {
631                     // find duration
632                     $timeend   = 0;
633                     if (!empty($user->{'enrolperiod'.$i})) {
634                         $duration = (int)$user->{'enrolperiod'.$i} * 86400; // convert days to seconds
635                         if ($duration > 0) { // sanity check
636                             $timeend   = $today + $duration;
637                         }
638                     }
640                     $manual->enrol_user($manualcache[$courseid], $user->id, $rid, $today, $timeend, true);
642                     $a = new stdClass();
643                     $a->course = $shortname;
644                     $a->role   = $rolecache[$rid]->name;
645                     $upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
646                 }
647             }
649             // find group to add to
650             if (!empty($user->{'group'.$i})) {
651                 // make sure user is enrolled into course before adding into groups
652                 if (!is_enrolled($coursecontext, $user->id)) {
653                     $upt->track('enrolments', get_string('addedtogroupnotenrolled', '', $user->{'group'.$i}), 'error');
654                     continue;
655                 }
656                 //build group cache
657                 if (is_null($ccache[$shortname]->groups)) {
658                     $ccache[$shortname]->groups = array();
659                     if ($groups = groups_get_all_groups($courseid)) {
660                         foreach ($groups as $gid=>$group) {
661                             $ccache[$shortname]->groups[$gid] = new stdClass();
662                             $ccache[$shortname]->groups[$gid]->id   = $gid;
663                             $ccache[$shortname]->groups[$gid]->name = $group->name;
664                             if (!is_numeric($group->name)) { // only non-numeric names are supported!!!
665                             $ccache[$shortname]->groups[$group->name] = new stdClass();
666                             $ccache[$shortname]->groups[$group->name]->id   = $gid;
667                             $ccache[$shortname]->groups[$group->name]->name = $group->name;
668                             }
669                         }
670                     }
671                 }
672                 // group exists?
673                 $addgroup = $user->{'group'.$i};
674                 if (!array_key_exists($addgroup, $ccache[$shortname]->groups)) {
675                     // if group doesn't exist,  create it
676                     $newgroupdata = new stdClass();
677                     $newgroupdata->name = $addgroup;
678                     $newgroupdata->courseid = $ccache[$shortname]->id;
679                     if ($ccache[$shortname]->groups[$addgroup]->id = groups_create_group($newgroupdata)){
680                         $ccache[$shortname]->groups[$addgroup]->name = $newgroupdata->name;
681                     } else {
682                         $upt->track('enrolments', get_string('unknowngroup', 'error', $addgroup), 'error');
683                         continue;
684                     }
685                 }
686                 $gid   = $ccache[$shortname]->groups[$addgroup]->id;
687                 $gname = $ccache[$shortname]->groups[$addgroup]->name;
689                 try {
690                     if (groups_add_member($gid, $user->id)) {
691                         $upt->track('enrolments', get_string('addedtogroup', '', $gname));
692                     }  else {
693                         $upt->track('enrolments', get_string('addedtogroupnot', '', $gname), 'error');
694                     }
695                 } catch (moodle_exception $e) {
696                     $upt->track('enrolments', get_string('addedtogroupnot', '', $gname), 'error');
697                     continue;
698                 }
699             }
700         }
701     }
702     $upt->flush();
703     $upt->close(); // close table
705     $cir->close();
706     $cir->cleanup(true);
708     echo $OUTPUT->box_start('boxwidthnarrow boxaligncenter generalbox', 'uploadresults');
709     echo '<p>';
710     if ($optype != UU_UPDATE) {
711         echo get_string('userscreated', 'admin').': '.$usersnew.'<br />';
712     }
713     if ($optype == UU_UPDATE or $optype == UU_ADD_UPDATE) {
714         echo get_string('usersupdated', 'admin').': '.$usersupdated.'<br />';
715     }
716     if ($allowdeletes) {
717         echo get_string('usersdeleted', 'admin').': '.$deletes.'<br />';
718         echo get_string('deleteerrors', 'admin').': '.$deleteerrors.'<br />';
719     }
720     if ($allowrenames) {
721         echo get_string('usersrenamed', 'admin').': '.$renames.'<br />';
722         echo get_string('renameerrors', 'admin').': '.$renameerrors.'<br />';
723     }
724     if ($usersskipped) {
725         echo get_string('usersskipped', 'admin').': '.$usersskipped.'<br />';
726     }
727     echo get_string('usersweakpassword', 'admin').': '.$weakpasswords.'<br />';
728     echo get_string('errors', 'admin').': '.$userserrors.'</p>';
729     echo $OUTPUT->box_end();
731     if ($bulk) {
732         echo $OUTPUT->continue_button($bulknurl);
733     } else {
734         echo $OUTPUT->continue_button($returnurl);
735     }
736     echo $OUTPUT->footer();
737     die;
740 // Print the header
741 echo $OUTPUT->header();
743 /// Print the form
745 echo $OUTPUT->heading(get_string('uploaduserspreview', 'admin'));
747 $cir->init();
749 $contents = array();
750 while ($fields = $cir->next()) {
751     $errormsg = array();
752     $rowcols = array();
753     foreach($fields as $key =>$field) {
754         $rowcols[$columns[$key]] = $field;
755     }
757     $usernameexist = $DB->record_exists('user', array('username'=>$rowcols['username']));
758     $emailexist    = $DB->record_exists('user', array('email'=>$rowcols['email']));
759     $cleanusername = clean_param($rowcols['username'], PARAM_USERNAME);
760     $validusername = strcmp($rowcols['username'], $cleanusername);
761     $validemail = validate_email($rowcols['email']);
763     if ($validusername != 0 || !$validemail) {
764         if ($validusername != 0) {
765             $errormsg['username'] = get_string('invalidusernameupload');
766         }
767         if (!$validemail) {
768             $errormsg['email'] = get_string('invalidemail');
769         }
770     }
772     switch($optype) {
773         case UU_ADDNEW:
774             if ($usernameexist || $emailexist ) {
775                $rowcols['action'] = 'skipped';
776             } else {
777                 $rowcols['action'] = 'create';
778             }
779             break;
781         case UU_ADDINC:
782             if (!$usernameexist && !$emailexist) {
783                 $rowcols['action'] = 'create';
784             } else if ($usernameexist && !$emailexist) {
785                 $rowcols['action'] = 'addcountertousername';
786                 $rowcols['username'] = increment_username($rowcols['username'], $CFG->mnet_localhost_id);
787             } else {
788                 $rowcols['action'] = 'skipped';
789             }
790             break;
792         case UU_ADD_UPDATE:
793             $oldusernameexist = '';
794             if (isset($rowcols['oldusername'])) {
795                 $oldusernameexist = $DB->record_exists('user', array('username'=>$rowcols['oldusername']));
796             }
797             if ($usernameexist || $emailexist || $oldusernameexist ) {
798                 $rowcols['action'] = 'update';
799             } else {
800                 $rowcols['action'] = 'create';
801             }
802             break;
804         case UU_UPDATE:
805              $oldusernameexist = '';
806             if (isset($rowcols['oldusername'])) {
807                 $oldusernameexist = $DB->record_exists('user', array('username'=>$rowcols['oldusername']));
808             }
810             if ($usernameexist || $emailexist || !empty($oldusernameexist)) {
811                 $rowcols['action'] = 'update';
812             } else {
813                 $rowcols['action'] = "skipped";
814             }
815             break;
816     }
818     if (!empty($errormsg)){
819         $rowcols['error'] = array();
820         $rowcols['error'] = $errormsg;
821     }
822     if ($rowcols['action'] != 'skipped') {
823         $contents[] = $rowcols;
824     }
826 $cir->close();
828 //get heading
829 $headings = array();
830 foreach ($contents as $content) {
831     foreach($content as $key => $value) {
832         if (!in_array($key, $headings)) {
833             $headings[] = $key;
834         }
835     }
838 $table = new html_table();
839 $table->id = "uupreview";
840 $table->attributes['class'] = 'generaltable';
841 $table->tablealign = 'center';
842 $table->summary = get_string('uploaduserspreview', 'admin');
843 $table->head = array();
844 $table->data = array();
846 //print heading
847 foreach ($headings as $heading) {
848     $table->head[] = s($heading);
851 $haserror = false;
852 $countcontent = 0;
853 if (in_array('error', $headings)) {
854     //print error
855     $haserror = true;
857     foreach ($contents as $content) {
858         if (array_key_exists('error', $content)) {
859             $rows = new html_table_row();
860             foreach ($content as $key => $value) {
861                 $cells = new html_table_cell();
862                 $errclass = '';
863                 if (array_key_exists($key, $content['error'])) {
864                     $errclass = 'uuerror';
865                 }
866                 if ($key == 'error') {
867                     $value = join('<br />', $content['error']);
868                 }
869                 if ($key == 'action') {
870                     $value = get_string($content[$key]);
871                 }
872                 $cells->text = $value;
873                 $cells->attributes['class'] = $errclass;
874                 $rows->cells[] = $cells;
875             }
876             $countcontent++;
877             $table->data[] = $rows;
878         }
879     }
880     $mform = new admin_uploaduser_form3();
881     $mform->set_data(array('uutype'=>$uploadtype));
882 } else if (empty($contents)) {
883     $mform = new admin_uploaduser_form3();
884     $mform->set_data(array('uutype'=>$uploadtype));
885 } else {
886     //print content
887     foreach ($contents as $content) {
888         $rows = new html_table_row();
889         if ($countcontent >= $previewrows) {
890             foreach ($content as $con) {
891                 $cells = new html_table_cell();
892                 $cells->text = '...';
893             }
894             $rows->cells[] = $cells;
895             $table->data[] = $rows;
896             break;
897         }
898         foreach ($headings as $heading) {
899             $cells = new html_table_cell();
900             if(array_key_exists($heading, $content)) {
901                 if ($heading == 'action') {
902                     $content[$heading] = get_string($content[$heading]);
903                 }
904                 $cells->text = $content[$heading];
905             } else {
906                 $cells->text = '';
907             }
908             $rows->cells[] = $cells;
909         }
910         $table->data[] = $rows;
911         $countcontent++;
912     }
914 echo html_writer::table($table);
916 if ($haserror) {
918     echo $OUTPUT->container(get_string('useruploadtype', 'moodle', $choices[$uploadtype]), 'centerpara');
919     echo $OUTPUT->container(get_string('uploadinvalidpreprocessedcount', 'moodle', $countcontent), 'centerpara');
920     echo $OUTPUT->container(get_string('invalidusername', 'moodle'), 'centerpara');
921     echo $OUTPUT->container(get_string('uploadfilecontainerror', 'moodle'), 'centerpara');
922 } else if (empty($contents)) {
923     echo $OUTPUT->container(get_string('uupreprocessedcount', 'admin', $countcontent), 'centerpara');
924     echo $OUTPUT->container(get_string('uploadfilecontentsnovaliddata'), 'centerpara');
925 } else {
926     echo $OUTPUT->container(get_string('uupreprocessedcount', 'admin', $countcontent), 'centerpara');
929 $mform->display();
930 echo $OUTPUT->footer();
931 die;
933 /////////////////////////////////////
934 /// Utility functions and classes ///
935 /////////////////////////////////////
937 class uu_progress_tracker {
938     var $_row;
939     var $columns = array('status', 'line', 'id', 'username', 'firstname', 'lastname', 'email', 'password', 'auth', 'enrolments', 'deleted');
941     function uu_progress_tracker() {
942     }
944     function init() {
945         $ci = 0;
946         echo '<table id="uuresults" class="generaltable boxaligncenter" summary="'.get_string('uploadusersresult', 'admin').'">';
947         echo '<tr class="heading r0">';
948         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('status').'</th>';
949         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('uucsvline', 'admin').'</th>';
950         echo '<th class="header c'.$ci++.'" scope="col">ID</th>';
951         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('username').'</th>';
952         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('firstname').'</th>';
953         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('lastname').'</th>';
954         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('email').'</th>';
955         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('password').'</th>';
956         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('authentication').'</th>';
957         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('enrolments', 'enrol').'</th>';
958         echo '<th class="header c'.$ci++.'" scope="col">'.get_string('delete').'</th>';
959         echo '</tr>';
960         $this->_row = null;
961     }
963     function flush() {
964         if (empty($this->_row) or empty($this->_row['line']['normal'])) {
965             $this->_row = array();
966             foreach ($this->columns as $col) {
967                 $this->_row[$col] = array('normal'=>'', 'info'=>'', 'warning'=>'', 'error'=>'');
968             }
969             return;
970         }
971         $ci = 0;
972         $ri = 1;
973         echo '<tr class="r'.$ri.'">';
974         foreach ($this->_row as $key=>$field) {
975             foreach ($field as $type=>$content) {
976                 if ($field[$type] !== '') {
977                     if ($key == 'username' && $type == 'normal') {
978                         $field[$type] = clean_param($field[$type], PARAM_USERNAME);
979                     }
980                     $field[$type] = '<span class="uu'.$type.'">'.$field[$type].'</span>';
981                 } else {
982                     unset($field[$type]);
983                 }
984             }
985             echo '<td class="cell c'.$ci++.'">';
986             if (!empty($field)) {
987                 echo implode('<br />', $field);
988             } else {
989                 echo '&nbsp;';
990             }
991             echo '</td>';
992         }
993         echo '</tr>';
994         foreach ($this->columns as $col) {
995             $this->_row[$col] = array('normal'=>'', 'info'=>'', 'warning'=>'', 'error'=>'');
996         }
997     }
999     function track($col, $msg, $level='normal', $merge=true) {
1000         if (empty($this->_row)) {
1001             $this->flush(); //init arrays
1002         }
1003         if (!in_array($col, $this->columns)) {
1004             debugging('Incorrect column:'.$col);
1005             return;
1006         }
1007         if ($merge) {
1008             if ($this->_row[$col][$level] != '') {
1009                 $this->_row[$col][$level] .='<br />';
1010             }
1011             $this->_row[$col][$level] .= s($msg);
1012         } else {
1013             $this->_row[$col][$level] = s($msg);
1014         }
1015     }
1017     function close() {
1018         echo '</table>';
1019     }
1022 /**
1023  * Validation callback function - verified the column line of csv file.
1024  * Converts column names to lowercase too.
1025  */
1026 function validate_user_upload_columns(&$columns) {
1027     global $STD_FIELDS, $PRF_FIELDS;
1029     if (count($columns) < 2) {
1030         return get_string('csvfewcolumns', 'error');
1031     }
1033     // test columns
1034     $processed = array();
1035     foreach ($columns as $key=>$unused) {
1036         $columns[$key] = strtolower($columns[$key]); // no unicode expected here, ignore case
1037         $field = $columns[$key];
1038         if (!in_array($field, $STD_FIELDS) && !in_array($field, $PRF_FIELDS) &&// if not a standard field and not an enrolment field, then we have an error
1039             !preg_match('/^course\d+$/', $field) && !preg_match('/^group\d+$/', $field) &&
1040             !preg_match('/^type\d+$/', $field) && !preg_match('/^role\d+$/', $field) &&
1041             !preg_match('/^enrolperiod\d+$/', $field)) {
1042             return get_string('invalidfieldname', 'error', $field);
1043         }
1044         if (in_array($field, $processed)) {
1045             return get_string('csvcolumnduplicates', 'error');
1046         }
1047         $processed[] = $field;
1048     }
1049     return true;
1052 /**
1053  * Increments username - increments trailing number or adds it if not present.
1054  * Varifies that the new username does not exist yet
1055  * @param string $username
1056  * @return incremented username which does not exist yet
1057  */
1058 function increment_username($username, $mnethostid) {
1059     global $DB;
1061     if (!preg_match_all('/(.*?)([0-9]+)$/', $username, $matches)) {
1062         $username = $username.'2';
1063     } else {
1064         $username = $matches[1][0].($matches[2][0]+1);
1065     }
1067     if ($DB->record_exists('user', array('username'=>$username, 'mnethostid'=>$mnethostid))) {
1068         return increment_username($username, $mnethostid);
1069     } else {
1070         return $username;
1071     }
1074 /**
1075  * Check if default field contains templates and apply them.
1076  * @param string template - potential tempalte string
1077  * @param object user object- we need username, firstname and lastname
1078  * @return string field value
1079  */
1080 function process_template($template, $user) {
1081     if (strpos($template, '%') === false) {
1082         return $template;
1083     }
1085     // very very ugly hack!
1086     global $template_globals;
1087     $template_globals = new stdClass();
1088     $template_globals->username  = isset($user->username)  ? $user->username  : '';
1089     $template_globals->firstname = isset($user->firstname) ? $user->firstname : '';
1090     $template_globals->lastname  = isset($user->lastname)  ? $user->lastname  : '';
1092     $result = preg_replace_callback('/(?<!%)%([+-~])?(\d)*([flu])/', 'process_template_callback', $template);
1094     $template_globals = null;
1096     if (is_null($result)) {
1097         return $template; //error during regex processing??
1098     } else {
1099         return $result;
1100     }
1103 /**
1104  * Internal callback function.
1105  */
1106 function process_template_callback($block) {
1107     global $template_globals;
1108     $textlib = textlib_get_instance();
1109     $repl = $block[0];
1111     switch ($block[3]) {
1112         case 'u': $repl = $template_globals->username; break;
1113         case 'f': $repl = $template_globals->firstname; break;
1114         case 'l': $repl = $template_globals->lastname; break;
1115     }
1116     switch ($block[1]) {
1117         case '+': $repl = $textlib->strtoupper($repl); break;
1118         case '-': $repl = $textlib->strtolower($repl); break;
1119         case '~': $repl = $textlib->strtotitle($repl); break;
1120     }
1121     if (!empty($block[2])) {
1122         $repl = $textlib->substr($repl, 0 , $block[2]);
1123     }
1125     return $repl;
1128 /**
1129  * Returns list of auth plugins that are enabled and known to work.
1130  */
1131 function uu_allowed_auths() {
1132     global $CFG;
1134     // only following plugins are guaranteed to work properly
1135     // TODO: add support for more plugins in 2.0
1136     $whitelist = array('manual', 'nologin', 'none', 'email');
1137     $plugins = get_enabled_auth_plugins();
1138     $choices = array();
1139     foreach ($plugins as $plugin) {
1140         $choices[$plugin] = get_string('pluginname', "auth_{$plugin}");
1141     }
1143     return $choices;
1146 /**
1147  * Returns list of roles that are assignable in courses
1148  */
1149 function uu_allowed_roles() {
1150     // let's cheat a bit, frontpage is guaranteed to exist and has the same list of roles ;-)
1151     $roles = get_assignable_roles(get_context_instance(CONTEXT_COURSE, SITEID), ROLENAME_ORIGINALANDSHORT);
1152     return array_reverse($roles, true);
1155 function uu_allowed_roles_cache() {
1156     $allowedroles = get_assignable_roles(get_context_instance(CONTEXT_COURSE, SITEID), ROLENAME_SHORT);
1157     foreach ($allowedroles as $rid=>$rname) {
1158         $rolecache[$rid] = new stdClass();
1159         $rolecache[$rid]->id   = $rid;
1160         $rolecache[$rid]->name = $rname;
1161         if (!is_numeric($rname)) { // only non-numeric shortnames are supported!!!
1162             $rolecache[$rname] = new stdClass();
1163             $rolecache[$rname]->id   = $rid;
1164             $rolecache[$rname]->name = $rname;
1165         }
1166     }
1167     return $rolecache;