moodle/moodle
3
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-08-05 17:06:53 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

MDL-51648 cbe: Add a user competency plan summary page (allows grading)

Browse source
This commit is contained in:
Damyon Wiese 2015-12-07 14:27:44 +08:00 • committed by Frederic Massart
parent 1ab69549ad
commit 3c659fc202
25 changed files with 1166 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

1
admin/tool/lp/amd/build/grade_user_competency_inline.min.js vendored Normal file
View file

@ -0,0 +1 @@
define(["jquery","core/notification","core/ajax","core/log"],function(a,b,c,d){var e=function(a,b,c,d,e){this._formId=a,this._scaleConfig=b,this._competencyId=c,this._userId=d,this._planId=e,this._buildSelect(),this._addListeners()};return e.prototype._buildSelect=function(){var b=1;for(b=1;b<this._scaleConfig.length;b++){var c=this._scaleConfig[b],d=a("<option></option>");d.text(c.name),d.attr("value",c.id),c.scaledefault&&d.attr("selected","selected"),a(document.getElementById(this._formId)).find("select").append(d)}},e.prototype._handleGrade=function(d){var e=this,f=a(document.getElementById(this._formId)).find("select").val();if(d.preventDefault(),this._planId>0){var g={userid:this._userId,competencyid:this._competencyId,planid:this._planId,grade:f,override:!0};c.call([{methodname:"tool_lp_grade_competency_in_plan",args:g,done:function(a){e._trigger("competencyupdated",{args:g,evidence:a})},fail:b.exception}])}},e.prototype._handleSuggest=function(d){var e=this,f=a(document.getElementById(this._formId)).find("select").val();if(d.preventDefault(),this._planId>0){var g={userid:this._userId,competencyid:this._competencyId,planid:this._planId,grade:f,override:!1};c.call([{methodname:"tool_lp_grade_competency_in_plan",args:g,done:function(a){e._trigger("competencyupdated",{args:g,evidence:a})},fail:b.exception}])}},e.prototype._addListeners=function(){var b=this,c=a(document.getElementById(this._formId)),e=c.find('[data-action="grade"]');e.on("click",function(a){b._handleGrade.call(b,a)});var f=c.find('[data-action="suggest"]');f.on("click",function(a){b._handleSuggest.call(b,a)}),this.on("competencyupdated",function(a,b){d.debug("Competency updated"),d.debug(b)})},e.prototype._trigger=function(c,d){return"competencyupdated"!=c&&b.exception("Invalid event name:"+c),a(document.getElementById(this._formId)).trigger(c,d),this},e.prototype.on=function(c,d){return"competencyupdated"!=c&&b.exception("Invalid event name:"+c),a(document.getElementById(this._formId)).on(c,d),this},e.prototype._formId=null,e.prototype._scaleConfig=null,e.prototype._competencyId=null,e.prototype._userId=null,e.prototype._planId=null,e});

1
admin/tool/lp/amd/build/user_competency_info.min.js vendored Normal file
View file

@ -0,0 +1 @@
define(["jquery","core/notification","core/ajax","core/templates"],function(a,b,c,d){var e=function(a,b,c,d){this._rootElement=a,this._competencyId=b,this._userId=c,this._planId=d};return e.prototype.reload=function(){var a=this,e=[];e=c.call([{methodname:"tool_lp_read_user_competency_summary",args:{userid:this._userId,competencyid:this._competencyId,planid:this._planId}}]),e[0].done(function(c){d.render("tool_lp/user_competency_info",c).done(function(b,c){d.replaceNode(a._rootElement,b,c)}).fail(b.exception)}).fail(b.exception)},e.prototype._rootElement=null,e.prototype._planId=null,e.prototype._competencyId=null,e.prototype._userId=null,e});

194
admin/tool/lp/amd/src/grade_user_competency_inline.js Normal file
View file

@ -0,0 +1,194 @@
// 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/>.
/**
* Module to enable inline editing of a comptency grade.
*
* @package tool_lp
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
define(['jquery', 'core/notification', 'core/ajax', 'core/log'], function($, notification, ajax, log) {
/**
* InlineEditor
*
* @param {String} The id of the form element.
* @param {Object} The scale config for this competency.
* @param {Number} The id of the competency.
* @param {Number} The id of the user.
* @param {Number} The id of the plan.
*/
var InlineEditor = function(formId, scaleConfig, competencyId, userId, planId) {
this._formId = formId;
this._scaleConfig = scaleConfig;
this._competencyId = competencyId;
this._userId = userId;
this._planId = planId;
this._buildSelect();
this._addListeners();
};
/**
* Add all the options to the select.
*
* @method _buildSelect
*/
InlineEditor.prototype._buildSelect = function() {
var i = 1;
// The first item is the scaleid - we don't care about that.
for (i = 1; i < this._scaleConfig.length; i++) {
var optionConfig = this._scaleConfig[i];
var optionEle = $('<option></option>');
optionEle.text(optionConfig.name);
optionEle.attr('value', optionConfig.id);
if (optionConfig.scaledefault) {
optionEle.attr('selected', 'selected');
}
$(document.getElementById(this._formId)).find('select').append(optionEle);
}
};
/**
* Handle grade button click
*
* @param {Event} event
* @method _handleGrade
*/
InlineEditor.prototype._handleGrade = function(event) {
var currentthis = this;
var grade = $(document.getElementById(this._formId)).find('select').val();
event.preventDefault();
if (this._planId > 0) {
var args = {
userid: this._userId,
competencyid: this._competencyId,
planid: this._planId,
grade: grade,
override: true
};
ajax.call([{
methodname: 'tool_lp_grade_competency_in_plan',
args: args,
done: function(evidence) {
currentthis._trigger('competencyupdated', { args: args, evidence: evidence});
},
fail: notification.exception
}]);
}
};
/**
* Handle suggest button click
*
* @param {Event} event
* @method _handleSuggest
*/
InlineEditor.prototype._handleSuggest = function(event) {
var currentthis = this;
var grade = $(document.getElementById(this._formId)).find('select').val();
event.preventDefault();
if (this._planId > 0) {
var args = {
userid: this._userId,
competencyid: this._competencyId,
planid: this._planId,
grade: grade,
override: false
};
ajax.call([{
methodname: 'tool_lp_grade_competency_in_plan',
args: args,
done: function(evidence) {
currentthis._trigger('competencyupdated', { args: args, evidence: evidence});
},
fail: notification.exception
}]);
}
};
/**
* Setup event listeners.
*
* @method _addListeners
*/
InlineEditor.prototype._addListeners = function() {
var currentthis = this;
var form = $(document.getElementById(this._formId));
var gradebutton = form.find('[data-action="grade"]');
gradebutton.on('click', function(event) {
currentthis._handleGrade.call(currentthis, event);
});
var suggestbutton = form.find('[data-action="suggest"]');
suggestbutton.on('click', function(event) {
currentthis._handleSuggest.call(currentthis, event);
});
this.on('competencyupdated', function(event, args) {
log.debug('Competency updated');
log.debug(args);
});
};
/**
* Trigger an event from this module.
*
* @param {String} eventname - Only 'competencyupdated' is supported
* @param {Object} arguments - Additional arguments for the event.
* @return InlineEditor for chaining
* @method _trigger
*/
InlineEditor.prototype._trigger = function(eventname, data) {
if (eventname != 'competencyupdated') {
notification.exception('Invalid event name:' + eventname);
}
$(document.getElementById(this._formId)).trigger(eventname, data);
return this;
};
/**
* Attach a listener for events triggered from this module.
*
* @param {String} eventname - Only 'competencyupdated' is supported
* @param {Function} handler - Event handler to call when this event is triggered.
* @return InlineEditor for chaining
* @method on
*/
InlineEditor.prototype.on = function(eventname, handler) {
if (eventname != 'competencyupdated') {
notification.exception('Invalid event name:' + eventname);
}
$(document.getElementById(this._formId)).on(eventname, handler);
return this;
};
/** @type {String} The id of the select element. */
InlineEditor.prototype._formId = null;
/** @type {Object} The scale config for this competency. */
InlineEditor.prototype._scaleConfig = null;
/** @type {Number} The id of the competency. */
InlineEditor.prototype._competencyId = null;
/** @type {Number} The id of the user. */
InlineEditor.prototype._userId = null;
/** @type {Number} The id of the plan. */
InlineEditor.prototype._planId = null;
return /** @alias module:tool_lp/grade_user_competency_inline */ InlineEditor;
});

73
admin/tool/lp/amd/src/user_competency_info.js Normal file
View file

@ -0,0 +1,73 @@
// 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/>.
/**
* Module to refresh a user competency summary in a page.
*
* @package tool_lp
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
define(['jquery', 'core/notification', 'core/ajax', 'core/templates'], function($, notification, ajax, templates) {
/**
* Info
*
* @param {JQuery} Selector to replace when the information needs updating.
* @param {Number} The id of the competency.
* @param {Number} The id of the user.
* @param {Number} The id of the plan.
*/
var Info = function(rootElement, competencyId, userId, planId) {
this._rootElement = rootElement;
this._competencyId = competencyId;
this._userId = userId;
this._planId = planId;
};
/**
* Reload the info for this user competency.
*
* @method reload
*/
Info.prototype.reload = function() {
var self = this,
promises = [];
promises = ajax.call([{
methodname: 'tool_lp_read_user_competency_summary',
args: { userid: this._userId, competencyid: this._competencyId, planid: this._planId }
}]);
promises[0].done(function(context) {
templates.render('tool_lp/user_competency_info', context).done(function(html, js) {
templates.replaceNode(self._rootElement, html, js);
}).fail(notification.exception);
}).fail(notification.exception);
};
/** @type {JQuery} The root element to replace in the DOM. */
Info.prototype._rootElement = null;
/** @type {Number} The id of the plan. */
Info.prototype._planId = null;
/** @type {Number} The id of the competency. */
Info.prototype._competencyId = null;
/** @type {Number} The id of the user. */
Info.prototype._userId = null;
return /** @alias module:tool_lp/grade_user_competency_inline */ Info;
});

106
admin/tool/lp/classes/api.php
View file

@ -2387,6 +2387,40 @@ class api {
}
}
/**
* List all the evidence for a user competency
*
* @param int $usercompetencyid The user competency id - if 0, then userid and competencyid are used.
* @param int $userid The user id - only used if usercompetencyid is 0.
* @param int $competencyid The competency id - only used it usercompetencyid is 0.
* @return array of \tool_lp\evidence
*/
public static function list_evidence($usercompetencyid = 0,
$userid = 0,
$competencyid = 0,
$sort = 'timecreated',
$order = 'DESC',
$skip = 0,
$limit = 0) {
if ($usercompetencyid > 0) {
$usercompetency = new user_competency($usercompetencyid);
$context = context_user::instance($usercompetency->get_userid());
require_capability('tool/lp:planview', $context);
} else {
$context = context_user::instance($userid);
require_capability('tool/lp:planview', $context);
$usercompetency = user_competency::get_record(array('userid' => $userid, 'competencyid' => $competencyid));
if (!$usercompetency) {
return array();
}
}
return evidence::get_records(array('usercompetencyid' => $usercompetency->get_id()), $sort, $order, $skip, $limit);
}
/**
* Create an evidence from a list of parameters.
*
@ -2683,4 +2717,76 @@ class api {
);
}
}
/**
* Returns a user competency data.
*
* @param int $userid
* @param array of int $competencyids
* @return array of \tool_lp\user_competency
*/
public static function read_user_competencies($userid, $competencyids) {
$context = context_user::instance($userid);
require_capability('tool/lp:planview', $context);
return user_competency::get_multiple($userid, $competencyids);
}
/**
* Manually grade a user competency from the plans page.
*
* @param int $userid
* @param int $competencyid
* @param int $planid
* @param int $grade
* @param boolean $override
* @return array of \tool_lp\user_competency
*/
public static function grade_competency_in_plan($userid, $competencyid, $planid, $grade, $override) {
global $USER;
$context = context_user::instance($userid);
if ($override) {
require_capability('tool/lp:competencygrade', $context);
} else {
require_capability('tool/lp:competencysuggestgrade', $context);
}
// Verify the data.
$plan = new plan($planid);
if ($plan->get_userid() != $userid) {
throw new coding_exception('The plan does not belong to this user: ' . $planid . ', ' . $userid);
}
$userplancompetencies = self::list_plan_competencies($plan);
$competency = null;
foreach ($userplancompetencies as $userplancompetency) {
if ($userplancompetency->competency->get_id() == $competencyid) {
$competency = $userplancompetency->competency;
}
}
if (!$competency) {
throw new coding_exception('The competency does not belong to this plan: ' . $competencyid . ', ' . $planid);
}
$action = evidence::ACTION_OVERRIDE;
$desckey = 'evidence_manualoverrideinplan';
if (!$override) {
$action = evidence::ACTION_SUGGEST;
$desckey = 'evidence_manualsuggestinplan';
}
return self::add_evidence($userid,
$competency,
$context->id,
$action,
$desckey,
'tool_lp',
$plan->get_name(),
false,
null,
$grade,
$USER->id);
}
}

188
admin/tool/lp/classes/external.php
View file

@ -47,6 +47,7 @@ use tool_lp\external\cohort_summary_exporter;
use tool_lp\external\user_summary_exporter;
use tool_lp\external\user_competency_exporter;
use tool_lp\external\user_competency_plan_exporter;
use tool_lp\external\user_competency_summary_exporter;
use tool_lp\external\user_evidence_exporter;
use tool_lp\external\user_evidence_competency_exporter;
use tool_lp\external\competency_exporter;
@ -54,6 +55,7 @@ use tool_lp\external\course_competency_exporter;
use tool_lp\external\course_summary_exporter;
use tool_lp\external\plan_exporter;
use tool_lp\external\template_exporter;
use tool_lp\external\evidence_exporter;
/**
* This is the external API for this tool.
@ -3546,8 +3548,7 @@ class external extends external_api {
// The following section is not learning plan specific and so has not been moved to the api.
// Retrieve the scale value from the database.
$scale = grade_scale::fetch(array('id' => $scaleid));
// Reverse the array so that high levels are at the top.
$scalevalues = array_reverse($scale->load_items());
$scalevalues = $scale->load_items();
foreach ($scalevalues as $key => $value) {
// Add a key (make the first value 1).
$scalevalues[$key] = array(
@ -4115,4 +4116,187 @@ class external extends external_api {
return new external_value(PARAM_BOOL, 'True if the update was successful');
}
/**
* Returns description of grade_competency_in_plan() parameters.
*
* @return \external_function_parameters
*/
public static function grade_competency_in_plan_parameters() {
$userid = new external_value(
PARAM_INT,
'User id',
VALUE_REQUIRED
);
$competencyid = new external_value(
PARAM_INT,
'Competency id',
VALUE_REQUIRED
);
$planid = new external_value(
PARAM_INT,
'Plan id',
VALUE_REQUIRED
);
$grade = new external_value(
PARAM_INT,
'New grade',
VALUE_REQUIRED
);
$override = new external_value(
PARAM_BOOL,
'Override the grade, or just suggest it',
VALUE_REQUIRED
);
$params = array(
'userid' => $userid,
'competencyid' => $competencyid,
'planid' => $planid,
'grade' => $grade,
'override' => $override
);
return new external_function_parameters($params);
}
/**
* Grade a competency in a plan.
*
* @param int $userid The user id
* @param int $competencyid The competency id
* @param int $planid The plan id
* @param int $grade The new grade value
* @param bool $override Override the grade or only suggest it
* @return bool
*/
public static function grade_competency_in_plan($userid, $competencyid, $planid, $grade, $override) {
global $USER, $PAGE;
$params = self::validate_parameters(self::grade_competency_in_plan_parameters(),
array(
'userid' => $userid,
'competencyid' => $competencyid,
'planid' => $planid,
'grade' => $grade,
'override' => $override
));
self::validate_context(context_user::instance($params['userid']));
$output = $PAGE->get_renderer('tool_lp');
$evidence = api::grade_competency_in_plan($params['userid'], $params['competencyid'], $params['planid'], $params['grade'], $params['override']);
$competency = api::read_competency($params['competencyid']);
$scale = $competency->get_scale();
$exporter = new evidence_exporter($evidence, array('actionuser' => $USER, 'scale' => $scale));
return $exporter->export($output);
}
/**
* Returns description of grade_competency_in_plan() result value.
*
* @return \external_value
*/
public static function grade_competency_in_plan_returns() {
return evidence_exporter::get_read_structure();
}
/**
* Returns description of read_user_competency_summary() parameters.
*
* @return \external_function_parameters
*/
public static function read_user_competency_summary_parameters() {
$userid = new external_value(
PARAM_INT,
'Data base record id for the user',
VALUE_REQUIRED
);
$competencyid = new external_value(
PARAM_INT,
'Data base record id for the competency',
VALUE_REQUIRED
);
$planid = new external_value(
PARAM_INT,
'Data base record id for the plan',
VALUE_DEFAULT,
0
);
$params = array(
'userid' => $userid,
'competencyid' => $competencyid,
'planid' => $planid,
);
return new external_function_parameters($params);
}
/**
* Read a user competency summary.
*
* @param int $userid The user id
* @param int $competencyid The competency id
* @param int $planid The plan id
* @return \stdClass
*/
public static function read_user_competency_summary($userid, $competencyid, $planid) {
global $PAGE, $DB, $CFG;
require_once($CFG->dirroot . '/user/lib.php');
$params = self::validate_parameters(self::read_user_competency_summary_parameters(),
array(
'userid' => $userid,
'competencyid' => $competencyid,
'planid' => $planid
));
$context = context_user::instance($params['userid']);
self::validate_context($context);
$output = $PAGE->get_renderer('tool_lp');
require_capability('tool/lp:planview', $context);
$list = api::read_user_competencies($params['userid'], array($params['competencyid']));
if ($list) {
$usercompetency = array_pop($list);
} else {
$record = (object)array('userid' => $params['userid'], 'competencyid' => $params['competencyid']);
$usercompetency = new user_competency(0, $record);
}
$competency = $usercompetency->get_competency();
$relatedcompetencies = api::list_related_competencies($competency->get_id());
$userid = $usercompetency->get_userid();
$user = (object) array('id' => $userid);
if (can_view_user_details_cap($user)) {
$user = $DB->get_record('user', array('id' => $userid));
} else {
$user = null;
}
$plan = null;
if ($params['planid']) {
$plan = \tool_lp\api::read_plan($planid);
}
$evidence = api::list_evidence(0, $params['userid'], $params['competencyid']);
$params = array(
'competency' => $competency,
'usercompetency' => $usercompetency,
'evidence' => $evidence,
'user' => $user,
'plan' => $plan,
'relatedcompetencies' => $relatedcompetencies
);
$exporter = new user_competency_summary_exporter(null, $params);
$data = $exporter->export($output);
return $data;
}
/**
* Returns description of read_user_competency_summary() result value.
*
* @return \external_description
*/
public static function read_user_competency_summary_returns() {
return user_competency_summary_exporter::get_read_structure();
}
}

83
admin/tool/lp/classes/external/evidence_exporter.php vendored Normal file
View file

@ -0,0 +1,83 @@
<?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/>.
/**
* Class for exporting evidence data.
*
* @package tool_lp
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace tool_lp\external;
use renderer_base;
/**
* Class for exporting evidence data.
*
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class evidence_exporter extends persistent_exporter {
protected static function define_related() {
return array('actionuser' => '\\stdClass?',
'scale' => 'grade_scale');
}
protected static function define_class() {
return 'tool_lp\\evidence';
}
protected function get_other_values(renderer_base $output) {
$other = array();
if ($this->related['actionuser']) {
$exporter = new user_summary_exporter($this->related['actionuser']);
$actionuser = $exporter->export($output);
$other['actionuser'] = $actionuser;
}
$other['description'] = $this->persistent->get_description();
$other['userdate'] = userdate($this->persistent->get_timecreated());
if ($this->persistent->get_grade() === null) {
$gradename = '-';
} else {
$gradename = $this->related['scale']->scale_items[$this->persistent->get_grade() - 1];
}
$other['gradename'] = $gradename;
return $other;
}
public static function define_other_properties() {
return array(
'actionuser' => array(
'type' => user_summary_exporter::read_properties_definition(),
'optional' => true
),
'description' => array(
'type' => PARAM_TEXT,
),
'gradename' => array(
'type' => PARAM_TEXT,
),
'userdate' => array(
'type' => PARAM_TEXT
)
);
}
}

2
admin/tool/lp/classes/external/user_competency_exporter.php vendored
View file

@ -56,7 +56,7 @@ class user_competency_exporter extends persistent_exporter {
$result->gradename = $gradename;
if ($this->persistent->get_proficiency() === null) {
$proficiencyname = '-';
$proficiencyname = get_string('no');
} else {
$proficiencyname = get_string($this->persistent->get_proficiency() ? 'yes' : 'no');
}

2
admin/tool/lp/classes/external/user_competency_plan_exporter.php vendored
View file

@ -55,7 +55,7 @@ class user_competency_plan_exporter extends persistent_exporter {
$result->gradename = $gradename;
if ($this->persistent->get_proficiency() === null) {
$proficiencyname = '-';
$proficiencyname = get_string('no');
} else {
$proficiencyname = get_string($this->persistent->get_proficiency() ? 'yes' : 'no');
}

153
admin/tool/lp/classes/external/user_competency_summary_exporter.php vendored Normal file
View file

@ -0,0 +1,153 @@
<?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/>.
/**
* Class for exporting user competency data with all the evidence
*
* @package tool_lp
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace tool_lp\external;
use context_user;
use renderer_base;
use stdClass;
/**
* Class for exporting user competency data with additional related data.
*
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class user_competency_summary_exporter extends exporter {
protected static function define_related() {
// We cache the context so it does not need to be retrieved from the framework every time.
return array('competency' => '\\tool_lp\\competency',
'relatedcompetencies' => '\\tool_lp\\competency[]',
'user' => '\\stdClass?',
'plan' => '\\tool_lp\\plan?',
'usercompetency' => '\\tool_lp\\user_competency',
'evidence' => '\\tool_lp\\evidence[]');
}
protected static function define_other_properties() {
return array(
'showrelatedcompetencies' => array(
'type' => PARAM_BOOL
),
'cangrade' => array(
'type' => PARAM_BOOL
),
'cansuggest' => array(
'type' => PARAM_BOOL
),
'cangradeorsuggest' => array(
'type' => PARAM_BOOL
),
'competency' => array(
'type' => competency_summary_exporter::read_properties_definition()
),
'user' => array(
'type' => user_summary_exporter::read_properties_definition(),
'optional' => true
),
'plan' => array(
'type' => plan_exporter::read_properties_definition(),
'optional' => true
),
'usercompetency' => array(
'type' => user_competency_exporter::read_properties_definition()
),
'evidence' => array(
'type' => evidence_exporter::read_properties_definition(),
'multiple' => true
)
);
}
protected function get_other_values(renderer_base $output) {
global $DB;
$result = new stdClass();
$result->showrelatedcompetencies = true;
$competency = $this->related['competency'];
$exporter = new competency_summary_exporter(null, array(
'competency' => $competency,
'context' => $competency->get_context(),
'framework' => $competency->get_framework(),
'linkedcourses' => array(),
'relatedcompetencies' => $this->related['relatedcompetencies']
));
$result->competency = $exporter->export($output);
$context = context_user::instance($this->related['usercompetency']->get_userid());
$result->cangrade = has_capability('tool/lp:competencygrade', $context);
$result->cansuggest = has_capability('tool/lp:competencysuggestgrade', $context);
$result->cangradeorsuggest = $result->cangrade || $result->cansuggest;
if ($this->related['user']) {
$exporter = new user_summary_exporter($this->related['user']);
$result->user = $exporter->export($output);
}
$exporter = new user_competency_exporter($this->related['usercompetency'], array('scale' => $competency->get_scale()));
$result->usercompetency = $exporter->export($output);
if ($this->related['plan']) {
$exporter = new plan_exporter($this->related['plan'], array('template' => $this->related['plan']->get_template()));
$result->plan = $exporter->export($output);
}
$allevidence = array();
$usercache = array();
$scale = $competency->get_scale();
$result->evidence = array();
if (count($this->related['evidence'])) {
foreach ($this->related['evidence'] as $evidence) {
if (!empty($evidence->get_actionuserid())) {
$usercache[$evidence->get_actionuserid()] = true;
}
}
$users = array();
if (!empty($usercache)) {
list($sql, $params) = $DB->get_in_or_equal(array_keys($usercache));
$users = $DB->get_records_select('user', 'id ' . $sql, $params);
}
foreach ($users as $user) {
if (can_view_user_details_cap($user)) {
$usercache[$user->id] = $user;
} else {
unset($usercache[$user->id]);
}
}
foreach ($this->related['evidence'] as $evidence) {
$related = array('scale' => $scale);
if (!empty($usercache[$evidence->get_actionuserid()])) {
$related['actionuser'] = $usercache[$evidence->get_actionuserid()];
} else {
$related['actionuser'] = null;
}
$exporter = new evidence_exporter($evidence, $related);
$allevidence[] = $exporter->export($output);
}
$result->evidence = $allevidence;
}
return (array) $result;
}
}

19
admin/tool/lp/classes/external/user_summary_exporter.php vendored
View file

@ -36,7 +36,7 @@ use moodle_url;
class user_summary_exporter extends exporter {
protected function get_other_values(renderer_base $output) {
global $PAGE;
global $PAGE, $CFG;
// Add user picture.
$userpicture = new \user_picture($this->data);
@ -45,10 +45,22 @@ class user_summary_exporter extends exporter {
$userpicture->size = 0; // Size f2.
$profileimageurlsmall = $userpicture->get_url($PAGE)->out(false);
$identityfields = array_flip(explode(',', $CFG->showuseridentity));
$identity = '';
$data = $this->data;
foreach ($identityfields as $field => $index) {
if (!empty($data->$field)) {
$identityfields[$field] = $data->$field;
} else {
unset($identityfields[$field]);
}
}
$identity = implode(', ', $identityfields);
return array(
'fullname' => fullname($this->data),
'profileimageurl' => $profileimageurl,
'profileimageurlsmall' => $profileimageurlsmall
'profileimageurlsmall' => $profileimageurlsmall,
'identity' => $identity
);
}
@ -89,6 +101,9 @@ class user_summary_exporter extends exporter {
'fullname' => array(
'type' => PARAM_TEXT
),
'identity' => array(
'type' => PARAM_TEXT
),
'profileimageurl' => array(
'type' => PARAM_URL
),

2
admin/tool/lp/classes/output/plan_page.php
View file

@ -24,10 +24,10 @@
namespace tool_lp\output;
defined('MOODLE_INTERNAL') || die();
use moodle_url;
use renderable;
use templatable;
use stdClass;
use moodle_url;
use tool_lp\api;
use tool_lp\plan;
use tool_lp\external\competency_exporter;

11
admin/tool/lp/classes/output/renderer.php
View file

@ -131,6 +131,17 @@ class renderer extends plugin_renderer_base {
return parent::render_from_template('tool_lp/related_competencies', $data);
}
/**
* Defer to template.
*
* @param renderable $page
* @return string
*/
public function render_user_competency_plan_page(user_competency_plan_page $page) {
$data = $page->export_for_template($this);
return parent::render_from_template('tool_lp/user_competency_info', $data);
}
/**
* Render the template plans page.
*

74
admin/tool/lp/classes/output/user_competency_plan_page.php Normal file
View file

@ -0,0 +1,74 @@
<?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/>.
/**
* User competency page class.
*
* @package tool_lp
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace tool_lp\output;
use renderable;
use context_user;
use templatable;
use stdClass;
use tool_lp\api;
use tool_lp\external\user_competency_summary_exporter;
use tool_lp\external\plan_exporter;
/**
* User competency page class.
*
* @package tool_lp
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class user_competency_plan_page implements renderable, templatable {
/** @var userid */
protected $userid;
/** @var competencyid */
protected $competencyid;
/** @var planid */
protected $planid;
/**
* Construct.
*
* @param $userid
* @param $competencyid
* @param $planid
*/
public function __construct($userid, $competencyid, $planid) {
$this->userid = $userid;
$this->competencyid = $competencyid;
$this->planid = $planid;
}
/**
* Export the data.
*
* @param renderer_base $output
* @return stdClass
*/
public function export_for_template(\renderer_base $output) {
return \tool_lp\external::read_user_competency_summary($this->userid, $this->competencyid, $this->planid);
}
}

15
admin/tool/lp/db/access.php
View file

@ -155,4 +155,19 @@ $capabilities = array(
),
'clonepermissionsfrom' => 'moodle/site:config'
),
'tool/lp:competencysuggestgrade' => array(
'captype' => 'write',
'contextlevel' => CONTEXT_COURSE, // And CONTEXT_USER.
'archetypes' => array(
'teacher' => CAP_ALLOW
),
),
'tool/lp:competencygrade' => array(
'captype' => 'write',
'contextlevel' => CONTEXT_COURSE, // And CONTEXT_USER.
'archetypes' => array(
'editingteacher' => CAP_ALLOW,
'manager' => CAP_ALLOW
),
),
);

19
admin/tool/lp/db/services.php
View file

@ -662,5 +662,24 @@ $functions = array(
'capabilities' => 'tool/lp:userevidencemanageown',
'ajax' => true,
),
'tool_lp_grade_competency_in_plan' => array(
'classname' => 'tool_lp\external',
'methodname' => 'grade_competency_in_plan',
'classpath' => '',
'description' => 'Grade a competency from the user plan page.',
'type' => 'write',
'capabilities' => 'tool/lp:competencygrade',
'ajax' => true,
),
'tool_lp_read_user_competency_summary' => array(
'classname' => 'tool_lp\external',
'methodname' => 'read_user_competency_summary',
'classpath' => '',
'description' => 'Load a summary of a user competency.',
'type' => 'read',
'capabilities' => 'tool/lp:planview',
'ajax' => true,
),
);

8
admin/tool/lp/lang/en/tool_lp.php
View file

@ -89,6 +89,8 @@ $string['evidence_competencyrule'] = 'The rule of the competency was met.';
$string['evidence_coursecompleted'] = 'The course \'{$a}\' was completed.';
$string['evidence_evidenceofpriorlearninglinked'] = 'The evidence of prior learning \'{$a}\' was linked.';
$string['evidence_evidenceofpriorlearningunlinked'] = 'The evidence of prior learning \'{$a}\' was unlinked.';
$string['evidence_manualoverrideinplan'] = 'The competency grade was manually set in the plan \'{$a}\'.';
$string['evidence_manualsuggestinplan'] = 'The competency grade was manually suggested in the plan \'{$a}\'.';
$string['errorcannotsetduedateinthepast'] = 'The due date cannot be set in the past.';
$string['errorcannotchangeapastduedate'] = 'The due date has passed, it cannot be changed.';
$string['errornocompetency'] = '{$a} competency can not be found';
@ -122,6 +124,8 @@ $string['listtemplatescaption'] = 'List of learning plan templates';
$string['loading'] = 'Loading...';
$string['locatecompetency'] = 'Locate competency';
$string['lp:competencymanage'] = 'Manage competency frameworks';
$string['lp:competencysuggestgrade'] = 'Suggest competency grade';
$string['lp:competencygrade'] = 'Set competency grade';
$string['lp:competencyread'] = 'View competency frameworks';
$string['lp:coursecompetencymanage'] = 'Manage course competencies';
$string['lp:coursecompetencyread'] = 'View course competencies';
@ -275,3 +279,7 @@ $string['userplans'] = 'User plans';
$string['visible'] = 'Visible';
$string['visible_help'] = 'A competency framework can be hidden from teachers. This could be useful if a framework is still in the process of being developed.';
$string['when'] = 'When';
$string['noevidence'] = 'No evidence';
$string['evidence'] = 'Evidence';
$string['grade'] = 'Grade';
$string['suggest'] = 'Suggest';

15
admin/tool/lp/templates/evidence_summary.mustache Normal file
View file

@ -0,0 +1,15 @@
<div class="well well-small evidence">
{{#actionuser}}
<div>
{{> tool_lp/form-user-selector-suggestion }}
</div>
{{/actionuser}}
<strong><time datetime="{{userdate}}">{{userdate}}</time></strong>
{{#grade}}
<p><span class="label">{{gradename}}</span></p>
{{/grade}}
<p>{{description}}</p>
{{#url}}
<p><a href="{{url}}" target="_blank" rel="noreferrer">{{url}}</a></p>
{{/url}}
</div>

31
admin/tool/lp/templates/grade_user_competency_form.mustache Normal file
View file

@ -0,0 +1,31 @@
<form class="form-inline pull-left" id="grade-competency-form-{{uniqid}}">
{{#cangrade}}
<div class="btn-group">
<button class="btn btn-primary" data-action="grade">{{#str}}grade, tool_lp{{/str}}</button>
{{/cangrade}}
{{#cansuggest}}
<button class="btn btn-inverse" data-action="suggest">{{#str}}suggest, tool_lp{{/str}}</button>
{{/cansuggest}}
</div>
<select>
</select>
</form>
{{#js}}
require(['jquery', 'tool_lp/grade_user_competency_inline', 'tool_lp/user_competency_info'], function($, mod, info) {
var competencyScaleConfig = '{{{competency.competency.scaleconfiguration}}}';
var frameworkScaleConfig = '{{{competency.framework.scaleconfiguration}}}';
var scaleConfig = frameworkScaleConfig;
{{#competency.competency.scaleid}}
scaleConfig = competencyScaleConfig;
{{/competency.competency.scaleid}}
scaleConfig = JSON.parse(scaleConfig);
var inlineGrader = new mod('grade-competency-form-{{uniqid}}', scaleConfig, '{{competency.competency.id}}', '{{user.id}}', '{{plan.id}}');
var competencyElement = $(document.getElementById('grade-competency-form-{{uniqid}}')).closest('[data-region=user-competency-full-info]');
var infoReloader = new info(competencyElement, '{{competency.competency.id}}', '{{user.id}}', '{{plan.id}}');
inlineGrader.on('competencyupdated', infoReloader.reload.bind(infoReloader));
});
{{/js}}

2
admin/tool/lp/templates/plan_page.mustache
View file

@ -79,7 +79,7 @@
{{#plan.canbeedited}}
<span class="drag-handlecontainer pull-left"></span>
{{/plan.canbeedited}}
<a href="#" data-action="competency-dialogue" data-id="{{competency.id}}">{{competency.shortname}}</a>
<a href="{{pluginbaseurl}}/usercompetencyplan.php?competencyid={{competency.id}}&amp;userid={{plan.userid}}&amp;planid={{plan.id}}">{{competency.shortname}}</a>
<em>{{competency.idnumber}}</em>
</td>
{{#plan.iscompleted}}

31
admin/tool/lp/templates/user_competency_info.mustache Normal file
View file

@ -0,0 +1,31 @@
<div data-region="user-competency-full-info" >
<div data-region="competency-summary">
{{#competency}}
{{> tool_lp/competency_summary }}
{{/competency}}
<dl>
<dt>{{#str}}grade, tool_lp{{/str}}</dt>
<dd>{{usercompetency.gradename}}</dd>
{{#cangradeorsuggest}}
<dt>{{#str}}editgrade, grades{{/str}}</dt>
<dd>{{> tool_lp/grade_user_competency_form }}</dd>
{{/cangradeorsuggest}}
<dt>{{#str}}proficient, tool_lp{{/str}}</dt>
<dd>
<span class="label{{^usercompetency.proficiency}} label-important{{/usercompetency.proficiency}} pull-left">
{{usercompetency.proficiencyname}}
</span>
</dd>
</dl>
<dl data-region="evidence-listing">
<dt>{{#str}}evidence, tool_lp{{/str}}</dt>
<dd>
{{#evidence}}
{{> tool_lp/evidence_summary }}
{{/evidence}}
{{^evidence}}
<p>{{#str}}noevidence, tool_lp{{/str}}</p>
{{/evidence}}
</dd>
</dl>
</div>

1
admin/tool/lp/tests/api_test.php
View file

@ -1721,7 +1721,6 @@ class tool_lp_api_testcase extends advanced_testcase {
$usercompetency->create();
$this->assertTrue(true);
} catch (\tool_lp\invalid_persistent_exception $e) {
var_dump($e);
$this->fail('Valide grade rejected in competency scale');
}
}

87
admin/tool/lp/tests/externallib_test.php
View file

@ -100,12 +100,17 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
$authrole = array_pop($userroles);
// Reset all default authenticated users permissions.
unassign_capability('tool/lp:competencygrade', $authrole->id);
unassign_capability('tool/lp:competencysuggestgrade', $authrole->id);
unassign_capability('tool/lp:competencymanage', $authrole->id);
unassign_capability('tool/lp:competencyread', $authrole->id);
unassign_capability('tool/lp:planmanage', $authrole->id);
unassign_capability('tool/lp:planmanagedraft', $authrole->id);
unassign_capability('tool/lp:planmanageown', $authrole->id);
unassign_capability('tool/lp:planview', $authrole->id);
unassign_capability('tool/lp:planviewdraft', $authrole->id);
unassign_capability('tool/lp:planviewown', $authrole->id);
unassign_capability('tool/lp:planviewowndraft', $authrole->id);
unassign_capability('tool/lp:templatemanage', $authrole->id);
unassign_capability('tool/lp:templateread', $authrole->id);
@ -119,8 +124,14 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
assign_capability('tool/lp:planmanagedraft', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:planmanageown', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:planview', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:planviewdraft', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:templatemanage', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:competencygrade', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:competencysuggestgrade', CAP_ALLOW, $this->creatorrole, $syscontext->id);
assign_capability('tool/lp:templateread', CAP_ALLOW, $this->userrole, $syscontext->id);
assign_capability('tool/lp:competencysuggestgrade', CAP_ALLOW, $this->userrole, $syscontext->id);
assign_capability('tool/lp:planviewown', CAP_ALLOW, $this->userrole, $syscontext->id);
assign_capability('tool/lp:planviewowndraft', CAP_ALLOW, $this->userrole, $syscontext->id);
role_assign($this->creatorrole, $creator->id, $syscontext->id);
role_assign($this->creatorrole, $catcreator->id, $catcontext->id);
@ -1606,19 +1617,19 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
// Expected return value.
$expected = array(array(
'id' => 1,
'name' => 'Excellent'
'name' => 'Poor'
), array(
'id' => 2,
'name' => 'Fine'
'name' => 'Not good'
), array(
'id' => 3,
'name' => 'Okay'
), array(
'id' => 4,
'name' => 'Not good'
'name' => 'Fine'
), array(
'id' => 5,
'name' => 'Poor'
'name' => 'Excellent'
)
);
// Call the webservice.
@ -2608,4 +2619,72 @@ class tool_lp_external_testcase extends externallib_advanced_testcase {
$this->assertEmpty($result['users'][0]['institution']);
}
public function test_grade_competency_in_plan() {
global $CFG;
$this->setUser($this->creator);
$dg = $this->getDataGenerator();
$lpg = $dg->get_plugin_generator('tool_lp');
$f1 = $lpg->create_framework();
$c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
$tpl = $lpg->create_template();
$lpg->create_template_competency(array('templateid' => $tpl->get_id(), 'competencyid' => $c1->get_id()));
$plan = $lpg->create_plan(array('userid' => $this->user->id, 'templateid' => $tpl->get_id(), 'name' => 'Evil'));
$uc = $lpg->create_user_competency(array('userid' => $this->user->id, 'competencyid' => $c1->get_id()));
$evidence = external::grade_competency_in_plan($this->user->id, $c1->get_id(), $plan->get_id(), 1, false);
$this->assertEquals('The competency grade was manually suggested in the plan \'Evil\'.', $evidence->description);
$this->assertEquals('A', $evidence->gradename);
$evidence = external::grade_competency_in_plan($this->user->id, $c1->get_id(), $plan->get_id(), 1, true);
$this->assertEquals('The competency grade was manually set in the plan \'Evil\'.', $evidence->description);
$this->assertEquals('A', $evidence->gradename);
$this->setUser($this->user);
$evidence = external::grade_competency_in_plan($this->user->id, $c1->get_id(), $plan->get_id(), 1, false);
$this->assertEquals('The competency grade was manually suggested in the plan \'Evil\'.', $evidence->description);
$this->assertEquals('A', $evidence->gradename);
$this->setExpectedException('required_capability_exception');
$evidence = external::grade_competency_in_plan($this->user->id, $c1->get_id(), $plan->get_id(), 1, true);
}
public function test_read_user_competency_summary() {
global $CFG;
$this->setUser($this->creator);
$dg = $this->getDataGenerator();
$lpg = $dg->get_plugin_generator('tool_lp');
$f1 = $lpg->create_framework();
$c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
$tpl = $lpg->create_template();
$lpg->create_template_competency(array('templateid' => $tpl->get_id(), 'competencyid' => $c1->get_id()));
$plan = $lpg->create_plan(array('userid' => $this->user->id, 'templateid' => $tpl->get_id(), 'name' => 'Evil'));
$uc = $lpg->create_user_competency(array('userid' => $this->user->id, 'competencyid' => $c1->get_id()));
$evidence = external::grade_competency_in_plan($this->user->id, $c1->get_id(), $plan->get_id(), 1, false);
$evidence = external::grade_competency_in_plan($this->user->id, $c1->get_id(), $plan->get_id(), 2, true);
$summary = external::read_user_competency_summary($this->user->id, $c1->get_id(), $plan->get_id());
$this->assertTrue($summary->cangrade);
$this->assertTrue($summary->cansuggest);
$this->assertEquals('Evil', $summary->plan->name);
$this->assertEquals('B', $summary->usercompetency->gradename);
$this->assertEquals('B', $summary->evidence[0]->gradename);
$this->assertEquals('A', $summary->evidence[1]->gradename);
}
}

59
admin/tool/lp/usercompetencyplan.php Normal file
View file

@ -0,0 +1,59 @@
<?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/>.
/**
* User competency page. Lists everything known about a user competency.
*
* @package tool_lp
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
require(__DIR__ . '/../../../config.php');
$userid = required_param('userid', PARAM_INT);
$competencyid = required_param('competencyid', PARAM_INT);
$planid = required_param('planid', PARAM_INT);
require_login(null, false);
if (isguestuser()) {
throw new require_login_exception('Guests are not allowed here.');
}
$params = array('userid' => $userid, 'competencyid' => $competencyid);
$params['planid'] = $planid;
$plan = \tool_lp\api::read_plan($planid);
$url = new moodle_url('/admin/tool/lp/usercompetencyplan.php', $params);
$competency = new \tool_lp\competency($competencyid);
$framework = $competency->get_framework();
$subtitle = get_string('taxonomy_' . $framework->get_taxonomy($competency->get_level()), 'tool_lp');
list($title, $subtitle) = \tool_lp\page_helper::setup_for_plan($userid, $url, $plan,
$subtitle);
$output = $PAGE->get_renderer('tool_lp');
echo $output->header();
if ($userid != $USER->id) {
echo $output->context_header($userid);
} else {
echo $output->heading($title);
echo $output->heading($subtitle, 3);
}
$page = new \tool_lp\output\user_competency_plan_page($userid, $competencyid, $planid);
echo $output->render($page);
echo $output->footer();