Merge branch 'MDL-60418' of git://github.com/timhunt/moodle
[moodle.git] / lib / tests / behat / behat_data_generators.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/>.
17 /**
18  * Data generators for acceptance testing.
19  *
20  * @package   core
21  * @category  test
22  * @copyright 2012 David MonllaĆ³
23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 // NOTE: no MOODLE_INTERNAL test here, this file may be required by behat before including /config.php.
28 require_once(__DIR__ . '/../../behat/behat_base.php');
30 use Behat\Gherkin\Node\TableNode as TableNode;
31 use Behat\Behat\Tester\Exception\PendingException as PendingException;
33 /**
34  * Class to set up quickly a Given environment.
35  *
36  * Acceptance tests are block-boxed, so this steps definitions should only
37  * be used to set up the test environment as we are not replicating user steps.
38  *
39  * All data generators should be in lib/testing/generator/*, shared between phpunit
40  * and behat and they should be called from here, if possible using the standard
41  * 'create_$elementname($options)' and if it's not possible (data generators arguments will not be
42  * always the same) or the element is not suitable to be a data generator, create a
43  * 'process_$elementname($options)' method and use the data generator from there if possible.
44  *
45  * @todo      If the available elements list grows too much this class must be split into smaller pieces
46  * @package   core
47  * @category  test
48  * @copyright 2012 David MonllaĆ³
49  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
50  */
51 class behat_data_generators extends behat_base {
53     /**
54      * @var testing_data_generator
55      */
56     protected $datagenerator;
58     /**
59      * Each element specifies:
60      * - The data generator sufix used.
61      * - The required fields.
62      * - The mapping between other elements references and database field names.
63      * @var array
64      */
65     protected static $elements = array(
66         'users' => array(
67             'datagenerator' => 'user',
68             'required' => array('username')
69         ),
70         'categories' => array(
71             'datagenerator' => 'category',
72             'required' => array('idnumber'),
73             'switchids' => array('category' => 'parent')
74         ),
75         'courses' => array(
76             'datagenerator' => 'course',
77             'required' => array('shortname'),
78             'switchids' => array('category' => 'category')
79         ),
80         'groups' => array(
81             'datagenerator' => 'group',
82             'required' => array('idnumber', 'course'),
83             'switchids' => array('course' => 'courseid')
84         ),
85         'groupings' => array(
86             'datagenerator' => 'grouping',
87             'required' => array('idnumber', 'course'),
88             'switchids' => array('course' => 'courseid')
89         ),
90         'course enrolments' => array(
91             'datagenerator' => 'enrol_user',
92             'required' => array('user', 'course', 'role'),
93             'switchids' => array('user' => 'userid', 'course' => 'courseid', 'role' => 'roleid')
94         ),
95         'custom field categories' => array(
96             'datagenerator' => 'custom_field_category',
97             'required' => array('name', 'component', 'area', 'itemid'),
98             'switchids' => array()
99         ),
100         'custom fields' => array(
101             'datagenerator' => 'custom_field',
102             'required' => array('name', 'category', 'type', 'shortname'),
103             'switchids' => array()
104         ),
105         'permission overrides' => array(
106             'datagenerator' => 'permission_override',
107             'required' => array('capability', 'permission', 'role', 'contextlevel', 'reference'),
108             'switchids' => array('role' => 'roleid')
109         ),
110         'system role assigns' => array(
111             'datagenerator' => 'system_role_assign',
112             'required' => array('user', 'role'),
113             'switchids' => array('user' => 'userid', 'role' => 'roleid')
114         ),
115         'role assigns' => array(
116             'datagenerator' => 'role_assign',
117             'required' => array('user', 'role', 'contextlevel', 'reference'),
118             'switchids' => array('user' => 'userid', 'role' => 'roleid')
119         ),
120         'activities' => array(
121             'datagenerator' => 'activity',
122             'required' => array('activity', 'idnumber', 'course'),
123             'switchids' => array('course' => 'course', 'gradecategory' => 'gradecat')
124         ),
125         'blocks' => array(
126             'datagenerator' => 'block_instance',
127             'required' => array('blockname', 'contextlevel', 'reference'),
128         ),
129         'group members' => array(
130             'datagenerator' => 'group_member',
131             'required' => array('user', 'group'),
132             'switchids' => array('user' => 'userid', 'group' => 'groupid')
133         ),
134         'grouping groups' => array(
135             'datagenerator' => 'grouping_group',
136             'required' => array('grouping', 'group'),
137             'switchids' => array('grouping' => 'groupingid', 'group' => 'groupid')
138         ),
139         'cohorts' => array(
140             'datagenerator' => 'cohort',
141             'required' => array('idnumber')
142         ),
143         'cohort members' => array(
144             'datagenerator' => 'cohort_member',
145             'required' => array('user', 'cohort'),
146             'switchids' => array('user' => 'userid', 'cohort' => 'cohortid')
147         ),
148         'roles' => array(
149             'datagenerator' => 'role',
150             'required' => array('shortname')
151         ),
152         'grade categories' => array(
153             'datagenerator' => 'grade_category',
154             'required' => array('fullname', 'course'),
155             'switchids' => array('course' => 'courseid', 'gradecategory' => 'parent')
156         ),
157         'grade items' => array(
158             'datagenerator' => 'grade_item',
159             'required' => array('course'),
160             'switchids' => array('scale' => 'scaleid', 'outcome' => 'outcomeid', 'course' => 'courseid',
161                                  'gradecategory' => 'categoryid')
162         ),
163         'grade outcomes' => array(
164             'datagenerator' => 'grade_outcome',
165             'required' => array('shortname', 'scale'),
166             'switchids' => array('course' => 'courseid', 'gradecategory' => 'categoryid', 'scale' => 'scaleid')
167         ),
168         'scales' => array(
169             'datagenerator' => 'scale',
170             'required' => array('name', 'scale'),
171             'switchids' => array('course' => 'courseid')
172         ),
173         'question categories' => array(
174             'datagenerator' => 'question_category',
175             'required' => array('name', 'contextlevel', 'reference'),
176             'switchids' => array('questioncategory' => 'parent')
177         ),
178         'questions' => array(
179             'datagenerator' => 'question',
180             'required' => array('qtype', 'questioncategory', 'name'),
181             'switchids' => array('questioncategory' => 'category', 'user' => 'createdby')
182         ),
183         'tags' => array(
184             'datagenerator' => 'tag',
185             'required' => array('name')
186         ),
187         'events' => array(
188             'datagenerator' => 'event',
189             'required' => array('name', 'eventtype'),
190             'switchids' => array(
191                 'user' => 'userid',
192                 'course' => 'courseid',
193                 'category' => 'categoryid',
194             )
195         ),
196         'message contacts' => array(
197             'datagenerator' => 'message_contacts',
198             'required' => array('user', 'contact'),
199             'switchids' => array('user' => 'userid', 'contact' => 'contactid')
200         ),
201         'private messages' => array(
202             'datagenerator' => 'private_messages',
203             'required' => array('user', 'contact', 'message'),
204             'switchids' => array('user' => 'userid', 'contact' => 'contactid')
205         ),
206         'favourite conversations' => array(
207             'datagenerator' => 'favourite_conversations',
208             'required' => array('user', 'contact'),
209             'switchids' => array('user' => 'userid', 'contact' => 'contactid')
210         ),
211     );
213     /**
214      * Creates the specified element.
215      *
216      * The most reliable list of what types of thing can be created is the
217      * $elements array defined above.
218      *
219      * @Given /^the following "(?P<element_string>(?:[^"]|\\")*)" exist:$/
220      *
221      * @throws Exception
222      * @throws PendingException
223      * @param string    $elementname The name of the entity to add
224      * @param TableNode $data
225      */
226     public function the_following_exist($elementname, TableNode $data) {
228         // Now that we need them require the data generators.
229         require_once(__DIR__ . '/../../testing/generator/lib.php');
231         if (empty(self::$elements[$elementname])) {
232             throw new PendingException($elementname . ' data generator is not implemented');
233         }
235         $this->datagenerator = testing_util::get_data_generator();
237         $elementdatagenerator = self::$elements[$elementname]['datagenerator'];
238         $requiredfields = self::$elements[$elementname]['required'];
239         if (!empty(self::$elements[$elementname]['switchids'])) {
240             $switchids = self::$elements[$elementname]['switchids'];
241         }
243         foreach ($data->getHash() as $elementdata) {
245             // Check if all the required fields are there.
246             foreach ($requiredfields as $requiredfield) {
247                 if (!isset($elementdata[$requiredfield])) {
248                     throw new Exception($elementname . ' requires the field ' . $requiredfield . ' to be specified');
249                 }
250             }
252             // Switch from human-friendly references to ids.
253             if (isset($switchids)) {
254                 foreach ($switchids as $element => $field) {
255                     $methodname = 'get_' . $element . '_id';
257                     // Not all the switch fields are required, default vars will be assigned by data generators.
258                     if (isset($elementdata[$element])) {
259                         // Temp $id var to avoid problems when $element == $field.
260                         $id = $this->{$methodname}($elementdata[$element]);
261                         unset($elementdata[$element]);
262                         $elementdata[$field] = $id;
263                     }
264                 }
265             }
267             // Preprocess the entities that requires a special treatment.
268             if (method_exists($this, 'preprocess_' . $elementdatagenerator)) {
269                 $elementdata = $this->{'preprocess_' . $elementdatagenerator}($elementdata);
270             }
272             // Creates element.
273             $methodname = 'create_' . $elementdatagenerator;
274             if (method_exists($this->datagenerator, $methodname)) {
275                 // Using data generators directly.
276                 $this->datagenerator->{$methodname}($elementdata);
278             } else if (method_exists($this, 'process_' . $elementdatagenerator)) {
279                 // Using an alternative to the direct data generator call.
280                 $this->{'process_' . $elementdatagenerator}($elementdata);
281             } else {
282                 throw new PendingException($elementname . ' data generator is not implemented');
283             }
284         }
286     }
288     /**
289      * If password is not set it uses the username.
290      * @param array $data
291      * @return array
292      */
293     protected function preprocess_user($data) {
294         if (!isset($data['password'])) {
295             $data['password'] = $data['username'];
296         }
297         return $data;
298     }
300     /**
301      * If contextlevel and reference are specified for cohort, transform them to the contextid.
302      *
303      * @param array $data
304      * @return array
305      */
306     protected function preprocess_cohort($data) {
307         if (isset($data['contextlevel'])) {
308             if (!isset($data['reference'])) {
309                 throw new Exception('If field contextlevel is specified, field reference must also be present');
310             }
311             $context = $this->get_context($data['contextlevel'], $data['reference']);
312             unset($data['contextlevel']);
313             unset($data['reference']);
314             $data['contextid'] = $context->id;
315         }
316         return $data;
317     }
319     /**
320      * Preprocesses the creation of a grade item. Converts gradetype text to a number.
321      * @param array $data
322      * @return array
323      */
324     protected function preprocess_grade_item($data) {
325         global $CFG;
326         require_once("$CFG->libdir/grade/constants.php");
328         if (isset($data['gradetype'])) {
329             $data['gradetype'] = constant("GRADE_TYPE_" . strtoupper($data['gradetype']));
330         }
332         if (!empty($data['category']) && !empty($data['courseid'])) {
333             $cat = grade_category::fetch(array('fullname' => $data['category'], 'courseid' => $data['courseid']));
334             if (!$cat) {
335                 throw new Exception('Could not resolve category with name "' . $data['category'] . '"');
336             }
337             unset($data['category']);
338             $data['categoryid'] = $cat->id;
339         }
341         return $data;
342     }
344     /**
345      * Adapter to modules generator
346      * @throws Exception Custom exception for test writers
347      * @param array $data
348      * @return void
349      */
350     protected function process_activity($data) {
351         global $DB, $CFG;
353         // The the_following_exists() method checks that the field exists.
354         $activityname = $data['activity'];
355         unset($data['activity']);
357         // Convert scale name into scale id (negative number indicates using scale).
358         if (isset($data['grade']) && strlen($data['grade']) && !is_number($data['grade'])) {
359             $data['grade'] = - $this->get_scale_id($data['grade']);
360             require_once("$CFG->libdir/grade/constants.php");
362             if (!isset($data['gradetype'])) {
363                 $data['gradetype'] = GRADE_TYPE_SCALE;
364             }
365         }
367         // We split $data in the activity $record and the course module $options.
368         $cmoptions = array();
369         $cmcolumns = $DB->get_columns('course_modules');
370         foreach ($cmcolumns as $key => $value) {
371             if (isset($data[$key])) {
372                 $cmoptions[$key] = $data[$key];
373             }
374         }
376         // Custom exception.
377         try {
378             $this->datagenerator->create_module($activityname, $data, $cmoptions);
379         } catch (coding_exception $e) {
380             throw new Exception('\'' . $activityname . '\' activity can not be added using this step,' .
381                 ' use the step \'I add a "ACTIVITY_OR_RESOURCE_NAME_STRING" to section "SECTION_NUMBER"\' instead');
382         }
383     }
385     /**
386      * Add a block to a page.
387      *
388      * @param array $data should mostly match the fields of the block_instances table.
389      *     The block type is specified by blockname.
390      *     The parentcontextid is set from contextlevel and reference.
391      *     Missing values are filled in by testing_block_generator::prepare_record.
392      *     $data is passed to create_block as both $record and $options. Normally
393      *     the keys are different, so this is a way to let people set values in either place.
394      */
395     protected function process_block_instance($data) {
397         if (empty($data['blockname'])) {
398             throw new Exception('\'blocks\' requires the field \'block\' type to be specified');
399         }
401         if (empty($data['contextlevel'])) {
402             throw new Exception('\'blocks\' requires the field \'contextlevel\' to be specified');
403         }
405         if (!isset($data['reference'])) {
406             throw new Exception('\'blocks\' requires the field \'reference\' to be specified');
407         }
409         $context = $this->get_context($data['contextlevel'], $data['reference']);
410         $data['parentcontextid'] = $context->id;
412         // Pass $data as both $record and $options. I think that is unlikely to
413         // cause problems since the relevant key names are different.
414         // $options is not used in most blocks I have seen, but where it is, it is necessary.
415         $this->datagenerator->create_block($data['blockname'], $data, $data);
416     }
418     /**
419      * Adapter to enrol_user() data generator.
420      * @throws Exception
421      * @param array $data
422      * @return void
423      */
424     protected function process_enrol_user($data) {
425         global $SITE;
427         if (empty($data['roleid'])) {
428             throw new Exception('\'course enrolments\' requires the field \'role\' to be specified');
429         }
431         if (!isset($data['userid'])) {
432             throw new Exception('\'course enrolments\' requires the field \'user\' to be specified');
433         }
435         if (!isset($data['courseid'])) {
436             throw new Exception('\'course enrolments\' requires the field \'course\' to be specified');
437         }
439         if (!isset($data['enrol'])) {
440             $data['enrol'] = 'manual';
441         }
443         if (!isset($data['timestart'])) {
444             $data['timestart'] = 0;
445         }
447         if (!isset($data['timeend'])) {
448             $data['timeend'] = 0;
449         }
451         if (!isset($data['status'])) {
452             $data['status'] = null;
453         }
455         // If the provided course shortname is the site shortname we consider it a system role assign.
456         if ($data['courseid'] == $SITE->id) {
457             // Frontpage course assign.
458             $context = context_course::instance($data['courseid']);
459             role_assign($data['roleid'], $data['userid'], $context->id);
461         } else {
462             // Course assign.
463             $this->datagenerator->enrol_user($data['userid'], $data['courseid'], $data['roleid'], $data['enrol'],
464                     $data['timestart'], $data['timeend'], $data['status']);
465         }
467     }
469     /**
470      * Allows/denies a capability at the specified context
471      *
472      * @throws Exception
473      * @param array $data
474      * @return void
475      */
476     protected function process_permission_override($data) {
478         // Will throw an exception if it does not exist.
479         $context = $this->get_context($data['contextlevel'], $data['reference']);
481         switch ($data['permission']) {
482             case get_string('allow', 'role'):
483                 $permission = CAP_ALLOW;
484                 break;
485             case get_string('prevent', 'role'):
486                 $permission = CAP_PREVENT;
487                 break;
488             case get_string('prohibit', 'role'):
489                 $permission = CAP_PROHIBIT;
490                 break;
491             default:
492                 throw new Exception('The \'' . $data['permission'] . '\' permission does not exist');
493                 break;
494         }
496         if (is_null(get_capability_info($data['capability']))) {
497             throw new Exception('The \'' . $data['capability'] . '\' capability does not exist');
498         }
500         role_change_permission($data['roleid'], $context, $data['capability'], $permission);
501     }
503     /**
504      * Assigns a role to a user at system context
505      *
506      * Used by "system role assigns" can be deleted when
507      * system role assign will be deprecated in favour of
508      * "role assigns"
509      *
510      * @throws Exception
511      * @param array $data
512      * @return void
513      */
514     protected function process_system_role_assign($data) {
516         if (empty($data['roleid'])) {
517             throw new Exception('\'system role assigns\' requires the field \'role\' to be specified');
518         }
520         if (!isset($data['userid'])) {
521             throw new Exception('\'system role assigns\' requires the field \'user\' to be specified');
522         }
524         $context = context_system::instance();
526         $this->datagenerator->role_assign($data['roleid'], $data['userid'], $context->id);
527     }
529     /**
530      * Assigns a role to a user at the specified context
531      *
532      * @throws Exception
533      * @param array $data
534      * @return void
535      */
536     protected function process_role_assign($data) {
538         if (empty($data['roleid'])) {
539             throw new Exception('\'role assigns\' requires the field \'role\' to be specified');
540         }
542         if (!isset($data['userid'])) {
543             throw new Exception('\'role assigns\' requires the field \'user\' to be specified');
544         }
546         if (empty($data['contextlevel'])) {
547             throw new Exception('\'role assigns\' requires the field \'contextlevel\' to be specified');
548         }
550         if (!isset($data['reference'])) {
551             throw new Exception('\'role assigns\' requires the field \'reference\' to be specified');
552         }
554         // Getting the context id.
555         $context = $this->get_context($data['contextlevel'], $data['reference']);
557         $this->datagenerator->role_assign($data['roleid'], $data['userid'], $context->id);
558     }
560     /**
561      * Creates a role.
562      *
563      * @param array $data
564      * @return void
565      */
566     protected function process_role($data) {
568         // We require the user to fill the role shortname.
569         if (empty($data['shortname'])) {
570             throw new Exception('\'role\' requires the field \'shortname\' to be specified');
571         }
573         $this->datagenerator->create_role($data);
574     }
576     /**
577      * Adds members to cohorts
578      *
579      * @param array $data
580      * @return void
581      */
582     protected function process_cohort_member($data) {
583         cohort_add_member($data['cohortid'], $data['userid']);
584     }
586     /**
587      * Create a question category.
588      *
589      * @param array $data the row of data from the behat script.
590      */
591     protected function process_question_category($data) {
592         $context = $this->get_context($data['contextlevel'], $data['reference']);
593         $data['contextid'] = $context->id;
594         $this->datagenerator->get_plugin_generator('core_question')->create_question_category($data);
595     }
597     /**
598      * Create a question.
599      *
600      * Creating questions relies on the question/type/.../tests/helper.php mechanism.
601      * We start with test_question_maker::get_question_form_data($data['qtype'], $data['template'])
602      * and then overlay the values from any other fields of $data that are set.
603      *
604      * @param array $data the row of data from the behat script.
605      */
606     protected function process_question($data) {
607         if (array_key_exists('questiontext', $data)) {
608             $data['questiontext'] = array(
609                     'text'   => $data['questiontext'],
610                     'format' => FORMAT_HTML,
611                 );
612         }
614         if (array_key_exists('generalfeedback', $data)) {
615             $data['generalfeedback'] = array(
616                     'text'   => $data['generalfeedback'],
617                     'format' => FORMAT_HTML,
618                 );
619         }
621         $which = null;
622         if (!empty($data['template'])) {
623             $which = $data['template'];
624         }
626         $this->datagenerator->get_plugin_generator('core_question')->create_question($data['qtype'], $which, $data);
627     }
629     /**
630      * Gets the grade category id from the grade category fullname
631      * @throws Exception
632      * @param string $username
633      * @return int
634      */
635     protected function get_gradecategory_id($fullname) {
636         global $DB;
638         if (!$id = $DB->get_field('grade_categories', 'id', array('fullname' => $fullname))) {
639             throw new Exception('The specified grade category with fullname "' . $fullname . '" does not exist');
640         }
641         return $id;
642     }
644     /**
645      * Gets the user id from it's username.
646      * @throws Exception
647      * @param string $username
648      * @return int
649      */
650     protected function get_user_id($username) {
651         global $DB;
653         if (!$id = $DB->get_field('user', 'id', array('username' => $username))) {
654             throw new Exception('The specified user with username "' . $username . '" does not exist');
655         }
656         return $id;
657     }
659     /**
660      * Gets the role id from it's shortname.
661      * @throws Exception
662      * @param string $roleshortname
663      * @return int
664      */
665     protected function get_role_id($roleshortname) {
666         global $DB;
668         if (!$id = $DB->get_field('role', 'id', array('shortname' => $roleshortname))) {
669             throw new Exception('The specified role with shortname "' . $roleshortname . '" does not exist');
670         }
672         return $id;
673     }
675     /**
676      * Gets the category id from it's idnumber.
677      * @throws Exception
678      * @param string $idnumber
679      * @return int
680      */
681     protected function get_category_id($idnumber) {
682         global $DB;
684         // If no category was specified use the data generator one.
685         if ($idnumber == false) {
686             return null;
687         }
689         if (!$id = $DB->get_field('course_categories', 'id', array('idnumber' => $idnumber))) {
690             throw new Exception('The specified category with idnumber "' . $idnumber . '" does not exist');
691         }
693         return $id;
694     }
696     /**
697      * Gets the course id from it's shortname.
698      * @throws Exception
699      * @param string $shortname
700      * @return int
701      */
702     protected function get_course_id($shortname) {
703         global $DB;
705         if (!$id = $DB->get_field('course', 'id', array('shortname' => $shortname))) {
706             throw new Exception('The specified course with shortname "' . $shortname . '" does not exist');
707         }
708         return $id;
709     }
711     /**
712      * Gets the group id from it's idnumber.
713      * @throws Exception
714      * @param string $idnumber
715      * @return int
716      */
717     protected function get_group_id($idnumber) {
718         global $DB;
720         if (!$id = $DB->get_field('groups', 'id', array('idnumber' => $idnumber))) {
721             throw new Exception('The specified group with idnumber "' . $idnumber . '" does not exist');
722         }
723         return $id;
724     }
726     /**
727      * Gets the grouping id from it's idnumber.
728      * @throws Exception
729      * @param string $idnumber
730      * @return int
731      */
732     protected function get_grouping_id($idnumber) {
733         global $DB;
735         if (!$id = $DB->get_field('groupings', 'id', array('idnumber' => $idnumber))) {
736             throw new Exception('The specified grouping with idnumber "' . $idnumber . '" does not exist');
737         }
738         return $id;
739     }
741     /**
742      * Gets the cohort id from it's idnumber.
743      * @throws Exception
744      * @param string $idnumber
745      * @return int
746      */
747     protected function get_cohort_id($idnumber) {
748         global $DB;
750         if (!$id = $DB->get_field('cohort', 'id', array('idnumber' => $idnumber))) {
751             throw new Exception('The specified cohort with idnumber "' . $idnumber . '" does not exist');
752         }
753         return $id;
754     }
756     /**
757      * Gets the outcome item id from its shortname.
758      * @throws Exception
759      * @param string $shortname
760      * @return int
761      */
762     protected function get_outcome_id($shortname) {
763         global $DB;
765         if (!$id = $DB->get_field('grade_outcomes', 'id', array('shortname' => $shortname))) {
766             throw new Exception('The specified outcome with shortname "' . $shortname . '" does not exist');
767         }
768         return $id;
769     }
771     /**
772      * Get the id of a named scale.
773      * @param string $name the name of the scale.
774      * @return int the scale id.
775      */
776     protected function get_scale_id($name) {
777         global $DB;
779         if (!$id = $DB->get_field('scale', 'id', array('name' => $name))) {
780             throw new Exception('The specified scale with name "' . $name . '" does not exist');
781         }
782         return $id;
783     }
785     /**
786      * Get the id of a named question category (must be globally unique).
787      * Note that 'Top' is a special value, used when setting the parent of another
788      * category, meaning top-level.
789      *
790      * @param string $name the question category name.
791      * @return int the question category id.
792      */
793     protected function get_questioncategory_id($name) {
794         global $DB;
796         if ($name == 'Top') {
797             return 0;
798         }
800         if (!$id = $DB->get_field('question_categories', 'id', array('name' => $name))) {
801             throw new Exception('The specified question category with name "' . $name . '" does not exist');
802         }
803         return $id;
804     }
806     /**
807      * Gets the internal context id from the context reference.
808      *
809      * The context reference changes depending on the context
810      * level, it can be the system, a user, a category, a course or
811      * a module.
812      *
813      * @throws Exception
814      * @param string $levelname The context level string introduced by the test writer
815      * @param string $contextref The context reference introduced by the test writer
816      * @return context
817      */
818     protected function get_context($levelname, $contextref) {
819         global $DB;
821         // Getting context levels and names (we will be using the English ones as it is the test site language).
822         $contextlevels = context_helper::get_all_levels();
823         $contextnames = array();
824         foreach ($contextlevels as $level => $classname) {
825             $contextnames[context_helper::get_level_name($level)] = $level;
826         }
828         if (empty($contextnames[$levelname])) {
829             throw new Exception('The specified "' . $levelname . '" context level does not exist');
830         }
831         $contextlevel = $contextnames[$levelname];
833         // Return it, we don't need to look for other internal ids.
834         if ($contextlevel == CONTEXT_SYSTEM) {
835             return context_system::instance();
836         }
838         switch ($contextlevel) {
840             case CONTEXT_USER:
841                 $instanceid = $DB->get_field('user', 'id', array('username' => $contextref));
842                 break;
844             case CONTEXT_COURSECAT:
845                 $instanceid = $DB->get_field('course_categories', 'id', array('idnumber' => $contextref));
846                 break;
848             case CONTEXT_COURSE:
849                 $instanceid = $DB->get_field('course', 'id', array('shortname' => $contextref));
850                 break;
852             case CONTEXT_MODULE:
853                 $instanceid = $DB->get_field('course_modules', 'id', array('idnumber' => $contextref));
854                 break;
856             default:
857                 break;
858         }
860         $contextclass = $contextlevels[$contextlevel];
861         if (!$context = $contextclass::instance($instanceid, IGNORE_MISSING)) {
862             throw new Exception('The specified "' . $contextref . '" context reference does not exist');
863         }
865         return $context;
866     }
868     /**
869      * Adds user to contacts
870      *
871      * @param array $data
872      * @return void
873      */
874     protected function process_message_contacts($data) {
875         \core_message\api::add_contact($data['userid'], $data['contactid']);
876     }
878     /**
879      * Gets the contact id from it's username.
880      * @throws Exception
881      * @param string $username
882      * @return int
883      */
884     protected function get_contact_id($username) {
885         global $DB;
887         if (!$id = $DB->get_field('user', 'id', array('username' => $username))) {
888             throw new Exception('The specified user with username "' . $username . '" does not exist');
889         }
890         return $id;
891     }
893     /**
894      * Send a new message from user to contact in a private conversation
895      *
896      * @param array $data
897      * @return void
898      */
899     protected function process_private_messages(array $data) {
900         if (!$conversationid = \core_message\api::get_conversation_between_users([$data['userid'], $data['contactid']])) {
901             $conversation = \core_message\api::create_conversation(
902                 \core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL,
903                 [$data['userid'], $data['contactid']]
904             );
905             $conversationid = $conversation->id;
906         }
907         \core_message\api::send_message_to_conversation($data['userid'], $conversationid, $data['message'], FORMAT_PLAIN);
908     }
910     /**
911      * Mark a private conversation as favourite for user
912      *
913      * @param array $data
914      * @return void
915      */
916     protected function process_favourite_conversations(array $data) {
917         if (!$conversationid = \core_message\api::get_conversation_between_users([$data['userid'], $data['contactid']])) {
918             $conversation = \core_message\api::create_conversation(
919                 \core_message\api::MESSAGE_CONVERSATION_TYPE_INDIVIDUAL,
920                 [$data['userid'], $data['contactid']]
921             );
922             $conversationid = $conversation->id;
923         }
924         \core_message\api::set_favourite_conversation($conversationid, $data['userid']);
925     }