Andrew Nicols
477 lines
18 KiB
PHP
477 lines
18 KiB
PHP
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
use core_courseformat\sectiondelegate;
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
require_once($CFG->dirroot. '/course/format/lib.php');
|
|
|
|
/**
|
|
* Main class for the singleactivity course format
|
|
*
|
|
* @package format_singleactivity
|
|
* @copyright 2012 Marina Glancy
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class format_singleactivity extends core_courseformat\base implements core_courseformat\main_activity_interface {
|
|
/** @var cm_info the current activity. Use get_main_activity() to retrieve it. */
|
|
private $activity = false;
|
|
|
|
/** @var int The category ID guessed from the form data. */
|
|
private $categoryid = false;
|
|
|
|
/**
|
|
* The URL to use for the specified course
|
|
*
|
|
* @param int|stdClass $section Section object from database or just field course_sections.section
|
|
* if null the course view page is returned
|
|
* @param array $options options for view URL. At the moment core uses:
|
|
* 'navigation' (bool) ignored by this format
|
|
* 'sr' (int) ignored by this format
|
|
* @return null|moodle_url
|
|
*/
|
|
public function get_view_url($section, $options = []) {
|
|
return new moodle_url('/course/view.php', ['id' => $this->courseid]);
|
|
}
|
|
|
|
/**
|
|
* Loads all of the course sections into the navigation
|
|
*
|
|
* @param global_navigation $navigation
|
|
* @param navigation_node $node The course node within the navigation
|
|
*/
|
|
public function extend_course_navigation($navigation, navigation_node $node) {
|
|
// SingleActivity course format does not extend navigation, it uses site_main_menu block instead.
|
|
}
|
|
|
|
/**
|
|
* Returns the list of blocks to be automatically added for the newly created course
|
|
*
|
|
* @return array of default blocks, must contain two keys BLOCK_POS_LEFT and BLOCK_POS_RIGHT
|
|
* each of values is an array of block names (for left and right side columns)
|
|
*/
|
|
public function get_default_blocks() {
|
|
return [
|
|
BLOCK_POS_LEFT => ['site_main_menu'],
|
|
BLOCK_POS_RIGHT => [],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Definitions of the additional options that this course format uses for course
|
|
*
|
|
* Singleactivity course format uses one option 'activitytype'
|
|
*
|
|
* @param bool $foreditform
|
|
* @return array of options
|
|
*/
|
|
public function course_format_options($foreditform = false) {
|
|
static $courseformatoptions = false;
|
|
|
|
$fetchtypes = $courseformatoptions === false;
|
|
$fetchtypes = $fetchtypes || ($foreditform && !isset($courseformatoptions['activitytype']['label']));
|
|
|
|
if ($fetchtypes) {
|
|
$availabletypes = $this->get_supported_activities();
|
|
core_collator::asort($availabletypes);
|
|
if ($this->courseid) {
|
|
// The course exists. Test against the course.
|
|
$testcontext = context_course::instance($this->courseid);
|
|
} else if ($this->categoryid) {
|
|
// The course does not exist yet, but we have a category ID that we can test against.
|
|
$testcontext = context_coursecat::instance($this->categoryid);
|
|
} else {
|
|
// The course does not exist, and we somehow do not have a category. Test capabilities against the system context.
|
|
$testcontext = context_system::instance();
|
|
}
|
|
foreach (array_keys($availabletypes) as $activity) {
|
|
$capability = "mod/{$activity}:addinstance";
|
|
if (!has_capability($capability, $testcontext)) {
|
|
if (!$this->categoryid) {
|
|
unset($availabletypes[$activity]);
|
|
} else {
|
|
// We do not have a course yet, so we guess if the user will have the capability to add the activity after
|
|
// creating the course.
|
|
$categorycontext = \context_coursecat::instance($this->categoryid);
|
|
if (!guess_if_creator_will_have_course_capability($capability, $categorycontext)) {
|
|
unset($availabletypes[$activity]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($courseformatoptions === false) {
|
|
$config = get_config('format_singleactivity');
|
|
$courseformatoptions = [
|
|
'activitytype' => [
|
|
'default' => $config->activitytype,
|
|
'type' => PARAM_TEXT,
|
|
],
|
|
];
|
|
|
|
if (!empty($availabletypes) && !isset($availabletypes[$config->activitytype])) {
|
|
$courseformatoptions['activitytype']['default'] = array_keys($availabletypes)[0];
|
|
}
|
|
}
|
|
|
|
if ($foreditform && !isset($courseformatoptions['activitytype']['label'])) {
|
|
$courseformatoptionsedit = [
|
|
'activitytype' => [
|
|
'label' => new lang_string('activitytype', 'format_singleactivity'),
|
|
'help' => 'activitytype',
|
|
'help_component' => 'format_singleactivity',
|
|
'element_type' => 'select',
|
|
'element_attributes' => [$availabletypes],
|
|
],
|
|
];
|
|
$courseformatoptions = array_merge_recursive($courseformatoptions, $courseformatoptionsedit);
|
|
}
|
|
return $courseformatoptions;
|
|
}
|
|
|
|
/**
|
|
* Adds format options elements to the course/section edit form
|
|
*
|
|
* This function is called from {@link course_edit_form::definition_after_data()}
|
|
*
|
|
* Format singleactivity adds a warning when format of the course is about to be changed.
|
|
*
|
|
* @param MoodleQuickForm $mform form the elements are added to
|
|
* @param bool $forsection 'true' if this is a section edit form, 'false' if this is course edit form
|
|
* @return array array of references to the added form elements
|
|
*/
|
|
public function create_edit_form_elements(&$mform, $forsection = false) {
|
|
if (!$this->course && $submitvalues = $mform->getSubmitValues()) {
|
|
$this->categoryid = $submitvalues['category'];
|
|
}
|
|
|
|
$elements = parent::create_edit_form_elements($mform, $forsection);
|
|
|
|
return $elements;
|
|
}
|
|
|
|
/**
|
|
* Returns the name of activity type used for this course
|
|
*
|
|
* @return string|null
|
|
*/
|
|
protected function get_activitytype() {
|
|
$options = $this->get_format_options();
|
|
$availabletypes = $this->get_supported_activities();
|
|
if (!empty($options['activitytype']) &&
|
|
array_key_exists($options['activitytype'], $availabletypes)) {
|
|
return $options['activitytype'];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#[\Override]
|
|
public function get_main_activity(): ?\cm_info {
|
|
if ($this->activity === false) {
|
|
$modinfo = get_fast_modinfo($this->courseid);
|
|
|
|
// Find the current activity (first activity with the specified type in all course activities).
|
|
$activitytype = $this->get_activitytype();
|
|
if (!empty($activitytype) && !empty($modinfo->sections)) {
|
|
// Get the first activity of the specified type, but only if it is in the 0-section.
|
|
$cmlist = $modinfo->sections[0];
|
|
foreach ($cmlist as $cmid) {
|
|
if ($modinfo->cms[$cmid]->modname === $activitytype) {
|
|
$this->activity = $modinfo->cms[$cmid];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure the current activity is visible.
|
|
if ($this->activity && !$this->activity->visible) {
|
|
set_coursemodule_visible($this->activity->id, 1);
|
|
}
|
|
}
|
|
|
|
if ($this->activity !== false) {
|
|
return $this->activity;
|
|
}
|
|
|
|
// No activity found, return null.
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Get the activities supported by the format.
|
|
*
|
|
* Here we ignore the modules that do not have a page of their own or need sections,
|
|
* like the label or subsection.
|
|
*
|
|
* @return array [$module => $name of the module].
|
|
*/
|
|
public static function get_supported_activities() {
|
|
$availabletypes = get_module_types_names();
|
|
foreach ($availabletypes as $module => $name) {
|
|
if (plugin_supports('mod', $module, FEATURE_NO_VIEW_LINK, false)) {
|
|
unset($availabletypes[$module]);
|
|
}
|
|
if (sectiondelegate::has_delegate_class('mod_' . $module)) {
|
|
unset($availabletypes[$module]);
|
|
}
|
|
}
|
|
return $availabletypes;
|
|
}
|
|
|
|
/**
|
|
* Checks if the current user can add the activity of the specified type to this course.
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function can_add_activity() {
|
|
global $CFG;
|
|
if (!($modname = $this->get_activitytype())) {
|
|
return false;
|
|
}
|
|
if (!has_capability('moodle/course:manageactivities', context_course::instance($this->courseid))) {
|
|
return false;
|
|
}
|
|
if (!course_allowed_module($this->get_course(), $modname)) {
|
|
return false;
|
|
}
|
|
$libfile = "$CFG->dirroot/mod/$modname/lib.php";
|
|
if (!file_exists($libfile)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if the activity type has multiple items in the activity chooser.
|
|
*
|
|
* @return bool|null (null if the check is not possible)
|
|
*/
|
|
public function activity_has_subtypes() {
|
|
global $USER;
|
|
if (!($modname = $this->get_activitytype())) {
|
|
return null;
|
|
}
|
|
$contentitemservice = \core_course\local\factory\content_item_service_factory::get_content_item_service();
|
|
$metadata = $contentitemservice->get_content_items_for_user_in_course($USER, $this->get_course());
|
|
|
|
// If there are multiple items originating from this mod_xxx component, then it's deemed to have subtypes.
|
|
// If there is only 1 item, but it's not a reference to the core content item for the module, then it's also deemed to
|
|
// have subtypes.
|
|
$count = 0;
|
|
foreach ($metadata as $key => $moduledata) {
|
|
if ('mod_'.$modname === $moduledata->componentname) {
|
|
$count ++;
|
|
}
|
|
}
|
|
if ($count > 1) {
|
|
return true;
|
|
} else {
|
|
// Get the single item.
|
|
$itemmetadata = $metadata[array_search('mod_' . $modname, array_column($metadata, 'componentname'))];
|
|
$urlbase = new \moodle_url('/course/mod.php', ['id' => $this->get_course()->id]);
|
|
$referenceurl = new \moodle_url($urlbase, ['add' => $modname]);
|
|
if ($referenceurl->out(false) != $itemmetadata->link) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Allows course format to execute code on moodle_page::set_course()
|
|
*
|
|
* This function is executed before the output starts.
|
|
*
|
|
* If everything is configured correctly, user is redirected from the
|
|
* default course view page to the activity view page.
|
|
*
|
|
* If user is on course view page and there is no module added to the course
|
|
* and the user has 'moodle/course:manageactivities' capability, redirect to create module
|
|
* form.
|
|
*
|
|
* @param moodle_page $page instance of page calling set_course
|
|
*/
|
|
public function page_set_course(moodle_page $page) {
|
|
global $PAGE;
|
|
$page->add_body_class('format-'. $this->get_format());
|
|
if ($PAGE == $page && $page->has_set_url() &&
|
|
$page->url->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE)) {
|
|
$edit = optional_param('edit', -1, PARAM_BOOL);
|
|
if (($edit == 0 || $edit == 1) && confirm_sesskey()) {
|
|
// This is a request to turn editing mode on or off, do not redirect here, /course/view.php will do redirection.
|
|
return;
|
|
}
|
|
$cm = $this->get_main_activity();
|
|
if (!$this->get_activitytype()) {
|
|
if (has_capability('moodle/course:update', context_course::instance($this->courseid))) {
|
|
// Teacher is redirected to edit course page.
|
|
$url = new moodle_url('/course/edit.php', ['id' => $this->courseid]);
|
|
redirect($url, get_string('erroractivitytype', 'format_singleactivity'));
|
|
} else {
|
|
// Student sees an empty course page.
|
|
return;
|
|
}
|
|
}
|
|
if ($cm == null) {
|
|
if ($this->can_add_activity()) {
|
|
// This is a user who has capability to create an activity.
|
|
if ($this->activity_has_subtypes()) {
|
|
// Activity has multiple items in the activity chooser, it can not be added automatically.
|
|
if (optional_param('addactivity', 0, PARAM_INT)) {
|
|
return;
|
|
} else {
|
|
$url = new moodle_url('/course/view.php', ['id' => $this->courseid, 'addactivity' => 1]);
|
|
redirect($url);
|
|
}
|
|
}
|
|
// Redirect to the add activity form.
|
|
$url = new moodle_url(
|
|
'/course/mod.php',
|
|
[
|
|
'id' => $this->courseid,
|
|
'section' => 0,
|
|
'sesskey' => sesskey(),
|
|
'add' => $this->get_activitytype(),
|
|
],
|
|
);
|
|
redirect($url);
|
|
} else {
|
|
// Student views an empty course page.
|
|
return;
|
|
}
|
|
} else if (!$cm->uservisible || !$cm->url) {
|
|
// Activity is set but not visible to current user or does not have url.
|
|
// Display course page (either empty or with availability restriction info).
|
|
return;
|
|
} else {
|
|
// Everything is set up and accessible, redirect to the activity page!
|
|
redirect($cm->url);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allows course format to execute code on moodle_page::set_cm()
|
|
*
|
|
* If we are inside the main module for this course, remove extra node level
|
|
* from navigation: substitute course node with activity node, move all children
|
|
*
|
|
* @param moodle_page $page instance of page calling set_cm
|
|
*/
|
|
public function page_set_cm(moodle_page $page) {
|
|
global $PAGE;
|
|
parent::page_set_cm($page);
|
|
if ($PAGE == $page && ($cm = $this->get_main_activity()) &&
|
|
$cm->uservisible &&
|
|
($cm->id === $page->cm->id) &&
|
|
($activitynode = $page->navigation->find($cm->id, navigation_node::TYPE_ACTIVITY)) &&
|
|
($node = $page->navigation->find($page->course->id, navigation_node::TYPE_COURSE))) {
|
|
// Substitute course node with activity node, move all children.
|
|
$node->action = $activitynode->action;
|
|
$node->type = $activitynode->type;
|
|
$node->id = $activitynode->id;
|
|
$node->key = $activitynode->key;
|
|
$node->isactive = $node->isactive || $activitynode->isactive;
|
|
$node->icon = null;
|
|
if ($activitynode->children->count()) {
|
|
foreach ($activitynode->children as &$child) {
|
|
$child->remove();
|
|
$node->add_node($child);
|
|
}
|
|
} else {
|
|
$node->search_for_active_node();
|
|
}
|
|
$activitynode->remove();
|
|
}
|
|
}
|
|
|
|
#[\Override]
|
|
public function has_view_page() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Return the plugin configs for external functions.
|
|
*
|
|
* @return array the list of configuration settings
|
|
* @since Moodle 3.5
|
|
*/
|
|
public function get_config_for_external() {
|
|
// Return everything (nothing to hide).
|
|
return $this->get_format_options();
|
|
}
|
|
|
|
#[\Override]
|
|
public function supports_ajax() {
|
|
// All home page is rendered in the backend, we only need an ajax editor components in edit mode.
|
|
// This will also prevent redirecting to the login page when a guest tries to access the site,
|
|
// and will make the home page loading faster.
|
|
$ajaxsupport = new stdClass();
|
|
$ajaxsupport->capable = $this->show_editor();
|
|
return $ajaxsupport;
|
|
}
|
|
|
|
#[\Override]
|
|
public function supports_components() {
|
|
return true;
|
|
}
|
|
|
|
#[\Override]
|
|
public function uses_sections() {
|
|
return false;
|
|
}
|
|
|
|
#[\Override]
|
|
public function get_section_name($section) {
|
|
$section = $this->get_section($section);
|
|
if ($section->is_delegated()) {
|
|
return $section->name;
|
|
}
|
|
// The single activity only uses one section inside the additional activities block.
|
|
return get_string('pluginname', 'format_singleactivity');
|
|
}
|
|
|
|
#[\Override]
|
|
public function get_sectionnum(): int {
|
|
// SingleActivity format uses only section 0.
|
|
return 0;
|
|
}
|
|
|
|
#[\Override]
|
|
public function allow_stealth_module_visibility($cm, $section) {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns if a specific section is visible to the current user.
|
|
*
|
|
* The single activity format does only have the section zero
|
|
* and subsections (delegated sections).
|
|
*
|
|
* @param section_info $section the section modinfo
|
|
* @return bool;
|
|
*/
|
|
#[\Override]
|
|
public function is_section_visible(section_info $section): bool {
|
|
$visible = parent::is_section_visible($section);
|
|
// Social format does only use section 0 as a normal section.
|
|
// Any other included section should be a delegated one (subsections).
|
|
return $visible && ($section->sectionnum == 0 || $section->is_delegated());
|
|
}
|
|
}
|