From 522841861fa4ef1a21c27b235e54750a58998999 Mon Sep 17 00:00:00 2001 From: Mark Nelson Date: Tue, 4 Sep 2018 14:53:19 +0800 Subject: [PATCH] MDL-63211 core_message: added new web services --- lib/db/services.php | 54 ++++ message/externallib.php | 351 ++++++++++++++++++++++++ message/tests/externallib_test.php | 423 +++++++++++++++++++++++++++++ version.php | 2 +- 4 files changed, 829 insertions(+), 1 deletion(-) diff --git a/lib/db/services.php b/lib/db/services.php index bedc6c25f6f..23342405733 100644 --- a/lib/db/services.php +++ b/lib/db/services.php @@ -821,6 +821,15 @@ $functions = array( 'description' => 'Updates existing groupings', 'type' => 'write', ), + 'core_message_block_user' => array( + 'classname' => 'core_message_external', + 'methodname' => 'block_user', + 'classpath' => 'message/externallib.php', + 'description' => 'Blocks a user', + 'type' => 'write', + 'ajax' => true, + 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), + ), 'core_message_block_contacts' => array( 'classname' => 'core_message_external', 'methodname' => 'block_contacts', @@ -841,6 +850,42 @@ $functions = array( 'ajax' => true, 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), ), + 'core_message_get_contact_requests' => array( + 'classname' => 'core_message_external', + 'methodname' => 'get_contact_requests', + 'classpath' => 'message/externallib.php', + 'description' => 'Returns contact requests for a user', + 'type' => 'read', + 'ajax' => true, + 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), + ), + 'core_message_create_contact_request' => array( + 'classname' => 'core_message_external', + 'methodname' => 'create_contact_request', + 'classpath' => 'message/externallib.php', + 'description' => 'Creates a contact request', + 'type' => 'write', + 'ajax' => true, + 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), + ), + 'core_message_confirm_contact_request' => array( + 'classname' => 'core_message_external', + 'methodname' => 'confirm_contact_request', + 'classpath' => 'message/externallib.php', + 'description' => 'Confirms a contact request', + 'type' => 'write', + 'ajax' => true, + 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), + ), + 'core_message_decline_contact_request' => array( + 'classname' => 'core_message_external', + 'methodname' => 'decline_contact_request', + 'classpath' => 'message/externallib.php', + 'description' => 'Declines a contact request', + 'type' => 'write', + 'ajax' => true, + 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), + ), 'core_message_delete_contacts' => array( 'classname' => 'core_message_external', 'methodname' => 'delete_contacts', @@ -1043,6 +1088,15 @@ $functions = array( 'ajax' => true, 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), ), + 'core_message_unblock_user' => array( + 'classname' => 'core_message_external', + 'methodname' => 'unblock_user', + 'classpath' => 'message/externallib.php', + 'description' => 'Unblocks a user', + 'type' => 'write', + 'ajax' => true, + 'services' => array(MOODLE_OFFICIAL_MOBILE_SERVICE), + ), 'core_message_unblock_contacts' => array( 'classname' => 'core_message_external', 'methodname' => 'unblock_contacts', diff --git a/message/externallib.php b/message/externallib.php index 43c94f394e0..6555b9d1f2e 100644 --- a/message/externallib.php +++ b/message/externallib.php @@ -343,6 +343,117 @@ class core_message_external extends external_api { return null; } + /** + * Block user parameters description. + * + * @return external_function_parameters + */ + public static function block_user_parameters() { + return new external_function_parameters( + [ + 'userid' => new external_value(PARAM_INT, 'The id of the user who is blocking'), + 'blockeduserid' => new external_value(PARAM_INT, 'The id of the user being blocked'), + ] + ); + } + + /** + * Blocks a user. + * + * @param int $userid The id of the user who is blocking + * @param int $blockeduserid The id of the user being blocked + * @return external_description + */ + public static function block_user(int $userid, int $blockeduserid) { + global $CFG, $USER; + + // Check if messaging is enabled. + if (empty($CFG->messaging)) { + throw new moodle_exception('disabled', 'message'); + } + + // Validate context. + $context = context_system::instance(); + self::validate_context($context); + + $capability = 'moodle/site:manageallmessaging'; + if (($USER->id != $userid) && !has_capability($capability, $context)) { + throw new required_capability_exception($context, $capability, 'nopermissions', ''); + } + + $params = ['userid' => $userid, 'blockeduserid' => $blockeduserid]; + $params = self::validate_parameters(self::block_user_parameters(), $params); + + if (!\core_message\api::is_blocked($params['userid'], $params['blockeduserid'])) { + \core_message\api::block_user($params['userid'], $params['blockeduserid']); + } + + return []; + } + + /** + * Block user return description. + * + * @return external_description + */ + public static function block_user_returns() { + return new external_warnings(); + } + + /** + * Unblock user parameters description. + * + * @return external_function_parameters + */ + public static function unblock_user_parameters() { + return new external_function_parameters( + [ + 'userid' => new external_value(PARAM_INT, 'The id of the user who is unblocking'), + 'unblockeduserid' => new external_value(PARAM_INT, 'The id of the user being unblocked'), + ] + ); + } + + /** + * Unblock user. + * + * @param int $userid The id of the user who is unblocking + * @param int $unblockeduserid The id of the user being unblocked + */ + public static function unblock_user(int $userid, int $unblockeduserid) { + global $CFG, $USER; + + // Check if messaging is enabled. + if (empty($CFG->messaging)) { + throw new moodle_exception('disabled', 'message'); + } + + // Validate context. + $context = context_system::instance(); + self::validate_context($context); + + $capability = 'moodle/site:manageallmessaging'; + if (($USER->id != $userid) && !has_capability($capability, $context)) { + throw new required_capability_exception($context, $capability, 'nopermissions', ''); + } + + $params = ['userid' => $userid, 'unblockeduserid' => $unblockeduserid]; + $params = self::validate_parameters(self::unblock_user_parameters(), $params); + + \core_message\api::unblock_user($params['userid'], $params['unblockeduserid']); + + return []; + } + + /** + * Unblock user return description. + * + * @return external_description + */ + public static function unblock_user_returns() { + return new external_warnings(); + } + /** * Block contacts parameters description. * @@ -510,6 +621,246 @@ class core_message_external extends external_api { return true; } + /** + * Returns contact requests parameters description. + * + * @return external_function_parameters + */ + public static function get_contact_requests_parameters() { + return new external_function_parameters( + [ + 'userid' => new external_value(PARAM_INT, 'The id of the user we want the requests for') + ] + ); + } + + /** + * Handles returning the contact requests for a user. + * + * This also includes the user data necessary to display information + * about the user. + * + * It will not include blocked users. + * + * @param int $userid The id of the user we want to get the contact requests for + */ + public static function get_contact_requests(int $userid) { + global $CFG, $USER; + + // Check if messaging is enabled. + if (empty($CFG->messaging)) { + throw new moodle_exception('disabled', 'message'); + } + + // Validate context. + $context = context_system::instance(); + self::validate_context($context); + + $capability = 'moodle/site:manageallmessaging'; + if (($USER->id != $userid) && !has_capability($capability, $context)) { + throw new required_capability_exception($context, $capability, 'nopermissions', ''); + } + + $params = ['userid' => $userid]; + $params = self::validate_parameters(self::get_contact_requests_parameters(), $params); + + return \core_message\api::get_contact_requests($params['userid']); + } + + /** + * Returns the contact requests return description. + * + * @return external_description + */ + public static function get_contact_requests_returns() { + return new external_multiple_structure( + new external_single_structure( + [ + 'id' => new external_value(core_user::get_property_type('id'), 'ID of the user'), + 'contactrequestid' => new external_value(PARAM_INT, 'The ID of the contact request'), + 'picture' => new external_value(core_user::get_property_type('picture'), 'The picture'), + 'firstname' => new external_value(core_user::get_property_type('firstname'), + 'The first name(s) of the user'), + 'lastname' => new external_value(core_user::get_property_type('lastname'), + 'The family name of the user'), + 'firstnamephonetic' => new external_value(core_user::get_property_type('firstnamephonetic'), + 'The phonetic first name of the user'), + 'lastnamephonetic' => new external_value(core_user::get_property_type('lastnamephonetic'), + 'The phonetic last name of the user'), + 'middlename' => new external_value(core_user::get_property_type('middlename'), + 'The middle name of the user'), + 'alternatename' => new external_value(core_user::get_property_type('alternatename'), + 'The alternate name of the user'), + 'email' => new external_value(core_user::get_property_type('email'), 'An email address') + ] + ) + ); + } + + /** + * Creates a contact request parameters description. + * + * @return external_function_parameters + */ + public static function create_contact_request_parameters() { + return new external_function_parameters( + [ + 'userid' => new external_value(PARAM_INT, 'The id of the user making the request'), + 'requesteduserid' => new external_value(PARAM_INT, 'The id of the user being requested') + ] + ); + } + + /** + * Creates a contact request. + * + * @param int $userid The id of the user who is creating the contact request + * @param int $requesteduserid The id of the user being requested + */ + public static function create_contact_request(int $userid, int $requesteduserid) { + global $CFG, $USER; + + // Check if messaging is enabled. + if (empty($CFG->messaging)) { + throw new moodle_exception('disabled', 'message'); + } + + // Validate context. + $context = context_system::instance(); + self::validate_context($context); + + $capability = 'moodle/site:manageallmessaging'; + if (($USER->id != $userid) && !has_capability($capability, $context)) { + throw new required_capability_exception($context, $capability, 'nopermissions', ''); + } + + $params = ['userid' => $userid, 'requesteduserid' => $requesteduserid]; + $params = self::validate_parameters(self::create_contact_request_parameters(), $params); + + if (!\core_message\api::does_contact_request_exist($params['userid'], $params['requesteduserid'])) { + \core_message\api::create_contact_request($params['userid'], $params['requesteduserid']); + } + + return []; + } + + /** + * Creates a contact request return description. + * + * @return external_description + */ + public static function create_contact_request_returns() { + return new external_warnings(); + } + + /** + * Confirm a contact request parameters description. + * + * @return external_function_parameters + */ + public static function confirm_contact_request_parameters() { + return new external_function_parameters( + [ + 'userid' => new external_value(PARAM_INT, 'The id of the user making the request'), + 'requesteduserid' => new external_value(PARAM_INT, 'The id of the user being requested') + ] + ); + } + + /** + * Confirm a contact request. + * + * @param int $userid The id of the user who is creating the contact request + * @param int $requesteduserid The id of the user being requested + */ + public static function confirm_contact_request(int $userid, int $requesteduserid) { + global $CFG, $USER; + + // Check if messaging is enabled. + if (empty($CFG->messaging)) { + throw new moodle_exception('disabled', 'message'); + } + + // Validate context. + $context = context_system::instance(); + self::validate_context($context); + + $capability = 'moodle/site:manageallmessaging'; + if (($USER->id != $requesteduserid) && !has_capability($capability, $context)) { + throw new required_capability_exception($context, $capability, 'nopermissions', ''); + } + + $params = ['userid' => $userid, 'requesteduserid' => $requesteduserid]; + $params = self::validate_parameters(self::confirm_contact_request_parameters(), $params); + + \core_message\api::confirm_contact_request($params['userid'], $params['requesteduserid']); + + return []; + } + + /** + * Confirm a contact request return description. + * + * @return external_description + */ + public static function confirm_contact_request_returns() { + return new external_warnings(); + } + + /** + * Declines a contact request parameters description. + * + * @return external_function_parameters + */ + public static function decline_contact_request_parameters() { + return new external_function_parameters( + [ + 'userid' => new external_value(PARAM_INT, 'The id of the user making the request'), + 'requesteduserid' => new external_value(PARAM_INT, 'The id of the user being requested') + ] + ); + } + + /** + * Declines a contact request. + * + * @param int $userid The id of the user who is creating the contact request + * @param int $requesteduserid The id of the user being requested + */ + public static function decline_contact_request(int $userid, int $requesteduserid) { + global $CFG, $USER; + + // Check if messaging is enabled. + if (empty($CFG->messaging)) { + throw new moodle_exception('disabled', 'message'); + } + + // Validate context. + $context = context_system::instance(); + self::validate_context($context); + + $capability = 'moodle/site:manageallmessaging'; + if (($USER->id != $requesteduserid) && !has_capability($capability, $context)) { + throw new required_capability_exception($context, $capability, 'nopermissions', ''); + } + + $params = ['userid' => $userid, 'requesteduserid' => $requesteduserid]; + $params = self::validate_parameters(self::decline_contact_request_parameters(), $params); + + \core_message\api::decline_contact_request($params['userid'], $params['requesteduserid']); + + return []; + } + + /** + * Declines a contact request return description. + * + * @return external_description + */ + public static function decline_contact_request_returns() { + return new external_warnings(); + } + /** * Return the structure of a message area contact. * diff --git a/message/tests/externallib_test.php b/message/tests/externallib_test.php index f78cc46b346..6f60b954908 100644 --- a/message/tests/externallib_test.php +++ b/message/tests/externallib_test.php @@ -329,6 +329,429 @@ class core_message_externallib_testcase extends externallib_advanced_testcase { core_message_external::unblock_contacts(array($user2->id), $user3->id); } + /** + * Test getting contact requests. + */ + public function test_get_contact_requests() { + $this->resetAfterTest(); + + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + $user3 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Block one user, their request should not show up. + \core_message\api::block_user($user1->id, $user3->id); + + \core_message\api::create_contact_request($user2->id, $user1->id); + \core_message\api::create_contact_request($user3->id, $user1->id); + + $requests = core_message_external::get_contact_requests($user1->id); + $requests = external_api::clean_returnvalue(core_message_external::get_contact_requests_returns(), $requests); + + $this->assertCount(1, $requests); + + $request = reset($requests); + + $this->assertEquals($user2->id, $request['id']); + $this->assertEquals($user2->picture, $request['picture']); + $this->assertEquals($user2->firstname, $request['firstname']); + $this->assertEquals($user2->lastname, $request['lastname']); + $this->assertEquals($user2->firstnamephonetic, $request['firstnamephonetic']); + $this->assertEquals($user2->lastnamephonetic, $request['lastnamephonetic']); + $this->assertEquals($user2->middlename, $request['middlename']); + $this->assertEquals($user2->alternatename, $request['alternatename']); + $this->assertEquals($user2->email, $request['email']); + } + + /** + * Test getting contact requests with messaging disabled. + */ + public function test_get_contact_requests_messaging_disabled() { + global $CFG; + + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Disable messaging. + $CFG->messaging = 0; + + // Ensure an exception is thrown. + $this->expectException('moodle_exception'); + core_message_external::get_contact_requests($user1->id); + } + + /** + * Test getting contact requests with no permission. + */ + public function test_get_contact_requests_no_permission() { + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + $user3 = self::getDataGenerator()->create_user(); + + $this->setUser($user3); + + // Ensure an exception is thrown. + $this->expectException('required_capability_exception'); + core_message_external::create_contact_request($user1->id, $user2->id); + } + + /** + * Test creating a contact request. + */ + public function test_create_contact_request() { + global $DB; + + $this->resetAfterTest(); + + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + $return = core_message_external::create_contact_request($user1->id, $user2->id); + $return = external_api::clean_returnvalue(core_message_external::create_contact_request_returns(), $return); + $this->assertEquals(array(), $return); + + $request = $DB->get_records('message_contact_requests'); + + $this->assertCount(1, $request); + + $request = reset($request); + + $this->assertEquals($user1->id, $request->userid); + $this->assertEquals($user2->id, $request->requesteduserid); + } + + /** + * Test creating a contact request with messaging disabled. + */ + public function test_create_contact_request_messaging_disabled() { + global $CFG; + + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Disable messaging. + $CFG->messaging = 0; + + // Ensure an exception is thrown. + $this->expectException('moodle_exception'); + core_message_external::create_contact_request($user1->id, $user2->id); + } + + /** + * Test creating a contact request with no permission. + */ + public function test_create_contact_request_no_permission() { + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + $user3 = self::getDataGenerator()->create_user(); + + $this->setUser($user3); + + // Ensure an exception is thrown. + $this->expectException('required_capability_exception'); + core_message_external::create_contact_request($user1->id, $user2->id); + } + + /** + * Test confirming a contact request. + */ + public function test_confirm_contact_request() { + global $DB; + + $this->resetAfterTest(); + + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + \core_message\api::create_contact_request($user1->id, $user2->id); + + $this->setUser($user2); + + $return = core_message_external::confirm_contact_request($user1->id, $user2->id); + $return = external_api::clean_returnvalue(core_message_external::confirm_contact_request_returns(), $return); + $this->assertEquals(array(), $return); + + $this->assertEquals(0, $DB->count_records('message_contact_requests')); + + $contact = $DB->get_records('message_contacts'); + + $this->assertCount(1, $contact); + + $contact = reset($contact); + + $this->assertEquals($user1->id, $contact->userid); + $this->assertEquals($user2->id, $contact->contactid); + } + + /** + * Test confirming a contact request with messaging disabled. + */ + public function test_confirm_contact_request_messaging_disabled() { + global $CFG; + + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Disable messaging. + $CFG->messaging = 0; + + // Ensure an exception is thrown. + $this->expectException('moodle_exception'); + core_message_external::confirm_contact_request($user1->id, $user2->id); + } + + /** + * Test confirming a contact request with no permission. + */ + public function test_confirm_contact_request_no_permission() { + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + $user3 = self::getDataGenerator()->create_user(); + + $this->setUser($user3); + + // Ensure an exception is thrown. + $this->expectException('required_capability_exception'); + core_message_external::confirm_contact_request($user1->id, $user2->id); + } + + /** + * Test declining a contact request. + */ + public function test_decline_contact_request() { + global $DB; + + $this->resetAfterTest(); + + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + \core_message\api::create_contact_request($user1->id, $user2->id); + + $this->setUser($user2); + + $return = core_message_external::decline_contact_request($user1->id, $user2->id); + $return = external_api::clean_returnvalue(core_message_external::decline_contact_request_returns(), $return); + $this->assertEquals(array(), $return); + + $this->assertEquals(0, $DB->count_records('message_contact_requests')); + $this->assertEquals(0, $DB->count_records('message_contacts')); + } + + /** + * Test declining a contact request with messaging disabled. + */ + public function test_decline_contact_request_messaging_disabled() { + global $CFG; + + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Disable messaging. + $CFG->messaging = 0; + + // Ensure an exception is thrown. + $this->expectException('moodle_exception'); + core_message_external::decline_contact_request($user1->id, $user2->id); + } + + /** + * Test declining a contact request with no permission. + */ + public function test_decline_contact_request_no_permission() { + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + $user3 = self::getDataGenerator()->create_user(); + + $this->setUser($user3); + + // Ensure an exception is thrown. + $this->expectException('required_capability_exception'); + core_message_external::decline_contact_request($user1->id, $user2->id); + } + + /** + * Test blocking a user. + */ + public function test_block_user() { + global $DB; + + $this->resetAfterTest(true); + + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Blocking a user. + $return = core_message_external::block_user($user1->id, $user2->id); + $return = external_api::clean_returnvalue(core_message_external::block_user_returns(), $return); + $this->assertEquals(array(), $return); + + // Get list of blocked users. + $record = $DB->get_record('message_users_blocked', []); + + $this->assertEquals($user1->id, $record->userid); + $this->assertEquals($user2->id, $record->blockeduserid); + + // Blocking a user who is already blocked. + $return = core_message_external::block_user($user1->id, $user2->id); + $return = external_api::clean_returnvalue(core_message_external::block_user_returns(), $return); + $this->assertEquals(array(), $return); + + $this->assertEquals(1, $DB->count_records('message_users_blocked')); + } + + /** + * Test blocking a user with messaging disabled. + */ + public function test_block_user_messaging_disabled() { + global $CFG; + + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Disable messaging. + $CFG->messaging = 0; + + // Ensure an exception is thrown. + $this->expectException('moodle_exception'); + core_message_external::block_user($user1->id, $user2->id); + } + + /** + * Test blocking a user with no permission. + */ + public function test_block_user_no_permission() { + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + $user3 = self::getDataGenerator()->create_user(); + + $this->setUser($user3); + + // Ensure an exception is thrown. + $this->expectException('required_capability_exception'); + core_message_external::block_user($user1->id, $user2->id); + } + + /** + * Test unblocking a user. + */ + public function test_unblock_user() { + global $DB; + + $this->resetAfterTest(true); + + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Block the user. + \core_message\api::block_user($user1->id, $user2->id); + + // Unblocking a user. + $return = core_message_external::unblock_user($user1->id, $user2->id); + $return = external_api::clean_returnvalue(core_message_external::unblock_user_returns(), $return); + $this->assertEquals(array(), $return); + + $this->assertEquals(0, $DB->count_records('message_users_blocked')); + + // Unblocking a user who is already unblocked. + $return = core_message_external::unblock_user($user1->id, $user2->id); + $return = external_api::clean_returnvalue(core_message_external::unblock_user_returns(), $return); + $this->assertEquals(array(), $return); + + $this->assertEquals(0, $DB->count_records('message_users_blocked')); + } + + /** + * Test unblocking a user with messaging disabled. + */ + public function test_unblock_user_messaging_disabled() { + global $CFG; + + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + + $this->setUser($user1); + + // Disable messaging. + $CFG->messaging = 0; + + // Ensure an exception is thrown. + $this->expectException('moodle_exception'); + core_message_external::unblock_user($user1->id, $user2->id); + } + + /** + * Test unblocking a user with no permission. + */ + public function test_unblock_user_no_permission() { + $this->resetAfterTest(); + + // Create some skeleton data just so we can call the WS. + $user1 = self::getDataGenerator()->create_user(); + $user2 = self::getDataGenerator()->create_user(); + $user3 = self::getDataGenerator()->create_user(); + + $this->setUser($user3); + + // Ensure an exception is thrown. + $this->expectException('required_capability_exception'); + core_message_external::unblock_user($user1->id, $user2->id); + } + /** * Test get_contacts. */ diff --git a/version.php b/version.php index e98f626efe0..a659fed374e 100644 --- a/version.php +++ b/version.php @@ -29,7 +29,7 @@ defined('MOODLE_INTERNAL') || die(); -$version = 2018092800.03; // YYYYMMDD = weekly release date of this DEV branch. +$version = 2018092800.04; // YYYYMMDD = weekly release date of this DEV branch. // RR = release increments - 00 in DEV branches. // .XX = incremental changes. -- 2.43.0