mirror of
https://github.com/moodle/moodle.git
synced 2025-08-06 01:16:44 +02:00
20854c75f1
This includes: - Multiple coding violations. - Better detection of criteria, avoiding troublemaker 0 != '' - Minor formatting. - Ordering by path always to cause excludes to work ok.
1180 lines
54 KiB
PHP
1180 lines
54 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/>.
|
|
|
|
|
|
/**
|
|
* External course API
|
|
*
|
|
* @package core_course
|
|
* @category external
|
|
* @copyright 2009 Petr Skodak
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die;
|
|
|
|
require_once("$CFG->libdir/externallib.php");
|
|
|
|
/**
|
|
* Course external functions
|
|
*
|
|
* @package core_course
|
|
* @category external
|
|
* @copyright 2011 Jerome Mouneyrac
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
* @since Moodle 2.2
|
|
*/
|
|
class core_course_external extends external_api {
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function get_course_contents_parameters() {
|
|
return new external_function_parameters(
|
|
array('courseid' => new external_value(PARAM_INT, 'course id'),
|
|
'options' => new external_multiple_structure (
|
|
new external_single_structure(
|
|
array('name' => new external_value(PARAM_ALPHANUM, 'option name'),
|
|
'value' => new external_value(PARAM_RAW, 'the value of the option, this param is personaly validated in the external function.')
|
|
)
|
|
), 'Options, not used yet, might be used in later version', VALUE_DEFAULT, array())
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get course contents
|
|
*
|
|
* @param int $courseid course id
|
|
* @param array $options These options are not used yet, might be used in later version
|
|
* @return array
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function get_course_contents($courseid, $options) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . "/course/lib.php");
|
|
|
|
//validate parameter
|
|
$params = self::validate_parameters(self::get_course_contents_parameters(),
|
|
array('courseid' => $courseid, 'options' => $options));
|
|
|
|
//retrieve the course
|
|
$course = $DB->get_record('course', array('id' => $params['courseid']), '*', MUST_EXIST);
|
|
|
|
//check course format exist
|
|
if (!file_exists($CFG->dirroot . '/course/format/' . $course->format . '/lib.php')) {
|
|
throw new moodle_exception('cannotgetcoursecontents', 'webservice', '', null, get_string('courseformatnotfound', 'error', '', $course->format));
|
|
} else {
|
|
require_once($CFG->dirroot . '/course/format/' . $course->format . '/lib.php');
|
|
}
|
|
|
|
// now security checks
|
|
$context = get_context_instance(CONTEXT_COURSE, $course->id);
|
|
try {
|
|
self::validate_context($context);
|
|
} catch (Exception $e) {
|
|
$exceptionparam = new stdClass();
|
|
$exceptionparam->message = $e->getMessage();
|
|
$exceptionparam->courseid = $course->id;
|
|
throw new moodle_exception('errorcoursecontextnotvalid', 'webservice', '', $exceptionparam);
|
|
}
|
|
|
|
$canupdatecourse = has_capability('moodle/course:update', $context);
|
|
|
|
//create return value
|
|
$coursecontents = array();
|
|
|
|
if ($canupdatecourse or $course->visible
|
|
or has_capability('moodle/course:viewhiddencourses', $context)) {
|
|
|
|
//retrieve sections
|
|
$modinfo = get_fast_modinfo($course);
|
|
$sections = get_all_sections($course->id);
|
|
|
|
//for each sections (first displayed to last displayed)
|
|
foreach ($sections as $key => $section) {
|
|
|
|
$showsection = (has_capability('moodle/course:viewhiddensections', $context) or $section->visible or !$course->hiddensections);
|
|
if (!$showsection) {
|
|
continue;
|
|
}
|
|
|
|
// reset $sectioncontents
|
|
$sectionvalues = array();
|
|
$sectionvalues['id'] = $section->id;
|
|
$sectionvalues['name'] = get_section_name($course, $section);
|
|
$summary = file_rewrite_pluginfile_urls($section->summary, 'webservice/pluginfile.php', $context->id, 'course', 'section', $section->id);
|
|
$sectionvalues['visible'] = $section->visible;
|
|
$sectionvalues['summary'] = format_text($summary, $section->summaryformat);
|
|
$sectioncontents = array();
|
|
|
|
//for each module of the section
|
|
foreach ($modinfo->sections[$section->section] as $cmid) { //matching /course/lib.php:print_section() logic
|
|
$cm = $modinfo->cms[$cmid];
|
|
|
|
// stop here if the module is not visible to the user
|
|
if (!$cm->uservisible) {
|
|
continue;
|
|
}
|
|
|
|
$module = array();
|
|
|
|
//common info (for people being able to see the module or availability dates)
|
|
$module['id'] = $cm->id;
|
|
$module['name'] = format_string($cm->name, true);
|
|
$module['modname'] = $cm->modname;
|
|
$module['modplural'] = $cm->modplural;
|
|
$module['modicon'] = $cm->get_icon_url()->out(false);
|
|
$module['indent'] = $cm->indent;
|
|
|
|
$modcontext = get_context_instance(CONTEXT_MODULE, $cm->id);
|
|
|
|
if (!empty($cm->showdescription)) {
|
|
$module['description'] = $cm->get_content();
|
|
}
|
|
|
|
//url of the module
|
|
$url = $cm->get_url();
|
|
if ($url) { //labels don't have url
|
|
$module['url'] = $cm->get_url()->out();
|
|
}
|
|
|
|
$canviewhidden = has_capability('moodle/course:viewhiddenactivities',
|
|
get_context_instance(CONTEXT_MODULE, $cm->id));
|
|
//user that can view hidden module should know about the visibility
|
|
$module['visible'] = $cm->visible;
|
|
|
|
//availability date (also send to user who can see hidden module when the showavailabilyt is ON)
|
|
if ($canupdatecourse or ($CFG->enableavailability && $canviewhidden && $cm->showavailability)) {
|
|
$module['availablefrom'] = $cm->availablefrom;
|
|
$module['availableuntil'] = $cm->availableuntil;
|
|
}
|
|
|
|
$baseurl = 'webservice/pluginfile.php';
|
|
|
|
//call $modulename_export_contents
|
|
//(each module callback take care about checking the capabilities)
|
|
require_once($CFG->dirroot . '/mod/' . $cm->modname . '/lib.php');
|
|
$getcontentfunction = $cm->modname.'_export_contents';
|
|
if (function_exists($getcontentfunction)) {
|
|
if ($contents = $getcontentfunction($cm, $baseurl)) {
|
|
$module['contents'] = $contents;
|
|
}
|
|
}
|
|
|
|
//assign result to $sectioncontents
|
|
$sectioncontents[] = $module;
|
|
|
|
}
|
|
$sectionvalues['modules'] = $sectioncontents;
|
|
|
|
// assign result to $coursecontents
|
|
$coursecontents[] = $sectionvalues;
|
|
}
|
|
}
|
|
return $coursecontents;
|
|
}
|
|
|
|
/**
|
|
* Returns description of method result value
|
|
*
|
|
* @return external_description
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function get_course_contents_returns() {
|
|
return new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'id' => new external_value(PARAM_INT, 'Section ID'),
|
|
'name' => new external_value(PARAM_TEXT, 'Section name'),
|
|
'visible' => new external_value(PARAM_INT, 'is the section visible', VALUE_OPTIONAL),
|
|
'summary' => new external_value(PARAM_RAW, 'Section description'),
|
|
'modules' => new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'id' => new external_value(PARAM_INT, 'activity id'),
|
|
'url' => new external_value(PARAM_URL, 'activity url', VALUE_OPTIONAL),
|
|
'name' => new external_value(PARAM_TEXT, 'activity module name'),
|
|
'description' => new external_value(PARAM_RAW, 'activity description', VALUE_OPTIONAL),
|
|
'visible' => new external_value(PARAM_INT, 'is the module visible', VALUE_OPTIONAL),
|
|
'modicon' => new external_value(PARAM_URL, 'activity icon url'),
|
|
'modname' => new external_value(PARAM_PLUGIN, 'activity module type'),
|
|
'modplural' => new external_value(PARAM_TEXT, 'activity module plural name'),
|
|
'availablefrom' => new external_value(PARAM_INT, 'module availability start date', VALUE_OPTIONAL),
|
|
'availableuntil' => new external_value(PARAM_INT, 'module availability en date', VALUE_OPTIONAL),
|
|
'indent' => new external_value(PARAM_INT, 'number of identation in the site'),
|
|
'contents' => new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
// content info
|
|
'type'=> new external_value(PARAM_TEXT, 'a file or a folder or external link'),
|
|
'filename'=> new external_value(PARAM_FILE, 'filename'),
|
|
'filepath'=> new external_value(PARAM_PATH, 'filepath'),
|
|
'filesize'=> new external_value(PARAM_INT, 'filesize'),
|
|
'fileurl' => new external_value(PARAM_URL, 'downloadable file url', VALUE_OPTIONAL),
|
|
'content' => new external_value(PARAM_RAW, 'Raw content, will be used when type is content', VALUE_OPTIONAL),
|
|
'timecreated' => new external_value(PARAM_INT, 'Time created'),
|
|
'timemodified' => new external_value(PARAM_INT, 'Time modified'),
|
|
'sortorder' => new external_value(PARAM_INT, 'Content sort order'),
|
|
|
|
// copyright related info
|
|
'userid' => new external_value(PARAM_INT, 'User who added this content to moodle'),
|
|
'author' => new external_value(PARAM_TEXT, 'Content owner'),
|
|
'license' => new external_value(PARAM_TEXT, 'Content license'),
|
|
)
|
|
), VALUE_DEFAULT, array()
|
|
)
|
|
)
|
|
), 'list of module'
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function get_categories_parameters() {
|
|
return new external_function_parameters(
|
|
array(
|
|
'criteria' => new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'key' => new external_value(PARAM_ALPHA, 'The category column to search, expected keys (value format) are:
|
|
"id" (int) the category id,
|
|
"name" (string) the category name,
|
|
"parent" (int) the parent category id,
|
|
"idnumber" (string) category idnumber,
|
|
"visible" (int) whether the category is visible or not,
|
|
"theme" (string) category theme'),
|
|
'value' => new external_value(PARAM_RAW, 'the value to match')
|
|
)
|
|
), VALUE_DEFAULT, array()
|
|
),
|
|
'addsubcategories' => new external_value(PARAM_BOOL, 'return the sub categories infos
|
|
(1 - default) otherwise only the category info (0)', VALUE_DEFAULT, 1)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get categories
|
|
*
|
|
* @param array $criteria Criteria to match the results
|
|
* @param booln $addsubcategories obtain only the category (false) or its subcategories (true - default)
|
|
* @return array list of categories
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function get_categories($criteria = array(), $addsubcategories = true) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . "/course/lib.php");
|
|
|
|
// Validate parameters.
|
|
$params = self::validate_parameters(self::get_categories_parameters(),
|
|
array('criteria' => $criteria, 'addsubcategories' => $addsubcategories));
|
|
|
|
// Retrieve the categories.
|
|
$categories = array();
|
|
if (!empty($params['criteria'])) {
|
|
|
|
$conditions = array();
|
|
$wheres = array();
|
|
foreach ($params['criteria'] as $crit) {
|
|
$key = trim($crit['key']);
|
|
|
|
// Trying to avoid duplicate keys.
|
|
if (!isset($conditions[$key])) {
|
|
|
|
$context = context_system::instance();
|
|
$value = null;
|
|
|
|
switch ($key) {
|
|
case 'id':
|
|
$value = clean_param($crit['value'], PARAM_INT);
|
|
break;
|
|
|
|
case 'idnumber':
|
|
if (has_capability('moodle/category:manage', $context)) {
|
|
$value = clean_param($crit['value'], PARAM_RAW);
|
|
}
|
|
break;
|
|
|
|
case 'name':
|
|
$value = clean_param($crit['value'], PARAM_TEXT);
|
|
break;
|
|
|
|
case 'parent':
|
|
$value = clean_param($crit['value'], PARAM_INT);
|
|
break;
|
|
|
|
case 'visible':
|
|
$value = clean_param($crit['value'], PARAM_INT);
|
|
break;
|
|
|
|
case 'theme':
|
|
if (has_capability('moodle/category:manage', $context)) {
|
|
$value = clean_param($crit['value'], PARAM_THEME);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
throw new moodle_exception('invalidextparam', 'webservice', '', $key);
|
|
}
|
|
|
|
if (isset($value)) {
|
|
$conditions[$key] = $crit['value'];
|
|
$wheres[] = $key . " = :" . $key;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!empty($wheres)) {
|
|
$wheres = implode(" AND ", $wheres);
|
|
|
|
$categories = $DB->get_records_select('course_categories', $wheres, $conditions 'path');
|
|
|
|
// Retrieve its sub subcategories (all levels).
|
|
if ($categories and !empty($params['addsubcategories'])) {
|
|
$newcategories = array();
|
|
|
|
foreach ($categories as $category) {
|
|
$sqllike = $DB->sql_like('path', ':path');
|
|
$sqlparams = array('path' => $category->path.'/%'); // It will NOT include the specified category.
|
|
$subcategories = $DB->get_records_select('course_categories', $sqllike, $sqlparams, 'path');
|
|
$newcategories = array_merge($newcategories, $subcategories); // Both arrays have integer as keys.
|
|
}
|
|
$categories = array_merge($categories, $newcategories);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// Retrieve all categories in the database.
|
|
$categories = $DB->get_records('course_categories', array(), 'path');
|
|
}
|
|
|
|
// The not returned categories. key => category id, value => reason of exclusion.
|
|
$excludedcats = array();
|
|
|
|
// The returned categories.
|
|
$categoriesinfo = array();
|
|
|
|
foreach ($categories as $category) {
|
|
|
|
// Check if the category is a child of an excluded category, if yes exclude it too (excluded => do not return).
|
|
$parents = explode('/', $category->path);
|
|
unset($parents[0]); // First key is always empty because path start with / => /1/2/4.
|
|
foreach ($parents as $parentid) {
|
|
// Note: when the parent exclusion was due to the context,
|
|
// the sub category could still be returned.
|
|
if (isset($excludedcats[$parentid]) and $excludedcats[$parentid] != 'context') {
|
|
$excludedcats[$category->id] = 'parent';
|
|
}
|
|
}
|
|
|
|
// Check category depth is <= maxdepth (do not check for user who can manage categories).
|
|
if ((!empty($CFG->maxcategorydepth) && count($parents) > $CFG->maxcategorydepth)
|
|
and !has_capability('moodle/category:manage', $context)) {
|
|
$excludedcats[$category->id] = 'depth';
|
|
}
|
|
|
|
// Check the user can use the category context.
|
|
$context = context_coursecat::instance($category->id);
|
|
try {
|
|
self::validate_context($context);
|
|
} catch (Exception $e) {
|
|
$excludedcats[$category->id] = 'context';
|
|
|
|
// If it was the requested category then throw an exception.
|
|
if (isset($params['categoryid']) && $category->id == $params['categoryid']) {
|
|
$exceptionparam = new stdClass();
|
|
$exceptionparam->message = $e->getMessage();
|
|
$exceptionparam->catid = $category->id;
|
|
throw new moodle_exception('errorcatcontextnotvalid', 'webservice', '', $exceptionparam);
|
|
}
|
|
}
|
|
|
|
// Return the category information.
|
|
if (!isset($excludedcats[$category->id])) {
|
|
|
|
// Final check to see if the category is visible to the user.
|
|
if ($category->visible
|
|
or has_capability('moodle/category:viewhiddencategories', context_system::instance())
|
|
or has_capability('moodle/category:manage', $context)) {
|
|
|
|
$categoryinfo = array();
|
|
$categoryinfo['id'] = $category->id;
|
|
$categoryinfo['name'] = $category->name;
|
|
$categoryinfo['description'] = file_rewrite_pluginfile_urls($category->description,
|
|
'webservice/pluginfile.php', $context->id, 'coursecat', 'description', null);
|
|
$options = new stdClass;
|
|
$options->noclean = true;
|
|
$options->para = false;
|
|
$categoryinfo['description'] = format_text($categoryinfo['description'],
|
|
$category->descriptionformat, $options);
|
|
$categoryinfo['parent'] = $category->parent;
|
|
$categoryinfo['sortorder'] = $category->sortorder;
|
|
$categoryinfo['coursecount'] = $category->coursecount;
|
|
$categoryinfo['depth'] = $category->depth;
|
|
$categoryinfo['path'] = $category->path;
|
|
|
|
// Some fields only returned for admin.
|
|
if (has_capability('moodle/category:manage', $context)) {
|
|
$categoryinfo['idnumber'] = $category->idnumber;
|
|
$categoryinfo['visible'] = $category->visible;
|
|
$categoryinfo['visibleold'] = $category->visibleold;
|
|
$categoryinfo['timemodified'] = $category->timemodified;
|
|
$categoryinfo['theme'] = $category->theme;
|
|
}
|
|
|
|
$categoriesinfo[] = $categoryinfo;
|
|
} else {
|
|
$excludedcats[$category->id] = 'visibility';
|
|
}
|
|
}
|
|
}
|
|
|
|
return $categoriesinfo;
|
|
}
|
|
|
|
/**
|
|
* Returns description of method result value
|
|
*
|
|
* @return external_description
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function get_categories_returns() {
|
|
return new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'id' => new external_value(PARAM_INT, 'category id'),
|
|
'name' => new external_value(PARAM_TEXT, 'category name'),
|
|
'idnumber' => new external_value(PARAM_RAW, 'category id number', VALUE_OPTIONAL),
|
|
'description' => new external_value(PARAM_RAW, 'category description'),
|
|
'parent' => new external_value(PARAM_INT, 'parent category id'),
|
|
'sortorder' => new external_value(PARAM_INT, 'category sorting order'),
|
|
'coursecount' => new external_value(PARAM_INT, 'number of courses in this category'),
|
|
'visible' => new external_value(PARAM_INT, '1: available, 0:not available', VALUE_OPTIONAL),
|
|
'visibleold' => new external_value(PARAM_INT, '1: available, 0:not available', VALUE_OPTIONAL),
|
|
'timemodified' => new external_value(PARAM_INT, 'timestamp', VALUE_OPTIONAL),
|
|
'depth' => new external_value(PARAM_INT, 'category depth'),
|
|
'path' => new external_value(PARAM_TEXT, 'category path'),
|
|
'theme' => new external_value(PARAM_THEME, 'category theme', VALUE_OPTIONAL),
|
|
), 'List of categories'
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function get_courses_parameters() {
|
|
return new external_function_parameters(
|
|
array('options' => new external_single_structure(
|
|
array('ids' => new external_multiple_structure(
|
|
new external_value(PARAM_INT, 'Course id')
|
|
, 'List of course id. If empty return all courses
|
|
except front page course.',
|
|
VALUE_OPTIONAL)
|
|
), 'options - operator OR is used', VALUE_DEFAULT, array())
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get courses
|
|
*
|
|
* @param array $options It contains an array (list of ids)
|
|
* @return array
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function get_courses($options) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . "/course/lib.php");
|
|
|
|
//validate parameter
|
|
$params = self::validate_parameters(self::get_courses_parameters(),
|
|
array('options' => $options));
|
|
|
|
//retrieve courses
|
|
if (!key_exists('ids', $params['options'])
|
|
or empty($params['options']['ids'])) {
|
|
$courses = $DB->get_records('course');
|
|
} else {
|
|
$courses = $DB->get_records_list('course', 'id', $params['options']['ids']);
|
|
}
|
|
|
|
//create return value
|
|
$coursesinfo = array();
|
|
foreach ($courses as $course) {
|
|
|
|
// now security checks
|
|
$context = get_context_instance(CONTEXT_COURSE, $course->id);
|
|
try {
|
|
self::validate_context($context);
|
|
} catch (Exception $e) {
|
|
$exceptionparam = new stdClass();
|
|
$exceptionparam->message = $e->getMessage();
|
|
$exceptionparam->courseid = $course->id;
|
|
throw new moodle_exception(
|
|
get_string('errorcoursecontextnotvalid', 'webservice', $exceptionparam));
|
|
}
|
|
require_capability('moodle/course:view', $context);
|
|
|
|
$courseinfo = array();
|
|
$courseinfo['id'] = $course->id;
|
|
$courseinfo['fullname'] = $course->fullname;
|
|
$courseinfo['shortname'] = $course->shortname;
|
|
$courseinfo['categoryid'] = $course->category;
|
|
$courseinfo['summary'] = $course->summary;
|
|
$courseinfo['summaryformat'] = $course->summaryformat;
|
|
$courseinfo['format'] = $course->format;
|
|
$courseinfo['startdate'] = $course->startdate;
|
|
$courseinfo['numsections'] = $course->numsections;
|
|
|
|
//some field should be returned only if the user has update permission
|
|
$courseadmin = has_capability('moodle/course:update', $context);
|
|
if ($courseadmin) {
|
|
$courseinfo['categorysortorder'] = $course->sortorder;
|
|
$courseinfo['idnumber'] = $course->idnumber;
|
|
$courseinfo['showgrades'] = $course->showgrades;
|
|
$courseinfo['showreports'] = $course->showreports;
|
|
$courseinfo['newsitems'] = $course->newsitems;
|
|
$courseinfo['visible'] = $course->visible;
|
|
$courseinfo['maxbytes'] = $course->maxbytes;
|
|
$courseinfo['hiddensections'] = $course->hiddensections;
|
|
$courseinfo['groupmode'] = $course->groupmode;
|
|
$courseinfo['groupmodeforce'] = $course->groupmodeforce;
|
|
$courseinfo['defaultgroupingid'] = $course->defaultgroupingid;
|
|
$courseinfo['lang'] = $course->lang;
|
|
$courseinfo['timecreated'] = $course->timecreated;
|
|
$courseinfo['timemodified'] = $course->timemodified;
|
|
$courseinfo['forcetheme'] = $course->theme;
|
|
$courseinfo['enablecompletion'] = $course->enablecompletion;
|
|
$courseinfo['completionstartonenrol'] = $course->completionstartonenrol;
|
|
$courseinfo['completionnotify'] = $course->completionnotify;
|
|
}
|
|
|
|
if ($courseadmin or $course->visible
|
|
or has_capability('moodle/course:viewhiddencourses', $context)) {
|
|
$coursesinfo[] = $courseinfo;
|
|
}
|
|
}
|
|
|
|
return $coursesinfo;
|
|
}
|
|
|
|
/**
|
|
* Returns description of method result value
|
|
*
|
|
* @return external_description
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function get_courses_returns() {
|
|
return new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'id' => new external_value(PARAM_INT, 'course id'),
|
|
'shortname' => new external_value(PARAM_TEXT, 'course short name'),
|
|
'categoryid' => new external_value(PARAM_INT, 'category id'),
|
|
'categorysortorder' => new external_value(PARAM_INT,
|
|
'sort order into the category', VALUE_OPTIONAL),
|
|
'fullname' => new external_value(PARAM_TEXT, 'full name'),
|
|
'idnumber' => new external_value(PARAM_RAW, 'id number', VALUE_OPTIONAL),
|
|
'summary' => new external_value(PARAM_RAW, 'summary'),
|
|
'summaryformat' => new external_value(PARAM_INT,
|
|
'the summary text Moodle format'),
|
|
'format' => new external_value(PARAM_PLUGIN,
|
|
'course format: weeks, topics, social, site,..'),
|
|
'showgrades' => new external_value(PARAM_INT,
|
|
'1 if grades are shown, otherwise 0', VALUE_OPTIONAL),
|
|
'newsitems' => new external_value(PARAM_INT,
|
|
'number of recent items appearing on the course page', VALUE_OPTIONAL),
|
|
'startdate' => new external_value(PARAM_INT,
|
|
'timestamp when the course start'),
|
|
'numsections' => new external_value(PARAM_INT, 'number of weeks/topics'),
|
|
'maxbytes' => new external_value(PARAM_INT,
|
|
'largest size of file that can be uploaded into the course',
|
|
VALUE_OPTIONAL),
|
|
'showreports' => new external_value(PARAM_INT,
|
|
'are activity report shown (yes = 1, no =0)', VALUE_OPTIONAL),
|
|
'visible' => new external_value(PARAM_INT,
|
|
'1: available to student, 0:not available', VALUE_OPTIONAL),
|
|
'hiddensections' => new external_value(PARAM_INT,
|
|
'How the hidden sections in the course are displayed to students',
|
|
VALUE_OPTIONAL),
|
|
'groupmode' => new external_value(PARAM_INT, 'no group, separate, visible',
|
|
VALUE_OPTIONAL),
|
|
'groupmodeforce' => new external_value(PARAM_INT, '1: yes, 0: no',
|
|
VALUE_OPTIONAL),
|
|
'defaultgroupingid' => new external_value(PARAM_INT, 'default grouping id',
|
|
VALUE_OPTIONAL),
|
|
'timecreated' => new external_value(PARAM_INT,
|
|
'timestamp when the course have been created', VALUE_OPTIONAL),
|
|
'timemodified' => new external_value(PARAM_INT,
|
|
'timestamp when the course have been modified', VALUE_OPTIONAL),
|
|
'enablecompletion' => new external_value(PARAM_INT,
|
|
'Enabled, control via completion and activity settings. Disbaled,
|
|
not shown in activity settings.',
|
|
VALUE_OPTIONAL),
|
|
'completionstartonenrol' => new external_value(PARAM_INT,
|
|
'1: begin tracking a student\'s progress in course completion
|
|
after course enrolment. 0: does not',
|
|
VALUE_OPTIONAL),
|
|
'completionnotify' => new external_value(PARAM_INT,
|
|
'1: yes 0: no', VALUE_OPTIONAL),
|
|
'lang' => new external_value(PARAM_SAFEDIR,
|
|
'forced course language', VALUE_OPTIONAL),
|
|
'forcetheme' => new external_value(PARAM_PLUGIN,
|
|
'name of the force theme', VALUE_OPTIONAL),
|
|
), 'course'
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function create_categories_parameters() {
|
|
return new external_function_parameters(
|
|
array(
|
|
'categories' => new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'name' => new external_value(PARAM_TEXT, 'new category name'),
|
|
'parent' => new external_value(PARAM_INT,
|
|
'the parent category id inside which the new category will be created'),
|
|
'idnumber' => new external_value(PARAM_RAW,
|
|
'the new category idnumber', VALUE_OPTIONAL),
|
|
'description' => new external_value(PARAM_RAW,
|
|
'the new category description', VALUE_OPTIONAL),
|
|
'theme' => new external_value(PARAM_THEME,
|
|
'the new category theme. This option must be enabled on moodle',
|
|
VALUE_OPTIONAL),
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Create categories
|
|
*
|
|
* @param array $categories - see create_categories_parameters() for the array structure
|
|
* @return array - see create_categories_returns() for the array structure
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function create_categories($categories) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . "/course/lib.php");
|
|
|
|
$params = self::validate_parameters(self::create_categories_parameters(),
|
|
array('categories' => $categories));
|
|
|
|
$transaction = $DB->start_delegated_transaction();
|
|
|
|
$createdcategories = array();
|
|
foreach ($params['categories'] as $category) {
|
|
if ($category['parent']) {
|
|
if (!$DB->record_exists('course_categories', array('id' => $category['parent']))) {
|
|
throw new moodle_exception('unknowcategory');
|
|
}
|
|
$context = context_coursecat::instance($category['parent']);
|
|
} else {
|
|
$context = context_system::instance();
|
|
}
|
|
self::validate_context($context);
|
|
require_capability('moodle/category:manage', $context);
|
|
|
|
// Check id number.
|
|
if (!empty($category['idnumber'])) { // Same as in course/editcategory_form.php .
|
|
if (textlib::strlen($category['idnumber'])>100) {
|
|
throw new moodle_exception('idnumbertoolong');
|
|
}
|
|
if ($existing = $DB->get_record('course_categories', array('idnumber' => $category['idnumber']))) {
|
|
if ($existing->id) {
|
|
throw new moodle_exception('idnumbertaken');
|
|
}
|
|
}
|
|
}
|
|
// Check name.
|
|
if (textlib::strlen($category['name'])>30) {
|
|
throw new moodle_exception('categorytoolong');
|
|
}
|
|
|
|
$newcategory = new stdClass();
|
|
$newcategory->name = $category['name'];
|
|
$newcategory->parent = $category['parent'];
|
|
$newcategory->idnumber = $category['idnumber'];
|
|
$newcategory->sortorder = 999; // Same as in the course/editcategory.php .
|
|
// Format the description.
|
|
if (!empty($category['description'])) {
|
|
$newcategory->description = $category['description'];
|
|
}
|
|
$newcategory->descriptionformat = FORMAT_HTML;
|
|
if (isset($category['theme']) and !empty($CFG->allowcategorythemes)) {
|
|
$newcategory->theme = $category['theme'];
|
|
}
|
|
|
|
$newcategory = create_course_category($newcategory);
|
|
// Populate special fields.
|
|
fix_course_sortorder();
|
|
|
|
$createdcategories[] = array('id' => $newcategory->id, 'name' => $newcategory->name);
|
|
}
|
|
|
|
$transaction->allow_commit();
|
|
|
|
return $createdcategories;
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function create_categories_returns() {
|
|
return new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'id' => new external_value(PARAM_INT, 'new category id'),
|
|
'name' => new external_value(PARAM_TEXT, 'new category name'),
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function create_courses_parameters() {
|
|
$courseconfig = get_config('moodlecourse'); //needed for many default values
|
|
return new external_function_parameters(
|
|
array(
|
|
'courses' => new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'fullname' => new external_value(PARAM_TEXT, 'full name'),
|
|
'shortname' => new external_value(PARAM_TEXT, 'course short name'),
|
|
'categoryid' => new external_value(PARAM_INT, 'category id'),
|
|
'idnumber' => new external_value(PARAM_RAW, 'id number', VALUE_OPTIONAL),
|
|
'summary' => new external_value(PARAM_RAW, 'summary', VALUE_OPTIONAL),
|
|
'summaryformat' => new external_value(PARAM_INT,
|
|
'the summary text Moodle format', VALUE_DEFAULT, FORMAT_MOODLE),
|
|
'format' => new external_value(PARAM_PLUGIN,
|
|
'course format: weeks, topics, social, site,..',
|
|
VALUE_DEFAULT, $courseconfig->format),
|
|
'showgrades' => new external_value(PARAM_INT,
|
|
'1 if grades are shown, otherwise 0', VALUE_DEFAULT,
|
|
$courseconfig->showgrades),
|
|
'newsitems' => new external_value(PARAM_INT,
|
|
'number of recent items appearing on the course page',
|
|
VALUE_DEFAULT, $courseconfig->newsitems),
|
|
'startdate' => new external_value(PARAM_INT,
|
|
'timestamp when the course start', VALUE_OPTIONAL),
|
|
'numsections' => new external_value(PARAM_INT, 'number of weeks/topics',
|
|
VALUE_DEFAULT, $courseconfig->numsections),
|
|
'maxbytes' => new external_value(PARAM_INT,
|
|
'largest size of file that can be uploaded into the course',
|
|
VALUE_DEFAULT, $courseconfig->maxbytes),
|
|
'showreports' => new external_value(PARAM_INT,
|
|
'are activity report shown (yes = 1, no =0)', VALUE_DEFAULT,
|
|
$courseconfig->showreports),
|
|
'visible' => new external_value(PARAM_INT,
|
|
'1: available to student, 0:not available', VALUE_OPTIONAL),
|
|
'hiddensections' => new external_value(PARAM_INT,
|
|
'How the hidden sections in the course are displayed to students',
|
|
VALUE_DEFAULT, $courseconfig->hiddensections),
|
|
'groupmode' => new external_value(PARAM_INT, 'no group, separate, visible',
|
|
VALUE_DEFAULT, $courseconfig->groupmode),
|
|
'groupmodeforce' => new external_value(PARAM_INT, '1: yes, 0: no',
|
|
VALUE_DEFAULT, $courseconfig->groupmodeforce),
|
|
'defaultgroupingid' => new external_value(PARAM_INT, 'default grouping id',
|
|
VALUE_DEFAULT, 0),
|
|
'enablecompletion' => new external_value(PARAM_INT,
|
|
'Enabled, control via completion and activity settings. Disabled,
|
|
not shown in activity settings.',
|
|
VALUE_OPTIONAL),
|
|
'completionstartonenrol' => new external_value(PARAM_INT,
|
|
'1: begin tracking a student\'s progress in course completion after
|
|
course enrolment. 0: does not',
|
|
VALUE_OPTIONAL),
|
|
'completionnotify' => new external_value(PARAM_INT,
|
|
'1: yes 0: no', VALUE_OPTIONAL),
|
|
'lang' => new external_value(PARAM_SAFEDIR,
|
|
'forced course language', VALUE_OPTIONAL),
|
|
'forcetheme' => new external_value(PARAM_PLUGIN,
|
|
'name of the force theme', VALUE_OPTIONAL),
|
|
)
|
|
), 'courses to create'
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Create courses
|
|
*
|
|
* @param array $courses
|
|
* @return array courses (id and shortname only)
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function create_courses($courses) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . "/course/lib.php");
|
|
require_once($CFG->libdir . '/completionlib.php');
|
|
|
|
|
|
$params = self::validate_parameters(self::create_courses_parameters(),
|
|
array('courses' => $courses));
|
|
|
|
$availablethemes = get_plugin_list('theme');
|
|
$availablelangs = get_string_manager()->get_list_of_translations();
|
|
|
|
$transaction = $DB->start_delegated_transaction();
|
|
|
|
foreach ($params['courses'] as $course) {
|
|
|
|
// Ensure the current user is allowed to run this function
|
|
$context = get_context_instance(CONTEXT_COURSECAT, $course['categoryid']);
|
|
try {
|
|
self::validate_context($context);
|
|
} catch (Exception $e) {
|
|
$exceptionparam = new stdClass();
|
|
$exceptionparam->message = $e->getMessage();
|
|
$exceptionparam->catid = $course['categoryid'];
|
|
throw new moodle_exception(
|
|
get_string('errorcatcontextnotvalid', 'webservice', $exceptionparam));
|
|
}
|
|
require_capability('moodle/course:create', $context);
|
|
|
|
// Make sure lang is valid
|
|
if (key_exists('lang', $course) and empty($availablelangs[$course['lang']])) {
|
|
throw new moodle_exception(
|
|
get_string('errorinvalidparam', 'webservice', 'lang'));
|
|
}
|
|
|
|
// Make sure theme is valid
|
|
if (key_exists('forcetheme', $course)) {
|
|
if (!empty($CFG->allowcoursethemes)) {
|
|
if (empty($availablethemes[$course['forcetheme']])) {
|
|
throw new moodle_exception(
|
|
get_string('errorinvalidparam', 'webservice', 'forcetheme'));
|
|
} else {
|
|
$course['theme'] = $course['forcetheme'];
|
|
}
|
|
}
|
|
}
|
|
|
|
//force visibility if ws user doesn't have the permission to set it
|
|
$category = $DB->get_record('course_categories', array('id' => $course['categoryid']));
|
|
if (!has_capability('moodle/course:visibility', $context)) {
|
|
$course['visible'] = $category->visible;
|
|
}
|
|
|
|
//set default value for completion
|
|
$courseconfig = get_config('moodlecourse');
|
|
if (completion_info::is_enabled_for_site()) {
|
|
if (!key_exists('enablecompletion', $course)) {
|
|
$course['enablecompletion'] = $courseconfig->enablecompletion;
|
|
}
|
|
if (!key_exists('completionstartonenrol', $course)) {
|
|
$course['completionstartonenrol'] = $courseconfig->completionstartonenrol;
|
|
}
|
|
} else {
|
|
$course['enablecompletion'] = 0;
|
|
$course['completionstartonenrol'] = 0;
|
|
}
|
|
|
|
$course['category'] = $course['categoryid'];
|
|
|
|
//Note: create_course() core function check shortname, idnumber, category
|
|
$course['id'] = create_course((object) $course)->id;
|
|
|
|
$resultcourses[] = array('id' => $course['id'], 'shortname' => $course['shortname']);
|
|
}
|
|
|
|
$transaction->allow_commit();
|
|
|
|
return $resultcourses;
|
|
}
|
|
|
|
/**
|
|
* Returns description of method result value
|
|
*
|
|
* @return external_description
|
|
* @since Moodle 2.2
|
|
*/
|
|
public static function create_courses_returns() {
|
|
return new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'id' => new external_value(PARAM_INT, 'course id'),
|
|
'shortname' => new external_value(PARAM_TEXT, 'short name'),
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
* @return external_function_parameters
|
|
*/
|
|
public static function delete_courses_parameters() {
|
|
return new external_function_parameters(
|
|
array(
|
|
'courseids' => new external_multiple_structure(new external_value(PARAM_INT, 'course ID')),
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Delete courses
|
|
* @param array $courseids A list of course ids
|
|
*/
|
|
public static function delete_courses($courseids) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot."/course/lib.php");
|
|
|
|
// Parameter validation.
|
|
$params = self::validate_parameters(self::delete_courses_parameters(), array('courseids'=>$courseids));
|
|
|
|
$transaction = $DB->start_delegated_transaction();
|
|
|
|
foreach ($params['courseids'] as $courseid) {
|
|
$course = $DB->get_record('course', array('id'=>$courseid), '*', MUST_EXIST);
|
|
|
|
// Check if the context is valid.
|
|
$coursecontext = context_course::instance($course->id);
|
|
self::validate_context($coursecontext);
|
|
|
|
// Check if the current user has enought permissions.
|
|
if (!can_delete_course($courseid)) {
|
|
throw new moodle_exception('cannotdeletecategorycourse', 'error', '', format_string($course->fullname)." (id: $courseid)");
|
|
}
|
|
|
|
delete_course($course, false);
|
|
}
|
|
|
|
$transaction->allow_commit();
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns description of method result value
|
|
* @return external_description
|
|
*/
|
|
public static function delete_courses_returns() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function delete_categories_parameters() {
|
|
return new external_function_parameters(
|
|
array(
|
|
'categories' => new external_multiple_structure(
|
|
new external_single_structure(
|
|
array(
|
|
'id' => new external_value(PARAM_INT, 'category id to delete'),
|
|
'newparent' => new external_value(PARAM_INT,
|
|
'the parent category to move the contents to, if specified', VALUE_OPTIONAL),
|
|
'recursive' => new external_value(PARAM_BOOL, '1: recursively delete all contents inside this
|
|
category, 0 (default): move contents to newparent or current parent category (except if parent is root)', VALUE_DEFAULT, 0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Delete categories
|
|
* @param array $categories A list of category ids
|
|
* @return array
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function delete_categories($categories) {
|
|
global $CFG, $DB;
|
|
require_once($CFG->dirroot . "/course/lib.php");
|
|
|
|
// Validate parameters.
|
|
$params = self::validate_parameters(self::delete_categories_parameters(), array('categories' => $categories));
|
|
|
|
foreach ($params['categories'] as $category) {
|
|
if (!$deletecat = $DB->get_record('course_categories', array('id' => $category['id']))) {
|
|
throw new moodle_exception('unknowcategory');
|
|
}
|
|
$context = context_coursecat::instance($deletecat->id);
|
|
require_capability('moodle/category:manage', $context);
|
|
self::validate_context($context);
|
|
self::validate_context(get_category_or_system_context($deletecat->parent));
|
|
|
|
if ($category['recursive']) {
|
|
// If recursive was specified, then we recursively delete the category's contents.
|
|
category_delete_full($deletecat, false);
|
|
} else {
|
|
// In this situation, we don't delete the category's contents, we either move it to newparent or parent.
|
|
// If the parent is the root, moving is not supported (because a course must always be inside a category).
|
|
// We must move to an existing category.
|
|
if (!empty($category['newparent'])) {
|
|
if (!$DB->record_exists('course_categories', array('id' => $category['newparent']))) {
|
|
throw new moodle_exception('unknowcategory');
|
|
}
|
|
$newparent = $category['newparent'];
|
|
} else {
|
|
$newparent = $deletecat->parent;
|
|
}
|
|
|
|
// This operation is not allowed. We must move contents to an existing category.
|
|
if ($newparent == 0) {
|
|
throw new moodle_exception('movecatcontentstoroot');
|
|
}
|
|
|
|
$parentcontext = get_category_or_system_context($newparent);
|
|
require_capability('moodle/category:manage', $parentcontext);
|
|
self::validate_context($parentcontext);
|
|
category_delete_move($deletecat, $newparent, false);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.3
|
|
*/
|
|
public static function delete_categories_returns() {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated course external functions
|
|
*
|
|
* @package core_course
|
|
* @copyright 2009 Petr Skodak
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
* @since Moodle 2.0
|
|
* @deprecated Moodle 2.2 MDL-29106 - Please do not use this class any more.
|
|
* @todo MDL-31194 This will be deleted in Moodle 2.5.
|
|
* @see core_course_external
|
|
*/
|
|
class moodle_course_external extends external_api {
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.0
|
|
* @deprecated Moodle 2.2 MDL-29106 - Please do not call this function any more.
|
|
* @todo MDL-31194 This will be deleted in Moodle 2.5.
|
|
* @see core_course_external::get_courses_parameters()
|
|
*/
|
|
public static function get_courses_parameters() {
|
|
return core_course_external::get_courses_parameters();
|
|
}
|
|
|
|
/**
|
|
* Get courses
|
|
*
|
|
* @param array $options
|
|
* @return array
|
|
* @since Moodle 2.0
|
|
* @deprecated Moodle 2.2 MDL-29106 - Please do not call this function any more.
|
|
* @todo MDL-31194 This will be deleted in Moodle 2.5.
|
|
* @see core_course_external::get_courses()
|
|
*/
|
|
public static function get_courses($options) {
|
|
return core_course_external::get_courses($options);
|
|
}
|
|
|
|
/**
|
|
* Returns description of method result value
|
|
*
|
|
* @return external_description
|
|
* @since Moodle 2.0
|
|
* @deprecated Moodle 2.2 MDL-29106 - Please do not call this function any more.
|
|
* @todo MDL-31194 This will be deleted in Moodle 2.5.
|
|
* @see core_course_external::get_courses_returns()
|
|
*/
|
|
public static function get_courses_returns() {
|
|
return core_course_external::get_courses_returns();
|
|
}
|
|
|
|
/**
|
|
* Returns description of method parameters
|
|
*
|
|
* @return external_function_parameters
|
|
* @since Moodle 2.0
|
|
* @deprecated Moodle 2.2 MDL-29106 - Please do not call this function any more.
|
|
* @todo MDL-31194 This will be deleted in Moodle 2.5.
|
|
* @see core_course_external::create_courses_parameters()
|
|
*/
|
|
public static function create_courses_parameters() {
|
|
return core_course_external::create_courses_parameters();
|
|
}
|
|
|
|
/**
|
|
* Create courses
|
|
*
|
|
* @param array $courses
|
|
* @return array courses (id and shortname only)
|
|
* @since Moodle 2.0
|
|
* @deprecated Moodle 2.2 MDL-29106 - Please do not call this function any more.
|
|
* @todo MDL-31194 This will be deleted in Moodle 2.5.
|
|
* @see core_course_external::create_courses()
|
|
*/
|
|
public static function create_courses($courses) {
|
|
return core_course_external::create_courses($courses);
|
|
}
|
|
|
|
/**
|
|
* Returns description of method result value
|
|
*
|
|
* @return external_description
|
|
* @since Moodle 2.0
|
|
* @deprecated Moodle 2.2 MDL-29106 - Please do not call this function any more.
|
|
* @todo MDL-31194 This will be deleted in Moodle 2.5.
|
|
* @see core_course_external::create_courses_returns()
|
|
*/
|
|
public static function create_courses_returns() {
|
|
return core_course_external::create_courses_returns();
|
|
}
|
|
|
|
}
|