coregrade/CoreGradeLearning
1
0
Fork 0
Code Issues Pull Requests Releases Activity

first commit

Browse Source
This commit is contained in:
CHIEFSOFT\ameye
2024-09-30 18:11:26 -04:00
commit e592ca6823
27270 changed files with 5002257 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rating/classes/external.php
+309
View File
@@ -0,0 +1,309 @@
<?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/>.
/**
* Rating external API
*
* @package core_rating
* @category external
* @copyright 2015 Costantino Cito <ccito@cvaconsulting.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @since Moodle 2.9
*/
defined('MOODLE_INTERNAL') || die;
require_once("$CFG->dirroot/rating/lib.php");
use core_external\external_api;
use core_external\external_value;
use core_external\external_single_structure;
use core_external\external_multiple_structure;
use core_external\external_function_parameters;
use core_external\external_warnings;
/**
* Rating external functions
*
* @package core_rating
* @category external
* @copyright 2015 Costantino Cito <ccito@cvaconsulting.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @since Moodle 2.9
*/
class core_rating_external extends external_api {
/**
* Returns description of get_item_ratings parameters.
*
* @return external_function_parameters
* @since Moodle 2.9
*/
public static function get_item_ratings_parameters() {
return new external_function_parameters (
array(
'contextlevel' => new external_value(PARAM_ALPHA, 'context level: course, module, user, etc...'),
'instanceid' => new external_value(PARAM_INT, 'the instance id of item associated with the context level'),
'component' => new external_value(PARAM_COMPONENT, 'component'),
'ratingarea' => new external_value(PARAM_AREA, 'rating area'),
'itemid' => new external_value(PARAM_INT, 'associated id'),
'scaleid' => new external_value(PARAM_INT, 'scale id'),
'sort' => new external_value(PARAM_ALPHA, 'sort order (firstname, rating or timemodified)')
)
);
}
/**
* Retrieve a list of ratings for a given item (forum post etc)
*
* @param string $contextlevel course, module, user...
* @param int $instanceid the instance if for the context element
* @param string $component the name of the component
* @param string $ratingarea rating area
* @param int $itemid the item id
* @param int $scaleid the scale id
* @param string $sort sql order (firstname, rating or timemodified)
* @return array Result and possible warnings
* @throws moodle_exception
* @since Moodle 2.9
*/
public static function get_item_ratings($contextlevel, $instanceid, $component, $ratingarea, $itemid, $scaleid, $sort) {
global $USER, $PAGE;
$warnings = array();
$arrayparams = array(
'contextlevel' => $contextlevel,
'instanceid' => $instanceid,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
'scaleid' => $scaleid,
'sort' => $sort
);
// Validate and normalize parameters.
$params = self::validate_parameters(self::get_item_ratings_parameters(), $arrayparams);
$context = self::get_context_from_params($params);
self::validate_context($context);
// Minimal capability required.
$callbackparams = array('contextid' => $context->id,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
'scaleid' => $scaleid);
if (!has_capability('moodle/rating:view', $context) ||
!component_callback($component, 'rating_can_see_item_ratings', array($callbackparams), true)) {
throw new moodle_exception('noviewrate', 'rating');
}
list($context, $course, $cm) = get_context_info_array($context->id);
// Can we see all ratings?
$canviewallratings = has_capability('moodle/rating:viewall', $context);
// Create the Sql sort order string.
switch ($params['sort']) {
case 'firstname':
$sqlsort = "u.firstname ASC";
break;
case 'rating':
$sqlsort = "r.rating ASC";
break;
default:
$sqlsort = "r.timemodified ASC";
}
$ratingoptions = new stdClass;
$ratingoptions->context = $context;
$ratingoptions->component = $params['component'];
$ratingoptions->ratingarea = $params['ratingarea'];
$ratingoptions->itemid = $params['itemid'];
$ratingoptions->sort = $sqlsort;
$rm = new rating_manager();
$ratings = $rm->get_all_ratings_for_item($ratingoptions);
$scalemenu = make_grades_menu($params['scaleid']);
// If the scale was changed after ratings were submitted some ratings may have a value above the current maximum.
// We can't just do count($scalemenu) - 1 as custom scales start at index 1, not 0.
$maxrating = max(array_keys($scalemenu));
$results = array();
foreach ($ratings as $rating) {
if ($canviewallratings || $USER->id == $rating->userid) {
if ($rating->rating > $maxrating) {
$rating->rating = $maxrating;
}
$result = array();
$result['id'] = $rating->id;
$result['userid'] = $rating->userid;
$result['userfullname'] = fullname($rating);
$result['rating'] = $scalemenu[$rating->rating];
$result['timemodified'] = $rating->timemodified;
// The rating object has all the required fields for generating the picture url.
// Undo the aliasing of the user id column from fields::get_sql.
$rating->id = $rating->userid;
$userpicture = new user_picture($rating);
$userpicture->size = 1; // Size f1.
$result['userpictureurl'] = $userpicture->get_url($PAGE)->out(false);
$results[] = $result;
}
}
return array(
'ratings' => $results,
'warnings' => $warnings
);
}
/**
* Returns description of get_item_ratings result values.
*
* @return external_single_structure
* @since Moodle 2.9
*/
public static function get_item_ratings_returns() {
return new external_single_structure(
array(
'ratings' => new external_multiple_structure(
new external_single_structure(
array(
'id' => new external_value(PARAM_INT, 'rating id'),
'userid' => new external_value(PARAM_INT, 'user id'),
'userpictureurl' => new external_value(PARAM_URL, 'URL user picture'),
'userfullname' => new external_value(PARAM_NOTAGS, 'user fullname'),
'rating' => new external_value(PARAM_NOTAGS, 'rating on scale'),
'timemodified' => new external_value(PARAM_INT, 'time modified (timestamp)')
), 'Rating'
), 'list of ratings'
),
'warnings' => new external_warnings(),
)
);
}
/**
* Returns description of add_rating parameters.
*
* @return external_function_parameters
* @since Moodle 3.2
*/
public static function add_rating_parameters() {
return new external_function_parameters (
array(
'contextlevel' => new external_value(PARAM_ALPHA, 'context level: course, module, user, etc...'),
'instanceid' => new external_value(PARAM_INT, 'the instance id of item associated with the context level'),
'component' => new external_value(PARAM_COMPONENT, 'component'),
'ratingarea' => new external_value(PARAM_AREA, 'rating area'),
'itemid' => new external_value(PARAM_INT, 'associated id'),
'scaleid' => new external_value(PARAM_INT, 'scale id'),
'rating' => new external_value(PARAM_INT, 'user rating'),
'rateduserid' => new external_value(PARAM_INT, 'rated user id'),
'aggregation' => new external_value(PARAM_INT, 'agreggation method', VALUE_DEFAULT, RATING_AGGREGATE_NONE)
)
);
}
/**
* Adds a rating to an item
*
* @param string $contextlevel course, module, user...
* @param int $instanceid the instance if for the context element
* @param string $component the name of the component
* @param string $ratingarea rating area
* @param int $itemid the item id
* @param int $scaleid the scale id
* @param int $rating the user rating
* @param int $rateduserid the rated user id
* @param int $aggregation the aggregation method
* @return array result and possible warnings
* @throws moodle_exception
* @since Moodle 3.2
*/
public static function add_rating($contextlevel, $instanceid, $component, $ratingarea, $itemid, $scaleid, $rating, $rateduserid,
$aggregation = RATING_AGGREGATE_NONE) {
$warnings = array();
$params = array(
'contextlevel' => $contextlevel,
'instanceid' => $instanceid,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
'scaleid' => $scaleid,
'rating' => $rating,
'rateduserid' => $rateduserid,
'aggregation' => $aggregation,
);
// Validate and normalize parameters.
$params = self::validate_parameters(self::add_rating_parameters(), $params);
$context = self::get_context_from_params($params);
self::validate_context($context);
$cm = get_coursemodule_from_id(false, $context->instanceid, 0, false, MUST_EXIST);
require_capability('moodle/rating:rate', $context);
$rm = new rating_manager();
$result = $rm->add_rating($cm, $context, $params['component'], $params['ratingarea'], $params['itemid'], $params['scaleid'],
$params['rating'], $params['rateduserid'], $params['aggregation']);
if (!empty($result->error)) {
throw new moodle_exception($result->error, 'rating');
}
$returndata = array(
'success' => $result->success,
'warnings' => $warnings
);
if (isset($result->aggregate)) {
$returndata['aggregate'] = $result->aggregate;
$returndata['count'] = $result->count;
$returndata['itemid'] = $result->itemid;
}
return $returndata;
}
/**
* Returns description of add_rating result values.
*
* @return external_single_structure
* @since Moodle 3.2
*/
public static function add_rating_returns() {
return new external_single_structure(
array(
'success' => new external_value(PARAM_BOOL, 'Whether the rate was successfully created'),
'aggregate' => new external_value(PARAM_TEXT, 'New aggregate', VALUE_OPTIONAL),
'count' => new external_value(PARAM_INT, 'Ratings count', VALUE_OPTIONAL),
'itemid' => new external_value(PARAM_INT, 'Rating item id', VALUE_OPTIONAL),
'warnings' => new external_warnings(),
)
);
}
}
rating/classes/external/util.php
Vendored
+188
View File
@@ -0,0 +1,188 @@
<?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/>.
/**
* Rating external functions utility class.
*
* @package core_rating
* @copyright 2017 Juan Leyva
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace core_rating\external;
defined('MOODLE_INTERNAL') || die();
require_once($CFG->dirroot . '/rating/lib.php');
use core_external\external_multiple_structure;
use core_external\external_single_structure;
use core_external\external_value;
use rating_manager;
use stdClass;
/**
* Rating external functions utility class.
*
* @package core_rating
* @copyright 2017 Juan Leyva
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @since Moodle 3.4
*/
class util {
/**
* Returns the ratings definition for external functions.
*/
public static function external_ratings_structure() {
return new external_single_structure (
[
'contextid' => new external_value(PARAM_INT, 'Context id.'),
'component' => new external_value(PARAM_COMPONENT, 'Context name.'),
'ratingarea' => new external_value(PARAM_AREA, 'Rating area name.'),
'canviewall' => new external_value(PARAM_BOOL, 'Whether the user can view all the individual ratings.',
VALUE_OPTIONAL),
'canviewany' => new external_value(PARAM_BOOL, 'Whether the user can view aggregate of ratings of others.',
VALUE_OPTIONAL),
'scales' => new external_multiple_structure(
new external_single_structure (
[
'id' => new external_value(PARAM_INT, 'Scale id.'),
'courseid' => new external_value(PARAM_INT, 'Course id.', VALUE_OPTIONAL),
'name' => new external_value(PARAM_TEXT, 'Scale name (when a real scale is used).', VALUE_OPTIONAL),
'max' => new external_value(PARAM_INT, 'Max value for the scale.'),
'isnumeric' => new external_value(PARAM_BOOL, 'Whether is a numeric scale.'),
'items' => new external_multiple_structure(
new external_single_structure (
[
'value' => new external_value(PARAM_INT, 'Scale value/option id.'),
'name' => new external_value(PARAM_NOTAGS, 'Scale name.'),
]
), 'Scale items. Only returned for not numerical scales.', VALUE_OPTIONAL
)
], 'Scale information'
), 'Different scales used information', VALUE_OPTIONAL
),
'ratings' => new external_multiple_structure(
new external_single_structure (
[
'itemid' => new external_value(PARAM_INT, 'Item id.'),
'scaleid' => new external_value(PARAM_INT, 'Scale id.', VALUE_OPTIONAL),
'userid' => new external_value(PARAM_INT, 'User who rated id.', VALUE_OPTIONAL),
'aggregate' => new external_value(PARAM_FLOAT, 'Aggregated ratings grade.', VALUE_OPTIONAL),
'aggregatestr' => new external_value(PARAM_NOTAGS, 'Aggregated ratings as string.', VALUE_OPTIONAL),
'aggregatelabel' => new external_value(PARAM_NOTAGS, 'The aggregation label.', VALUE_OPTIONAL),
'count' => new external_value(PARAM_INT, 'Ratings count (used when aggregating).', VALUE_OPTIONAL),
'rating' => new external_value(PARAM_INT, 'The rating the user gave.', VALUE_OPTIONAL),
'canrate' => new external_value(PARAM_BOOL, 'Whether the user can rate the item.', VALUE_OPTIONAL),
'canviewaggregate' => new external_value(PARAM_BOOL, 'Whether the user can view the aggregated grade.',
VALUE_OPTIONAL),
]
), 'The ratings', VALUE_OPTIONAL
),
], 'Rating information', VALUE_OPTIONAL
);
}
/**
* Returns rating information inside a data structure like the one defined by external_ratings_structure.
*
* @param stdClass $mod course module object
* @param stdClass $context context object
* @param str $component component name
* @param str $ratingarea rating area
* @param array $items items to add ratings
* @return array ratings ready to be returned by external functions.
*/
public static function get_rating_info($mod, $context, $component, $ratingarea, $items) {
global $USER;
$ratinginfo = [
'contextid' => $context->id,
'component' => $component,
'ratingarea' => $ratingarea,
'canviewall' => null,
'canviewany' => null,
'scales' => [],
'ratings' => [],
];
if ($mod->assessed != RATING_AGGREGATE_NONE) {
$ratingoptions = new stdClass;
$ratingoptions->context = $context;
$ratingoptions->component = $component;
$ratingoptions->ratingarea = $ratingarea;
$ratingoptions->items = $items;
$ratingoptions->aggregate = $mod->assessed;
$ratingoptions->scaleid = $mod->scale;
$ratingoptions->userid = $USER->id;
$ratingoptions->assesstimestart = $mod->assesstimestart;
$ratingoptions->assesstimefinish = $mod->assesstimefinish;
$rm = new rating_manager();
$allitems = $rm->get_ratings($ratingoptions);
foreach ($allitems as $item) {
if (empty($item->rating)) {
continue;
}
$rating = [
'itemid' => $item->rating->itemid,
'scaleid' => $item->rating->scaleid,
'userid' => $item->rating->userid,
'rating' => $item->rating->rating,
'canrate' => $item->rating->user_can_rate(),
'canviewaggregate' => $item->rating->user_can_view_aggregate(),
];
// Fill the capabilities fields the first time (the rest are the same values because they are not item dependent).
if ($ratinginfo['canviewall'] === null) {
$ratinginfo['canviewall'] = $item->rating->settings->permissions->viewall &&
$item->rating->settings->pluginpermissions->viewall;
$ratinginfo['canviewany'] = $item->rating->settings->permissions->viewany &&
$item->rating->settings->pluginpermissions->viewany;
}
// Return only the information the user can see.
if ($rating['canviewaggregate']) {
$rating['aggregate'] = $item->rating->aggregate;
$rating['aggregatestr'] = $item->rating->get_aggregate_string();
$rating['aggregatelabel'] = $rm->get_aggregate_label($item->rating->settings->aggregationmethod);
$rating['count'] = $item->rating->count;
}
// If the user can rate, return the scale information only one time.
if ($rating['canrate'] &&
!empty($item->rating->settings->scale->id) &&
!isset($ratinginfo['scales'][$item->rating->settings->scale->id])) {
$scale = $item->rating->settings->scale;
// Return only non numeric scales (to avoid return lots of data just including items from 0 to $scale->max).
if (!$scale->isnumeric) {
$scaleitems = [];
foreach ($scale->scaleitems as $value => $name) {
$scaleitems[] = [
'name' => $name,
'value' => $value,
];
}
$scale->items = $scaleitems;
}
$ratinginfo['scales'][$item->rating->settings->scale->id] = (array) $scale;
}
$ratinginfo['ratings'][] = $rating;
}
}
return $ratinginfo;
}
}
rating/classes/phpunit/privacy_helper.php
+135
View File
@@ -0,0 +1,135 @@
<?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/>.
/**
* Helpers for the core_rating subsystem implementation of privacy.
*
* @package core_rating
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace core_rating\phpunit;
defined('MOODLE_INTERNAL') || die();
use \core_privacy\tests\request\content_writer;
global $CFG;
/**
* Helpers for the core_rating subsystem implementation of privacy.
*
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
trait privacy_helper {
/**
* Fetch all ratings on a subcontext.
*
* @param \context $context The context being stored.
* @param array $subcontext The subcontext path to check.
* @return \stdClass|array
*/
protected function get_ratings_on_subcontext(\context $context, array $subcontext) {
$writer = \core_privacy\local\request\writer::with_context($context);
return $writer->get_related_data($subcontext, 'rating');
}
/**
* Check that all included ratings belong to the specified user.
*
* @param int $userid The ID of the user being stored.
* @param \context $context The context being stored.
* @param array $subcontext The subcontext path to check.
* @param string $component The component being stored.
* @param string $ratingarea The rating area to store results for.
* @param int $itemid The itemid to store.
*/
protected function assert_all_own_ratings_on_context(
int $userid,
\context $context,
array $subcontext,
$component,
$ratingarea,
$itemid
) {
$writer = \core_privacy\local\request\writer::with_context($context);
$rm = new \rating_manager();
$dbratings = $rm->get_all_ratings_for_item((object) [
'context' => $context,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
]);
$exportedratings = $this->get_ratings_on_subcontext($context, $subcontext);
foreach ($exportedratings as $ratingid => $rating) {
$this->assertTrue(isset($dbratings[$ratingid]));
$this->assertEquals($userid, $rating->author);
$this->assert_rating_matches($dbratings[$ratingid], $rating);
}
foreach ($dbratings as $rating) {
if ($rating->userid == $userid) {
$this->assertEquals($rating->id, $ratingid);
}
}
}
/**
* Check that all included ratings are valid. They may belong to any user.
*
* @param \context $context The context being stored.
* @param array $subcontext The subcontext path to check.
* @param string $component The component being stored.
* @param string $ratingarea The rating area to store results for.
* @param int $itemid The itemid to store.
*/
protected function assert_all_ratings_on_context(\context $context, array $subcontext, $component, $ratingarea, $itemid) {
$writer = \core_privacy\local\request\writer::with_context($context);
$rm = new \rating_manager();
$dbratings = $rm->get_all_ratings_for_item((object) [
'context' => $context,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
]);
$exportedratings = $this->get_ratings_on_subcontext($context, $subcontext);
foreach ($exportedratings as $ratingid => $rating) {
$this->assertTrue(isset($dbratings[$ratingid]));
$this->assert_rating_matches($dbratings[$ratingid], $rating);
}
foreach ($dbratings as $rating) {
$this->assertTrue(isset($exportedratings[$rating->id]));
}
}
/**
* Assert that the rating matches.
*
* @param \stdClass $expected The expected rating structure
* @param \stdClass $stored The actual rating structure
*/
protected function assert_rating_matches($expected, $stored) {
$this->assertEquals($expected->rating, $stored->rating);
$this->assertEquals($expected->userid, $stored->author);
}
}
rating/classes/privacy/provider.php
+260
View File
@@ -0,0 +1,260 @@
<?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/>.
/**
* Privacy Subsystem implementation for core_ratings.
*
* @package core_rating
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace core_rating\privacy;
use \core_privacy\local\metadata\collection;
use \core_privacy\local\request\userlist;
defined('MOODLE_INTERNAL') || die();
require_once($CFG->dirroot . '/rating/lib.php');
/**
* Privacy Subsystem implementation for core_ratings.
*
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class provider implements
// The ratings subsystem contains data.
\core_privacy\local\metadata\provider,
// The ratings subsystem is only ever used to store data for other components.
// It does not store any data of its own and does not need to implement the \core_privacy\local\request\subsystem\provider
// as a result.
// The ratings subsystem provides a data service to other components.
\core_privacy\local\request\subsystem\plugin_provider,
\core_privacy\local\request\shared_userlist_provider
{
/**
* Returns metadata about the ratings subsystem.
*
* @param collection $collection The initialised collection to add items to.
* @return collection A listing of user data stored through the subsystem.
*/
public static function get_metadata(collection $collection): collection {
// The table 'rating' cotains data that a user has entered.
// It stores the user-entered rating alongside a mapping to describe what was mapped.
$collection->add_database_table('rating', [
'rating' => 'privacy:metadata:rating:rating',
'userid' => 'privacy:metadata:rating:userid',
'timecreated' => 'privacy:metadata:rating:timecreated',
'timemodified' => 'privacy:metadata:rating:timemodified',
], 'privacy:metadata:rating');
return $collection;
}
/**
* Export all ratings which match the specified component, areaid, and itemid.
*
* If requesting ratings for a users own content, and you wish to include all ratings of that content, specify
* $onlyuser as false.
*
* When requesting ratings for another users content, you should only export the ratings that the specified user
* made themselves.
*
* @param int $userid The user whose information is to be exported
* @param \context $context The context being stored.
* @param array $subcontext The subcontext within the context to export this information
* @param string $component The component to fetch data from
* @param string $ratingarea The ratingarea that the data was stored in within the component
* @param int $itemid The itemid within that ratingarea
* @param bool $onlyuser Whether to only export ratings that the current user has made, or all ratings
*/
public static function export_area_ratings(
int $userid,
\context $context,
array $subcontext,
string $component,
string $ratingarea,
int $itemid,
bool $onlyuser = true
) {
global $DB;
$rm = new \rating_manager();
$ratings = $rm->get_all_ratings_for_item((object) [
'context' => $context,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
]);
if ($onlyuser) {
$ratings = array_filter($ratings, function($rating) use ($userid){
return ($rating->userid == $userid);
});
}
if (empty($ratings)) {
return;
}
$toexport = array_map(function($rating) {
return (object) [
'rating' => $rating->rating,
'author' => $rating->userid,
];
}, $ratings);
$writer = \core_privacy\local\request\writer::with_context($context)
->export_related_data($subcontext, 'rating', $toexport);
}
/**
* Get the SQL required to find all submission items where this user has had any involvements.
*
* If possible an inner join should be used.
*
* @param string $alias The name of the table alias to use.
* @param string $component The na eof the component to fetch ratings for.
* @param string $ratingarea The rating area to fetch results for.
* @param string $itemidjoin The right-hand-side of the JOIN ON clause.
* @param int $userid The ID of the user being stored.
* @param bool $innerjoin Whether to use an inner join (preferred)
* @return \stdClass
*/
public static function get_sql_join($alias, $component, $ratingarea, $itemidjoin, $userid, $innerjoin = false) {
static $count = 0;
$count++;
$userwhere = '';
if ($innerjoin) {
// Join the rating table with the specified alias and the relevant join params.
$join = "JOIN {rating} {$alias} ON ";
$join .= "{$alias}.itemid = {$itemidjoin}";
$userwhere .= "{$alias}.userid = :ratinguserid{$count} AND ";
$userwhere .= "{$alias}.component = :ratingcomponent{$count} AND ";
$userwhere .= "{$alias}.ratingarea = :ratingarea{$count}";
} else {
// Join the rating table with the specified alias and the relevant join params.
$join = "LEFT JOIN {rating} {$alias} ON ";
$join .= "{$alias}.userid = :ratinguserid{$count} AND ";
$join .= "{$alias}.component = :ratingcomponent{$count} AND ";
$join .= "{$alias}.ratingarea = :ratingarea{$count} AND ";
$join .= "{$alias}.itemid = {$itemidjoin}";
// Match against the specified user.
$userwhere = "{$alias}.id IS NOT NULL";
}
$params = [
'ratingcomponent' . $count => $component,
'ratingarea' . $count => $ratingarea,
'ratinguserid' . $count => $userid,
];
$return = (object) [
'join' => $join,
'params' => $params,
'userwhere' => $userwhere,
];
return $return;
}
/**
* Deletes all ratings for a specified context, component, ratingarea and itemid.
*
* Only delete ratings when the item itself was deleted.
*
* We never delete ratings for one user but not others - this may affect grades, therefore ratings
* made by particular user are not considered personal information.
*
* @param \context $context Details about which context to delete ratings for.
* @param string $component Component to delete.
* @param string $ratingarea Rating area to delete.
* @param int $itemid The item ID for use with deletion.
*/
public static function delete_ratings(\context $context, string $component = null,
string $ratingarea = null, int $itemid = null) {
global $DB;
$options = ['contextid' => $context->id];
if ($component) {
$options['component'] = $component;
}
if ($ratingarea) {
$options['ratingarea'] = $ratingarea;
}
if ($itemid) {
$options['itemid'] = $itemid;
}
$DB->delete_records('rating', $options);
}
/**
* Deletes all tag instances for given context, component, itemtype using subquery for itemids
*
* In most situations you will want to specify $userid as null. Per-user tag instances
* are possible in Tags API, however there are no components or standard plugins that actually use them.
*
* @param \context $context Details about which context to delete ratings for.
* @param string $component Component to delete.
* @param string $ratingarea Rating area to delete.
* @param string $itemidstest an SQL fragment that the itemid must match. Used
* in the query like WHERE itemid $itemidstest. Must use named parameters,
* and may not use named parameters called contextid, component or ratingarea.
* @param array $params any query params used by $itemidstest.
*/
public static function delete_ratings_select(\context $context, string $component,
string $ratingarea, $itemidstest, $params = []) {
global $DB;
$params += ['contextid' => $context->id, 'component' => $component, 'ratingarea' => $ratingarea];
$DB->delete_records_select('rating',
'contextid = :contextid AND component = :component AND ratingarea = :ratingarea AND itemid ' . $itemidstest,
$params);
}
/**
* Add the list of users who have rated in the specified constraints.
*
* @param userlist $userlist The userlist to add the users to.
* @param string $alias An alias prefix to use for rating selects to avoid interference with your own sql.
* @param string $component The component to check.
* @param string $area The rating area to check.
* @param string $insql The SQL to use in a sub-select for the itemid query.
* @param array $params The params required for the insql.
*/
public static function get_users_in_context_from_sql(
userlist $userlist, string $alias, string $component, string $area, string $insql, $params) {
// Discussion authors.
$sql = "SELECT {$alias}.userid
FROM {rating} {$alias}
WHERE {$alias}.component = :{$alias}component
AND {$alias}.ratingarea = :{$alias}ratingarea
AND {$alias}.itemid IN ({$insql})";
$params["{$alias}component"] = $component;
$params["{$alias}ratingarea"] = $area;
$userlist->add_from_sql('userid', $sql, $params);
}
}
rating/index.php
+154
View File
@@ -0,0 +1,154 @@
<?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/>.
/**
* A page to display a list of ratings for a given item (forum post etc)
*
* @package core_rating
* @category rating
* @copyright 2010 Andrew Davis
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
require_once("../config.php");
require_once("lib.php");
$contextid = required_param('contextid', PARAM_INT);
$component = required_param('component', PARAM_COMPONENT);
$ratingarea = required_param('ratingarea', PARAM_AREA);
$itemid = required_param('itemid', PARAM_INT);
$scaleid = required_param('scaleid', PARAM_INT);
$sort = optional_param('sort', '', PARAM_ALPHA);
$popup = optional_param('popup', 0, PARAM_INT); // Any non-zero value if in a popup window.
list($context, $course, $cm) = get_context_info_array($contextid);
require_login($course, false, $cm);
$url = new moodle_url('/rating/index.php', array('contextid' => $contextid,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
'scaleid' => $scaleid));
if (!empty($sort)) {
$url->param('sort', $sort);
}
if (!empty($popup)) {
$url->param('popup', $popup);
}
$PAGE->set_url($url);
$PAGE->set_context($context);
if ($popup) {
$PAGE->set_pagelayout('popup');
}
$params = array('contextid' => $contextid,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
'scaleid' => $scaleid);
if (!has_capability('moodle/rating:view', $context) ||
!component_callback($component, 'rating_can_see_item_ratings', array($params), true)) {
throw new \moodle_exception('noviewrate', 'rating');
}
$canviewallratings = has_capability('moodle/rating:viewall', $context);
switch ($sort) {
case 'firstname':
$sqlsort = "u.firstname ASC";
break;
case 'rating':
$sqlsort = "r.rating ASC";
break;
default:
$sqlsort = "r.timemodified ASC";
}
$scalemenu = make_grades_menu($scaleid);
$strrating = get_string('rating', 'rating');
$strname = get_string('name');
$strtime = get_string('time');
$PAGE->set_title(get_string('allratingsforitem', 'rating'));
echo $OUTPUT->header();
$ratingoptions = new stdClass;
$ratingoptions->context = $context;
$ratingoptions->component = $component;
$ratingoptions->ratingarea = $ratingarea;
$ratingoptions->itemid = $itemid;
$ratingoptions->sort = $sqlsort;
$rm = new rating_manager();
$ratings = $rm->get_all_ratings_for_item($ratingoptions);
if (!$ratings) {
$msg = get_string('noratings', 'rating');
echo html_writer::tag('div', $msg, array('class' => 'mdl-align'));
} else {
// To get the sort URL, copy the current URL and remove any previous sort.
$sorturl = new moodle_url($url);
$sorturl->remove_params('sort');
$table = new html_table;
$table->cellpadding = 3;
$table->cellspacing = 3;
$table->attributes['class'] = 'generalbox ratingtable';
$table->head = array(
'',
html_writer::link(new moodle_url($sorturl, array('sort' => 'firstname')), $strname),
html_writer::link(new moodle_url($sorturl, array('sort' => 'rating')), $strrating),
html_writer::link(new moodle_url($sorturl, array('sort' => 'time')), $strtime)
);
$table->colclasses = array('', 'firstname', 'rating', 'time');
$table->data = array();
// If the scale was changed after ratings were submitted some ratings may have a value above the current maximum.
// We can't just do count($scalemenu) - 1 as custom scales start at index 1, not 0.
$maxrating = max(array_keys($scalemenu));
foreach ($ratings as $rating) {
if (!$canviewallratings and $USER->id != $rating->userid) {
continue;
}
// Undo the aliasing of the user id column from fields::get_sql().
// We could clone the rating object or preserve the rating id if we needed it again
// but we don't.
$rating->id = $rating->userid;
$row = new html_table_row();
$row->attributes['class'] = 'ratingitemheader';
if ($course && $course->id) {
$row->cells[] = $OUTPUT->user_picture($rating, array('courseid' => $course->id));
} else {
$row->cells[] = $OUTPUT->user_picture($rating);
}
$row->cells[] = fullname($rating);
if ($rating->rating > $maxrating) {
$rating->rating = $maxrating;
}
$row->cells[] = $scalemenu[$rating->rating];
$row->cells[] = userdate($rating->timemodified);
$table->data[] = $row;
}
echo html_writer::table($table);
}
if ($popup) {
echo $OUTPUT->close_window_button();
}
echo $OUTPUT->footer();
rating/lib.php
+1249
View File
File diff suppressed because it is too large Load Diff
rating/module.js
+78
View File
@@ -0,0 +1,78 @@
M.core_rating = {
Y : null,
api: M.cfg.wwwroot + '/rating/rate_ajax.php',
init : function(Y){
this.Y = Y;
Y.all('select.postratingmenu').each(this.attach_rating_events, this);
//hide the submit buttons
this.Y.all('input.postratingmenusubmit').setStyle('display', 'none');
},
attach_rating_events : function(selectnode) {
selectnode.on('change', this.submit_rating, this, selectnode);
},
submit_rating : function(e, selectnode){
var theinputs = selectnode.ancestor('form').all('.ratinginput');
var thedata = [];
var inputssize = theinputs.size();
for (var i = 0; i < inputssize; i++) {
if(theinputs.item(i).get("name") != "returnurl") { // Dont include return url for ajax requests.
thedata[theinputs.item(i).get("name")] = theinputs.item(i).get("value");
}
}
var scope = this;
var cfg = {
method: 'POST',
on: {
complete : function(tid, outcome, args) {
try {
if (!outcome) {
alert('IO FATAL');
return false;
}
var data = scope.Y.JSON.parse(outcome.responseText);
if (data.success){
//if the user has access to the aggregate then update it
if (data.itemid) { //do not test data.aggregate or data.count otherwise it doesn't refresh value=0 or no value
var itemid = data.itemid;
var node = scope.Y.one('#ratingaggregate' + itemid);
node.set('innerHTML',data.aggregate);
// Empty the count value if no ratings.
var node = scope.Y.one('#ratingcount' + itemid);
if (data.count > 0) {
node.set('innerHTML', "(" + data.count + ")");
} else {
node.set('innerHTML', "");
}
}
return true;
}
else if (data.error) {
alert(data.error);
}
} catch(e) {
alert(e.message + " " + outcome.responseText);
}
return false;
}
},
arguments: {
scope: scope
},
headers: {
},
data: build_querystring(thedata)
};
this.Y.io(this.api, cfg);
}
};
rating/rate.php
+112
View File
@@ -0,0 +1,112 @@
<?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/>.
/**
* This page receives non-ajax rating submissions
*
* It is similar to rate_ajax.php. Unlike rate_ajax.php a return url is required.
*
* @package core_rating
* @category rating
* @copyright 2010 Andrew Davis
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
require_once('../config.php');
require_once($CFG->dirroot.'/rating/lib.php');
$contextid = required_param('contextid', PARAM_INT);
$component = required_param('component', PARAM_COMPONENT);
$ratingarea = required_param('ratingarea', PARAM_AREA);
$itemid = required_param('itemid', PARAM_INT);
$scaleid = required_param('scaleid', PARAM_INT);
$userrating = required_param('rating', PARAM_INT);
$rateduserid = required_param('rateduserid', PARAM_INT); // Which user is being rated. Required to update their grade.
$returnurl = required_param('returnurl', PARAM_LOCALURL); // Required for non-ajax requests.
$result = new stdClass;
list($context, $course, $cm) = get_context_info_array($contextid);
require_login($course, false, $cm);
$contextid = null; // Now we have a context object, throw away the id from the user.
$PAGE->set_context($context);
$PAGE->set_url('/rating/rate.php', array('contextid' => $context->id));
if (!confirm_sesskey() || !has_capability('moodle/rating:rate', $context)) {
throw new \moodle_exception('ratepermissiondenied', 'rating');
}
$rm = new rating_manager();
// Check the module rating permissions.
// Doing this check here rather than within rating_manager::get_ratings() so we can choose how to handle the error.
$pluginpermissionsarray = $rm->get_plugin_permissions_array($context->id, $component, $ratingarea);
if (!$pluginpermissionsarray['rate']) {
throw new \moodle_exception('ratepermissiondenied', 'rating');
} else {
$params = array(
'context' => $context,
'component' => $component,
'ratingarea' => $ratingarea,
'itemid' => $itemid,
'scaleid' => $scaleid,
'rating' => $userrating,
'rateduserid' => $rateduserid
);
if (!$rm->check_rating_is_valid($params)) {
echo $OUTPUT->header();
echo get_string('ratinginvalid', 'rating');
echo $OUTPUT->footer();
die();
}
}
if ($userrating != RATING_UNSET_RATING) {
$ratingoptions = new stdClass;
$ratingoptions->context = $context;
$ratingoptions->component = $component;
$ratingoptions->ratingarea = $ratingarea;
$ratingoptions->itemid = $itemid;
$ratingoptions->scaleid = $scaleid;
$ratingoptions->userid = $USER->id;
$rating = new rating($ratingoptions);
$rating->update_rating($userrating);
} else { // Delete the rating if the user set to "Rate..."
$options = new stdClass;
$options->contextid = $context->id;
$options->component = $component;
$options->ratingarea = $ratingarea;
$options->userid = $USER->id;
$options->itemid = $itemid;
$rm->delete_ratings($options);
}
if (!empty($cm) && $context->contextlevel == CONTEXT_MODULE) {
// Tell the module that its grades have changed.
$modinstance = $DB->get_record($cm->modname, array('id' => $cm->instance), '*', MUST_EXIST);
$modinstance->cmidnumber = $cm->id; // MDL-12961.
$functionname = $cm->modname.'_update_grades';
require_once($CFG->dirroot."/mod/{$cm->modname}/lib.php");
if (function_exists($functionname)) {
$functionname($modinstance, $rateduserid);
}
}
redirect($returnurl);
rating/rate_ajax.php
+73
View File
@@ -0,0 +1,73 @@
<?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/>.
/**
* This page receives ajax rating submissions
*
* It is similar to rate.php. Unlike rate.php a return url is NOT required.
*
* @package core_rating
* @category rating
* @copyright 2010 Andrew Davis
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
define('AJAX_SCRIPT', true);
require_once('../config.php');
require_once($CFG->dirroot.'/rating/lib.php');
$contextid = required_param('contextid', PARAM_INT);
$component = required_param('component', PARAM_COMPONENT);
$ratingarea = required_param('ratingarea', PARAM_AREA);
$itemid = required_param('itemid', PARAM_INT);
$scaleid = required_param('scaleid', PARAM_INT);
$userrating = required_param('rating', PARAM_INT);
$rateduserid = required_param('rateduserid', PARAM_INT); // The user being rated. Required to update their grade.
$aggregationmethod = optional_param('aggregation', RATING_AGGREGATE_NONE, PARAM_INT); // Used to calculate the aggregate to return.
$result = new stdClass;
// If session has expired and its an ajax request so we cant do a page redirect.
if (!isloggedin()) {
$result->error = get_string('sessionerroruser', 'error');
echo json_encode($result);
die();
}
list($context, $course, $cm) = get_context_info_array($contextid);
require_login($course, false, $cm);
$contextid = null; // Now we have a context object, throw away the id from the user.
$PAGE->set_context($context);
$PAGE->set_url('/rating/rate_ajax.php', array('contextid' => $context->id));
if (!confirm_sesskey() || !has_capability('moodle/rating:rate', $context)) {
echo $OUTPUT->header();
echo get_string('ratepermissiondenied', 'rating');
echo $OUTPUT->footer();
die();
}
$rm = new rating_manager();
$result = $rm->add_rating($cm, $context, $component, $ratingarea, $itemid, $scaleid, $userrating, $rateduserid, $aggregationmethod);
// Return translated error.
if (!empty($result->error)) {
$result->error = get_string($result->error, 'rating');
}
echo json_encode($result);
rating/tests/externallib_test.php
+280
View File
@@ -0,0 +1,280 @@
<?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 rating functions unit tests
*
* @package core_rating
* @category external
* @copyright 2015 Costantino Cito <ccito@cvaconsulting.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace core_rating;
use core_external\external_api;
use core_rating_external;
use externallib_advanced_testcase;
defined('MOODLE_INTERNAL') || die();
global $CFG;
require_once($CFG->dirroot . '/webservice/tests/helpers.php');
require_once($CFG->dirroot . '/rating/lib.php');
/**
* External rating functions unit tests
*
* @package core_rating
* @category external
* @copyright 2015 Costantino Cito <ccito@cvaconsulting.com>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class externallib_test extends externallib_advanced_testcase {
/** @var \stdClass course record. */
protected $course;
/** @var \stdClass user record. */
protected $student1;
/** @var \stdClass user record. */
protected $teacher1;
/** @var \stdClass user record. */
protected $student2;
/** @var \stdClass user record. */
protected $teacher2;
/** @var \stdClass user record. */
protected $student3;
/** @var \stdClass user record. */
protected $teacher3;
/** @var \stdClass activity record. */
protected $forum;
/** @var \stdClass activity record. */
protected $discussion;
/** @var int context instance ID. */
protected $contextid;
/** @var \stdClass forum post. */
protected $post;
/** @var \stdClass a fieldset object, false or exception if error not found. */
protected $studentrole;
/** @var \stdClass a fieldset object, false or exception if error not found. */
protected $teacherrole;
/*
* Set up for every test
*/
public function setUp(): void {
global $DB;
$this->resetAfterTest();
$this->course = self::getDataGenerator()->create_course();
$this->student1 = $this->getDataGenerator()->create_user();
$this->student2 = $this->getDataGenerator()->create_user();
$this->teacher1 = $this->getDataGenerator()->create_user();
$this->teacher2 = $this->getDataGenerator()->create_user();
$this->teacher3 = $this->getDataGenerator()->create_user();
$this->studentrole = $DB->get_record('role', array('shortname' => 'student'));
$this->teacherrole = $DB->get_record('role', array('shortname' => 'teacher'));
unassign_capability('moodle/site:accessallgroups', $this->teacherrole->id);
$this->getDataGenerator()->enrol_user($this->student1->id, $this->course->id, $this->studentrole->id);
$this->getDataGenerator()->enrol_user($this->student2->id, $this->course->id, $this->studentrole->id);
$this->getDataGenerator()->enrol_user($this->teacher1->id, $this->course->id, $this->teacherrole->id);
$this->getDataGenerator()->enrol_user($this->teacher2->id, $this->course->id, $this->teacherrole->id);
$this->getDataGenerator()->enrol_user($this->teacher3->id, $this->course->id, $this->teacherrole->id);
// Create the forum.
$record = new \stdClass();
$record->introformat = FORMAT_HTML;
$record->course = $this->course->id;
// Set Aggregate type = Average of ratings.
$record->assessed = RATING_AGGREGATE_AVERAGE;
$record->scale = 100;
$this->forum = self::getDataGenerator()->create_module('forum', $record);
$this->contextid = \context_module::instance($this->forum->cmid)->id;
// Add discussion to the forums.
$record = new \stdClass();
$record->course = $this->course->id;
$record->userid = $this->student1->id;
$record->forum = $this->forum->id;
$this->discussion = self::getDataGenerator()->get_plugin_generator('mod_forum')->create_discussion($record);
// Retrieve the first post.
$this->post = $DB->get_record('forum_posts', array('discussion' => $this->discussion->id));
}
/**
* Test get_item_ratings
*/
public function test_get_item_ratings(): void {
global $DB;
// Rete the discussion as teacher1.
$rating1 = new \stdClass();
$rating1->contextid = $this->contextid;
$rating1->component = 'mod_forum';
$rating1->ratingarea = 'post';
$rating1->itemid = $this->post->id;
$rating1->rating = 90;
$rating1->scaleid = 100;
$rating1->userid = $this->teacher1->id;
$rating1->timecreated = time();
$rating1->timemodified = time();
$rating1->id = $DB->insert_record('rating', $rating1);
// Rete the discussion as teacher2.
$rating2 = new \stdClass();
$rating2->contextid = $this->contextid;
$rating2->component = 'mod_forum';
$rating2->ratingarea = 'post';
$rating2->itemid = $this->post->id;
$rating2->rating = 95;
$rating2->scaleid = 100;
$rating2->userid = $this->teacher2->id;
$rating2->timecreated = time() + 1;
$rating2->timemodified = time() + 1;
$rating2->id = $DB->insert_record('rating', $rating2);
// Delete teacher2, we must still receive the ratings.
delete_user($this->teacher2);
// Teachers can see all the ratings.
$this->setUser($this->teacher1);
$ratings = core_rating_external::get_item_ratings('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100, '');
// We need to execute the return values cleaning process to simulate the web service server.
$ratings = external_api::clean_returnvalue(core_rating_external::get_item_ratings_returns(), $ratings);
$this->assertCount(2, $ratings['ratings']);
$indexedratings = array();
foreach ($ratings['ratings'] as $rating) {
$indexedratings[$rating['id']] = $rating;
}
$this->assertEquals($rating1->rating.' / '.$rating1->scaleid, $indexedratings[$rating1->id]['rating']);
$this->assertEquals($rating2->rating.' / '.$rating2->scaleid, $indexedratings[$rating2->id]['rating']);
$this->assertEquals($rating1->userid, $indexedratings[$rating1->id]['userid']);
$this->assertEquals($rating2->userid, $indexedratings[$rating2->id]['userid']);
// Student can see ratings.
$this->setUser($this->student1);
$ratings = core_rating_external::get_item_ratings('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100, '');
// We need to execute the return values cleaning process to simulate the web service server.
$ratings = external_api::clean_returnvalue(core_rating_external::get_item_ratings_returns(), $ratings);
$this->assertCount(2, $ratings['ratings']);
// Invalid item.
try {
$ratings = core_rating_external::get_item_ratings('module', $this->forum->cmid, 'mod_forum', 'post', 0, 100, '');
$this->fail('Exception expected due invalid itemid.');
} catch (\moodle_exception $e) {
$this->assertEquals('invalidrecord', $e->errorcode);
}
// Invalid area.
try {
$ratings = core_rating_external::get_item_ratings('module', $this->forum->cmid, 'mod_forum', 'xyz', $this->post->id, 100, '');
$this->fail('Exception expected due invalid rating area.');
} catch (\moodle_exception $e) {
$this->assertEquals('invalidratingarea', $e->errorcode);
}
// Invalid context. invalid_parameter_exception.
try {
$ratings = core_rating_external::get_item_ratings('module', 0, 'mod_forum', 'post', $this->post->id, 100, '');
$this->fail('Exception expected due invalid context.');
} catch (\invalid_parameter_exception $e) {
$this->assertEquals('invalidparameter', $e->errorcode);
}
// Test for groupmode.
set_coursemodule_groupmode($this->forum->cmid, SEPARATEGROUPS);
$group = $this->getDataGenerator()->create_group(array('courseid' => $this->course->id));
groups_add_member($group, $this->teacher1);
$this->discussion->groupid = $group->id;
$DB->update_record('forum_discussions', $this->discussion);
// Error for teacher3 and 2 ratings for teacher1 should be returned.
$this->setUser($this->teacher1);
$ratings = core_rating_external::get_item_ratings('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100, '');
// We need to execute the return values cleaning process to simulate the web service server.
$ratings = external_api::clean_returnvalue(core_rating_external::get_item_ratings_returns(), $ratings);
$this->assertCount(2, $ratings['ratings']);
$this->setUser($this->teacher3);
try {
$ratings = core_rating_external::get_item_ratings('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100, '');
$this->fail('Exception expected due invalid group permissions.');
} catch (\moodle_exception $e) {
$this->assertEquals('noviewrate', $e->errorcode);
}
}
/**
* Test add_rating
*/
public function test_add_rating(): void {
$this->setUser($this->teacher1);
// First rating of 50.
$rating = core_rating_external::add_rating('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100,
50, $this->student1->id, RATING_AGGREGATE_AVERAGE);
// We need to execute the return values cleaning process to simulate the web service server.
$rating = external_api::clean_returnvalue(core_rating_external::add_rating_returns(), $rating);
$this->assertTrue($rating['success']);
$this->assertEquals(50, $rating['aggregate']);
$this->assertEquals(1, $rating['count']);
// New different rate (it will replace the existing one).
$rating = core_rating_external::add_rating('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100,
100, $this->student1->id, RATING_AGGREGATE_AVERAGE);
$rating = external_api::clean_returnvalue(core_rating_external::add_rating_returns(), $rating);
$this->assertTrue($rating['success']);
$this->assertEquals(100, $rating['aggregate']);
$this->assertEquals(1, $rating['count']);
// Rate as other user.
$this->setUser($this->teacher2);
$rating = core_rating_external::add_rating('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100,
50, $this->student1->id, RATING_AGGREGATE_AVERAGE);
$rating = external_api::clean_returnvalue(core_rating_external::add_rating_returns(), $rating);
$this->assertEquals(75, $rating['aggregate']);
$this->assertEquals(2, $rating['count']);
// Try to rate my own post.
$this->setUser($this->student1);
$this->expectException('moodle_exception');
$this->expectExceptionMessage(get_string('ratepermissiondenied', 'rating'));
$rating = core_rating_external::add_rating('module', $this->forum->cmid, 'mod_forum', 'post', $this->post->id, 100,
100, $this->student1->id, RATING_AGGREGATE_AVERAGE);
}
}
rating/tests/privacy/provider_test.php
+442
View File
@@ -0,0 +1,442 @@
<?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/>.
/**
* Unit tests for the core_rating implementation of the Privacy API.
*
* @package core_rating
* @category test
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
namespace core_rating\privacy;
defined('MOODLE_INTERNAL') || die();
global $CFG;
require_once($CFG->dirroot . '/rating/lib.php');
use core_rating\privacy\provider;
use core_privacy\local\request\writer;
/**
* Unit tests for the core_rating implementation of the Privacy API.
*
* @copyright 2018 Andrew Nicols <andrew@nicols.co.uk>
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class provider_test extends \core_privacy\tests\provider_testcase {
/**
* Rate something as a user.
*
* @param int $userid
* @param string $component
* @param string $ratingarea
* @param int $itemid
* @param \context $context
* @param string $score
*/
protected function rate_as_user($userid, $component, $ratingarea, $itemid, $context, $score) {
// Rate the courses.
$rm = new \rating_manager();
$ratingoptions = (object) [
'component' => $component,
'ratingarea' => $ratingarea,
'scaleid' => 100,
];
// Rate all courses as u1, and the course category too..
$ratingoptions->itemid = $itemid;
$ratingoptions->userid = $userid;
$ratingoptions->context = $context;
$rating = new \rating($ratingoptions);
$rating->update_rating($score);
}
/**
* Ensure that the get_sql_join function returns valid SQL which returns the correct list of rated itemids.
*/
public function test_get_sql_join(): void {
global $DB;
$this->resetAfterTest();
$course1 = $this->getDataGenerator()->create_course();
$course2 = $this->getDataGenerator()->create_course();
$course3 = $this->getDataGenerator()->create_course();
$u1 = $this->getDataGenerator()->create_user();
$u2 = $this->getDataGenerator()->create_user();
$u3 = $this->getDataGenerator()->create_user();
// Rate the courses.
$rm = new \rating_manager();
$ratingoptions = (object) [
'component' => 'core_course',
'ratingarea' => 'course',
'scaleid' => 100,
];
// Rate all courses as u1, and something else in the same context.
$this->rate_as_user($u1->id, 'core_course', 'course', $course1->id, \context_course::instance($course1->id), 25);
$this->rate_as_user($u1->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 50);
$this->rate_as_user($u1->id, 'core_course', 'course', $course3->id, \context_course::instance($course3->id), 75);
$this->rate_as_user($u1->id, 'core_course', 'files', $course3->id, \context_course::instance($course3->id), 99);
// Rate course2 as u2, and something else in a different context/component..
$this->rate_as_user($u2->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 90);
$this->rate_as_user($u2->id, 'user', 'user', $u3->id, \context_user::instance($u3->id), 10);
// Return any course which the u1 has rated.
// u1 rated all three courses.
$ratingquery = provider::get_sql_join('r', 'core_course', 'course', 'c.id', $u1->id);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(3, $courses);
$this->assertTrue(isset($courses[$course1->id]));
$this->assertTrue(isset($courses[$course2->id]));
$this->assertTrue(isset($courses[$course3->id]));
// User u1 rated files in course 3 only.
$ratingquery = provider::get_sql_join('r', 'core_course', 'files', 'c.id', $u1->id);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(1, $courses);
$this->assertFalse(isset($courses[$course1->id]));
$this->assertFalse(isset($courses[$course2->id]));
$this->assertTrue(isset($courses[$course3->id]));
// Return any course which the u2 has rated.
// User u2 rated only course 2.
$ratingquery = provider::get_sql_join('r', 'core_course', 'course', 'c.id', $u2->id);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(1, $courses);
$this->assertFalse(isset($courses[$course1->id]));
$this->assertTrue(isset($courses[$course2->id]));
$this->assertFalse(isset($courses[$course3->id]));
// User u2 rated u3.
$ratingquery = provider::get_sql_join('r', 'user', 'user', 'u.id', $u2->id);
$sql = "SELECT u.id FROM {user} u {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$users = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(1, $users);
$this->assertFalse(isset($users[$u1->id]));
$this->assertFalse(isset($users[$u2->id]));
$this->assertTrue(isset($users[$u3->id]));
// Return any course which the u3 has rated.
// User u3 did not rate anything.
$ratingquery = provider::get_sql_join('r', 'core_course', 'course', 'c.id', $u3->id);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(0, $courses);
$this->assertFalse(isset($courses[$course1->id]));
$this->assertFalse(isset($courses[$course2->id]));
$this->assertFalse(isset($courses[$course3->id]));
}
/**
* Ensure that the get_sql_join function returns valid SQL which returns the correct list of rated itemids.
* This makes use of the optional inner join argument.
*/
public function test_get_sql_join_inner(): void {
global $DB;
$this->resetAfterTest();
$course1 = $this->getDataGenerator()->create_course();
$course2 = $this->getDataGenerator()->create_course();
$course3 = $this->getDataGenerator()->create_course();
$u1 = $this->getDataGenerator()->create_user();
$u2 = $this->getDataGenerator()->create_user();
$u3 = $this->getDataGenerator()->create_user();
// Rate the courses.
$rm = new \rating_manager();
$ratingoptions = (object) [
'component' => 'core_course',
'ratingarea' => 'course',
'scaleid' => 100,
];
// Rate all courses as u1, and something else in the same context.
$this->rate_as_user($u1->id, 'core_course', 'course', $course1->id, \context_course::instance($course1->id), 25);
$this->rate_as_user($u1->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 50);
$this->rate_as_user($u1->id, 'core_course', 'course', $course3->id, \context_course::instance($course3->id), 75);
$this->rate_as_user($u1->id, 'core_course', 'files', $course3->id, \context_course::instance($course3->id), 99);
// Rate course2 as u2, and something else in a different context/component..
$this->rate_as_user($u2->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 90);
$this->rate_as_user($u2->id, 'user', 'user', $u3->id, \context_user::instance($u3->id), 10);
// Return any course which the u1 has rated.
// u1 rated all three courses.
$ratingquery = provider::get_sql_join('r', 'core_course', 'course', 'c.id', $u1->id, true);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(3, $courses);
$this->assertTrue(isset($courses[$course1->id]));
$this->assertTrue(isset($courses[$course2->id]));
$this->assertTrue(isset($courses[$course3->id]));
// User u1 rated files in course 3 only.
$ratingquery = provider::get_sql_join('r', 'core_course', 'files', 'c.id', $u1->id, true);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(1, $courses);
$this->assertFalse(isset($courses[$course1->id]));
$this->assertFalse(isset($courses[$course2->id]));
$this->assertTrue(isset($courses[$course3->id]));
// Return any course which the u2 has rated.
// User u2 rated only course 2.
$ratingquery = provider::get_sql_join('r', 'core_course', 'course', 'c.id', $u2->id, true);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(1, $courses);
$this->assertFalse(isset($courses[$course1->id]));
$this->assertTrue(isset($courses[$course2->id]));
$this->assertFalse(isset($courses[$course3->id]));
// User u2 rated u3.
$ratingquery = provider::get_sql_join('r', 'user', 'user', 'u.id', $u2->id, true);
$sql = "SELECT u.id FROM {user} u {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$users = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(1, $users);
$this->assertFalse(isset($users[$u1->id]));
$this->assertFalse(isset($users[$u2->id]));
$this->assertTrue(isset($users[$u3->id]));
// Return any course which the u3 has rated.
// User u3 did not rate anything.
$ratingquery = provider::get_sql_join('r', 'core_course', 'course', 'c.id', $u3->id, true);
$sql = "SELECT c.id FROM {course} c {$ratingquery->join} WHERE {$ratingquery->userwhere}";
$courses = $DB->get_records_sql($sql, $ratingquery->params);
$this->assertCount(0, $courses);
$this->assertFalse(isset($courses[$course1->id]));
$this->assertFalse(isset($courses[$course2->id]));
$this->assertFalse(isset($courses[$course3->id]));
}
/**
* Ensure that export_area_ratings exports all ratings that a user has made, and all ratings for a users own content.
*/
public function test_export_area_ratings(): void {
global $DB;
$this->resetAfterTest();
$course1 = $this->getDataGenerator()->create_course();
$course2 = $this->getDataGenerator()->create_course();
$course3 = $this->getDataGenerator()->create_course();
$u1 = $this->getDataGenerator()->create_user();
$u2 = $this->getDataGenerator()->create_user();
$u3 = $this->getDataGenerator()->create_user();
// Rate the courses.
$rm = new \rating_manager();
$ratingoptions = (object) [
'component' => 'core_course',
'ratingarea' => 'course',
'scaleid' => 100,
];
// Rate all courses as u1, and something else in the same context.
$this->rate_as_user($u1->id, 'core_course', 'course', $course1->id, \context_course::instance($course1->id), 25);
$this->rate_as_user($u1->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 50);
$this->rate_as_user($u1->id, 'core_course', 'course', $course3->id, \context_course::instance($course3->id), 75);
$this->rate_as_user($u1->id, 'core_course', 'files', $course3->id, \context_course::instance($course3->id), 99);
$this->rate_as_user($u1->id, 'user', 'user', $u3->id, \context_user::instance($u3->id), 10);
// Rate course2 as u2, and something else in a different context/component..
$this->rate_as_user($u2->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 90);
$this->rate_as_user($u2->id, 'user', 'user', $u3->id, \context_user::instance($u3->id), 20);
// Test exports.
// User 1 rated all three courses, and the core_course, and user 3.
// User 1::course1 is stored in [] subcontext.
$context = \context_course::instance($course1->id);
$subcontext = [];
provider::export_area_ratings($u1->id, $context, $subcontext, 'core_course', 'course', $course1->id, true);
/** @var \core_privacy\tests\request\content_writer $writer */
$writer = writer::with_context($context);
$this->assertTrue($writer->has_any_data());
$rating = $writer->get_related_data($subcontext, 'rating');
$this->assert_has_rating($u1, 25, $rating);
// User 1::course2 is stored in ['foo'] subcontext.
$context = \context_course::instance($course2->id);
$subcontext = ['foo'];
provider::export_area_ratings($u1->id, $context, $subcontext, 'core_course', 'course', $course2->id, true);
/** @var \core_privacy\tests\request\content_writer $writer */
$writer = writer::with_context($context);
$this->assertTrue($writer->has_any_data());
$result = $writer->get_related_data($subcontext, 'rating');
$this->assertCount(1, $result);
$this->assert_has_rating($u1, 50, $result);
// User 1::course3 is stored in ['foo'] subcontext.
$context = \context_course::instance($course3->id);
$subcontext = ['foo'];
provider::export_area_ratings($u1->id, $context, $subcontext, 'core_course', 'course', $course3->id, true);
/** @var \core_privacy\tests\request\content_writer $writer */
$writer = writer::with_context($context);
$this->assertTrue($writer->has_any_data());
$result = $writer->get_related_data($subcontext, 'rating');
$this->assertCount(1, $result);
$this->assert_has_rating($u1, 75, $result);
// User 1::course3::files is stored in ['foo', 'files'] subcontext.
$context = \context_course::instance($course3->id);
$subcontext = ['foo', 'files'];
provider::export_area_ratings($u1->id, $context, $subcontext, 'core_course', 'files', $course3->id, true);
/** @var \core_privacy\tests\request\content_writer $writer */
$writer = writer::with_context($context);
$this->assertTrue($writer->has_any_data());
$result = $writer->get_related_data($subcontext, 'rating');
$this->assertCount(1, $result);
$this->assert_has_rating($u1, 99, $result);
// Both users 1 and 2 rated user 3.
// Exporting the data for user 3 should include both of those ratings.
$context = \context_user::instance($u3->id);
$subcontext = ['user'];
provider::export_area_ratings($u3->id, $context, $subcontext, 'user', 'user', $u3->id, false);
/** @var \core_privacy\tests\request\content_writer $writer */
$writer = writer::with_context($context);
$this->assertTrue($writer->has_any_data());
$result = $writer->get_related_data($subcontext, 'rating');
$this->assertCount(2, $result);
$this->assert_has_rating($u1, 10, $result);
$this->assert_has_rating($u2, 20, $result);
}
/**
* Test delete_ratings() method.
*/
public function test_delete_ratings(): void {
global $DB;
$this->resetAfterTest();
$course1 = $this->getDataGenerator()->create_course();
$course2 = $this->getDataGenerator()->create_course();
$course3 = $this->getDataGenerator()->create_course();
$u1 = $this->getDataGenerator()->create_user();
$u2 = $this->getDataGenerator()->create_user();
$u3 = $this->getDataGenerator()->create_user();
// Rate all courses as u1, and something else in the same context.
$this->rate_as_user($u1->id, 'core_course', 'course', $course1->id, \context_course::instance($course1->id), 25);
$this->rate_as_user($u1->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 50);
$this->rate_as_user($u1->id, 'core_course', 'course', $course3->id, \context_course::instance($course3->id), 75);
$this->rate_as_user($u1->id, 'core_course', 'files', $course3->id, \context_course::instance($course3->id), 99);
$this->rate_as_user($u1->id, 'core_user', 'user', $u3->id, \context_user::instance($u3->id), 10);
// Rate course2 as u2, and something else in a different context/component..
$this->rate_as_user($u2->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 90);
$this->rate_as_user($u2->id, 'core_user', 'user', $u3->id, \context_user::instance($u3->id), 20);
// Delete all ratings in course1.
$expectedratingscount = $DB->count_records('rating');
provider::delete_ratings(\context_course::instance($course1->id));
$expectedratingscount -= 1;
$this->assertEquals($expectedratingscount, $DB->count_records('rating'));
// Delete ratings in course2 specifying wrong component.
provider::delete_ratings(\context_course::instance($course2->id), 'other_component');
$this->assertEquals($expectedratingscount, $DB->count_records('rating'));
// Delete ratings in course2 specifying correct component.
provider::delete_ratings(\context_course::instance($course2->id), 'core_course');
$expectedratingscount -= 2;
$this->assertEquals($expectedratingscount, $DB->count_records('rating'));
// Delete user ratings specifyng all attributes.
provider::delete_ratings(\context_user::instance($u3->id), 'core_user', 'user', $u3->id);
$expectedratingscount -= 2;
$this->assertEquals($expectedratingscount, $DB->count_records('rating'));
}
/**
* Test delete_ratings_select() method.
*/
public function test_delete_ratings_select(): void {
global $DB;
$this->resetAfterTest();
$course1 = $this->getDataGenerator()->create_course();
$course2 = $this->getDataGenerator()->create_course();
$course3 = $this->getDataGenerator()->create_course();
$u1 = $this->getDataGenerator()->create_user();
$u2 = $this->getDataGenerator()->create_user();
$u3 = $this->getDataGenerator()->create_user();
// Rate all courses as u1, and something else in the same context.
$this->rate_as_user($u1->id, 'core_course', 'course', $course1->id, \context_course::instance($course1->id), 25);
$this->rate_as_user($u1->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 50);
$this->rate_as_user($u1->id, 'core_course', 'course', $course3->id, \context_course::instance($course3->id), 75);
$this->rate_as_user($u1->id, 'core_course', 'files', $course3->id, \context_course::instance($course3->id), 99);
$this->rate_as_user($u1->id, 'core_user', 'user', $u3->id, \context_user::instance($u3->id), 10);
// Rate course2 as u2, and something else in a different context/component..
$this->rate_as_user($u2->id, 'core_course', 'course', $course2->id, \context_course::instance($course2->id), 90);
$this->rate_as_user($u2->id, 'core_user', 'user', $u3->id, \context_user::instance($u3->id), 20);
// Delete ratings in course1.
list($sql, $params) = $DB->get_in_or_equal([$course1->id, $course2->id], SQL_PARAMS_NAMED);
$expectedratingscount = $DB->count_records('rating');
provider::delete_ratings_select(\context_course::instance($course1->id),
'core_course', 'course', $sql, $params);
$expectedratingscount -= 1;
$this->assertEquals($expectedratingscount, $DB->count_records('rating'));
}
/**
* Assert that a user has the correct rating.
*
* @param \stdClass $author The user with the rating
* @param int $score The rating that was given
* @param \stdClass[] The ratings which were found
*/
protected function assert_has_rating($author, $score, $actual) {
$found = false;
foreach ($actual as $rating) {
if ($author->id == $rating->author) {
$found = true;
$this->assertEquals($score, $rating->rating);
}
}
$this->assertTrue($found);
}
}
rating/tests/rating_test.php
+385
View File
@@ -0,0 +1,385 @@
<?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/>.
namespace core_rating;
use rating_manager;
defined('MOODLE_INTERNAL') || die();
// Include all the needed stuff.
global $CFG;
require_once($CFG->dirroot . '/rating/lib.php');
/**
* Unit test case for all the rating/lib.php requiring DB mockup & manipulation
*
* @package core_rating
* @category test
* @copyright 2011 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
* @covers \rating
*/
class rating_test extends \advanced_testcase {
protected $syscontext;
protected $neededcaps = array('view', 'viewall', 'viewany', 'rate');
protected $originaldefaultfrontpageroleid;
public function setUp(): void {
global $CFG;
parent::setUp();
$this->resetAfterTest(true);
$CFG->defaultfrontpageroleid = null;
}
/**
* Test the current get_ratings method main sql
*/
public function test_get_ratings_sql(): void {
global $DB;
// We load 3 items. Each is rated twice. For simplicity itemid == user id of the item owner.
$ctxid = \context_system::instance()->id;
$ratings = array(
// User 1's items. Average == 2.
array('contextid' => $ctxid,
'component' => 'mod_forum',
'ratingarea' => 'post',
'itemid' => 1,
'scaleid' => 10,
'rating' => 1,
'userid' => 2,
'timecreated' => 1,
'timemodified' => 1),
array('contextid' => $ctxid,
'component' => 'mod_forum',
'ratingarea' => 'post',
'itemid' => 1,
'scaleid' => 10,
'rating' => 3,
'userid' => 3,
'timecreated' => 1,
'timemodified' => 1),
// User 2's items. Average == 3.
array('contextid' => $ctxid,
'component' => 'mod_forum',
'ratingarea' => 'post',
'itemid' => 2,
'scaleid' => 10,
'rating' => 1,
'userid' => 1,
'timecreated' => 1,
'timemodified' => 1),
array('contextid' => $ctxid,
'component' => 'mod_forum',
'ratingarea' => 'post',
'itemid' => 2,
'scaleid' => 10,
'rating' => 4,
'userid' => 3,
'timecreated' => 1,
'timemodified' => 1),
// User 3's items. Average == 4.
array('contextid' => $ctxid,
'component' => 'mod_forum',
'ratingarea' => 'post',
'itemid' => 3,
'scaleid' => 10,
'rating' => 3,
'userid' => 1,
'timecreated' => 1,
'timemodified' => 1),
array('contextid' => $ctxid,
'component' => 'mod_forum',
'ratingarea' => 'post',
'itemid' => 3,
'scaleid' => 10,
'rating' => 5,
'userid' => 2,
'timecreated' => 1,
'timemodified' => 1)
);
foreach ($ratings as $rating) {
$DB->insert_record('rating', $rating);
}
// A post (item) by user 1 (rated above by user 2 and 3 with average = 2).
$user1posts = array(
(object)array('id' => 1, 'userid' => 1, 'message' => 'hello'));
// A post (item) by user 2 (rated above by user 1 and 3 with average = 3).
$user2posts = array(
(object)array('id' => 2, 'userid' => 2, 'message' => 'world'));
// A post (item) by user 3 (rated above by user 1 and 2 with average = 4).
$user3posts = array(
(object)array('id' => 3, 'userid' => 3, 'message' => 'moodle'));
// Prepare the default options.
$defaultoptions = array (
'context' => \context_system::instance(),
'component' => 'mod_forum',
'ratingarea' => 'post',
'scaleid' => 10,
'aggregate' => RATING_AGGREGATE_AVERAGE);
$rm = new mockup_rating_manager();
// STEP 1: Retreive ratings using the current user.
// Get results for user 1's item (expected average 1 + 3 / 2 = 2).
$toptions = (object)array_merge($defaultoptions, array('items' => $user1posts));
$result = $rm->get_ratings($toptions);
$this->assertEquals(count($result), count($user1posts));
$this->assertEquals($result[0]->id, $user1posts[0]->id);
$this->assertEquals($result[0]->userid, $user1posts[0]->userid);
$this->assertEquals($result[0]->message, $user1posts[0]->message);
$this->assertEquals($result[0]->rating->count, 2);
$this->assertEquals($result[0]->rating->aggregate, 2);
// Note that $result[0]->rating->rating is somewhat random.
// We didn't supply a user ID so $USER was used which will vary depending on who runs the tests.
// Get results for items of user 2 (expected average 1 + 4 / 2 = 2.5).
$toptions = (object)array_merge($defaultoptions, array('items' => $user2posts));
$result = $rm->get_ratings($toptions);
$this->assertEquals(count($result), count($user2posts));
$this->assertEquals($result[0]->id, $user2posts[0]->id);
$this->assertEquals($result[0]->userid, $user2posts[0]->userid);
$this->assertEquals($result[0]->message, $user2posts[0]->message);
$this->assertEquals($result[0]->rating->count, 2);
$this->assertEquals($result[0]->rating->aggregate, 2.5);
// Note that $result[0]->rating->rating is somewhat random.
// We didn't supply a user ID so $USER was used which will vary depending on who runs the tests.
// Get results for items of user 3 (expected average 3 + 5 / 2 = 4).
$toptions = (object)array_merge($defaultoptions, array('items' => $user3posts));
$result = $rm->get_ratings($toptions);
$this->assertEquals(count($result), count($user3posts));
$this->assertEquals($result[0]->id, $user3posts[0]->id);
$this->assertEquals($result[0]->userid, $user3posts[0]->userid);
$this->assertEquals($result[0]->message, $user3posts[0]->message);
$this->assertEquals($result[0]->rating->count, 2);
$this->assertEquals($result[0]->rating->aggregate, 4);
// Note that $result[0]->rating->rating is somewhat random.
// We didn't supply a user ID so $USER was used which will vary depending on who runs the tests.
// Get results for items of user 1 & 2 together (expected averages are 2 and 2.5, as tested above).
$posts = array_merge($user1posts, $user2posts);
$toptions = (object)array_merge($defaultoptions, array('items' => $posts));
$result = $rm->get_ratings($toptions);
$this->assertEquals(count($result), count($posts));
$this->assertEquals($result[0]->id, $posts[0]->id);
$this->assertEquals($result[0]->userid, $posts[0]->userid);
$this->assertEquals($result[0]->message, $posts[0]->message);
$this->assertEquals($result[0]->rating->count, 2);
$this->assertEquals($result[0]->rating->aggregate, 2);
// Note that $result[0]->rating->rating is somewhat random.
// We didn't supply a user ID so $USER was used which will vary depending on who runs the tests.
$this->assertEquals($result[1]->id, $posts[1]->id);
$this->assertEquals($result[1]->userid, $posts[1]->userid);
$this->assertEquals($result[1]->message, $posts[1]->message);
$this->assertEquals($result[1]->rating->count, 2);
$this->assertEquals($result[1]->rating->aggregate, 2.5);
// Note that $result[0]->rating->rating is somewhat random.
// We didn't supply a user ID so $USER was used which will vary depending on who runs the tests.
// STEP 2: Retrieve ratings by a specified user.
// We still expect complete aggregations and counts.
// Get results for items of user 1 rated by user 2 (avg 2, rating 1).
$toptions = (object)array_merge($defaultoptions, array('items' => $user1posts, 'userid' => 2));
$result = $rm->get_ratings($toptions);
$this->assertEquals(count($result), count($user1posts));
$this->assertEquals($result[0]->id, $user1posts[0]->id);
$this->assertEquals($result[0]->userid, $user1posts[0]->userid);
$this->assertEquals($result[0]->message, $user1posts[0]->message);
$this->assertEquals($result[0]->rating->count, 2);
$this->assertEquals($result[0]->rating->aggregate, 2);
$this->assertEquals($result[0]->rating->rating, 1); // User 2 rated user 1 "1".
$this->assertEquals($result[0]->rating->userid, $toptions->userid); // Must be the passed userid.
// Get results for items of user 1 rated by user 3.
$toptions = (object)array_merge($defaultoptions, array('items' => $user1posts, 'userid' => 3));
$result = $rm->get_ratings($toptions);
$this->assertEquals(count($result), count($user1posts));
$this->assertEquals($result[0]->id, $user1posts[0]->id);
$this->assertEquals($result[0]->userid, $user1posts[0]->userid);
$this->assertEquals($result[0]->message, $user1posts[0]->message);
$this->assertEquals($result[0]->rating->count, 2);
$this->assertEquals($result[0]->rating->aggregate, 2);
$this->assertEquals($result[0]->rating->rating, 3); // User 3 rated user 1 "3".
$this->assertEquals($result[0]->rating->userid, $toptions->userid); // Must be the passed userid.
// Get results for items of user 1 & 2 together rated by user 3.
$posts = array_merge($user1posts, $user2posts);
$toptions = (object)array_merge($defaultoptions, array('items' => $posts, 'userid' => 3));
$result = $rm->get_ratings($toptions);
$this->assertEquals(count($result), count($posts));
$this->assertEquals($result[0]->id, $posts[0]->id);
$this->assertEquals($result[0]->userid, $posts[0]->userid);
$this->assertEquals($result[0]->message, $posts[0]->message);
$this->assertEquals($result[0]->rating->count, 2);
$this->assertEquals($result[0]->rating->aggregate, 2);
$this->assertEquals($result[0]->rating->rating, 3); // User 3 rated user 1 "3".
$this->assertEquals($result[0]->rating->userid, $toptions->userid); // Must be the passed userid.
$this->assertEquals($result[1]->id, $posts[1]->id);
$this->assertEquals($result[1]->userid, $posts[1]->userid);
$this->assertEquals($result[1]->message, $posts[1]->message);
$this->assertEquals($result[1]->rating->count, 2);
$this->assertEquals($result[1]->rating->aggregate, 2.5);
$this->assertEquals($result[0]->rating->rating, 3); // User 3 rated user 2 "5".
$this->assertEquals($result[1]->rating->userid, $toptions->userid); // Must be the passed userid.
// STEP 3: Some special cases.
// Get results for user 1's items (expected average 1 + 3 / 2 = 2).
// Supplying a non-existent user id so no rating from that user should be found.
$toptions = (object)array_merge($defaultoptions, array('items' => $user1posts));
$toptions->userid = 123456; // Non-existent user.
$result = $rm->get_ratings($toptions);
$this->assertNull($result[0]->rating->userid);
$this->assertNull($result[0]->rating->rating);
$this->assertEquals($result[0]->rating->aggregate, 2); // Should still get the aggregate.
// Get results for items of user 2 (expected average 1 + 4 / 2 = 2.5).
// Supplying the user id of the user who owns the items so no rating should be found.
$toptions = (object)array_merge($defaultoptions, array('items' => $user2posts));
$toptions->userid = 2; // User 2 viewing the ratings of their own item.
$result = $rm->get_ratings($toptions);
// These should be null as the user is viewing their own item and thus cannot rate.
$this->assertNull($result[0]->rating->userid);
$this->assertNull($result[0]->rating->rating);
$this->assertEquals($result[0]->rating->aggregate, 2.5); // Should still get the aggregate.
}
/**
* Data provider for get_aggregate_string tests.
*
* @return array
*/
public function get_aggregate_string_provider() {
return [
'Non-numeric aggregate produces empty string' => [
RATING_AGGREGATE_NONE,
'string',
null,
['Foo', 'Bar'],
'',
],
'Aggregate count produces empty string' => [
RATING_AGGREGATE_COUNT,
0,
null,
['Foo', 'Bar'],
'',
],
'Numeric SUM with non-numeric scale produces returns original value' => [
RATING_AGGREGATE_SUM,
10,
false,
['Foo', 'Bar'],
'10',
],
'Numeric SUM with non-numeric scale produces returns rounded value' => [
RATING_AGGREGATE_SUM,
10.45,
false,
['Foo', 'Bar'],
'10.5',
],
'Numeric SUM with numeric scale produces returns rounded value' => [
RATING_AGGREGATE_SUM,
10.45,
true,
['Foo', 'Bar'],
'10.5',
],
'Numeric AVERAGE with numeric scale produces returns rounded value' => [
RATING_AGGREGATE_AVERAGE,
10.45,
true,
['Foo', 'Bar'],
'10.5',
],
'Numeric AVERAGE with non-numeric scale produces returns indexed value (0)' => [
RATING_AGGREGATE_AVERAGE,
0,
false,
['Foo', 'Bar'],
'Foo',
],
'Numeric AVERAGE with non-numeric scale produces returns indexed value (1)' => [
RATING_AGGREGATE_AVERAGE,
1,
false,
['Foo', 'Bar'],
'Bar',
],
];
}
/**
* Test the value returned by get_aggregate_string().
*
* @dataProvider get_aggregate_string_provider
*/
public function test_get_aggregate_string($method, $aggregate, $isnumeric, $scaleitems, $expectation): void {
$options = new \stdClass();
$options->aggregate = $aggregate;
$options->context = null;
$options->component = null;
$options->ratingarea = null;
$options->itemid = null;
$options->scaleid = null;
$options->userid = null;
$options->settings = new \stdClass();
$options->settings->aggregationmethod = $method;
$options->settings->scale = new \stdClass();
$options->settings->scale->isnumeric = $isnumeric;
$options->settings->scale->scaleitems = $scaleitems;
$rating = new \rating($options);
$this->assertEquals($expectation, $rating->get_aggregate_string());
}
}
/**
* rating_manager subclass for unit testing without requiring capabilities to be loaded
*/
class mockup_rating_manager extends rating_manager {
/**
* Overwrite get_plugin_permissions_array() so it always return granted perms for unit testing
*/
public function get_plugin_permissions_array($contextid, $component, $ratingarea) {
return array(
'rate' => true,
'view' => true,
'viewany' => true,
'viewall' => true);
}
}