/** * Convenience method to instantiate the event. * * @param template $template The template. * @return self */ public static final function create_from_template(template $template) { if (!$template->get_id()) { throw new \coding_exception('The template ID must be set.'); } $event = static::create(array('contextid' => $template->get_contextid(), 'objectid' => $template->get_id())); $event->add_record_snapshot(template::TABLE, $template->to_record()); return $event; }
/** * Construct this renderable. * * @param template $template The learning plan template. * @param context $pagecontext The page context. */ public function __construct(template $template, context $pagecontext) { $this->pagecontext = $pagecontext; $this->template = $template; $this->templatestatistics = new template_statistics($template->get_id()); $this->competencies = api::list_competencies_in_template($template); $this->canmanagecompetencyframeworks = has_capability('moodle/competency:competencymanage', $this->pagecontext); $this->canmanagetemplatecompetencies = has_capability('moodle/competency:templatemanage', $this->pagecontext); $this->manageurl = new moodle_url('/admin/tool/lp/competencyframeworks.php', array('pagecontextid' => $this->pagecontext->id)); }
/** * Sets up the table. * * @param string $uniqueid Unique id of table. * @param \core_competency\template $template The template. */ public function __construct($uniqueid, \core_competency\template $template) { parent::__construct($uniqueid); // This object should not be used without the right permissions. if (!$template->can_read()) { throw new \required_capability_exception($template->get_context(), 'moodle/competency:templateview', 'nopermissions', ''); } // Set protected properties. $this->template = $template; $this->context = $this->template->get_context(); // Define columns in the table. $this->define_table_columns(); // Define configs. $this->define_table_configs(); }
/** * This function extends the category navigation to add learning plan links. * * @param navigation_node $navigation The navigation node to extend * @param context $coursecategorycontext The context of the course category */ function tool_lp_extend_navigation_category_settings($navigation, $coursecategorycontext) { if (!get_config('core_competency', 'enabled')) { return false; } // We check permissions before renderring the links. $templatereadcapability = \core_competency\template::can_read_context($coursecategorycontext); $competencyreadcapability = \core_competency\competency_framework::can_read_context($coursecategorycontext); if (!$templatereadcapability && !$competencyreadcapability) { return false; } // The link to the learning plan page. if ($templatereadcapability) { $title = get_string('templates', 'tool_lp'); $path = new moodle_url("/admin/tool/lp/learningplans.php", array('pagecontextid' => $coursecategorycontext->id)); $settingsnode = navigation_node::create($title, $path, navigation_node::TYPE_SETTING, null, null, new pix_icon('i/competencies', '')); if (isset($settingsnode)) { $navigation->add_node($settingsnode); } } // The link to the competency frameworks page. if ($competencyreadcapability) { $title = get_string('competencyframeworks', 'tool_lp'); $path = new moodle_url("/admin/tool/lp/competencyframeworks.php", array('pagecontextid' => $coursecategorycontext->id)); $settingsnode = navigation_node::create($title, $path, navigation_node::TYPE_SETTING, null, null, new pix_icon('i/competencies', '')); if (isset($settingsnode)) { $navigation->add_node($settingsnode); } } }
/** * Export this data so it can be used as the context for a mustache template. * * @param renderer_base $output Renderer base. * @return stdClass */ public function export_for_template(renderer_base $output) { $data = new stdClass(); $data->pagecontextid = $this->pagecontext->id; $data->templates = array(); foreach ($this->templates as $template) { $exporter = new template_exporter($template); $data->templates[] = $exporter->export($output); } $data->pluginbaseurl = (new moodle_url('/admin/tool/lp'))->out(true); $data->navigation = array(); foreach ($this->navigation as $button) { $data->navigation[] = $output->render($button); } $data->canmanage = template::can_manage_context($this->pagecontext); return $data; }
public function test_delete_template_unlink_plans() { $this->resetAfterTest(true); $this->setAdminUser(); $dg = $this->getDataGenerator(); $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency'); $u1 = $dg->create_user(); $f = $lpg->create_framework(); $c1 = $lpg->create_competency(array('competencyframeworkid' => $f->get_id())); $c2 = $lpg->create_competency(array('competencyframeworkid' => $f->get_id())); $tpl = $lpg->create_template(); $tplc1 = $lpg->create_template_competency(array('templateid' => $tpl->get_id(), 'competencyid' => $c1->get_id(), 'sortorder' => 1)); $tplc2 = $lpg->create_template_competency(array('templateid' => $tpl->get_id(), 'competencyid' => $c2->get_id(), 'sortorder' => 2)); $p1 = $lpg->create_plan(array('templateid' => $tpl->get_id(), 'userid' => $u1->id)); // Check pre-test. $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(\core_competency\template::record_exists($tpl->get_id())); // Check that associated competencies are also deleted. $this->assertEquals(0, \core_competency\template_competency::count_competencies($tpl->get_id())); // Check that associated plan still exist but unlink from template. $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()); }
/** * Template event viewed. * * Requires moodle/competency:templateview capability at the system context. * * @param mixed $templateorid The id or the template. * @return boolean */ public static function template_viewed($templateorid) { static::require_enabled(); $template = $templateorid; if (!is_object($template)) { $template = new template($template); } // First we do a permissions check. if (!$template->can_read()) { throw new required_capability_exception($template->get_context(), 'moodle/competency:templateview', 'nopermissions', ''); } // Trigger a template viewed event. \core\event\competency_template_viewed::create_from_template($template)->trigger(); return true; }
/** * Create a template. * * @param array|stdClass $record * @return template */ public function create_template($record = null) { $this->templatecount++; $i = $this->templatecount; $record = (object) $record; if (!isset($record->shortname)) { $record->shortname = "Template shortname {$i}"; } if (!isset($record->description)) { $record->description = "Template {$i} description "; } if (!isset($record->contextid)) { $record->contextid = context_system::instance()->id; } $template = new template(0, $record); $template->create(); return $template; }
/** * Set-up a template page. * * Example: * list($title, $subtitle) = page_helper::setup_for_template($pagecontextid, $url, $template, $pagetitle); * echo $OUTPUT->heading($title); * echo $OUTPUT->heading($subtitle, 3); * * @param int $pagecontextid The page context ID. * @param moodle_url $url The current page. * @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: * - Page title * - Page sub title * - Return URL */ public static function setup_for_template($pagecontextid, moodle_url $url, $template = null, $subtitle = '', $returntype = null) { global $PAGE, $SITE; $pagecontext = context::instance_by_id($pagecontextid); $context = $pagecontext; if (!empty($template)) { $context = $template->get_context(); } $templatesurl = new moodle_url('/admin/tool/lp/learningplans.php', array('pagecontextid' => $pagecontextid)); $templateurl = null; if ($template) { $templateurl = new moodle_url('/admin/tool/lp/templatecompetencies.php', ['templateid' => $template->get_id(), 'pagecontextid' => $pagecontextid]); } $returnurl = $templatesurl; if ($returntype != 'templates' && $templateurl) { $returnurl = $templateurl; } $PAGE->navigation->override_active_url($templatesurl); $PAGE->set_context($pagecontext); if (!empty($template)) { $title = format_string($template->get_shortname(), true, array('context' => $context)); } else { $title = get_string('templates', 'tool_lp'); } if ($pagecontext->contextlevel == CONTEXT_SYSTEM) { $heading = $SITE->fullname; } else { if ($pagecontext->contextlevel == CONTEXT_COURSECAT) { $heading = $pagecontext->get_context_name(); } else { throw new coding_exception('Unexpected context!'); } } $PAGE->set_pagelayout('admin'); $PAGE->set_url($url); $PAGE->set_title($title); $PAGE->set_heading($heading); if (!empty($template)) { $PAGE->navbar->add($title, $templateurl); if (!empty($subtitle)) { $PAGE->navbar->add($subtitle, $url); } } else { if (!empty($subtitle)) { // We're in a sub page without a specific template. $PAGE->navbar->add($subtitle, $url); } } return array($title, $subtitle, $returnurl); }
/** * Validate templateid. * * @param int $value ID. * @return true|lang_string */ protected function validate_templateid($value) { if (!template::record_exists($value)) { return new \lang_string('invaliddata', 'error'); } return true; }
// Moodle is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with Moodle. If not, see <http://www.gnu.org/licenses/>. /** * This page lets users to manage site wide competencies. * * @package tool_lp * @copyright 2015 Damyon Wiese * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later */ require_once __DIR__ . '/../../../config.php'; require_once $CFG->libdir . '/adminlib.php'; $pagecontextid = required_param('pagecontextid', PARAM_INT); $context = context::instance_by_id($pagecontextid); require_login(0, false); \core_competency\api::require_enabled(); if (!\core_competency\template::can_read_context($context)) { throw new required_capability_exception($context, 'moodle/competency:templateview', 'nopermissions', ''); } $url = new moodle_url('/admin/tool/lp/learningplans.php', array('pagecontextid' => $pagecontextid)); list($title, $subtitle) = \tool_lp\page_helper::setup_for_template($pagecontextid, $url); $output = $PAGE->get_renderer('tool_lp'); echo $output->header(); echo $output->heading($title); $page = new \tool_lp\output\manage_templates_page($context); echo $output->render($page); echo $output->footer();
public function test_create_template() { $this->resetAfterTest(true); $lpg = $this->getDataGenerator()->get_plugin_generator('core_competency'); $this->assertEquals(0, template::count_records()); $template = $lpg->create_template(); $template = $lpg->create_template(); $this->assertEquals(2, template::count_records()); $this->assertInstanceOf('\\core_competency\\template', $template); }
/** * Update from template. * * Bulk update a lot of plans from a template * * @param template $template * @return bool */ public static function update_multiple_from_template(template $template) { global $DB; if (!$template->is_valid()) { // As we will bypass this model's validation we rely on the template being validated. throw new \coding_exception('The template must be validated before updating plans.'); } $params = array('templateid' => $template->get_id(), 'status' => self::STATUS_COMPLETE, 'name' => $template->get_shortname(), 'description' => $template->get_description(), 'descriptionformat' => $template->get_descriptionformat(), 'duedate' => $template->get_duedate()); $sql = "UPDATE {" . self::TABLE . "}\n SET name = :name,\n description = :description,\n descriptionformat = :descriptionformat,\n duedate = :duedate\n WHERE templateid = :templateid\n AND status != :status"; return $DB->execute($sql, $params); }
/** * Return an array of templates persistent with their missing userids. * * Note that only cohorts associated with visible templates are considered, * as well as only templates with a due date in the future, or no due date. * * @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' => \core_competency\template, * 'userids' => array * )) */ public static function get_all_missing_plans($lastruntime = 0, $unlinkedaremissing = false) { global $DB; $planwhereclause = " WHERE (p.id is NULL\n AND (cm.timeadded >= :lastruntime1\n OR tc.timecreated >= :lastruntime3\n OR t.timemodified >= :lastruntime4))"; if ($unlinkedaremissing) { $planwhereclause .= " OR (p.origtemplateid IS NOT NULL AND cm.timeadded < :lastruntime2)"; } $sql = "SELECT " . $DB->sql_concat('cm.userid', 'tc.templateid') . " as uniqueid, cm.userid, t.*\n FROM {cohort_members} cm\n JOIN {" . self::TABLE . "} tc ON cm.cohortid = tc.cohortid\n JOIN {" . template::TABLE . "} t\n ON (tc.templateid = t.id AND t.visible = 1)\n AND (t.duedate = 0 OR t.duedate > :time1)\n LEFT JOIN {" . plan::TABLE . "} p ON (cm.userid = p.userid AND (t.id = p.templateid OR t.id = p.origtemplateid))\n {$planwhereclause}\n ORDER BY t.id"; $params = array('time1' => time(), 'time2' => time(), 'lastruntime1' => $lastruntime, 'lastruntime2' => $lastruntime, 'lastruntime3' => $lastruntime, 'lastruntime4' => $lastruntime); $results = $DB->get_records_sql($sql, $params); $missingplans = array(); foreach ($results as $usertemplate) { $userid = $usertemplate->userid; // Check if template already exist in the array. if (isset($missingplans[$usertemplate->id])) { $missingplans[$usertemplate->id]['userids'][] = $userid; } else { unset($usertemplate->userid); unset($usertemplate->uniqueid); $template = new template(0, $usertemplate); $missingplans[$template->get_id()]['template'] = $template; $missingplans[$template->get_id()]['userids'][] = $userid; } } return array_values($missingplans); }