mirror of
https://github.com/moodle/moodle.git
synced 2025-01-19 14:27:22 +01:00
5afac432f5
Note this fixes the unit tests. Still the calendar API itself should be able to manage this cases, both casting (int) or being stricter about what's allowed there (param hinting). But that falls out from this issue and the code that introduced the failures, so the pure unit-test fix has been applied.
2799 lines
121 KiB
PHP
2799 lines
121 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 calendar functions unit tests
|
|
*
|
|
* @package core_calendar
|
|
* @category external
|
|
* @copyright 2012 Ankit Agarwal
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
global $CFG;
|
|
|
|
require_once($CFG->dirroot . '/webservice/tests/helpers.php');
|
|
|
|
/**
|
|
* External course functions unit tests
|
|
*
|
|
* @package core_calendar
|
|
* @category external
|
|
* @copyright 2012 Ankit Agarwal
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
* @since Moodle 2.5
|
|
*/
|
|
class core_calendar_externallib_testcase extends externallib_advanced_testcase {
|
|
|
|
/**
|
|
* Tests set up
|
|
*/
|
|
protected function setUp() {
|
|
global $CFG;
|
|
require_once($CFG->dirroot . '/calendar/externallib.php');
|
|
}
|
|
|
|
/** Create calendar events or update them
|
|
* Set $prop->id, if you want to do an update instead of creating an new event
|
|
*
|
|
* @param string $name Event title
|
|
* @param int $userid User id
|
|
* @param string $type Event type
|
|
* @param int $repeats Number of repeated events to create
|
|
* @param int $timestart Time stamp of the event start
|
|
* @param mixed $prop List of event properties as array or object
|
|
* @return mixed Event object or false;
|
|
* @since Moodle 2.5
|
|
*/
|
|
|
|
public static function create_calendar_event($name, $userid = 0, $type = 'user', $repeats = 0, $timestart = null, $prop = null) {
|
|
global $CFG, $DB, $SITE;
|
|
|
|
require_once("$CFG->dirroot/calendar/lib.php");
|
|
if (!empty($prop)) {
|
|
if (is_array($prop)) {
|
|
$prop = (object)$prop;
|
|
}
|
|
} else {
|
|
$prop = new stdClass();
|
|
}
|
|
$prop->name = $name;
|
|
if (empty($prop->eventtype)) {
|
|
$prop->eventtype = $type;
|
|
}
|
|
if (empty($prop->repeats)) {
|
|
$prop->repeats = $repeats;
|
|
}
|
|
if (empty($prop->timestart)) {
|
|
$prop->timestart = time();
|
|
}
|
|
if (empty($prop->timeduration)) {
|
|
$prop->timeduration = 0;
|
|
}
|
|
if (empty($prop->timesort)) {
|
|
$prop->timesort = 0;
|
|
}
|
|
if (empty($prop->type)) {
|
|
$prop->type = CALENDAR_EVENT_TYPE_STANDARD;
|
|
}
|
|
if (empty($prop->repeats)) {
|
|
$prop->repeat = 0;
|
|
} else {
|
|
$prop->repeat = 1;
|
|
}
|
|
if (empty($prop->userid)) {
|
|
if (!empty($userid)) {
|
|
$prop->userid = $userid;
|
|
} else {
|
|
$prop->userid = 0;
|
|
}
|
|
}
|
|
if (!isset($prop->courseid)) {
|
|
$prop->courseid = $SITE->id;
|
|
}
|
|
|
|
// Determine event priority.
|
|
if ($prop->courseid == 0 && isset($prop->groupid) && $prop->groupid == 0 && !empty($prop->userid)) {
|
|
// User override event.
|
|
$prop->priority = CALENDAR_EVENT_USER_OVERRIDE_PRIORITY;
|
|
} else if ($prop->courseid != $SITE->id && !empty($prop->groupid)) {
|
|
// Group override event.
|
|
$priorityparams = ['courseid' => $prop->courseid, 'groupid' => $prop->groupid];
|
|
// Group override event with the highest priority.
|
|
$groupevents = $DB->get_records('event', $priorityparams, 'priority DESC', 'id, priority', 0, 1);
|
|
$priority = 1;
|
|
if (!empty($groupevents)) {
|
|
$event = reset($groupevents);
|
|
if (!empty($event->priority)) {
|
|
$priority = $event->priority + 1;
|
|
}
|
|
}
|
|
$prop->priority = $priority;
|
|
}
|
|
|
|
$event = new calendar_event($prop);
|
|
return $event->create($prop);
|
|
}
|
|
|
|
public function test_create_calendar_events () {
|
|
global $DB, $USER;
|
|
|
|
$this->setAdminUser();
|
|
$this->resetAfterTest();
|
|
$prevcount = count($DB->get_records("event"));
|
|
|
|
// Create a few events and do asserts.
|
|
$this->create_calendar_event('test', $USER->id);
|
|
$where = $DB->sql_compare_text('name') ." = ?";
|
|
$count = count($DB->get_records_select("event", $where, array('test')));
|
|
$this->assertEquals(1, $count);
|
|
$aftercount = count($DB->get_records("event"));
|
|
$this->assertEquals($prevcount + 1, $aftercount);
|
|
|
|
$this->create_calendar_event('user', $USER->id, 'user', 3);
|
|
$where = $DB->sql_compare_text('name') ." = ?";
|
|
$count = count($DB->get_records_select("event", $where, array('user')));
|
|
|
|
$this->assertEquals(3, $count);
|
|
$aftercount = count($DB->get_records("event"));
|
|
$this->assertEquals($prevcount + 4, $aftercount);
|
|
|
|
}
|
|
|
|
/**
|
|
* Test delete_calendar_events
|
|
*
|
|
* @expectedException moodle_exception
|
|
*/
|
|
public function test_delete_calendar_events() {
|
|
global $DB, $USER;
|
|
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
// Create a few stuff to test with.
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$group = $this->getDataGenerator()->create_group($record);
|
|
|
|
$notdeletedcount = $DB->count_records('event');
|
|
|
|
// Let's create a few events.
|
|
$siteevent = $this->create_calendar_event('site', $USER->id, 'site');
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$courseevent = $this->create_calendar_event('course', $USER->id, 'course', 2, time(), $record);
|
|
$userevent = $this->create_calendar_event('user', $USER->id);
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$record->groupid = $group->id;
|
|
$groupevent = $this->create_calendar_event('group', $USER->id, 'group', 0, time(), $record);
|
|
|
|
// Now lets try to delete stuff with proper rights.
|
|
$events = array(
|
|
array('eventid' => $siteevent->id, 'repeat' => 0),
|
|
array('eventid' => $courseevent->id, 'repeat' => 1),
|
|
array('eventid' => $userevent->id, 'repeat' => 0),
|
|
array('eventid' => $groupevent->id, 'repeat' => 0)
|
|
);
|
|
core_calendar_external::delete_calendar_events($events);
|
|
|
|
// Check to see if things were deleted properly.
|
|
$deletedcount = $DB->count_records('event');
|
|
$this->assertEquals($notdeletedcount, $deletedcount);
|
|
|
|
// Let's create a few events.
|
|
$siteevent = $this->create_calendar_event('site', $USER->id, 'site');
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$courseevent = $this->create_calendar_event('course', $USER->id, 'course', 3, time(), $record);
|
|
$userevent = $this->create_calendar_event('user', $USER->id);
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$record->groupid = $group->id;
|
|
$groupevent = $this->create_calendar_event('group', $USER->id, 'group', 0, time(), $record);
|
|
|
|
$this->setuser($user);
|
|
$sitecontext = context_system::instance();
|
|
$coursecontext = context_course::instance($course->id);
|
|
$usercontext = context_user::instance($user->id);
|
|
$role = $DB->get_record('role', array('shortname' => 'student'));
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, $role->id);
|
|
|
|
// Remove all caps.
|
|
$this->unassignUserCapability('moodle/calendar:manageentries', $sitecontext->id, $role->id);
|
|
$this->unassignUserCapability('moodle/calendar:manageentries', $coursecontext->id, $role->id);
|
|
$this->unassignUserCapability('moodle/calendar:managegroupentries', $coursecontext->id, $role->id);
|
|
$this->unassignUserCapability('moodle/calendar:manageownentries', $usercontext->id, $role->id);
|
|
|
|
// Assign proper caps and attempt delete.
|
|
$this->assignUserCapability('moodle/calendar:manageentries', $sitecontext->id, $role->id);
|
|
$events = array(
|
|
array('eventid' => $siteevent->id, 'repeat' => 0),
|
|
);
|
|
core_calendar_external::delete_calendar_events($events);
|
|
$deletedcount = $DB->count_records('event');
|
|
$count = $notdeletedcount+5;
|
|
$this->assertEquals($count, $deletedcount);
|
|
|
|
$this->assignUserCapability('moodle/calendar:manageentries', $sitecontext->id, $role->id);
|
|
$events = array(
|
|
array('eventid' => $courseevent->id, 'repeat' => 0),
|
|
);
|
|
core_calendar_external::delete_calendar_events($events);
|
|
$deletedcount = $DB->count_records('event');
|
|
$count = $notdeletedcount+4;
|
|
$this->assertEquals($count, $deletedcount);
|
|
|
|
$this->assignUserCapability('moodle/calendar:manageownentries', $usercontext->id, $role->id);
|
|
$events = array(
|
|
array('eventid' => $userevent->id, 'repeat' => 0),
|
|
);
|
|
core_calendar_external::delete_calendar_events($events);
|
|
$deletedcount = $DB->count_records('event');
|
|
$count = $notdeletedcount+3;
|
|
$this->assertEquals($count, $deletedcount);
|
|
|
|
$this->assignUserCapability('moodle/calendar:managegroupentries', $coursecontext->id, $role->id);
|
|
$events = array(
|
|
array('eventid' => $groupevent->id, 'repeat' => 0),
|
|
);
|
|
core_calendar_external::delete_calendar_events($events);
|
|
$deletedcount = $DB->count_records('event');
|
|
$count = $notdeletedcount+2;
|
|
$this->assertEquals($count, $deletedcount);
|
|
|
|
$notdeletedcount = $deletedcount;
|
|
|
|
// Let us try deleting without caps.
|
|
|
|
$siteevent = $this->create_calendar_event('site', $USER->id, 'site');
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$courseevent = $this->create_calendar_event('course', $USER->id, 'course', 3, time(), $record);
|
|
$userevent = $this->create_calendar_event('user', $USER->id);
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$record->groupid = $group->id;
|
|
$groupevent = $this->create_calendar_event('group', $USER->id, 'group', 0, time(), $record);
|
|
|
|
$this->setGuestUser();
|
|
|
|
$events = array(
|
|
array('eventid' => $siteevent->id, 'repeat' => 0),
|
|
array('eventid' => $courseevent->id, 'repeat' => 0),
|
|
array('eventid' => $userevent->id, 'repeat' => 0),
|
|
array('eventid' => $groupevent->id, 'repeat' => 0)
|
|
);
|
|
core_calendar_external::delete_calendar_events($events);
|
|
}
|
|
|
|
/**
|
|
* Test get_calendar_events
|
|
*/
|
|
public function test_get_calendar_events() {
|
|
global $DB, $USER;
|
|
|
|
$this->resetAfterTest(true);
|
|
set_config('calendar_adminseesall', 1);
|
|
$this->setAdminUser();
|
|
|
|
// Create a few stuff to test with.
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$user2 = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
|
|
$category = $this->getDataGenerator()->create_category();
|
|
|
|
$category2 = $this->getDataGenerator()->create_category();
|
|
$category2b = $this->getDataGenerator()->create_category(['parent' => $category2->id]);
|
|
$course3 = $this->getDataGenerator()->create_course(['category' => $category2b->id]);
|
|
|
|
$role = $DB->get_record('role', array('shortname' => 'student'));
|
|
$this->getDataGenerator()->enrol_user($user2->id, $course3->id, $role->id);
|
|
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$group = $this->getDataGenerator()->create_group($record);
|
|
|
|
$beforecount = $DB->count_records('event');
|
|
|
|
// Let's create a few events.
|
|
$siteevent = $this->create_calendar_event('site', $USER->id, 'site');
|
|
|
|
// This event will have description with an inline fake image.
|
|
$draftidfile = file_get_unused_draft_itemid();
|
|
$usercontext = context_course::instance($course->id);
|
|
$filerecord = array(
|
|
'contextid' => $usercontext->id,
|
|
'component' => 'user',
|
|
'filearea' => 'draft',
|
|
'itemid' => $draftidfile,
|
|
'filepath' => '/',
|
|
'filename' => 'fakeimage.png',
|
|
);
|
|
$fs = get_file_storage();
|
|
$fs->create_file_from_string($filerecord, 'img contents');
|
|
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$record->groupid = 0;
|
|
$record->description = array(
|
|
'format' => FORMAT_HTML,
|
|
'text' => 'Text with img <img src="@@PLUGINFILE@@/fakeimage.png">',
|
|
'itemid' => $draftidfile
|
|
);
|
|
$courseevent = $this->create_calendar_event('course', $USER->id, 'course', 2, time(), $record);
|
|
|
|
$record = new stdClass();
|
|
$record->courseid = 0;
|
|
$record->groupid = 0;
|
|
$userevent = $this->create_calendar_event('user', $USER->id, 'user', 0, time(), $record);
|
|
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$record->groupid = $group->id;
|
|
$groupevent = $this->create_calendar_event('group', $USER->id, 'group', 0, time(), $record);
|
|
|
|
$paramevents = array ('eventids' => array($siteevent->id), 'courseids' => array($course->id),
|
|
'groupids' => array($group->id), 'categoryids' => array($category->id));
|
|
|
|
$options = array ('siteevents' => true, 'userevents' => true);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
|
|
// Check to see if we got all events.
|
|
$this->assertEquals(5, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
$options = array ('siteevents' => true, 'userevents' => true, 'timeend' => time() + 7*WEEKSECS);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(5, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
// Expect the same URL in the description of two different events (because they are repeated).
|
|
$coursecontext = context_course::instance($course->id);
|
|
$expectedurl = "webservice/pluginfile.php/$coursecontext->id/calendar/event_description/$courseevent->id/fakeimage.png";
|
|
$withdescription = 0;
|
|
foreach ($events['events'] as $event) {
|
|
if (!empty($event['description'])) {
|
|
$withdescription++;
|
|
$this->assertContains($expectedurl, $event['description']);
|
|
}
|
|
}
|
|
$this->assertEquals(2, $withdescription);
|
|
|
|
// Let's play around with caps.
|
|
|
|
// Create user event for the user $user.
|
|
$record = new stdClass();
|
|
$record->courseid = 0;
|
|
$record->groupid = 0;
|
|
$this->create_calendar_event('user', $user->id, 'user', 0, time(), $record);
|
|
|
|
$this->setUser($user);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(2, count($events['events'])); // site, user.
|
|
$this->assertEquals(2, count($events['warnings'])); // course, group.
|
|
|
|
$role = $DB->get_record('role', array('shortname' => 'student'));
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, $role->id);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(4, count($events['events'])); // site, user, both course events.
|
|
$this->assertEquals(1, count($events['warnings'])); // group.
|
|
|
|
$options = array ('siteevents' => true, 'userevents' => true, 'timeend' => time() + HOURSECS);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(3, count($events['events'])); // site, user, one course event.
|
|
$this->assertEquals(1, count($events['warnings'])); // group.
|
|
|
|
groups_add_member($group, $user);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(4, count($events['events'])); // site, user, group, one course event.
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
$paramevents = array ('courseids' => array($course->id), 'groupids' => array($group->id));
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(4, count($events['events'])); // site, user, group, one course event.
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
$paramevents = array ('groupids' => array($group->id, 23));
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(3, count($events['events'])); // site, user, group.
|
|
$this->assertEquals(1, count($events['warnings']));
|
|
|
|
$paramevents = array ('courseids' => array(23));
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(2, count($events['events'])); // site, user.
|
|
$this->assertEquals(1, count($events['warnings']));
|
|
|
|
$paramevents = array ();
|
|
$options = array ('siteevents' => false, 'userevents' => false, 'timeend' => time() + 7*WEEKSECS);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(0, count($events['events'])); // nothing returned.
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
$paramevents = array ('eventids' => array($siteevent->id, $groupevent->id));
|
|
$options = array ('siteevents' => false, 'userevents' => false, 'timeend' => time() + 7*WEEKSECS);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(2, count($events['events'])); // site, group.
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
$paramevents = array ('eventids' => array($siteevent->id));
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(1, count($events['events'])); // site.
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
// Try getting a course event by its id.
|
|
$paramevents = array ('eventids' => array($courseevent->id));
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(1, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
// Now, create an activity event.
|
|
$this->setAdminUser();
|
|
$nexttime = time() + DAYSECS;
|
|
$assign = $this->getDataGenerator()->create_module('assign', array('course' => $course->id, 'duedate' => $nexttime));
|
|
|
|
$this->setUser($user);
|
|
$paramevents = array ('courseids' => array($course->id));
|
|
$options = array ('siteevents' => true, 'userevents' => true, 'timeend' => time() + WEEKSECS);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
|
|
$this->assertCount(5, $events['events']);
|
|
|
|
// Hide the assignment.
|
|
set_coursemodule_visible($assign->cmid, 0);
|
|
// Empty all the caches that may be affected by this change.
|
|
accesslib_clear_all_caches_for_unit_testing();
|
|
course_modinfo::clear_instance_cache();
|
|
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
// Expect one less.
|
|
$this->assertCount(4, $events['events']);
|
|
|
|
// Create some category events.
|
|
$this->setAdminUser();
|
|
$record = new stdClass();
|
|
$record->courseid = 0;
|
|
$record->categoryid = $category->id;
|
|
$record->timestart = time() - DAYSECS;
|
|
$catevent1 = $this->create_calendar_event('category a', $USER->id, 'category', 0, time(), $record);
|
|
|
|
$record = new stdClass();
|
|
$record->courseid = 0;
|
|
$record->categoryid = $category2->id;
|
|
$record->timestart = time() + DAYSECS;
|
|
$catevent2 = $this->create_calendar_event('category b', $USER->id, 'category', 0, time(), $record);
|
|
|
|
// Now as student, make sure we get the events of the courses I am enrolled.
|
|
$this->setUser($user2);
|
|
$paramevents = array('categoryids' => array($category2b->id));
|
|
$options = array('timeend' => time() + 7 * WEEKSECS, 'userevents' => false, 'siteevents' => false);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
|
|
// Should be just one, since there's just one category event of the course I am enrolled (course3 - cat2b).
|
|
$this->assertEquals(1, count($events['events']));
|
|
$this->assertEquals($catevent2->id, $events['events'][0]['id']);
|
|
$this->assertEquals($category2->id, $events['events'][0]['categoryid']);
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
// Now get category events but by course (there aren't course events in the course).
|
|
$paramevents = array('courseids' => array($course3->id));
|
|
$options = array('timeend' => time() + 7 * WEEKSECS, 'userevents' => false, 'siteevents' => false);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(1, count($events['events']));
|
|
$this->assertEquals($catevent2->id, $events['events'][0]['id']);
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
// Empty events in one where I'm not enrolled and one parent category
|
|
// (parent of a category where this is a course where the user is enrolled).
|
|
$paramevents = array('categoryids' => array($category2->id, $category->id));
|
|
$options = array('timeend' => time() + 7 * WEEKSECS, 'userevents' => false, 'siteevents' => false);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(1, count($events['events']));
|
|
$this->assertEquals($catevent2->id, $events['events'][0]['id']);
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
|
|
// Admin can see all category events.
|
|
$this->setAdminUser();
|
|
$paramevents = array('categoryids' => array($category->id, $category2->id, $category2b->id));
|
|
$options = array('timeend' => time() + 7 * WEEKSECS, 'userevents' => false, 'siteevents' => false);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(2, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
$this->assertEquals($catevent1->id, $events['events'][0]['id']);
|
|
$this->assertEquals($category->id, $events['events'][0]['categoryid']);
|
|
$this->assertEquals($catevent2->id, $events['events'][1]['id']);
|
|
$this->assertEquals($category2->id, $events['events'][1]['categoryid']);
|
|
}
|
|
|
|
/**
|
|
* Test core_calendar_external::create_calendar_events
|
|
*/
|
|
public function test_core_create_calendar_events() {
|
|
global $DB, $USER, $SITE;
|
|
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
// Create a few stuff to test with.
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$group = $this->getDataGenerator()->create_group($record);
|
|
|
|
$prevcount = $DB->count_records('event');
|
|
|
|
// Let's create a few events.
|
|
$events = array (
|
|
array('name' => 'site', 'courseid' => $SITE->id, 'eventtype' => 'site'),
|
|
array('name' => 'course', 'courseid' => $course->id, 'eventtype' => 'course', 'repeats' => 2),
|
|
array('name' => 'group', 'courseid' => $course->id, 'groupid' => $group->id, 'eventtype' => 'group'),
|
|
array('name' => 'user')
|
|
);
|
|
$eventsret = core_calendar_external::create_calendar_events($events);
|
|
$eventsret = external_api::clean_returnvalue(core_calendar_external::create_calendar_events_returns(), $eventsret);
|
|
|
|
// Check to see if things were created properly.
|
|
$aftercount = $DB->count_records('event');
|
|
$this->assertEquals($prevcount + 5, $aftercount);
|
|
$this->assertEquals(5, count($eventsret['events']));
|
|
$this->assertEquals(0, count($eventsret['warnings']));
|
|
|
|
$sitecontext = context_system::instance();
|
|
$coursecontext = context_course::instance($course->id);
|
|
|
|
$this->setUser($user);
|
|
$prevcount = $aftercount;
|
|
$events = array (
|
|
array('name' => 'course', 'courseid' => $course->id, 'eventtype' => 'course', 'repeats' => 2),
|
|
array('name' => 'group', 'courseid' => $course->id, 'groupid' => $group->id, 'eventtype' => 'group'),
|
|
array('name' => 'user')
|
|
);
|
|
$role = $DB->get_record('role', array('shortname' => 'student'));
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, $role->id);
|
|
groups_add_member($group, $user);
|
|
$this->assignUserCapability('moodle/calendar:manageentries', $coursecontext->id, $role->id);
|
|
$this->assignUserCapability('moodle/calendar:managegroupentries', $coursecontext->id, $role->id);
|
|
$eventsret = core_calendar_external::create_calendar_events($events);
|
|
$eventsret = external_api::clean_returnvalue(core_calendar_external::create_calendar_events_returns(), $eventsret);
|
|
// Check to see if things were created properly.
|
|
$aftercount = $DB->count_records('event');
|
|
$this->assertEquals($prevcount + 4, $aftercount);
|
|
$this->assertEquals(4, count($eventsret['events']));
|
|
$this->assertEquals(0, count($eventsret['warnings']));
|
|
|
|
// Check to see nothing was created without proper permission.
|
|
$this->setGuestUser();
|
|
$prevcount = $DB->count_records('event');
|
|
$eventsret = core_calendar_external::create_calendar_events($events);
|
|
$eventsret = external_api::clean_returnvalue(core_calendar_external::create_calendar_events_returns(), $eventsret);
|
|
$aftercount = $DB->count_records('event');
|
|
$this->assertEquals($prevcount, $aftercount);
|
|
$this->assertEquals(0, count($eventsret['events']));
|
|
$this->assertEquals(3, count($eventsret['warnings']));
|
|
|
|
$this->setUser($user);
|
|
$this->unassignUserCapability('moodle/calendar:manageentries', $coursecontext->id, $role->id);
|
|
$this->unassignUserCapability('moodle/calendar:managegroupentries', $coursecontext->id, $role->id);
|
|
$prevcount = $DB->count_records('event');
|
|
$eventsret = core_calendar_external::create_calendar_events($events);
|
|
$eventsret = external_api::clean_returnvalue(core_calendar_external::create_calendar_events_returns(), $eventsret);
|
|
$aftercount = $DB->count_records('event');
|
|
$this->assertEquals($prevcount + 1, $aftercount); // User event.
|
|
$this->assertEquals(1, count($eventsret['events']));
|
|
$this->assertEquals(2, count($eventsret['warnings']));
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events from a given time should return all events with a sort
|
|
* time at or after the requested time. All events prior to that time should not
|
|
* be return.
|
|
*
|
|
* If there are no events on or after the given time then an empty result set should
|
|
* be returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_timesort_after_time() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$moduleinstance = $generator->create_instance(['course' => $course->id]);
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$params = [
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'modulename' => 'assign',
|
|
'instance' => $moduleinstance->id,
|
|
'courseid' => $course->id,
|
|
];
|
|
|
|
$event1 = $this->create_calendar_event('Event 1', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 1]));
|
|
$event2 = $this->create_calendar_event('Event 2', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 2]));
|
|
$event3 = $this->create_calendar_event('Event 3', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 3]));
|
|
$event4 = $this->create_calendar_event('Event 4', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 4]));
|
|
$event5 = $this->create_calendar_event('Event 5', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 5]));
|
|
$event6 = $this->create_calendar_event('Event 6', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 6]));
|
|
$event7 = $this->create_calendar_event('Event 7', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 7]));
|
|
$event8 = $this->create_calendar_event('Event 8', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 8]));
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(5);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
$events = $result['events'];
|
|
|
|
$this->assertCount(4, $events);
|
|
$this->assertEquals('Event 5', $events[0]['name']);
|
|
$this->assertEquals('Event 6', $events[1]['name']);
|
|
$this->assertEquals('Event 7', $events[2]['name']);
|
|
$this->assertEquals('Event 8', $events[3]['name']);
|
|
$this->assertEquals($event5->id, $result['firstid']);
|
|
$this->assertEquals($event8->id, $result['lastid']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(9);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
|
|
$this->assertEmpty($result['events']);
|
|
$this->assertNull($result['firstid']);
|
|
$this->assertNull($result['lastid']);
|
|
|
|
// Requesting action events on behalf of another user.
|
|
$this->setAdminUser();
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(5, null, 0, 20, false, $user->id);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
$events = $result['events'];
|
|
|
|
$this->assertCount(4, $events);
|
|
$this->assertEquals('Event 5', $events[0]['name']);
|
|
$this->assertEquals('Event 6', $events[1]['name']);
|
|
$this->assertEquals('Event 7', $events[2]['name']);
|
|
$this->assertEquals('Event 8', $events[3]['name']);
|
|
$this->assertEquals($event5->id, $result['firstid']);
|
|
$this->assertEquals($event8->id, $result['lastid']);
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events before a given time should return all events with a sort
|
|
* time at or before the requested time (inclusive). All events after that time
|
|
* should not be returned.
|
|
*
|
|
* If there are no events before the given time then an empty result set should be
|
|
* returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_timesort_before_time() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$moduleinstance = $generator->create_instance(['course' => $course->id]);
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$params = [
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'modulename' => 'assign',
|
|
'instance' => $moduleinstance->id,
|
|
'courseid' => $course->id,
|
|
];
|
|
|
|
$event1 = $this->create_calendar_event('Event 1', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 2]));
|
|
$event2 = $this->create_calendar_event('Event 2', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 3]));
|
|
$event3 = $this->create_calendar_event('Event 3', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 4]));
|
|
$event4 = $this->create_calendar_event('Event 4', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 5]));
|
|
$event5 = $this->create_calendar_event('Event 5', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 6]));
|
|
$event6 = $this->create_calendar_event('Event 6', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 7]));
|
|
$event7 = $this->create_calendar_event('Event 7', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 8]));
|
|
$event8 = $this->create_calendar_event('Event 8', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 9]));
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(null, 5);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
$events = $result['events'];
|
|
|
|
$this->assertCount(4, $events);
|
|
$this->assertEquals('Event 1', $events[0]['name']);
|
|
$this->assertEquals('Event 2', $events[1]['name']);
|
|
$this->assertEquals('Event 3', $events[2]['name']);
|
|
$this->assertEquals('Event 4', $events[3]['name']);
|
|
$this->assertEquals($event1->id, $result['firstid']);
|
|
$this->assertEquals($event4->id, $result['lastid']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(null, 1);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
|
|
$this->assertEmpty($result['events']);
|
|
$this->assertNull($result['firstid']);
|
|
$this->assertNull($result['lastid']);
|
|
|
|
// Requesting action events on behalf of another user.
|
|
$this->setAdminUser();
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(null, 5, 0, 20, false, $user->id);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
$events = $result['events'];
|
|
|
|
$this->assertCount(4, $events);
|
|
$this->assertEquals('Event 1', $events[0]['name']);
|
|
$this->assertEquals('Event 2', $events[1]['name']);
|
|
$this->assertEquals('Event 3', $events[2]['name']);
|
|
$this->assertEquals('Event 4', $events[3]['name']);
|
|
$this->assertEquals($event1->id, $result['firstid']);
|
|
$this->assertEquals($event4->id, $result['lastid']);
|
|
}
|
|
|
|
/**
|
|
* Test retrieving event that was overridden for a user
|
|
*/
|
|
public function test_get_calendar_events_override() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$user2 = $this->getDataGenerator()->create_user();
|
|
$teacher = $this->getDataGenerator()->create_user();
|
|
$anotheruser = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$moduleinstance = $generator->create_instance(['course' => $course->id]);
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, 'student');
|
|
$this->getDataGenerator()->enrol_user($user2->id, $course->id, 'student');
|
|
$this->getDataGenerator()->enrol_user($teacher->id, $course->id, 'editingteacher');
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$params = [
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'modulename' => 'assign',
|
|
'instance' => $moduleinstance->id,
|
|
];
|
|
|
|
$now = time();
|
|
// Create two events - one for everybody in the course and one only for the first student.
|
|
$event1 = $this->create_calendar_event('Base event', 0, 'due', 0, $now + DAYSECS, $params + ['courseid' => $course->id]);
|
|
$event2 = $this->create_calendar_event('User event', $user->id, 'due', 0, $now + 2*DAYSECS, $params + ['courseid' => 0]);
|
|
|
|
// Retrieve course events for the second student - only one "Base event" is returned.
|
|
$this->setUser($user2);
|
|
$paramevents = array('courseids' => array($course->id));
|
|
$options = array ('siteevents' => true, 'userevents' => true);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(1, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
$this->assertEquals('Base event', $events['events'][0]['name']);
|
|
|
|
// Retrieve events for the first student - both events are returned.
|
|
$this->setUser($user);
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(2, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
$this->assertEquals('Base event', $events['events'][0]['name']);
|
|
$this->assertEquals('User event', $events['events'][1]['name']);
|
|
|
|
// Retrieve events by id as a teacher, 'User event' should be returned since teacher has access to this course.
|
|
$this->setUser($teacher);
|
|
$paramevents = ['eventids' => [$event2->id]];
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(1, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
$this->assertEquals('User event', $events['events'][0]['name']);
|
|
|
|
// Retrieve events by id as another user, nothing should be returned.
|
|
$this->setUser($anotheruser);
|
|
$paramevents = ['eventids' => [$event2->id, $event1->id]];
|
|
$events = core_calendar_external::get_calendar_events($paramevents, $options);
|
|
$events = external_api::clean_returnvalue(core_calendar_external::get_calendar_events_returns(), $events);
|
|
$this->assertEquals(0, count($events['events']));
|
|
$this->assertEquals(0, count($events['warnings']));
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events within a given time range should return all events with
|
|
* a sort time between the lower and upper time bound (inclusive).
|
|
*
|
|
* If there are no events in the given time range then an empty result set should be
|
|
* returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_timesort_time_range() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$moduleinstance = $generator->create_instance(['course' => $course->id]);
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$params = [
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'modulename' => 'assign',
|
|
'instance' => $moduleinstance->id,
|
|
'courseid' => $course->id,
|
|
];
|
|
|
|
$event1 = $this->create_calendar_event('Event 1', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 1]));
|
|
$event2 = $this->create_calendar_event('Event 2', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 2]));
|
|
$event3 = $this->create_calendar_event('Event 3', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 3]));
|
|
$event4 = $this->create_calendar_event('Event 4', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 4]));
|
|
$event5 = $this->create_calendar_event('Event 5', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 5]));
|
|
$event6 = $this->create_calendar_event('Event 6', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 6]));
|
|
$event7 = $this->create_calendar_event('Event 7', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 7]));
|
|
$event8 = $this->create_calendar_event('Event 8', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 8]));
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(3, 6);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
$events = $result['events'];
|
|
|
|
$this->assertCount(4, $events);
|
|
$this->assertEquals('Event 3', $events[0]['name']);
|
|
$this->assertEquals('Event 4', $events[1]['name']);
|
|
$this->assertEquals('Event 5', $events[2]['name']);
|
|
$this->assertEquals('Event 6', $events[3]['name']);
|
|
$this->assertEquals($event3->id, $result['firstid']);
|
|
$this->assertEquals($event6->id, $result['lastid']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(10, 15);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
|
|
$this->assertEmpty($result['events']);
|
|
$this->assertNull($result['firstid']);
|
|
$this->assertNull($result['lastid']);
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events within a given time range and a limit and offset should return
|
|
* the number of events up to the given limit value that have a sort time between the lower
|
|
* and uppper time bound (inclusive) where the result set is shifted by the offset value.
|
|
*
|
|
* If there are no events in the given time range then an empty result set should be
|
|
* returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_timesort_time_limit_offset() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$moduleinstance = $generator->create_instance(['course' => $course->id]);
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$params = [
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'modulename' => 'assign',
|
|
'instance' => $moduleinstance->id,
|
|
'courseid' => $course->id,
|
|
];
|
|
|
|
$event1 = $this->create_calendar_event('Event 1', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 1]));
|
|
$event2 = $this->create_calendar_event('Event 2', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 2]));
|
|
$event3 = $this->create_calendar_event('Event 3', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 3]));
|
|
$event4 = $this->create_calendar_event('Event 4', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 4]));
|
|
$event5 = $this->create_calendar_event('Event 5', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 5]));
|
|
$event6 = $this->create_calendar_event('Event 6', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 6]));
|
|
$event7 = $this->create_calendar_event('Event 7', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 7]));
|
|
$event8 = $this->create_calendar_event('Event 8', $user->id, 'user', 0, 1, array_merge($params, ['timesort' => 8]));
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(2, 7, $event3->id, 2);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
$events = $result['events'];
|
|
|
|
$this->assertCount(2, $events);
|
|
$this->assertEquals('Event 4', $events[0]['name']);
|
|
$this->assertEquals('Event 5', $events[1]['name']);
|
|
$this->assertEquals($event4->id, $result['firstid']);
|
|
$this->assertEquals($event5->id, $result['lastid']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(2, 7, $event5->id, 2);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
$events = $result['events'];
|
|
|
|
$this->assertCount(2, $events);
|
|
$this->assertEquals('Event 6', $events[0]['name']);
|
|
$this->assertEquals('Event 7', $events[1]['name']);
|
|
$this->assertEquals($event6->id, $result['firstid']);
|
|
$this->assertEquals($event7->id, $result['lastid']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(2, 7, $event7->id, 2);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_timesort_returns(),
|
|
$result
|
|
);
|
|
|
|
$this->assertEmpty($result['events']);
|
|
$this->assertNull($result['firstid']);
|
|
$this->assertNull($result['lastid']);
|
|
}
|
|
|
|
/**
|
|
* Check that it is possible to restrict the calendar events to events where the user is not suspended in the course.
|
|
*/
|
|
public function test_get_calendar_action_events_by_timesort_suspended_course() {
|
|
$this->resetAfterTest();
|
|
$user1 = $this->getDataGenerator()->create_user();
|
|
$user2 = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$this->setAdminUser();
|
|
$lesson = $this->getDataGenerator()->create_module('lesson', [
|
|
'name' => 'Lesson 1',
|
|
'course' => $course->id,
|
|
'available' => time(),
|
|
'deadline' => (time() + (60 * 60 * 24 * 5))
|
|
]
|
|
);
|
|
$this->getDataGenerator()->enrol_user($user1->id, $course->id, null, 'manual', 0, 0, ENROL_USER_SUSPENDED);
|
|
$this->getDataGenerator()->enrol_user($user2->id, $course->id);
|
|
|
|
$this->setUser($user1);
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(0, null, 0, 20, true);
|
|
$this->assertEmpty($result->events);
|
|
$this->setUser($user2);
|
|
$result = core_calendar_external::get_calendar_action_events_by_timesort(0, null, 0, 20, true);
|
|
$this->assertCount(1, $result->events);
|
|
$this->assertEquals('Lesson 1 closes', $result->events[0]->name);
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events from a given course and time should return all
|
|
* events with a sort time at or after the requested time. All events prior
|
|
* to that time should not be return.
|
|
*
|
|
* If there are no events on or after the given time then an empty result set should
|
|
* be returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_course_after_time() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course1 = $this->getDataGenerator()->create_course();
|
|
$course2 = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$instance1 = $generator->create_instance(['course' => $course1->id]);
|
|
$instance2 = $generator->create_instance(['course' => $course2->id]);
|
|
$records = [];
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course1->id);
|
|
$this->getDataGenerator()->enrol_user($user->id, $course2->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
for ($i = 1; $i < 19; $i++) {
|
|
$courseid = ($i < 9) ? $course1->id : $course2->id;
|
|
$instance = ($i < 9) ? $instance1->id : $instance2->id;
|
|
$records[] = $this->create_calendar_event(
|
|
sprintf('Event %d', $i),
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
1,
|
|
[
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'courseid' => $courseid,
|
|
'timesort' => $i,
|
|
'modulename' => 'assign',
|
|
'instance' => $instance,
|
|
]
|
|
);
|
|
}
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course($course1->id, 5);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertCount(4, $result);
|
|
$this->assertEquals('Event 5', $result[0]['name']);
|
|
$this->assertEquals('Event 6', $result[1]['name']);
|
|
$this->assertEquals('Event 7', $result[2]['name']);
|
|
$this->assertEquals('Event 8', $result[3]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course($course1->id, 9);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertEmpty($result);
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events for a course and before a given time should return
|
|
* all events with a sort time at or before the requested time (inclusive). All
|
|
* events after that time should not be returned.
|
|
*
|
|
* If there are no events before the given time then an empty result set should be
|
|
* returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_course_before_time() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course1 = $this->getDataGenerator()->create_course();
|
|
$course2 = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$instance1 = $generator->create_instance(['course' => $course1->id]);
|
|
$instance2 = $generator->create_instance(['course' => $course2->id]);
|
|
$records = [];
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course1->id);
|
|
$this->getDataGenerator()->enrol_user($user->id, $course2->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
for ($i = 1; $i < 19; $i++) {
|
|
$courseid = ($i < 9) ? $course1->id : $course2->id;
|
|
$instance = ($i < 9) ? $instance1->id : $instance2->id;
|
|
$records[] = $this->create_calendar_event(
|
|
sprintf('Event %d', $i),
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
1,
|
|
[
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'courseid' => $courseid,
|
|
'timesort' => $i + 1,
|
|
'modulename' => 'assign',
|
|
'instance' => $instance,
|
|
]
|
|
);
|
|
}
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course($course1->id, null, 5);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertCount(4, $result);
|
|
$this->assertEquals('Event 1', $result[0]['name']);
|
|
$this->assertEquals('Event 2', $result[1]['name']);
|
|
$this->assertEquals('Event 3', $result[2]['name']);
|
|
$this->assertEquals('Event 4', $result[3]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course($course1->id, null, 1);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertEmpty($result);
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events for a course and within a given time range should
|
|
* return all events with a sort time between the lower and upper time bound
|
|
* (inclusive).
|
|
*
|
|
* If there are no events in the given time range then an empty result set should be
|
|
* returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_course_time_range() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course1 = $this->getDataGenerator()->create_course();
|
|
$course2 = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$instance1 = $generator->create_instance(['course' => $course1->id]);
|
|
$instance2 = $generator->create_instance(['course' => $course2->id]);
|
|
$records = [];
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course1->id);
|
|
$this->getDataGenerator()->enrol_user($user->id, $course2->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
for ($i = 1; $i < 19; $i++) {
|
|
$courseid = ($i < 9) ? $course1->id : $course2->id;
|
|
$instance = ($i < 9) ? $instance1->id : $instance2->id;
|
|
$records[] = $this->create_calendar_event(
|
|
sprintf('Event %d', $i),
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
1,
|
|
[
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'courseid' => $courseid,
|
|
'timesort' => $i,
|
|
'modulename' => 'assign',
|
|
'instance' => $instance,
|
|
]
|
|
);
|
|
}
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course($course1->id, 3, 6);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertCount(4, $result);
|
|
$this->assertEquals('Event 3', $result[0]['name']);
|
|
$this->assertEquals('Event 4', $result[1]['name']);
|
|
$this->assertEquals('Event 5', $result[2]['name']);
|
|
$this->assertEquals('Event 6', $result[3]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course($course1->id, 10, 15);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertEmpty($result);
|
|
}
|
|
|
|
/**
|
|
* Requesting calendar events for a course and within a given time range and a limit
|
|
* and offset should return the number of events up to the given limit value that have
|
|
* a sort time between the lower and uppper time bound (inclusive) where the result
|
|
* set is shifted by the offset value.
|
|
*
|
|
* If there are no events in the given time range then an empty result set should be
|
|
* returned.
|
|
*/
|
|
public function test_get_calendar_action_events_by_course_time_limit_offset() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course1 = $this->getDataGenerator()->create_course();
|
|
$course2 = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$instance1 = $generator->create_instance(['course' => $course1->id]);
|
|
$instance2 = $generator->create_instance(['course' => $course2->id]);
|
|
$records = [];
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course1->id);
|
|
$this->getDataGenerator()->enrol_user($user->id, $course2->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
for ($i = 1; $i < 19; $i++) {
|
|
$courseid = ($i < 9) ? $course1->id : $course2->id;
|
|
$instance = ($i < 9) ? $instance1->id : $instance2->id;
|
|
$records[] = $this->create_calendar_event(
|
|
sprintf('Event %d', $i),
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
1,
|
|
[
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'courseid' => $courseid,
|
|
'timesort' => $i,
|
|
'modulename' => 'assign',
|
|
'instance' => $instance,
|
|
]
|
|
);
|
|
}
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course(
|
|
$course1->id, 2, 7, $records[2]->id, 2);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertCount(2, $result);
|
|
$this->assertEquals('Event 4', $result[0]['name']);
|
|
$this->assertEquals('Event 5', $result[1]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course(
|
|
$course1->id, 2, 7, $records[4]->id, 2);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertCount(2, $result);
|
|
$this->assertEquals('Event 6', $result[0]['name']);
|
|
$this->assertEquals('Event 7', $result[1]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_course(
|
|
$course1->id, 2, 7, $records[6]->id, 2);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_course_returns(),
|
|
$result
|
|
);
|
|
$result = $result['events'];
|
|
|
|
$this->assertEmpty($result);
|
|
}
|
|
|
|
/**
|
|
* Test that get_action_events_by_courses will return a list of events for each
|
|
* course you provided as long as the user is enrolled in the course.
|
|
*/
|
|
public function test_get_action_events_by_courses() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course1 = $this->getDataGenerator()->create_course();
|
|
$course2 = $this->getDataGenerator()->create_course();
|
|
$course3 = $this->getDataGenerator()->create_course();
|
|
$generator = $this->getDataGenerator()->get_plugin_generator('mod_assign');
|
|
$instance1 = $generator->create_instance(['course' => $course1->id]);
|
|
$instance2 = $generator->create_instance(['course' => $course2->id]);
|
|
$instance3 = $generator->create_instance(['course' => $course3->id]);
|
|
$records = [];
|
|
$mapresult = function($result) {
|
|
$groupedbycourse = [];
|
|
foreach ($result['groupedbycourse'] as $group) {
|
|
$events = $group['events'];
|
|
$courseid = $group['courseid'];
|
|
$groupedbycourse[$courseid] = $events;
|
|
}
|
|
|
|
return $groupedbycourse;
|
|
};
|
|
|
|
$this->getDataGenerator()->enrol_user($user->id, $course1->id);
|
|
$this->getDataGenerator()->enrol_user($user->id, $course2->id);
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
for ($i = 1; $i < 10; $i++) {
|
|
if ($i < 3) {
|
|
$courseid = $course1->id;
|
|
$instance = $instance1->id;
|
|
} else if ($i < 6) {
|
|
$courseid = $course2->id;
|
|
$instance = $instance2->id;
|
|
} else {
|
|
$courseid = $course3->id;
|
|
$instance = $instance3->id;
|
|
}
|
|
|
|
$records[] = $this->create_calendar_event(
|
|
sprintf('Event %d', $i),
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
1,
|
|
[
|
|
'type' => CALENDAR_EVENT_TYPE_ACTION,
|
|
'courseid' => $courseid,
|
|
'timesort' => $i,
|
|
'modulename' => 'assign',
|
|
'instance' => $instance,
|
|
]
|
|
);
|
|
}
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_courses([], 1);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_courses_returns(),
|
|
$result
|
|
);
|
|
$result = $result['groupedbycourse'];
|
|
|
|
$this->assertEmpty($result);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_courses([$course1->id], 3);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_courses_returns(),
|
|
$result
|
|
);
|
|
|
|
$groupedbycourse = $mapresult($result);
|
|
|
|
$this->assertEmpty($groupedbycourse[$course1->id]);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_courses([$course1->id], 1);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_courses_returns(),
|
|
$result
|
|
);
|
|
$groupedbycourse = $mapresult($result);
|
|
|
|
$this->assertCount(2, $groupedbycourse[$course1->id]);
|
|
$this->assertEquals('Event 1', $groupedbycourse[$course1->id][0]['name']);
|
|
$this->assertEquals('Event 2', $groupedbycourse[$course1->id][1]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_courses(
|
|
[$course1->id, $course2->id], 1);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_courses_returns(),
|
|
$result
|
|
);
|
|
$groupedbycourse = $mapresult($result);
|
|
|
|
$this->assertCount(2, $groupedbycourse[$course1->id]);
|
|
$this->assertEquals('Event 1', $groupedbycourse[$course1->id][0]['name']);
|
|
$this->assertEquals('Event 2', $groupedbycourse[$course1->id][1]['name']);
|
|
$this->assertCount(3, $groupedbycourse[$course2->id]);
|
|
$this->assertEquals('Event 3', $groupedbycourse[$course2->id][0]['name']);
|
|
$this->assertEquals('Event 4', $groupedbycourse[$course2->id][1]['name']);
|
|
$this->assertEquals('Event 5', $groupedbycourse[$course2->id][2]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_courses(
|
|
[$course1->id, $course2->id], 2, 4);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_courses_returns(),
|
|
$result
|
|
);
|
|
$groupedbycourse = $mapresult($result);
|
|
|
|
$this->assertCount(2, $groupedbycourse);
|
|
$this->assertCount(1, $groupedbycourse[$course1->id]);
|
|
$this->assertEquals('Event 2', $groupedbycourse[$course1->id][0]['name']);
|
|
$this->assertCount(2, $groupedbycourse[$course2->id]);
|
|
$this->assertEquals('Event 3', $groupedbycourse[$course2->id][0]['name']);
|
|
$this->assertEquals('Event 4', $groupedbycourse[$course2->id][1]['name']);
|
|
|
|
$result = core_calendar_external::get_calendar_action_events_by_courses(
|
|
[$course1->id, $course2->id], 1, null, 1);
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_action_events_by_courses_returns(),
|
|
$result
|
|
);
|
|
$groupedbycourse = $mapresult($result);
|
|
|
|
$this->assertCount(2, $groupedbycourse);
|
|
$this->assertCount(1, $groupedbycourse[$course1->id]);
|
|
$this->assertEquals('Event 1', $groupedbycourse[$course1->id][0]['name']);
|
|
$this->assertCount(1, $groupedbycourse[$course2->id]);
|
|
$this->assertEquals('Event 3', $groupedbycourse[$course2->id][0]['name']);
|
|
}
|
|
|
|
/**
|
|
* Test for deleting module events.
|
|
*/
|
|
public function test_delete_calendar_events_for_modules() {
|
|
$this->resetAfterTest();
|
|
$this->setAdminUser();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$nexttime = time() + DAYSECS;
|
|
$this->getDataGenerator()->create_module('assign', ['course' => $course->id, 'duedate' => $nexttime]);
|
|
$events = calendar_get_events(time(), $nexttime, true, true, true);
|
|
$this->assertCount(1, $events);
|
|
$params = [];
|
|
foreach ($events as $event) {
|
|
$params[] = [
|
|
'eventid' => $event->id,
|
|
'repeat' => false
|
|
];
|
|
}
|
|
|
|
$this->expectException('moodle_exception');
|
|
core_calendar_external::delete_calendar_events($params);
|
|
}
|
|
|
|
/**
|
|
* Updating the event start day should change the date value but leave
|
|
* the time of day unchanged.
|
|
*/
|
|
public function test_update_event_start_day() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$roleid = $generator->create_role();
|
|
$context = \context_system::instance();
|
|
$originalstarttime = new DateTimeImmutable('2017-01-1T15:00:00+08:00');
|
|
$newstartdate = new DateTimeImmutable('2018-02-2T10:00:00+08:00');
|
|
$expected = new DateTimeImmutable('2018-02-2T15:00:00+08:00');
|
|
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
assign_capability('moodle/calendar:manageownentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$this->setUser($user);
|
|
$this->resetAfterTest(true);
|
|
|
|
$event = $this->create_calendar_event(
|
|
'Test event',
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
null,
|
|
[
|
|
'courseid' => 0,
|
|
'timestart' => $originalstarttime->getTimestamp()
|
|
]
|
|
);
|
|
|
|
$result = core_calendar_external::update_event_start_day($event->id, $newstartdate->getTimestamp());
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::update_event_start_day_returns(),
|
|
$result
|
|
);
|
|
|
|
$this->assertEquals($expected->getTimestamp(), $result['event']['timestart']);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able to edit an event that they don't have
|
|
* capabilities for.
|
|
*/
|
|
public function test_update_event_start_day_no_permission() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$roleid = $generator->create_role();
|
|
$context = \context_system::instance();
|
|
$originalstarttime = new DateTimeImmutable('2017-01-1T15:00:00+08:00');
|
|
$newstartdate = new DateTimeImmutable('2018-02-2T10:00:00+08:00');
|
|
$expected = new DateTimeImmutable('2018-02-2T15:00:00+08:00');
|
|
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
assign_capability('moodle/calendar:manageownentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$this->setUser($user);
|
|
$this->resetAfterTest(true);
|
|
|
|
$event = $this->create_calendar_event(
|
|
'Test event',
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
null,
|
|
[
|
|
'courseid' => 0,
|
|
'timestart' => $originalstarttime->getTimestamp()
|
|
]
|
|
);
|
|
|
|
assign_capability('moodle/calendar:manageownentries', CAP_PROHIBIT, $roleid, $context, true);
|
|
$this->expectException('moodle_exception');
|
|
$result = core_calendar_external::update_event_start_day($event->id, $newstartdate->getTimestamp());
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::update_event_start_day_returns(),
|
|
$result
|
|
);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able to update a module event.
|
|
*/
|
|
public function test_update_event_start_day_module_event() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$plugingenerator = $generator->get_plugin_generator('mod_assign');
|
|
$moduleinstance = $plugingenerator->create_instance(['course' => $course->id]);
|
|
$roleid = $generator->create_role();
|
|
$context = \context_course::instance($course->id);
|
|
$originalstarttime = new DateTimeImmutable('2017-01-1T15:00:00+08:00');
|
|
$newstartdate = new DateTimeImmutable('2018-02-2T10:00:00+08:00');
|
|
$expected = new DateTimeImmutable('2018-02-2T15:00:00+08:00');
|
|
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
$generator->enrol_user($user->id, $course->id);
|
|
|
|
$this->setUser($user);
|
|
$this->resetAfterTest(true);
|
|
|
|
$event = $this->create_calendar_event(
|
|
'Test event',
|
|
$user->id,
|
|
'user',
|
|
0,
|
|
null,
|
|
[
|
|
'modulename' => 'assign',
|
|
'instance' => $moduleinstance->id,
|
|
'courseid' => $course->id,
|
|
'timestart' => $originalstarttime->getTimestamp()
|
|
]
|
|
);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_ALLOW, $roleid, $context, true);
|
|
$this->expectException('moodle_exception');
|
|
$result = core_calendar_external::update_event_start_day($event->id, $newstartdate->getTimestamp());
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::update_event_start_day_returns(),
|
|
$result
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Submit a request where the time duration until is earlier than the time
|
|
* start in order to get a validation error from the server.
|
|
*/
|
|
public function test_submit_create_update_form_validation_error() {
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->sub($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'user',
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$this->assertTrue($result['validationerror']);
|
|
}
|
|
|
|
/**
|
|
* A user with the moodle/calendar:manageownentries capability at the
|
|
* system context should be able to create a user event.
|
|
*/
|
|
public function test_submit_create_update_form_create_user_event() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$roleid = $generator->create_role();
|
|
$context = \context_system::instance();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'user',
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
'itemid' => 0
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
assign_capability('moodle/calendar:manageownentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$event = $result['event'];
|
|
$this->assertEquals($user->id, $event['userid']);
|
|
$this->assertEquals($formdata['eventtype'], $event['eventtype']);
|
|
$this->assertEquals($formdata['name'], $event['name']);
|
|
}
|
|
|
|
/**
|
|
* A user without the moodle/calendar:manageownentries capability at the
|
|
* system context should not be able to create a user event.
|
|
*/
|
|
public function test_submit_create_update_form_create_user_event_no_permission() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$roleid = $generator->create_role();
|
|
$context = \context_system::instance();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'user',
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
assign_capability('moodle/calendar:manageownentries', CAP_PROHIBIT, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$this->expectException('moodle_exception');
|
|
|
|
external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* A user with the moodle/calendar:manageentries capability at the
|
|
* site course context should be able to create a site event.
|
|
*/
|
|
public function test_submit_create_update_form_create_site_event() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$context = context_system::instance();
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'site',
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
'itemid' => 0
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$event = $result['event'];
|
|
$this->assertEquals($user->id, $event['userid']);
|
|
$this->assertEquals($formdata['eventtype'], $event['eventtype']);
|
|
$this->assertEquals($formdata['name'], $event['name']);
|
|
}
|
|
|
|
/**
|
|
* A user without the moodle/calendar:manageentries capability at the
|
|
* site course context should not be able to create a site event.
|
|
*/
|
|
public function test_submit_create_update_form_create_site_event_no_permission() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$context = context_course::instance(SITEID);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'site',
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_PROHIBIT, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$this->assertTrue($result['validationerror']);
|
|
}
|
|
|
|
/**
|
|
* A user that has the moodle/calendar:manageentries in a course that they
|
|
* are enrolled in should be able to create a course event in that course.
|
|
*/
|
|
public function test_submit_create_update_form_create_course_event() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$context = context_course::instance($course->id);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'course',
|
|
'courseid' => $course->id,
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
'itemid' => 0,
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->enrol_user($user->id, $course->id, 'student');
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$event = $result['event'];
|
|
$this->assertEquals($user->id, $event['userid']);
|
|
$this->assertEquals($formdata['eventtype'], $event['eventtype']);
|
|
$this->assertEquals($formdata['name'], $event['name']);
|
|
$this->assertEquals($formdata['courseid'], $event['course']['id']);
|
|
}
|
|
|
|
/**
|
|
* A user without the moodle/calendar:manageentries capability in a course
|
|
* that they are enrolled in should not be able to create a course event in that course.
|
|
*/
|
|
public function test_submit_create_update_form_create_course_event_no_permission() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$context = context_course::instance($course->id);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'course',
|
|
'courseid' => $course->id,
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->enrol_user($user->id, $course->id, 'student');
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_PROHIBIT, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$this->assertTrue($result['validationerror']);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able to create an event for a course that they are
|
|
* not enrolled in.
|
|
*/
|
|
public function test_submit_create_update_form_create_course_event_not_enrolled() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$course2 = $generator->create_course();
|
|
$context = context_course::instance($course->id);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'course',
|
|
'courseid' => $course2->id, // Not enrolled.
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->enrol_user($user->id, $course->id, 'student');
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$this->assertTrue($result['validationerror']);
|
|
}
|
|
|
|
/**
|
|
* A user should be able to create an event for a group that they are a member of in
|
|
* a course in which they are enrolled and have the moodle/calendar:manageentries capability.
|
|
*/
|
|
public function test_submit_create_update_form_create_group_event_group_member_manage_course() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$group = $generator->create_group(array('courseid' => $course->id));
|
|
$context = context_course::instance($course->id);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'group',
|
|
'groupid' => $group->id,
|
|
'groupcourseid' => $course->id,
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
'itemid' => 0
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->enrol_user($user->id, $course->id, 'student');
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
$generator->create_group_member(['groupid' => $group->id, 'userid' => $user->id]);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$event = $result['event'];
|
|
$this->assertEquals($user->id, $event['userid']);
|
|
$this->assertEquals($formdata['eventtype'], $event['eventtype']);
|
|
$this->assertEquals($formdata['name'], $event['name']);
|
|
$this->assertEquals($group->id, $event['groupid']);
|
|
}
|
|
|
|
/**
|
|
* A user should be able to create an event for a group that they are a member of in
|
|
* a course in which they are enrolled and have the moodle/calendar:managegroupentries capability.
|
|
*/
|
|
public function test_submit_create_update_form_create_group_event_group_member_manage_group_entries() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$group = $generator->create_group(array('courseid' => $course->id));
|
|
$context = context_course::instance($course->id);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'group',
|
|
'groupid' => $group->id,
|
|
'groupcourseid' => $course->id,
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
'itemid' => 0
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->enrol_user($user->id, $course->id, 'student');
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
$generator->create_group_member(['groupid' => $group->id, 'userid' => $user->id]);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_PROHIBIT, $roleid, $context, true);
|
|
assign_capability('moodle/calendar:managegroupentries', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$event = $result['event'];
|
|
$this->assertEquals($user->id, $event['userid']);
|
|
$this->assertEquals($formdata['eventtype'], $event['eventtype']);
|
|
$this->assertEquals($formdata['name'], $event['name']);
|
|
$this->assertEquals($group->id, $event['groupid']);
|
|
}
|
|
|
|
/**
|
|
* A user should be able to create an event for any group in a course in which
|
|
* they are enrolled and have the moodle/site:accessallgroups capability.
|
|
*/
|
|
public function test_submit_create_update_form_create_group_event_access_all_groups() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$group = $generator->create_group(array('courseid' => $course->id));
|
|
$context = context_course::instance($course->id);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'group',
|
|
'groupid' => $group->id,
|
|
'groupcourseid' => $course->id,
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
'itemid' => 0
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->enrol_user($user->id, $course->id, 'student');
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_ALLOW, $roleid, $context, true);
|
|
assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$event = $result['event'];
|
|
$this->assertEquals($user->id, $event['userid']);
|
|
$this->assertEquals($formdata['eventtype'], $event['eventtype']);
|
|
$this->assertEquals($formdata['name'], $event['name']);
|
|
$this->assertEquals($group->id, $event['groupid']);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able to create an event for any group that they are not a
|
|
* member of in a course in which they are enrolled but don't have the
|
|
* moodle/site:accessallgroups capability.
|
|
*/
|
|
public function test_submit_create_update_form_create_group_event_non_member_no_permission() {
|
|
$generator = $this->getDataGenerator();
|
|
$user = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$group = $generator->create_group(array('courseid' => $course->id));
|
|
$context = context_course::instance($course->id);
|
|
$roleid = $generator->create_role();
|
|
$timestart = new DateTime();
|
|
$interval = new DateInterval("P1D"); // One day.
|
|
$timedurationuntil = new DateTime();
|
|
$timedurationuntil->add($interval);
|
|
$formdata = [
|
|
'id' => 0,
|
|
'userid' => $user->id,
|
|
'modulename' => '',
|
|
'instance' => 0,
|
|
'visible' => 1,
|
|
'name' => 'Test',
|
|
'timestart' => [
|
|
'day' => $timestart->format('j'),
|
|
'month' => $timestart->format('n'),
|
|
'year' => $timestart->format('Y'),
|
|
'hour' => $timestart->format('G'),
|
|
'minute' => 0,
|
|
],
|
|
'eventtype' => 'group',
|
|
'groupid' => $group->id,
|
|
'groupcourseid' => $course->id,
|
|
'description' => [
|
|
'text' => '',
|
|
'format' => 1,
|
|
],
|
|
'location' => 'Test',
|
|
'duration' => 1,
|
|
'timedurationuntil' => [
|
|
'day' => $timedurationuntil->format('j'),
|
|
'month' => $timedurationuntil->format('n'),
|
|
'year' => $timedurationuntil->format('Y'),
|
|
'hour' => $timedurationuntil->format('G'),
|
|
'minute' => 0,
|
|
]
|
|
];
|
|
|
|
$formdata = \core_calendar\local\event\forms\create::mock_generate_submit_keys($formdata);
|
|
$querystring = http_build_query($formdata, '', '&');
|
|
|
|
$generator->enrol_user($user->id, $course->id, 'student');
|
|
$generator->role_assign($roleid, $user->id, $context->id);
|
|
|
|
assign_capability('moodle/calendar:manageentries', CAP_ALLOW, $roleid, $context, true);
|
|
assign_capability('moodle/site:accessallgroups', CAP_PROHIBIT, $roleid, $context, true);
|
|
|
|
$user->ignoresesskey = true;
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($user);
|
|
|
|
$result = external_api::clean_returnvalue(
|
|
core_calendar_external::submit_create_update_form_returns(),
|
|
core_calendar_external::submit_create_update_form($querystring)
|
|
);
|
|
|
|
$this->assertTrue($result['validationerror']);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able load the calendar monthly view for a course they cannot access.
|
|
*/
|
|
public function test_get_calendar_monthly_view_no_course_permission() {
|
|
global $USER;
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$generator = $this->getDataGenerator();
|
|
$user1 = $generator->create_user();
|
|
$user2 = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$generator->enrol_user($user1->id, $course->id, 'student');
|
|
$name = 'Course Event (course' . $course->id . ')';
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$courseevent = $this->create_calendar_event($name, $USER->id, 'course', 0, time(), $record);
|
|
|
|
$timestart = new DateTime();
|
|
// Admin can load the course.
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_monthly_view_returns(),
|
|
core_calendar_external::get_calendar_monthly_view($timestart->format('Y'), $timestart->format('n'),
|
|
$course->id, null, false, true, $timestart->format('j'))
|
|
);
|
|
$this->assertEquals($data['courseid'], $course->id);
|
|
// User enrolled in the course can load the course calendar.
|
|
$this->setUser($user1);
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_monthly_view_returns(),
|
|
core_calendar_external::get_calendar_monthly_view($timestart->format('Y'), $timestart->format('n'),
|
|
$course->id, null, false, true, $timestart->format('j'))
|
|
);
|
|
$this->assertEquals($data['courseid'], $course->id);
|
|
// User not enrolled in the course cannot load the course calendar.
|
|
$this->setUser($user2);
|
|
$this->expectException('require_login_exception');
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_monthly_view_returns(),
|
|
core_calendar_external::get_calendar_monthly_view($timestart->format('Y'), $timestart->format('n'),
|
|
$course->id, null, false, false, $timestart->format('j'))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test get_calendar_monthly_view when a day parameter is provided.
|
|
*/
|
|
public function test_get_calendar_monthly_view_with_day_provided() {
|
|
$this->resetAfterTest();
|
|
$this->setAdminUser();
|
|
|
|
$timestart = new DateTime();
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_monthly_view_returns(),
|
|
core_calendar_external::get_calendar_monthly_view($timestart->format('Y'), $timestart->format('n'),
|
|
SITEID, null, false, true, $timestart->format('j'))
|
|
);
|
|
$this->assertEquals($data['date']['mday'], $timestart->format('d'));
|
|
}
|
|
|
|
/**
|
|
* A user should not be able load the calendar day view for a course they cannot access.
|
|
*/
|
|
public function test_get_calendar_day_view_no_course_permission() {
|
|
global $USER;
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$generator = $this->getDataGenerator();
|
|
$user1 = $generator->create_user();
|
|
$user2 = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$generator->enrol_user($user1->id, $course->id, 'student');
|
|
$name = 'Course Event (course' . $course->id . ')';
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$courseevent = $this->create_calendar_event($name, $USER->id, 'course', 0, time(), $record);
|
|
|
|
$timestart = new DateTime();
|
|
// Admin can load the course.
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_day_view_returns(),
|
|
core_calendar_external::get_calendar_day_view($timestart->format('Y'), $timestart->format('n'),
|
|
$timestart->format('j'), $course->id, null)
|
|
);
|
|
$this->assertEquals($data['courseid'], $course->id);
|
|
// User enrolled in the course can load the course calendar.
|
|
$this->setUser($user1);
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_day_view_returns(),
|
|
core_calendar_external::get_calendar_day_view($timestart->format('Y'), $timestart->format('n'),
|
|
$timestart->format('j'), $course->id, null)
|
|
);
|
|
$this->assertEquals($data['courseid'], $course->id);
|
|
// User not enrolled in the course cannot load the course calendar.
|
|
$this->setUser($user2);
|
|
$this->expectException('require_login_exception');
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_day_view_returns(),
|
|
core_calendar_external::get_calendar_day_view($timestart->format('Y'), $timestart->format('n'),
|
|
$timestart->format('j'), $course->id, null)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able load the calendar upcoming view for a course they cannot access.
|
|
*/
|
|
public function test_get_calendar_upcoming_view_no_course_permission() {
|
|
global $USER;
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$generator = $this->getDataGenerator();
|
|
$user1 = $generator->create_user();
|
|
$user2 = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$generator->enrol_user($user1->id, $course->id, 'student');
|
|
$name = 'Course Event (course' . $course->id . ')';
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$courseevent = $this->create_calendar_event($name, $USER->id, 'course', 0, time(), $record);
|
|
|
|
// Admin can load the course.
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_upcoming_view_returns(),
|
|
core_calendar_external::get_calendar_upcoming_view($course->id, null)
|
|
);
|
|
$this->assertEquals($data['courseid'], $course->id);
|
|
// User enrolled in the course can load the course calendar.
|
|
$this->setUser($user1);
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_upcoming_view_returns(),
|
|
core_calendar_external::get_calendar_upcoming_view($course->id, null)
|
|
);
|
|
$this->assertEquals($data['courseid'], $course->id);
|
|
// User not enrolled in the course cannot load the course calendar.
|
|
$this->setUser($user2);
|
|
$this->expectException('require_login_exception');
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_upcoming_view_returns(),
|
|
core_calendar_external::get_calendar_upcoming_view($course->id, null)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able load the calendar event for a course they cannot access.
|
|
*/
|
|
public function test_get_calendar_event_by_id_no_course_permission() {
|
|
global $USER;
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$generator = $this->getDataGenerator();
|
|
$user1 = $generator->create_user();
|
|
$user2 = $generator->create_user();
|
|
$course = $generator->create_course();
|
|
$generator->enrol_user($user1->id, $course->id, 'student');
|
|
$name = 'Course Event (course' . $course->id . ')';
|
|
$record = new stdClass();
|
|
$record->courseid = $course->id;
|
|
$courseevent = $this->create_calendar_event($name, $USER->id, 'course', 0, time(), $record);
|
|
|
|
// Admin can load the course event.
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_event_by_id_returns(),
|
|
core_calendar_external::get_calendar_event_by_id($courseevent->id)
|
|
);
|
|
$this->assertEquals($data['event']['id'], $courseevent->id);
|
|
// User enrolled in the course can load the course event.
|
|
$this->setUser($user1);
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_event_by_id_returns(),
|
|
core_calendar_external::get_calendar_event_by_id($courseevent->id)
|
|
);
|
|
$this->assertEquals($data['event']['id'], $courseevent->id);
|
|
// User not enrolled in the course cannot load the course event.
|
|
$this->setUser($user2);
|
|
$this->expectException('required_capability_exception');
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_event_by_id_returns(),
|
|
core_calendar_external::get_calendar_event_by_id($courseevent->id)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* A user should not be able load the calendar events for a category they cannot see.
|
|
*/
|
|
public function test_get_calendar_events_hidden_category() {
|
|
global $USER;
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$generator = $this->getDataGenerator();
|
|
$user1 = $generator->create_user();
|
|
$category = $generator->create_category(['visible' => 0]);
|
|
$name = 'Category Event (category: ' . $category->id . ')';
|
|
$record = new stdClass();
|
|
$record->categoryid = $category->id;
|
|
$categoryevent = $this->create_calendar_event($name, $USER->id, 'category', 0, time(), $record);
|
|
|
|
$events = [
|
|
'eventids' => [$categoryevent->id]
|
|
];
|
|
$options = [];
|
|
// Admin can load the category event.
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_events_returns(),
|
|
core_calendar_external::get_calendar_events($events, $options)
|
|
);
|
|
$this->assertEquals($data['events'][0]['id'], $categoryevent->id);
|
|
// User with no special permission to see hidden categories will not see the event.
|
|
$this->setUser($user1);
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_events_returns(),
|
|
core_calendar_external::get_calendar_events($events, $options)
|
|
);
|
|
$this->assertCount(0, $data['events']);
|
|
$this->assertEquals('nopermissions', $data['warnings'][0]['warningcode']);
|
|
}
|
|
|
|
/**
|
|
* Test get_calendar_access_information for admins.
|
|
*/
|
|
public function test_get_calendar_access_information_for_admins() {
|
|
global $CFG;
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$CFG->calendar_adminseesall = 1;
|
|
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_access_information_returns(),
|
|
core_calendar_external::get_calendar_access_information()
|
|
);
|
|
$this->assertTrue($data['canmanageownentries']);
|
|
$this->assertTrue($data['canmanagegroupentries']);
|
|
$this->assertTrue($data['canmanageentries']);
|
|
}
|
|
|
|
/**
|
|
* Test get_calendar_access_information for authenticated users.
|
|
*/
|
|
public function test_get_calendar_access_information_for_authenticated_users() {
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($this->getDataGenerator()->create_user());
|
|
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_access_information_returns(),
|
|
core_calendar_external::get_calendar_access_information()
|
|
);
|
|
$this->assertTrue($data['canmanageownentries']);
|
|
$this->assertFalse($data['canmanagegroupentries']);
|
|
$this->assertFalse($data['canmanageentries']);
|
|
}
|
|
|
|
/**
|
|
* Test get_calendar_access_information for student users.
|
|
*/
|
|
public function test_get_calendar_access_information_for_student_users() {
|
|
global $DB;
|
|
$this->resetAfterTest(true);
|
|
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$role = $DB->get_record('role', array('shortname' => 'student'));
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, $role->id);
|
|
|
|
$this->setUser($user);
|
|
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_access_information_returns(),
|
|
core_calendar_external::get_calendar_access_information($course->id)
|
|
);
|
|
$this->assertTrue($data['canmanageownentries']);
|
|
$this->assertFalse($data['canmanagegroupentries']);
|
|
$this->assertFalse($data['canmanageentries']);
|
|
}
|
|
|
|
/**
|
|
* Test get_calendar_access_information for teacher users.
|
|
*/
|
|
public function test_get_calendar_access_information_for_teacher_users() {
|
|
global $DB;
|
|
$this->resetAfterTest(true);
|
|
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course(['groupmode' => 1]);
|
|
$role = $DB->get_record('role', array('shortname' => 'editingteacher'));
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, $role->id);
|
|
$this->getDataGenerator()->create_group(['courseid' => $course->id]);
|
|
|
|
$this->setUser($user);
|
|
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_calendar_access_information_returns(),
|
|
core_calendar_external::get_calendar_access_information($course->id)
|
|
);
|
|
$this->assertTrue($data['canmanageownentries']);
|
|
$this->assertTrue($data['canmanagegroupentries']);
|
|
$this->assertTrue($data['canmanageentries']);
|
|
}
|
|
|
|
/**
|
|
* Test get_allowed_event_types for admins.
|
|
*/
|
|
public function test_get_allowed_event_types_for_admins() {
|
|
global $CFG;
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
$CFG->calendar_adminseesall = 1;
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_allowed_event_types_returns(),
|
|
core_calendar_external::get_allowed_event_types()
|
|
);
|
|
$this->assertEquals(['user', 'site', 'course', 'category'], $data['allowedeventtypes']);
|
|
}
|
|
/**
|
|
* Test get_allowed_event_types for authenticated users.
|
|
*/
|
|
public function test_get_allowed_event_types_for_authenticated_users() {
|
|
$this->resetAfterTest(true);
|
|
$this->setUser($this->getDataGenerator()->create_user());
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_allowed_event_types_returns(),
|
|
core_calendar_external::get_allowed_event_types()
|
|
);
|
|
$this->assertEquals(['user'], $data['allowedeventtypes']);
|
|
}
|
|
/**
|
|
* Test get_allowed_event_types for student users.
|
|
*/
|
|
public function test_get_allowed_event_types_for_student_users() {
|
|
global $DB;
|
|
$this->resetAfterTest(true);
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course();
|
|
$role = $DB->get_record('role', array('shortname' => 'student'));
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, $role->id);
|
|
$this->setUser($user);
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_allowed_event_types_returns(),
|
|
core_calendar_external::get_allowed_event_types($course->id)
|
|
);
|
|
$this->assertEquals(['user'], $data['allowedeventtypes']);
|
|
}
|
|
/**
|
|
* Test get_allowed_event_types for teacher users.
|
|
*/
|
|
public function test_get_allowed_event_types_for_teacher_users() {
|
|
global $DB;
|
|
$this->resetAfterTest(true);
|
|
$user = $this->getDataGenerator()->create_user();
|
|
$course = $this->getDataGenerator()->create_course(['groupmode' => 1]);
|
|
$role = $DB->get_record('role', array('shortname' => 'editingteacher'));
|
|
$this->getDataGenerator()->enrol_user($user->id, $course->id, $role->id);
|
|
$this->getDataGenerator()->create_group(['courseid' => $course->id]);
|
|
$this->setUser($user);
|
|
$data = external_api::clean_returnvalue(
|
|
core_calendar_external::get_allowed_event_types_returns(),
|
|
core_calendar_external::get_allowed_event_types($course->id)
|
|
);
|
|
$this->assertEquals(['user', 'course', 'group'], $data['allowedeventtypes']);
|
|
}
|
|
|
|
/**
|
|
* Test get_timestamps with string keys, with and without optional hour/minute values.
|
|
*/
|
|
public function test_get_timestamps_string_keys() {
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$time1 = new DateTime('2018-12-30 00:00:00');
|
|
$time2 = new DateTime('2019-03-27 23:59:00');
|
|
|
|
$dates = [
|
|
[
|
|
'key' => 'from',
|
|
'year' => $time1->format('Y'),
|
|
'month' => $time1->format('m'),
|
|
'day' => $time1->format('d'),
|
|
],
|
|
[
|
|
'key' => 'to',
|
|
'year' => $time2->format('Y'),
|
|
'month' => (int) $time2->format('m'),
|
|
'day' => $time2->format('d'),
|
|
'hour' => $time2->format('H'),
|
|
'minute' => $time2->format('i'),
|
|
],
|
|
];
|
|
|
|
$expectedtimestamps = [
|
|
'from' => $time1->getTimestamp(),
|
|
'to' => $time2->getTimestamp(),
|
|
];
|
|
|
|
$result = core_calendar_external::get_timestamps($dates);
|
|
|
|
$this->assertEquals(['timestamps'], array_keys($result));
|
|
$this->assertEquals(2, count($result['timestamps']));
|
|
|
|
foreach ($result['timestamps'] as $data) {
|
|
$this->assertTrue(in_array($data['key'], ['from', 'to']));
|
|
$this->assertEquals($expectedtimestamps[$data['key']], $data['timestamp']);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test get_timestamps with no keys specified, with and without optional hour/minute values.
|
|
*/
|
|
public function test_get_timestamps_no_keys() {
|
|
$this->resetAfterTest(true);
|
|
$this->setAdminUser();
|
|
|
|
$time1 = new DateTime('2018-12-30 00:00:00');
|
|
$time2 = new DateTime('2019-03-27 23:59:00');
|
|
|
|
$dates = [
|
|
[
|
|
'year' => $time1->format('Y'),
|
|
'month' => $time1->format('m'),
|
|
'day' => $time1->format('d'),
|
|
],
|
|
[
|
|
'year' => $time2->format('Y'),
|
|
'month' => (int) $time2->format('m'),
|
|
'day' => $time2->format('d'),
|
|
'hour' => $time2->format('H'),
|
|
'minute' => $time2->format('i'),
|
|
],
|
|
];
|
|
|
|
$expectedtimestamps = [
|
|
0 => $time1->getTimestamp(),
|
|
1 => $time2->getTimestamp(),
|
|
];
|
|
|
|
$result = core_calendar_external::get_timestamps($dates);
|
|
|
|
$this->assertEquals(['timestamps'], array_keys($result));
|
|
$this->assertEquals(2, count($result['timestamps']));
|
|
|
|
foreach ($result['timestamps'] as $data) {
|
|
$this->assertEquals($expectedtimestamps[$data['key']], $data['timestamp']);
|
|
}
|
|
}
|
|
}
|