* @method getType
*/
Rule.prototype.getType = function() {
- return 'tool_lp\\competency_rule_all';
+ return 'core_competency\\competency_rule_all';
};
/**
* @method getType
*/
Rule.prototype.getType = function() {
- return 'tool_lp\\competency_rule_points';
+ return 'core_competency\\competency_rule_points';
};
/**
$pluginwrapper->add_child($coursecompetencysettings);
$sql = 'SELECT s.pushratingstouserplans
- FROM {' . \tool_lp\course_competency_settings::TABLE . '} s
+ FROM {' . \core_competency\course_competency_settings::TABLE . '} s
WHERE s.courseid = :courseid';
$coursecompetencysettings->set_source_sql($sql, array('courseid' => backup::VAR_COURSEID));
$coursecompetencies->add_child($competency);
$sql = 'SELECT c.idnumber, cc.ruleoutcome, cc.sortorder, f.idnumber AS frameworkidnumber
- FROM {' . \tool_lp\course_competency::TABLE . '} cc
- JOIN {' . \tool_lp\competency::TABLE . '} c ON c.id = cc.competencyid
- JOIN {' . \tool_lp\competency_framework::TABLE . '} f ON f.id = c.competencyframeworkid
+ FROM {' . \core_competency\course_competency::TABLE . '} cc
+ JOIN {' . \core_competency\competency::TABLE . '} c ON c.id = cc.competencyid
+ JOIN {' . \core_competency\competency_framework::TABLE . '} f ON f.id = c.competencyframeworkid
WHERE cc.courseid = :courseid
ORDER BY cc.sortorder';
$competency->set_source_sql($sql, array('courseid' => backup::VAR_COURSEID));
$coursecompetencies->add_child($competency);
$sql = 'SELECT c.idnumber, cmc.ruleoutcome, cmc.sortorder, f.idnumber AS frameworkidnumber
- FROM {' . \tool_lp\course_module_competency::TABLE . '} cmc
- JOIN {' . \tool_lp\competency::TABLE . '} c ON c.id = cmc.competencyid
- JOIN {' . \tool_lp\competency_framework::TABLE . '} f ON f.id = c.competencyframeworkid
+ FROM {' . \core_competency\course_module_competency::TABLE . '} cmc
+ JOIN {' . \core_competency\competency::TABLE . '} c ON c.id = cmc.competencyid
+ JOIN {' . \core_competency\competency_framework::TABLE . '} f ON f.id = c.competencyframeworkid
WHERE cmc.cmid = :coursemoduleid
ORDER BY cmc.sortorder';
$competency->set_source_sql($sql, array('coursemoduleid' => backup::VAR_MODID));
*/
protected function get_include_condition() {
$result = '';
- if (\tool_lp\course_competency::record_exists_select('courseid = ?', array($this->task->get_courseid()))) {
+ if (\core_competency\course_competency::record_exists_select('courseid = ?', array($this->task->get_courseid()))) {
$result = 'include';
};
return array('sqlparam' => $result);
$data = (object) $data;
$courseid = $this->task->get_courseid();
- $exists = \tool_lp\course_competency_settings::get_record(array('courseid' => $courseid));
+ $exists = \core_competency\course_competency_settings::get_record(array('courseid' => $courseid));
// Now update or insert.
if ($exists) {
return $settings->update();
} else {
$data = (object) array('courseid' => $courseid, 'pushratingstouserplans' => $data->pushratingstouserplans);
- $settings = new \tool_lp\course_competency_settings(0, $data);
+ $settings = new \core_competency\course_competency_settings(0, $data);
return !empty($settings->create());
}
}
$data = (object) $data;
// Mapping the competency by ID numbers.
- $framework = \tool_lp\competency_framework::get_record(array('idnumber' => $data->frameworkidnumber));
+ $framework = \core_competency\competency_framework::get_record(array('idnumber' => $data->frameworkidnumber));
if (!$framework) {
return;
}
- $competency = \tool_lp\competency::get_record(array('idnumber' => $data->idnumber,
+ $competency = \core_competency\competency::get_record(array('idnumber' => $data->idnumber,
'competencyframeworkid' => $framework->get_id()));
if (!$competency) {
return;
'courseid' => $this->task->get_courseid()
);
$query = 'competencyid = :competencyid AND courseid = :courseid';
- $existing = \tool_lp\course_competency::record_exists_select($query, $params);
+ $existing = \core_competency\course_competency::record_exists_select($query, $params);
if (!$existing) {
// Sortorder is ignored by precaution, anyway we should walk through the records in the right order.
$record = (object) $params;
$record->ruleoutcome = $data->ruleoutcome;
- $coursecompetency = new \tool_lp\course_competency(0, $record);
+ $coursecompetency = new \core_competency\course_competency(0, $record);
$coursecompetency->create();
}
$data = (object) $data;
// Mapping the competency by ID numbers.
- $framework = \tool_lp\competency_framework::get_record(array('idnumber' => $data->frameworkidnumber));
+ $framework = \core_competency\competency_framework::get_record(array('idnumber' => $data->frameworkidnumber));
if (!$framework) {
return;
}
- $competency = \tool_lp\competency::get_record(array('idnumber' => $data->idnumber,
+ $competency = \core_competency\competency::get_record(array('idnumber' => $data->idnumber,
'competencyframeworkid' => $framework->get_id()));
if (!$competency) {
return;
'cmid' => $this->task->get_moduleid()
);
$query = 'competencyid = :competencyid AND cmid = :cmid';
- $existing = \tool_lp\course_module_competency::record_exists_select($query, $params);
+ $existing = \core_competency\course_module_competency::record_exists_select($query, $params);
if (!$existing) {
// Sortorder is ignored by precaution, anyway we should walk through the records in the right order.
$record = (object) $params;
$record->ruleoutcome = $data->ruleoutcome;
- $coursemodulecompetency = new \tool_lp\course_module_competency(0, $record);
+ $coursemodulecompetency = new \core_competency\course_module_competency(0, $record);
$coursemodulecompetency->create();
}
use moodle_exception;
use moodle_url;
use required_capability_exception;
+use \core_competency\competency;
+use \core_competency\competency_framework;
+use \core_competency\course_competency;
+use \core_competency\course_competency_settings;
+use \core_competency\course_module_competency;
+use \core_competency\evidence;
+use \core_competency\plan;
+use \core_competency\plan_competency;
+use \core_competency\related_competency;
+use \core_competency\template;
+use \core_competency\template_cohort;
+use \core_competency\template_competency;
+use \core_competency\user_competency;
+use \core_competency\user_competency_course;
+use \core_competency\user_competency_plan;
+use \core_competency\user_evidence;
+use \core_competency\user_evidence_competency;
/**
* Class for doing things with competency frameworks.
*
* @param mixed $courseorid The course, or its ID.
* @return array( array(
- * 'competency' => \tool_lp\competency,
- * 'coursecompetency' => \tool_lp\course_competency
+ * 'competency' => \core_competency\competency,
+ * 'coursecompetency' => \core_competency\course_competency
* ))
*/
public static function list_course_competencies($courseorid) {
*
* @param mixed $cmorid The course module, or its ID.
* @return array( array(
- * 'competency' => \tool_lp\competency,
- * 'coursemodulecompetency' => \tool_lp\course_module_competency
+ * 'competency' => \core_competency\competency,
+ * 'coursemodulecompetency' => \core_competency\course_module_competency
* ))
*/
public static function list_course_module_competencies($cmorid) {
* Lists user plans.
*
* @param int $userid
- * @return \tool_lp\plan[]
+ * @return \core_competency\plan[]
*/
public static function list_user_plans($userid) {
global $DB, $USER;
* Creates a learning plan based on the provided data.
*
* @param stdClass $record
- * @return \tool_lp\plan
+ * @return \core_competency\plan
*/
public static function create_plan(stdClass $record) {
global $USER;
*
* @param mixed $templateorid The template object or ID.
* @param int $userid
- * @return false|\tool_lp\plan Returns false when the plan already exists.
+ * @return false|\core_competency\plan Returns false when the plan already exists.
*/
public static function create_plan_from_template($templateorid, $userid) {
static::require_enabled();
/**
* Unlink a plan from its template.
*
- * @param \tool_lp\plan|int $planorid The plan or its ID.
+ * @param \core_competency\plan|int $planorid The plan or its ID.
* @return bool
*/
public static function unlink_plan_from_template($planorid) {
* Updates a plan.
*
* @param stdClass $record
- * @return \tool_lp\plan
+ * @return \core_competency\plan
*/
public static function update_plan(stdClass $record) {
static::require_enabled();
* Returns a plan data.
*
* @param int $id
- * @return \tool_lp\plan
+ * @return \core_competency\plan
*/
public static function read_plan($id) {
static::require_enabled();
* @param int $planorid The plan, or its ID.
* @param int $competencyid The competency id.
* @return (object) array(
- * 'competency' => \tool_lp\competency,
- * 'usercompetency' => \tool_lp\user_competency
- * 'usercompetencyplan' => \tool_lp\user_competency_plan
+ * 'competency' => \core_competency\competency,
+ * 'usercompetency' => \core_competency\user_competency
+ * 'usercompetencyplan' => \core_competency\user_competency_plan
* )
* The values of of keys usercompetency and usercompetencyplan cannot be defined at the same time.
*/
*
* @param int $planorid The plan, or its ID.
* @return array((object) array(
- * 'competency' => \tool_lp\competency,
- * 'usercompetency' => \tool_lp\user_competency
- * 'usercompetencyplan' => \tool_lp\user_competency_plan
+ * 'competency' => \core_competency\competency,
+ * 'usercompetency' => \core_competency\user_competency
+ * 'usercompetencyplan' => \core_competency\user_competency_plan
* ))
* The values of of keys usercompetency and usercompetencyplan cannot be defined at the same time.
*/
* @param string $order The ordering of the sorting.
* @param int $skip Number of records to skip.
* @param int $limit Number of records to return.
- * @return \tool_lp\evidence[]
- * @return array of \tool_lp\evidence
+ * @return \core_competency\evidence[]
+ * @return array of \core_competency\evidence
*/
public static function list_evidence($userid = 0,
$competencyid = 0,
* @param string $order The ordering of the sorting.
* @param int $skip Number of records to skip.
* @param int $limit Number of records to return.
- * @return \tool_lp\evidence[]
+ * @return \core_competency\evidence[]
*/
public static function list_evidence_in_course($userid = 0,
$courseid = 0,
* @param int $userid The user id for which evidence is added.
* @param competency|int $competencyorid The competency, or its id for which evidence is added.
* @param context|int $contextorid The context in which the evidence took place.
- * @param int $action The type of action to take on the competency. \tool_lp\evidence::ACTION_*.
+ * @param int $action The type of action to take on the competency. \core_competency\evidence::ACTION_*.
* @param string $descidentifier The strings identifier.
* @param string $desccomponent The strings component.
* @param mixed $desca Any arguments the string requires.
return;
}
+
// Fetch or create the user competency for the parent.
$userid = $usercompetency->get_userid();
$parentuc = user_competency::get_record(array('userid' => $userid, 'competencyid' => $parent->get_id()));
$parentuc->create();
}
+
// Does the rule match?
if (!$rule->matches($parentuc)) {
return;
* @param int $competencyid
* @param int $grade
* @param string $note A note to attach to the evidence
- * @return array of \tool_lp\user_competency
+ * @return array of \core_competency\user_competency
*/
public static function grade_competency($userid, $competencyid, $grade, $note = null) {
global $USER;
* @param int $competencyid
* @param int $grade
* @param string $note A note to attach to the evidence
- * @return array of \tool_lp\user_competency
+ * @return array of \core_competency\user_competency
*/
public static function grade_competency_in_plan($planorid, $competencyid, $grade, $note = null) {
global $USER;
* @param int $competencyid
* @param int $grade
* @param string $note A note to attach to the evidence
- * @return array of \tool_lp\user_competency
+ * @return array of \core_competency\user_competency
*/
public static function grade_competency_in_course($courseorid, $userid, $competencyid, $grade, $note = null) {
global $USER, $DB;
use tool_lp\api;
use tool_lp\external\competency_exporter;
-use tool_lp\course_module_competency;
+use core_competency\course_module_competency;
require_once($CFG->libdir . '/form/select.php');
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency;
+use core_competency\competency;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency;
+use core_competency\competency;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency_framework;
+use core_competency\competency_framework;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency_framework;
+use core_competency\competency_framework;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency_framework;
+use core_competency\competency_framework;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency_framework;
+use core_competency\competency_framework;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency;
+use core_competency\competency;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\competency;
+use core_competency\competency;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\evidence;
-use tool_lp\user_competency;
+use core_competency\evidence;
+use core_competency\user_competency;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\plan;
+use core_competency\plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\template;
+use core_competency\template;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\template;
+use core_competency\template;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\template;
+use core_competency\template;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\template;
+use core_competency\template;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
defined('MOODLE_INTERNAL') || die();
/**
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency_course;
+use core_competency\user_competency_course;
use context_course;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
defined('MOODLE_INTERNAL') || die();
/**
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency_plan;
+use core_competency\user_competency_plan;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
defined('MOODLE_INTERNAL') || die();
/**
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
defined('MOODLE_INTERNAL') || die();
/**
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
defined('MOODLE_INTERNAL') || die();
/**
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
defined('MOODLE_INTERNAL') || die();
/**
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
use context_course;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency_course;
+use core_competency\user_competency_course;
use context_course;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_competency;
+use core_competency\user_competency;
use context_course;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_evidence;
+use core_competency\user_evidence;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_evidence;
+use core_competency\user_evidence;
defined('MOODLE_INTERNAL') || die();
namespace tool_lp\event;
use core\event\base;
-use tool_lp\user_evidence;
+use core_competency\user_evidence;
defined('MOODLE_INTERNAL') || die();
use invalid_parameter_exception;
use required_capability_exception;
use grade_scale;
+use \core_competency\competency;
+use \core_competency\competency_framework;
+use \core_competency\course_competency;
+use \core_competency\course_competency_settings;
+use \core_competency\course_module_competency;
+use \core_competency\evidence;
+use \core_competency\plan;
+use \core_competency\plan_competency;
+use \core_competency\related_competency;
+use \core_competency\template;
+use \core_competency\template_cohort;
+use \core_competency\template_competency;
+use \core_competency\user_competency;
+use \core_competency\user_competency_course;
+use \core_competency\user_competency_plan;
+use \core_competency\user_evidence;
+use \core_competency\user_evidence_competency;
use tool_lp\external\competency_framework_exporter;
use tool_lp\external\competency_summary_exporter;
use tool_lp\external\competency_path_exporter;
class competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\competency';
+ return 'core_competency\\competency';
}
protected static function define_related() {
* @return string
*/
protected static function define_class() {
- return 'tool_lp\\competency_framework';
+ return 'core_competency\\competency_framework';
}
/**
*/
protected static function define_related() {
return [
- 'ancestors' => 'tool_lp\\competency[]',
- 'framework' => 'tool_lp\\competency_framework',
+ 'ancestors' => 'core_competency\\competency[]',
+ 'framework' => 'core_competency\\competency_framework',
'context' => 'context'
];
}
use context_course;
use renderer_base;
use stdClass;
-use \tool_lp\competency_framework;
+use \core_competency\competency_framework;
/**
* Class for exporting competency data with additional related data.
protected static function define_related() {
// We cache the context so it does not need to be retrieved from the framework every time.
return array('context' => '\\context',
- 'competency' => '\\tool_lp\\competency',
- 'framework' => '\\tool_lp\\competency_framework',
+ 'competency' => '\\core_competency\\competency',
+ 'framework' => '\\core_competency\\competency_framework',
'linkedcourses' => '\\stdClass[]',
- 'relatedcompetencies' => '\\tool_lp\\competency[]');
+ 'relatedcompetencies' => '\\core_competency\\competency[]');
}
protected static function define_other_properties() {
class course_competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\course_competency';
+ return 'core_competency\\course_competency';
}
}
class course_competency_settings_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\course_competency_settings';
+ return 'core_competency\\course_competency_settings';
}
}
class course_module_competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\course_module_competency';
+ return 'core_competency\\course_module_competency';
}
}
}
protected static function define_class() {
- return 'tool_lp\\evidence';
+ return 'core_competency\\evidence';
}
protected function get_other_values(renderer_base $output) {
* export of the persistent data.
*
* The format of the array returned by this method has to match the structure
- * defined in {@link \tool_lp\persistent::define_properties()}. The display properties
+ * defined in {@link \core_competency\persistent::define_properties()}. The display properties
* can however do some more fancy things. They can define 'multiple' => true to wrap
* values in an external_multiple_structure automatically - or they can define the
* type as a nested array of more properties in order to generate a nested
* Return the list of properties.
*
* The format of the array returned by this method has to match the structure
- * defined in {@link \tool_lp\persistent::define_properties()}.
+ * defined in {@link \core_competency\persistent::define_properties()}.
*
* @return array
*/
*/
abstract class persistent_exporter extends exporter {
- /** @var \tool_lp\persistent The persistent object we will export. */
+ /** @var \core_competency\persistent The persistent object we will export. */
protected $persistent = null;
/**
* Constructor - saves the persistent object, and the related objects.
*
- * @param \tool_lp\persistent $persistent The persistent object to export.
+ * @param \core_competency\persistent $persistent The persistent object to export.
* @param array $related - An optional list of pre-loaded objects related to this persistent.
*/
- public final function __construct(\tool_lp\persistent $persistent, $related = array()) {
+ public final function __construct(\core_competency\persistent $persistent, $related = array()) {
$classname = static::define_class();
if (!$persistent instanceof $classname) {
throw new coding_exception('Invalid type for persistent. ' .
class plan_competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\plan_competency';
+ return 'core_competency\\plan_competency';
}
}
class plan_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\plan';
+ return 'core_competency\\plan';
}
protected static function define_related() {
- return array('template' => 'tool_lp\\template?');
+ return array('template' => 'core_competency\\template?');
}
protected function get_other_values(renderer_base $output) {
class related_competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\related_competency';
+ return 'core_competency\\related_competency';
}
}
class template_competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\template_competency';
+ return 'core_competency\\template_competency';
}
}
use moodle_url;
use renderer_base;
-use tool_lp\plan;
-use tool_lp\template_cohort;
+use core_competency\plan;
+use core_competency\template_cohort;
/**
* Class for exporting template data.
class template_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\template';
+ return 'core_competency\\template';
}
protected function get_other_values(renderer_base $output) {
class user_competency_course_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\user_competency_course';
+ return 'core_competency\\user_competency_course';
}
protected static function define_related() {
use core_user;
use renderer_base;
use stdClass;
-use tool_lp\user_competency;
+use core_competency\user_competency;
/**
* Class for exporting user competency data.
class user_competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\user_competency';
+ return 'core_competency\\user_competency';
}
protected static function define_related() {
class user_competency_plan_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\user_competency_plan';
+ return 'core_competency\\user_competency_plan';
}
protected static function define_related() {
use context_user;
use renderer_base;
use stdClass;
-use tool_lp\user_competency;
+use core_competency\user_competency;
/**
* Class for exporting user competency data with additional related data.
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[]',
+ return array('competency' => '\\core_competency\\competency',
+ 'relatedcompetencies' => '\\core_competency\\competency[]',
'user' => '\\stdClass',
- 'usercompetency' => '\\tool_lp\\user_competency?',
- 'usercompetencyplan' => '\\tool_lp\\user_competency_plan?',
- 'evidence' => '\\tool_lp\\evidence[]');
+ 'usercompetency' => '\\core_competency\\user_competency?',
+ 'usercompetencyplan' => '\\core_competency\\user_competency_plan?',
+ 'evidence' => '\\core_competency\\evidence[]');
}
protected static function define_other_properties() {
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[]',
+ return array('competency' => '\\core_competency\\competency',
+ 'relatedcompetencies' => '\\core_competency\\competency[]',
'user' => '\\stdClass',
'course' => '\\stdClass',
- 'usercompetencycourse' => '\\tool_lp\\user_competency_course?',
- 'evidence' => '\\tool_lp\\evidence[]',
+ 'usercompetencycourse' => '\\core_competency\\user_competency_course?',
+ 'evidence' => '\\core_competency\\evidence[]',
'scale' => '\\grade_scale');
}
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[]',
+ return array('competency' => '\\core_competency\\competency',
+ 'relatedcompetencies' => '\\core_competency\\competency[]',
'user' => '\\stdClass',
- 'plan' => '\\tool_lp\\plan',
- 'usercompetency' => '\\tool_lp\\user_competency?',
- 'usercompetencyplan' => '\\tool_lp\\user_competency_plan?',
- 'evidence' => '\\tool_lp\\evidence[]');
+ 'plan' => '\\core_competency\\plan',
+ 'usercompetency' => '\\core_competency\\user_competency?',
+ 'usercompetencyplan' => '\\core_competency\\user_competency_plan?',
+ 'evidence' => '\\core_competency\\evidence[]');
}
protected static function define_other_properties() {
class user_evidence_competency_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\user_evidence_competency';
+ return 'core_competency\\user_evidence_competency';
}
}
class user_evidence_competency_summary_exporter extends exporter {
protected static function define_related() {
- return array('competency' => '\\tool_lp\\competency',
- 'usercompetency' => '\\tool_lp\\user_competency',
+ return array('competency' => '\\core_competency\\competency',
+ 'usercompetency' => '\\core_competency\\user_competency',
'scale' => 'grade_scale',
'context' => '\\context'
);
class user_evidence_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\user_evidence';
+ return 'core_competency\\user_evidence';
}
protected static function define_other_properties() {
protected static function define_related() {
return array(
'context' => 'context',
- 'competencies' => 'tool_lp\\competency[]'
+ 'competencies' => 'core_competency\\competency[]'
);
}
class user_evidence_summary_exporter extends persistent_exporter {
protected static function define_class() {
- return 'tool_lp\\user_evidence';
+ return 'core_competency\\user_evidence';
}
protected static function define_other_properties() {
*/
class competency extends persistent {
- protected static $persistentclass = 'tool_lp\\competency';
+ protected static $persistentclass = 'core_competency\\competency';
/**
* Define the form - called by parent constructor
*/
class competency_framework extends persistent {
- protected static $persistentclass = 'tool_lp\\competency_framework';
+ protected static $persistentclass = 'core_competency\\competency_framework';
/**
* Define the form - called by parent constructor
$mform->setDefault('context', $context->get_context_name(false));
$mform->addElement('header', 'taxonomyhdr', get_string('taxonomies', 'tool_lp'));
- $taxonomies = \tool_lp\competency_framework::get_taxonomies_list();
+ $taxonomies = \core_competency\competency_framework::get_taxonomies_list();
$taxdefaults = array();
- for ($i = 1; $i <= \tool_lp\competency_framework::get_taxonomies_max_level(); $i++) {
+ for ($i = 1; $i <= \core_competency\competency_framework::get_taxonomies_max_level(); $i++) {
$mform->addElement('select', "taxonomies[$i]", get_string('levela', 'tool_lp', $i), $taxonomies);
- $taxdefaults[$i] = \tool_lp\competency_framework::TAXONOMY_COMPETENCY;
+ $taxdefaults[$i] = \core_competency\competency_framework::TAXONOMY_COMPETENCY;
}
// Not using taxonomies[n] here or it would takes precedence over set_data(array('taxonomies' => ...)).
$mform->setDefault('taxonomies', $taxdefaults);
use coding_exception;
use MoodleQuickForm_autocomplete;
-use \tool_lp\competency_framework;
+use \core_competency\competency_framework;
global $CFG;
require_once($CFG->libdir . '/form/autocomplete.php');
$attributes = null, $editable = true) {
if (empty(static::$persistentclass)) {
throw new coding_exception('Static property $persistentclass must be set.');
- } else if (!is_subclass_of(static::$persistentclass, 'tool_lp\\persistent')) {
+ } else if (!is_subclass_of(static::$persistentclass, 'core_competency\\persistent')) {
throw new coding_exception('Static property $persistentclass is not valid.');
} else if (!array_key_exists('persistent', $customdata)) {
throw new coding_exception('The custom data \'persistent\' key must be set, even if it is null.');
namespace tool_lp\form;
defined('MOODLE_INTERNAL') || die();
-use tool_lp\plan as planpersistent;
+use core_competency\plan as planpersistent;
use required_capability_exception;
/**
*/
class plan extends persistent {
- protected static $persistentclass = 'tool_lp\\plan';
+ protected static $persistentclass = 'core_competency\\plan';
/**
* Define the form - called by parent constructor
*/
class template extends persistent {
- protected static $persistentclass = 'tool_lp\\template';
+ protected static $persistentclass = 'core_competency\\template';
/**
* Define the form - called by parent constructor
*/
class user_evidence extends persistent {
- protected static $persistentclass = 'tool_lp\\user_evidence';
+ protected static $persistentclass = 'core_competency\\user_evidence';
protected static $foreignfields = array('files');
*/
class competency_summary implements renderable, templatable {
- /** @var \tool_lp\competency_framework $framework This competency framework. */
+ /** @var \core_competency\competency_framework $framework This competency framework. */
protected $framework = null;
- /** @var \tool_lp\competency $competency. */
+ /** @var \core_competency\competency $competency. */
protected $competency = null;
- /** @var \tool_lp\competency[] $relatedcompetencies List of competencies. */
+ /** @var \core_competency\competency[] $relatedcompetencies List of competencies. */
protected $relatedcompetencies = array();
/** @var course[] $courses List of courses. */
/**
* Construct this renderable.
*
- * @param \tool_lp\competency $competency Competency persistent.
- * @param \tool_lp\competency_framework $framework framework persistent.
+ * @param \core_competency\competency $competency Competency persistent.
+ * @param \core_competency\competency_framework $framework framework persistent.
* @param boolean $includerelated Include or not related competencies.
* @param boolean $includecourses Include or not competency courses.
*/
use context_system;
use context_course;
use tool_lp\api;
-use tool_lp\course_competency;
-use tool_lp\course_competency_statistics;
-use tool_lp\competency;
+use core_competency\course_competency;
+use core_competency\course_competency_statistics;
+use core_competency\competency;
use tool_lp\external\competency_exporter;
use tool_lp\external\competency_path_exporter;
use tool_lp\external\course_competency_exporter;
/** @var context $context The context for this page. */
protected $context = null;
- /** @var \tool_lp\course_competency[] $competencies List of competencies. */
+ /** @var \core_competency\course_competency[] $competencies List of competencies. */
protected $coursecompetencylist = array();
/** @var bool $canmanagecompetencyframeworks Can the current user manage competency frameworks. */
use moodle_url;
use context_system;
use tool_lp\api;
-use tool_lp\competency;
-use tool_lp\competency_framework;
+use core_competency\competency;
+use core_competency\competency_framework;
use tool_lp\external\competency_framework_exporter;
/**
*/
class manage_competencies_page implements renderable, templatable {
- /** @var \tool_lp\competency_framework $framework This competency framework. */
+ /** @var \core_competency\competency_framework $framework This competency framework. */
protected $framework = null;
- /** @var \tool_lp\competency[] $competencies List of competencies. */
+ /** @var \core_competency\competency[] $competencies List of competencies. */
protected $competencies = array();
/** @var string $search Text to search for. */
/**
* Construct this renderable.
*
- * @param \tool_lp\competency_framework $framework Competency framework.
+ * @param \core_competency\competency_framework $framework Competency framework.
* @param string $search Search string.
* @param context $pagecontext The page context.
*/
use context;
use context_system;
use tool_lp\api;
-use tool_lp\competency_framework;
+use core_competency\competency_framework;
use tool_lp\external\competency_framework_exporter;
/**
use moodle_url;
use context_system;
use tool_lp\api;
-use tool_lp\template;
+use core_competency\template;
use tool_lp\external\template_exporter;
/**
use stdClass;
use moodle_url;
use tool_lp\api;
-use tool_lp\plan;
+use core_competency\plan;
use tool_lp\external\competency_exporter;
use tool_lp\external\competency_path_exporter;
use tool_lp\external\plan_exporter;
use moodle_url;
use tool_lp\api;
use tool_lp\external\plan_exporter;
-use tool_lp\plan;
-use tool_lp\user_evidence;
+use core_competency\plan;
+use core_competency\user_evidence;
use context_user;
/**
/** @var array $navigation List of links to display on the page. Each link contains a url and a title. */
protected $navigation = array();
- /** @var array|\tool_lp\plan[] $plans List of plans. */
+ /** @var array|\core_competency\plan[] $plans List of plans. */
protected $plans = array();
/** @var context_user|null $context context. */
$data->canreaduserevidence = user_evidence::can_read_user($this->userid);
$data->canmanageuserplans = plan::can_manage_user($this->userid);
- // Attach standard objects as mustache can not parse \tool_lp\plan objects.
+ // Attach standard objects as mustache can not parse \core_competency\plan objects.
$data->plans = array();
if ($this->plans) {
foreach ($this->plans as $plan) {
/**
* Constructor.
- * @param \tool_lp\template $template
+ * @param \core_competency\template $template
* @param \moodle_url $url
*/
- public function __construct(\tool_lp\template $template, \moodle_url $url) {
+ public function __construct(\core_competency\template $template, \moodle_url $url) {
$this->template = $template;
$this->url = $url;
$this->table = new template_cohorts_table('tplcohorts', $template);
use html_writer;
use moodle_url;
use table_sql;
-use tool_lp\template;
+use core_competency\template;
/**
* Template cohorts table class.
/** @var context The context. */
protected $context;
- /** @var \tool_lp\template The template. */
+ /** @var \core_competency\template The template. */
protected $template;
/**
* Sets up the table.
*
* @param string $uniqueid Unique id of table.
- * @param \tool_lp\template $template The template.
+ * @param \core_competency\template $template The template.
*/
- public function __construct($uniqueid, \tool_lp\template $template) {
+ public function __construct($uniqueid, \core_competency\template $template) {
parent::__construct($uniqueid);
// This object should not be used without the right permissions.
}
$sql = "SELECT $select
- FROM {" . \tool_lp\template_cohort::TABLE . "} tc
+ FROM {" . \core_competency\template_cohort::TABLE . "} tc
JOIN {cohort} c ON c.id = tc.cohortid
WHERE tc.templateid = :templateid";
$params = array('templateid' => $this->template->get_id());
use moodle_url;
use tool_lp\api;
use tool_lp\external\competency_summary_exporter;
-use tool_lp\template;
-use tool_lp\template_statistics;
+use core_competency\template;
+use core_competency\template_statistics;
use tool_lp\external\template_exporter;
use tool_lp\external\template_statistics_exporter;
/** @var template $template Template for this page. */
protected $template = null;
- /** @var \tool_lp\competency[] $competencies List of competencies. */
+ /** @var \core_competency\competency[] $competencies List of competencies. */
protected $competencies = array();
/** @var bool $canmanagecompetencyframeworks Can the current user manage competency frameworks. */
/**
* Constructor.
- * @param \tool_lp\template $template
+ * @param \core_competency\template $template
* @param \moodle_url $url
*/
- public function __construct(\tool_lp\template $template, \moodle_url $url) {
+ public function __construct(\core_competency\template $template, \moodle_url $url) {
$this->template = $template;
$this->url = $url;
$this->table = new template_plans_table('tplplans', $template);
use html_writer;
use moodle_url;
use table_sql;
-use tool_lp\template;
+use core_competency\template;
/**
* Template plans table class.
/** @var context The context. */
protected $context;
- /** @var \tool_lp\template The template. */
+ /** @var \core_competency\template The template. */
protected $template;
/**
* Sets up the table.
*
* @param string $uniqueid Unique id of table.
- * @param \tool_lp\template $template The template.
+ * @param \core_competency\template $template The template.
*/
- public function __construct($uniqueid, \tool_lp\template $template) {
+ public function __construct($uniqueid, \core_competency\template $template) {
parent::__construct($uniqueid);
// This object should not be used without the right permissions.
}
$sql = "SELECT $select
- FROM {" . \tool_lp\plan::TABLE . "} p
+ FROM {" . \core_competency\plan::TABLE . "} p
JOIN {user} u ON u.id = p.userid
WHERE p.templateid = :templateid";
$params = array('templateid' => $this->template->get_id());
use renderable;
use templatable;
use tool_lp\api;
-use tool_lp\user_competency;
+use core_competency\user_competency;
use tool_lp\external\user_competency_summary_exporter;
/**
use renderer_base;
use templatable;
use tool_lp\api;
-use tool_lp\user_competency;
+use core_competency\user_competency;
use tool_lp\external\user_competency_summary_in_course_exporter;
/**
use moodle_url;
use tool_lp\api;
use tool_lp\external\user_evidence_summary_exporter;
-use tool_lp\user_evidence;
+use core_competency\user_evidence;
use context_user;
/**
*
* @param int $pagecontextid The page context ID.
* @param moodle_url $url The current page.
- * @param \tool_lp\template $template The template, if any.
+ * @param \core_competency\template $template The template, if any.
* @param string $subtitle The title of the subpage, if any.
* @param string $returntype The desired return page.
* @return array With the following:
*
* @param int $userid The user ID.
* @param moodle_url $url The current page.
- * @param \tool_lp\plan $plan The plan, if any.
+ * @param \core_competency\plan $plan The plan, if any.
* @param string $subtitle The title of the subpage, if any.
* @param string $returntype The desired return page.
* @return array With the following:
*
* @param int $userid The user ID.
* @param moodle_url $url The current page.
- * @param \tool_lp\user_evidence $evidence The user evidence, if any.
+ * @param \core_competency\user_evidence $evidence The user evidence, if any.
* @param string $subtitle The title of the subpage, if any.
* @param string $returntype The desired return page.
* @return array With the following:
*
* @param int $id The framework ID.
* @param int $pagecontextid The page context ID.
- * @param \tool_lp\competency_framework $framework The framework.
+ * @param \core_competency\competency_framework $framework The framework.
* @param string $returntype The desired return page.
* @return array With the following:
* - Page title
*
* @param int $pagecontextid The page context ID.
* @param moodle_url $url The current page.
- * @param \tool_lp\competency_framework $framework The competency framework.
- * @param \tool_lp\competency $competency The competency, if any.
- * @param \tool_lp\competency $parent The parent competency, if any.
+ * @param \core_competency\competency_framework $framework The competency framework.
+ * @param \core_competency\competency $competency The competency, if any.
+ * @param \core_competency\competency $parent The parent competency, if any.
* @return array With the following:
* - Page title
* - Page sub title
namespace tool_lp;
defined('MOODLE_INTERNAL') || die();
+use core_competency\api;
+use core_competency\plan;
+use core_competency\template;
+
/**
* Template statistics class.
*
$framework = \tool_lp\api::read_framework($id);
$context = $framework->get_context();
-if (!\tool_lp\competency_framework::can_read_context($context)) {
+if (!\core_competency\competency_framework::can_read_context($context)) {
throw new required_capability_exception($context, 'moodle/competency:competencyview', 'nopermissions', '');
}
require_login();
\tool_lp\api::require_enabled();
-if (!\tool_lp\competency_framework::can_read_context($context)) {
+if (!\core_competency\competency_framework::can_read_context($context)) {
throw new required_capability_exception($context, 'moodle/competency:competencyview', 'nopermissions', '');
}
$observers = array(
array(
'eventname' => '\\core\\event\\course_completed',
- 'callback' => '\\tool_lp\\api::observe_course_completed',
+ 'callback' => '\\core_competency\\api::observe_course_completed',
),
array(
'eventname' => '\\core\\event\\course_module_completion_updated',
- 'callback' => '\\tool_lp\\api::observe_course_module_completion_updated',
+ 'callback' => '\\core_competency\\api::observe_course_module_completion_updated',
),
);
$framework = null;
if (!empty($id)) {
// Always use the context from the framework when it exists.
- $framework = new \tool_lp\competency_framework($id);
+ $framework = new \core_competency\competency_framework($id);
$context = $framework->get_context();
} else {
$context = context::instance_by_id($pagecontextid);
// User can create plan if he can_manage_user with active/complete status
// or if he can_manage_user_draft with draft status.
-$cancreate = \tool_lp\plan::can_manage_user_draft($userid) || \tool_lp\plan::can_manage_user($userid);
+$cancreate = \core_competency\plan::can_manage_user_draft($userid) || \core_competency\plan::can_manage_user($userid);
// If editing plan, check if user has permissions to edit it.
if ($plan != null) {
$template = null;
if (!empty($id)) {
// Always use the context from the framework when it exists.
- $template = new \tool_lp\template($id);
+ $template = new \core_competency\template($id);
$context = $template->get_context();
} else {
$context = context::instance_by_id($pagecontextid);
require_login(0, false);
\tool_lp\api::require_enabled();
-if (!\tool_lp\template::can_read_context($context)) {
+if (!\core_competency\template::can_read_context($context)) {
throw new required_capability_exception($context, 'moodle/competency:templateview', 'nopermissions', '');
}
return;
}
- if (\tool_lp\plan::can_read_user($user->id)) {
+ 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 (\tool_lp\user_evidence::can_read_user($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)));
}
function tool_lp_myprofile_navigation(core_user\output\myprofile\tree $tree, $user, $iscurrentuser, $course) {
if (!\tool_lp\api::is_enabled()) {
return false;
- } else if (!\tool_lp\plan::can_read_user($user->id)) {
+ } else if (!\core_competency\plan::can_read_user($user->id)) {
return false;
}
}
// We check permissions before renderring the links.
- $templatereadcapability = \tool_lp\template::can_read_context($coursecategorycontext);
- $competencyreadcapability = \tool_lp\competency_framework::can_read_context($coursecategorycontext);
+ $templatereadcapability = \core_competency\template::can_read_context($coursecategorycontext);
+ $competencyreadcapability = \core_competency\competency_framework::can_read_context($coursecategorycontext);
if (!$templatereadcapability && !$competencyreadcapability) {
return false;
}
$filepath = $args ? '/' .implode('/', $args) . '/' : '/';
if ($filearea == 'userevidence' && $context->contextlevel == CONTEXT_USER) {
- if (\tool_lp\user_evidence::can_read_user($context->instanceid)) {
+ if (\core_competency\user_evidence::can_read_user($context->instanceid)) {
$file = $fs->get_file($context->id, 'tool_lp', $filearea, $itemid, $filepath, $filename);
}
}
}
if ($params->commentarea == 'user_competency') {
- $uc = new \tool_lp\user_competency($params->itemid);
+ $uc = new \core_competency\user_competency($params->itemid);
// Message both the user and the reviewer, except when they are the author of the message.
$recipients = array($uc->get_userid());
$plan = null;
$plans = $uc->get_plans();
foreach ($plans as $candidate) {
- if ($candidate->get_status() == \tool_lp\plan::STATUS_ACTIVE) {
+ if ($candidate->get_status() == \core_competency\plan::STATUS_ACTIVE) {
$plan = $candidate;
break;
}
} else if ($params->commentarea == 'plan') {
- $plan = new \tool_lp\plan($params->itemid);
+ $plan = new \core_competency\plan($params->itemid);
// Message both the user and the reviewer, except when they are the author of the message.
$recipients = array($plan->get_userid());
}
if ($params->commentarea == 'user_competency') {
- $uc = new \tool_lp\user_competency($params->itemid);
+ $uc = new \core_competency\user_competency($params->itemid);
if ($uc->can_read()) {
return array('post' => $uc->can_comment(), 'view' => $uc->can_read_comments());
}
} else if ($params->commentarea == 'plan') {
- $plan = new \tool_lp\plan($params->itemid);
+ $plan = new \core_competency\plan($params->itemid);
if ($plan->can_read()) {
return array('post' => $plan->can_comment(), 'view' => $plan->can_read_comments());
}
}
if ($params->commentarea == 'user_competency') {
- if (!\tool_lp\user_competency::record_exists($params->itemid)) {
+ if (!\core_competency\user_competency::record_exists($params->itemid)) {
return false;
}
return true;
} else if ($params->commentarea == 'plan') {
- if (!\tool_lp\plan::record_exists($params->itemid)) {
+ if (!\core_competency\plan::record_exists($params->itemid)) {
return false;
}
return true;
// 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 = \tool_lp\course_module_competency::list_course_module_competencies($data->coursemodule);
+ $existing = \core_competency\course_module_competency::list_course_module_competencies($data->coursemodule);
$existingids = array();
foreach ($existing as $cmc) {
if ($template->get_visible() && $i < $maxtocreate && !$duedatereached) {
// Only create a few plans right now.
- $tocreate = \tool_lp\template_cohort::get_missing_plans($template->get_id(), $cohortid);
+ $tocreate = \core_competency\template_cohort::get_missing_plans($template->get_id(), $cohortid);
if ($i + count($tocreate) <= $maxtocreate) {
$i += \tool_lp\api::create_plans_from_template_cohort($template, $cohortid);
} else {
global $CFG;
use tool_lp\api;
-use tool_lp\competency;
-use tool_lp\competency_framework;
-use tool_lp\course_competency_settings;
-use tool_lp\evidence;
-use tool_lp\user_competency;
-use tool_lp\plan;
+use core_competency\competency;
+use core_competency\competency_framework;
+use core_competency\course_competency_settings;
+use core_competency\evidence;
+use core_competency\user_competency;
+use core_competency\plan;
/**
* API tests.
array('id' => $competency42->get_id(), 'points' => 2, 'required' => 1),
)
));
- $competency4->set_ruletype('tool_lp\competency_rule_points');
- $competency4->set_ruleoutcome(\tool_lp\competency::OUTCOME_EVIDENCE);
+ $competency4->set_ruletype('core_competency\competency_rule_points');
+ $competency4->set_ruleoutcome(\core_competency\competency::OUTCOME_EVIDENCE);
$competency4->set_ruleconfig($config);
$competency4->update();
// Check if user create draft can edit the plan name.
$plan = api::update_plan($record);
- $this->assertInstanceOf('\tool_lp\plan', $plan);
+ $this->assertInstanceOf('\core_competency\plan', $plan);
// The status cannot be changed in this method.
- $record->status = \tool_lp\plan::STATUS_ACTIVE;
+ $record->status = \core_competency\plan::STATUS_ACTIVE;
try {
$plan = api::update_plan($record);
$this->fail('Updating the status is not allowed.');
}
// Test when user with manage own plan capability try to edit other user plan.
- $record->status = \tool_lp\plan::STATUS_DRAFT;
+ $record->status = \core_competency\plan::STATUS_DRAFT;
$record->name = 'plan create draft modified 2';
$this->setUser($usermanageown);
try {
// User with manage draft capability can edit other user's learning plan if the status is draft.
$this->setUser($usermanagedraft);
- $record->status = \tool_lp\plan::STATUS_DRAFT;
+ $record->status = \core_competency\plan::STATUS_DRAFT;
$record->name = 'plan manage draft modified 3';
$plan = api::update_plan($record);
- $this->assertInstanceOf('\tool_lp\plan', $plan);
+ $this->assertInstanceOf('\core_competency\plan', $plan);
// User with manage plan capability can create/edit learning plan if status is active/complete.
$this->setUser($usermanage);
'name' => 'plan create',
'description' => 'plan create',
'userid' => $usermanage->id,
- 'status' => \tool_lp\plan::STATUS_ACTIVE
+ 'status' => \core_competency\plan::STATUS_ACTIVE
);
$plan = api::create_plan((object)$plan);
// Silently transition to complete status to avoid errors about transitioning to complete.
- $plan->set_status(\tool_lp\plan::STATUS_COMPLETE);
+ $plan->set_status(\core_competency\plan::STATUS_COMPLETE);
$plan->update();
$record = $plan->to_record();
// Creating a new plan.
$plan = api::create_plan_from_template($tpl, $u1->id);
$record = $plan->to_record();
- $this->assertInstanceOf('\tool_lp\plan', $plan);
- $this->assertTrue(\tool_lp\plan::record_exists($plan->get_id()));
+ $this->assertInstanceOf('\core_competency\plan', $plan);
+ $this->assertTrue(\core_competency\plan::record_exists($plan->get_id()));
$this->assertEquals($tpl->get_id(), $plan->get_templateid());
$this->assertEquals($u1->id, $plan->get_userid());
$this->assertTrue($plan->is_based_on_template());
$plan3 = $lpg->create_plan(array('userid' => $u1->id, 'templateid' => $tpl1->get_id(), 'status' => plan::STATUS_COMPLETE));
// Check that we have what we expect at this stage.
- $this->assertEquals(2, \tool_lp\template_competency::count_records(array('templateid' => $tpl1->get_id())));
- $this->assertEquals(1, \tool_lp\template_competency::count_records(array('templateid' => $tpl2->get_id())));
- $this->assertEquals(0, \tool_lp\plan_competency::count_records(array('planid' => $plan1->get_id())));
- $this->assertEquals(0, \tool_lp\plan_competency::count_records(array('planid' => $plan2->get_id())));
+ $this->assertEquals(2, \core_competency\template_competency::count_records(array('templateid' => $tpl1->get_id())));
+ $this->assertEquals(1, \core_competency\template_competency::count_records(array('templateid' => $tpl2->get_id())));
+ $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan1->get_id())));
+ $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan2->get_id())));
$this->assertTrue($plan1->is_based_on_template());
$this->assertTrue($plan2->is_based_on_template());
// Let's do this!
- $tpl1comps = \tool_lp\template_competency::list_competencies($tpl1->get_id(), true);
- $tpl2comps = \tool_lp\template_competency::list_competencies($tpl2->get_id(), true);
+ $tpl1comps = \core_competency\template_competency::list_competencies($tpl1->get_id(), true);
+ $tpl2comps = \core_competency\template_competency::list_competencies($tpl2->get_id(), true);
api::unlink_plan_from_template($plan1);
$plan2->read();
$this->assertCount(2, $tpl1comps);
$this->assertCount(1, $tpl2comps);
- $this->assertEquals(2, \tool_lp\template_competency::count_records(array('templateid' => $tpl1->get_id())));
- $this->assertEquals(1, \tool_lp\template_competency::count_records(array('templateid' => $tpl2->get_id())));
- $this->assertEquals(2, \tool_lp\plan_competency::count_records(array('planid' => $plan1->get_id())));
- $this->assertEquals(0, \tool_lp\plan_competency::count_records(array('planid' => $plan2->get_id())));
+ $this->assertEquals(2, \core_competency\template_competency::count_records(array('templateid' => $tpl1->get_id())));
+ $this->assertEquals(1, \core_competency\template_competency::count_records(array('templateid' => $tpl2->get_id())));
+ $this->assertEquals(2, \core_competency\plan_competency::count_records(array('planid' => $plan1->get_id())));
+ $this->assertEquals(0, \core_competency\plan_competency::count_records(array('planid' => $plan2->get_id())));
$this->assertFalse($plan1->is_based_on_template());
$this->assertEquals($tpl1->get_id(), $plan1->get_origtemplateid());
$this->assertTrue($plan2->is_based_on_template());
}
// Even the order remains.
- $plan1comps = \tool_lp\plan_competency::list_competencies($plan1->get_id());
+ $plan1comps = \core_competency\plan_competency::list_competencies($plan1->get_id());
$before = reset($tpl1comps);
$after = reset($plan1comps);
$this->assertEquals($before->get_id(), $after->get_id());
'proficiency' => false, 'grade' => 2 ))
);
- $this->assertEquals(2, \tool_lp\user_competency::count_records());
- $this->assertEquals(0, \tool_lp\user_competency_plan::count_records());
+ $this->assertEquals(2, \core_competency\user_competency::count_records());
+ $this->assertEquals(0, \core_competency\user_competency_plan::count_records());
// Change status of the plan to complete.
api::complete_plan($plan);
// Check that user competencies are now in user_competency_plan objects and still in user_competency.
- $this->assertEquals(2, \tool_lp\user_competency::count_records());
- $this->assertEquals(3, \tool_lp\user_competency_plan::count_records());
+ $this->assertEquals(2, \core_competency\user_competency::count_records());
+ $this->assertEquals(3, \core_competency\user_competency_plan::count_records());
- $usercompetenciesplan = \tool_lp\user_competency_plan::get_records();
+ $usercompetenciesplan = \core_competency\user_competency_plan::get_records();
$this->assertEquals($uclist[0]->get_userid(), $usercompetenciesplan[0]->get_userid());
$this->assertEquals($uclist[0]->get_competencyid(), $usercompetenciesplan[0]->get_competencyid());
// Change status of the plan to complete.
$record = $plan->to_record();
- $record->status = \tool_lp\plan::STATUS_COMPLETE;
+ $record->status = \core_competency\plan::STATUS_COMPLETE;
try {
$plan = api::update_plan($record);
api::complete_plan($plan);
// Check that user compretencies are now in user_competency_plan objects and still in user_competency.
- $this->assertEquals(2, \tool_lp\user_competency::count_records());
- $this->assertEquals(3, \tool_lp\user_competency_plan::count_records());
+ $this->assertEquals(2, \core_competency\user_competency::count_records());
+ $this->assertEquals(3, \core_competency\user_competency_plan::count_records());
- $usercompetenciesplan = \tool_lp\user_competency_plan::get_records();
+ $usercompetenciesplan = \core_competency\user_competency_plan::get_records();
$this->assertEquals($uclist[0]->get_userid(), $usercompetenciesplan[0]->get_userid());
$this->assertEquals($uclist[0]->get_competencyid(), $usercompetenciesplan[0]->get_competencyid());
// Change status of the plan to active.
$record = $plan->to_record();
- $record->status = \tool_lp\plan::STATUS_ACTIVE;
+ $record->status = \core_competency\plan::STATUS_ACTIVE;
try {
api::update_plan($record);
api::reopen_plan($record->id);
// Check that user_competency_plan objects are deleted if the plan status is changed to another status.
- $this->assertEquals(2, \tool_lp\user_competency::count_records());
- $this->assertEquals(0, \tool_lp\user_competency_plan::count_records());
+ $this->assertEquals(2, \core_competency\user_competency::count_records());
+ $this->assertEquals(0, \core_competency\user_competency_plan::count_records());
}
/**
$c3 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
// Create completed plan with records in user_competency.
- $completedplan = $lpg->create_plan(array('userid' => $user->id, 'status' => \tool_lp\plan::STATUS_COMPLETE));
+ $completedplan = $lpg->create_plan(array('userid' => $user->id, 'status' => \core_competency\plan::STATUS_COMPLETE));
$lpg->create_plan_competency(array('planid' => $completedplan->get_id(), 'competencyid' => $c1->get_id()));
$lpg->create_plan_competency(array('planid' => $completedplan->get_id(), 'competencyid' => $c2->get_id()));
api::delete_plan($completedplan->get_id());
// Check that achived user competencies are deleted.
- $this->assertEquals(0, \tool_lp\plan::count_records());
- $this->assertEquals(2, \tool_lp\user_competency::count_records());
- $this->assertEquals(0, \tool_lp\user_competency_plan::count_records());
+ $this->assertEquals(0, \core_competency\plan::count_records());
+ $this->assertEquals(2, \core_competency\user_competency::count_records());
+ $this->assertEquals(0, \core_competency\user_competency_plan::count_records());
}
/**
$plancompetencies = api::list_plan_competencies($draftplan);
$this->assertCount(3, $plancompetencies);
- $this->assertInstanceOf('\tool_lp\user_competency', $plancompetencies[0]->usercompetency);
+ $this->assertInstanceOf('\core_competency\user_competency', $plancompetencies[0]->usercompetency);
$this->assertEquals($uc1->get_id(), $plancompetencies[0]->usercompetency->get_id());
$this->assertNull($plancompetencies[0]->usercompetencyplan);
- $this->assertInstanceOf('\tool_lp\user_competency', $plancompetencies[1]->usercompetency);
+ $this->assertInstanceOf('\core_competency\user_competency', $plancompetencies[1]->usercompetency);
$this->assertEquals($uc2->get_id(), $plancompetencies[1]->usercompetency->get_id());
$this->assertNull($plancompetencies[1]->usercompetencyplan);
- $this->assertInstanceOf('\tool_lp\user_competency', $plancompetencies[2]->usercompetency);
+ $this->assertInstanceOf('\core_competency\user_competency', $plancompetencies[2]->usercompetency);
$this->assertEquals(0, $plancompetencies[2]->usercompetency->get_id());
$this->assertNull($plancompetencies[2]->usercompetencyplan);
// Create completed plan with records in user_competency_plan.
- $completedplan = $lpg->create_plan(array('userid' => $user->id, 'status' => \tool_lp\plan::STATUS_COMPLETE));
+ $completedplan = $lpg->create_plan(array('userid' => $user->id, 'status' => \core_competency\plan::STATUS_COMPLETE));
$pc1 = $lpg->create_plan_competency(array('planid' => $completedplan->get_id(), 'competencyid' => $c1->get_id()));
$pc2 = $lpg->create_plan_competency(array('planid' => $completedplan->get_id(), 'competencyid' => $c2->get_id()));
$plancompetencies = api::list_plan_competencies($completedplan);
$this->assertCount(3, $plancompetencies);
- $this->assertInstanceOf('\tool_lp\user_competency_plan', $plancompetencies[0]->usercompetencyplan);
+ $this->assertInstanceOf('\core_competency\user_competency_plan', $plancompetencies[0]->usercompetencyplan);
$this->assertEquals($ucp1->get_id(), $plancompetencies[0]->usercompetencyplan->get_id());
$this->assertNull($plancompetencies[0]->usercompetency);
- $this->assertInstanceOf('\tool_lp\user_competency_plan', $plancompetencies[1]->usercompetencyplan);
+ $this->assertInstanceOf('\core_competency\user_competency_plan', $plancompetencies[1]->usercompetencyplan);
$this->assertEquals($ucp2->get_id(), $plancompetencies[1]->usercompetencyplan->get_id());
$this->assertNull($plancompetencies[1]->usercompetency);
- $this->assertInstanceOf('\tool_lp\user_competency_plan', $plancompetencies[2]->usercompetencyplan);
+ $this->assertInstanceOf('\core_competency\user_competency_plan', $plancompetencies[2]->usercompetencyplan);
$this->assertEquals($ucp3->get_id(), $plancompetencies[2]->usercompetencyplan->get_id());
$this->assertNull($plancompetencies[2]->usercompetency);
}
$t1 = $lpg->create_template();
$t2 = $lpg->create_template();
- $this->assertEquals(0, \tool_lp\template_cohort::count_records());
+ $this->assertEquals(0, \core_competency\template_cohort::count_records());
// Create two relations with mixed parameters.
$result = api::create_template_cohort($t1->get_id(), $c1->id);
$result = api::create_template_cohort($t1, $c2);
- $this->assertEquals(2, \tool_lp\template_cohort::count_records());
- $this->assertInstanceOf('tool_lp\template_cohort', $result);
+ $this->assertEquals(2, \core_competency\template_cohort::count_records());
+ $this->assertInstanceOf('core_competency\template_cohort', $result);
$this->assertEquals($c2->id, $result->get_cohortid());
$this->assertEquals($t1->get_id(), $result->get_templateid());
- $this->assertEquals(2, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
- $this->assertEquals(0, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
+ $this->assertEquals(2, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
+ $this->assertEquals(0, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
}
public function test_create_template_cohort_permissions() {
$c2 = $dg->create_cohort(array('visible' => 0, 'contextid' => $catcontext->id));
$t1 = $lpg->create_template();
- $this->assertEquals(0, \tool_lp\template_cohort::count_records());
+ $this->assertEquals(0, \core_competency\template_cohort::count_records());
$this->setUser($user);
$result = api::create_template_cohort($t1, $c1);
- $this->assertInstanceOf('tool_lp\\template_cohort', $result);
+ $this->assertInstanceOf('core_competency\\template_cohort', $result);
try {
$result = api::create_template_cohort($t1, $c2);
accesslib_clear_all_caches_for_unit_testing();
$result = api::create_template_cohort($t1, $c2);
- $this->assertInstanceOf('tool_lp\\template_cohort', $result);
+ $this->assertInstanceOf('core_competency\\template_cohort', $result);
}
public function test_delete_template() {
$tc1 = $lpg->create_template_cohort(array('templateid' => $template->get_id(), 'cohortid' => $c2->id));
// Check pre-test.
- $this->assertTrue(tool_lp\template::record_exists($id));
- $this->assertEquals(2, \tool_lp\template_cohort::count_records(array('templateid' => $id)));
+ $this->assertTrue(\core_competency\template::record_exists($id));
+ $this->assertEquals(2, \core_competency\template_cohort::count_records(array('templateid' => $id)));
$result = api::delete_template($template->get_id());
$this->assertTrue($result);
// Check that the template deos not exist anymore.
- $this->assertFalse(tool_lp\template::record_exists($id));
+ $this->assertFalse(\core_competency\template::record_exists($id));
// Test if associated cohorts are also deleted.
- $this->assertEquals(0, \tool_lp\template_cohort::count_records(array('templateid' => $id)));
+ $this->assertEquals(0, \core_competency\template_cohort::count_records(array('templateid' => $id)));
}
public function test_delete_template_cohort() {
$tc1 = $lpg->create_template_cohort(array('templateid' => $t1->get_id(), 'cohortid' => $c1->id));
$tc1 = $lpg->create_template_cohort(array('templateid' => $t2->get_id(), 'cohortid' => $c2->id));
- $this->assertEquals(2, \tool_lp\template_cohort::count_records());
- $this->assertEquals(1, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
- $this->assertEquals(1, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
+ $this->assertEquals(2, \core_competency\template_cohort::count_records());
+ $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
+ $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
// Delete existing.
$result = api::delete_template_cohort($t1->get_id(), $c1->id);
$this->assertTrue($result);
- $this->assertEquals(1, \tool_lp\template_cohort::count_records());
- $this->assertEquals(0, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
- $this->assertEquals(1, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
+ $this->assertEquals(1, \core_competency\template_cohort::count_records());
+ $this->assertEquals(0, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
+ $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
// Delete non-existant.
$result = api::delete_template_cohort($t1->get_id(), $c1->id);
$this->assertTrue($result);
- $this->assertEquals(1, \tool_lp\template_cohort::count_records());
- $this->assertEquals(0, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
- $this->assertEquals(1, \tool_lp\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
+ $this->assertEquals(1, \core_competency\template_cohort::count_records());
+ $this->assertEquals(0, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t1->get_id())));
+ $this->assertEquals(1, \core_competency\template_cohort::count_records_select('templateid = :id', array('id' => $t2->get_id())));
}
public function test_add_evidence_log() {
$c2 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
// Creating a standard evidence with minimal information.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_LOG, 'invaliddata', 'error');
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata', 'error');
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertSame(null, $uc->get_grade());
$this->assertSame(null, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_LOG, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_LOG, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
$this->assertSame(null, $evidence->get_actionuserid());
// Creating a standard evidence with more information.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_LOG, 'invaliddata', 'error',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata', 'error',
'$a', false, 'http://moodle.org', null, 2, 'The evidence of prior learning were reviewed.');
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertSame(null, $uc->get_grade());
$this->assertSame(null, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_LOG, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_LOG, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertEquals('$a', $evidence->get_desca());
$this->assertSame('The evidence of prior learning were reviewed.', $evidence->get_note());
// Creating a standard evidence and send for review.
- $evidence = api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_LOG, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
'error', null, true);
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
// Trying to pass a grade should fail.
try {
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_LOG, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
'error', null, false, null, 1);
$this->fail('A grade can not be set');
} catch (coding_exception $e) {
$c3 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
// Creating an evidence with minimal information.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_COMPLETE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
'error');
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertEquals(2, $uc->get_grade()); // The grade has been set automatically to the framework default.
$this->assertEquals(0, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_COMPLETE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
$this->assertSame(null, $evidence->get_actionuserid());
// Creating an evidence complete on competency with custom scale.
- $evidence = api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_COMPLETE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
'error');
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertEquals(4, $uc->get_grade()); // The grade has been set automatically to the competency default.
$this->assertEquals(true, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_COMPLETE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
'proficiency' => 0));
$this->assertEquals(1, $uc->get_grade());
$this->assertEquals(0, $uc->get_proficiency());
- $evidence = api::add_evidence($u1->id, $c3->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_COMPLETE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c3->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
'error');
$evidence->read();
$uc->read();
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertEquals(1, $uc->get_grade()); // The grade has not been changed.
$this->assertEquals(0, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_COMPLETE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
$this->assertSame(null, $evidence->get_actionuserid());
// Creating a standard evidence and send for review.
- $evidence = api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_COMPLETE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
'error', null, true);
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
// Trying to pass a grade should throw an exception.
try {
- api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_COMPLETE, 'invaliddata',
+ api::add_evidence($u1->id, $c2->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_COMPLETE, 'invaliddata',
'error', null, false, null, 1);
} catch (coding_exception $e) {
$this->assertRegExp('/grade MUST NOT be set/', $e->getMessage());
$c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
// Creating an evidence with minimal information.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_OVERRIDE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
'error');
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertSame(null, $uc->get_grade()); // We overrode with 'null'.
$this->assertSame(null, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_OVERRIDE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
$this->assertSame(null, $evidence->get_actionuserid());
// Creating an evidence with a grade information.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_OVERRIDE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
'error', null, false, null, 3);
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertEquals(3, $uc->get_grade());
$this->assertEquals(true, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_OVERRIDE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
$this->assertSame(null, $evidence->get_actionuserid());
// Creating an evidence with another grade information.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_OVERRIDE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
'error', null, false, null, 1);
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc->get_status());
$this->assertEquals(1, $uc->get_grade());
$this->assertEquals(0, $uc->get_proficiency());
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals($u1ctx->id, $evidence->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_OVERRIDE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get_action());
$this->assertEquals('invaliddata', $evidence->get_descidentifier());
$this->assertEquals('error', $evidence->get_desccomponent());
$this->assertSame(null, $evidence->get_desca());
$this->assertSame(null, $evidence->get_actionuserid());
// Creating reverting the grade and send for review.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_OVERRIDE, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_OVERRIDE, 'invaliddata',
'error', null, true);
$evidence->read();
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
$this->assertSame(null, $uc->get_grade());
$this->assertSame(null, $uc->get_proficiency());
- $this->assertEquals(\tool_lp\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
+ $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
$this->assertSame(null, $evidence->get_grade());
}
$c1 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
// Non-existing user competencies are created up for review.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_LOG, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
'error', null, true);
- $uc = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
- $this->assertEquals(\tool_lp\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
+ $uc = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c1->get_id()));
+ $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
// Existing user competencies sent for review don't change.
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_LOG, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
'error', null, true);
$uc->read();
- $this->assertEquals(\tool_lp\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
+ $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc->get_status());
// A user competency with a status non-idle won't change.
- $uc->set_status(\tool_lp\user_competency::STATUS_IN_REVIEW);
+ $uc->set_status(\core_competency\user_competency::STATUS_IN_REVIEW);
$uc->update();
- $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \tool_lp\evidence::ACTION_LOG, 'invaliddata',
+ $evidence = api::add_evidence($u1->id, $c1->get_id(), $u1ctx->id, \core_competency\evidence::ACTION_LOG, 'invaliddata',
'error', null, true);
$uc->read();
- $this->assertEquals(\tool_lp\user_competency::STATUS_IN_REVIEW, $uc->get_status());
+ $this->assertEquals(\core_competency\user_competency::STATUS_IN_REVIEW, $uc->get_status());
}
/**
$this->assertSame(null, $uc->get_proficiency());
// Create an evidence and check it was created with the right usercomptencyid and information.
- $evidence = api::add_evidence($user->id, $c1->get_id(), $syscontext->id, \tool_lp\evidence::ACTION_OVERRIDE,
+ $evidence = api::add_evidence($user->id, $c1->get_id(), $syscontext->id, \core_competency\evidence::ACTION_OVERRIDE,
'invalidevidencedesc', 'tool_lp', array('a' => 'b'), false, 'http://moodle.org', 1, 2);
- $this->assertEquals(1, \tool_lp\evidence::count_records());
+ $this->assertEquals(1, \core_competency\evidence::count_records());
$evidence->read();
$uc->read();
$this->assertEquals('tool_lp', $evidence->get_desccomponent());
$this->assertEquals((object) array('a' => 'b'), $evidence->get_desca());
$this->assertEquals('http://moodle.org', $evidence->get_url());
- $this->assertEquals(\tool_lp\evidence::ACTION_OVERRIDE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get_action());
$this->assertEquals(2, $evidence->get_actionuserid());
$this->assertEquals(1, $evidence->get_grade());
$this->assertEquals(1, $uc->get_grade());
$framework = $lpg->create_framework();
$c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
$c2 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
- $this->assertEquals(0, \tool_lp\user_competency::count_records());
+ $this->assertEquals(0, \core_competency\user_competency::count_records());
// Create an evidence without a user competency record.
- $evidence = api::add_evidence($user->id, $c1->get_id(), $syscontext->id, \tool_lp\evidence::ACTION_OVERRIDE,
+ $evidence = api::add_evidence($user->id, $c1->get_id(), $syscontext->id, \core_competency\evidence::ACTION_OVERRIDE,
'invalidevidencedesc', 'tool_lp', 'Hello world!', false, 'http://moodle.org', 1, 2);
- $this->assertEquals(1, \tool_lp\evidence::count_records());
- $this->assertEquals(1, \tool_lp\user_competency::count_records());
+ $this->assertEquals(1, \core_competency\evidence::count_records());
+ $this->assertEquals(1, \core_competency\user_competency::count_records());
- $uc = \tool_lp\user_competency::get_record(array('userid' => $user->id, 'competencyid' => $c1->get_id()));
+ $uc = \core_competency\user_competency::get_record(array('userid' => $user->id, 'competencyid' => $c1->get_id()));
$evidence->read();
$this->assertEquals($uc->get_id(), $evidence->get_usercompetencyid());
$this->assertEquals('invalidevidencedesc', $evidence->get_descidentifier());
$this->assertEquals('tool_lp', $evidence->get_desccomponent());
$this->assertEquals('Hello world!', $evidence->get_desca());
$this->assertEquals('http://moodle.org', $evidence->get_url());
- $this->assertEquals(\tool_lp\evidence::ACTION_OVERRIDE, $evidence->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_OVERRIDE, $evidence->get_action());
$this->assertEquals(2, $evidence->get_actionuserid());
$this->assertEquals(1, $evidence->get_grade());
$this->assertEquals(1, $uc->get_grade());
$c5 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
// Setting up the rules.
- $c1->set_ruletype('tool_lp\\competency_rule_all');
- $c1->set_ruleoutcome(\tool_lp\competency::OUTCOME_COMPLETE);
+ $c1->set_ruletype('core_competency\\competency_rule_all');
+ $c1->set_ruleoutcome(\core_competency\competency::OUTCOME_COMPLETE);
$c1->update();
- $c2->set_ruletype('tool_lp\\competency_rule_all');
- $c2->set_ruleoutcome(\tool_lp\competency::OUTCOME_RECOMMEND);
+ $c2->set_ruletype('core_competency\\competency_rule_all');
+ $c2->set_ruleoutcome(\core_competency\competency::OUTCOME_RECOMMEND);
$c2->update();
- $c3->set_ruletype('tool_lp\\competency_rule_all');
- $c3->set_ruleoutcome(\tool_lp\competency::OUTCOME_EVIDENCE);
+ $c3->set_ruletype('core_competency\\competency_rule_all');
+ $c3->set_ruleoutcome(\core_competency\competency::OUTCOME_EVIDENCE);
$c3->update();
- $c4->set_ruletype('tool_lp\\competency_rule_all');
- $c4->set_ruleoutcome(\tool_lp\competency::OUTCOME_NONE);
+ $c4->set_ruletype('core_competency\\competency_rule_all');
+ $c4->set_ruleoutcome(\core_competency\competency::OUTCOME_NONE);
$c4->update();
// Confirm the current data.
'userid' => $student->id,
'competencyid' => $comp->get_id(),
);
- $usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
+ $usercompcourse = \core_competency\user_competency_course::get_record($filterparams);
// There should be no user_competency_course object created when grading.
$this->assertFalse($usercompcourse);
}
$evidence = api::add_evidence($student->id, $comp, $coursecontext, evidence::ACTION_OVERRIDE,
'commentincontext', 'core', null, false, null, 3, $USER->id);
// Get user competency course record.
- $usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
+ $usercompcourse = \core_competency\user_competency_course::get_record($filterparams);
// There should be a user_competency_course object when adding a grade.
$this->assertNotEmpty($usercompcourse);
$grade = $evidence->get_grade();
'userid' => $student->id,
'competencyid' => $comp->get_id(),
];
- $usercompetency = \tool_lp\user_competency::get_record($usercompetencyparams);
+ $usercompetency = \core_competency\user_competency::get_record($usercompetencyparams);
$this->assertNotEmpty($usercompetency);
$this->assertNotEquals($usercompcourse->get_grade(), $usercompetency->get_grade());
$this->assertNotEquals($usercompcourse->get_proficiency(), $usercompetency->get_proficiency());
$c3 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
$c4 = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
$cc1 = $lpg->create_course_competency(array('competencyid' => $c1->get_id(), 'courseid' => $course->id,
- 'ruleoutcome' => \tool_lp\course_competency::OUTCOME_NONE));
+ 'ruleoutcome' => \core_competency\course_competency::OUTCOME_NONE));
$cc2 = $lpg->create_course_competency(array('competencyid' => $c2->get_id(), 'courseid' => $course->id,
- 'ruleoutcome' => \tool_lp\course_competency::OUTCOME_EVIDENCE));
+ 'ruleoutcome' => \core_competency\course_competency::OUTCOME_EVIDENCE));
$cc3 = $lpg->create_course_competency(array('competencyid' => $c3->get_id(), 'courseid' => $course->id,
- 'ruleoutcome' => \tool_lp\course_competency::OUTCOME_RECOMMEND));
+ 'ruleoutcome' => \core_competency\course_competency::OUTCOME_RECOMMEND));
$cc4 = $lpg->create_course_competency(array('competencyid' => $c4->get_id(), 'courseid' => $course->id,
- 'ruleoutcome' => \tool_lp\course_competency::OUTCOME_COMPLETE));
+ 'ruleoutcome' => \core_competency\course_competency::OUTCOME_COMPLETE));
$event = \core\event\course_completed::create(array(
'objectid' => 1,
'courseid' => $course->id,
'other' => array('relateduserid' => $u1->id)
));
- $this->assertEquals(0, \tool_lp\user_competency::count_records());
- $this->assertEquals(0, \tool_lp\evidence::count_records());
+ $this->assertEquals(0, \core_competency\user_competency::count_records());
+ $this->assertEquals(0, \core_competency\evidence::count_records());
// Let's go!
api::observe_course_completed($event);
- $this->assertEquals(3, \tool_lp\user_competency::count_records());
- $this->assertEquals(3, \tool_lp\evidence::count_records());
+ $this->assertEquals(3, \core_competency\user_competency::count_records());
+ $this->assertEquals(3, \core_competency\evidence::count_records());
// Outcome NONE did nothing.
- $this->assertFalse(\tool_lp\user_competency::record_exists_select('userid = :uid AND competencyid = :cid', array(
+ $this->assertFalse(\core_competency\user_competency::record_exists_select('userid = :uid AND competencyid = :cid', array(
'uid' => $u1->id, 'cid' => $c1->get_id()
)));
// Outcome evidence.
- $uc2 = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
- $ev2 = \tool_lp\evidence::get_record(array('usercompetencyid' => $uc2->get_id()));
+ $uc2 = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c2->get_id()));
+ $ev2 = \core_competency\evidence::get_record(array('usercompetencyid' => $uc2->get_id()));
$this->assertEquals(null, $uc2->get_grade());
$this->assertEquals(null, $uc2->get_proficiency());
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc2->get_status());
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc2->get_status());
$this->assertEquals('evidence_coursecompleted', $ev2->get_descidentifier());
$this->assertEquals('tool_lp', $ev2->get_desccomponent());
$this->assertStringEndsWith('/report/completion/index.php?course=' . $course->id, $ev2->get_url());
$this->assertEquals(null, $ev2->get_grade());
$this->assertEquals($coursectx->id, $ev2->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_LOG, $ev2->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_LOG, $ev2->get_action());
$this->assertEquals(null, $ev2->get_actionuserid());
// Outcome recommend.
- $uc3 = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c3->get_id()));
- $ev3 = \tool_lp\evidence::get_record(array('usercompetencyid' => $uc3->get_id()));
+ $uc3 = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c3->get_id()));
+ $ev3 = \core_competency\evidence::get_record(array('usercompetencyid' => $uc3->get_id()));
$this->assertEquals(null, $uc3->get_grade());
$this->assertEquals(null, $uc3->get_proficiency());
- $this->assertEquals(\tool_lp\user_competency::STATUS_WAITING_FOR_REVIEW, $uc3->get_status());
+ $this->assertEquals(\core_competency\user_competency::STATUS_WAITING_FOR_REVIEW, $uc3->get_status());
$this->assertEquals('evidence_coursecompleted', $ev3->get_descidentifier());
$this->assertEquals('tool_lp', $ev3->get_desccomponent());
$this->assertStringEndsWith('/report/completion/index.php?course=' . $course->id, $ev3->get_url());
$this->assertEquals(null, $ev3->get_grade());
$this->assertEquals($coursectx->id, $ev3->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_LOG, $ev3->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_LOG, $ev3->get_action());
$this->assertEquals(null, $ev3->get_actionuserid());
// Outcome complete.
- $uc4 = \tool_lp\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c4->get_id()));
- $ev4 = \tool_lp\evidence::get_record(array('usercompetencyid' => $uc4->get_id()));
+ $uc4 = \core_competency\user_competency::get_record(array('userid' => $u1->id, 'competencyid' => $c4->get_id()));
+ $ev4 = \core_competency\evidence::get_record(array('usercompetencyid' => $uc4->get_id()));
$this->assertEquals(3, $uc4->get_grade());
$this->assertEquals(1, $uc4->get_proficiency());
- $this->assertEquals(\tool_lp\user_competency::STATUS_IDLE, $uc4->get_status());
+ $this->assertEquals(\core_competency\user_competency::STATUS_IDLE, $uc4->get_status());
$this->assertEquals('evidence_coursecompleted', $ev4->get_descidentifier());
$this->assertEquals('tool_lp', $ev4->get_desccomponent());
$this->assertStringEndsWith('/report/completion/index.php?course=' . $course->id, $ev4->get_url());
$this->assertEquals(3, $ev4->get_grade());
$this->assertEquals($coursectx->id, $ev4->get_contextid());
- $this->assertEquals(\tool_lp\evidence::ACTION_COMPLETE, $ev4->get_action());
+ $this->assertEquals(\core_competency\evidence::ACTION_COMPLETE, $ev4->get_action());
$this->assertEquals(null, $ev4->get_actionuserid());
}
$cc = api::add_competency_to_course($course->id, $c->get_id());
// Check record was created with default rule value Evidence.
- $this->assertEquals(1, \tool_lp\course_competency::count_records());
+ $this->assertEquals(1, \core_competency\course_competency::count_records());
$recordscc = api::list_course_competencies($course->id);
- $this->assertEquals(\tool_lp\course_competency::OUTCOME_EVIDENCE, $recordscc[0]['coursecompetency']->get_ruleoutcome());
+ $this->assertEquals(\core_competency\course_competency::OUTCOME_EVIDENCE, $recordscc[0]['coursecompetency']->get_ruleoutcome());
// Check ruleoutcome value is updated to None.
$this->assertTrue(api::set_course_competency_ruleoutcome($recordscc[0]['coursecompetency']->get_id(),
- \tool_lp\course_competency::OUTCOME_NONE));
+ \core_competency\course_competency::OUTCOME_NONE));
$recordscc = api::list_course_competencies($course->id);
- $this->assertEquals(\tool_lp\course_competency::OUTCOME_NONE, $recordscc[0]['coursecompetency']->get_ruleoutcome());
+ $this->assertEquals(\core_competency\course_competency::OUTCOME_NONE, $recordscc[0]['coursecompetency']->get_ruleoutcome());
}
/**
'proficiency' => true, 'grade' => 3 ));
$usercompetency->create();
$this->fail('Invalid grade not detected in framework scale');
- } catch (\tool_lp\invalid_persistent_exception $e) {
+ } catch (\core_competency\invalid_persistent_exception $e) {
$this->assertTrue(true);
}
'proficiency' => true, 'grade' => 5 ));
$usercompetency->create();
$this->fail('Invalid grade not detected in competency scale');
- } catch (\tool_lp\invalid_persistent_exception $e) {
+ } catch (\core_competency\invalid_persistent_exception $e) {
$this->assertTrue(true);
}
'proficiency' => true, 'grade' => 1 ));
$usercompetency->create();
$this->assertTrue(true);
- } catch (\tool_lp\invalid_persistent_exception $e) {
+ } catch (\core_competency\invalid_persistent_exception $e) {
$this->fail('Valide grade rejected in framework scale');
}
'proficiency' => true, 'grade' => 4 ));
$usercompetency->create();
$this->assertTrue(true);
- } catch (\tool_lp\invalid_persistent_exception $e) {
+ } catch (\core_competency\invalid_persistent_exception $e) {
$this->fail('Valide grade rejected in competency scale');
}
}
// Can associate hidden template to cohort.
$templatecohort = api::create_template_cohort($template->get_id(), $cohort->id);
- $this->assertInstanceOf('\tool_lp\template_cohort', $templatecohort);
+ $this->assertInstanceOf('\core_competency\template_cohort', $templatecohort);
}
/**
api::complete_plan($plan);
// Check user competency plan created correctly.
- $this->assertEquals(3, \tool_lp\user_competency_plan::count_records());
- $ucp = \tool_lp\user_competency_plan::get_records();
+ $this->assertEquals(3, \core_competency\user_competency_plan::count_records());
+ $ucp = \core_competency\user_competency_plan::get_records();
$this->assertEquals($ucp[0]->get_competencyid(), $c1->get_id());
$this->assertEquals($ucp[1]->get_competencyid(), $c2->get_id());
$this->assertEquals($ucp[2]->get_competencyid(), $c3->get_id());
$c2a = $lpg->create_competency(array('competencyframeworkid' => $f1->get_id()));
$c1->set_ruleoutcome(competency::OUTCOME_EVIDENCE);
- $c1->set_ruletype('tool_lp\\competency_rule_all');
+ $c1->set_ruletype('core_competency\\competency_rule_all');
$c1->update();
$c1a->set_ruleoutcome(competency::OUTCOME_EVIDENCE);
- $c1a->set_ruletype('tool_lp\\competency_rule_all');
+ $c1a->set_ruletype('core_competency\\competency_rule_all');
$c1a->update();
$c1a1->set_ruleoutcome(competency::OUTCOME_EVIDENCE);
- $c1a1->set_ruletype('tool_lp\\competency_rule_all');
+ $c1a1->set_ruletype('core_competency\\competency_rule_all');
$c1a1->update();
$c1b->set_ruleoutcome(competency::OUTCOME_EVIDENCE);
- $c1b->set_ruletype('tool_lp\\competency_rule_all');
+ $c1b->set_ruletype('core_competency\\competency_rule_all');
$c1b->update();
$c2->set_ruleoutcome(competency::OUTCOME_EVIDENCE);
- $c2->set_ruletype('tool_lp\\competency_rule_all');
+ $c2->set_ruletype('core_competency\\competency_rule_all');
$c2->update();
return array(
$p1 = $lpg->create_plan(array('templateid' => $tpl->get_id(), 'userid' => $u1->id));
// Check pre-test.
- $this->assertTrue(tool_lp\template::record_exists($tpl->get_id()));
- $this->assertEquals(2, \tool_lp\template_competency::count_competencies($tpl->get_id()));
- $this->assertEquals(1, count(\tool_lp\plan::get_records(array('templateid' => $tpl->get_id()))));
+ $this->assertTrue(\core_competency\template::record_exists($tpl->get_id()));
+ $this->assertEquals(2, \core_competency\template_competency::count_competencies($tpl->get_id()));
+ $this->assertEquals(1, count(\core_competency\plan::get_records(array('templateid' => $tpl->get_id()))));
$result = api::delete_template($tpl->get_id(), true);
$this->assertTrue($result);
// Check that the template does not exist anymore.
- $this->assertFalse(tool_lp\template::record_exists($tpl->get_id()));
+ $this->assertFalse(\core_competency\template::record_exists($tpl->get_id()));
// Check that associated competencies are also deleted.
- $this->assertEquals(0, \tool_lp\template_competency::count_competencies($tpl->get_id()));
+ $this->assertEquals(0, \core_competency\template_competency::count_competencies($tpl->get_id()));
// Check that associated plan are also deleted.
- $this->assertEquals(0, count(\tool_lp\plan::get_records(array('templateid' => $tpl->get_id()))));
+ $this->assertEquals(0, count(\core_competency\plan::get_records(array('templateid' => $tpl->get_id()))));
}
public function test_delete_template_unlink_plans() {
$p1 = $lpg->create_plan(array('templateid' => $tpl->get_id(), 'userid' => $u1->id));
// Check pre-test.
- $this->assertTrue(tool_lp\template::record_exists($tpl->get_id()));
- $this->assertEquals(2, \tool_lp\template_competency::count_competencies($tpl->get_id()));
- $this->assertEquals(1, count(\tool_lp\plan::get_records(array('templateid' => $tpl->get_id()))));
+ $this->assertTrue(\core_competency\template::record_exists($tpl->get_id()));
+ $this->assertEquals(2, \core_competency\template_competency::count_competencies($tpl->get_id()));
+ $this->assertEquals(1, count(\core_competency\plan::get_records(array('templateid' => $tpl->get_id()))));
$result = api::delete_template($tpl->get_id(), false);
$this->assertTrue($result);
// Check that the template does not exist anymore.
- $this->assertFalse(tool_lp\template::record_exists($tpl->get_id()));
+ $this->assertFalse(\core_competency\template::record_exists($tpl->get_id()));
// Check that associated competencies are also deleted.
- $this->assertEquals(0, \tool_lp\template_competency::count_competencies($tpl->get_id()));
+ $this->assertEquals(0, \core_competency\template_competency::count_competencies($tpl->get_id()));
// Check that associated plan still exist but unlink from template.
- $plans = \tool_lp\plan::get_records(array('id' => $p1->get_id()));
+ $plans = \core_competency\plan::get_records(array('id' => $p1->get_id()));
$this->assertEquals(1, count($plans));
$this->assertEquals($plans[0]->get_origtemplateid(), $tpl->get_id());
$this->assertNull($plans[0]->get_templateid());
// Set rules on parent competency.
$c1->set_ruleoutcome(competency::OUTCOME_EVIDENCE);
- $c1->set_ruletype('tool_lp\\competency_rule_all');
+ $c1->set_ruletype('core_competency\\competency_rule_all');
$c1->update();
// If we delete competeny, the related competencies relations and evidences should be deleted.
$this->assertFalse(competency::record_exists($c12b->get_id()));
// Check if evidence are also deleted.
- $this->assertEquals(0, tool_lp\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
+ $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
// Check if related conpetency relation is deleted.
$this->assertEquals(0, count(api::list_related_competencies($c2->get_id())));
$this->assertFalse(competency::record_exists($c12b->get_id()));
// Check if evidence are also deleted.
- $this->assertEquals(0, tool_lp\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
+ $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
// Check if related conpetency relation is deleted.
- $this->assertEquals(0, count(\tool_lp\related_competency::get_multiple_relations(array($c2id))));
+ $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
// Delete a simple framework.
$f2 = $lpg->create_framework();
$this->assertFalse(competency::record_exists($c11b->get_id()));
$this->assertFalse(competency::record_exists($c12b->get_id()));
// Check if evidence are also deleted.
- $this->assertEquals(0, tool_lp\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
+ $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
// Check if related conpetency relation is deleted.
- $this->assertEquals(0, count(\tool_lp\related_competency::get_multiple_relations(array($c2id))));
+ $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
}
public function test_delete_framework_competency_used_in_usercompetency() {
$this->assertFalse(competency::record_exists($c11b->get_id()));
$this->assertFalse(competency::record_exists($c12b->get_id()));
// Check if evidence are also deleted.
- $this->assertEquals(0, tool_lp\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
+ $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
// Check if related conpetency relation is deleted.
- $this->assertEquals(0, count(\tool_lp\related_competency::get_multiple_relations(array($c2id))));
+ $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
}
public function test_delete_framework_competency_used_in_usercompetencyplan() {
$this->assertFalse(competency::record_exists($c11b->get_id()));
$this->assertFalse(competency::record_exists($c12b->get_id()));
// Check if evidence are also deleted.
- $this->assertEquals(0, tool_lp\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
+ $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
// Check if related conpetency relation is deleted.
- $this->assertEquals(0, count(\tool_lp\related_competency::get_multiple_relations(array($c2id))));
+ $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
}
public function test_delete_framework_competency_used_in_template() {
$this->assertFalse(competency::record_exists($c11b->get_id()));
$this->assertFalse(competency::record_exists($c12b->get_id()));
// Check if evidence are also deleted.
- $this->assertEquals(0, tool_lp\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
+ $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
// Check if related conpetency relation is deleted.
- $this->assertEquals(0, count(\tool_lp\related_competency::get_multiple_relations(array($c2id))));
+ $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
}
public function test_delete_framework_competency_used_in_course() {
$this->assertFalse(competency::record_exists($c11b->get_id()));
$this->assertFalse(competency::record_exists($c12b->get_id()));
// Check if evidence are also deleted.
- $this->assertEquals(0, tool_lp\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
+ $this->assertEquals(0, \core_competency\user_evidence_competency::count_records(array('competencyid' => $c11b->get_id())));
// Check if related conpetency relation is deleted.
- $this->assertEquals(0, count(\tool_lp\related_competency::get_multiple_relations(array($c2id))));
+ $this->assertEquals(0, count(\core_competency\related_competency::get_multiple_relations(array($c2id))));
}
public function test_grade_competency_in_course_permissions() {
$this->assertEquals(4, count($result));
foreach ($result as $one) {
- $this->assertInstanceOf('\tool_lp\plan', $one);
+ $this->assertInstanceOf('\core_competency\plan', $one);
}
// This lists the plans based on this template, optionally filtered by status.
$result = api::list_plans_for_template($tpl->get_id(), plan::STATUS_COMPLETE);
$this->assertEquals(3, count($result));
foreach ($result as $one) {
- $this->assertInstanceOf('\tool_lp\plan', $one);
+ $this->assertInstanceOf('\core_competency\plan', $one);
$this->assertEquals(plan::STATUS_COMPLETE, $one->get_status());
}
$this->assertEquals(2, count($result));
$leastarray = array($comp4->get_id(), $comp6->get_id());
foreach ($result as $one) {
- $this->assertInstanceOf('\tool_lp\competency', $one);
+ $this->assertInstanceOf('\core_competency\competency', $one);
$this->assertContains($one->get_id(), $leastarray);
}
}
use Behat\Gherkin\Node\TableNode as TableNode;
use Behat\Behat\Exception\PendingException as PendingException;
-use tool_lp\competency_framework;
-use tool_lp\plan;
+use core_competency\competency;
+use core_competency\competency_framework;
+use core_competency\plan;
+use core_competency\user_evidence;
/**
* Step definition to generate database fixtures for learning plan system.
global $DB;
if (isset($data['plan'])) {
- $plan = $DB->get_record('tool_lp_plan', array('name' => $data['plan']), '*', MUST_EXIST);
+ $plan = $DB->get_record(plan::TABLE, array('name' => $data['plan']), '*', MUST_EXIST);
$data['planid'] = $plan->id;
}
unset($data['plan']);
if (isset($data['competency'])) {
- $competency = $DB->get_record('tool_lp_competency', array('shortname' => $data['competency']), '*', MUST_EXIST);
+ $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
$data['competencyid'] = $competency->id;
}
unset($data['competency']);
global $DB;
if (isset($data['userevidence'])) {
- $userevidence = $DB->get_record('tool_lp_user_evidence', array('name' => $data['userevidence']), '*', MUST_EXIST);
+ $userevidence = $DB->get_record(user_evidence::TABLE, array('name' => $data['userevidence']), '*', MUST_EXIST);
$data['userevidenceid'] = $userevidence->id;
}
unset($data['userevidence']);
if (isset($data['competency'])) {
- $competency = $DB->get_record('tool_lp_competency', array('shortname' => $data['competency']), '*', MUST_EXIST);
+ $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
$data['competencyid'] = $competency->id;
}
unset($data['competency']);
unset($data['user']);
if (isset($data['competency'])) {
- $competency = $DB->get_record('tool_lp_competency', array('shortname' => $data['competency']), '*', MUST_EXIST);
+ $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
$data['competencyid'] = $competency->id;
}
unset($data['competency']);
unset($data['user']);
if (isset($data['competency'])) {
- $competency = $DB->get_record('tool_lp_competency', array('shortname' => $data['competency']), '*', MUST_EXIST);
+ $competency = $DB->get_record(competency::TABLE, array('shortname' => $data['competency']), '*', MUST_EXIST);
$data['competencyid'] = $competency->id;
}
unset($data['competency']);
if (isset($data['plan'])) {
- $plan = $DB->get_record('tool_lp_plan', array('name' => $data['plan']), '*', MUST_EXIST);
+ $plan = $DB->get_record(plan::TABLE, array('name' => $data['plan']), '*', MUST_EXIST);
$data['planid'] = $plan->id;
}
unset($data['plan']);
global $CFG;
require_once($CFG->dirroot . '/webservice/tests/helpers.php');
-use tool_lp\user_competency;
-use tool_lp\competency;
-use tool_lp\competency_rule_all;
-use tool_lp\competency_rule_points;
+use core_competency\user_competency;
+use core_competency\competency;
+use core_competency\competency_rule_all;
+use core_competency\competency_rule_points;
/**
* Competency rule testcase.
// Set up the framework and competencies.
$framework = $lpg->create_framework();
$c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(),
- 'ruletype' => 'tool_lp\competency_rule_all'));
+ 'ruletype' => 'core_competency\competency_rule_all'));
$c11 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c1->get_id(),
- 'ruletype' => 'tool_lp\competency_rule_all'));
+ 'ruletype' => 'core_competency\competency_rule_all'));
$c111 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c11->get_id(),
- 'ruletype' => 'tool_lp\competency_rule_all'));
+ 'ruletype' => 'core_competency\competency_rule_all'));
$c112 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c11->get_id(),
- 'ruletype' => 'tool_lp\competency_rule_all'));
+ 'ruletype' => 'core_competency\competency_rule_all'));
$c12 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c1->get_id(),
- 'ruletype' => 'tool_lp\competency_rule_all'));
+ 'ruletype' => 'core_competency\competency_rule_all'));
$c13 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c1->get_id(),
- 'ruletype' => 'tool_lp\competency_rule_all'));
+ 'ruletype' => 'core_competency\competency_rule_all'));
$c131 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c13->get_id(),
- 'ruletype' => 'tool_lp\competency_rule_all'));
+ 'ruletype' => 'core_competency\competency_rule_all'));
// Create some user competency records.
$uc1 = $lpg->create_user_competency(array('competencyid' => $c1->get_id(), 'userid' => $u1->id));
$c4 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
$cx = $lpg->create_competency(array('competencyframeworkid' => $framework2->get_id()));
- $c1->set_ruletype('tool_lp\competency_rule_points');
+ $c1->set_ruletype('core_competency\competency_rule_points');
$rule = new competency_rule_points($c1);
// Invalid config.
// Set up the framework and competencies.
$framework = $lpg->create_framework();
$c1 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
- $c1->set_ruletype('tool_lp\competency_rule_points');
+ $c1->set_ruletype('core_competency\competency_rule_points');
$comprule = new competency_rule_points($c1);
$c11 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c1->get_id()));
$c12 = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id(), 'parentid' => $c1->get_id()));
defined('MOODLE_INTERNAL') || die();
global $CFG;
-use tool_lp\course_competency;
+use core_competency\course_competency;
use tool_lp\api;
-use tool_lp\course_competency_settings;
+use core_competency\course_competency_settings;
/**
* This test ensures that the course competency settings are applied and work correctly.
'userid' => $u1->id,
'competencyid' => $comp1->get_id(),
);
- $usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
- $usercomp = \tool_lp\user_competency::get_record($filterparams);
+ $usercompcourse = \core_competency\user_competency_course::get_record($filterparams);
+ $usercomp = \core_competency\user_competency::get_record($filterparams);
// No grade in plan - only a grade in the course.
$this->assertEmpty($usercomp->get_grade());
'userid' => $u1->id,
'competencyid' => $comp1->get_id(),
);
- $usercompcourse = \tool_lp\user_competency_course::get_record($filterparams);
- $usercomp = \tool_lp\user_competency::get_record($filterparams);
+ $usercompcourse = \core_competency\user_competency_course::get_record($filterparams);
+ $usercomp = \core_competency\user_competency::get_record($filterparams);
// Updated grade in plan - updated grade in the course.
$this->assertEquals(2, $usercomp->get_grade());
defined('MOODLE_INTERNAL') || die();
global $CFG;
-use tool_lp\course_competency;
+use core_competency\course_competency;
/**
* Course competency persistent testcase.
$sink = $this->redirectEvents();
api::create_plans_from_template_cohort($t1->get_id(), $c1->id);
// Get our event event.
- $plans = tool_lp\plan::get_records(array('templateid' => $t1->get_id()), 'id');
+ $plans = core_competency\plan::get_records(array('templateid' => $t1->get_id()), 'id');
$events = $sink->get_events();
$this->assertCount(2, $events);
$this->assertCount(2, $plans);
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$user1 = $dg->create_user();
- $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \tool_lp\plan::STATUS_ACTIVE));
+ $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_ACTIVE));
$planid = $plan->get_id();
$contextid = $plan->get_context()->id;
// Trigger and capture the event.
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$user1 = $dg->create_user();
- $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \tool_lp\plan::STATUS_COMPLETE));
+ $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_COMPLETE));
$planid = $plan->get_id();
$contextid = $plan->get_context()->id;
// Trigger and capture the event.
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$user1 = $dg->create_user();
- $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \tool_lp\plan::STATUS_ACTIVE));
+ $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_ACTIVE));
$planid = $plan->get_id();
$contextid = $plan->get_context()->id;
// Trigger and capture the event.
$template = $lpg->create_template();
$plan = $lpg->create_plan(array(
'userid' => $user1->id,
- 'status' => \tool_lp\plan::STATUS_ACTIVE,
+ 'status' => \core_competency\plan::STATUS_ACTIVE,
'templateid' => $template->get_id()
));
$planid = $plan->get_id();
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$user1 = $dg->create_user();
- $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \tool_lp\plan::STATUS_WAITING_FOR_REVIEW));
+ $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_WAITING_FOR_REVIEW));
$planid = $plan->get_id();
$contextid = $plan->get_context()->id;
// Trigger and capture the event.
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$user1 = $dg->create_user();
- $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \tool_lp\plan::STATUS_WAITING_FOR_REVIEW));
+ $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_WAITING_FOR_REVIEW));
$planid = $plan->get_id();
$contextid = $plan->get_context()->id;
// Trigger and capture the event.
$dg = $this->getDataGenerator();
$lpg = $this->getDataGenerator()->get_plugin_generator('tool_lp');
$user1 = $dg->create_user();
- $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \tool_lp\plan::STATUS_IN_REVIEW));
+ $plan = $lpg->create_plan(array('userid' => $user1->id, 'status' => \core_competency\plan::STATUS_IN_REVIEW));
$planid = $plan->get_id();
$contextid = $plan->get_context()->id;
// Trigger and capture the event.
// Add evidence.
$recommend = false;
- $evidence = api::add_evidence($student->id, $comp, $syscontext, \tool_lp\evidence::ACTION_OVERRIDE,
+ $evidence = api::add_evidence($student->id, $comp, $syscontext, \core_competency\evidence::ACTION_OVERRIDE,
'commentincontext', 'core', null, $recommend, null, 1);
// Get event.
$comp = $lpg->create_competency(['competencyframeworkid' => $framework->get_id()]);
// Create a different user competency.
- $otheruc = \tool_lp\user_competency::create_relation($student2->id, $comp->get_id());
+ $otheruc = \core_competency\user_competency::create_relation($student2->id, $comp->get_id());
$otheruc->create();
// Add evidence.
$recommend = false;
- $evidence = api::add_evidence($student->id, $comp, $syscontext, \tool_lp\evidence::ACTION_OVERRIDE,
+ $evidence = api::add_evidence($student->id, $comp, $syscontext, \core_competency\evidence::ACTION_OVERRIDE,
'commentincontext', 'core', null, $recommend, null, 1);
// We expect this to fail and throw a coding exception.
/**
* Test creation of evidence_created event with missing data.
*
- * These data are validated by \tool_lp\evidence_created::validate_data().
+ * These data are validated by \core_competency\evidence_created::validate_data().
*/
public function test_evidence_created_with_missing_data() {
$eventdata = [
use tool_lp\api;
use tool_lp\external;
-use tool_lp\plan;
-use tool_lp\related_competency;
-use tool_lp\user_competency;
-use tool_lp\user_competency_plan;
-use tool_lp\plan_competency;
-use tool_lp\template;
-use tool_lp\template_competency;
-use tool_lp\course_competency_settings;
+use core_competency\invalid_persistent_exception;
+use core_competency\plan;
+use core_competency\related_competency;
+use core_competency\user_competency;
+use core_competency\user_competency_plan;
+use core_competency\plan_competency;
+use core_competency\template;
+use core_competency\template_competency;
+use core_competency\course_competency_settings;
/**
* External learning plans webservice API tests.
// Changing the framework where the scale is not used.
$result = $this->update_competency_framework($f1->get_id(), 3, true);
- $f1 = new \tool_lp\competency_framework($f1->get_id());
+ $f1 = new \core_competency\competency_framework($f1->get_id());
$this->assertEquals(3, $f1->get_scaleid());
// Changing the framework where the scale is used.
try {
$result = $this->update_competency_framework($f2->get_id(), 4, true);
$this->fail('The scale cannot be changed once used.');
- } catch (\tool_lp\invalid_persistent_exception $e) {
+ } catch (\core_competency\invalid_persistent_exception $e) {
$this->assertRegexp('/scaleid/', $e->getMessage());
}
}
try {
external::add_related_competency($competency1->get_id(), $competency4->get_id());
$this->fail('Exception expected due mis-use of shared competencies');
- } catch (tool_lp\invalid_persistent_exception $e) {
+ } catch (invalid_persistent_exception $e) {
// Yay!
}
$this->setUser($usermanage);
$plan = array (
'userid' => $usermanage->id,
- 'status' => \tool_lp\plan::STATUS_ACTIVE
+ 'status' => \core_competency\plan::STATUS_ACTIVE
);
$pl1 = $lpg->create_plan($plan);
$framework = $lpg->create_framework();
$template = $lpg->create_template();
$plan = array (
'userid' => $usermanage->id,
- 'status' => \tool_lp\plan::STATUS_ACTIVE,
+ 'status' => \core_competency\plan::STATUS_ACTIVE,
'templateid' => $template->get_id()
);
$pl2 = $lpg->create_plan($plan);
$this->setUser($usermanage);
$plan = array (
'userid' => $usermanage->id,
- 'status' => \tool_lp\plan::STATUS_ACTIVE
+ 'status' => \core_competency\plan::STATUS_ACTIVE
);
$pl1 = $lpg->create_plan($plan);
$framework = $lpg->create_framework();
$this->setUser($usermanage);
$plan = array (
'userid' => $usermanage->id,
- 'status' => \tool_lp\plan::STATUS_ACTIVE
+ 'status' => \core_competency\plan::STATUS_ACTIVE
);
$pl1 = $lpg->create_plan($plan);
$framework = $lpg->create_framework();
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-use tool_lp\competency;
-use tool_lp\competency_framework;
-use tool_lp\course_competency;
-use tool_lp\course_module_competency;
+use core_competency\competency;
+use core_competency\competency_framework;
+use core_competency\course_competency;
+use core_competency\course_module_competency;
use tool_lp\external;
-use tool_lp\plan;
-use tool_lp\related_competency;
-use tool_lp\template;
-use tool_lp\template_cohort;
-use tool_lp\template_competency;
-use tool_lp\user_competency;
-use tool_lp\user_competency_course;
-use tool_lp\user_competency_plan;
-use tool_lp\plan_competency;
-use tool_lp\evidence;
-use tool_lp\user_evidence;
-use tool_lp\user_evidence_competency;
+use core_competency\plan;
+use core_competency\related_competency;
+use core_competency\template;
+use core_competency\template_cohort;
+use core_competency\template_competency;
+use core_competency\user_competency;
+use core_competency\user_competency_course;
+use core_competency\user_competency_plan;
+use core_competency\plan_competency;
+use core_competency\evidence;
+use core_competency\user_evidence;
+use core_competency\user_evidence_competency;
defined('MOODLE_INTERNAL') || die();
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-use tool_lp\competency;
-use tool_lp\competency_framework;
-use tool_lp\course_competency;
-use tool_lp\course_module_competency;
-use tool_lp\plan;
-use tool_lp\related_competency;
-use tool_lp\template;
-use tool_lp\template_cohort;
-use tool_lp\template_competency;
-use tool_lp\user_competency;
-use tool_lp\user_competency_plan;
-use tool_lp\plan_competency;
-use tool_lp\evidence;
+use core_competency\competency;
+use core_competency\competency_framework;
+use core_competency\course_competency;
+use core_competency\course_module_competency;
+use core_competency\plan;
+use core_competency\related_competency;
+use core_competency\template;
+use core_competency\template_cohort;
+use core_competency\template_competency;
+use core_competency\user_competency;
+use core_competency\user_competency_plan;
+use core_competency\plan_competency;
+use core_competency\evidence;
defined('MOODLE_INTERNAL') || die();
$framework = $lpg->create_framework();
$framework = $lpg->create_framework();
$this->assertEquals(2, competency_framework::count_records());
- $this->assertInstanceOf('\tool_lp\competency_framework', $framework);
+ $this->assertInstanceOf('\core_competency\competency_framework', $framework);
}
public function test_create_competency() {
$competency = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
$competency = $lpg->create_competency(array('competencyframeworkid' => $framework->get_id()));
$this->assertEquals(2, competency::count_records());
- $this->assertInstanceOf('\tool_lp\competency', $competency);
+ $this->assertInstanceOf('\core_competency\competency', $competency);
}
public function test_create_related_competency() {
$rc = $lpg->create_related_competency(array('competencyid' => $c1->get_id(), 'relatedcompetencyid' => $c2->get_id()));
$rc = $lpg->create_related_competency(array('competencyid' => $c2->get_id(), 'relatedcompetencyid' => $c3->get_id()));
$this->assertEquals(2, related_competency::count_records());
- $this->assertInstanceOf('\tool_lp\related_competency', $rc);
+ $this->assertInstanceOf('\core_competency\related_competency', $rc);
}
public function test_create_plan() {
$this->assertEquals(0, plan::count_records());
$plan = $lpg->create_plan(array('userid' => $user->id));
$this->assertEquals(1, plan::count_records());
- $this->assertInstanceOf('\tool_lp\plan', $plan);
+ $this->assertInstanceOf('\core_competency\plan', $plan);
}
public function test_create_user_competency() {
$rc = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c1->get_id()));
$rc = $lpg->create_user_competency(array('userid' => $user->id, 'competencyid' => $c2->get_id()));
$this->assertEquals(2, user_competency::count_records());
- $this->assertInstanceOf('\tool_lp\user_competency', $rc);
+ $this->assertInstanceOf('\core_competency\user_competency', $rc);
}
public function test_create_user_competency_plan() {
'planid' => $plan->get_id()
));
$this->assertEquals(2, user_competency_plan::count_records());
- $this->assertInstanceOf('\tool_lp\user_competency_plan', $ucp);
+ $this->assertInstanceOf('\core_competency\user_competency_plan', $ucp);
}
public function test_create_template() {
$template = $lpg->create_template();
$template = $lpg->create_template();
$this->assertEquals(2, template::count_records());
- $this->assertInstanceOf('\tool_lp\template', $template);
+ $this->assertInstanceOf('\core_competency\template', $template);
}
public function test_create_template_competency() {
$relation = $lpg->create_template_competency(array('competencyid' => $c1->get_id(), 'templateid' => $template->get_id()));
$relation = $lpg->create_template_competency(array('competencyid' => $c2->get_id(), 'templateid' => $template->get_id()));
$this->assertEquals(2, template_competency::count_records());
- $this->assertInstanceOf('\tool_lp\template_competency', $relation);
+ $this->assertInstanceOf('\core_competency\template_competency', $relation);
}
public function test_create_plan_competency() {
$pc2 = $lpg->create_plan_competency(array('planid' => $plan->get_id(), 'competencyid' => $c2->get_id()));
$this->assertEquals(2, plan_competency::count_records());
- $this->assertInstanceOf('\tool_lp\plan_competency', $pc1);
- $this->assertInstanceOf('\tool_lp\plan_competency', $pc2);
+ $this->assertInstanceOf('\core_competency\plan_competency', $pc1);
+ $this->assertInstanceOf('\core_competency\plan_competency', $pc2);
$this->assertEquals($plan->get_id(), $pc1->get_planid());
}
$this->assertEquals(1, template_cohort::count_records());
$tc = $lpg->create_template_cohort(array('templateid' => $t1->get_id(), 'cohortid' => $c2->id));
$this->assertEquals(2, template_cohort::count_records());
- $this->assertInstanceOf('\tool_lp\template_cohort', $tc);
+ $this->assertInstanceOf('\core_competency\template_cohort', $tc);
}
public function test_create_evidence() {
$e = $lpg->create_evidence(array('usercompetencyid' => $rc1->get_id()));
$e = $lpg->create_evidence(array('usercompetencyid' => $rc2->get_id()));
$this->assertEquals(2, evidence::count_records());
- $this->assertInstanceOf('\tool_lp\evidence', $e);
+ $this->assertInstanceOf('\core_competency\evidence', $e);
}
public function test_create_course_competency() {
$this->assertEquals(0, course_competency::count_records(array('courseid' => $course2->id)));
$rc = $lpg->create_course_competency(array('competencyid' => $c3->get_id(), 'courseid' => $course2->id));
$this->assertEquals(1, course_competency::count_records(array('courseid' => $course2->id)));
- $this->assertInstanceOf('\tool_lp\course_competency', $rc);
+ $this->assertInstanceOf('\core_competency\course_competency', $rc);
}
public function test_create_course_module_competency() {
$this->assertEquals(0, course_module_competency::count_records(array('cmid' => $cm2->cmid)));
$rc = $lpg->create_course_module_competency(array('competencyid' => $c3->get_id(), 'cmid' => $cm2->cmid));
$this->assertEquals(1, course_module_competency::count_records(array('cmid' => $cm2->cmid)));
- $this->assertInstanceOf('\tool_lp\course_module_competency', $rc);
+ $this->assertInstanceOf('\core_competency\course_module_competency', $rc);
}
}
defined('MOODLE_INTERNAL') || die();
-use tool_lp\plan;
-use tool_lp\user_competency;
+use core_competency\plan;
+use core_competency\user_competency;
global $CFG;
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-class tool_lp_testable_persistent extends \tool_lp\persistent {
+class tool_lp_testable_persistent extends \core_competency\persistent {
const TABLE = 'competency';
global $CFG;
use tool_lp\api;
-use tool_lp\plan;
+use core_competency\plan;
/**
* Plan persistent testcase.
defined('MOODLE_INTERNAL') || die();
global $CFG;
-use tool_lp\plan;
+use core_competency\plan;
/**
* Plan persistent testcase.
accesslib_clear_all_caches_for_unit_testing();
$this->setUser($u1);
- $this->assertTrue(\tool_lp\plan::can_manage_user($u1->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user($u2->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user($u3->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user($u1->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user($u2->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user($u3->id));
$this->setUser($u2);
- $this->assertFalse(\tool_lp\plan::can_manage_user($u1->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user($u2->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user($u3->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user($u1->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user($u2->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user($u3->id));
$this->setUser($u3);
- $this->assertFalse(\tool_lp\plan::can_manage_user($u1->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user($u2->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user($u3->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user($u1->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user($u2->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user($u3->id));
}
public function test_can_manage_user_draft() {
accesslib_clear_all_caches_for_unit_testing();
$this->setUser($u1);
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u1->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u4->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u1->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u4->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u5->id));
$this->setUser($u2);
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u1->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u4->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u1->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u4->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u5->id));
$this->setUser($u3);
- $this->assertTrue(\tool_lp\plan::can_manage_user_draft($u1->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user_draft($u2->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user_draft($u3->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user_draft($u4->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user_draft($u5->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user_draft($u1->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user_draft($u2->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user_draft($u3->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user_draft($u4->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user_draft($u5->id));
$this->setUser($u4);
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u1->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u4->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u1->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u4->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u5->id));
$this->setUser($u5);
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u1->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_manage_user_draft($u4->id));
- $this->assertTrue(\tool_lp\plan::can_manage_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u1->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_manage_user_draft($u4->id));
+ $this->assertTrue(\core_competency\plan::can_manage_user_draft($u5->id));
}
public function test_can_read_user() {
accesslib_clear_all_caches_for_unit_testing();
$this->setUser($u1);
- $this->assertTrue(\tool_lp\plan::can_read_user($u1->id));
- $this->assertTrue(\tool_lp\plan::can_read_user($u2->id));
- $this->assertTrue(\tool_lp\plan::can_read_user($u3->id));
+ $this->assertTrue(\core_competency\plan::can_read_user($u1->id));
+ $this->assertTrue(\core_competency\plan::can_read_user($u2->id));
+ $this->assertTrue(\core_competency\plan::can_read_user($u3->id));
$this->setUser($u2);
- $this->assertFalse(\tool_lp\plan::can_read_user($u1->id));
- $this->assertTrue(\tool_lp\plan::can_read_user($u2->id));
- $this->assertFalse(\tool_lp\plan::can_read_user($u3->id));
+ $this->assertFalse(\core_competency\plan::can_read_user($u1->id));
+ $this->assertTrue(\core_competency\plan::can_read_user($u2->id));
+ $this->assertFalse(\core_competency\plan::can_read_user($u3->id));
$this->setUser($u3);
- $this->assertFalse(\tool_lp\plan::can_read_user($u1->id));
- $this->assertTrue(\tool_lp\plan::can_read_user($u2->id));
- $this->assertTrue(\tool_lp\plan::can_read_user($u3->id)); // Due to the default capability.
+ $this->assertFalse(\core_competency\plan::can_read_user($u1->id));
+ $this->assertTrue(\core_competency\plan::can_read_user($u2->id));
+ $this->assertTrue(\core_competency\plan::can_read_user($u3->id)); // Due to the default capability.
}
public function test_can_read_user_draft() {
accesslib_clear_all_caches_for_unit_testing();
$this->setUser($u1);
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u1->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u4->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u1->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u4->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u5->id));
$this->setUser($u2);
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u1->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u4->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u1->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u4->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u5->id));
$this->setUser($u3);
- $this->assertTrue(\tool_lp\plan::can_read_user_draft($u1->id));
- $this->assertTrue(\tool_lp\plan::can_read_user_draft($u2->id));
- $this->assertTrue(\tool_lp\plan::can_read_user_draft($u3->id));
- $this->assertTrue(\tool_lp\plan::can_read_user_draft($u4->id));
- $this->assertTrue(\tool_lp\plan::can_read_user_draft($u5->id));
+ $this->assertTrue(\core_competency\plan::can_read_user_draft($u1->id));
+ $this->assertTrue(\core_competency\plan::can_read_user_draft($u2->id));
+ $this->assertTrue(\core_competency\plan::can_read_user_draft($u3->id));
+ $this->assertTrue(\core_competency\plan::can_read_user_draft($u4->id));
+ $this->assertTrue(\core_competency\plan::can_read_user_draft($u5->id));
$this->setUser($u4);
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u1->id));
- $this->assertTrue(\tool_lp\plan::can_read_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u4->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u1->id));
+ $this->assertTrue(\core_competency\plan::can_read_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u4->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u5->id));
$this->setUser($u5);
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u1->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u2->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u3->id));
- $this->assertFalse(\tool_lp\plan::can_read_user_draft($u4->id));
- $this->assertTrue(\tool_lp\plan::can_read_user_draft($u5->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u1->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u2->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u3->id));
+ $this->assertFalse(\core_competency\plan::can_read_user_draft($u4->id));
+ $this->assertTrue(\core_competency\plan::can_read_user_draft($u5->id));
}
public function test_validate_duedate() {
$user = $dg->create_user();
$record = array('userid' => $user->id,
- 'status' => tool_lp\plan::STATUS_DRAFT,
+ 'status' => core_competency\plan::STATUS_DRAFT,
'duedate' => time() - 8000);
// Ignore duedate validation on create/update draft plan.
$plan = $lpg->create_plan($record);
- $this->assertInstanceOf('\tool_lp\plan', $plan);
+ $this->assertInstanceOf('\core_competency\plan', $plan);
// Passing from draft to active.
- $plan->set_status(tool_lp\plan::STATUS_ACTIVE);
+ $plan->set_status(core_competency\plan::STATUS_ACTIVE);
// Draft to active with duedate in the past.
$expected = array(
$this->assertEquals($expected, $plan->validate());
// Draft to active: past date => future date (pass).
- $plan->set_duedate(time() + tool_lp\plan::DUEDATE_THRESHOLD + 10);
+ $plan->set_duedate(time() + core_competency\plan::DUEDATE_THRESHOLD + 10);
$this->assertEquals(true, $plan->validate());
// Draft to active: past date => unset date (pass).
$this->assertEquals($expected, $plan->validate());
// Active to active: unset date => future date (pass).
- $plan->set_duedate(time() + tool_lp\plan::DUEDATE_THRESHOLD + 10);
+ $plan->set_duedate(time() + core_competency\plan::DUEDATE_THRESHOLD + 10);
$this->assertEquals(true, $plan->validate());
// Updating active plan with future date.
$this->assertEquals($expected, $plan->validate());
// Active to active: future date => future date (pass).
- $plan->set_duedate(time() + tool_lp\plan::DUEDATE_THRESHOLD + 10);
+ $plan->set_duedate(time() + core_competency\plan::DUEDATE_THRESHOLD + 10);
$this->assertEquals(true, $plan->validate());
// Completing plan: with due date in the past.
$record = $plan->to_record();
- $record->status = tool_lp\plan::STATUS_ACTIVE;
+ $record->status = core_competency\plan::STATUS_ACTIVE;
$record->duedate = time() - 200;
- $DB->update_record(tool_lp\plan::TABLE, $record);
+ $DB->update_record(core_competency\plan::TABLE, $record);
$success = tool_lp\api::complete_plan($plan->get_id());
$this->assertTrue($success);
// Completing plan: with due date too soon (pass).
$record = $plan->to_record();
- $record->status = tool_lp\plan::STATUS_ACTIVE;
+ $record->status = core_competency\plan::STATUS_ACTIVE;
$record->duedate = time() + 200;
- $DB->update_record(tool_lp\plan::TABLE, $record);
+ $DB->update_record(core_competency\plan::TABLE, $record);
$success = tool_lp\api::complete_plan($plan->get_id());
$this->assertTrue($success);
// Completing plan: with due date in the future (pass).
$record = $plan->to_record();
- $record->status = tool_lp\plan::STATUS_ACTIVE;
- $record->duedate = time() + tool_lp\plan::DUEDATE_THRESHOLD + 10;
- $DB->update_record(tool_lp\plan::TABLE, $record);
+ $record->status = core_competency\plan::STATUS_ACTIVE;
+ $record->duedate = time() + core_competency\plan::DUEDATE_THRESHOLD + 10;
+ $DB->update_record(core_competency\plan::TABLE, $record);
$success = tool_lp\api::complete_plan($plan->get_id());
$this->assertTrue($success);
// Completing plan: with due date unset (pass).
$record = $plan->to_record();
- $record->status = tool_lp\plan::STATUS_ACTIVE;
+ $record->status = core_competency\plan::STATUS_ACTIVE;
$record->duedate = 0;
- $DB->update_record(tool_lp\plan::TABLE, $record);
+ $DB->update_record(core_competency\plan::TABLE, $record);
$success = tool_lp\api::complete_plan($plan->get_id());
$this->assertTrue($success);
// Reopening plan: with due date in the past => duedate unset.
$record = $plan->to_record();
- $record->status = tool_lp\plan::STATUS_COMPLETE;
+ $record->status = core_competency\plan::STATUS_COMPLETE;
$record->duedate = time() - 200;
- $DB->update_record(tool_lp\plan::TABLE, $record);
+ $DB->update_record(core_competency\plan::TABLE, $record);
$success = tool_lp\api::reopen_plan($plan->get_id());
$this->assertTrue($success);
// Reopening plan: with due date too soon => duedate unset.
$record = $plan->to_record();
- $record->status = tool_lp\plan::STATUS_COMPLETE;
+ $record->status = core_competency\plan::STATUS_COMPLETE;
$record->duedate = time() + 100;
- $DB->update_record(tool_lp\plan::TABLE, $record);
+ $DB->update_record(core_competency\plan::TABLE, $record);
$success = tool_lp\api::reopen_plan($plan->get_id());
$this->assertTrue($success);
// Reopening plan: with due date in the future => duedate unchanged.
$record = $plan->to_record();
- $record->status = tool_lp\plan::STATUS_COMPLETE;
- $record->duedate = time() + tool_lp\plan::DUEDATE_THRESHOLD + 10;
- $DB->update_record(tool_lp\plan::TABLE, $record);
+ $record->status = core_competency\plan::STATUS_COMPLETE;
+ $record->duedate = time() + core_competency\plan::DUEDATE_THRESHOLD + 10;
+ $DB->update_record(core_competency\plan::TABLE, $record);
$success = tool_lp\api::reopen_plan($plan->get_id());
$this->assertTrue($success);
$plan->read();
// Check that the due date has not changed, but allow for PHP Unit latency.
- $this->assertTrue($plan->get_duedate() >= time() + tool_lp\plan::DUEDATE_THRESHOLD + 10);
- $this->assertTrue($plan->get_duedate() <= time() + tool_lp\plan::DUEDATE_THRESHOLD + 15);
+ $this->assertTrue($plan->get_duedate() >= time() + core_competency\plan::DUEDATE_THRESHOLD + 10);
+ $this->assertTrue($plan->get_duedate() <= time() + core_competency\plan::DUEDATE_THRESHOLD + 15);
}
}
defined('MOODLE_INTERNAL') || die();
use tool_lp\api;
-use tool_lp\plan;
+use core_competency\plan;
/**
* Task tests.
// Sql to simulate the execution in time.
$cmsql = "UPDATE {cohort_members} SET timeadded = :currenttime WHERE cohortid = :cohortid AND userid = :userid";
- $tplsql = "UPDATE {" . \tool_lp\template::TABLE . "} SET timemodified = :currenttime WHERE id = :templateid";
- $plansql = "UPDATE {" . \tool_lp\plan::TABLE . "} SET timemodified = :currenttime WHERE id = :planid";
+ $tplsql = "UPDATE {" . \core_competency\template::TABLE . "} SET timemodified = :currenttime WHERE id = :templateid";
+ $plansql = "UPDATE {" . \core_competency\plan::TABLE . "} SET timemodified = :currenttime WHERE id = :planid";
$currenttime = time();
// Creating plans from template cohort.
$task->execute();
- $this->assertEquals(1, \tool_lp\plan::count_records());
+ $this->assertEquals(1, \core_competency\plan::count_records());
// Now add another user, but this time the template will be expired.
cohort_add_member($cohort->id, $user2->id);
$record = $tpl->to_record();
$record->duedate = time() - 10000;
- $DB->update_record(\tool_lp\template::TABLE, $record);
+ $DB->update_record(\core_competency\template::TABLE, $record);
$tpl->read();
$task->execute();
- $this->assertEquals(1, \tool_lp\plan::count_records()); // Still only one plan.
+ $this->assertEquals(1, \core_competency\plan::count_records()); // Still only one plan.
// Pretend it wasn't expired.
$tpl->set_duedate(time() + 100);
$tpl->update();
$task->execute();
- $this->assertEquals(2, \tool_lp\plan::count_records()); // Now there is two.
+ $this->assertEquals(2, \core_competency\plan::count_records()); // Now there is two.
}
public function test_complete_plans_task() {
$user = $dg->create_user();
$up1 = $lpg->create_plan(array('userid' => $user->id,
- 'status' => \tool_lp\plan::STATUS_DRAFT));
+ 'status' => \core_competency\plan::STATUS_DRAFT));
$up2 = $lpg->create_plan(array('userid' => $user->id,
- 'status' => \tool_lp\plan::STATUS_ACTIVE));
+ 'status' => \core_competency\plan::STATUS_ACTIVE));
// Set duedate in the past.
$date = new \DateTime('yesterday');
$record1 = $up1->to_record();
$task->execute();
$plandraft = api::read_plan($up1->get_id());
- $this->assertEquals(\tool_lp\plan::STATUS_DRAFT, $plandraft->get_status());
+ $this->assertEquals(\core_competency\plan::STATUS_DRAFT, $plandraft->get_status());
// Test that active plan can be completed on running task.
$task->execute();
$planactive = api::read_plan($up2->get_id());
- $this->assertEquals(\tool_lp\plan::STATUS_COMPLETE, $planactive->get_status());
+ $this->assertEquals(\core_competency\plan::STATUS_COMPLETE, $planactive->get_status());
}
}
defined('MOODLE_INTERNAL') || die();
global $CFG;
-use tool_lp\template;
+use core_competency\template;
/**
* Template persistent testcase.
defined('MOODLE_INTERNAL') || die();
global $CFG;
-use tool_lp\user_evidence_competency;
+use core_competency\user_evidence_competency;
/**
* User evidence competency persistent testcase.
$usercontext = context_user::instance($userid);
$user = $DB->get_record('user', array('id' => $userid));
}
-$competency = new \tool_lp\competency($competencyid);
+$competency = new \core_competency\competency($competencyid);
// Does a permissions check for us.
if ($userid > 0) {
$params['planid'] = $planid;
$plan = \tool_lp\api::read_plan($planid);
$url = new moodle_url('/admin/tool/lp/user_competency_in_plan.php', $params);
-$competency = new \tool_lp\competency($competencyid);
+$competency = new \core_competency\competency($competencyid);
$framework = $competency->get_framework();
list($title, $subtitle) = \tool_lp\page_helper::setup_for_plan($userid, $url, $plan);
echo $output->render($page);
// Trigger the viewed event.
$pc = \tool_lp\api::get_plan_competency($plan, $competency->get_id());
-if ($plan->get_status() == \tool_lp\plan::STATUS_COMPLETE) {
+if ($plan->get_status() == \core_competency\plan::STATUS_COMPLETE) {
$usercompetencyplan = $pc->usercompetencyplan;
\tool_lp\api::user_competency_plan_viewed($usercompetencyplan);
} else {
}
$customdata['evidence'] = $userevidence;
-} else if (!\tool_lp\user_evidence::can_manage_user($userid)) {
+} else if (!\core_competency\user_evidence::can_manage_user($userid)) {
throw new required_capability_exception($context, 'moodle/competency:userevidencemanage', 'nopermissions', '');
}
/**
* Class for loading/storing competencies from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
public function get_rule_object() {
$rule = $this->get_ruletype();
- if (!$rule || !is_subclass_of($rule, 'tool_lp\\competency_rule')) {
+ if (!$rule || !is_subclass_of($rule, 'core_competency\\competency_rule')) {
// Double check that the rule is extending the right class to avoid bad surprises.
return null;
}
return true;
}
- if (!class_exists($value) || !is_subclass_of($value, '\tool_lp\competency_rule')) {
+ if (!class_exists($value) || !is_subclass_of($value, 'core_competency\\competency_rule')) {
return new lang_string('invaliddata', 'error');
}
/**
* Validate the scale configuration.
*
- * This logic is adapted from {@link \tool_lp\competency_framework::validate_scaleconfiguration()}.
+ * This logic is adapted from {@link \core_competency\competency_framework::validate_scaleconfiguration()}.
*
* @param string $value The scale configuration.
* @return bool|lang_string
public static function get_available_rules() {
// Fully qualified class names without leading slashes because get_class() does not add them either.
$rules = array(
- 'tool_lp\\competency_rule_all' => (object) array(),
- 'tool_lp\\competency_rule_points' => (object) array(),
+ 'core_competency\\competency_rule_all' => (object) array(),
+ 'core_competency\\competency_rule_points' => (object) array(),
);
foreach ($rules as $class => $rule) {
$rule->name = $class::get_name();
/**
* Class for loading/storing competency frameworks from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
/**
* Competency rule base.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
* Rules are attached to a competency and then tested against a user competency
* to determine whether or not it matches.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Competency rule all.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use lang_string;
*
* This rule is considered matched when all the children of a competency are completed.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Competency rule points based.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
*
* This rule matches when related competencies contribute for a required number of points.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Class for loading/storing competencies from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
/**
* Class for course_competency_settings persistence.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2016 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
use lang_string;
use context_course;
/**
* Class for loading/storing competencies from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use stdClass;
/**
* Evidence persistent file.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
/**
* Evidence persistent class.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Invalid persistent exception.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
/**
* Invalid persistent exception class.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
foreach ($errors as $key => $message) {
$debuginfo[] = "$key: $message";
}
- parent::__construct('invalidpersistent', 'tool_lp', null, null, implode(' - ', $debuginfo));
+ parent::__construct('invalidpersistent', 'core_competency', null, null, implode(' - ', $debuginfo));
}
}
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
- * Abstract class for tool_lp objects saved to the DB.
+ * Abstract class for core_competency objects saved to the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
use renderer_base;
/**
- * Abstract class for tool_lp objects saved to the DB.
+ * Abstract class for core_competency objects saved to the DB.
*
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
public static function extract_record($row, $prefix = null) {
if ($prefix === null) {
- $prefix = static::TABLE . '_';
+ $prefix = str_replace('_', '', static::TABLE) . '_';
}
$prefixlength = strlen($prefix);
* @param int $skip Limitstart.
* @param int $limit Number of rows to return.
*
- * @return \tool_lp\persistent[]
+ * @return \core_competency\persistent[]
*/
public static function get_records($filters = array(), $sort = '', $order = 'ASC', $skip = 0, $limit = 0) {
global $DB;
* Load a single record.
*
* @param array $filters Filters to apply.
- * @return false|\tool_lp\persistent
+ * @return false|\core_competency\persistent
*/
public static function get_record($filters = array()) {
global $DB;
* @param string $fields
* @param int $limitfrom
* @param int $limitnum
- * @return \tool_lp\persistent[]
+ * @return \core_competency\persistent[]
*/
public static function get_records_select($select, $params = null, $sort = '', $fields = '*', $limitfrom = 0, $limitnum = 0) {
global $DB;
$fields = array();
if ($prefix === null) {
- $prefix = static::TABLE . '_';
+ $prefix = str_replace('_', '', static::TABLE) . '_';
}
// Get the properties and move ID to the top.
/**
* Class for plans persistence.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 David Monllao
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use comment;
/**
* Class for plan_competency persistence.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Issam Taboubi <issam.taboubi@umontreal.ca>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use lang_string;
/**
* Class for loading/storing related competencies from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 David Monllao
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use lang_string;
/**
* Class for loading/storing related_competencies from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 David Monllao
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
/**
* Class for loading/storing learning plan templates from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use context;
/**
* Template cohort persistent.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use lang_string;
-use tool_lp\template;
+use core_competency\template;
/**
* Template cohort persistent.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Frédéric Massart - FMCorz.net
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
* @param int $lastruntime The last time the Cohort ssync task ran.
* @param bool $unlinkedaremissing When true, unlinked plans are considered as missing.
* @return array( array(
- * 'template' => \tool_lp\template,
+ * 'template' => \core_competency\template,
* 'userids' => array
* ))
*/
/**
* Class for loading/storing competencies from the DB.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use stdClass;
/**
* Class for user_competency persistence.
*
- * @package tool_lp
+ * @package core_competency
* @copyright 2015 Serge Gauthier
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
-namespace tool_lp;
+namespace core_competency;
defined('MOODLE_INTERNAL') || die();
use coding_exception;
*
* @param int $userid The user ID.
* @param int $competencyid The competency ID.
- * @return \tool_lp\user_competency
+ * @return \core_competency\user_competency
*/
&n
