public function get_content()
 {
     global $COURSE, $USER;
     if ($this->content !== null) {
         return $this->content;
     }
     $this->content = new stdClass();
     $this->content->text = var_export($this->context, true);
     $coursecontext = context_course::instance($COURSE->id);
     if (has_capability('block/demostudent:addinstance', $coursecontext)) {
         // If DemoStudent has not yet been enrolled, allow user to create/enrol one.
         $demostudentusername = generate_demostudent_name($USER->username);
         $demostudentuser = get_complete_user_data('username', $demostudentusername);
         if (!$demostudentuser || !is_enrolled($coursecontext, $demostudentuser)) {
             $this->render_view('firstuse');
         } else {
             $this->render_view('instructor');
         }
     } else {
         if (has_capability('block/demostudent:seedemostudentblock', $coursecontext)) {
             $this->render_view('demostudent');
         } else {
             // If the user does not need to see the block, do not display it at all.
             $this->content->text = '';
             $this->content->footer = '';
         }
     }
     return $this->content;
 }

/**
 * Add a "Compile" menu link to the Course Admin block as the top link.
 *
 * @author Gerald Albion
 * date 2014-10-31
 * @copyright 2014 Royal Roads University
 * @param object $settingsnav Main navigation object.
 * @param object $context Course context.
 */
function local_compile_extends_settings_navigation($settingsnav, $context)
{
    // Context must be course.
    if ($context->contextlevel != CONTEXT_COURSE) {
        return;
    }
    // Must be in a valid course: Cannot be course id 0.
    if ($context->instanceid == 0) {
        return;
    }
    // Must be in a valid course: Course must be retrievable.
    if (!($course = get_course($context->instanceid))) {
        return;
    }
    // Must be enrolled or otherwise allowed to view the course.
    if (!(is_enrolled($context) || is_viewing($context))) {
        return;
    }
    // Must have a course admin menu in which to add link.
    if (!($coursenode = $settingsnav->find('courseadmin', navigation_node::TYPE_COURSE))) {
        return;
    }
    // Good to go.  Build the menu item.
    $url = new moodle_url('/local/compile/list_modules.php', array('id' => $course->id));
    $newnode = navigation_node::create(get_string('menucaption', 'local_compile'), $url, navigation_node::NODETYPE_LEAF, 'compile', 'compile', new pix_icon('i/settings', ''));
    // We want to put this link at the top: find the existing top (first) node.
    $firstnode = $coursenode->get_children_key_list()[0];
    // Add the menu item to the menu, before the first node.
    $coursenode->add_node($newnode, $firstnode);
}

 /**
  * Return information about this specific context level
  *
  * @param $component
  * @param $filearea
  * @param $itemid
  * @param $filepath
  * @param $filename
  */
 public function get_file_info($component, $filearea, $itemid, $filepath, $filename)
 {
     if (!is_enrolled($this->context) and !is_viewing($this->context)) {
         // no peaking here if not enrolled or inspector
         return null;
     }
     if (empty($component)) {
         return $this;
     }
     if ($component == 'mod_' . $this->modname and $filearea === 'intro') {
         return $this->get_area_intro($itemid, $filepath, $filename);
     } else {
         if ($component == 'backup' and $filearea === 'activity') {
             return $this->get_area_backup($itemid, $filepath, $filename);
         }
     }
     $functionname = 'mod_' . $this->modname . '_get_file_info';
     $functionname_old = $this->modname . '_get_file_info';
     if (function_exists($functionname)) {
         return $functionname($this->browser, $this->areas, $this->course, $this->cm, $this->context, $filearea, $itemid, $filepath, $filename);
     } else {
         if (function_exists($functionname_old)) {
             return $functionname_old($this->browser, $this->areas, $this->course, $this->cm, $this->context, $filearea, $itemid, $filepath, $filename);
         }
     }
     return null;
 }

 /**
  * Test get_enrolled_users
  */
 public function test_enrol_users()
 {
     global $DB;
     $this->resetAfterTest(true);
     $user = self::getDataGenerator()->create_user();
     $this->setUser($user);
     $course1 = self::getDataGenerator()->create_course();
     $course2 = self::getDataGenerator()->create_course();
     $user1 = self::getDataGenerator()->create_user();
     $user2 = self::getDataGenerator()->create_user();
     $context1 = context_course::instance($course1->id);
     $context2 = context_course::instance($course2->id);
     $instance1 = $DB->get_record('enrol', array('courseid' => $course1->id, 'enrol' => 'manual'), '*', MUST_EXIST);
     $instance2 = $DB->get_record('enrol', array('courseid' => $course2->id, 'enrol' => 'manual'), '*', MUST_EXIST);
     // Set the required capabilities by the external function.
     $roleid = $this->assignUserCapability('enrol/manual:enrol', $context1->id);
     $this->assignUserCapability('moodle/course:view', $context1->id, $roleid);
     $this->assignUserCapability('moodle/role:assign', $context1->id, $roleid);
     $this->assignUserCapability('enrol/manual:enrol', $context2->id, $roleid);
     $this->assignUserCapability('moodle/course:view', $context2->id, $roleid);
     $this->assignUserCapability('moodle/role:assign', $context2->id, $roleid);
     allow_assign($roleid, 3);
     // Call the external function.
     enrol_manual_external::enrol_users(array(array('roleid' => 3, 'userid' => $user1->id, 'courseid' => $course1->id), array('roleid' => 3, 'userid' => $user2->id, 'courseid' => $course1->id)));
     $this->assertEquals(2, $DB->count_records('user_enrolments', array('enrolid' => $instance1->id)));
     $this->assertEquals(0, $DB->count_records('user_enrolments', array('enrolid' => $instance2->id)));
     $this->assertTrue(is_enrolled($context1, $user1));
     $this->assertTrue(is_enrolled($context1, $user2));
     // Call without required capability.
     $DB->delete_records('user_enrolments');
     $this->unassignUserCapability('enrol/manual:enrol', $context1->id, $roleid);
     try {
         enrol_manual_external::enrol_users(array(array('roleid' => 3, 'userid' => $user1->id, 'courseid' => $course1->id)));
         $this->fail('Exception expected if not having capability to enrol');
     } catch (moodle_exception $e) {
         $this->assertInstanceOf('required_capability_exception', $e);
         $this->assertSame('nopermissions', $e->errorcode);
     }
     $this->assignUserCapability('enrol/manual:enrol', $context1->id, $roleid);
     $this->assertEquals(0, $DB->count_records('user_enrolments'));
     // Call with forbidden role.
     try {
         enrol_manual_external::enrol_users(array(array('roleid' => 1, 'userid' => $user1->id, 'courseid' => $course1->id)));
         $this->fail('Exception expected if not allowed to assign role.');
     } catch (moodle_exception $e) {
         $this->assertSame('wsusercannotassign', $e->errorcode);
     }
     $this->assertEquals(0, $DB->count_records('user_enrolments'));
     // Call for course without manual instance.
     $DB->delete_records('user_enrolments');
     $DB->delete_records('enrol', array('courseid' => $course2->id));
     try {
         enrol_manual_external::enrol_users(array(array('roleid' => 3, 'userid' => $user1->id, 'courseid' => $course1->id), array('roleid' => 3, 'userid' => $user1->id, 'courseid' => $course2->id)));
         $this->fail('Exception expected if course does not have manual instance');
     } catch (moodle_exception $e) {
         $this->assertSame('wsnoinstance', $e->errorcode);
     }
 }

 function execute($userid, $context, $data)
 {
     global $DB, $CFG;
     // Everyone should be enrolled at the system level.
     if ($context == context_system::instance()) {
         return true;
     }
     return is_enrolled($context, $userid);
 }

/**
 * Adds a specified user to a group
 *
 * @param mixed $grouporid  The group id or group object
 * @param mixed $userorid   The user id or user object
 * @param string $component Optional component name e.g. 'enrol_imsenterprise'
 * @param int $itemid Optional itemid associated with component
 * @return bool True if user added successfully or the user is already a
 * member of the group, false otherwise.
 */
function groups_add_member($grouporid, $userorid, $component = null, $itemid = 0)
{
    global $DB;
    if (is_object($userorid)) {
        $userid = $userorid->id;
        $user = $userorid;
    } else {
        $userid = $userorid;
        $user = $DB->get_record('user', array('id' => $userid), '*', MUST_EXIST);
    }
    if (is_object($grouporid)) {
        $groupid = $grouporid->id;
        $group = $grouporid;
    } else {
        $groupid = $grouporid;
        $group = $DB->get_record('groups', array('id' => $groupid), '*', MUST_EXIST);
    }
    //check if the user a participant of the group course
    if (!is_enrolled(context_course::instance($group->courseid), $userid)) {
        return false;
    }
    if (groups_is_member($groupid, $userid)) {
        return true;
    }
    $member = new stdClass();
    $member->groupid = $groupid;
    $member->userid = $userid;
    $member->timeadded = time();
    $member->component = '';
    $member->itemid = 0;
    // Check the component exists if specified
    if (!empty($component)) {
        $dir = get_component_directory($component);
        if ($dir && is_dir($dir)) {
            // Component exists and can be used
            $member->component = $component;
            $member->itemid = $itemid;
        } else {
            throw new coding_exception('Invalid call to groups_add_member(). An invalid component was specified');
        }
    }
    if ($itemid !== 0 && empty($member->component)) {
        // An itemid can only be specified if a valid component was found
        throw new coding_exception('Invalid call to groups_add_member(). A component must be specified if an itemid is given');
    }
    $DB->insert_record('groups_members', $member);
    //update group info
    $DB->set_field('groups', 'timemodified', $member->timeadded, array('id' => $groupid));
    //trigger groups events
    $eventdata = new stdClass();
    $eventdata->groupid = $groupid;
    $eventdata->userid = $userid;
    $eventdata->component = $member->component;
    $eventdata->itemid = $member->itemid;
    events_trigger('groups_member_added', $eventdata);
    return true;
}

 /**
  * Loads the data required to render the report.
  *
  * @param int $courseid The course id
  * @param int $userid The user id
  * @return \stdClass
  */
 public static function data_for_report($courseid, $userid)
 {
     global $PAGE;
     $params = self::validate_parameters(self::data_for_report_parameters(), array('courseid' => $courseid, 'userid' => $userid));
     $context = context_course::instance($params['courseid']);
     self::validate_context($context);
     if (!is_enrolled($context, $params['userid'], 'moodle/competency:coursecompetencygradable')) {
         throw new coding_exception('invaliduser');
     }
     $renderable = new output\report($params['courseid'], $params['userid']);
     $renderer = $PAGE->get_renderer('report_competency');
     $data = $renderable->export_for_template($renderer);
     return $data;
 }

 public function is_available($not, \core_availability\info $info, $grabthelot, $userid)
 {
     $allow = true;
     if ($this->expectedpublicprivate == PUBLICPRIVATE_PRIVATE) {
         $modinfo = $info->get_modinfo();
         $course = $modinfo->get_course();
         $context = \context_course::instance($course->id);
         $allow = is_enrolled($context, $userid, '', true) || has_capability('moodle/course:view', $context);
     }
     if ($not) {
         $allow = !$allow;
     }
     return $allow;
 }

/**
 * Adds a specified user to a group
 *
 * @param mixed $grouporid  The group id or group object
 * @param mixed $userorid   The user id or user object
 * @return bool True if user added successfully or the user is already a
 * member of the group, false otherwise.
 */
function groups_add_member($grouporid, $userorid) {
    global $DB;

    if (is_object($userorid)) {
        $userid = $userorid->id;
        $user   = $userorid;
    } else {
        $userid = $userorid;
        $user = $DB->get_record('user', array('id'=>$userid), '*', MUST_EXIST);
    }

    if (is_object($grouporid)) {
        $groupid = $grouporid->id;
        $group   = $grouporid;
    } else {
        $groupid = $grouporid;
        $group = $DB->get_record('groups', array('id'=>$groupid), '*', MUST_EXIST);
    }

    //check if the user a participant of the group course
    if (!is_enrolled(get_context_instance(CONTEXT_COURSE, $group->courseid), $userid)) {
        return false;
    }

    if (groups_is_member($groupid, $userid)) {
        return true;
    }

    $member = new stdClass();
    $member->groupid   = $groupid;
    $member->userid    = $userid;
    $member->timeadded = time();

    $DB->insert_record('groups_members', $member);

    //update group info
    $DB->set_field('groups', 'timemodified', $member->timeadded, array('id'=>$groupid));

    //trigger groups events
    $eventdata = new stdClass();
    $eventdata->groupid = $groupid;
    $eventdata->userid  = $userid;
    events_trigger('groups_member_added', $eventdata);

    return true;
}

function block_csv_enrol_enrol_users($courseid, $csvcontent)
{
    global $DB, $CFG;
    require_once $CFG->libdir . '/enrollib.php';
    //get enrolment instance (manual and student)
    $instances = enrol_get_instances($courseid, false);
    $enrolment = "";
    foreach ($instances as $instance) {
        if ($instance->enrol === 'manual') {
            $enrolment = $instance;
            break;
        }
    }
    //get enrolment plugin
    $manual = enrol_get_plugin('manual');
    $context = get_context_instance(CONTEXT_COURSE, $courseid);
    $stats = new StdClass();
    $stats->success = $stats->failed = 0;
    //init counters
    $log = get_string('enrolling', 'block_csv_enrol') . "\r\n";
    $lines = explode("\n", $csvcontent);
    foreach ($lines as $line) {
        if ($line == "") {
            continue;
        }
        $user = $DB->get_record('user', array('email' => trim($line)));
        if ($user && !$user->deleted) {
            if (is_enrolled($context, $user)) {
                $log .= get_string('enrollinguser', 'block_csv_enrol', fullname($user) . ' (' . $user->username . ')') . "\r\n";
            } else {
                $log .= get_string('alreadyenrolled', 'block_csv_enrol', fullname($user) . ' (' . $user->username . ')') . "\r\n";
                $manual->enrol_user($enrolment, $user->id, $enrolment->roleid, time());
            }
            $stats->success++;
        } else {
            $log .= get_string('emailnotfound', 'block_csv_enrol', trim($line)) . "\r\n";
            $stats->failed++;
        }
    }
    $log .= get_string('done', 'block_csv_enrol') . "\r\n";
    $log = get_string('status', 'block_csv_enrol', $stats) . ' ' . get_string('enrolmentlog', 'block_csv_enrol') . "\r\n\r\n" . $log;
    return $log;
}

 /**
  * Return information about this specific context level
  *
  * @param $component
  * @param $filearea
  * @param $itemid
  * @param $filepath
  * @param $filename
  */
 public function get_file_info($component, $filearea, $itemid, $filepath, $filename)
 {
     // try to emulate require_login() tests here
     if (!isloggedin()) {
         return null;
     }
     $coursecontext = get_course_context($this->context);
     if (!$this->course->visible and !has_capability('moodle/course:viewhiddencourses', $coursecontext)) {
         return null;
     }
     if (!is_viewing($this->context) and !is_enrolled($this->context)) {
         // no peaking here if not enrolled or inspector
         return null;
     }
     $modinfo = get_fast_modinfo($this->course);
     $cminfo = $modinfo->get_cm($this->cm->id);
     if (!$cminfo->uservisible) {
         // activity hidden sorry
         return null;
     }
     if (empty($component)) {
         return $this;
     }
     if ($component == 'mod_' . $this->modname and $filearea === 'intro') {
         return $this->get_area_intro($itemid, $filepath, $filename);
     } else {
         if ($component == 'backup' and $filearea === 'activity') {
             return $this->get_area_backup($itemid, $filepath, $filename);
         }
     }
     $functionname = 'mod_' . $this->modname . '_get_file_info';
     $functionname_old = $this->modname . '_get_file_info';
     if (function_exists($functionname)) {
         return $functionname($this->browser, $this->areas, $this->course, $this->cm, $this->context, $filearea, $itemid, $filepath, $filename);
     } else {
         if (function_exists($functionname_old)) {
             return $functionname_old($this->browser, $this->areas, $this->course, $this->cm, $this->context, $filearea, $itemid, $filepath, $filename);
         }
     }
     return null;
 }

/**
 * Is current user allowed to access this report
 *
 * @private defined in lib.php for performance reasons
 *
 * @param stdClass $user
 * @param stdClass $course
 * @return bool
 */
function report_outline_can_access_user_report($user, $course)
{
    global $USER;
    $coursecontext = context_course::instance($course->id);
    $personalcontext = context_user::instance($user->id);
    if (has_capability('report/outline:view', $coursecontext)) {
        return true;
    }
    if (has_capability('moodle/user:viewuseractivitiesreport', $personalcontext)) {
        if ($course->showreports and (is_viewing($coursecontext, $user) or is_enrolled($coursecontext, $user))) {
            return true;
        }
    } else {
        if ($user->id == $USER->id) {
            if ($course->showreports and (is_viewing($coursecontext, $USER) or is_enrolled($coursecontext, $USER))) {
                return true;
            }
        }
    }
    return false;
}

 /**
  * Return information about this specific context level
  *
  * @param string $component component
  * @param string $filearea file area
  * @param int $itemid item ID
  * @param string $filepath file path
  * @param string $filename file name
  * @return file_info|null file_info instance or null if not found or access not allowed
  */
 public function get_file_info($component, $filearea, $itemid, $filepath, $filename)
 {
     // try to emulate require_login() tests here
     if (!isloggedin()) {
         return null;
     }
     if (!$this->course->visible and !has_capability('moodle/course:viewhiddencourses', $this->context)) {
         return null;
     }
     if (!is_viewing($this->context) and !is_enrolled($this->context)) {
         // no peaking here if not enrolled or inspector
         return null;
     }
     if (empty($component)) {
         return $this;
     }
     $methodname = "get_area_{$component}_{$filearea}";
     if (method_exists($this, $methodname)) {
         return $this->{$methodname}($itemid, $filepath, $filename);
     }
     return null;
 }

             if ($duration > 0) {
                 // sanity check
                 $timeend = $today + $duration;
             }
         }
         $manual->enrol_user($manualcache[$courseid], $user->id, $rid, $today, $timeend);
         $a = new stdClass();
         $a->course = $shortname;
         $a->role = $rolecache[$rid]->name;
         $upt->track('enrolments', get_string('enrolledincourserole', 'enrol_manual', $a));
     }
 }
 // find group to add to
 if (!empty($user->{'group' . $i})) {
     // make sure user is enrolled into course before adding into groups
     if (!is_enrolled($coursecontext, $user->id)) {
         $upt->track('enrolments', get_string('addedtogroupnotenrolled', '', $user->{'group' . $i}), 'error');
         continue;
     }
     //build group cache
     if (is_null($ccache[$shortname]->groups)) {
         $ccache[$shortname]->groups = array();
         if ($groups = groups_get_all_groups($courseid)) {
             foreach ($groups as $gid => $group) {
                 $ccache[$shortname]->groups[$gid] = new stdClass();
                 $ccache[$shortname]->groups[$gid]->id = $gid;
                 $ccache[$shortname]->groups[$gid]->name = $group->name;
                 if (!is_numeric($group->name)) {
                     // only non-numeric names are supported!!!
                     $ccache[$shortname]->groups[$group->name] = new stdClass();
                     $ccache[$shortname]->groups[$group->name]->id = $gid;

$digestoptions = forum_get_user_digest_options();
$digestoptions_selector = new single_select(new moodle_url('/mod/forum/maildigest.php', array('backtoindex' => 1)), 'maildigest', $digestoptions, null, '');
$digestoptions_selector->method = 'post';
// Start of the table for General Forums
$generaltable = new html_table();
$generaltable->head = array($strforum, $strdescription, $strdiscussions);
$generaltable->align = array('left', 'left', 'center');
if ($usetracking = forum_tp_can_track_forums()) {
    $untracked = forum_tp_get_untracked_forums($USER->id, $course->id);
    $generaltable->head[] = $strunreadposts;
    $generaltable->align[] = 'center';
    $generaltable->head[] = $strtracking;
    $generaltable->align[] = 'center';
}
$subscribed_forums = forum_get_subscribed_forums($course);
$can_subscribe = is_enrolled($coursecontext);
if ($can_subscribe) {
    $generaltable->head[] = $strsubscribed;
    $generaltable->align[] = 'center';
    $generaltable->head[] = $stremaildigest . ' ' . $OUTPUT->help_icon('emaildigesttype', 'mod_forum');
    $generaltable->align[] = 'center';
}
if ($show_rss = ($can_subscribe || $course->id == SITEID) && isset($CFG->enablerssfeeds) && isset($CFG->forum_enablerssfeeds) && $CFG->enablerssfeeds && $CFG->forum_enablerssfeeds) {
    $generaltable->head[] = $strrss;
    $generaltable->align[] = 'center';
}
$usesections = course_format_uses_sections($course->format);
$table = new html_table();
// Parse and organise all the forums.  Most forums are course modules but
// some special ones are not.  These get placed in the general forums
// category with the forums in section 0.

if ((!$current or $choice->allowupdate) and $choiceopen and is_enrolled($context, NULL, 'mod/choice:choose')) {
    // They haven't made their choice yet or updates allowed and choice is open
    $options = choice_prepare_options($choice, $USER, $cm, $allresponses);
    $renderer = $PAGE->get_renderer('mod_choice');
    echo $renderer->display_options($options, $cm->id, $choice->display, $choice->allowmultiple);
    $choiceformshown = true;
} else {
    $choiceformshown = false;
}
if (!$choiceformshown) {
    $sitecontext = context_system::instance();
    if (isguestuser()) {
        // Guest account
        echo $OUTPUT->confirm(get_string('noguestchoose', 'choice') . '<br /><br />' . get_string('liketologin'), get_login_url(), new moodle_url('/course/view.php', array('id' => $course->id)));
    } else {
        if (!is_enrolled($context)) {
            // Only people enrolled can make a choice
            $SESSION->wantsurl = qualified_me();
            $SESSION->enrolcancel = get_local_referer(false);
            $coursecontext = context_course::instance($course->id);
            $courseshortname = format_string($course->shortname, true, array('context' => $coursecontext));
            echo $OUTPUT->box_start('generalbox', 'notice');
            echo '<p align="center">' . get_string('notenrolledchoose', 'choice') . '</p>';
            echo $OUTPUT->container_start('continuebutton');
            echo $OUTPUT->single_button(new moodle_url('/enrol/index.php?', array('id' => $course->id)), get_string('enrolme', 'core_enrol', $courseshortname));
            echo $OUTPUT->container_end();
            echo $OUTPUT->box_end();
        }
    }
}
// print the results at the bottom of the screen

    $node->add(format_string($post->subject), $PAGE->url);
}
$PAGE->set_title("{$course->shortname}: " . format_string($discussion->name));
$PAGE->set_heading($course->fullname);
$PAGE->set_button($searchform);
echo $OUTPUT->header();
echo $OUTPUT->heading(format_string($forum->name), 2);
/// Check to see if groups are being used in this forum
/// If so, make sure the current person is allowed to see this discussion
/// Also, if we know they should be able to reply, then explicitly set $canreply for performance reasons
$canreply = forum_user_can_post($forum, $discussion, $USER, $cm, $course, $modcontext);
if (!$canreply and $forum->type !== 'news') {
    if (isguestuser() or !isloggedin()) {
        $canreply = true;
    }
    if (!is_enrolled($modcontext) and !is_viewing($modcontext)) {
        // allow guests and not-logged-in to see the link - they are prompted to log in after clicking the link
        // normal users with temporary guest access see this link too, they are asked to enrol instead
        $canreply = enrol_selfenrol_available($course->id);
    }
}
/// Print the controls across the top
echo '<div class="discussioncontrols clearfix">';
if (!empty($CFG->enableportfolios) && has_capability('mod/forum:exportdiscussion', $modcontext)) {
    require_once $CFG->libdir . '/portfoliolib.php';
    $button = new portfolio_add_button();
    $button->set_callback_options('forum_portfolio_caller', array('discussionid' => $discussion->id), 'mod_forum');
    $button = $button->to_html(PORTFOLIO_ADD_FULL_FORM, get_string('exportdiscussion', 'mod_forum'));
    $buttonextraclass = '';
    if (empty($button)) {
        // no portfolio plugin available.

 protected function define_execution()
 {
     global $CFG, $DB;
     if (!($userid = $this->task->get_userid())) {
         return;
     }
     if (empty($CFG->restorernewroleid)) {
         // Bad luck, no fallback role for restorers specified
         return;
     }
     $courseid = $this->get_courseid();
     $context = context_course::instance($courseid);
     if (is_enrolled($context, $userid, 'moodle/course:update', true) or is_viewing($context, $userid, 'moodle/course:update')) {
         // Current user may access the course (admin, category manager or restored teacher enrolment usually)
         return;
     }
     // Try to add role only - we do not need enrolment if user has moodle/course:view or is already enrolled
     role_assign($CFG->restorernewroleid, $userid, $context);
     if (is_enrolled($context, $userid, 'moodle/course:update', true) or is_viewing($context, $userid, 'moodle/course:update')) {
         // Extra role is enough, yay!
         return;
     }
     // The last chance is to create manual enrol if it does not exist and and try to enrol the current user,
     // hopefully admin selected suitable $CFG->restorernewroleid ...
     if (!enrol_is_enabled('manual')) {
         return;
     }
     if (!($enrol = enrol_get_plugin('manual'))) {
         return;
     }
     if (!$DB->record_exists('enrol', array('enrol' => 'manual', 'courseid' => $courseid))) {
         $course = $DB->get_record('course', array('id' => $courseid), '*', MUST_EXIST);
         $fields = array('status' => ENROL_INSTANCE_ENABLED, 'enrolperiod' => $enrol->get_config('enrolperiod', 0), 'roleid' => $enrol->get_config('roleid', 0));
         $enrol->add_instance($course, $fields);
     }
     enrol_try_internal_enrol($courseid, $userid);
 }

    /**
     * Parse moss result page and store to DB
     *
     * @param string $url moss result page url
     * @param int $configid
     * @return true or false
     */
    protected function save_results($url, $configid) {
        global $DB, $UNITTEST;

        mtrace("\tProcessing $url");

        if (!$result_page = download_file_content($url)) {
            mtrace("\tcan not read $url");
            return false;
        }

        preg_match_all(
            '/(?P<link>http:\/\/moss\.stanford\.edu\/results\/\d+\/match\d+\.html)">.+\/(?P<user1>\d+)\/ \((?P<percentage1>\d+)%\).+\/(?P<user2>\d+)\/ \((?P<percentage2>\d+)%\).+right>(?P<linesmatched>\d+)\\n/Us',
            $result_page,
            $matches,
            PREG_SET_ORDER
        );

        if (empty($matches)) {
            mtrace("\tcan not parse $url");
            return false;
        }

        if (!isset($UNITTEST)) { // testcase can not construct course structure
            $context = get_context_instance(CONTEXT_COURSE, $this->moss->course);
        }

        $filepatterns = $DB->get_field('moss_configs', 'filepatterns', array('id' => $configid));
        $filepatterns = explode(' ', $filepatterns);
        $fs = get_file_storage();
        $rank = 1;
        foreach ($matches as $result) {
            $result['moss'] = $this->moss->id;
            $result['config'] = $configid;
            $result['rank'] = $rank + 1;
            $result1 = (object)$result;
            $result1->userid = $result['user1'];
            $result1->percentage = $result['percentage1'];
            $result2 = (object)$result;
            $result2->userid = $result['user2'];
            $result2->percentage = $result['percentage2'];

            if (!isset($UNITTEST)) { // testcase can not construct course structure
                // skip unenrolled users
                if (!is_enrolled($context, $result1->userid) and !is_enrolled($context, $result2->userid)) {
                    continue;
                }
            }

            $result1->id = $DB->insert_record('moss_results', $result1);
            $result2->pair = $result1->id;
            $result2->id = $DB->insert_record('moss_results', $result2);
            $result1->pair = $result2->id;
            $DB->update_record('moss_results', $result1);

            // update moss_matched_files db
            for ($i=1; $i<=2; $i++) {
                $userid = eval('return $result'.$i.'->userid;');
                $resultid = eval('return $result'.$i.'->id;');

                $files = $fs->get_directory_files(get_system_context()->id, 'plagiarism_moss', 'files', $this->moss->cmid, "/$userid/");
                foreach ($files as $file) {
                    foreach ($filepatterns as $pattern) {
                        if (fnmatch($pattern, $file->get_filename())) {
                            $obj = new stdClass();
                            $obj->result = $resultid;
                            $obj->contenthash = $file->get_contenthash();
                            $DB->insert_record('moss_matched_files', $obj);
                        }
                    }
                }
            }

            $rank++;
        }

        mtrace("\tGot $rank pairs");

        return true;
    }

 /**
  * Save the extension date for a single user.
  *
  * @param int $userid The user id
  * @param mixed $extensionduedate Either an integer date or null
  * @return boolean
  */
 public function save_user_extension($userid, $extensionduedate)
 {
     global $DB;
     // Need submit permission to submit an assignment.
     require_capability('mod/assign:grantextension', $this->context);
     if (!is_enrolled($this->get_course_context(), $userid)) {
         return false;
     }
     if (!has_capability('mod/assign:submit', $this->context, $userid)) {
         return false;
     }
     if ($this->get_instance()->duedate && $extensionduedate) {
         if ($this->get_instance()->duedate > $extensionduedate) {
             return false;
         }
     }
     if ($this->get_instance()->allowsubmissionsfromdate && $extensionduedate) {
         if ($this->get_instance()->allowsubmissionsfromdate > $extensionduedate) {
             return false;
         }
     }
     $flags = $this->get_user_flags($userid, true);
     $flags->extensionduedate = $extensionduedate;
     $result = $this->update_user_flags($flags);
     if ($result) {
         $addtolog = $this->add_to_log('grant extension', $userid, '', true);
         $params = array('context' => $this->context, 'objectid' => $flags->assignment, 'relateduserid' => $userid);
         $event = \mod_assign\event\extension_granted::create($params);
         $event->set_legacy_logdata($addtolog);
         $event->trigger();
     }
     return $result;
 }