示例#1
1
    $coursecontext = $context;
}
require_login($course);
$baseurl = 'override.php?contextid=' . $context->id;
if (!empty($userid)) {
    $baseurl .= '&userid=' . $userid;
}
if ($courseid != SITEID) {
    $baseurl .= '&courseid=' . $courseid;
}
if ($cancel) {
    redirect($baseurl);
}
/// needed for tabs.php
$overridableroles = get_overridable_roles($context);
$assignableroles = get_assignable_roles($context);
/// Get some language strings
$strroletooverride = get_string('roletooverride', 'role');
$straction = get_string('overrideroles', 'role');
$strcurrentrole = get_string('currentrole', 'role');
$strparticipants = get_string('participants');
/// Make sure this user can override that role
if ($roleid) {
    if (!user_can_override($context, $roleid)) {
        error('you can not override this role in this context');
    }
}
if ($userid) {
    $user = get_record('user', 'id', $userid);
    $fullname = fullname($user, has_capability('moodle/site:viewfullnames', $context));
}
示例#2
1
 /**
  * Given one role, as loaded from XML, perform the best possible matching against the assignable
  * roles, using different fallback alternatives (shortname, archetype, editingteacher => teacher, defaultcourseroleid)
  * returning the id of the best matching role or 0 if no match is found
  */
 protected static function get_best_assignable_role($role, $courseid, $userid, $samesite)
 {
     global $CFG, $DB;
     // Gather various information about roles
     $coursectx = get_context_instance(CONTEXT_COURSE, $courseid);
     $allroles = $DB->get_records('role');
     $assignablerolesshortname = get_assignable_roles($coursectx, ROLENAME_SHORT, false, $userid);
     // Note: under 1.9 we had one function restore_samerole() that performed one complete
     // matching of roles (all caps) and if match was found the mapping was availabe bypassing
     // any assignable_roles() security. IMO that was wrong and we must not allow such
     // mappings anymore. So we have left that matching strategy out in 2.0
     // Empty assignable roles, mean no match possible
     if (empty($assignablerolesshortname)) {
         return 0;
     }
     // Match by shortname
     if ($match = array_search($role->shortname, $assignablerolesshortname)) {
         return $match;
     }
     // Match by archetype
     list($in_sql, $in_params) = $DB->get_in_or_equal(array_keys($assignablerolesshortname));
     $params = array_merge(array($role->archetype), $in_params);
     if ($rec = $DB->get_record_select('role', "archetype = ? AND id {$in_sql}", $params, 'id', IGNORE_MULTIPLE)) {
         return $rec->id;
     }
     // Match editingteacher to teacher (happens a lot, from 1.9)
     if ($role->shortname == 'editingteacher' && in_array('teacher', $assignablerolesshortname)) {
         return array_search('teacher', $assignablerolesshortname);
     }
     // No match, return 0
     return 0;
 }
 function definition()
 {
     global $CFG, $DB;
     $mform = $this->_form;
     list($instance, $plugin, $course) = $this->_customdata;
     $coursecontext = context_course::instance($course->id);
     $enrol = enrol_get_plugin('cohort');
     $groups = array(0 => get_string('none'));
     foreach (groups_get_all_groups($course->id) as $group) {
         $groups[$group->id] = format_string($group->name, true, array('context' => $coursecontext));
     }
     $mform->addElement('header', 'general', get_string('pluginname', 'enrol_cohort'));
     $mform->addElement('text', 'name', get_string('custominstancename', 'enrol'));
     $mform->setType('name', PARAM_TEXT);
     $options = array(ENROL_INSTANCE_ENABLED => get_string('yes'), ENROL_INSTANCE_DISABLED => get_string('no'));
     $mform->addElement('select', 'status', get_string('status', 'enrol_cohort'), $options);
     if ($instance->id) {
         if ($cohort = $DB->get_record('cohort', array('id' => $instance->customint1))) {
             $cohorts = array($instance->customint1 => format_string($cohort->name, true, array('context' => context::instance_by_id($cohort->contextid))));
         } else {
             $cohorts = array($instance->customint1 => get_string('error'));
         }
         $mform->addElement('select', 'customint1', get_string('cohort', 'cohort'), $cohorts);
         $mform->setConstant('customint1', $instance->customint1);
         $mform->hardFreeze('customint1', $instance->customint1);
     } else {
         $cohorts = array('' => get_string('choosedots'));
         $allcohorts = cohort_get_available_cohorts($coursecontext, 0, 0, 0);
         foreach ($allcohorts as $c) {
             $cohorts[$c->id] = format_string($c->name);
         }
         $mform->addElement('select', 'customint1', get_string('cohort', 'cohort'), $cohorts);
         $mform->addRule('customint1', get_string('required'), 'required', null, 'client');
     }
     $roles = get_assignable_roles($coursecontext);
     $roles[0] = get_string('none');
     $roles = array_reverse($roles, true);
     // Descending default sortorder.
     $mform->addElement('select', 'roleid', get_string('assignrole', 'enrol_cohort'), $roles);
     $mform->setDefault('roleid', $enrol->get_config('roleid'));
     if ($instance->id and !isset($roles[$instance->roleid])) {
         if ($role = $DB->get_record('role', array('id' => $instance->roleid))) {
             $roles = role_fix_names($roles, $coursecontext, ROLENAME_ALIAS, true);
             $roles[$instance->roleid] = role_get_name($role, $coursecontext);
         } else {
             $roles[$instance->roleid] = get_string('error');
         }
     }
     $mform->addElement('select', 'customint2', get_string('addgroup', 'enrol_cohort'), $groups);
     $mform->addElement('hidden', 'courseid', null);
     $mform->setType('courseid', PARAM_INT);
     $mform->addElement('hidden', 'id', null);
     $mform->setType('id', PARAM_INT);
     if ($instance->id) {
         $this->add_action_buttons(true);
     } else {
         $this->add_action_buttons(true, get_string('addinstance', 'enrol'));
     }
     $this->set_data($instance);
 }
	function definition() {
		global $CFG;
		$mform = & $this->_form;
		$course = $this->_customdata['course'];
		$context = $this->_customdata['context'];

		// the upload manager is used directly in post precessing, moodleform::save_files() is not used yet
		//$this->set_upload_manager(new upload_manager('attachment'));

		$mform->addElement('header', 'general', ''); //fill in the data depending on page params
		//later using set_data
		$mform->addElement('filepicker', 'attachment', get_string('location', 'enrol_flatfile'));

		$mform->addRule('attachment', null, 'required');
		
		$choices = csv_import_reader::get_delimiter_list();
        $mform->addElement('select', 'delimiter_name', get_string('csvdelimiter', 'tool_uploaduser'), $choices);
        if (array_key_exists('cfg', $choices)) {
            $mform->setDefault('delimiter_name', 'cfg');
        } else if (get_string('listsep', 'langconfig') == ';') {
            $mform->setDefault('delimiter_name', 'semicolon');
        } else {
            $mform->setDefault('delimiter_name', 'comma');
        }

        $choices = textlib::get_encodings();
        $mform->addElement('select', 'encoding', get_string('encoding', 'tool_uploaduser'), $choices);
        $mform->setDefault('encoding', 'UTF-8');
		
		
        $roles = get_assignable_roles($context);
		$mform->addElement('select', 'roleassign', get_string('roleassign', 'local_mass_enroll'), $roles);
		$mform->setDefault('roleassign', 5); //student

		$ids = array (
			'idnumber' => get_string('idnumber', 'local_mass_enroll'),
			'username' => get_string('username', 'local_mass_enroll'),
			'email' => get_string('email')
		);
		$mform->addElement('select', 'firstcolumn', get_string('firstcolumn', 'local_mass_enroll'), $ids);
		$mform->setDefault('firstcolumn', 'idnumber');

		$mform->addElement('selectyesno', 'creategroups', get_string('creategroups', 'local_mass_enroll'));
		$mform->setDefault('creategroups', 1);

			$mform->addElement('selectyesno', 'creategroupings', get_string('creategroupings', 'local_mass_enroll'));
			$mform->setDefault('creategroupings', 1);


		$mform->addElement('selectyesno', 'mailreport', get_string('mailreport', 'local_mass_enroll'));
		$mform->setDefault('mailreport', 1);

		//-------------------------------------------------------------------------------
		// buttons

		$this->add_action_buttons(true, get_string('enroll', 'local_mass_enroll'));

		$mform->addElement('hidden', 'id', $course->id);
		$mform->setType('id', PARAM_INT);
	}
示例#5
0
 function definition()
 {
     global $CFG, $DB;
     $mform = $this->_form;
     $course = $this->_customdata['course'];
     $enrol = $this->_customdata['enrol'];
     $service = $this->_customdata['service'];
     $coursecontext = context_course::instance($course->id);
     $subscribers = $service->get_remote_subscribers();
     $hosts = array(0 => get_string('remotesubscribersall', 'enrol_mnet'));
     foreach ($subscribers as $hostid => $subscriber) {
         $hosts[$hostid] = $subscriber->appname . ': ' . $subscriber->hostname . ' (' . $subscriber->hosturl . ')';
     }
     $roles = get_assignable_roles($coursecontext);
     $mform->addElement('header', 'general', get_string('pluginname', 'enrol_mnet'));
     $mform->addElement('select', 'hostid', get_string('remotesubscriber', 'enrol_mnet'), $hosts);
     $mform->addHelpButton('hostid', 'remotesubscriber', 'enrol_mnet');
     $mform->addRule('hostid', get_string('required'), 'required', null, 'client');
     $mform->addElement('select', 'roleid', get_string('roleforremoteusers', 'enrol_mnet'), $roles);
     $mform->addHelpButton('roleid', 'roleforremoteusers', 'enrol_mnet');
     $mform->addRule('roleid', get_string('required'), 'required', null, 'client');
     $mform->setDefault('roleid', $enrol->get_config('roleid'));
     $mform->addElement('text', 'name', get_string('instancename', 'enrol_mnet'));
     $mform->addHelpButton('name', 'instancename', 'enrol_mnet');
     $mform->setType('name', PARAM_TEXT);
     $mform->addElement('hidden', 'id', null);
     $mform->setType('id', PARAM_INT);
     $this->add_action_buttons();
     $this->set_data(array('id' => $course->id));
 }
示例#6
0
 function definition()
 {
     global $CFG, $DB;
     $mform = $this->_form;
     $course = $this->_customdata;
     $coursecontext = context_course::instance($course->id);
     $enrol = enrol_get_plugin('cohort');
     $cohorts = array('' => get_string('choosedots'));
     list($sqlparents, $params) = $DB->get_in_or_equal(get_parent_contexts($coursecontext));
     $sql = "SELECT id, name, contextid\n                  FROM {cohort}\n                 WHERE contextid {$sqlparents}\n              ORDER BY name ASC";
     $rs = $DB->get_recordset_sql($sql, $params);
     foreach ($rs as $c) {
         $context = get_context_instance_by_id($c->contextid);
         if (!has_capability('moodle/cohort:view', $context)) {
             continue;
         }
         $cohorts[$c->id] = format_string($c->name);
     }
     $rs->close();
     $roles = get_assignable_roles($coursecontext);
     $roles[0] = get_string('none');
     $roles = array_reverse($roles, true);
     // descending default sortorder
     $mform->addElement('header', 'general', get_string('pluginname', 'enrol_cohort'));
     $mform->addElement('select', 'cohortid', get_string('cohort', 'cohort'), $cohorts);
     $mform->addRule('cohortid', get_string('required'), 'required', null, 'client');
     $mform->addElement('select', 'roleid', get_string('role'), $roles);
     $mform->addRule('roleid', get_string('required'), 'required', null, 'client');
     $mform->setDefault('roleid', $enrol->get_config('roleid'));
     $mform->addElement('hidden', 'id', null);
     $mform->setType('id', PARAM_INT);
     $this->add_action_buttons(true, get_string('addinstance', 'enrol'));
     $this->set_data(array('id' => $course->id));
 }
示例#7
0
 /**
  * Enrolment of users.
  *
  * Function throw an exception at the first error encountered.
  * @param array $enrolments  An array of user enrolment
  * @since Moodle 2.2
  */
 public static function enrol_users($enrolments)
 {
     global $DB, $CFG;
     require_once $CFG->libdir . '/enrollib.php';
     $params = self::validate_parameters(self::enrol_users_parameters(), array('enrolments' => $enrolments));
     $transaction = $DB->start_delegated_transaction();
     // Rollback all enrolment if an error occurs
     // (except if the DB doesn't support it).
     // Retrieve the manual enrolment plugin.
     $enrol = enrol_get_plugin('manual');
     if (empty($enrol)) {
         throw new moodle_exception('manualpluginnotinstalled', 'enrol_manual');
     }
     foreach ($params['enrolments'] as $enrolment) {
         // Ensure the current user is allowed to run this function in the enrolment context.
         $context = context_course::instance($enrolment['courseid'], IGNORE_MISSING);
         self::validate_context($context);
         // Check that the user has the permission to manual enrol.
         require_capability('enrol/manual:enrol', $context);
         // Throw an exception if user is not able to assign the role.
         $roles = get_assignable_roles($context);
         if (!array_key_exists($enrolment['roleid'], $roles)) {
             $errorparams = new stdClass();
             $errorparams->roleid = $enrolment['roleid'];
             $errorparams->courseid = $enrolment['courseid'];
             $errorparams->userid = $enrolment['userid'];
             throw new moodle_exception('wsusercannotassign', 'enrol_manual', '', $errorparams);
         }
         // Check manual enrolment plugin instance is enabled/exist.
         $instance = null;
         $enrolinstances = enrol_get_instances($enrolment['courseid'], true);
         foreach ($enrolinstances as $courseenrolinstance) {
             if ($courseenrolinstance->enrol == "manual") {
                 $instance = $courseenrolinstance;
                 break;
             }
         }
         if (empty($instance)) {
             $errorparams = new stdClass();
             $errorparams->courseid = $enrolment['courseid'];
             throw new moodle_exception('wsnoinstance', 'enrol_manual', $errorparams);
         }
         // Check that the plugin accept enrolment (it should always the case, it's hard coded in the plugin).
         if (!$enrol->allow_enrol($instance)) {
             $errorparams = new stdClass();
             $errorparams->roleid = $enrolment['roleid'];
             $errorparams->courseid = $enrolment['courseid'];
             $errorparams->userid = $enrolment['userid'];
             throw new moodle_exception('wscannotenrol', 'enrol_manual', '', $errorparams);
         }
         // Finally proceed the enrolment.
         $enrolment['timestart'] = isset($enrolment['timestart']) ? $enrolment['timestart'] : 0;
         $enrolment['timeend'] = isset($enrolment['timeend']) ? $enrolment['timeend'] : 0;
         $enrolment['status'] = isset($enrolment['suspend']) && !empty($enrolment['suspend']) ? ENROL_USER_SUSPENDED : ENROL_USER_ACTIVE;
         $enrol->enrol_user($instance, $enrolment['userid'], $enrolment['roleid'], $enrolment['timestart'], $enrolment['timeend'], $enrolment['status']);
     }
     $transaction->allow_commit();
 }
    public function definition()
    {
        global $CFG, $DB;
        $mform = $this->_form;
        $course = $this->_customdata['course'];
        $instance = $this->_customdata['instance'];
        $this->course = $course;
        $existing = array();
        if ($instance) {
            $existing = $DB->get_records('enrol_metaplus', array('enrolid' => $instance->id), '', 'courseid, id');
        }
        $courses = array();
        $select = context_helper::get_preload_record_columns_sql('ctx');
        $sql = <<<SQL
            SELECT c.id, c.fullname, c.shortname, c.visible, {$select}
            FROM {course} c
            LEFT JOIN {context} ctx
                ON (ctx.instanceid = c.id AND ctx.contextlevel = :contextlevel)
SQL;
        $rs = $DB->get_recordset_sql($sql, array('contextlevel' => CONTEXT_COURSE));
        foreach ($rs as $c) {
            if ($c->id == SITEID || $c->id == $course->id) {
                continue;
            }
            context_helper::preload_from_record($c);
            $coursecontext = context_course::instance($c->id);
            if (!$c->visible && !has_capability('moodle/course:viewhiddencourses', $coursecontext)) {
                continue;
            }
            if (!has_capability('enrol/meta:selectaslinked', $coursecontext)) {
                continue;
            }
            $courses[$c->id] = $coursecontext->get_context_name(false);
        }
        $rs->close();
        $mform->addElement('header', 'general', get_string('pluginname', 'enrol_meta'));
        $mform->addElement('select', 'link', get_string('linkedcourse', 'enrol_metaplus'), $courses, array('multiple' => 'multiple', 'class' => 'chosen'));
        $mform->addRule('link', get_string('required'), 'required', null, 'server');
        // Add role sync list.
        $coursecontext = \context_course::instance($course->id);
        $roles = get_assignable_roles($coursecontext);
        $mform->addElement('select', 'roleexclusions', get_string('roleexclusions', 'enrol_metaplus'), $roles, array('multiple' => 'multiple'));
        $mform->addElement('hidden', 'id', null);
        $mform->setType('id', PARAM_INT);
        $mform->addElement('hidden', 'enrolid');
        $mform->setType('enrolid', PARAM_INT);
        $data = array('id' => $course->id);
        if ($instance) {
            $data['link'] = implode(',', array_keys($existing));
            $data['enrolid'] = $instance->id;
            $data['roleexclusions'] = $instance->customtext1;
            $this->add_action_buttons();
        } else {
            $this->add_add_buttons();
        }
        $this->set_data($data);
    }
 /**
  * Gets a list of roles that this user can assign for the course as the default for auto-enrolment.
  *
  * @param context $context the context.
  * @param integer $defaultrole the id of the role that is set as the default for auto-enrolment
  * @return array index is the role id, value is the role name
  */
 function extend_assignable_roles($context, $defaultrole)
 {
     global $DB;
     $roles = get_assignable_roles($context, ROLENAME_BOTH);
     if (!isset($roles[$defaultrole])) {
         if ($role = $DB->get_record('role', array('id' => $defaultrole))) {
             $roles[$defaultrole] = role_get_name($role, $context, ROLENAME_BOTH);
         }
     }
     return $roles;
 }
 public function definition()
 {
     $mform =& $this->_form;
     $mform->addElement('checkbox', 'enabled', null, get_string('enabled', 'local_anonymousposting'));
     $mform->setDefault('enabled', 1);
     $context = context_course::instance(SITEID, MUST_EXIST);
     $assignableroles = get_assignable_roles($context);
     $mform->addElement('select', 'defaultcourserole', get_string('defaultcourserole', 'local_anonymousposting'), $assignableroles);
     $mform->setDefault('defaultcourserole', '5');
     $mform->addElement('select', 'defaultactivityrole', get_string('defaultactivityrole', 'local_anonymousposting'), $assignableroles);
     $mform->setDefault('defaultactivityrole', '5');
     $this->add_action_buttons();
 }
 /**
  * Core function for creation of form defined in block_panopto_edit_form class
  */
 protected function specific_definition($mform)
 {
     global $COURSE, $CFG;
     // Construct the Panopto data proxy object.
     $panoptodata = new panopto_data($COURSE->id);
     if (!empty($panoptodata->servername) && !empty($panoptodata->instancename) && !empty($panoptodata->applicationkey)) {
         $mform->addElement('header', 'configheader', get_string('block_edit_header', 'block_panopto'));
         $params = new stdClass();
         $params->course_id = $COURSE->id;
         $params->return_url = $_SERVER['REQUEST_URI'];
         $querystring = http_build_query($params, '', '&');
         $provisionurl = "{$CFG->wwwroot}/blocks/panopto/provision_course.php?" . $querystring;
         $addtopanopto = get_string('add_to_panopto', 'block_panopto');
         $or = get_string('or', 'block_panopto');
         $mform->addElement('html', "<a href='{$provisionurl}'>{$addtopanopto}</a><br><br>-- {$or} --<br><br>");
         $courselist = $panoptodata->get_course_options();
         $mform->addElement('selectgroups', 'config_course', get_string('existing_course', 'block_panopto'), $courselist['courses']);
         $mform->setDefault('config_course', $courselist['selected']);
         // Set course context to get roles.
         $context = context_course::instance($COURSE->id);
         // Get current role mappings.
         $currentmappings = $panoptodata->get_course_role_mappings($COURSE->id);
         // Get roles that current user may assign in this course.
         $currentcourseroles = get_assignable_roles($context, $rolenamedisplay = ROLENAME_ALIAS, $withusercounts = false, $user = null);
         while ($role = current($currentcourseroles)) {
             $rolearray[key($currentcourseroles)] = $currentcourseroles[key($currentcourseroles)];
             next($currentcourseroles);
         }
         $mform->addElement('header', 'rolemapheader', get_string('role_map_header', 'block_panopto'));
         $mform->addElement('html', get_string('role_map_info_text', 'block_panopto'));
         $createselect = $mform->addElement('select', 'config_creator', get_string('creator', 'block_panopto'), $rolearray, null);
         $createselect->setMultiple(true);
         // Set default selected to previous setting.
         if (!empty($currentmappings['creator'])) {
             $createselect->setSelected($currentmappings['creator']);
         }
         $pubselect = $mform->addElement('select', 'config_publisher', get_string('publisher', 'block_panopto'), $rolearray, null);
         $pubselect->setMultiple(true);
         // Set default selected to previous setting.
         if (!empty($currentmappings['publisher'])) {
             $pubselect->setSelected($currentmappings['publisher']);
         }
     } else {
         $mform->addElement('static', 'error', '', get_string('block_edit_error', 'block_panopto'));
     }
 }
 /**
  * Form definition
  */
 public function definition()
 {
     global $DB;
     $mform =& $this->_form;
     $course = $this->_customdata['course'];
     $context = $this->_customdata['context'];
     $config = get_config('local_mass_enroll');
     $mform->addElement('header', 'general', '');
     // Fill in the data depending on page params.
     // Later using set_data.
     $mform->addElement('filepicker', 'attachment', get_string('location', 'enrol_flatfile'));
     $mform->addRule('attachment', null, 'required');
     $choices = csv_import_reader::get_delimiter_list();
     $mform->addElement('select', 'delimiter_name', get_string('csvdelimiter', 'tool_uploaduser'), $choices);
     if (array_key_exists('cfg', $choices)) {
         $mform->setDefault('delimiter_name', 'cfg');
     } else {
         if (get_string('listsep', 'langconfig') == ';') {
             $mform->setDefault('delimiter_name', 'semicolon');
         } else {
             $mform->setDefault('delimiter_name', 'comma');
         }
     }
     $choices = \core_text::get_encodings();
     $mform->addElement('select', 'encoding', get_string('encoding', 'tool_uploaduser'), $choices);
     $mform->setDefault('encoding', 'UTF-8');
     $roles = get_assignable_roles($context);
     $mform->addElement('select', 'roleassign', get_string('roleassign', 'local_mass_enroll'), $roles);
     $studentrole = $DB->get_record('role', array('archetype' => 'student'));
     $mform->setDefault('roleassign', $studentrole->id);
     $ids = array('idnumber' => get_string('idnumber', 'local_mass_enroll'), 'username' => get_string('username', 'local_mass_enroll'), 'email' => get_string('email'));
     $mform->addElement('select', 'firstcolumn', get_string('firstcolumn', 'local_mass_enroll'), $ids);
     $mform->setDefault('firstcolumn', 'idnumber');
     $mform->addElement('selectyesno', 'creategroups', get_string('creategroups', 'local_mass_enroll'));
     $mform->setDefault('creategroups', 1);
     $mform->addElement('selectyesno', 'creategroupings', get_string('creategroupings', 'local_mass_enroll'));
     $mform->setDefault('creategroupings', 1);
     $mform->addElement('selectyesno', 'mailreport', get_string('mailreport', 'local_mass_enroll'));
     $mform->setDefault('mailreport', (int) $config->mailreportdefault);
     // Buttons.
     $this->add_action_buttons(true, get_string('enroll', 'local_mass_enroll'));
     $mform->addElement('hidden', 'id', $course->id);
     $mform->setType('id', PARAM_INT);
 }
示例#13
0
 /**
  * Form definition.
  */
 protected function definition()
 {
     global $DB;
     $mform = $this->_form;
     // Add student select box.
     $mform->addElement('select', 'users', 'Users', $DB->get_records_menu('user', array(), '', 'id,username'), array('class' => 'chosen', 'multiple' => 'multiple'));
     $mform->addRule('users', null, 'required', null, 'client');
     // Add student select box.
     $courses = $DB->get_records_menu('course', array(), '', 'id,CONCAT(shortname, \': \', fullname)');
     $mform->addElement('select', 'courses', 'Courses', $courses, array('class' => 'chosen', 'multiple' => 'multiple'));
     $mform->addRule('courses', null, 'required', null, 'client');
     unset($courses);
     // Add role select box.
     $course = get_site();
     $roles = get_assignable_roles(\context_course::instance($course->id));
     $mform->addElement('select', 'roleid', 'Role', $roles);
     $mform->addRule('roleid', null, 'required', null, 'client');
     $this->add_action_buttons(true, 'Enrol');
 }
 function definition()
 {
     global $CFG, $DB;
     $mform = $this->_form;
     $course = $this->_customdata;
     $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);
     $enrol = enrol_get_plugin('jwc');
     $roles = get_assignable_roles($coursecontext);
     $roles = array_reverse($roles, true);
     // descending default sortorder
     $mform->addElement('header', 'general', get_string('pluginname', 'enrol_jwc'));
     $mform->addElement('html', '与教务管理系统的学生选课同步。只有使用HITID登录的教师和学生才能享用此功能');
     $mform->addElement('text', 'coursenumber', get_string('coursenumber', 'enrol_jwc'));
     $mform->setType('coursenumber', PARAM_ALPHANUM);
     $mform->addHelpButton('coursenumber', 'coursenumber', 'enrol_jwc');
     $mform->addRule('coursenumber', get_string('required'), 'required', null, 'client');
     $mform->addElement('hidden', 'roleid', $enrol->get_config('roleid'));
     $mform->setType('roleid', PARAM_INT);
     $mform->addElement('hidden', 'id', null);
     $mform->setType('id', PARAM_INT);
     $this->add_action_buttons(true, get_string('addinstance', 'enrol'));
     $this->set_data(array('id' => $course->id));
 }
 /**
  * Test returning of assignable roles in context.
  */
 public function test_get_assignable_roles()
 {
     global $DB;
     $this->resetAfterTest();
     $course = $this->getDataGenerator()->create_course();
     $coursecontext = context_course::instance($course->id);
     $teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'), '*', MUST_EXIST);
     $teacher = $this->getDataGenerator()->create_user();
     role_assign($teacherrole->id, $teacher->id, $coursecontext);
     $teacherename = (object) array('roleid' => $teacherrole->id, 'name' => 'Učitel', 'contextid' => $coursecontext->id);
     $DB->insert_record('role_names', $teacherename);
     $studentrole = $DB->get_record('role', array('shortname' => 'student'), '*', MUST_EXIST);
     $student = $this->getDataGenerator()->create_user();
     role_assign($studentrole->id, $student->id, $coursecontext);
     $contexts = $DB->get_records('context');
     $users = $DB->get_records('user');
     $allroles = $DB->get_records('role');
     // Evaluate all results for all users in all contexts.
     foreach ($users as $user) {
         $this->setUser($user);
         foreach ($contexts as $contextid => $unused) {
             $context = context_helper::instance_by_id($contextid);
             $roles = get_assignable_roles($context, ROLENAME_SHORT);
             foreach ($allroles as $roleid => $role) {
                 if (isset($roles[$roleid])) {
                     if (is_siteadmin()) {
                         $this->assertTrue($DB->record_exists('role_context_levels', array('contextlevel' => $context->contextlevel, 'roleid' => $roleid)));
                     } else {
                         $this->assertTrue(user_can_assign($context, $roleid), "u:{$user->id} r:{$roleid}");
                     }
                     $this->assertEquals($role->shortname, $roles[$roleid]);
                 } else {
                     $allowed = $DB->record_exists('role_context_levels', array('contextlevel' => $context->contextlevel, 'roleid' => $roleid));
                     if (is_siteadmin()) {
                         $this->assertFalse($allowed);
                     } else {
                         $this->assertFalse($allowed and user_can_assign($context, $roleid), "u:{$user->id}, r:{$allroles[$roleid]->name}, c:{$context->contextlevel}");
                     }
                 }
             }
         }
     }
     // Not-logged-in user.
     $this->setUser(0);
     foreach ($contexts as $contextid => $unused) {
         $context = context_helper::instance_by_id($contextid);
         $roles = get_assignable_roles($context, ROLENAME_SHORT);
         $this->assertSame(array(), $roles);
     }
     // Test current user.
     $this->setUser(0);
     $admin = $DB->get_record('user', array('username' => 'admin'), '*', MUST_EXIST);
     $roles1 = get_assignable_roles($coursecontext, ROLENAME_SHORT, false, $admin);
     $roles2 = get_assignable_roles($coursecontext, ROLENAME_SHORT, false, $admin->id);
     $this->setAdminUser();
     $roles3 = get_assignable_roles($coursecontext, ROLENAME_SHORT);
     $this->assertSame($roles1, $roles3);
     $this->assertSame($roles2, $roles3);
     // Test parameter defaults.
     $this->setAdminUser();
     $roles1 = get_assignable_roles($coursecontext);
     $roles2 = get_assignable_roles($coursecontext, ROLENAME_ALIAS, false, $admin);
     $this->assertEquals($roles2, $roles1);
     // Verify returned names - let's allow all roles everywhere to simplify this a bit.
     $alllevels = context_helper::get_all_levels();
     $alllevels = array_keys($alllevels);
     foreach ($allroles as $roleid => $role) {
         set_role_contextlevels($roleid, $alllevels);
     }
     $alltypes = array(ROLENAME_ALIAS, ROLENAME_ALIAS_RAW, ROLENAME_BOTH, ROLENAME_ORIGINAL, ROLENAME_ORIGINALANDSHORT, ROLENAME_SHORT);
     foreach ($alltypes as $type) {
         $rolenames = role_fix_names($allroles, $coursecontext, $type);
         $roles = get_assignable_roles($coursecontext, $type, false, $admin);
         foreach ($roles as $roleid => $rolename) {
             $this->assertSame($rolenames[$roleid]->localname, $rolename);
         }
     }
     // Verify counts.
     $alltypes = array(ROLENAME_ALIAS, ROLENAME_ALIAS_RAW, ROLENAME_BOTH, ROLENAME_ORIGINAL, ROLENAME_ORIGINALANDSHORT, ROLENAME_SHORT);
     foreach ($alltypes as $type) {
         $roles = get_assignable_roles($coursecontext, $type, false, $admin);
         list($rolenames, $rolecounts, $nameswithcounts) = get_assignable_roles($coursecontext, $type, true, $admin);
         $this->assertEquals($roles, $rolenames);
         foreach ($rolenames as $roleid => $name) {
             if ($roleid == $teacherrole->id or $roleid == $studentrole->id) {
                 $this->assertEquals(1, $rolecounts[$roleid]);
             } else {
                 $this->assertEquals(0, $rolecounts[$roleid]);
             }
             $this->assertSame("{$name} ({$rolecounts[$roleid]})", $nameswithcounts[$roleid]);
         }
     }
 }
示例#16
0
 function definition()
 {
     global $CFG, $DB, $PAGE;
     $mform = $this->_form;
     list($instance, $plugin, $course) = $this->_customdata;
     $coursecontext = context_course::instance($course->id);
     $PAGE->requires->yui_module('moodle-enrol_ilios-groupchoosers', 'M.enrol_ilios.init_groupchoosers', array(array('formid' => $mform->getAttribute('id'), 'courseid' => $course->id)));
     $enrol = $plugin;
     $http = $plugin->get_http_client();
     $mform->addElement('header', 'general', get_string('pluginname', 'enrol_ilios'));
     $mform->addElement('text', 'name', get_string('custominstancename', 'enrol'));
     $mform->setType('name', PARAM_TEXT);
     $options = array(ENROL_INSTANCE_ENABLED => get_string('yes'), ENROL_INSTANCE_DISABLED => get_string('no'));
     $mform->addElement('select', 'status', get_string('status', 'enrol_ilios'), $options);
     $schooloptions = array('' => get_string('choosedots'));
     $programoptions = array('' => get_string('choosedots'));
     $cohortoptions = array('' => get_string('choosedots'));
     $learnergroupoptions = array('' => get_string('none'));
     $subgroupoptions = array('' => get_string('none'));
     if ($instance->id) {
         $synctype = $instance->customchar1;
         $syncid = $instance->customint1;
         $syncinfo = json_decode($instance->customtext1);
         $instance->schoolid = $syncinfo->school->id;
         $school = $http->getbyid('schools', $instance->schoolid);
         $instance->selectschoolindex = "{$instance->schoolid}:{$school->title}";
         $schooloptions = array($instance->selectschoolindex => $school->title);
         $instance->programid = $syncinfo->program->id;
         $program = $http->getbyid('programs', $instance->programid);
         $instance->selectprogramindex = "{$instance->programid}:{$program->shortTitle}:{$program->title}";
         $programoptions = array($instance->selectprogramindex => $program->title);
         $instance->cohortid = $syncinfo->cohort->id;
         $cohort = $http->getbyid('cohorts', $instance->cohortid);
         $instance->selectcohortindex = "{$instance->cohortid}:{$cohort->title}";
         $cohortoptions = array($instance->selectcohortindex => $cohort->title);
         $instance->learnergroupid = '';
         $instance->selectlearnergroupindex = '';
         $instance->subgroupid = '';
         $instance->selectsubgroupindex = '';
         if ($synctype == 'learnerGroup') {
             $instance->learnergroupid = $syncid;
             $group = $http->getbyid('learnerGroups', $instance->learnergroupid);
             $instance->selectlearnergroupindex = "{$instance->learnergroupid}:{$group->title}";
             $grouptitle = $group->title . ' (' . count($group->children) . ')' . ' (' . count($group->users) . ')';
             $learnergroupoptions = array($instance->selectlearnergroupindex => $grouptitle);
             if (!empty($group->parent)) {
                 $processparents = function ($child) use(&$processparents, &$learnergroupoptions, &$grouptitle, &$instance, $http) {
                     $parentgroup = $http->getbyid('learnerGroups', $child->parent);
                     $instance->learnergroupid = $parentgroup->id;
                     $instance->selectlearnergroupindex = "{$instance->learnergroupid}:{$parentgroup->title}";
                     $learnergroupoptions = array("{$instance->learnergroupid}:{$parentgroup->title}" => $parentgroup->title);
                     if (!empty($parentgroup->parent)) {
                         $grouptitle = $parentgroup->title . ' / ' . $grouptitle;
                         $processparents($parentgroup);
                     }
                 };
                 $processparents($group);
                 $instance->subgroupid = $group->id;
                 $instance->selectsubgroupindex = "{$group->id}:{$group->title}";
                 $subgroupoptions = array($instance->selectsubgroupindex => $grouptitle);
             }
         }
     }
     if ($instance->id) {
         $mform->addElement('select', 'selectschool', get_string('school', 'enrol_ilios'), $schooloptions);
         $mform->setConstant('selectschool', $instance->selectschoolindex);
         $mform->hardFreeze('selectschool', $instance->selectschoolindex);
     } else {
         $mform->addElement('select', 'selectschool', get_string('school', 'enrol_ilios'), $schooloptions);
         $mform->addRule('selectschool', get_string('required'), 'required', null, 'client');
         $mform->addHelpButton('selectschool', 'school', 'enrol_ilios');
         $mform->registerNoSubmitButton('updateschooloptions');
         $mform->addElement('submit', 'updateschooloptions', get_string('schooloptionsupdate', 'enrol_ilios'));
     }
     if ($instance->id) {
         $mform->addElement('select', 'selectprogram', get_string('program', 'enrol_ilios'), $programoptions);
         $mform->setConstant('selectprogram', $instance->selectprogramindex);
         $mform->hardFreeze('selectprogram', $instance->selectprogramindex);
     } else {
         $mform->addElement('select', 'selectprogram', get_string('program', 'enrol_ilios'), $programoptions);
         $mform->addRule('selectprogram', get_string('required'), 'required', null, 'client');
         $mform->addHelpButton('selectprogram', 'program', 'enrol_ilios');
         $mform->disabledIf('selectprogram', 'selectschool', 'eq', '');
         $mform->registerNoSubmitButton('updateprogramoptions');
         $mform->addElement('submit', 'updateprogramoptions', get_string('programoptionsupdate', 'enrol_ilios'));
     }
     if ($instance->id) {
         $mform->addElement('select', 'selectcohort', get_string('cohort', 'enrol_ilios'), $cohortoptions);
         $mform->setConstant('selectcohort', $instance->selectcohortindex);
         $mform->hardFreeze('selectcohort', $instance->selectcohortindex);
     } else {
         $mform->addElement('select', 'selectcohort', get_string('cohort', 'enrol_ilios'), $cohortoptions);
         $mform->addRule('selectcohort', get_string('required'), 'required', null, 'client');
         $mform->addHelpButton('selectcohort', 'cohort', 'enrol_ilios');
         $mform->disabledIf('selectcohort', 'selectprogram', 'eq', '');
         $mform->registerNoSubmitButton('updatecohortoptions');
         $mform->addElement('submit', 'updatecohortoptions', get_string('cohortoptionsupdate', 'enrol_ilios'));
     }
     if ($instance->id) {
         $mform->addElement('select', 'selectlearnergroup', get_string('learnergroup', 'enrol_ilios'), $learnergroupoptions);
         $mform->setConstant('selectlearnergroup', $instance->selectlearnergroupindex);
         $mform->hardFreeze('selectlearnergroup', $instance->selectlearnergroupindex);
     } else {
         $mform->addElement('select', 'selectlearnergroup', get_string('learnergroup', 'enrol_ilios'), $learnergroupoptions);
         $mform->addHelpButton('selectlearnergroup', 'learnergroup', 'enrol_ilios');
         $mform->disabledIf('selectlearnergroup', 'selectcohort', 'eq', '');
         $mform->registerNoSubmitButton('updatelearnergroupoptions');
         $mform->addElement('submit', 'updatelearnergroupoptions', get_string('learnergroupoptionsupdate', 'enrol_ilios'));
     }
     if ($instance->id) {
         $mform->addElement('select', 'selectsubgroup', get_string('subgroup', 'enrol_ilios'), $subgroupoptions);
         $mform->setConstant('selectsubgroup', $instance->selectsubgroupindex);
         $mform->hardFreeze('selectsubgroup', $instance->selectsubgroupindex);
     } else {
         $mform->addElement('select', 'selectsubgroup', get_string('subgroup', 'enrol_ilios'), $subgroupoptions);
         $mform->addHelpButton('selectsubgroup', 'subgroup', 'enrol_ilios');
         $mform->disabledIf('selectsubgroup', 'selectlearnergroup', 'eq', '');
     }
     $roles = get_assignable_roles($coursecontext);
     $roles[0] = get_string('none');
     $roles = array_reverse($roles, true);
     // Descending default sortorder.
     $mform->addElement('select', 'roleid', get_string('assignrole', 'enrol_ilios'), $roles);
     $mform->setDefault('roleid', $enrol->get_config('roleid'));
     if ($instance->id and !isset($roles[$instance->roleid])) {
         if ($role = $DB->get_record('role', array('id' => $instance->roleid))) {
             $roles = role_fix_names($roles, $coursecontext, ROLENAME_ALIAS, true);
             $roles[$instance->roleid] = role_get_name($role, $coursecontext);
         } else {
             $roles[$instance->roleid] = get_string('error');
         }
     }
     $groups = array(0 => get_string('none'));
     foreach (groups_get_all_groups($course->id) as $group) {
         $groups[$group->id] = format_string($group->name, true, array('context' => $coursecontext));
     }
     $mform->addElement('select', 'customint6', get_string('addgroup', 'enrol_ilios'), $groups);
     $mform->addElement('hidden', 'courseid', null);
     $mform->setType('courseid', PARAM_INT);
     $mform->addElement('hidden', 'id', null);
     $mform->setType('id', PARAM_INT);
     if ($instance->id) {
         $this->add_action_buttons(true);
     } else {
         $this->add_action_buttons(true, get_string('addinstance', 'enrol'));
     }
     $this->set_data($instance);
     $prog_el =& $mform->getElement('selectschool');
 }
 /**
  * Renders the process stage screen
  *
  * @throws restore_ui_exception
  * @param core_backup_renderer $renderer renderer instance to use
  * @return string HTML code
  */
 public function display(core_backup_renderer $renderer)
 {
     global $PAGE;
     $html = '';
     $haserrors = false;
     $url = new moodle_url($PAGE->url, array('restore' => $this->get_uniqueid(), 'stage' => restore_ui::STAGE_PROCESS, 'substage' => $this->substage, 'sesskey' => sesskey()));
     $html .= html_writer::start_tag('form', array('action' => $url->out_omit_querystring(), 'class' => 'backup-restore', 'enctype' => 'application/x-www-form-urlencoded', 'method' => 'post'));
     foreach ($url->params() as $name => $value) {
         $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $name, 'value' => $value));
     }
     switch ($this->substage) {
         case self::SUBSTAGE_PRECHECKS:
             $results = $this->ui->get_controller()->get_precheck_results();
             $info = $this->ui->get_controller()->get_info();
             $haserrors = !empty($results['errors']);
             $html .= $renderer->precheck_notices($results);
             if (!empty($info->role_mappings->mappings)) {
                 $context = context_course::instance($this->ui->get_controller()->get_courseid());
                 $assignableroles = get_assignable_roles($context, ROLENAME_ALIAS, false);
                 $html .= $renderer->role_mappings($info->role_mappings->mappings, $assignableroles);
             }
             break;
         default:
             throw new restore_ui_exception('backup_ui_must_execute_first');
     }
     $html .= $renderer->substage_buttons($haserrors);
     $html .= html_writer::end_tag('form');
     return $html;
 }
 public function definition()
 {
     global $USER, $CFG, $COURSE;
     $mform =& $this->_form;
     $templateuser = $USER;
     $context = $this->_customdata['context'];
     $mform->addElement('header', 'settingsheader', get_string('toolsettings', 'local_ltiprovider'));
     $tools = array();
     $tools[$context->id] = get_string('course');
     $modinfo = get_fast_modinfo($this->_customdata['courseid']);
     $mods = $modinfo->get_cms();
     foreach ($mods as $mod) {
         $tools[$mod->context->id] = format_string($mod->name);
     }
     $mform->addElement('select', 'contextid', get_string('tooltobeprovide', 'local_ltiprovider'), $tools);
     $mform->setDefault('contextid', $context->id);
     $mform->addElement('checkbox', 'sendgrades', null, get_string('sendgrades', 'local_ltiprovider'));
     $mform->setDefault('sendgrades', 1);
     $mform->addElement('checkbox', 'forcenavigation', null, get_string('forcenavigation', 'local_ltiprovider'));
     $mform->setDefault('forcenavigation', 1);
     $mform->addElement('duration', 'enrolperiod', get_string('enrolperiod', 'local_ltiprovider'), array('optional' => true, 'defaultunit' => 86400));
     $mform->setDefault('enrolperiod', 0);
     $mform->addHelpButton('enrolperiod', 'enrolperiod', 'local_ltiprovider');
     $mform->addElement('date_selector', 'enrolstartdate', get_string('enrolstartdate', 'local_ltiprovider'), array('optional' => true));
     $mform->setDefault('enrolstartdate', 0);
     $mform->addHelpButton('enrolstartdate', 'enrolstartdate', 'local_ltiprovider');
     $mform->addElement('date_selector', 'enrolenddate', get_string('enrolenddate', 'local_ltiprovider'), array('optional' => true));
     $mform->setDefault('enrolenddate', 0);
     $mform->addHelpButton('enrolenddate', 'enrolenddate', 'local_ltiprovider');
     $mform->addElement('text', 'maxenrolled', get_string('maxenrolled', 'local_ltiprovider'));
     $mform->setDefault('maxenrolled', 0);
     $mform->addHelpButton('maxenrolled', 'maxenrolled', 'local_ltiprovider');
     $mform->setType('maxenrolled', PARAM_INT);
     $assignableroles = get_assignable_roles($context);
     $mform->addElement('select', 'croleinst', get_string('courseroleinstructor', 'local_ltiprovider'), $assignableroles);
     $mform->setDefault('croleinst', '3');
     $mform->setAdvanced('croleinst');
     $mform->addElement('select', 'crolelearn', get_string('courserolelearner', 'local_ltiprovider'), $assignableroles);
     $mform->setDefault('crolelearn', '5');
     $mform->setAdvanced('crolelearn');
     $mform->addElement('select', 'aroleinst', get_string('activityroleinstructor', 'local_ltiprovider'), $assignableroles);
     $mform->disabledIf('aroleinst', 'contextid', 'eq', $context->id);
     $mform->setDefault('aroleinst', '3');
     $mform->setAdvanced('aroleinst');
     $mform->addElement('select', 'arolelearn', get_string('activityrolelearner', 'local_ltiprovider'), $assignableroles);
     $mform->disabledIf('arolelearn', 'contextid', 'eq', $context->id);
     $mform->setDefault('arolelearn', '5');
     $mform->setAdvanced('arolelearn');
     $mform->addElement('header', 'remotesystem', get_string('remotesystem', 'local_ltiprovider'));
     $mform->addElement('text', 'secret', get_string('secret', 'local_ltiprovider'), 'maxlength="64" size="25"');
     $mform->setType('secret', PARAM_MULTILANG);
     $mform->setDefault('secret', md5(uniqid(rand(), 1)));
     $mform->addRule('secret', get_string('required'), 'required');
     if (class_exists('textlib')) {
         $textlib = new textlib();
     } else {
         try {
             // for older moodle instances
             $textlib = textlib_get_instance();
         } catch (Exception $e) {
             // updated to use new core_text lib as required by Moodle 2.9
             $textlib = new core_text();
         }
     }
     $choices = $textlib->get_encodings();
     $mform->addElement('select', 'encoding', get_string('remoteencoding', 'local_ltiprovider'), $choices);
     $mform->setDefault('encoding', 'UTF-8');
     $mform->addElement('header', 'defaultheader', get_string('userdefaultvalues', 'local_ltiprovider'));
     $choices = array(0 => get_string('never'), 1 => get_string('always'));
     $mform->addElement('select', 'userprofileupdate', get_string('userprofileupdate', 'local_ltiprovider'), $choices);
     $userprofileupdate = get_config('local_ltiprovider', 'userprofileupdate');
     if ($userprofileupdate != -1) {
         $mform->setDefault('userprofileupdate', $userprofileupdate);
         $mform->freeze('userprofileupdate');
     } else {
         $mform->setDefault('userprofileupdate', 1);
     }
     $choices = array(0 => get_string('emaildisplayno'), 1 => get_string('emaildisplayyes'), 2 => get_string('emaildisplaycourse'));
     $mform->addElement('select', 'maildisplay', get_string('emaildisplay'), $choices);
     $mform->setDefault('maildisplay', 2);
     $mform->addElement('text', 'city', get_string('city'), 'maxlength="100" size="25"');
     $mform->setType('city', PARAM_MULTILANG);
     if (empty($CFG->defaultcity)) {
         $mform->setDefault('city', $templateuser->city);
     } else {
         $mform->setDefault('city', $CFG->defaultcity);
     }
     $mform->addRule('city', get_string('required'), 'required');
     $mform->addElement('select', 'country', get_string('selectacountry'), get_string_manager()->get_list_of_countries());
     if (empty($CFG->country)) {
         $mform->setDefault('country', $templateuser->country);
     } else {
         $mform->setDefault('country', $CFG->country);
     }
     $mform->setAdvanced('country');
     $choices = get_list_of_timezones();
     $choices['99'] = get_string('serverlocaltime');
     $mform->addElement('select', 'timezone', get_string('timezone'), $choices);
     $mform->setDefault('timezone', $templateuser->timezone);
     $mform->setAdvanced('timezone');
     $mform->addElement('select', 'lang', get_string('preferredlanguage'), get_string_manager()->get_list_of_translations());
     $mform->setDefault('lang', $templateuser->lang);
     $mform->setAdvanced('lang');
     $mform->addElement('text', 'institution', get_string('institution'), 'maxlength="40" size="25"');
     $mform->setType('institution', PARAM_MULTILANG);
     $mform->setDefault('institution', $templateuser->institution);
     $mform->setAdvanced('institution');
     $mform->addElement('header', 'memberships', get_string('membershipsettings', 'local_ltiprovider'));
     $mform->addElement('checkbox', 'syncmembers', null, get_string('enablememberssync', 'local_ltiprovider'));
     $mform->disabledIf('syncmembers', 'contextid', 'neq', $context->id);
     $options = array();
     $options[30 * 60] = '30 ' . get_string('minutes');
     $options[60 * 60] = '1 ' . get_string('hour');
     $options[2 * 60 * 60] = '2 ' . get_string('hours');
     $options[6 * 60 * 60] = '6 ' . get_string('hours');
     $options[12 * 60 * 60] = '12 ' . get_string('hours');
     $options[24 * 60 * 60] = '24 ' . get_string('hours');
     $mform->addElement('select', 'syncperiod', get_string('syncperiod', 'local_ltiprovider'), $options);
     $mform->setDefault('syncperiod', 30 * 60);
     $mform->disabledIf('syncperiod', 'contextid', 'neq', $context->id);
     $options = array();
     $options[1] = get_string('enrolandunenrol', 'local_ltiprovider');
     $options[2] = get_string('enrolnew', 'local_ltiprovider');
     $options[3] = get_string('unenrolmissing', 'local_ltiprovider');
     $mform->addElement('select', 'syncmode', get_string('syncmode', 'local_ltiprovider'), $options);
     $mform->setDefault('syncmode', 1);
     $mform->disabledIf('syncmode', 'contextid', 'neq', $context->id);
     $mform->addElement('header', 'layoutandcss', get_string('layoutandcss', 'local_ltiprovider'));
     $mform->addElement('checkbox', 'hidepageheader', null, get_string('hidepageheader', 'local_ltiprovider'));
     $mform->addElement('checkbox', 'hidepagefooter', null, get_string('hidepagefooter', 'local_ltiprovider'));
     $mform->addElement('checkbox', 'hideleftblocks', null, get_string('hideleftblocks', 'local_ltiprovider'));
     $mform->addElement('checkbox', 'hiderightblocks', null, get_string('hiderightblocks', 'local_ltiprovider'));
     $mform->setAdvanced('hideleftblocks');
     $mform->setAdvanced('hiderightblocks');
     $editoroptions = array();
     $displayoptions = array('rows' => '4', 'cols' => '');
     $mform->addElement('textarea', 'customcss', get_string('customcss', 'local_ltiprovider'), $displayoptions, $editoroptions);
     $mform->setAdvanced('customcss');
     $mform->addElement('hidden', 'id');
     $mform->setType('id', PARAM_INT);
     $mform->addElement('hidden', 'courseid');
     $mform->setType('courseid', PARAM_INT);
     $this->add_action_buttons();
 }
        }
    }
    // Process incoming role unassignments
    if (optional_param('remove', false, PARAM_BOOL) && confirm_sesskey()) {
        $userstounassign = $currentuserselector->get_selected_users();
        if (!empty($userstounassign)) {
            foreach ($userstounassign as $removeuser) {
                //unassign only roles that are added manually, no messing with other components!!!
                role_unassign($roleid, $removeuser->id, $context->id, '');
            }
            $potentialuserselector->invalidate_selected_users();
            $currentuserselector->invalidate_selected_users();
            $rolename = $assignableroles[$roleid];
            add_to_log($course->id, 'role', 'unassign', 'mod/adobeconnect/participant.php?contextid=' . $context->id . '&roleid=' . $roleid, $rolename, '', $USER->id);
            // Counts have changed, so reload.
            list($assignableroles, $assigncounts, $nameswithcounts) = get_assignable_roles($context, ROLENAME_BOTH, true);
        }
    }
}
$PAGE->set_pagelayout('admin');
$PAGE->set_title($title);
switch ($context->contextlevel) {
    case CONTEXT_SYSTEM:
        admin_externalpage_setup('assignroles', '', array('contextid' => $contextid, 'roleid' => $roleid));
        break;
    case CONTEXT_USER:
        $fullname = fullname($user, has_capability('moodle/site:viewfullnames', $context));
        $PAGE->set_heading($fullname);
        $showroles = 1;
        break;
    case CONTEXT_COURSECAT:
示例#20
0
    $contexts[$conid]->children = array();
    $contexts[$conid]->roleassignments = array();
}
/// Put the contexts into a tree structure.
foreach ($contexts as $conid => $con) {
    $context = context::instance_by_id($conid);
    $parentcontextid = get_parent_contextid($context);
    if ($parentcontextid) {
        $contexts[$parentcontextid]->children[] = $conid;
    }
}
/// Put the role capabilities into the context tree.
foreach ($roleassignments as $ra) {
    $contexts[$ra->contextid]->roleassignments[$ra->roleid] = $ra;
}
$assignableroles = get_assignable_roles($usercontext, ROLENAME_BOTH);
$overridableroles = get_overridable_roles($usercontext, ROLENAME_BOTH);
/// Print the header
$fullname = fullname($user, has_capability('moodle/site:viewfullnames', $coursecontext));
$straction = get_string('thisusersroles', 'role');
$title = get_string('xroleassignments', 'role', $fullname);
/// Course header
$PAGE->set_title($title);
if ($courseid != SITEID) {
    $PAGE->set_heading($fullname);
} else {
    $PAGE->set_heading($course->fullname);
}
echo $OUTPUT->header();
echo $OUTPUT->heading($title, 3);
echo $OUTPUT->box_start('generalbox boxaligncenter boxwidthnormal');
示例#21
0
 /**
  * Gets all of the assignable roles for this course.
  *
  * @return array
  */
 public function get_assignable_roles($otherusers = false)
 {
     if ($this->_assignableroles === null) {
         $this->_assignableroles = get_assignable_roles($this->context, ROLENAME_ALIAS, false);
         // verifies unassign access control too
     }
     if ($otherusers) {
         if (!is_array($this->_assignablerolesothers)) {
             $this->_assignablerolesothers = array();
             list($courseviewroles, $ignored) = get_roles_with_cap_in_context($this->context, 'moodle/course:view');
             foreach ($this->_assignableroles as $roleid => $role) {
                 if (isset($courseviewroles[$roleid])) {
                     $this->_assignablerolesothers[$roleid] = $role;
                 }
             }
         }
         return $this->_assignablerolesothers;
     } else {
         return $this->_assignableroles;
     }
 }
示例#22
0
/**
 * Returns mapping of all roles using short role name as index.
 * @return array
 */
function uu_allowed_roles_cache()
{
    $allowedroles = get_assignable_roles(get_context_instance(CONTEXT_COURSE, SITEID), ROLENAME_SHORT);
    foreach ($allowedroles as $rid => $rname) {
        $rolecache[$rid] = new stdClass();
        $rolecache[$rid]->id = $rid;
        $rolecache[$rid]->name = $rname;
        if (!is_numeric($rname)) {
            // only non-numeric shortnames are supported!!!
            $rolecache[$rname] = new stdClass();
            $rolecache[$rname]->id = $rid;
            $rolecache[$rname]->name = $rname;
        }
    }
    return $rolecache;
}
 function definition()
 {
     global $CFG, $DB;
     $mform = $this->_form;
     list($instance, $plugin, $course) = $this->_customdata;
     $coursecontext = context_course::instance($course->id);
     $enrol = enrol_get_plugin('delayedcohort');
     $groups = array(0 => get_string('none'));
     foreach (groups_get_all_groups($course->id) as $group) {
         $groups[$group->id] = format_string($group->name, true, array('context' => $coursecontext));
     }
     $mform->addElement('header', 'general', get_string('pluginname', 'enrol_delayedcohort'));
     $mform->addElement('text', 'name', get_string('custominstancename', 'enrol'));
     $mform->setType('name', PARAM_TEXT);
     $options = array(ENROL_INSTANCE_ENABLED => get_string('yes'), ENROL_INSTANCE_DISABLED => get_string('no'));
     $mform->addElement('select', 'status', get_string('status', 'enrol_delayedcohort'), $options);
     if ($instance->id) {
         if ($cohort = $DB->get_record('cohort', array('id' => $instance->customint1))) {
             $cohorts = array($instance->customint1 => format_string($cohort->name, true, array('context' => context::instance_by_id($cohort->contextid))));
         } else {
             $cohorts = array($instance->customint1 => get_string('error'));
         }
         $mform->addElement('select', 'customint1', get_string('cohort', 'cohort'), $cohorts);
         $mform->setConstant('customint1', $instance->customint1);
         $mform->hardFreeze('customint1', $instance->customint1);
     } else {
         $cohorts = array('' => get_string('choosedots'));
         list($sqlparents, $params) = $DB->get_in_or_equal($coursecontext->get_parent_context_ids());
         $sql = "SELECT id, name, idnumber, contextid\n                      FROM {cohort}\n                     WHERE contextid {$sqlparents}\n                  ORDER BY name ASC, idnumber ASC";
         $rs = $DB->get_recordset_sql($sql, $params);
         foreach ($rs as $c) {
             $context = context::instance_by_id($c->contextid);
             if (!has_capability('moodle/cohort:view', $context)) {
                 continue;
             }
             $cohorts[$c->id] = format_string($c->name);
         }
         $rs->close();
         $mform->addElement('select', 'customint1', get_string('cohort', 'cohort'), $cohorts);
         $mform->addRule('customint1', get_string('required'), 'required', null, 'client');
     }
     $roles = get_assignable_roles($coursecontext);
     $roles[0] = get_string('none');
     $roles = array_reverse($roles, true);
     // Descending default sortorder.
     $mform->addElement('select', 'roleid', get_string('assignrole', 'enrol_delayedcohort'), $roles);
     $mform->setDefault('roleid', $enrol->get_config('roleid'));
     if ($instance->id and !isset($roles[$instance->roleid])) {
         if ($role = $DB->get_record('role', array('id' => $instance->roleid))) {
             $roles = role_fix_names($roles, $coursecontext, ROLENAME_ALIAS, true);
             $roles[$instance->roleid] = role_get_name($role, $coursecontext);
         } else {
             $roles[$instance->roleid] = get_string('error');
         }
     }
     $mform->addElement('select', 'customint2', get_string('addgroup', 'enrol_delayedcohort'), $groups);
     $mform->addElement('date_time_selector', 'customint3', get_string('triggerdate', 'enrol_delayedcohort'), array('optional' => true));
     $mform->addElement('date_time_selector', 'customint4', get_string('enddate', 'enrol_delayedcohort'), array('optional' => true));
     $mform->addElement('hidden', 'courseid', null);
     $mform->setType('courseid', PARAM_INT);
     $mform->addElement('hidden', 'id', null);
     $mform->setType('id', PARAM_INT);
     if ($instance->id) {
         $this->add_action_buttons(true);
     } else {
         $this->add_action_buttons(true, get_string('addinstance', 'enrol'));
     }
     $this->set_data($instance);
 }
示例#24
0
 /**
  * Unassign roles from users
  *
  * @param array $unassignments An array of unassignment
  */
 public static function unassign_roles($unassignments)
 {
     global $DB;
     // Do basic automatic PARAM checks on incoming data, using params description
     // If any problems are found then exceptions are thrown with helpful error messages
     $params = self::validate_parameters(self::unassign_roles_parameters(), array('unassignments' => $unassignments));
     $transaction = $DB->start_delegated_transaction();
     foreach ($params['unassignments'] as $unassignment) {
         // Ensure the current user is allowed to run this function in the unassignment context
         $context = self::get_context_from_params($unassignment);
         self::validate_context($context);
         require_capability('moodle/role:assign', $context);
         // throw an exception if user is not able to unassign the role in this context
         $roles = get_assignable_roles($context, ROLENAME_SHORT);
         if (!array_key_exists($unassignment['roleid'], $roles)) {
             throw new invalid_parameter_exception('Can not unassign roleid=' . $unassignment['roleid'] . ' in contextid=' . $unassignment['contextid']);
         }
         role_unassign($unassignment['roleid'], $unassignment['userid'], $context->id);
     }
     $transaction->allow_commit();
 }
示例#25
0
 /**
  * Loads category specific settings in the navigation
  *
  * @return navigation_node
  */
 protected function load_category_settings()
 {
     global $CFG;
     // We can land here while being in the context of a block, in which case we
     // should get the parent context which should be the category one. See self::initialise().
     if ($this->context->contextlevel == CONTEXT_BLOCK) {
         $catcontext = $this->context->get_parent_context();
     } else {
         $catcontext = $this->context;
     }
     // Let's make sure that we always have the right context when getting here.
     if ($catcontext->contextlevel != CONTEXT_COURSECAT) {
         throw new coding_exception('Unexpected context while loading category settings.');
     }
     $categorynode = $this->add($catcontext->get_context_name(), null, null, null, 'categorysettings');
     $categorynode->nodetype = navigation_node::NODETYPE_BRANCH;
     $categorynode->force_open();
     if (can_edit_in_category($catcontext->instanceid)) {
         $url = new moodle_url('/course/management.php', array('categoryid' => $catcontext->instanceid));
         $editstring = get_string('managecategorythis');
         $categorynode->add($editstring, $url, self::TYPE_SETTING, null, null, new pix_icon('i/edit', ''));
     }
     if (has_capability('moodle/category:manage', $catcontext)) {
         $editurl = new moodle_url('/course/editcategory.php', array('id' => $catcontext->instanceid));
         $categorynode->add(get_string('editcategorythis'), $editurl, self::TYPE_SETTING, null, 'edit', new pix_icon('i/edit', ''));
         $addsubcaturl = new moodle_url('/course/editcategory.php', array('parent' => $catcontext->instanceid));
         $categorynode->add(get_string('addsubcategory'), $addsubcaturl, self::TYPE_SETTING, null, 'addsubcat', new pix_icon('i/withsubcat', ''));
     }
     // Assign local roles
     $assignableroles = get_assignable_roles($catcontext);
     if (!empty($assignableroles)) {
         $assignurl = new moodle_url('/' . $CFG->admin . '/roles/assign.php', array('contextid' => $catcontext->id));
         $categorynode->add(get_string('assignroles', 'role'), $assignurl, self::TYPE_SETTING, null, 'roles', new pix_icon('i/assignroles', ''));
     }
     // Override roles
     if (has_capability('moodle/role:review', $catcontext) or count(get_overridable_roles($catcontext)) > 0) {
         $url = new moodle_url('/' . $CFG->admin . '/roles/permissions.php', array('contextid' => $catcontext->id));
         $categorynode->add(get_string('permissions', 'role'), $url, self::TYPE_SETTING, null, 'permissions', new pix_icon('i/permissions', ''));
     }
     // Check role permissions
     if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride', 'moodle/role:override', 'moodle/role:assign'), $catcontext)) {
         $url = new moodle_url('/' . $CFG->admin . '/roles/check.php', array('contextid' => $catcontext->id));
         $categorynode->add(get_string('checkpermissions', 'role'), $url, self::TYPE_SETTING, null, 'checkpermissions', new pix_icon('i/checkpermissions', ''));
     }
     // Cohorts
     if (has_any_capability(array('moodle/cohort:view', 'moodle/cohort:manage'), $catcontext)) {
         $categorynode->add(get_string('cohorts', 'cohort'), new moodle_url('/cohort/index.php', array('contextid' => $catcontext->id)), self::TYPE_SETTING, null, 'cohort', new pix_icon('i/cohort', ''));
     }
     // Manage filters
     if (has_capability('moodle/filter:manage', $catcontext) && count(filter_get_available_in_context($catcontext)) > 0) {
         $url = new moodle_url('/filter/manage.php', array('contextid' => $catcontext->id));
         $categorynode->add(get_string('filters', 'admin'), $url, self::TYPE_SETTING, null, 'filters', new pix_icon('i/filter', ''));
     }
     // Restore.
     if (has_capability('moodle/restore:restorecourse', $catcontext)) {
         $url = new moodle_url('/backup/restorefile.php', array('contextid' => $catcontext->id));
         $categorynode->add(get_string('restorecourse', 'admin'), $url, self::TYPE_SETTING, null, 'restorecourse', new pix_icon('i/restore', ''));
     }
     // Let plugins hook into category settings navigation.
     $pluginsfunction = get_plugins_with_function('extend_navigation_category_settings', 'lib.php');
     foreach ($pluginsfunction as $plugintype => $plugins) {
         foreach ($plugins as $pluginfunction) {
             $pluginfunction($categorynode, $catcontext);
         }
     }
     return $categorynode;
 }
示例#26
0
} else {
    if (!empty($courseid)) {
        // we need this for user tabs in user context
        if (!($course = get_record('course', 'id', $courseid))) {
            error('Invalid course id');
        }
    } else {
        $courseid = SITEID;
        $course = clone $SITE;
    }
}
require_login($course);
require_capability('moodle/role:assign', $context);
/// needed for tabs.php
$overridableroles = get_overridable_roles($context, 'name', ROLENAME_BOTH);
$assignableroles = get_assignable_roles($context, 'name', ROLENAME_BOTH);
/// Get some language strings
$strpotentialusers = get_string('potentialusers', 'role');
$strexistingusers = get_string('existingusers', 'role');
$straction = get_string('assignroles', 'role');
$strroletoassign = get_string('roletoassign', 'role');
$strsearch = get_string('search');
$strshowall = get_string('showall');
$strparticipants = get_string('participants');
$strsearchresults = get_string('searchresults');
$unlimitedperiod = get_string('unlimited');
$defaultperiod = $course->enrolperiod;
for ($i = 1; $i <= 365; $i++) {
    $seconds = $i * 86400;
    $periodmenu[$seconds] = get_string('numdays', '', $i);
}
示例#27
0
 function definition()
 {
     global $USER, $CFG, $DB;
     $courseconfig = get_config('moodlecourse');
     $mform =& $this->_form;
     $course = $this->_customdata['course'];
     $category = $this->_customdata['category'];
     $systemcontext = get_context_instance(CONTEXT_SYSTEM);
     $categorycontext = get_context_instance(CONTEXT_COURSECAT, $category->id);
     $disable_meta = false;
     // basic meta course state protection; server-side security checks not needed
     if (!empty($course)) {
         $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);
         $context = $coursecontext;
         if (course_in_meta($course)) {
             $disable_meta = get_string('metaalreadyinmeta');
         } else {
             if ($course->metacourse) {
                 if ($DB->count_records('course_meta', array('parent_course' => $course->id)) > 0) {
                     $disable_meta = get_string('metaalreadyhascourses');
                 }
             } else {
                 // if users already enrolled directly into coures, do not allow switching to meta,
                 // users with metacourse manage permission are exception
                 // please note that we do not need exact results - anything unexpected here prevents metacourse
                 $managers = get_users_by_capability($coursecontext, 'moodle/course:managemetacourse', 'u.id');
                 $enrolroles = get_roles_with_capability('moodle/course:view', CAP_ALLOW, $coursecontext);
                 if ($users = get_role_users(array_keys($enrolroles), $coursecontext, false, 'u.id', 'u.id ASC')) {
                     foreach ($users as $user) {
                         if (!isset($managers[$user->id])) {
                             $disable_meta = get_string('metaalreadyhasenrolments');
                             break;
                         }
                     }
                 }
                 unset($managers);
                 unset($users);
                 unset($enrolroles);
             }
         }
     } else {
         $coursecontext = null;
         $context = $categorycontext;
     }
     /// form definition with new course defaults
     //--------------------------------------------------------------------------------
     $mform->addElement('header', 'general', get_string('general', 'form'));
     // Must have create course capability in both categories in order to move course
     if (has_capability('moodle/course:create', $categorycontext)) {
         $displaylist = array();
         $parentlist = array();
         make_categories_list($displaylist, $parentlist, 'moodle/course:create');
         $mform->addElement('select', 'category', get_string('category'), $displaylist);
     } else {
         $mform->addElement('hidden', 'category', null);
     }
     $mform->setHelpButton('category', array('coursecategory', get_string('category')));
     $mform->setDefault('category', $category->id);
     $mform->setType('category', PARAM_INT);
     $fullname = get_string('defaultcoursefullname');
     $shortname = get_string('defaultcourseshortname');
     while ($DB->record_exists('course', array('fullname' => $fullname)) or $DB->record_exists('course', array('fullname' => $fullname))) {
         $fullname++;
         $shortname++;
     }
     $mform->addElement('text', 'fullname', get_string('fullnamecourse'), 'maxlength="254" size="50"');
     $mform->setHelpButton('fullname', array('coursefullname', get_string('fullnamecourse')), true);
     $mform->addRule('fullname', get_string('missingfullname'), 'required', null, 'client');
     $mform->setType('fullname', PARAM_MULTILANG);
     if ($course and !has_capability('moodle/course:changefullname', $coursecontext)) {
         $mform->hardFreeze('fullname');
         $mform->setConstant('fullname', $course->fullname);
     }
     $mform->setDefault('fullname', $fullname);
     $mform->addElement('text', 'shortname', get_string('shortnamecourse'), 'maxlength="100" size="20"');
     $mform->setHelpButton('shortname', array('courseshortname', get_string('shortnamecourse')), true);
     $mform->addRule('shortname', get_string('missingshortname'), 'required', null, 'client');
     $mform->setType('shortname', PARAM_MULTILANG);
     if ($course and !has_capability('moodle/course:changeshortname', $coursecontext)) {
         $mform->hardFreeze('shortname');
         $mform->setConstant('shortname', $course->shortname);
     }
     $mform->setDefault('shortname', $shortname);
     $mform->addElement('text', 'idnumber', get_string('idnumbercourse'), 'maxlength="100"  size="10"');
     $mform->setHelpButton('idnumber', array('courseidnumber', get_string('idnumbercourse')), true);
     $mform->setType('idnumber', PARAM_RAW);
     if ($course and !has_capability('moodle/course:changeidnumber', $coursecontext)) {
         $mform->hardFreeze('idnumber');
         $mform->setConstants('idnumber', $course->idnumber);
     }
     $mform->addElement('htmleditor', 'summary', get_string('summary'), array('rows' => '10', 'cols' => '65'));
     $mform->setHelpButton('summary', array('text2', get_string('helptext')), true);
     $mform->setType('summary', PARAM_RAW);
     $courseformats = get_list_of_plugins('course/format');
     $formcourseformats = array();
     foreach ($courseformats as $courseformat) {
         $formcourseformats["{$courseformat}"] = get_string("format{$courseformat}", "format_{$courseformat}");
         if ($formcourseformats["{$courseformat}"] == "[[format{$courseformat}]]") {
             $formcourseformats["{$courseformat}"] = get_string("format{$courseformat}");
         }
     }
     $mform->addElement('select', 'format', get_string('format'), $formcourseformats);
     $mform->setHelpButton('format', array('courseformats', get_string('courseformats')), true);
     $mform->setDefault('format', $courseconfig->format);
     for ($i = 1; $i <= 52; $i++) {
         $sectionmenu[$i] = "{$i}";
     }
     $mform->addElement('select', 'numsections', get_string('numberweeks'), $sectionmenu);
     $mform->setDefault('numsections', $courseconfig->numsections);
     $mform->addElement('date_selector', 'startdate', get_string('startdate'));
     $mform->setHelpButton('startdate', array('coursestartdate', get_string('startdate')), true);
     $mform->setDefault('startdate', time() + 3600 * 24);
     $choices = array();
     $choices['0'] = get_string('hiddensectionscollapsed');
     $choices['1'] = get_string('hiddensectionsinvisible');
     $mform->addElement('select', 'hiddensections', get_string('hiddensections'), $choices);
     $mform->setHelpButton('hiddensections', array('coursehiddensections', get_string('hiddensections')), true);
     $mform->setDefault('hiddensections', $courseconfig->hiddensections);
     $options = range(0, 10);
     $mform->addElement('select', 'newsitems', get_string('newsitemsnumber'), $options);
     $mform->setHelpButton('newsitems', array('coursenewsitems', get_string('newsitemsnumber')), true);
     $mform->setDefault('newsitems', $courseconfig->newsitems);
     $mform->addElement('selectyesno', 'showgrades', get_string('showgrades'));
     $mform->setHelpButton('showgrades', array('coursegrades', get_string('grades')), true);
     $mform->setDefault('showgrades', $courseconfig->showgrades);
     $mform->addElement('selectyesno', 'showreports', get_string('showreports'));
     $mform->setHelpButton('showreports', array('coursereports', get_string('activityreport')), true);
     $mform->setDefault('showreports', $courseconfig->showreports);
     $choices = get_max_upload_sizes($CFG->maxbytes);
     $mform->addElement('select', 'maxbytes', get_string('maximumupload'), $choices);
     $mform->setHelpButton('maxbytes', array('courseuploadsize', get_string('maximumupload')), true);
     $mform->setDefault('maxbytes', $courseconfig->maxbytes);
     if (!empty($CFG->allowcoursethemes)) {
         $themes = array();
         $themes[''] = get_string('forceno');
         $themes += get_list_of_themes();
         $mform->addElement('select', 'theme', get_string('forcetheme'), $themes);
     }
     $meta = array();
     $meta[0] = get_string('no');
     $meta[1] = get_string('yes');
     if ($disable_meta === false) {
         $mform->addElement('select', 'metacourse', get_string('managemeta'), $meta);
         $mform->setHelpButton('metacourse', array('metacourse', get_string('metacourse')), true);
         $mform->setDefault('metacourse', $courseconfig->metacourse);
     } else {
         // no metacourse element - we do not want to change it anyway!
         $mform->addElement('static', 'nometacourse', get_string('managemeta'), (empty($course->metacourse) ? $meta[0] : $meta[1]) . " - {$disable_meta} ");
         $mform->setHelpButton('nometacourse', array('metacourse', get_string('metacourse')), true);
     }
     //--------------------------------------------------------------------------------
     $mform->addElement('header', 'enrolhdr', get_string('enrolments'));
     $choices = array();
     $modules = explode(',', $CFG->enrol_plugins_enabled);
     foreach ($modules as $module) {
         $name = get_string('enrolname', "enrol_{$module}");
         $plugin = enrolment_factory::factory($module);
         if (method_exists($plugin, 'print_entry')) {
             $choices[$name] = $module;
         }
     }
     asort($choices);
     $choices = array_flip($choices);
     $choices = array_merge(array('' => get_string('sitedefault') . ' (' . get_string('enrolname', "enrol_{$CFG->enrol}") . ')'), $choices);
     $mform->addElement('select', 'enrol', get_string('enrolmentplugins'), $choices);
     $mform->setHelpButton('enrol', array('courseenrolmentplugins', get_string('enrolmentplugins')), true);
     $mform->setDefault('enrol', $courseconfig->enrol);
     $roles = get_assignable_roles($context);
     if (!empty($course)) {
         // add current default role, so that it is selectable even when user can not assign it
         if ($current_role = $DB->get_record('role', array('id' => $course->defaultrole))) {
             $roles[$current_role->id] = strip_tags(format_string($current_role->name, true));
         }
     }
     $choices = array();
     if ($sitedefaultrole = $DB->get_record('role', array('id' => $CFG->defaultcourseroleid))) {
         $choices[0] = get_string('sitedefault') . ' (' . $sitedefaultrole->name . ')';
     } else {
         $choices[0] = get_string('sitedefault');
     }
     $choices = $choices + $roles;
     // fix for MDL-9197
     foreach ($choices as $choiceid => $choice) {
         $choices[$choiceid] = format_string($choice);
     }
     $mform->addElement('select', 'defaultrole', get_string('defaultrole', 'role'), $choices);
     $mform->setDefault('defaultrole', 0);
     $radio = array();
     $radio[] =& MoodleQuickForm::createElement('radio', 'enrollable', null, get_string('no'), 0);
     $radio[] =& MoodleQuickForm::createElement('radio', 'enrollable', null, get_string('yes'), 1);
     $radio[] =& MoodleQuickForm::createElement('radio', 'enrollable', null, get_string('enroldate'), 2);
     $mform->addGroup($radio, 'enrollable', get_string('enrollable'), ' ', false);
     $mform->setHelpButton('enrollable', array('courseenrollable2', get_string('enrollable')), true);
     $mform->setDefault('enrollable', $courseconfig->enrollable);
     $mform->addElement('date_selector', 'enrolstartdate', get_string('enrolstartdate'), array('optional' => true));
     $mform->setDefault('enrolstartdate', 0);
     $mform->disabledIf('enrolstartdate', 'enrollable', 'neq', 2);
     $mform->addElement('date_selector', 'enrolenddate', get_string('enrolenddate'), array('optional' => true));
     $mform->setDefault('enrolenddate', 0);
     $mform->disabledIf('enrolenddate', 'enrollable', 'neq', 2);
     $mform->addElement('duration', 'enrolperiod', get_string('enrolperiod'), array('optional' => true, 'defaultunit' => 86400));
     $mform->setDefault('enrolperiod', $courseconfig->enrolperiod);
     //--------------------------------------------------------------------------------
     $mform->addElement('header', 'expirynotifyhdr', get_string('expirynotify'));
     $choices = array();
     $choices['0'] = get_string('no');
     $choices['1'] = get_string('yes');
     $mform->addElement('select', 'expirynotify', get_string('notify'), $choices);
     $mform->setHelpButton('expirynotify', array('expirynotify', get_string('expirynotify')), true);
     $mform->setDefault('expirynotify', $courseconfig->expirynotify);
     $mform->addElement('select', 'notifystudents', get_string('expirynotifystudents'), $choices);
     $mform->setHelpButton('notifystudents', array('expirynotifystudents', get_string('expirynotifystudents')), true);
     $mform->setDefault('notifystudents', $courseconfig->notifystudents);
     $thresholdmenu = array();
     for ($i = 1; $i <= 30; $i++) {
         $seconds = $i * 86400;
         $thresholdmenu[$seconds] = get_string('numdays', '', $i);
     }
     $mform->addElement('select', 'expirythreshold', get_string('expirythreshold'), $thresholdmenu);
     $mform->setHelpButton('expirythreshold', array('expirythreshold', get_string('expirythreshold')), true);
     $mform->setDefault('expirythreshold', $courseconfig->expirythreshold);
     //--------------------------------------------------------------------------------
     $mform->addElement('header', '', get_string('groups', 'group'));
     $choices = array();
     $choices[NOGROUPS] = get_string('groupsnone', 'group');
     $choices[SEPARATEGROUPS] = get_string('groupsseparate', 'group');
     $choices[VISIBLEGROUPS] = get_string('groupsvisible', 'group');
     $mform->addElement('select', 'groupmode', get_string('groupmode'), $choices);
     $mform->setHelpButton('groupmode', array('groupmode', get_string('groupmode')), true);
     $mform->setDefault('groupmode', $courseconfig->groupmode);
     $choices = array();
     $choices['0'] = get_string('no');
     $choices['1'] = get_string('yes');
     $mform->addElement('select', 'groupmodeforce', get_string('force'), $choices);
     $mform->setHelpButton('groupmodeforce', array('groupmodeforce', get_string('groupmodeforce')), true);
     $mform->setDefault('groupmodeforce', $courseconfig->groupmodeforce);
     if (!empty($CFG->enablegroupings)) {
         //default groupings selector
         $options = array();
         $options[0] = get_string('none');
         $mform->addElement('select', 'defaultgroupingid', get_string('defaultgrouping', 'group'), $options);
     }
     //--------------------------------------------------------------------------------
     $mform->addElement('header', '', get_string('availability'));
     $choices = array();
     $choices['0'] = get_string('courseavailablenot');
     $choices['1'] = get_string('courseavailable');
     $mform->addElement('select', 'visible', get_string('availability'), $choices);
     $mform->setHelpButton('visible', array('courseavailability', get_string('availability')), true);
     $mform->setDefault('visible', $courseconfig->visible);
     if ($course and !has_capability('moodle/course:visibility', $coursecontext)) {
         $mform->hardFreeze('visible');
         $mform->setConstant('visible', $course->visible);
     }
     $mform->addElement('passwordunmask', 'enrolpassword', get_string('enrolmentkey'), 'size="25"');
     $mform->setHelpButton('enrolpassword', array('enrolmentkey', get_string('enrolmentkey')), true);
     $mform->setDefault('enrolpassword', '');
     $mform->setDefault('enrolpassword', $courseconfig->enrolpassword);
     $mform->setType('enrolpassword', PARAM_RAW);
     if (empty($course) or $course->password !== '' and $course->id != SITEID) {
         // do not require password in existing courses that do not have password yet - backwards compatibility ;-)
         if (!empty($CFG->enrol_manual_requirekey)) {
             $mform->addRule('enrolpassword', get_string('required'), 'required', null, 'client');
         }
     }
     $choices = array();
     $choices['0'] = get_string('guestsno');
     $choices['1'] = get_string('guestsyes');
     $choices['2'] = get_string('guestskey');
     $mform->addElement('select', 'guest', get_string('opentoguests'), $choices);
     $mform->setHelpButton('guest', array('guestaccess', get_string('opentoguests')), true);
     $mform->setDefault('guest', $courseconfig->guest);
     // If we are creating a course, its enrol method isn't yet chosen, BUT the site has a default enrol method which we can use here
     $enrol_object = $CFG;
     if (!empty($course)) {
         $enrol_object = $course;
     }
     // If the print_entry method exists and the course enrol method isn't manual (both set or inherited from site), show cost
     if (method_exists(enrolment_factory::factory($enrol_object->enrol), 'print_entry') && !($enrol_object->enrol == 'manual' || empty($enrol_object->enrol) && $CFG->enrol == 'manual')) {
         $costgroup = array();
         $currencies = get_list_of_currencies();
         $costgroup[] =& MoodleQuickForm::createElement('text', 'cost', '', 'maxlength="6" size="6"');
         $costgroup[] =& MoodleQuickForm::createElement('select', 'currency', '', $currencies);
         $mform->addGroup($costgroup, 'costgrp', get_string('cost'), '&nbsp;', false);
         //defining a rule for a form element within a group :
         $costgrprules = array();
         //set the message to null to tell Moodle to use a default message
         //available for most rules, fetched from language pack (err_{rulename}).
         $costgrprules['cost'][] = array(null, 'numeric', null, 'client');
         $mform->addGroupRule('costgrp', $costgrprules);
         $mform->setHelpButton('costgrp', array('cost', get_string('cost')), true);
         $mform->setDefault('cost', '');
         $mform->setDefault('currency', empty($CFG->enrol_currency) ? 'USD' : $CFG->enrol_currency);
     }
     //--------------------------------------------------------------------------------
     $mform->addElement('header', '', get_string('language'));
     $languages = array();
     $languages[''] = get_string('forceno');
     $languages += get_list_of_languages();
     $mform->addElement('select', 'lang', get_string('forcelanguage'), $languages);
     $mform->setDefault('lang', $courseconfig->lang);
     //--------------------------------------------------------------------------------
     require_once $CFG->libdir . '/completionlib.php';
     if (completion_info::is_enabled_for_site()) {
         $mform->addElement('header', '', get_string('progress', 'completion'));
         $mform->addElement('select', 'enablecompletion', get_string('completion', 'completion'), array(0 => get_string('completiondisabled', 'completion'), 1 => get_string('completionenabled', 'completion')));
         $mform->setDefault('enablecompletion', $courseconfig->enablecompletion);
     } else {
         $mform->addElement('hidden', 'enablecompletion');
         $mform->setDefault('enablecompletion', 0);
     }
     //--------------------------------------------------------------------------------
     if (has_capability('moodle/site:config', $systemcontext) && (!empty($course->requested) && $CFG->restrictmodulesfor == 'requested' || $CFG->restrictmodulesfor == 'all')) {
         $mform->addElement('header', '', get_string('restrictmodules'));
         $options = array();
         $options['0'] = get_string('no');
         $options['1'] = get_string('yes');
         $mform->addElement('select', 'restrictmodules', get_string('restrictmodules'), $options);
         $mods = array(0 => get_string('allownone'));
         $mods += $DB->get_records_menu('modules', array(), 'name', 'id, name');
         $mform->addElement('select', 'allowedmods', get_string('to'), $mods, array('multiple' => 'multiple', 'size' => '10'));
         $mform->disabledIf('allowedmods', 'restrictmodules', 'eq', 0);
     } else {
         $mform->addElement('hidden', 'restrictmodules', null);
     }
     if ($CFG->restrictmodulesfor == 'all') {
         $mform->setDefault('allowedmods', explode(',', $CFG->defaultallowedmodules));
         if (!empty($CFG->restrictbydefault)) {
             $mform->setDefault('restrictmodules', 1);
         }
     }
     $mform->setType('restrictmodules', PARAM_INT);
     /// customizable role names in this course
     //--------------------------------------------------------------------------------
     $mform->addElement('header', 'rolerenaming', get_string('rolerenaming'));
     $mform->setHelpButton('rolerenaming', array('rolerenaming', get_string('rolerenaming')), true);
     if ($roles = get_all_roles()) {
         if ($coursecontext) {
             $roles = role_fix_names($roles, $coursecontext, ROLENAME_ALIAS_RAW);
         }
         $assignableroles = get_roles_for_contextlevels(CONTEXT_COURSE);
         foreach ($roles as $role) {
             $mform->addElement('text', 'role_' . $role->id, get_string('yourwordforx', '', $role->name));
             if (isset($role->localname)) {
                 $mform->setDefault('role_' . $role->id, $role->localname);
             }
             $mform->setType('role_' . $role->id, PARAM_TEXT);
             if (!in_array($role->id, $assignableroles)) {
                 $mform->setAdvanced('role_' . $role->id);
             }
         }
     }
     //--------------------------------------------------------------------------------
     $this->add_action_buttons();
     //--------------------------------------------------------------------------------
     $mform->addElement('hidden', 'id', null);
     $mform->setType('id', PARAM_INT);
 }
示例#28
0
 /**
  * Returns an array of available roles
  * @return array of availble roles
  */
 function get_roles()
 {
     $context = get_context_instance(CONTEXT_SYSTEM);
     $roles = array(0 => get_string('anyrole', 'filters')) + get_assignable_roles($context);
     return $roles;
 }
示例#29
0
 /**
  * This function gets called by {@link settings_navigation::load_user_settings()} and actually works out
  * what can be shown/done
  *
  * @param int $courseid The current course' id
  * @param int $userid The user id to load for
  * @param string $gstitle The string to pass to get_string for the branch title
  * @return navigation_node|false
  */
 protected function generate_user_settings($courseid, $userid, $gstitle = 'usercurrentsettings')
 {
     global $DB, $CFG, $USER, $SITE;
     if ($courseid != $SITE->id) {
         if (!empty($this->page->course->id) && $this->page->course->id == $courseid) {
             $course = $this->page->course;
         } else {
             $select = context_helper::get_preload_record_columns_sql('ctx');
             $sql = "SELECT c.*, {$select}\n                          FROM {course} c\n                          JOIN {context} ctx ON c.id = ctx.instanceid\n                         WHERE c.id = :courseid AND ctx.contextlevel = :contextlevel";
             $params = array('courseid' => $courseid, 'contextlevel' => CONTEXT_COURSE);
             $course = $DB->get_record_sql($sql, $params, MUST_EXIST);
             context_helper::preload_from_record($course);
         }
     } else {
         $course = $SITE;
     }
     $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);
     // Course context
     $systemcontext = get_system_context();
     $currentuser = $USER->id == $userid;
     if ($currentuser) {
         $user = $USER;
         $usercontext = get_context_instance(CONTEXT_USER, $user->id);
         // User context
     } else {
         $select = context_helper::get_preload_record_columns_sql('ctx');
         $sql = "SELECT u.*, {$select}\n                      FROM {user} u\n                      JOIN {context} ctx ON u.id = ctx.instanceid\n                     WHERE u.id = :userid AND ctx.contextlevel = :contextlevel";
         $params = array('userid' => $userid, 'contextlevel' => CONTEXT_USER);
         $user = $DB->get_record_sql($sql, $params, IGNORE_MISSING);
         if (!$user) {
             return false;
         }
         context_helper::preload_from_record($user);
         // Check that the user can view the profile
         $usercontext = get_context_instance(CONTEXT_USER, $user->id);
         // User context
         $canviewuser = has_capability('moodle/user:viewdetails', $usercontext);
         if ($course->id == $SITE->id) {
             if ($CFG->forceloginforprofiles && !has_coursecontact_role($user->id) && !$canviewuser) {
                 // Reduce possibility of "browsing" userbase at site level
                 // Teachers can browse and be browsed at site level. If not forceloginforprofiles, allow access (bug #4366)
                 return false;
             }
         } else {
             $canviewusercourse = has_capability('moodle/user:viewdetails', $coursecontext);
             $canaccessallgroups = has_capability('moodle/site:accessallgroups', $coursecontext);
             if (!$canviewusercourse && !$canviewuser || !can_access_course($course, $user->id)) {
                 return false;
             }
             if (!$canaccessallgroups && groups_get_course_groupmode($course) == SEPARATEGROUPS) {
                 // If groups are in use, make sure we can see that group
                 return false;
             }
         }
     }
     $fullname = fullname($user, has_capability('moodle/site:viewfullnames', $this->page->context));
     $key = $gstitle;
     if ($gstitle != 'usercurrentsettings') {
         $key .= $userid;
     }
     // Add a user setting branch
     $usersetting = $this->add(get_string($gstitle, 'moodle', $fullname), null, self::TYPE_CONTAINER, null, $key);
     $usersetting->id = 'usersettings';
     if ($this->page->context->contextlevel == CONTEXT_USER && $this->page->context->instanceid == $user->id) {
         // Automatically start by making it active
         $usersetting->make_active();
     }
     // Check if the user has been deleted
     if ($user->deleted) {
         if (!has_capability('moodle/user:update', $coursecontext)) {
             // We can't edit the user so just show the user deleted message
             $usersetting->add(get_string('userdeleted'), null, self::TYPE_SETTING);
         } else {
             // We can edit the user so show the user deleted message and link it to the profile
             if ($course->id == $SITE->id) {
                 $profileurl = new moodle_url('/user/profile.php', array('id' => $user->id));
             } else {
                 $profileurl = new moodle_url('/user/view.php', array('id' => $user->id, 'course' => $course->id));
             }
             $usersetting->add(get_string('userdeleted'), $profileurl, self::TYPE_SETTING);
         }
         return true;
     }
     $userauthplugin = false;
     if (!empty($user->auth)) {
         $userauthplugin = get_auth_plugin($user->auth);
     }
     // Add the profile edit link
     if (isloggedin() && !isguestuser($user) && !is_mnet_remote_user($user)) {
         if (($currentuser || is_siteadmin($USER) || !is_siteadmin($user)) && has_capability('moodle/user:update', $systemcontext)) {
             $url = new moodle_url('/user/editadvanced.php', array('id' => $user->id, 'course' => $course->id));
             $usersetting->add(get_string('editmyprofile'), $url, self::TYPE_SETTING);
         } else {
             if (has_capability('moodle/user:editprofile', $usercontext) && !is_siteadmin($user) || $currentuser && has_capability('moodle/user:editownprofile', $systemcontext)) {
                 if ($userauthplugin && $userauthplugin->can_edit_profile()) {
                     $url = $userauthplugin->edit_profile_url();
                     if (empty($url)) {
                         $url = new moodle_url('/user/edit.php', array('id' => $user->id, 'course' => $course->id));
                     }
                     $usersetting->add(get_string('editmyprofile'), $url, self::TYPE_SETTING);
                 }
             }
         }
     }
     // Change password link
     if ($userauthplugin && $currentuser && !session_is_loggedinas() && !isguestuser() && has_capability('moodle/user:changeownpassword', $systemcontext) && $userauthplugin->can_change_password()) {
         $passwordchangeurl = $userauthplugin->change_password_url();
         if (empty($passwordchangeurl)) {
             $passwordchangeurl = new moodle_url('/login/change_password.php', array('id' => $course->id));
         }
         $usersetting->add(get_string("changepassword"), $passwordchangeurl, self::TYPE_SETTING);
     }
     // View the roles settings
     if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride', 'moodle/role:override', 'moodle/role:manage'), $usercontext)) {
         $roles = $usersetting->add(get_string('roles'), null, self::TYPE_SETTING);
         $url = new moodle_url('/admin/roles/usersroles.php', array('userid' => $user->id, 'courseid' => $course->id));
         $roles->add(get_string('thisusersroles', 'role'), $url, self::TYPE_SETTING);
         $assignableroles = get_assignable_roles($usercontext, ROLENAME_BOTH);
         if (!empty($assignableroles)) {
             $url = new moodle_url('/admin/roles/assign.php', array('contextid' => $usercontext->id, 'userid' => $user->id, 'courseid' => $course->id));
             $roles->add(get_string('assignrolesrelativetothisuser', 'role'), $url, self::TYPE_SETTING);
         }
         if (has_capability('moodle/role:review', $usercontext) || count(get_overridable_roles($usercontext, ROLENAME_BOTH)) > 0) {
             $url = new moodle_url('/admin/roles/permissions.php', array('contextid' => $usercontext->id, 'userid' => $user->id, 'courseid' => $course->id));
             $roles->add(get_string('permissions', 'role'), $url, self::TYPE_SETTING);
         }
         $url = new moodle_url('/admin/roles/check.php', array('contextid' => $usercontext->id, 'userid' => $user->id, 'courseid' => $course->id));
         $roles->add(get_string('checkpermissions', 'role'), $url, self::TYPE_SETTING);
     }
     // Portfolio
     if ($currentuser && !empty($CFG->enableportfolios) && has_capability('moodle/portfolio:export', $systemcontext)) {
         require_once $CFG->libdir . '/portfoliolib.php';
         if (portfolio_instances(true, false)) {
             $portfolio = $usersetting->add(get_string('portfolios', 'portfolio'), null, self::TYPE_SETTING);
             $url = new moodle_url('/user/portfolio.php', array('courseid' => $course->id));
             $portfolio->add(get_string('configure', 'portfolio'), $url, self::TYPE_SETTING);
             $url = new moodle_url('/user/portfoliologs.php', array('courseid' => $course->id));
             $portfolio->add(get_string('logs', 'portfolio'), $url, self::TYPE_SETTING);
         }
     }
     $enablemanagetokens = false;
     if (!empty($CFG->enablerssfeeds)) {
         $enablemanagetokens = true;
     } else {
         if (!is_siteadmin($USER->id) && !empty($CFG->enablewebservices) && has_capability('moodle/webservice:createtoken', get_system_context())) {
             $enablemanagetokens = true;
         }
     }
     // Security keys
     if ($currentuser && $enablemanagetokens) {
         $url = new moodle_url('/user/managetoken.php', array('sesskey' => sesskey()));
         $usersetting->add(get_string('securitykeys', 'webservice'), $url, self::TYPE_SETTING);
     }
     // Repository
     if (!$currentuser && $usercontext->contextlevel == CONTEXT_USER) {
         if (!$this->cache->cached('contexthasrepos' . $usercontext->id)) {
             require_once $CFG->dirroot . '/repository/lib.php';
             $editabletypes = repository::get_editable_types($usercontext);
             $haseditabletypes = !empty($editabletypes);
             unset($editabletypes);
             $this->cache->set('contexthasrepos' . $usercontext->id, $haseditabletypes);
         } else {
             $haseditabletypes = $this->cache->{'contexthasrepos' . $usercontext->id};
         }
         if ($haseditabletypes) {
             $url = new moodle_url('/repository/manage_instances.php', array('contextid' => $usercontext->id));
             $usersetting->add(get_string('repositories', 'repository'), $url, self::TYPE_SETTING);
         }
     }
     // Messaging
     if ($currentuser && has_capability('moodle/user:editownmessageprofile', $systemcontext) || !isguestuser($user) && has_capability('moodle/user:editmessageprofile', $usercontext) && !is_primary_admin($user->id)) {
         $url = new moodle_url('/message/edit.php', array('id' => $user->id));
         $usersetting->add(get_string('editmymessage', 'message'), $url, self::TYPE_SETTING);
     }
     // Blogs
     if ($currentuser && !empty($CFG->bloglevel)) {
         $blog = $usersetting->add(get_string('blogs', 'blog'), null, navigation_node::TYPE_CONTAINER, null, 'blogs');
         $blog->add(get_string('preferences', 'blog'), new moodle_url('/blog/preferences.php'), navigation_node::TYPE_SETTING);
         if (!empty($CFG->useexternalblogs) && $CFG->maxexternalblogsperuser > 0 && has_capability('moodle/blog:manageexternal', get_context_instance(CONTEXT_SYSTEM))) {
             $blog->add(get_string('externalblogs', 'blog'), new moodle_url('/blog/external_blogs.php'), navigation_node::TYPE_SETTING);
             $blog->add(get_string('addnewexternalblog', 'blog'), new moodle_url('/blog/external_blog_edit.php'), navigation_node::TYPE_SETTING);
         }
     }
     // Login as ...
     if (!$user->deleted and !$currentuser && !session_is_loggedinas() && has_capability('moodle/user:loginas', $coursecontext) && !is_siteadmin($user->id)) {
         $url = new moodle_url('/course/loginas.php', array('id' => $course->id, 'user' => $user->id, 'sesskey' => sesskey()));
         $usersetting->add(get_string('loginas'), $url, self::TYPE_SETTING);
     }
     return $usersetting;
 }
示例#30
0
 /**
  * Get the appropriate list of editing icons for a block. This is used
  * to set {@link block_contents::$controls} in {@link block_base::get_contents_for_output()}.
  *
  * @param $output The core_renderer to use when generating the output. (Need to get icon paths.)
  * @return an array in the format for {@link block_contents::$controls}
  */
 public function edit_controls($block)
 {
     global $CFG;
     $controls = array();
     $actionurl = $this->page->url->out(false, array('sesskey' => sesskey()));
     $blocktitle = $block->title;
     if (empty($blocktitle)) {
         $blocktitle = $block->arialabel;
     }
     if ($this->page->user_can_edit_blocks()) {
         // Move icon.
         $str = new lang_string('moveblock', 'block', $blocktitle);
         $controls[] = new action_menu_link_primary(new moodle_url($actionurl, array('bui_moveid' => $block->instance->id)), new pix_icon('t/move', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')), $str, array('class' => 'editing_move'));
     }
     if ($this->page->user_can_edit_blocks() || $block->user_can_edit()) {
         // Edit config icon - always show - needed for positioning UI.
         $str = new lang_string('configureblock', 'block', $blocktitle);
         $controls[] = new action_menu_link_secondary(new moodle_url($actionurl, array('bui_editid' => $block->instance->id)), new pix_icon('t/edit', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')), $str, array('class' => 'editing_edit'));
     }
     if ($this->page->user_can_edit_blocks() && $block->instance_can_be_hidden()) {
         // Show/hide icon.
         if ($block->instance->visible) {
             $str = new lang_string('hideblock', 'block', $blocktitle);
             $url = new moodle_url($actionurl, array('bui_hideid' => $block->instance->id));
             $icon = new pix_icon('t/hide', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
             $attributes = array('class' => 'editing_hide');
         } else {
             $str = new lang_string('showblock', 'block', $blocktitle);
             $url = new moodle_url($actionurl, array('bui_showid' => $block->instance->id));
             $icon = new pix_icon('t/show', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
             $attributes = array('class' => 'editing_show');
         }
         $controls[] = new action_menu_link_secondary($url, $icon, $str, $attributes);
     }
     // Display either "Assign roles" or "Permissions" or "Change permissions" icon (whichever first is available).
     $rolesurl = null;
     if (get_assignable_roles($block->context, ROLENAME_SHORT)) {
         $rolesurl = new moodle_url('/admin/roles/assign.php', array('contextid' => $block->context->id));
         $str = new lang_string('assignrolesinblock', 'block', $blocktitle);
         $icon = 'i/assignroles';
     } else {
         if (has_capability('moodle/role:review', $block->context) or get_overridable_roles($block->context)) {
             $rolesurl = new moodle_url('/admin/roles/permissions.php', array('contextid' => $block->context->id));
             $str = get_string('permissions', 'role');
             $icon = 'i/permissions';
         } else {
             if (has_any_capability(array('moodle/role:safeoverride', 'moodle/role:override', 'moodle/role:assign'), $block->context)) {
                 $rolesurl = new moodle_url('/admin/roles/check.php', array('contextid' => $block->context->id));
                 $str = get_string('checkpermissions', 'role');
                 $icon = 'i/checkpermissions';
             }
         }
     }
     if ($rolesurl) {
         // TODO: please note it is sloppy to pass urls through page parameters!!
         //      it is shortened because some web servers (e.g. IIS by default) give
         //      a 'security' error if you try to pass a full URL as a GET parameter in another URL.
         $return = $this->page->url->out(false);
         $return = str_replace($CFG->wwwroot . '/', '', $return);
         $rolesurl->param('returnurl', $return);
         $controls[] = new action_menu_link_secondary($rolesurl, new pix_icon($icon, $str, 'moodle', array('class' => 'iconsmall', 'title' => '')), $str, array('class' => 'editing_roles'));
     }
     if ($this->user_can_delete_block($block)) {
         // Delete icon.
         $str = new lang_string('deleteblock', 'block', $blocktitle);
         $controls[] = new action_menu_link_secondary(new moodle_url($actionurl, array('bui_deleteid' => $block->instance->id)), new pix_icon('t/delete', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')), $str, array('class' => 'editing_delete'));
     }
     return $controls;
 }