mod/data/tests/externallib_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Database module external functions tests
  19  *
  20  * @package    mod_data
  21  * @category   external
  22  * @copyright  2015 Juan Leyva <juan@moodle.com>
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  * @since      Moodle 2.9
  25  */
  26
  27 defined('MOODLE_INTERNAL') || die();
  28
  29 global $CFG;
  30
  31 require_once($CFG->dirroot . '/webservice/tests/helpers.php');
  32
  33 /**
  34  * Database module external functions tests
  35  *
  36  * @package    mod_data
  37  * @category   external
  38  * @copyright  2015 Juan Leyva <juan@moodle.com>
  39  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  40  * @since      Moodle 2.9
  41  */
  42 class mod_data_external_testcase extends externallib_advanced_testcase {
  43
  44     /** @var stdClass Test module context. */
  45     protected $context;
  46
  47     /** @var stdClass Test course.*/
  48     protected $course;
  49
  50     /** @var stdClass Test course module. */
  51     protected $cm;
  52
  53     /** @var  stdClass Test database activity. */
  54     protected $database;
  55
  56     /** @var stdClass Test group 1. */
  57     protected $group1;
  58
  59     /** @var stdClass Test group 2. */
  60     protected $group2;
  61
  62     /** @var stdClass Test student 1. */
  63     protected $student1;
  64
  65     /** @var stdClass Test student 2. */
  66     protected $student2;
  67
  68     /** @var stdClass Test student 3. */
  69     protected $student3;
  70
  71     /** @var stdClass Test student 4. */
  72     protected $student4;
  73
  74     /** @var stdClass Student role. */
  75     protected $studentrole;
  76
  77     /** @var stdClass Test teacher. */
  78     protected $teacher;
  79
  80     /** @var stdClass Teacher role. */
  81     protected $teacherrole;
  82
  83     /**
  84      * Set up for every test
  85      */
  86     public function setUp() {
  87         global $DB;
  88         $this->resetAfterTest();
  89         $this->setAdminUser();
  90
  91         // Setup test data.
  92         $course = new stdClass();
  93         $course->groupmode = SEPARATEGROUPS;
  94         $course->groupmodeforce = true;
  95         $this->course = $this->getDataGenerator()->create_course($course);
  96         $this->database = $this->getDataGenerator()->create_module('data', array('course' => $this->course->id));
  97         $this->context = context_module::instance($this->database->cmid);
  98         $this->cm = get_coursemodule_from_instance('data', $this->database->id);
  99
 100         // Create users.
 101         $this->student1 = self::getDataGenerator()->create_user(['firstname' => 'Olivia', 'lastname' => 'Smith']);
 102         $this->student2 = self::getDataGenerator()->create_user(['firstname' => 'Ezra', 'lastname' => 'Johnson']);
 103         $this->student3 = self::getDataGenerator()->create_user(['firstname' => 'Amelia', 'lastname' => 'Williams']);
 104         $this->teacher = self::getDataGenerator()->create_user(['firstname' => 'Asher', 'lastname' => 'Jones']);
 105
 106         // Users enrolments.
 107         $this->studentrole = $DB->get_record('role', array('shortname' => 'student'));
 108         $this->teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
 109         $this->getDataGenerator()->enrol_user($this->student1->id, $this->course->id, $this->studentrole->id, 'manual');
 110         $this->getDataGenerator()->enrol_user($this->student2->id, $this->course->id, $this->studentrole->id, 'manual');
 111         $this->getDataGenerator()->enrol_user($this->student3->id, $this->course->id, $this->studentrole->id, 'manual');
 112         $this->getDataGenerator()->enrol_user($this->teacher->id, $this->course->id, $this->teacherrole->id, 'manual');
 113
 114         $this->group1 = $this->getDataGenerator()->create_group(array('courseid' => $this->course->id));
 115         $this->group2 = $this->getDataGenerator()->create_group(array('courseid' => $this->course->id));
 116         groups_add_member($this->group1, $this->student1);
 117         groups_add_member($this->group1, $this->student2);
 118         groups_add_member($this->group2, $this->student3);
 119     }
 120
 121     /**
 122      * Test get databases by courses
 123      */
 124     public function test_mod_data_get_databases_by_courses() {
 125         global $DB;
 126
 127         $this->resetAfterTest(true);
 128
 129         // Create users.
 130         $student = self::getDataGenerator()->create_user();
 131         $teacher = self::getDataGenerator()->create_user();
 132
 133         // Set to the student user.
 134         self::setUser($student);
 135
 136         // Create courses to add the modules.
 137         $course1 = self::getDataGenerator()->create_course();
 138         $course2 = self::getDataGenerator()->create_course();
 139
 140         // First database.
 141         $record = new stdClass();
 142         $record->introformat = FORMAT_HTML;
 143         $record->course = $course1->id;
 144         $database1 = self::getDataGenerator()->create_module('data', $record);
 145
 146         // Second database.
 147         $record = new stdClass();
 148         $record->introformat = FORMAT_HTML;
 149         $record->course = $course2->id;
 150         $database2 = self::getDataGenerator()->create_module('data', $record);
 151
 152         $studentrole = $DB->get_record('role', array('shortname' => 'student'));
 153         $teacherrole = $DB->get_record('role', array('shortname' => 'editingteacher'));
 154
 155         // Users enrolments.
 156         $this->getDataGenerator()->enrol_user($student->id, $course1->id, $studentrole->id, 'manual');
 157         $this->getDataGenerator()->enrol_user($teacher->id, $course1->id, $teacherrole->id, 'manual');
 158
 159         // Execute real Moodle enrolment as we'll call unenrol() method on the instance later.
 160         $enrol = enrol_get_plugin('manual');
 161         $enrolinstances = enrol_get_instances($course2->id, true);
 162         foreach ($enrolinstances as $courseenrolinstance) {
 163             if ($courseenrolinstance->enrol == "manual") {
 164                 $instance2 = $courseenrolinstance;
 165                 break;
 166             }
 167         }
 168         $enrol->enrol_user($instance2, $student->id, $studentrole->id);
 169
 170         // Create what we expect to be returned when querying the two courses.
 171         // First for the student user.
 172         $expectedfields = array('id', 'coursemodule', 'course', 'name', 'comments', 'timeavailablefrom',
 173                             'timeavailableto', 'timeviewfrom', 'timeviewto', 'requiredentries', 'requiredentriestoview',
 174                             'intro', 'introformat', 'introfiles', 'maxentries', 'rssarticles', 'singletemplate', 'listtemplate',
 175                             'listtemplateheader', 'listtemplatefooter', 'addtemplate', 'rsstemplate', 'rsstitletemplate',
 176                             'csstemplate', 'jstemplate', 'asearchtemplate', 'approval', 'defaultsort', 'defaultsortdir', 'manageapproved');
 177
 178         // Add expected coursemodule.
 179         $database1->coursemodule = $database1->cmid;
 180         $database1->introfiles = [];
 181         $database2->coursemodule = $database2->cmid;
 182         $database2->introfiles = [];
 183
 184         $expected1 = array();
 185         $expected2 = array();
 186         foreach ($expectedfields as $field) {
 187             if ($field == 'approval' or $field == 'manageapproved') {
 188                 $database1->{$field} = (bool) $database1->{$field};
 189                 $database2->{$field} = (bool) $database2->{$field};
 190             }
 191             $expected1[$field] = $database1->{$field};
 192             $expected2[$field] = $database2->{$field};
 193         }
 194         $expected1['comments'] = (bool) $expected1['comments'];
 195         $expected2['comments'] = (bool) $expected2['comments'];
 196
 197         $expecteddatabases = array();
 198         $expecteddatabases[] = $expected2;
 199         $expecteddatabases[] = $expected1;
 200
 201         // Call the external function passing course ids.
 202         $result = mod_data_external::get_databases_by_courses(array($course2->id, $course1->id));
 203         $result = external_api::clean_returnvalue(mod_data_external::get_databases_by_courses_returns(), $result);
 204         $this->assertEquals($expecteddatabases, $result['databases']);
 205
 206         // Call the external function without passing course id.
 207         $result = mod_data_external::get_databases_by_courses();
 208         $result = external_api::clean_returnvalue(mod_data_external::get_databases_by_courses_returns(), $result);
 209         $this->assertEquals($expecteddatabases, $result['databases']);
 210
 211         // Unenrol user from second course and alter expected databases.
 212         $enrol->unenrol_user($instance2, $student->id);
 213         array_shift($expecteddatabases);
 214
 215         // Call the external function without passing course id.
 216         $result = mod_data_external::get_databases_by_courses();
 217         $result = external_api::clean_returnvalue(mod_data_external::get_databases_by_courses_returns(), $result);
 218         $this->assertEquals($expecteddatabases, $result['databases']);
 219
 220         // Call for the second course we unenrolled the user from, expected warning.
 221         $result = mod_data_external::get_databases_by_courses(array($course2->id));
 222         $this->assertCount(1, $result['warnings']);
 223         $this->assertEquals('1', $result['warnings'][0]['warningcode']);
 224         $this->assertEquals($course2->id, $result['warnings'][0]['itemid']);
 225
 226         // Now, try as a teacher for getting all the additional fields.
 227         self::setUser($teacher);
 228
 229         $additionalfields = array('scale', 'assessed', 'assesstimestart', 'assesstimefinish', 'editany', 'notification', 'timemodified');
 230
 231         foreach ($additionalfields as $field) {
 232             if ($field == 'editany') {
 233                 $database1->{$field} = (bool) $database1->{$field};
 234             }
 235             $expecteddatabases[0][$field] = $database1->{$field};
 236         }
 237         $result = mod_data_external::get_databases_by_courses();
 238         $result = external_api::clean_returnvalue(mod_data_external::get_databases_by_courses_returns(), $result);
 239         $this->assertEquals($expecteddatabases, $result['databases']);
 240
 241         // Admin should get all the information.
 242         self::setAdminUser();
 243
 244         $result = mod_data_external::get_databases_by_courses(array($course1->id));
 245         $result = external_api::clean_returnvalue(mod_data_external::get_databases_by_courses_returns(), $result);
 246         $this->assertEquals($expecteddatabases, $result['databases']);
 247     }
 248
 249     /**
 250      * Test view_database invalid id.
 251      */
 252     public function test_view_database_invalid_id() {
 253
 254         // Test invalid instance id.
 255         $this->expectException('moodle_exception');
 256         mod_data_external::view_database(0);
 257     }
 258
 259     /**
 260      * Test view_database not enrolled user.
 261      */
 262     public function test_view_database_not_enrolled_user() {
 263
 264         $usernotenrolled = self::getDataGenerator()->create_user();
 265         $this->setUser($usernotenrolled);
 266
 267         $this->expectException('moodle_exception');
 268         mod_data_external::view_database(0);
 269     }
 270
 271     /**
 272      * Test view_database no capabilities.
 273      */
 274     public function test_view_database_no_capabilities() {
 275         // Test user with no capabilities.
 276         // We need a explicit prohibit since this capability is allowed for students by default.
 277         assign_capability('mod/data:viewpage', CAP_PROHIBIT, $this->studentrole->id, $this->context->id);
 278         accesslib_clear_all_caches_for_unit_testing();
 279
 280         $this->expectException('moodle_exception');
 281         mod_data_external::view_database(0);
 282     }
 283
 284     /**
 285      * Test view_database.
 286      */
 287     public function test_view_database() {
 288
 289         // Test user with full capabilities.
 290         $this->setUser($this->student1);
 291
 292         // Trigger and capture the event.
 293         $sink = $this->redirectEvents();
 294
 295         $result = mod_data_external::view_database($this->database->id);
 296         $result = external_api::clean_returnvalue(mod_data_external::view_database_returns(), $result);
 297
 298         $events = $sink->get_events();
 299         $this->assertCount(1, $events);
 300         $event = array_shift($events);
 301
 302         // Checking that the event contains the expected values.
 303         $this->assertInstanceOf('\mod_data\event\course_module_viewed', $event);
 304         $this->assertEquals($this->context, $event->get_context());
 305         $moodledata = new \moodle_url('/mod/data/view.php', array('id' => $this->cm->id));
 306         $this->assertEquals($moodledata, $event->get_url());
 307         $this->assertEventContextNotUsed($event);
 308         $this->assertNotEmpty($event->get_name());
 309     }
 310
 311     /**
 312      * Test get_data_access_information for student.
 313      */
 314     public function test_get_data_access_information_student() {
 315         global $DB;
 316         // Modify the database to add access restrictions.
 317         $this->database->timeavailablefrom = time() + DAYSECS;
 318         $this->database->requiredentries = 2;
 319         $this->database->requiredentriestoview = 2;
 320         $DB->update_record('data', $this->database);
 321
 322         // Test user with full capabilities.
 323         $this->setUser($this->student1);
 324
 325         $result = mod_data_external::get_data_access_information($this->database->id);
 326         $result = external_api::clean_returnvalue(mod_data_external::get_data_access_information_returns(), $result);
 327
 328         $this->assertEquals($this->group1->id, $result['groupid']);
 329
 330         $this->assertFalse($result['canmanageentries']);
 331         $this->assertFalse($result['canapprove']);
 332         $this->assertTrue($result['canaddentry']);  // It return true because it doen't check time restrictions.
 333         $this->assertFalse($result['timeavailable']);
 334         $this->assertFalse($result['inreadonlyperiod']);
 335         $this->assertEquals(0, $result['numentries']);
 336         $this->assertEquals($this->database->requiredentries, $result['entrieslefttoadd']);
 337         $this->assertEquals($this->database->requiredentriestoview, $result['entrieslefttoview']);
 338     }
 339
 340     /**
 341      * Test get_data_access_information for teacher.
 342      */
 343     public function test_get_data_access_information_teacher() {
 344         global $DB;
 345         // Modify the database to add access restrictions.
 346         $this->database->timeavailablefrom = time() + DAYSECS;
 347         $this->database->requiredentries = 2;
 348         $this->database->requiredentriestoview = 2;
 349         $DB->update_record('data', $this->database);
 350
 351         // Test user with full capabilities.
 352         $this->setUser($this->teacher);
 353
 354         $result = mod_data_external::get_data_access_information($this->database->id);
 355         $result = external_api::clean_returnvalue(mod_data_external::get_data_access_information_returns(), $result);
 356
 357         $this->assertEquals(0, $result['groupid']);
 358
 359         $this->assertTrue($result['canmanageentries']);
 360         $this->assertTrue($result['canapprove']);
 361         $this->assertTrue($result['canaddentry']);  // It return true because it doen't check time restrictions.
 362         $this->assertTrue($result['timeavailable']);
 363         $this->assertFalse($result['inreadonlyperiod']);
 364         $this->assertEquals(0, $result['numentries']);
 365         $this->assertEquals(0, $result['entrieslefttoadd']);
 366         $this->assertEquals(0, $result['entrieslefttoview']);
 367     }
 368
 369     /**
 370      * Helper method to populate the database with some entries.
 371      *
 372      * @return array the entry ids created
 373      */
 374     public function populate_database_with_entries() {
 375         global $DB;
 376
 377         // Force approval.
 378         $DB->set_field('data', 'approval', 1, array('id' => $this->database->id));
 379         $generator = $this->getDataGenerator()->get_plugin_generator('mod_data');
 380         $fieldtypes = array('checkbox', 'date', 'menu', 'multimenu', 'number', 'radiobutton', 'text', 'textarea', 'url');
 381
 382         $count = 1;
 383         // Creating test Fields with default parameter values.
 384         foreach ($fieldtypes as $fieldtype) {
 385             $fieldname = 'field-' . $count;
 386             $record = new StdClass();
 387             $record->name = $fieldname;
 388             $record->type = $fieldtype;
 389             $record->required = 1;
 390
 391             $generator->create_field($record, $this->database);
 392             $count++;
 393         }
 394         // Get all the fields created.
 395         $fields = $DB->get_records('data_fields', array('dataid' => $this->database->id), 'id');
 396
 397         // Populate with contents, creating a new entry.
 398         $contents = array();
 399         $contents[] = array('opt1', 'opt2', 'opt3', 'opt4');
 400         $contents[] = '01-01-2037'; // It should be lower than 2038, to avoid failing on 32-bit windows.
 401         $contents[] = 'menu1';
 402         $contents[] = array('multimenu1', 'multimenu2', 'multimenu3', 'multimenu4');
 403         $contents[] = '12345';
 404         $contents[] = 'radioopt1';
 405         $contents[] = 'text for testing';
 406         $contents[] = '<p>text area testing<br /></p>';
 407         $contents[] = array('example.url', 'sampleurl');
 408         $count = 0;
 409         $fieldcontents = array();
 410         foreach ($fields as $fieldrecord) {
 411             $fieldcontents[$fieldrecord->id] = $contents[$count++];
 412         }
 413
 414         $this->setUser($this->student1);
 415         $entry11 = $generator->create_entry($this->database, $fieldcontents, $this->group1->id);
 416         $this->setUser($this->student2);
 417         $entry12 = $generator->create_entry($this->database, $fieldcontents, $this->group1->id);
 418         $entry13 = $generator->create_entry($this->database, $fieldcontents, $this->group1->id);
 419         // Entry not in group.
 420         $entry14 = $generator->create_entry($this->database, $fieldcontents, 0);
 421
 422         $this->setUser($this->student3);
 423         $entry21 = $generator->create_entry($this->database, $fieldcontents, $this->group2->id);
 424
 425         // Approve all except $entry13.
 426         $DB->set_field('data_records', 'approved', 1, ['id' => $entry11]);
 427         $DB->set_field('data_records', 'approved', 1, ['id' => $entry12]);
 428         $DB->set_field('data_records', 'approved', 1, ['id' => $entry14]);
 429         $DB->set_field('data_records', 'approved', 1, ['id' => $entry21]);
 430
 431         return [$entry11, $entry12, $entry13, $entry14, $entry21];
 432     }
 433
 434     /**
 435      * Test get_entries
 436      */
 437     public function test_get_entries() {
 438         global $DB;
 439         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 440
 441         // First of all, expect to see only my group entries (not other users in other groups ones).
 442         // We may expect entries without group also.
 443         $this->setUser($this->student1);
 444         $result = mod_data_external::get_entries($this->database->id);
 445         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 446         $this->assertCount(0, $result['warnings']);
 447         $this->assertCount(3, $result['entries']);
 448         $this->assertEquals(3, $result['totalcount']);
 449         $this->assertEquals($entry11, $result['entries'][0]['id']);
 450         $this->assertEquals($this->student1->id, $result['entries'][0]['userid']);
 451         $this->assertEquals($this->group1->id, $result['entries'][0]['groupid']);
 452         $this->assertEquals($this->database->id, $result['entries'][0]['dataid']);
 453         $this->assertEquals($entry12, $result['entries'][1]['id']);
 454         $this->assertEquals($this->student2->id, $result['entries'][1]['userid']);
 455         $this->assertEquals($this->group1->id, $result['entries'][1]['groupid']);
 456         $this->assertEquals($this->database->id, $result['entries'][1]['dataid']);
 457         $this->assertEquals($entry14, $result['entries'][2]['id']);
 458         $this->assertEquals($this->student2->id, $result['entries'][2]['userid']);
 459         $this->assertEquals(0, $result['entries'][2]['groupid']);
 460         $this->assertEquals($this->database->id, $result['entries'][2]['dataid']);
 461         // Other user in same group.
 462         $this->setUser($this->student2);
 463         $result = mod_data_external::get_entries($this->database->id);
 464         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 465         $this->assertCount(0, $result['warnings']);
 466         $this->assertCount(4, $result['entries']);  // I can see my entry not approved yet.
 467         $this->assertEquals(4, $result['totalcount']);
 468
 469         // Now try with the user in the second group that must see only two entries (his group entry and the one without group).
 470         $this->setUser($this->student3);
 471         $result = mod_data_external::get_entries($this->database->id);
 472         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 473         $this->assertCount(0, $result['warnings']);
 474         $this->assertCount(2, $result['entries']);
 475         $this->assertEquals(2, $result['totalcount']);
 476         $this->assertEquals($entry14, $result['entries'][0]['id']);
 477         $this->assertEquals($this->student2->id, $result['entries'][0]['userid']);
 478         $this->assertEquals(0, $result['entries'][0]['groupid']);
 479         $this->assertEquals($this->database->id, $result['entries'][0]['dataid']);
 480         $this->assertEquals($entry21, $result['entries'][1]['id']);
 481         $this->assertEquals($this->student3->id, $result['entries'][1]['userid']);
 482         $this->assertEquals($this->group2->id, $result['entries'][1]['groupid']);
 483         $this->assertEquals($this->database->id, $result['entries'][1]['dataid']);
 484
 485         // Now, as teacher we should see all (we have permissions to view all groups).
 486         $this->setUser($this->teacher);
 487         $result = mod_data_external::get_entries($this->database->id);
 488         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 489         $this->assertCount(0, $result['warnings']);
 490         $this->assertCount(5, $result['entries']);  // I can see the not approved one.
 491         $this->assertEquals(5, $result['totalcount']);
 492
 493         $entries = $DB->get_records('data_records', array('dataid' => $this->database->id), 'id');
 494         $this->assertCount(5, $entries);
 495         $count = 0;
 496         foreach ($entries as $entry) {
 497             $this->assertEquals($entry->id, $result['entries'][$count]['id']);
 498             $count++;
 499         }
 500
 501         // Basic test passing the parameter (instead having to calculate it).
 502         $this->setUser($this->student1);
 503         $result = mod_data_external::get_entries($this->database->id, $this->group1->id);
 504         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 505         $this->assertCount(0, $result['warnings']);
 506         $this->assertCount(3, $result['entries']);
 507         $this->assertEquals(3, $result['totalcount']);
 508
 509         // Test ordering (reverse).
 510         $this->setUser($this->student1);
 511         $result = mod_data_external::get_entries($this->database->id, $this->group1->id, false, null, 'DESC');
 512         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 513         $this->assertCount(0, $result['warnings']);
 514         $this->assertCount(3, $result['entries']);
 515         $this->assertEquals(3, $result['totalcount']);
 516         $this->assertEquals($entry14, $result['entries'][0]['id']);
 517
 518         // Test pagination.
 519         $this->setUser($this->student1);
 520         $result = mod_data_external::get_entries($this->database->id, $this->group1->id, false, null, null, 0, 1);
 521         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 522         $this->assertCount(0, $result['warnings']);
 523         $this->assertCount(1, $result['entries']);
 524         $this->assertEquals(3, $result['totalcount']);
 525         $this->assertEquals($entry11, $result['entries'][0]['id']);
 526
 527         $result = mod_data_external::get_entries($this->database->id, $this->group1->id, false, null, null, 1, 1);
 528         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 529         $this->assertCount(0, $result['warnings']);
 530         $this->assertCount(1, $result['entries']);
 531         $this->assertEquals(3, $result['totalcount']);
 532         $this->assertEquals($entry12, $result['entries'][0]['id']);
 533
 534         // Now test the return contents.
 535         data_generate_default_template($this->database, 'listtemplate', 0, false, true); // Generate a default list template.
 536         $result = mod_data_external::get_entries($this->database->id, $this->group1->id, true, null, null, 0, 2);
 537         $result = external_api::clean_returnvalue(mod_data_external::get_entries_returns(), $result);
 538         $this->assertCount(0, $result['warnings']);
 539         $this->assertCount(2, $result['entries']);
 540         $this->assertEquals(3, $result['totalcount']);
 541         $this->assertCount(9, $result['entries'][0]['contents']);
 542         $this->assertCount(9, $result['entries'][1]['contents']);
 543         // Search for some content.
 544         $this->assertTrue(strpos($result['listviewcontents'], 'opt1') !== false);
 545         $this->assertTrue(strpos($result['listviewcontents'], 'January') !== false);
 546         $this->assertTrue(strpos($result['listviewcontents'], 'menu1') !== false);
 547         $this->assertTrue(strpos($result['listviewcontents'], 'text for testing') !== false);
 548         $this->assertTrue(strpos($result['listviewcontents'], 'sampleurl') !== false);
 549     }
 550
 551     /**
 552      * Test get_entry_visible_groups.
 553      */
 554     public function test_get_entry_visible_groups() {
 555         global $DB;
 556
 557         $DB->set_field('course', 'groupmode', VISIBLEGROUPS, ['id' => $this->course->id]);
 558         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 559
 560         // Check I can see my approved group entries.
 561         $this->setUser($this->student1);
 562         $result = mod_data_external::get_entry($entry11);
 563         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 564         $this->assertCount(0, $result['warnings']);
 565         $this->assertEquals($entry11, $result['entry']['id']);
 566         $this->assertTrue($result['entry']['approved']);
 567         $this->assertTrue($result['entry']['canmanageentry']); // Is mine, I can manage it.
 568
 569         // Entry from other group.
 570         $result = mod_data_external::get_entry($entry21);
 571         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 572         $this->assertCount(0, $result['warnings']);
 573         $this->assertEquals($entry21, $result['entry']['id']);
 574     }
 575
 576     /**
 577      * Test get_entry_separated_groups.
 578      */
 579     public function test_get_entry_separated_groups() {
 580         global $DB;
 581         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 582
 583         // Check I can see my approved group entries.
 584         $this->setUser($this->student1);
 585         $result = mod_data_external::get_entry($entry11);
 586         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 587         $this->assertCount(0, $result['warnings']);
 588         $this->assertEquals($entry11, $result['entry']['id']);
 589         $this->assertTrue($result['entry']['approved']);
 590         $this->assertTrue($result['entry']['canmanageentry']); // Is mine, I can manage it.
 591
 592         // Retrieve contents.
 593         data_generate_default_template($this->database, 'singletemplate', 0, false, true);
 594         $result = mod_data_external::get_entry($entry11, true);
 595         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 596         $this->assertCount(0, $result['warnings']);
 597         $this->assertCount(9, $result['entry']['contents']);
 598         $this->assertTrue(strpos($result['entryviewcontents'], 'opt1') !== false);
 599         $this->assertTrue(strpos($result['entryviewcontents'], 'January') !== false);
 600         $this->assertTrue(strpos($result['entryviewcontents'], 'menu1') !== false);
 601         $this->assertTrue(strpos($result['entryviewcontents'], 'text for testing') !== false);
 602         $this->assertTrue(strpos($result['entryviewcontents'], 'sampleurl') !== false);
 603
 604         // This is in my group but I'm not the author.
 605         $result = mod_data_external::get_entry($entry12);
 606         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 607         $this->assertCount(0, $result['warnings']);
 608         $this->assertEquals($entry12, $result['entry']['id']);
 609         $this->assertTrue($result['entry']['approved']);
 610         $this->assertFalse($result['entry']['canmanageentry']); // Not mine.
 611
 612         $this->setUser($this->student3);
 613         $result = mod_data_external::get_entry($entry21);
 614         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 615         $this->assertCount(0, $result['warnings']);
 616         $this->assertEquals($entry21, $result['entry']['id']);
 617         $this->assertTrue($result['entry']['approved']);
 618         $this->assertTrue($result['entry']['canmanageentry']); // Is mine, I can manage it.
 619
 620         // As teacher I should be able to see all the entries.
 621         $this->setUser($this->teacher);
 622         $result = mod_data_external::get_entry($entry11);
 623         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 624         $this->assertEquals($entry11, $result['entry']['id']);
 625
 626         $result = mod_data_external::get_entry($entry12);
 627         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 628         $this->assertEquals($entry12, $result['entry']['id']);
 629         // This is the not approved one.
 630         $result = mod_data_external::get_entry($entry13);
 631         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 632         $this->assertEquals($entry13, $result['entry']['id']);
 633
 634         $result = mod_data_external::get_entry($entry21);
 635         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 636         $this->assertEquals($entry21, $result['entry']['id']);
 637
 638         // Now, try to get an entry not approved yet.
 639         $this->setUser($this->student1);
 640         $this->expectException('moodle_exception');
 641         $result = mod_data_external::get_entry($entry13);
 642     }
 643
 644     /**
 645      * Test get_entry from other group in separated groups.
 646      */
 647     public function test_get_entry_other_group_separated_groups() {
 648         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 649
 650         // We should not be able to view other gropu entries (in separated groups).
 651         $this->setUser($this->student1);
 652         $this->expectException('moodle_exception');
 653         $result = mod_data_external::get_entry($entry21);
 654     }
 655
 656     /**
 657      * Test get_fields.
 658      */
 659     public function test_get_fields() {
 660         global $DB;
 661         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 662
 663         $this->setUser($this->student1);
 664         $result = mod_data_external::get_fields($this->database->id);
 665         $result = external_api::clean_returnvalue(mod_data_external::get_fields_returns(), $result);
 666
 667         // Basically compare we retrieve all the fields and the correct values.
 668         $fields = $DB->get_records('data_fields', array('dataid' => $this->database->id), 'id');
 669         foreach ($result['fields'] as $field) {
 670             $this->assertEquals($field, (array) $fields[$field['id']]);
 671         }
 672     }
 673
 674     /**
 675      * Test get_fields_database_without_fields.
 676      */
 677     public function test_get_fields_database_without_fields() {
 678
 679         $this->setUser($this->student1);
 680         $result = mod_data_external::get_fields($this->database->id);
 681         $result = external_api::clean_returnvalue(mod_data_external::get_fields_returns(), $result);
 682
 683         $this->assertEmpty($result['fields']);
 684     }
 685
 686     /**
 687      * Test search_entries.
 688      */
 689     public function test_search_entries() {
 690         global $DB;
 691         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 692
 693         $this->setUser($this->student1);
 694         // Empty search, it should return all the visible entries.
 695         $result = mod_data_external::search_entries($this->database->id, 0, false);
 696         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 697         $this->assertCount(3, $result['entries']);
 698         $this->assertEquals(3, $result['totalcount']);
 699
 700         // Search for something that does not exists.
 701         $result = mod_data_external::search_entries($this->database->id, 0, false, 'abc');
 702         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 703         $this->assertCount(0, $result['entries']);
 704         $this->assertEquals(0, $result['totalcount']);
 705
 706         // Search by text matching all the entries.
 707         $result = mod_data_external::search_entries($this->database->id, 0, false, 'text');
 708         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 709         $this->assertCount(3, $result['entries']);
 710         $this->assertEquals(3, $result['totalcount']);
 711         $this->assertEquals(3, $result['maxcount']);
 712
 713         // Now as the other student I should receive my not approved entry. Apply ordering here.
 714         $this->setUser($this->student2);
 715         $result = mod_data_external::search_entries($this->database->id, 0, false, 'text', [], DATA_APPROVED, 'ASC');
 716         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 717         $this->assertCount(4, $result['entries']);
 718         $this->assertEquals(4, $result['totalcount']);
 719         $this->assertEquals(4, $result['maxcount']);
 720         // The not approved one should be the first.
 721         $this->assertEquals($entry13, $result['entries'][0]['id']);
 722
 723         // Now as the other group student.
 724         $this->setUser($this->student3);
 725         $result = mod_data_external::search_entries($this->database->id, 0, false, 'text');
 726         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 727         $this->assertCount(2, $result['entries']);
 728         $this->assertEquals(2, $result['totalcount']);
 729         $this->assertEquals(2, $result['maxcount']);
 730         $this->assertEquals($this->student2->id, $result['entries'][0]['userid']);
 731         $this->assertEquals($this->student3->id, $result['entries'][1]['userid']);
 732
 733         // Same normal text search as teacher.
 734         $this->setUser($this->teacher);
 735         $result = mod_data_external::search_entries($this->database->id, 0, false, 'text');
 736         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 737         $this->assertCount(5, $result['entries']);  // I can see all groups and non approved.
 738         $this->assertEquals(5, $result['totalcount']);
 739         $this->assertEquals(5, $result['maxcount']);
 740
 741         // Pagination.
 742         $this->setUser($this->teacher);
 743         $result = mod_data_external::search_entries($this->database->id, 0, false, 'text', [], DATA_TIMEADDED, 'ASC', 0, 2);
 744         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 745         $this->assertCount(2, $result['entries']);  // Only 2 per page.
 746         $this->assertEquals(5, $result['totalcount']);
 747         $this->assertEquals(5, $result['maxcount']);
 748
 749         // Now advanced search or not dinamic fields (user firstname for example).
 750         $this->setUser($this->student1);
 751         $advsearch = [
 752             ['name' => 'fn', 'value' => json_encode($this->student2->firstname)]
 753         ];
 754         $result = mod_data_external::search_entries($this->database->id, 0, false, '', $advsearch);
 755         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 756         $this->assertCount(2, $result['entries']);
 757         $this->assertEquals(2, $result['totalcount']);
 758         $this->assertEquals(3, $result['maxcount']);
 759         $this->assertEquals($this->student2->id, $result['entries'][0]['userid']);  // I only found mine!
 760
 761         // Advanced search for fields.
 762         $field = $DB->get_record('data_fields', array('type' => 'url'));
 763         $advsearch = [
 764             ['name' => 'f_' . $field->id , 'value' => 'sampleurl']
 765         ];
 766         $result = mod_data_external::search_entries($this->database->id, 0, false, '', $advsearch);
 767         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 768         $this->assertCount(3, $result['entries']);  // Found two entries matching this.
 769         $this->assertEquals(3, $result['totalcount']);
 770         $this->assertEquals(3, $result['maxcount']);
 771
 772         // Combined search.
 773         $field2 = $DB->get_record('data_fields', array('type' => 'number'));
 774         $advsearch = [
 775             ['name' => 'f_' . $field->id , 'value' => 'sampleurl'],
 776             ['name' => 'f_' . $field2->id , 'value' => '12345'],
 777             ['name' => 'ln', 'value' => json_encode($this->student2->lastname)]
 778         ];
 779         $result = mod_data_external::search_entries($this->database->id, 0, false, '', $advsearch);
 780         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 781         $this->assertCount(2, $result['entries']);  // Only one matching everything.
 782         $this->assertEquals(2, $result['totalcount']);
 783         $this->assertEquals(3, $result['maxcount']);
 784
 785         // Combined search (no results).
 786         $field2 = $DB->get_record('data_fields', array('type' => 'number'));
 787         $advsearch = [
 788             ['name' => 'f_' . $field->id , 'value' => 'sampleurl'],
 789             ['name' => 'f_' . $field2->id , 'value' => '98780333'], // Non existent number.
 790         ];
 791         $result = mod_data_external::search_entries($this->database->id, 0, false, '', $advsearch);
 792         $result = external_api::clean_returnvalue(mod_data_external::search_entries_returns(), $result);
 793         $this->assertCount(0, $result['entries']);  // Only one matching everything.
 794         $this->assertEquals(0, $result['totalcount']);
 795         $this->assertEquals(3, $result['maxcount']);
 796     }
 797
 798     /**
 799      * Test approve_entry.
 800      */
 801     public function test_approve_entry() {
 802         global $DB;
 803         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 804
 805         $this->setUser($this->teacher);
 806         $this->assertEquals(0, $DB->get_field('data_records', 'approved', array('id' => $entry13)));
 807         $result = mod_data_external::approve_entry($entry13);
 808         $result = external_api::clean_returnvalue(mod_data_external::approve_entry_returns(), $result);
 809         $this->assertEquals(1, $DB->get_field('data_records', 'approved', array('id' => $entry13)));
 810     }
 811
 812     /**
 813      * Test unapprove_entry.
 814      */
 815     public function test_unapprove_entry() {
 816         global $DB;
 817         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 818
 819         $this->setUser($this->teacher);
 820         $this->assertEquals(1, $DB->get_field('data_records', 'approved', array('id' => $entry11)));
 821         $result = mod_data_external::approve_entry($entry11, false);
 822         $result = external_api::clean_returnvalue(mod_data_external::approve_entry_returns(), $result);
 823         $this->assertEquals(0, $DB->get_field('data_records', 'approved', array('id' => $entry11)));
 824     }
 825
 826     /**
 827      * Test approve_entry missing permissions.
 828      */
 829     public function test_approve_entry_missing_permissions() {
 830         global $DB;
 831         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 832
 833         $this->setUser($this->student1);
 834         $this->expectException('moodle_exception');
 835         mod_data_external::approve_entry($entry13);
 836     }
 837
 838     /**
 839      * Test delete_entry as teacher. Check I can delete any entry.
 840      */
 841     public function test_delete_entry_as_teacher() {
 842         global $DB;
 843         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 844
 845         $this->setUser($this->teacher);
 846         $result = mod_data_external::delete_entry($entry11);
 847         $result = external_api::clean_returnvalue(mod_data_external::delete_entry_returns(), $result);
 848         $this->assertEquals(0, $DB->count_records('data_records', array('id' => $entry11)));
 849
 850         // Entry in other group.
 851         $result = mod_data_external::delete_entry($entry21);
 852         $result = external_api::clean_returnvalue(mod_data_external::delete_entry_returns(), $result);
 853         $this->assertEquals(0, $DB->count_records('data_records', array('id' => $entry21)));
 854     }
 855
 856     /**
 857      * Test delete_entry as student. Check I can delete my own entries.
 858      */
 859     public function test_delete_entry_as_student() {
 860         global $DB;
 861         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 862
 863         $this->setUser($this->student1);
 864         $result = mod_data_external::delete_entry($entry11);
 865         $result = external_api::clean_returnvalue(mod_data_external::delete_entry_returns(), $result);
 866         $this->assertEquals(0, $DB->count_records('data_records', array('id' => $entry11)));
 867     }
 868
 869     /**
 870      * Test delete_entry as student in read only mode period. Check I cannot delete my own entries in that period.
 871      */
 872     public function test_delete_entry_as_student_in_read_only_period() {
 873         global $DB;
 874         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 875         // Set a time period.
 876         $this->database->timeviewfrom = time() - HOURSECS;
 877         $this->database->timeviewto = time() + HOURSECS;
 878         $DB->update_record('data', $this->database);
 879
 880         $this->setUser($this->student1);
 881         $this->expectException('moodle_exception');
 882         mod_data_external::delete_entry($entry11);
 883     }
 884
 885     /**
 886      * Test delete_entry with an user missing permissions.
 887      */
 888     public function test_delete_entry_missing_permissions() {
 889         global $DB;
 890         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 891
 892         $this->setUser($this->student1);
 893         $this->expectException('moodle_exception');
 894         mod_data_external::delete_entry($entry21);
 895     }
 896
 897     /**
 898      * Test add_entry.
 899      */
 900     public function test_add_entry() {
 901         global $DB;
 902         // First create the record structure and add some entries.
 903         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
 904
 905         $this->setUser($this->student1);
 906         $newentrydata = [];
 907         $fields = $DB->get_records('data_fields', array('dataid' => $this->database->id), 'id');
 908         // Prepare the new entry data.
 909         foreach ($fields as $field) {
 910             $subfield = $value = '';
 911
 912             switch ($field->type) {
 913                 case 'checkbox':
 914                     $value = ['opt1', 'opt2'];
 915                     break;
 916                 case 'date':
 917                     // Add two extra.
 918                     $newentrydata[] = [
 919                         'fieldid' => $field->id,
 920                         'subfield' => 'day',
 921                         'value' => json_encode('5')
 922                     ];
 923                     $newentrydata[] = [
 924                         'fieldid' => $field->id,
 925                         'subfield' => 'month',
 926                         'value' => json_encode('1')
 927                     ];
 928                     $subfield = 'year';
 929                     $value = '1981';
 930                     break;
 931                 case 'menu':
 932                     $value = 'menu1';
 933                     break;
 934                 case 'multimenu':
 935                     $value = ['multimenu1', 'multimenu4'];
 936                     break;
 937                 case 'number':
 938                     $value = 6;
 939                     break;
 940                 case 'radiobutton':
 941                     $value = 'radioopt1';
 942                     break;
 943                 case 'text':
 944                     $value = 'some text';
 945                     break;
 946                 case 'textarea':
 947                     $newentrydata[] = [
 948                         'fieldid' => $field->id,
 949                         'subfield' => 'content1',
 950                         'value' => json_encode(FORMAT_MOODLE)
 951                     ];
 952                     $newentrydata[] = [
 953                         'fieldid' => $field->id,
 954                         'subfield' => 'itemid',
 955                         'value' => json_encode(0)
 956                     ];
 957                     $value = 'more text';
 958                     break;
 959                 case 'url':
 960                     $value = 'https://moodle.org';
 961                     $subfield = 0;
 962                     break;
 963             }
 964
 965             $newentrydata[] = [
 966                 'fieldid' => $field->id,
 967                 'subfield' => $subfield,
 968                 'value' => json_encode($value)
 969             ];
 970         }
 971         $result = mod_data_external::add_entry($this->database->id, 0, $newentrydata);
 972         $result = external_api::clean_returnvalue(mod_data_external::add_entry_returns(), $result);
 973
 974         $newentryid = $result['newentryid'];
 975         $result = mod_data_external::get_entry($newentryid, true);
 976         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
 977         $this->assertEquals($this->student1->id, $result['entry']['userid']);
 978         $this->assertCount(9, $result['entry']['contents']);
 979         foreach ($result['entry']['contents'] as $content) {
 980             $field = $fields[$content['fieldid']];
 981             // Stored content same that the one retrieved by WS.
 982             $dbcontent = $DB->get_record('data_content', array('fieldid' => $field->id, 'recordid' => $newentryid));
 983             $this->assertEquals($dbcontent->content, $content['content']);
 984
 985             // Now double check everything stored is correct.
 986             if ($field->type == 'checkbox') {
 987                 $this->assertEquals('opt1##opt2', $content['content']);
 988                 continue;
 989             }
 990             if ($field->type == 'date') {
 991                 $this->assertEquals(347500800, $content['content']); // Date in gregorian format.
 992                 continue;
 993             }
 994             if ($field->type == 'menu') {
 995                 $this->assertEquals('menu1', $content['content']);
 996                 continue;
 997             }
 998             if ($field->type == 'multimenu') {
 999                 $this->assertEquals('multimenu1##multimenu4', $content['content']);
1000                 continue;
1001             }
1002             if ($field->type == 'number') {
1003                 $this->assertEquals(6, $content['content']);
1004                 continue;
1005             }
1006             if ($field->type == 'radiobutton') {
1007                 $this->assertEquals('radioopt1', $content['content']);
1008                 continue;
1009             }
1010             if ($field->type == 'text') {
1011                 $this->assertEquals('some text', $content['content']);
1012                 continue;
1013             }
1014             if ($field->type == 'textarea') {
1015                 $this->assertEquals('more text', $content['content']);
1016                 $this->assertEquals(FORMAT_MOODLE, $content['content1']);
1017                 continue;
1018             }
1019             if ($field->type == 'url') {
1020                 $this->assertEquals('https://moodle.org', $content['content']);
1021                 continue;
1022             }
1023             $this->assertEquals('multimenu1##multimenu4', $content['content']);
1024         }
1025
1026         // Now, try to add another entry but removing some required data.
1027         unset($newentrydata[0]);
1028         $result = mod_data_external::add_entry($this->database->id, 0, $newentrydata);
1029         $result = external_api::clean_returnvalue(mod_data_external::add_entry_returns(), $result);
1030         $this->assertEquals(0, $result['newentryid']);
1031         $this->assertCount(0, $result['generalnotifications']);
1032         $this->assertCount(1, $result['fieldnotifications']);
1033         $this->assertEquals('field-1', $result['fieldnotifications'][0]['fieldname']);
1034         $this->assertEquals(get_string('errormustsupplyvalue', 'data'), $result['fieldnotifications'][0]['notification']);
1035     }
1036
1037     /**
1038      * Test add_entry empty_form.
1039      */
1040     public function test_add_entry_empty_form() {
1041         $result = mod_data_external::add_entry($this->database->id, 0, []);
1042         $result = external_api::clean_returnvalue(mod_data_external::add_entry_returns(), $result);
1043         $this->assertEquals(0, $result['newentryid']);
1044         $this->assertCount(1, $result['generalnotifications']);
1045         $this->assertCount(0, $result['fieldnotifications']);
1046         $this->assertEquals(get_string('emptyaddform', 'data'), $result['generalnotifications'][0]);
1047     }
1048
1049     /**
1050      * Test add_entry read_only_period.
1051      */
1052     public function test_add_entry_read_only_period() {
1053         global $DB;
1054         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
1055         // Set a time period.
1056         $this->database->timeviewfrom = time() - HOURSECS;
1057         $this->database->timeviewto = time() + HOURSECS;
1058         $DB->update_record('data', $this->database);
1059
1060         $this->setUser($this->student1);
1061         $this->expectExceptionMessage(get_string('noaccess', 'data'));
1062         $this->expectException('moodle_exception');
1063         mod_data_external::add_entry($this->database->id, 0, []);
1064     }
1065
1066     /**
1067      * Test add_entry max_num_entries.
1068      */
1069     public function test_add_entry_max_num_entries() {
1070         global $DB;
1071         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
1072         // Set a time period.
1073         $this->database->maxentries = 1;
1074         $DB->update_record('data', $this->database);
1075
1076         $this->setUser($this->student1);
1077         $this->expectExceptionMessage(get_string('noaccess', 'data'));
1078         $this->expectException('moodle_exception');
1079         mod_data_external::add_entry($this->database->id, 0, []);
1080     }
1081
1082     /**
1083      * Test update_entry.
1084      */
1085     public function test_update_entry() {
1086         global $DB;
1087         // First create the record structure and add some entries.
1088         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
1089
1090         $this->setUser($this->student1);
1091         $newentrydata = [];
1092         $fields = $DB->get_records('data_fields', array('dataid' => $this->database->id), 'id');
1093         // Prepare the new entry data.
1094         foreach ($fields as $field) {
1095             $subfield = $value = '';
1096
1097             switch ($field->type) {
1098                 case 'checkbox':
1099                     $value = ['opt1', 'opt2'];
1100                     break;
1101                 case 'date':
1102                     // Add two extra.
1103                     $newentrydata[] = [
1104                         'fieldid' => $field->id,
1105                         'subfield' => 'day',
1106                         'value' => json_encode('5')
1107                     ];
1108                     $newentrydata[] = [
1109                         'fieldid' => $field->id,
1110                         'subfield' => 'month',
1111                         'value' => json_encode('1')
1112                     ];
1113                     $subfield = 'year';
1114                     $value = '1981';
1115                     break;
1116                 case 'menu':
1117                     $value = 'menu1';
1118                     break;
1119                 case 'multimenu':
1120                     $value = ['multimenu1', 'multimenu4'];
1121                     break;
1122                 case 'number':
1123                     $value = 6;
1124                     break;
1125                 case 'radiobutton':
1126                     $value = 'radioopt2';
1127                     break;
1128                 case 'text':
1129                     $value = 'some text';
1130                     break;
1131                 case 'textarea':
1132                     $newentrydata[] = [
1133                         'fieldid' => $field->id,
1134                         'subfield' => 'content1',
1135                         'value' => json_encode(FORMAT_MOODLE)
1136                     ];
1137                     $newentrydata[] = [
1138                         'fieldid' => $field->id,
1139                         'subfield' => 'itemid',
1140                         'value' => json_encode(0)
1141                     ];
1142                     $value = 'more text';
1143                     break;
1144                 case 'url':
1145                     $value = 'https://moodle.org';
1146                     $subfield = 0;
1147                     break;
1148             }
1149
1150             $newentrydata[] = [
1151                 'fieldid' => $field->id,
1152                 'subfield' => $subfield,
1153                 'value' => json_encode($value)
1154             ];
1155         }
1156         $result = mod_data_external::update_entry($entry11, $newentrydata);
1157         $result = external_api::clean_returnvalue(mod_data_external::update_entry_returns(), $result);
1158         $this->assertTrue($result['updated']);
1159         $this->assertCount(0, $result['generalnotifications']);
1160         $this->assertCount(0, $result['fieldnotifications']);
1161
1162         $result = mod_data_external::get_entry($entry11, true);
1163         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
1164         $this->assertEquals($this->student1->id, $result['entry']['userid']);
1165         $this->assertCount(9, $result['entry']['contents']);
1166         foreach ($result['entry']['contents'] as $content) {
1167             $field = $fields[$content['fieldid']];
1168             // Stored content same that the one retrieved by WS.
1169             $dbcontent = $DB->get_record('data_content', array('fieldid' => $field->id, 'recordid' => $entry11));
1170             $this->assertEquals($dbcontent->content, $content['content']);
1171
1172             // Now double check everything stored is correct.
1173             if ($field->type == 'checkbox') {
1174                 $this->assertEquals('opt1##opt2', $content['content']);
1175                 continue;
1176             }
1177             if ($field->type == 'date') {
1178                 $this->assertEquals(347500800, $content['content']); // Date in gregorian format.
1179                 continue;
1180             }
1181             if ($field->type == 'menu') {
1182                 $this->assertEquals('menu1', $content['content']);
1183                 continue;
1184             }
1185             if ($field->type == 'multimenu') {
1186                 $this->assertEquals('multimenu1##multimenu4', $content['content']);
1187                 continue;
1188             }
1189             if ($field->type == 'number') {
1190                 $this->assertEquals(6, $content['content']);
1191                 continue;
1192             }
1193             if ($field->type == 'radiobutton') {
1194                 $this->assertEquals('radioopt2', $content['content']);
1195                 continue;
1196             }
1197             if ($field->type == 'text') {
1198                 $this->assertEquals('some text', $content['content']);
1199                 continue;
1200             }
1201             if ($field->type == 'textarea') {
1202                 $this->assertEquals('more text', $content['content']);
1203                 $this->assertEquals(FORMAT_MOODLE, $content['content1']);
1204                 continue;
1205             }
1206             if ($field->type == 'url') {
1207                 $this->assertEquals('https://moodle.org', $content['content']);
1208                 continue;
1209             }
1210             $this->assertEquals('multimenu1##multimenu4', $content['content']);
1211         }
1212
1213         // Now, try to update the entry but removing some required data.
1214         unset($newentrydata[0]);
1215         $result = mod_data_external::update_entry($entry11, $newentrydata);
1216         $result = external_api::clean_returnvalue(mod_data_external::update_entry_returns(), $result);
1217         $this->assertFalse($result['updated']);
1218         $this->assertCount(0, $result['generalnotifications']);
1219         $this->assertCount(1, $result['fieldnotifications']);
1220         $this->assertEquals('field-1', $result['fieldnotifications'][0]['fieldname']);
1221         $this->assertEquals(get_string('errormustsupplyvalue', 'data'), $result['fieldnotifications'][0]['notification']);
1222     }
1223
1224     /**
1225      * Test update_entry sending empty data.
1226      */
1227     public function test_update_entry_empty_data() {
1228         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
1229
1230         $this->setUser($this->student1);
1231         $result = mod_data_external::update_entry($entry11, []);
1232         $result = external_api::clean_returnvalue(mod_data_external::update_entry_returns(), $result);
1233         $this->assertFalse($result['updated']);
1234         $this->assertCount(1, $result['generalnotifications']);
1235         $this->assertCount(9, $result['fieldnotifications']);
1236         $this->assertEquals(get_string('emptyaddform', 'data'), $result['generalnotifications'][0]);
1237     }
1238
1239     /**
1240      * Test update_entry in read only period.
1241      */
1242     public function test_update_entry_read_only_period() {
1243         global $DB;
1244         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
1245         // Set a time period.
1246         $this->database->timeviewfrom = time() - HOURSECS;
1247         $this->database->timeviewto = time() + HOURSECS;
1248         $DB->update_record('data', $this->database);
1249
1250         $this->setUser($this->student1);
1251         $this->expectExceptionMessage(get_string('noaccess', 'data'));
1252         $this->expectException('moodle_exception');
1253         mod_data_external::update_entry($entry11, []);
1254     }
1255
1256     /**
1257      * Test update_entry other_user.
1258      */
1259     public function test_update_entry_other_user() {
1260         // Try to update other user entry.
1261         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
1262         $this->setUser($this->student2);
1263         $this->expectExceptionMessage(get_string('noaccess', 'data'));
1264         $this->expectException('moodle_exception');
1265         mod_data_external::update_entry($entry11, []);
1266     }
1267
1268     /**
1269      * Test get_entry_rating_information.
1270      */
1271     public function test_get_entry_rating_information() {
1272         global $DB, $CFG;
1273         require_once($CFG->dirroot . '/rating/lib.php');
1274
1275         $DB->set_field('data', 'assessed', RATING_AGGREGATE_SUM, array('id' => $this->database->id));
1276         $DB->set_field('data', 'scale', 100, array('id' => $this->database->id));
1277         list($entry11, $entry12, $entry13, $entry14, $entry21) = self::populate_database_with_entries();
1278
1279         $user1 = self::getDataGenerator()->create_user();
1280         $user2 = self::getDataGenerator()->create_user();
1281         $this->getDataGenerator()->enrol_user($user1->id, $this->course->id, $this->studentrole->id, 'manual');
1282         $this->getDataGenerator()->enrol_user($user2->id, $this->course->id, $this->studentrole->id, 'manual');
1283
1284         // Rate the entry as user1.
1285         $rating1 = new stdClass();
1286         $rating1->contextid = $this->context->id;
1287         $rating1->component = 'mod_data';
1288         $rating1->ratingarea = 'entry';
1289         $rating1->itemid = $entry11;
1290         $rating1->rating = 50;
1291         $rating1->scaleid = 100;
1292         $rating1->userid = $user1->id;
1293         $rating1->timecreated = time();
1294         $rating1->timemodified = time();
1295         $rating1->id = $DB->insert_record('rating', $rating1);
1296
1297         // Rate the entry as user2.
1298         $rating2 = new stdClass();
1299         $rating2->contextid = $this->context->id;
1300         $rating2->component = 'mod_data';
1301         $rating2->ratingarea = 'entry';
1302         $rating2->itemid = $entry11;
1303         $rating2->rating = 100;
1304         $rating2->scaleid = 100;
1305         $rating2->userid = $user2->id;
1306         $rating2->timecreated = time() + 1;
1307         $rating2->timemodified = time() + 1;
1308         $rating2->id = $DB->insert_record('rating', $rating2);
1309
1310         // As student, retrieve ratings information.
1311         $this->setUser($this->student2);
1312         $result = mod_data_external::get_entry($entry11);
1313         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
1314         $this->assertCount(1, $result['ratinginfo']['ratings']);
1315         $this->assertFalse($result['ratinginfo']['ratings'][0]['canviewaggregate']);
1316         $this->assertFalse($result['ratinginfo']['canviewall']);
1317         $this->assertFalse($result['ratinginfo']['ratings'][0]['canrate']);
1318         $this->assertTrue(!isset($result['ratinginfo']['ratings'][0]['count']));
1319
1320         // Now, as teacher, I should see the info correctly.
1321         $this->setUser($this->teacher);
1322         $result = mod_data_external::get_entry($entry11);
1323         $result = external_api::clean_returnvalue(mod_data_external::get_entry_returns(), $result);
1324         $this->assertCount(1, $result['ratinginfo']['ratings']);
1325         $this->assertTrue($result['ratinginfo']['ratings'][0]['canviewaggregate']);
1326         $this->assertTrue($result['ratinginfo']['canviewall']);
1327         $this->assertTrue($result['ratinginfo']['ratings'][0]['canrate']);
1328         $this->assertEquals(2, $result['ratinginfo']['ratings'][0]['count']);
1329         $this->assertEquals(100, $result['ratinginfo']['ratings'][0]['aggregate']); // Expect maximium scale value.
1330     }
1331 }