[Summary view]

   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   * Flatfile enrolment plugin.
  19   *
  20   * This plugin lets the user specify a "flatfile" (CSV) containing enrolment information.
  21   * On a regular cron cycle, the specified file is parsed and then deleted.
  22   *
  23   * @package    enrol_flatfile
  24   * @copyright  2010 Eugene Venter
  25   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26   */
  27  
  28  defined('MOODLE_INTERNAL') || die();
  29  
  30  
  31  /**
  32   * Flatfile enrolment plugin implementation.
  33   *
  34   * Comma separated file assumed to have four or six fields per line:
  35   *   operation, role, idnumber(user), idnumber(course) [, starttime [, endtime]]
  36   * where:
  37   *   operation        = add | del
  38   *   role             = student | teacher | teacheredit
  39   *   idnumber(user)   = idnumber in the user table NB not id
  40   *   idnumber(course) = idnumber in the course table NB not id
  41   *   starttime        = start time (in seconds since epoch) - optional
  42   *   endtime          = end time (in seconds since epoch) - optional
  43   *
  44   * @author  Eugene Venter - based on code by Petr Skoda, Martin Dougiamas, Martin Langhoff and others
  45   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  46   */
  47  class enrol_flatfile_plugin extends enrol_plugin {
  48      protected $lasternoller = null;
  49      protected $lasternollercourseid = 0;
  50  
  51      /**
  52       * Does this plugin assign protected roles are can they be manually removed?
  53       * @return bool - false means anybody may tweak roles, it does not use itemid and component when assigning roles
  54       */
  55      public function roles_protected() {
  56          return false;
  57      }
  58  
  59      /**
  60       * Does this plugin allow manual unenrolment of all users?
  61       * All plugins allowing this must implement 'enrol/xxx:unenrol' capability
  62       *
  63       * @param stdClass $instance course enrol instance
  64       * @return bool - true means user with 'enrol/xxx:unenrol' may unenrol others freely, false means nobody may touch user_enrolments
  65       */
  66      public function allow_unenrol(stdClass $instance) {
  67          return true;
  68      }
  69  
  70      /**
  71       * Does this plugin allow manual unenrolment of a specific user?
  72       * All plugins allowing this must implement 'enrol/xxx:unenrol' capability
  73       *
  74       * This is useful especially for synchronisation plugins that
  75       * do suspend instead of full unenrolment.
  76       *
  77       * @param stdClass $instance course enrol instance
  78       * @param stdClass $ue record from user_enrolments table, specifies user
  79       *
  80       * @return bool - true means user with 'enrol/xxx:unenrol' may unenrol this user, false means nobody may touch this user enrolment
  81       */
  82      public function allow_unenrol_user(stdClass $instance, stdClass $ue) {
  83          return true;
  84      }
  85  
  86      /**
  87       * Does this plugin allow manual changes in user_enrolments table?
  88       *
  89       * All plugins allowing this must implement 'enrol/xxx:manage' capability
  90       *
  91       * @param stdClass $instance course enrol instance
  92       * @return bool - true means it is possible to change enrol period and status in user_enrolments table
  93       */
  94      public function allow_manage(stdClass $instance) {
  95          return true;
  96      }
  97  
  98      /**
  99       * Is it possible to delete enrol instance via standard UI?
 100       *
 101       * @param object $instance
 102       * @return bool
 103       */
 104      public function can_delete_instance($instance) {
 105          $context = context_course::instance($instance->courseid);
 106          return has_capability('enrol/flatfile:manage', $context);
 107      }
 108  
 109      /**
 110       * Is it possible to hide/show enrol instance via standard UI?
 111       *
 112       * @param stdClass $instance
 113       * @return bool
 114       */
 115      public function can_hide_show_instance($instance) {
 116          $context = context_course::instance($instance->courseid);
 117          return has_capability('enrol/flatfile:manage', $context);
 118      }
 119  
 120      /**
 121       * Enrol user into course via enrol instance.
 122       *
 123       * @param stdClass $instance
 124       * @param int $userid
 125       * @param int $roleid optional role id
 126       * @param int $timestart 0 means unknown
 127       * @param int $timeend 0 means forever
 128       * @param int $status default to ENROL_USER_ACTIVE for new enrolments, no change by default in updates
 129       * @param bool $recovergrades restore grade history
 130       * @return void
 131       */
 132      public function enrol_user(stdClass $instance, $userid, $roleid = null, $timestart = 0, $timeend = 0, $status = null, $recovergrades = null) {
 133          parent::enrol_user($instance, $userid, null, $timestart, $timeend, $status, $recovergrades);
 134          if ($roleid) {
 135              $context = context_course::instance($instance->courseid, MUST_EXIST);
 136              role_assign($roleid, $userid, $context->id, 'enrol_'.$this->get_name(), $instance->id);
 137          }
 138      }
 139  
 140      /**
 141       * Execute synchronisation.
 142       * @param progress_trace
 143       * @return int exit code, 0 means ok, 2 means plugin disabled
 144       */
 145      public function sync(progress_trace $trace) {
 146          if (!enrol_is_enabled('flatfile')) {
 147              return 2;
 148          }
 149  
 150          $mailadmins = $this->get_config('mailadmins', 0);
 151  
 152          if ($mailadmins) {
 153              $buffer = new progress_trace_buffer(new text_progress_trace(), false);
 154              $trace = new combined_progress_trace(array($trace, $buffer));
 155          }
 156  
 157          $processed = false;
 158  
 159          $processed = $this->process_file($trace) || $processed;
 160          $processed = $this->process_buffer($trace) || $processed;
 161          $processed = $this->process_expirations($trace) || $processed;
 162  
 163          if ($processed and $mailadmins) {
 164              if ($log = $buffer->get_buffer()) {
 165                  $eventdata = new \core\message\message();
 166                  $eventdata->courseid          = SITEID;
 167                  $eventdata->modulename        = 'moodle';
 168                  $eventdata->component         = 'enrol_flatfile';
 169                  $eventdata->name              = 'flatfile_enrolment';
 170                  $eventdata->userfrom          = get_admin();
 171                  $eventdata->userto            = get_admin();
 172                  $eventdata->subject           = 'Flatfile Enrolment Log';
 173                  $eventdata->fullmessage       = $log;
 174                  $eventdata->fullmessageformat = FORMAT_PLAIN;
 175                  $eventdata->fullmessagehtml   = '';
 176                  $eventdata->smallmessage      = '';
 177                  message_send($eventdata);
 178              }
 179              $buffer->reset_buffer();
 180          }
 181  
 182          return 0;
 183      }
 184  
 185      /**
 186       * Sorry, we do not want to show paths in cron output.
 187       *
 188       * @param string $filepath
 189       * @return string
 190       */
 191      protected function obfuscate_filepath($filepath) {
 192          global $CFG;
 193  
 194          if (strpos($filepath, $CFG->dataroot.'/') === 0 or strpos($filepath, $CFG->dataroot.'\\') === 0) {
 195              $disclosefile = '$CFG->dataroot'.substr($filepath, strlen($CFG->dataroot));
 196  
 197          } else if (strpos($filepath, $CFG->dirroot.'/') === 0 or strpos($filepath, $CFG->dirroot.'\\') === 0) {
 198              $disclosefile = '$CFG->dirroot'.substr($filepath, strlen($CFG->dirroot));
 199  
 200          } else {
 201              $disclosefile = basename($filepath);
 202          }
 203  
 204          return $disclosefile;
 205      }
 206  
 207      /**
 208       * Process flatfile.
 209       * @param progress_trace $trace
 210       * @return bool true if any data processed, false if not
 211       */
 212      protected function process_file(progress_trace $trace) {
 213          global $CFG, $DB;
 214  
 215          // We may need more memory here.
 216          core_php_time_limit::raise();
 217          raise_memory_limit(MEMORY_HUGE);
 218  
 219          $filelocation = $this->get_config('location');
 220          if (empty($filelocation)) {
 221              // Default legacy location.
 222              $filelocation = "$CFG->dataroot/1/enrolments.txt";
 223          }
 224          $disclosefile = $this->obfuscate_filepath($filelocation);
 225  
 226          if (!file_exists($filelocation)) {
 227              $trace->output("Flatfile enrolments file not found: $disclosefile");
 228              $trace->finished();
 229              return false;
 230          }
 231          $trace->output("Processing flat file enrolments from: $disclosefile ...");
 232  
 233          $content = file_get_contents($filelocation);
 234  
 235          if ($content !== false) {
 236  
 237              $rolemap = $this->get_role_map($trace);
 238  
 239              $content = core_text::convert($content, $this->get_config('encoding', 'utf-8'), 'utf-8');
 240              $content = str_replace("\r", '', $content);
 241              $content = explode("\n", $content);
 242  
 243              $line = 0;
 244              foreach($content as $fields) {
 245                  $line++;
 246  
 247                  if (trim($fields) === '') {
 248                      // Empty lines are ignored.
 249                      continue;
 250                  }
 251  
 252                  // Deal with different separators.
 253                  if (strpos($fields, ',') !== false) {
 254                      $fields = explode(',', $fields);
 255                  } else {
 256                      $fields = explode(';', $fields);
 257                  }
 258  
 259                  // If a line is incorrectly formatted ie does not have 4 comma separated fields then ignore it.
 260                  if (count($fields) < 4 or count($fields) > 6) {
 261                      $trace->output("Line incorrectly formatted - ignoring $line", 1);
 262                      continue;
 263                  }
 264  
 265                  $fields[0] = trim(core_text::strtolower($fields[0]));
 266                  $fields[1] = trim(core_text::strtolower($fields[1]));
 267                  $fields[2] = trim($fields[2]);
 268                  $fields[3] = trim($fields[3]);
 269                  $fields[4] = isset($fields[4]) ? (int)trim($fields[4]) : 0;
 270                  $fields[5] = isset($fields[5]) ? (int)trim($fields[5]) : 0;
 271  
 272                  // Deal with quoted values - all or nothing, we need to support "' in idnumbers, sorry.
 273                  if (strpos($fields[0], "'") === 0) {
 274                      foreach ($fields as $k=>$v) {
 275                          $fields[$k] = trim($v, "'");
 276                      }
 277                  } else if (strpos($fields[0], '"') === 0) {
 278                      foreach ($fields as $k=>$v) {
 279                          $fields[$k] = trim($v, '"');
 280                      }
 281                  }
 282  
 283                  $trace->output("$line: $fields[0], $fields[1], $fields[2], $fields[3], $fields[4], $fields[5]", 1);
 284  
 285                  // Check correct formatting of operation field.
 286                  if ($fields[0] !== "add" and $fields[0] !== "del") {
 287                      $trace->output("Unknown operation in field 1 - ignoring line $line", 1);
 288                      continue;
 289                  }
 290  
 291                  // Check correct formatting of role field.
 292                  if (!isset($rolemap[$fields[1]])) {
 293                      $trace->output("Unknown role in field2 - ignoring line $line", 1);
 294                      continue;
 295                  }
 296                  $roleid = $rolemap[$fields[1]];
 297  
 298                  if (empty($fields[2]) or !$user = $DB->get_record("user", array("idnumber"=>$fields[2], 'deleted'=>0))) {
 299                      $trace->output("Unknown user idnumber or deleted user in field 3 - ignoring line $line", 1);
 300                      continue;
 301                  }
 302  
 303                  if (!$course = $DB->get_record("course", array("idnumber"=>$fields[3]))) {
 304                      $trace->output("Unknown course idnumber in field 4 - ignoring line $line", 1);
 305                      continue;
 306                  }
 307  
 308                  if ($fields[4] > $fields[5] and $fields[5] != 0) {
 309                      $trace->output("Start time was later than end time - ignoring line $line", 1);
 310                      continue;
 311                  }
 312  
 313                  $this->process_records($trace, $fields[0], $roleid, $user, $course, $fields[4], $fields[5]);
 314              }
 315  
 316              unset($content);
 317          }
 318  
 319          if (!unlink($filelocation)) {
 320              $eventdata = new \core\message\message();
 321              $eventdata->courseid          = SITEID;
 322              $eventdata->modulename        = 'moodle';
 323              $eventdata->component         = 'enrol_flatfile';
 324              $eventdata->name              = 'flatfile_enrolment';
 325              $eventdata->userfrom          = get_admin();
 326              $eventdata->userto            = get_admin();
 327              $eventdata->subject           = get_string('filelockedmailsubject', 'enrol_flatfile');
 328              $eventdata->fullmessage       = get_string('filelockedmail', 'enrol_flatfile', $filelocation);
 329              $eventdata->fullmessageformat = FORMAT_PLAIN;
 330              $eventdata->fullmessagehtml   = '';
 331              $eventdata->smallmessage      = '';
 332              message_send($eventdata);
 333              $trace->output("Error deleting enrolment file: $disclosefile", 1);
 334          } else {
 335              $trace->output("Deleted enrolment file", 1);
 336          }
 337  
 338          $trace->output("...finished enrolment file processing.");
 339          $trace->finished();
 340  
 341          return true;
 342      }
 343  
 344      /**
 345       * Process any future enrollments stored in the buffer.
 346       * @param progress_trace $trace
 347       * @return bool true if any data processed, false if not
 348       */
 349      protected function process_buffer(progress_trace $trace) {
 350          global $DB;
 351  
 352          if (!$future_enrols = $DB->get_records_select('enrol_flatfile', "timestart < ?", array(time()))) {
 353              $trace->output("No enrolments to be processed in flatfile buffer");
 354              $trace->finished();
 355              return false;
 356          }
 357  
 358          $trace->output("Starting processing of flatfile buffer");
 359          foreach($future_enrols as $en) {
 360              $user = $DB->get_record('user', array('id'=>$en->userid));
 361              $course = $DB->get_record('course', array('id'=>$en->courseid));
 362              if ($user and $course) {
 363                  $trace->output("buffer: $en->action $en->roleid $user->id $course->id $en->timestart $en->timeend", 1);
 364                  $this->process_records($trace, $en->action, $en->roleid, $user, $course, $en->timestart, $en->timeend, false);
 365              }
 366              $DB->delete_records('enrol_flatfile', array('id'=>$en->id));
 367          }
 368          $trace->output("Finished processing of flatfile buffer");
 369          $trace->finished();
 370  
 371          return true;
 372      }
 373  
 374      /**
 375       * Process user enrolment line.
 376       *
 377       * @param progress_trace $trace
 378       * @param string $action
 379       * @param int $roleid
 380       * @param stdClass $user
 381       * @param stdClass $course
 382       * @param int $timestart
 383       * @param int $timeend
 384       * @param bool $buffer_if_future
 385       */
 386      protected function process_records(progress_trace $trace, $action, $roleid, $user, $course, $timestart, $timeend, $buffer_if_future = true) {
 387          global $CFG, $DB;
 388  
 389          // Check if timestart is for future processing.
 390          if ($timestart > time() and $buffer_if_future) {
 391              // Populate into enrol_flatfile table as a future role to be assigned by cron.
 392              // Note: since 2.0 future enrolments do not cause problems if you disable guest access.
 393              $future_en = new stdClass();
 394              $future_en->action       = $action;
 395              $future_en->roleid       = $roleid;
 396              $future_en->userid       = $user->id;
 397              $future_en->courseid     = $course->id;
 398              $future_en->timestart    = $timestart;
 399              $future_en->timeend      = $timeend;
 400              $future_en->timemodified = time();
 401              $DB->insert_record('enrol_flatfile', $future_en);
 402              $trace->output("User $user->id will be enrolled later into course $course->id using role $roleid ($timestart, $timeend)", 1);
 403              return;
 404          }
 405  
 406          $context = context_course::instance($course->id);
 407  
 408          if ($action === 'add') {
 409              // Clear the buffer just in case there were some future enrolments.
 410              $DB->delete_records('enrol_flatfile', array('userid'=>$user->id, 'courseid'=>$course->id, 'roleid'=>$roleid));
 411  
 412              $instance = $DB->get_record('enrol', array('courseid' => $course->id, 'enrol' => 'flatfile'));
 413              if (empty($instance)) {
 414                  // Only add an enrol instance to the course if non-existent.
 415                  $enrolid = $this->add_instance($course);
 416                  $instance = $DB->get_record('enrol', array('id' => $enrolid));
 417              }
 418  
 419              $notify = false;
 420              if ($ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$user->id))) {
 421                  // Update only.
 422                  $this->update_user_enrol($instance, $user->id, ENROL_USER_ACTIVE, $timestart, $timeend);
 423                  if (!$DB->record_exists('role_assignments', array('contextid'=>$context->id, 'roleid'=>$roleid, 'userid'=>$user->id, 'component'=>'enrol_flatfile', 'itemid'=>$instance->id))) {
 424                      role_assign($roleid, $user->id, $context->id, 'enrol_flatfile', $instance->id);
 425                  }
 426                  $trace->output("User $user->id enrolment updated in course $course->id using role $roleid ($timestart, $timeend)", 1);
 427  
 428              } else {
 429                  // Enrol the user with this plugin instance.
 430                  $this->enrol_user($instance, $user->id, $roleid, $timestart, $timeend);
 431                  $trace->output("User $user->id enrolled in course $course->id using role $roleid ($timestart, $timeend)", 1);
 432                  $notify = true;
 433              }
 434  
 435              if ($notify and $this->get_config('mailstudents')) {
 436                  $oldforcelang = force_current_language($user->lang);
 437  
 438                  // Send welcome notification to enrolled users.
 439                  $a = new stdClass();
 440                  $a->coursename = format_string($course->fullname, true, array('context' => $context));
 441                  $a->profileurl = "$CFG->wwwroot/user/view.php?id=$user->id&amp;course=$course->id";
 442                  $subject = get_string('enrolmentnew', 'enrol', format_string($course->shortname, true, array('context' => $context)));
 443  
 444                  $eventdata = new \core\message\message();
 445                  $eventdata->courseid          = $course->id;
 446                  $eventdata->modulename        = 'moodle';
 447                  $eventdata->component         = 'enrol_flatfile';
 448                  $eventdata->name              = 'flatfile_enrolment';
 449                  $eventdata->userfrom          = $this->get_enroller($course->id);
 450                  $eventdata->userto            = $user;
 451                  $eventdata->subject           = $subject;
 452                  $eventdata->fullmessage       = get_string('welcometocoursetext', '', $a);
 453                  $eventdata->fullmessageformat = FORMAT_PLAIN;
 454                  $eventdata->fullmessagehtml   = '';
 455                  $eventdata->smallmessage      = '';
 456                  if (message_send($eventdata)) {
 457                      $trace->output("Notified enrolled user", 1);
 458                  } else {
 459                      $trace->output("Failed to notify enrolled user", 1);
 460                  }
 461  
 462                  force_current_language($oldforcelang);
 463              }
 464  
 465              if ($notify and $this->get_config('mailteachers', 0)) {
 466                  // Notify person responsible for enrolments.
 467                  $enroller = $this->get_enroller($course->id);
 468  
 469                  $oldforcelang = force_current_language($enroller->lang);
 470  
 471                  $a = new stdClass();
 472                  $a->course = format_string($course->fullname, true, array('context' => $context));
 473                  $a->user = fullname($user);
 474                  $subject = get_string('enrolmentnew', 'enrol', format_string($course->shortname, true, array('context' => $context)));
 475  
 476                  $eventdata = new \core\message\message();
 477                  $eventdata->courseid          = $course->id;
 478                  $eventdata->modulename        = 'moodle';
 479                  $eventdata->component         = 'enrol_flatfile';
 480                  $eventdata->name              = 'flatfile_enrolment';
 481                  $eventdata->userfrom          = get_admin();
 482                  $eventdata->userto            = $enroller;
 483                  $eventdata->subject           = $subject;
 484                  $eventdata->fullmessage       = get_string('enrolmentnewuser', 'enrol', $a);
 485                  $eventdata->fullmessageformat = FORMAT_PLAIN;
 486                  $eventdata->fullmessagehtml   = '';
 487                  $eventdata->smallmessage      = '';
 488                  if (message_send($eventdata)) {
 489                      $trace->output("Notified enroller {$eventdata->userto->id}", 1);
 490                  } else {
 491                      $trace->output("Failed to notify enroller {$eventdata->userto->id}", 1);
 492                  }
 493  
 494                  force_current_language($oldforcelang);
 495              }
 496              return;
 497  
 498          } else if ($action === 'del') {
 499              // Clear the buffer just in case there were some future enrolments.
 500              $DB->delete_records('enrol_flatfile', array('userid'=>$user->id, 'courseid'=>$course->id, 'roleid'=>$roleid));
 501  
 502              $action = $this->get_config('unenrolaction');
 503              if ($action == ENROL_EXT_REMOVED_KEEP) {
 504                  $trace->output("del action is ignored", 1);
 505                  return;
 506              }
 507  
 508              // Loops through all enrolment methods, try to unenrol if roleid somehow matches.
 509              $instances = $DB->get_records('enrol', array('courseid' => $course->id));
 510              $unenrolled = false;
 511              foreach ($instances as $instance) {
 512                  if (!$ue = $DB->get_record('user_enrolments', array('enrolid'=>$instance->id, 'userid'=>$user->id))) {
 513                      continue;
 514                  }
 515                  if ($instance->enrol === 'flatfile') {
 516                      $plugin = $this;
 517                  } else {
 518                      if (!enrol_is_enabled($instance->enrol)) {
 519                          continue;
 520                      }
 521                      if (!$plugin = enrol_get_plugin($instance->enrol)) {
 522                          continue;
 523                      }
 524                      if (!$plugin->allow_unenrol_user($instance, $ue)) {
 525                          continue;
 526                      }
 527                  }
 528  
 529                  // For some reason the del action includes a role name, this complicates everything.
 530                  $componentroles = array();
 531                  $manualroles = array();
 532                  $ras = $DB->get_records('role_assignments', array('userid'=>$user->id, 'contextid'=>$context->id));
 533                  foreach ($ras as $ra) {
 534                      if ($ra->component === '') {
 535                          $manualroles[$ra->roleid] = $ra->roleid;
 536                      } else if ($ra->component === 'enrol_'.$instance->enrol and $ra->itemid == $instance->id) {
 537                          $componentroles[$ra->roleid] = $ra->roleid;
 538                      }
 539                  }
 540  
 541                  if ($componentroles and !isset($componentroles[$roleid])) {
 542                      // Do not unenrol using this method, user has some other protected role!
 543                      continue;
 544  
 545                  } else if (empty($ras)) {
 546                      // If user does not have any roles then let's just suspend as many methods as possible.
 547  
 548                  } else if (!$plugin->roles_protected()) {
 549                      if (!$componentroles and $manualroles and !isset($manualroles[$roleid])) {
 550                          // Most likely we want to keep users enrolled because they have some other course roles.
 551                          continue;
 552                      }
 553                  }
 554  
 555                  if ($action == ENROL_EXT_REMOVED_UNENROL) {
 556                      $unenrolled = true;
 557                      if (!$plugin->roles_protected()) {
 558                          role_unassign_all(array('contextid'=>$context->id, 'userid'=>$user->id, 'roleid'=>$roleid, 'component'=>'', 'itemid'=>0), true);
 559                      }
 560                      $plugin->unenrol_user($instance, $user->id);
 561                      $trace->output("User $user->id was unenrolled from course $course->id (enrol_$instance->enrol)", 1);
 562  
 563                  } else if ($action == ENROL_EXT_REMOVED_SUSPENDNOROLES) {
 564                      if ($plugin->allow_manage($instance)) {
 565                          if ($ue->status == ENROL_USER_ACTIVE) {
 566                              $unenrolled = true;
 567                              $plugin->update_user_enrol($instance, $user->id, ENROL_USER_SUSPENDED);
 568                              if (!$plugin->roles_protected()) {
 569                                  role_unassign_all(array('contextid'=>$context->id, 'userid'=>$user->id, 'component'=>'enrol_'.$instance->enrol, 'itemid'=>$instance->id), true);
 570                                  role_unassign_all(array('contextid'=>$context->id, 'userid'=>$user->id, 'roleid'=>$roleid, 'component'=>'', 'itemid'=>0), true);
 571                              }
 572                              $trace->output("User $user->id enrolment was suspended in course $course->id (enrol_$instance->enrol)", 1);
 573                          }
 574                      }
 575                  }
 576              }
 577  
 578              if (!$unenrolled) {
 579                  if (0 == $DB->count_records('role_assignments', array('userid'=>$user->id, 'contextid'=>$context->id))) {
 580                      role_unassign_all(array('contextid'=>$context->id, 'userid'=>$user->id, 'component'=>'', 'itemid'=>0), true);
 581                  }
 582                  $trace->output("User $user->id (with role $roleid) not unenrolled from course $course->id", 1);
 583              }
 584  
 585              return;
 586          }
 587      }
 588  
 589      /**
 590       * Returns the user who is responsible for flatfile enrolments in given curse.
 591       *
 592       * Usually it is the first editing teacher - the person with "highest authority"
 593       * as defined by sort_by_roleassignment_authority() having 'enrol/flatfile:manage'
 594       * or 'moodle/role:assign' capability.
 595       *
 596       * @param int $courseid enrolment instance id
 597       * @return stdClass user record
 598       */
 599      protected function get_enroller($courseid) {
 600          if ($this->lasternollercourseid == $courseid and $this->lasternoller) {
 601              return $this->lasternoller;
 602          }
 603  
 604          $context = context_course::instance($courseid);
 605  
 606          $users = get_enrolled_users($context, 'enrol/flatfile:manage');
 607          if (!$users) {
 608              $users = get_enrolled_users($context, 'moodle/role:assign');
 609          }
 610  
 611          if ($users) {
 612              $users = sort_by_roleassignment_authority($users, $context);
 613              $this->lasternoller = reset($users);
 614              unset($users);
 615          } else {
 616              $this->lasternoller = get_admin();
 617          }
 618  
 619          $this->lasternollercourseid == $courseid;
 620  
 621          return $this->lasternoller;
 622      }
 623  
 624      /**
 625       * Returns a mapping of ims roles to role ids.
 626       *
 627       * @param progress_trace $trace
 628       * @return array imsrolename=>roleid
 629       */
 630      protected function get_role_map(progress_trace $trace) {
 631          global $DB;
 632  
 633          // Get all roles.
 634          $rolemap = array();
 635          $roles = $DB->get_records('role', null, '', 'id, name, shortname');
 636          foreach ($roles as $id=>$role) {
 637              $alias = $this->get_config('map_'.$id, $role->shortname, '');
 638              $alias = trim(core_text::strtolower($alias));
 639              if ($alias === '') {
 640                  // Either not configured yet or somebody wants to skip these intentionally.
 641                  continue;
 642              }
 643              if (isset($rolemap[$alias])) {
 644                  $trace->output("Duplicate role alias $alias detected!");
 645              } else {
 646                  $rolemap[$alias] = $id;
 647              }
 648          }
 649  
 650          return $rolemap;
 651      }
 652  
 653      /**
 654       * Restore instance and map settings.
 655       *
 656       * @param restore_enrolments_structure_step $step
 657       * @param stdClass $data
 658       * @param stdClass $course
 659       * @param int $oldid
 660       */
 661      public function restore_instance(restore_enrolments_structure_step $step, stdClass $data, $course, $oldid) {
 662          global $DB;
 663  
 664          if ($instance = $DB->get_record('enrol', array('courseid'=>$course->id, 'enrol'=>$this->get_name()))) {
 665              $instanceid = $instance->id;
 666          } else {
 667              $instanceid = $this->add_instance($course);
 668          }
 669          $step->set_mapping('enrol', $oldid, $instanceid);
 670      }
 671  
 672      /**
 673       * Restore user enrolment.
 674       *
 675       * @param restore_enrolments_structure_step $step
 676       * @param stdClass $data
 677       * @param stdClass $instance
 678       * @param int $oldinstancestatus
 679       * @param int $userid
 680       */
 681      public function restore_user_enrolment(restore_enrolments_structure_step $step, $data, $instance, $userid, $oldinstancestatus) {
 682          $this->enrol_user($instance, $userid, null, $data->timestart, $data->timeend, $data->status);
 683      }
 684  
 685      /**
 686       * Restore role assignment.
 687       *
 688       * @param stdClass $instance
 689       * @param int $roleid
 690       * @param int $userid
 691       * @param int $contextid
 692       */
 693      public function restore_role_assignment($instance, $roleid, $userid, $contextid) {
 694          role_assign($roleid, $userid, $contextid, 'enrol_'.$instance->enrol, $instance->id);
 695      }
 696  }