mirror of
https://github.com/moodle/moodle.git
synced 2025-01-19 06:18:28 +01:00
cfb643293c
Previously, if a course module had already been graded, course module completion linked to the course module would not update. This commit adds the option to enable overriding the grade at the course module competency level. This ensures that if enabled and a user completes a module associated with a competency, that competency will be graded appropriately.
299 lines
12 KiB
PHP
299 lines
12 KiB
PHP
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* This page contains navigation hooks for learning plans.
|
|
*
|
|
* @package tool_lp
|
|
* @copyright 2015 Damyon Wiese
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* This function extends the user navigation.
|
|
*
|
|
* @param navigation_node $navigation The navigation node to extend
|
|
* @param stdClass $user The user object
|
|
* @param context_user $usercontext The user context
|
|
* @param stdClass $course The course object
|
|
* @param context_course $coursecontext The context of the course
|
|
*/
|
|
function tool_lp_extend_navigation_user($navigation, $user, $usercontext, $course, $coursecontext) {
|
|
if (!get_config('core_competency', 'enabled')) {
|
|
return;
|
|
}
|
|
|
|
if (\core_competency\plan::can_read_user($user->id)) {
|
|
$node = $navigation->add(get_string('learningplans', 'tool_lp'),
|
|
new moodle_url('/admin/tool/lp/plans.php', array('userid' => $user->id)));
|
|
|
|
if (\core_competency\user_evidence::can_read_user($user->id)) {
|
|
$node->add(get_string('userevidence', 'tool_lp'),
|
|
new moodle_url('/admin/tool/lp/user_evidence_list.php', array('userid' => $user->id)));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Add nodes to myprofile page.
|
|
*
|
|
* @param \core_user\output\myprofile\tree $tree Tree object
|
|
* @param stdClass $user user object
|
|
* @param bool $iscurrentuser
|
|
* @param stdClass $course Course object
|
|
*
|
|
* @return bool
|
|
*/
|
|
function tool_lp_myprofile_navigation(core_user\output\myprofile\tree $tree, $user, $iscurrentuser, $course) {
|
|
if (!get_config('core_competency', 'enabled')) {
|
|
return false;
|
|
} else if (!\core_competency\plan::can_read_user($user->id)) {
|
|
return false;
|
|
}
|
|
|
|
$url = new moodle_url('/admin/tool/lp/plans.php', array('userid' => $user->id));
|
|
$node = new core_user\output\myprofile\node('miscellaneous', 'learningplans',
|
|
get_string('learningplans', 'tool_lp'), null, $url);
|
|
$tree->add_node($node);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This function extends the category navigation to add learning plan links.
|
|
*
|
|
* @param navigation_node $navigation The navigation node to extend
|
|
* @param context $coursecategorycontext The context of the course category
|
|
*/
|
|
function tool_lp_extend_navigation_category_settings($navigation, $coursecategorycontext) {
|
|
if (!get_config('core_competency', 'enabled')) {
|
|
return false;
|
|
}
|
|
|
|
// We check permissions before renderring the links.
|
|
$templatereadcapability = \core_competency\template::can_read_context($coursecategorycontext);
|
|
$competencyreadcapability = \core_competency\competency_framework::can_read_context($coursecategorycontext);
|
|
if (!$templatereadcapability && !$competencyreadcapability) {
|
|
return false;
|
|
}
|
|
|
|
// The link to the learning plan page.
|
|
if ($templatereadcapability) {
|
|
$title = get_string('templates', 'tool_lp');
|
|
$path = new moodle_url("/admin/tool/lp/learningplans.php", array('pagecontextid' => $coursecategorycontext->id));
|
|
$settingsnode = navigation_node::create($title,
|
|
$path,
|
|
navigation_node::TYPE_SETTING,
|
|
null,
|
|
'learningplantemplates',
|
|
new pix_icon('i/competencies', ''));
|
|
if (isset($settingsnode)) {
|
|
$settingsnode->set_force_into_more_menu(true);
|
|
$navigation->add_node($settingsnode);
|
|
}
|
|
}
|
|
|
|
// The link to the competency frameworks page.
|
|
if ($competencyreadcapability) {
|
|
$title = get_string('competencyframeworks', 'tool_lp');
|
|
$path = new moodle_url("/admin/tool/lp/competencyframeworks.php", array('pagecontextid' => $coursecategorycontext->id));
|
|
$settingsnode = navigation_node::create($title,
|
|
$path,
|
|
navigation_node::TYPE_SETTING,
|
|
null,
|
|
'competencyframeworks',
|
|
new pix_icon('i/competencies', ''));
|
|
if (isset($settingsnode)) {
|
|
$settingsnode->set_force_into_more_menu(true);
|
|
$navigation->add_node($settingsnode);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inject the competencies elements into all moodle module settings forms.
|
|
*
|
|
* @param moodleform $formwrapper The moodle quickforms wrapper object.
|
|
* @param MoodleQuickForm $mform The actual form object (required to modify the form).
|
|
*/
|
|
function tool_lp_coursemodule_standard_elements($formwrapper, $mform) {
|
|
global $CFG, $COURSE;
|
|
|
|
if (!get_config('core_competency', 'enabled')) {
|
|
return;
|
|
} else if (!has_capability('moodle/competency:coursecompetencymanage', $formwrapper->get_context())) {
|
|
return;
|
|
}
|
|
|
|
$mform->addElement('header', 'competenciessection', get_string('competencies', 'core_competency'));
|
|
|
|
MoodleQuickForm::registerElementType('course_competencies',
|
|
"$CFG->dirroot/$CFG->admin/tool/lp/classes/course_competencies_form_element.php",
|
|
'tool_lp_course_competencies_form_element');
|
|
$cmid = null;
|
|
if ($cm = $formwrapper->get_coursemodule()) {
|
|
$cmid = $cm->id;
|
|
}
|
|
$options = array(
|
|
'courseid' => $COURSE->id,
|
|
'cmid' => $cmid
|
|
);
|
|
$mform->addElement('course_competencies', 'competencies', get_string('modcompetencies', 'tool_lp'), $options);
|
|
$mform->addHelpButton('competencies', 'modcompetencies', 'tool_lp');
|
|
MoodleQuickForm::registerElementType('course_competency_rule',
|
|
"$CFG->dirroot/$CFG->admin/tool/lp/classes/course_competency_rule_form_element.php",
|
|
'tool_lp_course_competency_rule_form_element');
|
|
// Reuse the same options.
|
|
$mform->addElement('course_competency_rule', 'competency_rule', get_string('uponcoursemodulecompletion', 'tool_lp'), $options);
|
|
|
|
$overrideelementfile = "$CFG->dirroot/$CFG->admin/tool/lp/classes/course_competency_overridegrade_form_element.php";
|
|
MoodleQuickForm::registerElementType('course_competency_overridegrade', $overrideelementfile,
|
|
'tool_lp_course_competency_overridegrade_form_element');
|
|
$mform->addElement('course_competency_overridegrade', 'override_grade', get_string('overridegrade', 'tool_lp'), $options);
|
|
$mform->hideIf('override_grade', 'competency_rule', 'noteq', \core_competency\competency::OUTCOME_COMPLETE + 1);
|
|
}
|
|
|
|
/**
|
|
* Hook the add/edit of the course module.
|
|
*
|
|
* @param stdClass $data Data from the form submission.
|
|
* @param stdClass $course The course.
|
|
*/
|
|
function tool_lp_coursemodule_edit_post_actions($data, $course) {
|
|
if (!get_config('core_competency', 'enabled')) {
|
|
return $data;
|
|
}
|
|
|
|
// It seems like the form did not contain any of the form fields, we can return.
|
|
if (!isset($data->competency_rule) && !isset($data->competencies)) {
|
|
return $data;
|
|
}
|
|
|
|
// We bypass the API here and go direct to the persistent layer - because we don't want to do permission
|
|
// checks here - we need to load the real list of existing course module competencies.
|
|
$existing = \core_competency\course_module_competency::list_course_module_competencies($data->coursemodule);
|
|
|
|
$existingids = array();
|
|
foreach ($existing as $cmc) {
|
|
array_push($existingids, $cmc->get('competencyid'));
|
|
}
|
|
|
|
$newids = isset($data->competencies) ? $data->competencies : array();
|
|
|
|
$removed = array_diff($existingids, $newids);
|
|
$added = array_diff($newids, $existingids);
|
|
|
|
foreach ($removed as $removedid) {
|
|
\core_competency\api::remove_competency_from_course_module($data->coursemodule, $removedid);
|
|
}
|
|
foreach ($added as $addedid) {
|
|
\core_competency\api::add_competency_to_course_module($data->coursemodule, $addedid);
|
|
}
|
|
|
|
if (isset($data->competency_rule)) {
|
|
$overridegrade = isset($data->override_grade) ? $data->override_grade : false;
|
|
|
|
// Now update the rules for each course_module_competency.
|
|
$current = \core_competency\api::list_course_module_competencies_in_course_module($data->coursemodule);
|
|
foreach ($current as $coursemodulecompetency) {
|
|
\core_competency\api::set_course_module_competency_ruleoutcome($coursemodulecompetency, $data->competency_rule,
|
|
$overridegrade);
|
|
}
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Map icons for font-awesome themes.
|
|
*/
|
|
function tool_lp_get_fontawesome_icon_map() {
|
|
return [
|
|
'tool_lp:url' => 'fa-external-link'
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Render a short bit of information about a competency.
|
|
*
|
|
* @param \core_competency\competency $competency The competency to show.
|
|
* @param \core_competency\competency_framework $framework The competency framework.
|
|
* @param boolean $includerelated If true, show related competencies.
|
|
* @param boolean $includecourses If true, show courses using this competency.
|
|
* @param boolean $skipenabled If true, show this competency even if competencies are disabled.
|
|
* @return string The html summary for the competency.
|
|
*/
|
|
function tool_lp_render_competency_summary(\core_competency\competency $competency,
|
|
\core_competency\competency_framework $framework,
|
|
$includerelated,
|
|
$includecourses,
|
|
$skipenabled = false) {
|
|
global $PAGE;
|
|
|
|
if (!$skipenabled && !get_config('core_competency', 'enabled')) {
|
|
return;
|
|
}
|
|
|
|
$summary = new \tool_lp\output\competency_summary($competency, $framework, $includerelated, $includecourses);
|
|
|
|
$output = $PAGE->get_renderer('tool_lp');
|
|
|
|
return $output->render($summary);
|
|
}
|
|
|
|
/**
|
|
* Inject a course competency picker into the form.
|
|
*
|
|
* @param MoodleQuickForm $mform The actual form object (required to modify the form).
|
|
* @param integer $courseid - SITEID or a course id
|
|
* @param context $context - The page context
|
|
* @param string $elementname - The name of the form element to create
|
|
*/
|
|
function tool_lp_competency_picker($mform, $courseid, $context, $elementname) {
|
|
global $CFG, $COURSE;
|
|
|
|
if (!get_config('core_competency', 'enabled')) {
|
|
return;
|
|
}
|
|
|
|
if ($courseid == SITEID) {
|
|
if (!has_capability('moodle/competency:competencymanage', $context)) {
|
|
return;
|
|
}
|
|
|
|
MoodleQuickForm::registerElementType('site_competencies',
|
|
"$CFG->dirroot/$CFG->admin/tool/lp/classes/site_competencies_form_element.php",
|
|
'tool_lp_site_competencies_form_element');
|
|
$mform->addElement('site_competencies', $elementname);
|
|
} else {
|
|
if (!has_capability('moodle/competency:coursecompetencymanage', $context)) {
|
|
return;
|
|
}
|
|
|
|
MoodleQuickForm::registerElementType('course_competencies',
|
|
"$CFG->dirroot/$CFG->admin/tool/lp/classes/course_competencies_form_element.php",
|
|
'tool_lp_course_competencies_form_element');
|
|
$options = array(
|
|
'courseid' => $COURSE->id
|
|
);
|
|
$mform->addElement('course_competencies', $elementname, get_string('modcompetencies', 'tool_lp'), $options);
|
|
}
|
|
$mform->setType($elementname, PARAM_SEQUENCE);
|
|
}
|