3f469203fd059b86350516a5c1f2731e39ee8f6b
[moodle.git] / mod / data / lib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * @package   mod_data
20  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
21  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
22  */
24 defined('MOODLE_INTERNAL') || die();
26 // Some constants
27 define ('DATA_MAX_ENTRIES', 50);
28 define ('DATA_PERPAGE_SINGLE', 1);
30 define ('DATA_FIRSTNAME', -1);
31 define ('DATA_LASTNAME', -2);
32 define ('DATA_APPROVED', -3);
33 define ('DATA_TIMEADDED', 0);
34 define ('DATA_TIMEMODIFIED', -4);
35 define ('DATA_TAGS', -5);
37 define ('DATA_CAP_EXPORT', 'mod/data:viewalluserpresets');
39 define('DATA_PRESET_COMPONENT', 'mod_data');
40 define('DATA_PRESET_FILEAREA', 'site_presets');
41 define('DATA_PRESET_CONTEXT', SYSCONTEXTID);
43 define('DATA_EVENT_TYPE_OPEN', 'open');
44 define('DATA_EVENT_TYPE_CLOSE', 'close');
46 // Users having assigned the default role "Non-editing teacher" can export database records
47 // Using the mod/data capability "viewalluserpresets" existing in Moodle 1.9.x.
48 // In Moodle >= 2, new roles may be introduced and used instead.
50 /**
51  * @package   mod_data
52  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
53  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
54  */
55 class data_field_base {     // Base class for Database Field Types (see field/*/field.class.php)
57     /** @var string Subclasses must override the type with their name */
58     var $type = 'unknown';
59     /** @var object The database object that this field belongs to */
60     var $data = NULL;
61     /** @var object The field object itself, if we know it */
62     var $field = NULL;
63     /** @var int Width of the icon for this fieldtype */
64     var $iconwidth = 16;
65     /** @var int Width of the icon for this fieldtype */
66     var $iconheight = 16;
67     /** @var object course module or cmifno */
68     var $cm;
69     /** @var object activity context */
70     var $context;
71     /** @var priority for globalsearch indexing */
72     protected static $priority = self::NO_PRIORITY;
73     /** priority value for invalid fields regarding indexing */
74     const NO_PRIORITY = 0;
75     /** priority value for minimum priority */
76     const MIN_PRIORITY = 1;
77     /** priority value for low priority */
78     const LOW_PRIORITY = 2;
79     /** priority value for high priority */
80     const HIGH_PRIORITY = 3;
81     /** priority value for maximum priority */
82     const MAX_PRIORITY = 4;
84     /**
85      * Constructor function
86      *
87      * @global object
88      * @uses CONTEXT_MODULE
89      * @param int $field
90      * @param int $data
91      * @param int $cm
92      */
93     function __construct($field=0, $data=0, $cm=0) {   // Field or data or both, each can be id or object
94         global $DB;
96         if (empty($field) && empty($data)) {
97             print_error('missingfield', 'data');
98         }
100         if (!empty($field)) {
101             if (is_object($field)) {
102                 $this->field = $field;  // Programmer knows what they are doing, we hope
103             } else if (!$this->field = $DB->get_record('data_fields', array('id'=>$field))) {
104                 print_error('invalidfieldid', 'data');
105             }
106             if (empty($data)) {
107                 if (!$this->data = $DB->get_record('data', array('id'=>$this->field->dataid))) {
108                     print_error('invalidid', 'data');
109                 }
110             }
111         }
113         if (empty($this->data)) {         // We need to define this properly
114             if (!empty($data)) {
115                 if (is_object($data)) {
116                     $this->data = $data;  // Programmer knows what they are doing, we hope
117                 } else if (!$this->data = $DB->get_record('data', array('id'=>$data))) {
118                     print_error('invalidid', 'data');
119                 }
120             } else {                      // No way to define it!
121                 print_error('missingdata', 'data');
122             }
123         }
125         if ($cm) {
126             $this->cm = $cm;
127         } else {
128             $this->cm = get_coursemodule_from_instance('data', $this->data->id);
129         }
131         if (empty($this->field)) {         // We need to define some default values
132             $this->define_default_field();
133         }
135         $this->context = context_module::instance($this->cm->id);
136     }
139     /**
140      * This field just sets up a default field object
141      *
142      * @return bool
143      */
144     function define_default_field() {
145         global $OUTPUT;
146         if (empty($this->data->id)) {
147             echo $OUTPUT->notification('Programmer error: dataid not defined in field class');
148         }
149         $this->field = new stdClass();
150         $this->field->id = 0;
151         $this->field->dataid = $this->data->id;
152         $this->field->type   = $this->type;
153         $this->field->param1 = '';
154         $this->field->param2 = '';
155         $this->field->param3 = '';
156         $this->field->name = '';
157         $this->field->description = '';
158         $this->field->required = false;
160         return true;
161     }
163     /**
164      * Set up the field object according to data in an object.  Now is the time to clean it!
165      *
166      * @return bool
167      */
168     function define_field($data) {
169         $this->field->type        = $this->type;
170         $this->field->dataid      = $this->data->id;
172         $this->field->name        = trim($data->name);
173         $this->field->description = trim($data->description);
174         $this->field->required    = !empty($data->required) ? 1 : 0;
176         if (isset($data->param1)) {
177             $this->field->param1 = trim($data->param1);
178         }
179         if (isset($data->param2)) {
180             $this->field->param2 = trim($data->param2);
181         }
182         if (isset($data->param3)) {
183             $this->field->param3 = trim($data->param3);
184         }
185         if (isset($data->param4)) {
186             $this->field->param4 = trim($data->param4);
187         }
188         if (isset($data->param5)) {
189             $this->field->param5 = trim($data->param5);
190         }
192         return true;
193     }
195     /**
196      * Insert a new field in the database
197      * We assume the field object is already defined as $this->field
198      *
199      * @global object
200      * @return bool
201      */
202     function insert_field() {
203         global $DB, $OUTPUT;
205         if (empty($this->field)) {
206             echo $OUTPUT->notification('Programmer error: Field has not been defined yet!  See define_field()');
207             return false;
208         }
210         $this->field->id = $DB->insert_record('data_fields',$this->field);
212         // Trigger an event for creating this field.
213         $event = \mod_data\event\field_created::create(array(
214             'objectid' => $this->field->id,
215             'context' => $this->context,
216             'other' => array(
217                 'fieldname' => $this->field->name,
218                 'dataid' => $this->data->id
219             )
220         ));
221         $event->trigger();
223         return true;
224     }
227     /**
228      * Update a field in the database
229      *
230      * @global object
231      * @return bool
232      */
233     function update_field() {
234         global $DB;
236         $DB->update_record('data_fields', $this->field);
238         // Trigger an event for updating this field.
239         $event = \mod_data\event\field_updated::create(array(
240             'objectid' => $this->field->id,
241             'context' => $this->context,
242             'other' => array(
243                 'fieldname' => $this->field->name,
244                 'dataid' => $this->data->id
245             )
246         ));
247         $event->trigger();
249         return true;
250     }
252     /**
253      * Delete a field completely
254      *
255      * @global object
256      * @return bool
257      */
258     function delete_field() {
259         global $DB;
261         if (!empty($this->field->id)) {
262             // Get the field before we delete it.
263             $field = $DB->get_record('data_fields', array('id' => $this->field->id));
265             $this->delete_content();
266             $DB->delete_records('data_fields', array('id'=>$this->field->id));
268             // Trigger an event for deleting this field.
269             $event = \mod_data\event\field_deleted::create(array(
270                 'objectid' => $this->field->id,
271                 'context' => $this->context,
272                 'other' => array(
273                     'fieldname' => $this->field->name,
274                     'dataid' => $this->data->id
275                  )
276             ));
277             $event->add_record_snapshot('data_fields', $field);
278             $event->trigger();
279         }
281         return true;
282     }
284     /**
285      * Print the relevant form element in the ADD template for this field
286      *
287      * @global object
288      * @param int $recordid
289      * @return string
290      */
291     function display_add_field($recordid=0, $formdata=null) {
292         global $DB, $OUTPUT;
294         if ($formdata) {
295             $fieldname = 'field_' . $this->field->id;
296             $content = $formdata->$fieldname;
297         } else if ($recordid) {
298             $content = $DB->get_field('data_content', 'content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid));
299         } else {
300             $content = '';
301         }
303         // beware get_field returns false for new, empty records MDL-18567
304         if ($content===false) {
305             $content='';
306         }
308         $str = '<div title="' . s($this->field->description) . '">';
309         $str .= '<label for="field_'.$this->field->id.'"><span class="accesshide">'.$this->field->name.'</span>';
310         if ($this->field->required) {
311             $image = $OUTPUT->pix_icon('req', get_string('requiredelement', 'form'));
312             $str .= html_writer::div($image, 'inline-req');
313         }
314         $str .= '</label><input class="basefieldinput form-control d-inline mod-data-input" ' .
315                 'type="text" name="field_' . $this->field->id . '" ' .
316                 'id="field_' . $this->field->id . '" value="' . s($content) . '" />';
317         $str .= '</div>';
319         return $str;
320     }
322     /**
323      * Print the relevant form element to define the attributes for this field
324      * viewable by teachers only.
325      *
326      * @global object
327      * @global object
328      * @return void Output is echo'd
329      */
330     function display_edit_field() {
331         global $CFG, $DB, $OUTPUT;
333         if (empty($this->field)) {   // No field has been defined yet, try and make one
334             $this->define_default_field();
335         }
336         echo $OUTPUT->box_start('generalbox boxaligncenter boxwidthwide');
338         echo '<form id="editfield" action="'.$CFG->wwwroot.'/mod/data/field.php" method="post">'."\n";
339         echo '<input type="hidden" name="d" value="'.$this->data->id.'" />'."\n";
340         if (empty($this->field->id)) {
341             echo '<input type="hidden" name="mode" value="add" />'."\n";
342             $savebutton = get_string('add');
343         } else {
344             echo '<input type="hidden" name="fid" value="'.$this->field->id.'" />'."\n";
345             echo '<input type="hidden" name="mode" value="update" />'."\n";
346             $savebutton = get_string('savechanges');
347         }
348         echo '<input type="hidden" name="type" value="'.$this->type.'" />'."\n";
349         echo '<input name="sesskey" value="'.sesskey().'" type="hidden" />'."\n";
351         echo $OUTPUT->heading($this->name(), 3);
353         require_once($CFG->dirroot.'/mod/data/field/'.$this->type.'/mod.html');
355         echo '<div class="mdl-align">';
356         echo '<input type="submit" class="btn btn-primary" value="'.$savebutton.'" />'."\n";
357         echo '<input type="submit" class="btn btn-secondary" name="cancel" value="'.get_string('cancel').'" />'."\n";
358         echo '</div>';
360         echo '</form>';
362         echo $OUTPUT->box_end();
363     }
365     /**
366      * Display the content of the field in browse mode
367      *
368      * @global object
369      * @param int $recordid
370      * @param object $template
371      * @return bool|string
372      */
373     function display_browse_field($recordid, $template) {
374         global $DB;
376         if ($content = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
377             if (isset($content->content)) {
378                 $options = new stdClass();
379                 if ($this->field->param1 == '1') {  // We are autolinking this field, so disable linking within us
380                     //$content->content = '<span class="nolink">'.$content->content.'</span>';
381                     //$content->content1 = FORMAT_HTML;
382                     $options->filter=false;
383                 }
384                 $options->para = false;
385                 $str = format_text($content->content, $content->content1, $options);
386             } else {
387                 $str = '';
388             }
389             return $str;
390         }
391         return false;
392     }
394     /**
395      * Update the content of one data field in the data_content table
396      * @global object
397      * @param int $recordid
398      * @param mixed $value
399      * @param string $name
400      * @return bool
401      */
402     function update_content($recordid, $value, $name=''){
403         global $DB;
405         $content = new stdClass();
406         $content->fieldid = $this->field->id;
407         $content->recordid = $recordid;
408         $content->content = clean_param($value, PARAM_NOTAGS);
410         if ($oldcontent = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
411             $content->id = $oldcontent->id;
412             return $DB->update_record('data_content', $content);
413         } else {
414             return $DB->insert_record('data_content', $content);
415         }
416     }
418     /**
419      * Delete all content associated with the field
420      *
421      * @global object
422      * @param int $recordid
423      * @return bool
424      */
425     function delete_content($recordid=0) {
426         global $DB;
428         if ($recordid) {
429             $conditions = array('fieldid'=>$this->field->id, 'recordid'=>$recordid);
430         } else {
431             $conditions = array('fieldid'=>$this->field->id);
432         }
434         $rs = $DB->get_recordset('data_content', $conditions);
435         if ($rs->valid()) {
436             $fs = get_file_storage();
437             foreach ($rs as $content) {
438                 $fs->delete_area_files($this->context->id, 'mod_data', 'content', $content->id);
439             }
440         }
441         $rs->close();
443         return $DB->delete_records('data_content', $conditions);
444     }
446     /**
447      * Check if a field from an add form is empty
448      *
449      * @param mixed $value
450      * @param mixed $name
451      * @return bool
452      */
453     function notemptyfield($value, $name) {
454         return !empty($value);
455     }
457     /**
458      * Just in case a field needs to print something before the whole form
459      */
460     function print_before_form() {
461     }
463     /**
464      * Just in case a field needs to print something after the whole form
465      */
466     function print_after_form() {
467     }
470     /**
471      * Returns the sortable field for the content. By default, it's just content
472      * but for some plugins, it could be content 1 - content4
473      *
474      * @return string
475      */
476     function get_sort_field() {
477         return 'content';
478     }
480     /**
481      * Returns the SQL needed to refer to the column.  Some fields may need to CAST() etc.
482      *
483      * @param string $fieldname
484      * @return string $fieldname
485      */
486     function get_sort_sql($fieldname) {
487         return $fieldname;
488     }
490     /**
491      * Returns the name/type of the field
492      *
493      * @return string
494      */
495     function name() {
496         return get_string('fieldtypelabel', "datafield_$this->type");
497     }
499     /**
500      * Prints the respective type icon
501      *
502      * @global object
503      * @return string
504      */
505     function image() {
506         global $OUTPUT;
508         $params = array('d'=>$this->data->id, 'fid'=>$this->field->id, 'mode'=>'display', 'sesskey'=>sesskey());
509         $link = new moodle_url('/mod/data/field.php', $params);
510         $str = '<a href="'.$link->out().'">';
511         $str .= $OUTPUT->pix_icon('field/' . $this->type, $this->type, 'data');
512         $str .= '</a>';
513         return $str;
514     }
516     /**
517      * Per default, it is assumed that fields support text exporting.
518      * Override this (return false) on fields not supporting text exporting.
519      *
520      * @return bool true
521      */
522     function text_export_supported() {
523         return true;
524     }
526     /**
527      * Per default, return the record's text value only from the "content" field.
528      * Override this in fields class if necesarry.
529      *
530      * @param string $record
531      * @return string
532      */
533     function export_text_value($record) {
534         if ($this->text_export_supported()) {
535             return $record->content;
536         }
537     }
539     /**
540      * @param string $relativepath
541      * @return bool false
542      */
543     function file_ok($relativepath) {
544         return false;
545     }
547     /**
548      * Returns the priority for being indexed by globalsearch
549      *
550      * @return int
551      */
552     public static function get_priority() {
553         return static::$priority;
554     }
556     /**
557      * Returns the presentable string value for a field content.
558      *
559      * The returned string should be plain text.
560      *
561      * @param stdClass $content
562      * @return string
563      */
564     public static function get_content_value($content) {
565         return trim($content->content, "\r\n ");
566     }
568     /**
569      * Return the plugin configs for external functions,
570      * in some cases the configs will need formatting or be returned only if the current user has some capabilities enabled.
571      *
572      * @return array the list of config parameters
573      * @since Moodle 3.3
574      */
575     public function get_config_for_external() {
576         // Return all the field configs to null (maybe there is a private key for a service or something similar there).
577         $configs = [];
578         for ($i = 1; $i <= 10; $i++) {
579             $configs["param$i"] = null;
580         }
581         return $configs;
582     }
586 /**
587  * Given a template and a dataid, generate a default case template
588  *
589  * @global object
590  * @param object $data
591  * @param string template [addtemplate, singletemplate, listtempalte, rsstemplate]
592  * @param int $recordid
593  * @param bool $form
594  * @param bool $update
595  * @return bool|string
596  */
597 function data_generate_default_template(&$data, $template, $recordid=0, $form=false, $update=true) {
598     global $DB;
600     if (!$data && !$template) {
601         return false;
602     }
603     if ($template == 'csstemplate' or $template == 'jstemplate' ) {
604         return '';
605     }
607     // get all the fields for that database
608     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'id')) {
610         $table = new html_table();
611         $table->attributes['class'] = 'mod-data-default-template ##approvalstatus##';
612         $table->colclasses = array('template-field', 'template-token');
613         $table->data = array();
614         foreach ($fields as $field) {
615             if ($form) {   // Print forms instead of data
616                 $fieldobj = data_get_field($field, $data);
617                 $token = $fieldobj->display_add_field($recordid, null);
618             } else {           // Just print the tag
619                 $token = '[['.$field->name.']]';
620             }
621             $table->data[] = array(
622                 $field->name.': ',
623                 $token
624             );
625         }
627         if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
628             $label = new html_table_cell(get_string('tags') . ':');
629             if ($form) {
630                 $cell = data_generate_tag_form();
631             } else {
632                 $cell = new html_table_cell('##tags##');
633             }
634             $table->data[] = new html_table_row(array($label, $cell));
635         }
637         if ($template == 'listtemplate') {
638             $cell = new html_table_cell('##edit##  ##more##  ##delete##  ##approve##  ##disapprove##  ##export##');
639             $cell->colspan = 2;
640             $cell->attributes['class'] = 'controls';
641             $table->data[] = new html_table_row(array($cell));
642         } else if ($template == 'singletemplate') {
643             $cell = new html_table_cell('##edit##  ##delete##  ##approve##  ##disapprove##  ##export##');
644             $cell->colspan = 2;
645             $cell->attributes['class'] = 'controls';
646             $table->data[] = new html_table_row(array($cell));
647         } else if ($template == 'asearchtemplate') {
648             $row = new html_table_row(array(get_string('authorfirstname', 'data').': ', '##firstname##'));
649             $row->attributes['class'] = 'searchcontrols';
650             $table->data[] = $row;
651             $row = new html_table_row(array(get_string('authorlastname', 'data').': ', '##lastname##'));
652             $row->attributes['class'] = 'searchcontrols';
653             $table->data[] = $row;
654         }
656         $str = '';
657         if ($template == 'listtemplate'){
658             $str .= '##delcheck##';
659             $str .= html_writer::empty_tag('br');
660         }
662         $str .= html_writer::start_tag('div', array('class' => 'defaulttemplate'));
663         $str .= html_writer::table($table);
664         $str .= html_writer::end_tag('div');
665         if ($template == 'listtemplate'){
666             $str .= html_writer::empty_tag('hr');
667         }
669         if ($update) {
670             $newdata = new stdClass();
671             $newdata->id = $data->id;
672             $newdata->{$template} = $str;
673             $DB->update_record('data', $newdata);
674             $data->{$template} = $str;
675         }
677         return $str;
678     }
681 /**
682  * Build the form elements to manage tags for a record.
683  *
684  * @param int|bool $recordid
685  * @param string[] $selected raw tag names
686  * @return string
687  */
688 function data_generate_tag_form($recordid = false, $selected = []) {
689     global $CFG, $DB, $OUTPUT, $PAGE;
691     $tagtypestoshow = \core_tag_area::get_showstandard('mod_data', 'data_records');
692     $showstandard = ($tagtypestoshow != core_tag_tag::HIDE_STANDARD);
693     $typenewtags = ($tagtypestoshow != core_tag_tag::STANDARD_ONLY);
695     $str = html_writer::start_tag('div', array('class' => 'datatagcontrol'));
697     $namefield = empty($CFG->keeptagnamecase) ? 'name' : 'rawname';
699     $tagcollid = \core_tag_area::get_collection('mod_data', 'data_records');
700     $tags = [];
701     $selectedtags = [];
703     if ($showstandard) {
704         $tags += $DB->get_records_menu('tag', array('isstandard' => 1, 'tagcollid' => $tagcollid),
705             $namefield, 'id,' . $namefield . ' as fieldname');
706     }
708     if ($recordid) {
709         $selectedtags += core_tag_tag::get_item_tags_array('mod_data', 'data_records', $recordid);
710     }
712     if (!empty($selected)) {
713         list($sql, $params) = $DB->get_in_or_equal($selected, SQL_PARAMS_NAMED);
714         $params['tagcollid'] = $tagcollid;
715         $sql = "SELECT id, $namefield FROM {tag} WHERE tagcollid = :tagcollid AND rawname $sql";
716         $selectedtags += $DB->get_records_sql_menu($sql, $params);
717     }
719     $tags += $selectedtags;
721     $str .= '<select class="custom-select" name="tags[]" id="tags" multiple>';
722     foreach ($tags as $tagid => $tag) {
723         $selected = key_exists($tagid, $selectedtags) ? 'selected' : '';
724         $str .= "<option value='$tag' $selected>$tag</option>";
725     }
726     $str .= '</select>';
728     if (has_capability('moodle/tag:manage', context_system::instance()) && $showstandard) {
729         $url = new moodle_url('/tag/manage.php', array('tc' => core_tag_area::get_collection('mod_data',
730             'data_records')));
731         $str .= ' ' . $OUTPUT->action_link($url, get_string('managestandardtags', 'tag'));
732     }
734     $PAGE->requires->js_call_amd('core/form-autocomplete', 'enhance', $params = array(
735             '#tags',
736             $typenewtags,
737             '',
738             get_string('entertags', 'tag'),
739             false,
740             $showstandard,
741             get_string('noselection', 'form')
742         )
743     );
745     $str .= html_writer::end_tag('div');
747     return $str;
751 /**
752  * Search for a field name and replaces it with another one in all the
753  * form templates. Set $newfieldname as '' if you want to delete the
754  * field from the form.
755  *
756  * @global object
757  * @param object $data
758  * @param string $searchfieldname
759  * @param string $newfieldname
760  * @return bool
761  */
762 function data_replace_field_in_templates($data, $searchfieldname, $newfieldname) {
763     global $DB;
765     if (!empty($newfieldname)) {
766         $prestring = '[[';
767         $poststring = ']]';
768         $idpart = '#id';
770     } else {
771         $prestring = '';
772         $poststring = '';
773         $idpart = '';
774     }
776     $newdata = new stdClass();
777     $newdata->id = $data->id;
778     $newdata->singletemplate = str_ireplace('[['.$searchfieldname.']]',
779             $prestring.$newfieldname.$poststring, $data->singletemplate);
781     $newdata->listtemplate = str_ireplace('[['.$searchfieldname.']]',
782             $prestring.$newfieldname.$poststring, $data->listtemplate);
784     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.']]',
785             $prestring.$newfieldname.$poststring, $data->addtemplate);
787     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.'#id]]',
788             $prestring.$newfieldname.$idpart.$poststring, $data->addtemplate);
790     $newdata->rsstemplate = str_ireplace('[['.$searchfieldname.']]',
791             $prestring.$newfieldname.$poststring, $data->rsstemplate);
793     return $DB->update_record('data', $newdata);
797 /**
798  * Appends a new field at the end of the form template.
799  *
800  * @global object
801  * @param object $data
802  * @param string $newfieldname
803  */
804 function data_append_new_field_to_templates($data, $newfieldname) {
805     global $DB;
807     $newdata = new stdClass();
808     $newdata->id = $data->id;
809     $change = false;
811     if (!empty($data->singletemplate)) {
812         $newdata->singletemplate = $data->singletemplate.' [[' . $newfieldname .']]';
813         $change = true;
814     }
815     if (!empty($data->addtemplate)) {
816         $newdata->addtemplate = $data->addtemplate.' [[' . $newfieldname . ']]';
817         $change = true;
818     }
819     if (!empty($data->rsstemplate)) {
820         $newdata->rsstemplate = $data->singletemplate.' [[' . $newfieldname . ']]';
821         $change = true;
822     }
823     if ($change) {
824         $DB->update_record('data', $newdata);
825     }
829 /**
830  * given a field name
831  * this function creates an instance of the particular subfield class
832  *
833  * @global object
834  * @param string $name
835  * @param object $data
836  * @return object|bool
837  */
838 function data_get_field_from_name($name, $data){
839     global $DB;
841     $field = $DB->get_record('data_fields', array('name'=>$name, 'dataid'=>$data->id));
843     if ($field) {
844         return data_get_field($field, $data);
845     } else {
846         return false;
847     }
850 /**
851  * given a field id
852  * this function creates an instance of the particular subfield class
853  *
854  * @global object
855  * @param int $fieldid
856  * @param object $data
857  * @return bool|object
858  */
859 function data_get_field_from_id($fieldid, $data){
860     global $DB;
862     $field = $DB->get_record('data_fields', array('id'=>$fieldid, 'dataid'=>$data->id));
864     if ($field) {
865         return data_get_field($field, $data);
866     } else {
867         return false;
868     }
871 /**
872  * given a field id
873  * this function creates an instance of the particular subfield class
874  *
875  * @global object
876  * @param string $type
877  * @param object $data
878  * @return object
879  */
880 function data_get_field_new($type, $data) {
881     global $CFG;
883     require_once($CFG->dirroot.'/mod/data/field/'.$type.'/field.class.php');
884     $newfield = 'data_field_'.$type;
885     $newfield = new $newfield(0, $data);
886     return $newfield;
889 /**
890  * returns a subclass field object given a record of the field, used to
891  * invoke plugin methods
892  * input: $param $field - record from db
893  *
894  * @global object
895  * @param object $field
896  * @param object $data
897  * @param object $cm
898  * @return object
899  */
900 function data_get_field($field, $data, $cm=null) {
901     global $CFG;
903     if ($field) {
904         require_once('field/'.$field->type.'/field.class.php');
905         $newfield = 'data_field_'.$field->type;
906         $newfield = new $newfield($field, $data, $cm);
907         return $newfield;
908     }
912 /**
913  * Given record object (or id), returns true if the record belongs to the current user
914  *
915  * @global object
916  * @global object
917  * @param mixed $record record object or id
918  * @return bool
919  */
920 function data_isowner($record) {
921     global $USER, $DB;
923     if (!isloggedin()) { // perf shortcut
924         return false;
925     }
927     if (!is_object($record)) {
928         if (!$record = $DB->get_record('data_records', array('id'=>$record))) {
929             return false;
930         }
931     }
933     return ($record->userid == $USER->id);
936 /**
937  * has a user reached the max number of entries?
938  *
939  * @param object $data
940  * @return bool
941  */
942 function data_atmaxentries($data){
943     if (!$data->maxentries){
944         return false;
946     } else {
947         return (data_numentries($data) >= $data->maxentries);
948     }
951 /**
952  * returns the number of entries already made by this user
953  *
954  * @global object
955  * @global object
956  * @param object $data
957  * @return int
958  */
959 function data_numentries($data, $userid=null) {
960     global $USER, $DB;
961     if ($userid === null) {
962         $userid = $USER->id;
963     }
964     $sql = 'SELECT COUNT(*) FROM {data_records} WHERE dataid=? AND userid=?';
965     return $DB->count_records_sql($sql, array($data->id, $userid));
968 /**
969  * function that takes in a dataid and adds a record
970  * this is used everytime an add template is submitted
971  *
972  * @global object
973  * @global object
974  * @param object $data
975  * @param int $groupid
976  * @return bool
977  */
978 function data_add_record($data, $groupid=0){
979     global $USER, $DB;
981     $cm = get_coursemodule_from_instance('data', $data->id);
982     $context = context_module::instance($cm->id);
984     $record = new stdClass();
985     $record->userid = $USER->id;
986     $record->dataid = $data->id;
987     $record->groupid = $groupid;
988     $record->timecreated = $record->timemodified = time();
989     if (has_capability('mod/data:approve', $context)) {
990         $record->approved = 1;
991     } else {
992         $record->approved = 0;
993     }
994     $record->id = $DB->insert_record('data_records', $record);
996     // Trigger an event for creating this record.
997     $event = \mod_data\event\record_created::create(array(
998         'objectid' => $record->id,
999         'context' => $context,
1000         'other' => array(
1001             'dataid' => $data->id
1002         )
1003     ));
1004     $event->trigger();
1006     $course = get_course($cm->course);
1007     data_update_completion_state($data, $course, $cm);
1009     return $record->id;
1012 /**
1013  * check the multple existence any tag in a template
1014  *
1015  * check to see if there are 2 or more of the same tag being used.
1016  *
1017  * @global object
1018  * @param int $dataid,
1019  * @param string $template
1020  * @return bool
1021  */
1022 function data_tags_check($dataid, $template) {
1023     global $DB, $OUTPUT;
1025     // first get all the possible tags
1026     $fields = $DB->get_records('data_fields', array('dataid'=>$dataid));
1027     // then we generate strings to replace
1028     $tagsok = true; // let's be optimistic
1029     foreach ($fields as $field){
1030         $pattern="/\[\[" . preg_quote($field->name, '/') . "\]\]/i";
1031         if (preg_match_all($pattern, $template, $dummy)>1){
1032             $tagsok = false;
1033             echo $OUTPUT->notification('[['.$field->name.']] - '.get_string('multipletags','data'));
1034         }
1035     }
1036     // else return true
1037     return $tagsok;
1040 /**
1041  * Adds an instance of a data
1042  *
1043  * @param stdClass $data
1044  * @param mod_data_mod_form $mform
1045  * @return int intance id
1046  */
1047 function data_add_instance($data, $mform = null) {
1048     global $DB, $CFG;
1049     require_once($CFG->dirroot.'/mod/data/locallib.php');
1051     if (empty($data->assessed)) {
1052         $data->assessed = 0;
1053     }
1055     if (empty($data->ratingtime) || empty($data->assessed)) {
1056         $data->assesstimestart  = 0;
1057         $data->assesstimefinish = 0;
1058     }
1060     $data->timemodified = time();
1062     $data->id = $DB->insert_record('data', $data);
1064     // Add calendar events if necessary.
1065     data_set_events($data);
1066     if (!empty($data->completionexpected)) {
1067         \core_completion\api::update_completion_date_event($data->coursemodule, 'data', $data->id, $data->completionexpected);
1068     }
1070     data_grade_item_update($data);
1072     return $data->id;
1075 /**
1076  * updates an instance of a data
1077  *
1078  * @global object
1079  * @param object $data
1080  * @return bool
1081  */
1082 function data_update_instance($data) {
1083     global $DB, $CFG;
1084     require_once($CFG->dirroot.'/mod/data/locallib.php');
1086     $data->timemodified = time();
1087     $data->id           = $data->instance;
1089     if (empty($data->assessed)) {
1090         $data->assessed = 0;
1091     }
1093     if (empty($data->ratingtime) or empty($data->assessed)) {
1094         $data->assesstimestart  = 0;
1095         $data->assesstimefinish = 0;
1096     }
1098     if (empty($data->notification)) {
1099         $data->notification = 0;
1100     }
1102     $DB->update_record('data', $data);
1104     // Add calendar events if necessary.
1105     data_set_events($data);
1106     $completionexpected = (!empty($data->completionexpected)) ? $data->completionexpected : null;
1107     \core_completion\api::update_completion_date_event($data->coursemodule, 'data', $data->id, $completionexpected);
1109     data_grade_item_update($data);
1111     return true;
1115 /**
1116  * deletes an instance of a data
1117  *
1118  * @global object
1119  * @param int $id
1120  * @return bool
1121  */
1122 function data_delete_instance($id) {    // takes the dataid
1123     global $DB, $CFG;
1125     if (!$data = $DB->get_record('data', array('id'=>$id))) {
1126         return false;
1127     }
1129     $cm = get_coursemodule_from_instance('data', $data->id);
1130     $context = context_module::instance($cm->id);
1132 /// Delete all the associated information
1134     // files
1135     $fs = get_file_storage();
1136     $fs->delete_area_files($context->id, 'mod_data');
1138     // get all the records in this data
1139     $sql = "SELECT r.id
1140               FROM {data_records} r
1141              WHERE r.dataid = ?";
1143     $DB->delete_records_select('data_content', "recordid IN ($sql)", array($id));
1145     // delete all the records and fields
1146     $DB->delete_records('data_records', array('dataid'=>$id));
1147     $DB->delete_records('data_fields', array('dataid'=>$id));
1149     // Remove old calendar events.
1150     $events = $DB->get_records('event', array('modulename' => 'data', 'instance' => $id));
1151     foreach ($events as $event) {
1152         $event = calendar_event::load($event);
1153         $event->delete();
1154     }
1156     // Delete the instance itself
1157     $result = $DB->delete_records('data', array('id'=>$id));
1159     // cleanup gradebook
1160     data_grade_item_delete($data);
1162     return $result;
1165 /**
1166  * returns a summary of data activity of this user
1167  *
1168  * @global object
1169  * @param object $course
1170  * @param object $user
1171  * @param object $mod
1172  * @param object $data
1173  * @return object|null
1174  */
1175 function data_user_outline($course, $user, $mod, $data) {
1176     global $DB, $CFG;
1177     require_once("$CFG->libdir/gradelib.php");
1179     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1180     if (empty($grades->items[0]->grades)) {
1181         $grade = false;
1182     } else {
1183         $grade = reset($grades->items[0]->grades);
1184     }
1187     if ($countrecords = $DB->count_records('data_records', array('dataid'=>$data->id, 'userid'=>$user->id))) {
1188         $result = new stdClass();
1189         $result->info = get_string('numrecords', 'data', $countrecords);
1190         $lastrecord   = $DB->get_record_sql('SELECT id,timemodified FROM {data_records}
1191                                               WHERE dataid = ? AND userid = ?
1192                                            ORDER BY timemodified DESC', array($data->id, $user->id), true);
1193         $result->time = $lastrecord->timemodified;
1194         if ($grade) {
1195             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1196         }
1197         return $result;
1198     } else if ($grade) {
1199         $result = new stdClass();
1200         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1202         //datesubmitted == time created. dategraded == time modified or time overridden
1203         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1204         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1205         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1206             $result->time = $grade->dategraded;
1207         } else {
1208             $result->time = $grade->datesubmitted;
1209         }
1211         return $result;
1212     }
1213     return NULL;
1216 /**
1217  * Prints all the records uploaded by this user
1218  *
1219  * @global object
1220  * @param object $course
1221  * @param object $user
1222  * @param object $mod
1223  * @param object $data
1224  */
1225 function data_user_complete($course, $user, $mod, $data) {
1226     global $DB, $CFG, $OUTPUT;
1227     require_once("$CFG->libdir/gradelib.php");
1229     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1230     if (!empty($grades->items[0]->grades)) {
1231         $grade = reset($grades->items[0]->grades);
1232         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1233         if ($grade->str_feedback) {
1234             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1235         }
1236     }
1238     if ($records = $DB->get_records('data_records', array('dataid'=>$data->id,'userid'=>$user->id), 'timemodified DESC')) {
1239         data_print_template('singletemplate', $records, $data);
1240     }
1243 /**
1244  * Return grade for given user or all users.
1245  *
1246  * @global object
1247  * @param object $data
1248  * @param int $userid optional user id, 0 means all users
1249  * @return array array of grades, false if none
1250  */
1251 function data_get_user_grades($data, $userid=0) {
1252     global $CFG;
1254     require_once($CFG->dirroot.'/rating/lib.php');
1256     $ratingoptions = new stdClass;
1257     $ratingoptions->component = 'mod_data';
1258     $ratingoptions->ratingarea = 'entry';
1259     $ratingoptions->modulename = 'data';
1260     $ratingoptions->moduleid   = $data->id;
1262     $ratingoptions->userid = $userid;
1263     $ratingoptions->aggregationmethod = $data->assessed;
1264     $ratingoptions->scaleid = $data->scale;
1265     $ratingoptions->itemtable = 'data_records';
1266     $ratingoptions->itemtableusercolumn = 'userid';
1268     $rm = new rating_manager();
1269     return $rm->get_user_grades($ratingoptions);
1272 /**
1273  * Update activity grades
1274  *
1275  * @category grade
1276  * @param object $data
1277  * @param int $userid specific user only, 0 means all
1278  * @param bool $nullifnone
1279  */
1280 function data_update_grades($data, $userid=0, $nullifnone=true) {
1281     global $CFG, $DB;
1282     require_once($CFG->libdir.'/gradelib.php');
1284     if (!$data->assessed) {
1285         data_grade_item_update($data);
1287     } else if ($grades = data_get_user_grades($data, $userid)) {
1288         data_grade_item_update($data, $grades);
1290     } else if ($userid and $nullifnone) {
1291         $grade = new stdClass();
1292         $grade->userid   = $userid;
1293         $grade->rawgrade = NULL;
1294         data_grade_item_update($data, $grade);
1296     } else {
1297         data_grade_item_update($data);
1298     }
1301 /**
1302  * Update/create grade item for given data
1303  *
1304  * @category grade
1305  * @param stdClass $data A database instance with extra cmidnumber property
1306  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1307  * @return object grade_item
1308  */
1309 function data_grade_item_update($data, $grades=NULL) {
1310     global $CFG;
1311     require_once($CFG->libdir.'/gradelib.php');
1313     $params = array('itemname'=>$data->name, 'idnumber'=>$data->cmidnumber);
1315     if (!$data->assessed or $data->scale == 0) {
1316         $params['gradetype'] = GRADE_TYPE_NONE;
1318     } else if ($data->scale > 0) {
1319         $params['gradetype'] = GRADE_TYPE_VALUE;
1320         $params['grademax']  = $data->scale;
1321         $params['grademin']  = 0;
1323     } else if ($data->scale < 0) {
1324         $params['gradetype'] = GRADE_TYPE_SCALE;
1325         $params['scaleid']   = -$data->scale;
1326     }
1328     if ($grades  === 'reset') {
1329         $params['reset'] = true;
1330         $grades = NULL;
1331     }
1333     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, $grades, $params);
1336 /**
1337  * Delete grade item for given data
1338  *
1339  * @category grade
1340  * @param object $data object
1341  * @return object grade_item
1342  */
1343 function data_grade_item_delete($data) {
1344     global $CFG;
1345     require_once($CFG->libdir.'/gradelib.php');
1347     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, NULL, array('deleted'=>1));
1350 // junk functions
1351 /**
1352  * takes a list of records, the current data, a search string,
1353  * and mode to display prints the translated template
1354  *
1355  * @global object
1356  * @global object
1357  * @param string $template
1358  * @param array $records
1359  * @param object $data
1360  * @param string $search
1361  * @param int $page
1362  * @param bool $return
1363  * @param object $jumpurl a moodle_url by which to jump back to the record list (can be null)
1364  * @return mixed
1365  */
1366 function data_print_template($template, $records, $data, $search='', $page=0, $return=false, moodle_url $jumpurl=null) {
1367     global $CFG, $DB, $OUTPUT;
1369     $cm = get_coursemodule_from_instance('data', $data->id);
1370     $context = context_module::instance($cm->id);
1372     static $fields = array();
1373     static $dataid = null;
1375     if (empty($dataid)) {
1376         $dataid = $data->id;
1377     } else if ($dataid != $data->id) {
1378         $fields = array();
1379     }
1381     if (empty($fields)) {
1382         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1383         foreach ($fieldrecords as $fieldrecord) {
1384             $fields[]= data_get_field($fieldrecord, $data);
1385         }
1386     }
1388     if (empty($records)) {
1389         return;
1390     }
1392     if (!$jumpurl) {
1393         $jumpurl = new moodle_url('/mod/data/view.php', array('d' => $data->id));
1394     }
1395     $jumpurl = new moodle_url($jumpurl, array('page' => $page, 'sesskey' => sesskey()));
1397     foreach ($records as $record) {   // Might be just one for the single template
1399     // Replacing tags
1400         $patterns = array();
1401         $replacement = array();
1403     // Then we generate strings to replace for normal tags
1404         foreach ($fields as $field) {
1405             $patterns[]='[['.$field->field->name.']]';
1406             $replacement[] = highlight($search, $field->display_browse_field($record->id, $template));
1407         }
1409         $canmanageentries = has_capability('mod/data:manageentries', $context);
1411     // Replacing special tags (##Edit##, ##Delete##, ##More##)
1412         $patterns[]='##edit##';
1413         $patterns[]='##delete##';
1414         if (data_user_can_manage_entry($record, $data, $context)) {
1415             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/edit.php?d='
1416                              .$data->id.'&amp;rid='.$record->id.'&amp;sesskey='.sesskey().'">' .
1417                              $OUTPUT->pix_icon('t/edit', get_string('edit')) . '</a>';
1418             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/view.php?d='
1419                              .$data->id.'&amp;delete='.$record->id.'&amp;sesskey='.sesskey().'">' .
1420                              $OUTPUT->pix_icon('t/delete', get_string('delete')) . '</a>';
1421         } else {
1422             $replacement[] = '';
1423             $replacement[] = '';
1424         }
1426         $moreurl = $CFG->wwwroot . '/mod/data/view.php?d=' . $data->id . '&amp;rid=' . $record->id;
1427         if ($search) {
1428             $moreurl .= '&amp;filter=1';
1429         }
1430         $patterns[]='##more##';
1431         $replacement[] = '<a href="'.$moreurl.'">' . $OUTPUT->pix_icon('t/preview', get_string('more', 'data')) . '</a>';
1433         $patterns[]='##moreurl##';
1434         $replacement[] = $moreurl;
1436         $patterns[]='##delcheck##';
1437         if ($canmanageentries) {
1438             $replacement[] = html_writer::checkbox('delcheck[]', $record->id, false, '', array('class' => 'recordcheckbox'));
1439         } else {
1440             $replacement[] = '';
1441         }
1443         $patterns[]='##user##';
1444         $replacement[] = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$record->userid.
1445                                '&amp;course='.$data->course.'">'.fullname($record).'</a>';
1447         $patterns[] = '##userpicture##';
1448         $ruser = user_picture::unalias($record, null, 'userid');
1449         // If the record didn't come with user data, retrieve the user from database.
1450         if (!isset($ruser->picture)) {
1451             $ruser = core_user::get_user($record->userid);
1452         }
1453         $replacement[] = $OUTPUT->user_picture($ruser, array('courseid' => $data->course));
1455         $patterns[]='##export##';
1457         if (!empty($CFG->enableportfolios) && ($template == 'singletemplate' || $template == 'listtemplate')
1458             && ((has_capability('mod/data:exportentry', $context)
1459                 || (data_isowner($record->id) && has_capability('mod/data:exportownentry', $context))))) {
1460             require_once($CFG->libdir . '/portfoliolib.php');
1461             $button = new portfolio_add_button();
1462             $button->set_callback_options('data_portfolio_caller', array('id' => $cm->id, 'recordid' => $record->id), 'mod_data');
1463             list($formats, $files) = data_portfolio_caller::formats($fields, $record);
1464             $button->set_formats($formats);
1465             $replacement[] = $button->to_html(PORTFOLIO_ADD_ICON_LINK);
1466         } else {
1467             $replacement[] = '';
1468         }
1470         $patterns[] = '##timeadded##';
1471         $replacement[] = userdate($record->timecreated);
1473         $patterns[] = '##timemodified##';
1474         $replacement [] = userdate($record->timemodified);
1476         $patterns[]='##approve##';
1477         if (has_capability('mod/data:approve', $context) && ($data->approval) && (!$record->approved)) {
1478             $approveurl = new moodle_url($jumpurl, array('approve' => $record->id));
1479             $approveicon = new pix_icon('t/approve', get_string('approve', 'data'), '', array('class' => 'iconsmall'));
1480             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($approveurl, $approveicon),
1481                     array('class' => 'approve'));
1482         } else {
1483             $replacement[] = '';
1484         }
1486         $patterns[]='##disapprove##';
1487         if (has_capability('mod/data:approve', $context) && ($data->approval) && ($record->approved)) {
1488             $disapproveurl = new moodle_url($jumpurl, array('disapprove' => $record->id));
1489             $disapproveicon = new pix_icon('t/block', get_string('disapprove', 'data'), '', array('class' => 'iconsmall'));
1490             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($disapproveurl, $disapproveicon),
1491                     array('class' => 'disapprove'));
1492         } else {
1493             $replacement[] = '';
1494         }
1496         $patterns[] = '##approvalstatus##';
1497         if (!$data->approval) {
1498             $replacement[] = '';
1499         } else if ($record->approved) {
1500             $replacement[] = get_string('approved', 'data');
1501         } else {
1502             $replacement[] = get_string('notapproved', 'data');
1503         }
1505         $patterns[]='##comments##';
1506         if (($template == 'listtemplate') && ($data->comments)) {
1508             if (!empty($CFG->usecomments)) {
1509                 require_once($CFG->dirroot  . '/comment/lib.php');
1510                 list($context, $course, $cm) = get_context_info_array($context->id);
1511                 $cmt = new stdClass();
1512                 $cmt->context = $context;
1513                 $cmt->course  = $course;
1514                 $cmt->cm      = $cm;
1515                 $cmt->area    = 'database_entry';
1516                 $cmt->itemid  = $record->id;
1517                 $cmt->showcount = true;
1518                 $cmt->component = 'mod_data';
1519                 $comment = new comment($cmt);
1520                 $replacement[] = $comment->output(true);
1521             }
1522         } else {
1523             $replacement[] = '';
1524         }
1526         if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
1527             $patterns[] = "##tags##";
1528             $replacement[] = $OUTPUT->tag_list(
1529                 core_tag_tag::get_item_tags('mod_data', 'data_records', $record->id), '', 'data-tags');
1530         }
1532         // actual replacement of the tags
1533         $newtext = str_ireplace($patterns, $replacement, $data->{$template});
1535         // no more html formatting and filtering - see MDL-6635
1536         if ($return) {
1537             return $newtext;
1538         } else {
1539             echo $newtext;
1541             // hack alert - return is always false in singletemplate anyway ;-)
1542             /**********************************
1543              *    Printing Ratings Form       *
1544              *********************************/
1545             if ($template == 'singletemplate') {    //prints ratings options
1546                 data_print_ratings($data, $record);
1547             }
1549             /**********************************
1550              *    Printing Comments Form       *
1551              *********************************/
1552             if (($template == 'singletemplate') && ($data->comments)) {
1553                 if (!empty($CFG->usecomments)) {
1554                     require_once($CFG->dirroot . '/comment/lib.php');
1555                     list($context, $course, $cm) = get_context_info_array($context->id);
1556                     $cmt = new stdClass();
1557                     $cmt->context = $context;
1558                     $cmt->course  = $course;
1559                     $cmt->cm      = $cm;
1560                     $cmt->area    = 'database_entry';
1561                     $cmt->itemid  = $record->id;
1562                     $cmt->showcount = true;
1563                     $cmt->component = 'mod_data';
1564                     $comment = new comment($cmt);
1565                     $comment->output(false);
1566                 }
1567             }
1568         }
1569     }
1572 /**
1573  * Return rating related permissions
1574  *
1575  * @param string $contextid the context id
1576  * @param string $component the component to get rating permissions for
1577  * @param string $ratingarea the rating area to get permissions for
1578  * @return array an associative array of the user's rating permissions
1579  */
1580 function data_rating_permissions($contextid, $component, $ratingarea) {
1581     $context = context::instance_by_id($contextid, MUST_EXIST);
1582     if ($component != 'mod_data' || $ratingarea != 'entry') {
1583         return null;
1584     }
1585     return array(
1586         'view'    => has_capability('mod/data:viewrating',$context),
1587         'viewany' => has_capability('mod/data:viewanyrating',$context),
1588         'viewall' => has_capability('mod/data:viewallratings',$context),
1589         'rate'    => has_capability('mod/data:rate',$context)
1590     );
1593 /**
1594  * Validates a submitted rating
1595  * @param array $params submitted data
1596  *            context => object the context in which the rated items exists [required]
1597  *            itemid => int the ID of the object being rated
1598  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
1599  *            rating => int the submitted rating
1600  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
1601  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
1602  * @return boolean true if the rating is valid. Will throw rating_exception if not
1603  */
1604 function data_rating_validate($params) {
1605     global $DB, $USER;
1607     // Check the component is mod_data
1608     if ($params['component'] != 'mod_data') {
1609         throw new rating_exception('invalidcomponent');
1610     }
1612     // Check the ratingarea is entry (the only rating area in data module)
1613     if ($params['ratingarea'] != 'entry') {
1614         throw new rating_exception('invalidratingarea');
1615     }
1617     // Check the rateduserid is not the current user .. you can't rate your own entries
1618     if ($params['rateduserid'] == $USER->id) {
1619         throw new rating_exception('nopermissiontorate');
1620     }
1622     $datasql = "SELECT d.id as dataid, d.scale, d.course, r.userid as userid, d.approval, r.approved, r.timecreated, d.assesstimestart, d.assesstimefinish, r.groupid
1623                   FROM {data_records} r
1624                   JOIN {data} d ON r.dataid = d.id
1625                  WHERE r.id = :itemid";
1626     $dataparams = array('itemid'=>$params['itemid']);
1627     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1628         //item doesn't exist
1629         throw new rating_exception('invaliditemid');
1630     }
1632     if ($info->scale != $params['scaleid']) {
1633         //the scale being submitted doesnt match the one in the database
1634         throw new rating_exception('invalidscaleid');
1635     }
1637     //check that the submitted rating is valid for the scale
1639     // lower limit
1640     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
1641         throw new rating_exception('invalidnum');
1642     }
1644     // upper limit
1645     if ($info->scale < 0) {
1646         //its a custom scale
1647         $scalerecord = $DB->get_record('scale', array('id' => -$info->scale));
1648         if ($scalerecord) {
1649             $scalearray = explode(',', $scalerecord->scale);
1650             if ($params['rating'] > count($scalearray)) {
1651                 throw new rating_exception('invalidnum');
1652             }
1653         } else {
1654             throw new rating_exception('invalidscaleid');
1655         }
1656     } else if ($params['rating'] > $info->scale) {
1657         //if its numeric and submitted rating is above maximum
1658         throw new rating_exception('invalidnum');
1659     }
1661     if ($info->approval && !$info->approved) {
1662         //database requires approval but this item isnt approved
1663         throw new rating_exception('nopermissiontorate');
1664     }
1666     // check the item we're rating was created in the assessable time window
1667     if (!empty($info->assesstimestart) && !empty($info->assesstimefinish)) {
1668         if ($info->timecreated < $info->assesstimestart || $info->timecreated > $info->assesstimefinish) {
1669             throw new rating_exception('notavailable');
1670         }
1671     }
1673     $course = $DB->get_record('course', array('id'=>$info->course), '*', MUST_EXIST);
1674     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1675     $context = context_module::instance($cm->id);
1677     // if the supplied context doesnt match the item's context
1678     if ($context->id != $params['context']->id) {
1679         throw new rating_exception('invalidcontext');
1680     }
1682     // Make sure groups allow this user to see the item they're rating
1683     $groupid = $info->groupid;
1684     if ($groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
1685         if (!groups_group_exists($groupid)) { // Can't find group
1686             throw new rating_exception('cannotfindgroup');//something is wrong
1687         }
1689         if (!groups_is_member($groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
1690             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
1691             throw new rating_exception('notmemberofgroup');
1692         }
1693     }
1695     return true;
1698 /**
1699  * Can the current user see ratings for a given itemid?
1700  *
1701  * @param array $params submitted data
1702  *            contextid => int contextid [required]
1703  *            component => The component for this module - should always be mod_data [required]
1704  *            ratingarea => object the context in which the rated items exists [required]
1705  *            itemid => int the ID of the object being rated [required]
1706  *            scaleid => int scale id [optional]
1707  * @return bool
1708  * @throws coding_exception
1709  * @throws rating_exception
1710  */
1711 function mod_data_rating_can_see_item_ratings($params) {
1712     global $DB;
1714     // Check the component is mod_data.
1715     if (!isset($params['component']) || $params['component'] != 'mod_data') {
1716         throw new rating_exception('invalidcomponent');
1717     }
1719     // Check the ratingarea is entry (the only rating area in data).
1720     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'entry') {
1721         throw new rating_exception('invalidratingarea');
1722     }
1724     if (!isset($params['itemid'])) {
1725         throw new rating_exception('invaliditemid');
1726     }
1728     $datasql = "SELECT d.id as dataid, d.course, r.groupid
1729                   FROM {data_records} r
1730                   JOIN {data} d ON r.dataid = d.id
1731                  WHERE r.id = :itemid";
1732     $dataparams = array('itemid' => $params['itemid']);
1733     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1734         // Item doesn't exist.
1735         throw new rating_exception('invaliditemid');
1736     }
1738     // User can see ratings of all participants.
1739     if ($info->groupid == 0) {
1740         return true;
1741     }
1743     $course = $DB->get_record('course', array('id' => $info->course), '*', MUST_EXIST);
1744     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1746     // Make sure groups allow this user to see the item they're rating.
1747     return groups_group_visible($info->groupid, $course, $cm);
1751 /**
1752  * function that takes in the current data, number of items per page,
1753  * a search string and prints a preference box in view.php
1754  *
1755  * This preference box prints a searchable advanced search template if
1756  *     a) A template is defined
1757  *  b) The advanced search checkbox is checked.
1758  *
1759  * @global object
1760  * @global object
1761  * @param object $data
1762  * @param int $perpage
1763  * @param string $search
1764  * @param string $sort
1765  * @param string $order
1766  * @param array $search_array
1767  * @param int $advanced
1768  * @param string $mode
1769  * @return void
1770  */
1771 function data_print_preference_form($data, $perpage, $search, $sort='', $order='ASC', $search_array = '', $advanced = 0, $mode= ''){
1772     global $CFG, $DB, $PAGE, $OUTPUT;
1774     $cm = get_coursemodule_from_instance('data', $data->id);
1775     $context = context_module::instance($cm->id);
1776     echo '<br /><div class="datapreferences">';
1777     echo '<form id="options" action="view.php" method="get">';
1778     echo '<div>';
1779     echo '<input type="hidden" name="d" value="'.$data->id.'" />';
1780     if ($mode =='asearch') {
1781         $advanced = 1;
1782         echo '<input type="hidden" name="mode" value="list" />';
1783     }
1784     echo '<label for="pref_perpage">'.get_string('pagesize','data').'</label> ';
1785     $pagesizes = array(2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,15=>15,
1786                        20=>20,30=>30,40=>40,50=>50,100=>100,200=>200,300=>300,400=>400,500=>500,1000=>1000);
1787     echo html_writer::select($pagesizes, 'perpage', $perpage, false, array('id' => 'pref_perpage', 'class' => 'custom-select'));
1789     if ($advanced) {
1790         $regsearchclass = 'search_none';
1791         $advancedsearchclass = 'search_inline';
1792     } else {
1793         $regsearchclass = 'search_inline';
1794         $advancedsearchclass = 'search_none';
1795     }
1796     echo '<div id="reg_search" class="' . $regsearchclass . ' form-inline" >&nbsp;&nbsp;&nbsp;';
1797     echo '<label for="pref_search">' . get_string('search') . '</label> <input type="text" ' .
1798          'class="form-control" size="16" name="search" id= "pref_search" value="' . s($search) . '" /></div>';
1799     echo '&nbsp;&nbsp;&nbsp;<label for="pref_sortby">'.get_string('sortby').'</label> ';
1800     // foreach field, print the option
1801     echo '<select name="sort" id="pref_sortby" class="custom-select m-r-1">';
1802     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'name')) {
1803         echo '<optgroup label="'.get_string('fields', 'data').'">';
1804         foreach ($fields as $field) {
1805             if ($field->id == $sort) {
1806                 echo '<option value="'.$field->id.'" selected="selected">'.$field->name.'</option>';
1807             } else {
1808                 echo '<option value="'.$field->id.'">'.$field->name.'</option>';
1809             }
1810         }
1811         echo '</optgroup>';
1812     }
1813     $options = array();
1814     $options[DATA_TIMEADDED]    = get_string('timeadded', 'data');
1815     $options[DATA_TIMEMODIFIED] = get_string('timemodified', 'data');
1816     $options[DATA_FIRSTNAME]    = get_string('authorfirstname', 'data');
1817     $options[DATA_LASTNAME]     = get_string('authorlastname', 'data');
1818     if ($data->approval and has_capability('mod/data:approve', $context)) {
1819         $options[DATA_APPROVED] = get_string('approved', 'data');
1820     }
1821     echo '<optgroup label="'.get_string('other', 'data').'">';
1822     foreach ($options as $key => $name) {
1823         if ($key == $sort) {
1824             echo '<option value="'.$key.'" selected="selected">'.$name.'</option>';
1825         } else {
1826             echo '<option value="'.$key.'">'.$name.'</option>';
1827         }
1828     }
1829     echo '</optgroup>';
1830     echo '</select>';
1831     echo '<label for="pref_order" class="accesshide">'.get_string('order').'</label>';
1832     echo '<select id="pref_order" name="order" class="custom-select m-r-1">';
1833     if ($order == 'ASC') {
1834         echo '<option value="ASC" selected="selected">'.get_string('ascending','data').'</option>';
1835     } else {
1836         echo '<option value="ASC">'.get_string('ascending','data').'</option>';
1837     }
1838     if ($order == 'DESC') {
1839         echo '<option value="DESC" selected="selected">'.get_string('descending','data').'</option>';
1840     } else {
1841         echo '<option value="DESC">'.get_string('descending','data').'</option>';
1842     }
1843     echo '</select>';
1845     if ($advanced) {
1846         $checked = ' checked="checked" ';
1847     }
1848     else {
1849         $checked = '';
1850     }
1851     $PAGE->requires->js('/mod/data/data.js');
1852     echo '&nbsp;<input type="hidden" name="advanced" value="0" />';
1853     echo '&nbsp;<input type="hidden" name="filter" value="1" />';
1854     echo '&nbsp;<input type="checkbox" id="advancedcheckbox" name="advanced" value="1" ' . $checked . ' ' .
1855          'onchange="showHideAdvSearch(this.checked);" class="m-x-1" />' .
1856          '<label for="advancedcheckbox">' . get_string('advancedsearch', 'data') . '</label>';
1857     echo '&nbsp;<input type="submit" class="btn btn-secondary" value="' . get_string('savesettings', 'data') . '" />';
1859     echo '<br />';
1860     echo '<div class="' . $advancedsearchclass . '" id="data_adv_form">';
1861     echo '<table class="boxaligncenter">';
1863     // print ASC or DESC
1864     echo '<tr><td colspan="2">&nbsp;</td></tr>';
1865     $i = 0;
1867     // Determine if we are printing all fields for advanced search, or the template for advanced search
1868     // If a template is not defined, use the deafault template and display all fields.
1869     if(empty($data->asearchtemplate)) {
1870         data_generate_default_template($data, 'asearchtemplate');
1871     }
1873     static $fields = array();
1874     static $dataid = null;
1876     if (empty($dataid)) {
1877         $dataid = $data->id;
1878     } else if ($dataid != $data->id) {
1879         $fields = array();
1880     }
1882     if (empty($fields)) {
1883         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1884         foreach ($fieldrecords as $fieldrecord) {
1885             $fields[]= data_get_field($fieldrecord, $data);
1886         }
1887     }
1889     // Replacing tags
1890     $patterns = array();
1891     $replacement = array();
1893     // Then we generate strings to replace for normal tags
1894     foreach ($fields as $field) {
1895         $fieldname = $field->field->name;
1896         $fieldname = preg_quote($fieldname, '/');
1897         $patterns[] = "/\[\[$fieldname\]\]/i";
1898         $searchfield = data_get_field_from_id($field->field->id, $data);
1899         if (!empty($search_array[$field->field->id]->data)) {
1900             $replacement[] = $searchfield->display_search_field($search_array[$field->field->id]->data);
1901         } else {
1902             $replacement[] = $searchfield->display_search_field();
1903         }
1904     }
1905     $fn = !empty($search_array[DATA_FIRSTNAME]->data) ? $search_array[DATA_FIRSTNAME]->data : '';
1906     $ln = !empty($search_array[DATA_LASTNAME]->data) ? $search_array[DATA_LASTNAME]->data : '';
1907     $patterns[]    = '/##firstname##/';
1908     $replacement[] = '<label class="accesshide" for="u_fn">' . get_string('authorfirstname', 'data') . '</label>' .
1909                      '<input type="text" class="form-control" size="16" id="u_fn" name="u_fn" value="' . s($fn) . '" />';
1910     $patterns[]    = '/##lastname##/';
1911     $replacement[] = '<label class="accesshide" for="u_ln">' . get_string('authorlastname', 'data') . '</label>' .
1912                      '<input type="text" class="form-control" size="16" id="u_ln" name="u_ln" value="' . s($ln) . '" />';
1914     if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
1915         $patterns[] = "/##tags##/";
1916         $selectedtags = isset($search_array[DATA_TAGS]->rawtagnames) ? $search_array[DATA_TAGS]->rawtagnames : [];
1917         $replacement[] = data_generate_tag_form(false, $selectedtags);
1918     }
1920     // actual replacement of the tags
1921     $newtext = preg_replace($patterns, $replacement, $data->asearchtemplate);
1923     $options = new stdClass();
1924     $options->para=false;
1925     $options->noclean=true;
1926     echo '<tr><td>';
1927     echo format_text($newtext, FORMAT_HTML, $options);
1928     echo '</td></tr>';
1930     echo '<tr><td colspan="4"><br/>' .
1931          '<input type="submit" class="btn btn-primary m-r-1" value="' . get_string('savesettings', 'data') . '" />' .
1932          '<input type="submit" class="btn btn-secondary" name="resetadv" value="' . get_string('resetsettings', 'data') . '" />' .
1933          '</td></tr>';
1934     echo '</table>';
1935     echo '</div>';
1936     echo '</div>';
1937     echo '</form>';
1938     echo '</div>';
1941 /**
1942  * @global object
1943  * @global object
1944  * @param object $data
1945  * @param object $record
1946  * @return void Output echo'd
1947  */
1948 function data_print_ratings($data, $record) {
1949     global $OUTPUT;
1950     if (!empty($record->rating)){
1951         echo $OUTPUT->render($record->rating);
1952     }
1955 /**
1956  * List the actions that correspond to a view of this module.
1957  * This is used by the participation report.
1958  *
1959  * Note: This is not used by new logging system. Event with
1960  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
1961  *       be considered as view action.
1962  *
1963  * @return array
1964  */
1965 function data_get_view_actions() {
1966     return array('view');
1969 /**
1970  * List the actions that correspond to a post of this module.
1971  * This is used by the participation report.
1972  *
1973  * Note: This is not used by new logging system. Event with
1974  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
1975  *       will be considered as post action.
1976  *
1977  * @return array
1978  */
1979 function data_get_post_actions() {
1980     return array('add','update','record delete');
1983 /**
1984  * @param string $name
1985  * @param int $dataid
1986  * @param int $fieldid
1987  * @return bool
1988  */
1989 function data_fieldname_exists($name, $dataid, $fieldid = 0) {
1990     global $DB;
1992     if (!is_numeric($name)) {
1993         $like = $DB->sql_like('df.name', ':name', false);
1994     } else {
1995         $like = "df.name = :name";
1996     }
1997     $params = array('name'=>$name);
1998     if ($fieldid) {
1999         $params['dataid']   = $dataid;
2000         $params['fieldid1'] = $fieldid;
2001         $params['fieldid2'] = $fieldid;
2002         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
2003                                         WHERE $like AND df.dataid = :dataid
2004                                               AND ((df.id < :fieldid1) OR (df.id > :fieldid2))", $params);
2005     } else {
2006         $params['dataid']   = $dataid;
2007         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
2008                                         WHERE $like AND df.dataid = :dataid", $params);
2009     }
2012 /**
2013  * @param array $fieldinput
2014  */
2015 function data_convert_arrays_to_strings(&$fieldinput) {
2016     foreach ($fieldinput as $key => $val) {
2017         if (is_array($val)) {
2018             $str = '';
2019             foreach ($val as $inner) {
2020                 $str .= $inner . ',';
2021             }
2022             $str = substr($str, 0, -1);
2024             $fieldinput->$key = $str;
2025         }
2026     }
2030 /**
2031  * Converts a database (module instance) to use the Roles System
2032  *
2033  * @global object
2034  * @global object
2035  * @uses CONTEXT_MODULE
2036  * @uses CAP_PREVENT
2037  * @uses CAP_ALLOW
2038  * @param object $data a data object with the same attributes as a record
2039  *                     from the data database table
2040  * @param int $datamodid the id of the data module, from the modules table
2041  * @param array $teacherroles array of roles that have archetype teacher
2042  * @param array $studentroles array of roles that have archetype student
2043  * @param array $guestroles array of roles that have archetype guest
2044  * @param int $cmid the course_module id for this data instance
2045  * @return boolean data module was converted or not
2046  */
2047 function data_convert_to_roles($data, $teacherroles=array(), $studentroles=array(), $cmid=NULL) {
2048     global $CFG, $DB, $OUTPUT;
2050     if (!isset($data->participants) && !isset($data->assesspublic)
2051             && !isset($data->groupmode)) {
2052         // We assume that this database has already been converted to use the
2053         // Roles System. above fields get dropped the data module has been
2054         // upgraded to use Roles.
2055         return false;
2056     }
2058     if (empty($cmid)) {
2059         // We were not given the course_module id. Try to find it.
2060         if (!$cm = get_coursemodule_from_instance('data', $data->id)) {
2061             echo $OUTPUT->notification('Could not get the course module for the data');
2062             return false;
2063         } else {
2064             $cmid = $cm->id;
2065         }
2066     }
2067     $context = context_module::instance($cmid);
2070     // $data->participants:
2071     // 1 - Only teachers can add entries
2072     // 3 - Teachers and students can add entries
2073     switch ($data->participants) {
2074         case 1:
2075             foreach ($studentroles as $studentrole) {
2076                 assign_capability('mod/data:writeentry', CAP_PREVENT, $studentrole->id, $context->id);
2077             }
2078             foreach ($teacherroles as $teacherrole) {
2079                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
2080             }
2081             break;
2082         case 3:
2083             foreach ($studentroles as $studentrole) {
2084                 assign_capability('mod/data:writeentry', CAP_ALLOW, $studentrole->id, $context->id);
2085             }
2086             foreach ($teacherroles as $teacherrole) {
2087                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
2088             }
2089             break;
2090     }
2092     // $data->assessed:
2093     // 2 - Only teachers can rate posts
2094     // 1 - Everyone can rate posts
2095     // 0 - No one can rate posts
2096     switch ($data->assessed) {
2097         case 0:
2098             foreach ($studentroles as $studentrole) {
2099                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2100             }
2101             foreach ($teacherroles as $teacherrole) {
2102                 assign_capability('mod/data:rate', CAP_PREVENT, $teacherrole->id, $context->id);
2103             }
2104             break;
2105         case 1:
2106             foreach ($studentroles as $studentrole) {
2107                 assign_capability('mod/data:rate', CAP_ALLOW, $studentrole->id, $context->id);
2108             }
2109             foreach ($teacherroles as $teacherrole) {
2110                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2111             }
2112             break;
2113         case 2:
2114             foreach ($studentroles as $studentrole) {
2115                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2116             }
2117             foreach ($teacherroles as $teacherrole) {
2118                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2119             }
2120             break;
2121     }
2123     // $data->assesspublic:
2124     // 0 - Students can only see their own ratings
2125     // 1 - Students can see everyone's ratings
2126     switch ($data->assesspublic) {
2127         case 0:
2128             foreach ($studentroles as $studentrole) {
2129                 assign_capability('mod/data:viewrating', CAP_PREVENT, $studentrole->id, $context->id);
2130             }
2131             foreach ($teacherroles as $teacherrole) {
2132                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2133             }
2134             break;
2135         case 1:
2136             foreach ($studentroles as $studentrole) {
2137                 assign_capability('mod/data:viewrating', CAP_ALLOW, $studentrole->id, $context->id);
2138             }
2139             foreach ($teacherroles as $teacherrole) {
2140                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2141             }
2142             break;
2143     }
2145     if (empty($cm)) {
2146         $cm = $DB->get_record('course_modules', array('id'=>$cmid));
2147     }
2149     switch ($cm->groupmode) {
2150         case NOGROUPS:
2151             break;
2152         case SEPARATEGROUPS:
2153             foreach ($studentroles as $studentrole) {
2154                 assign_capability('moodle/site:accessallgroups', CAP_PREVENT, $studentrole->id, $context->id);
2155             }
2156             foreach ($teacherroles as $teacherrole) {
2157                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2158             }
2159             break;
2160         case VISIBLEGROUPS:
2161             foreach ($studentroles as $studentrole) {
2162                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $studentrole->id, $context->id);
2163             }
2164             foreach ($teacherroles as $teacherrole) {
2165                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2166             }
2167             break;
2168     }
2169     return true;
2172 /**
2173  * Returns the best name to show for a preset
2174  *
2175  * @param string $shortname
2176  * @param  string $path
2177  * @return string
2178  */
2179 function data_preset_name($shortname, $path) {
2181     // We are looking inside the preset itself as a first choice, but also in normal data directory
2182     $string = get_string('modulename', 'datapreset_'.$shortname);
2184     if (substr($string, 0, 1) == '[') {
2185         return $shortname;
2186     } else {
2187         return $string;
2188     }
2191 /**
2192  * Returns an array of all the available presets.
2193  *
2194  * @return array
2195  */
2196 function data_get_available_presets($context) {
2197     global $CFG, $USER;
2199     $presets = array();
2201     // First load the ratings sub plugins that exist within the modules preset dir
2202     if ($dirs = core_component::get_plugin_list('datapreset')) {
2203         foreach ($dirs as $dir=>$fulldir) {
2204             if (is_directory_a_preset($fulldir)) {
2205                 $preset = new stdClass();
2206                 $preset->path = $fulldir;
2207                 $preset->userid = 0;
2208                 $preset->shortname = $dir;
2209                 $preset->name = data_preset_name($dir, $fulldir);
2210                 if (file_exists($fulldir.'/screenshot.jpg')) {
2211                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.jpg';
2212                 } else if (file_exists($fulldir.'/screenshot.png')) {
2213                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.png';
2214                 } else if (file_exists($fulldir.'/screenshot.gif')) {
2215                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.gif';
2216                 }
2217                 $presets[] = $preset;
2218             }
2219         }
2220     }
2221     // Now add to that the site presets that people have saved
2222     $presets = data_get_available_site_presets($context, $presets);
2223     return $presets;
2226 /**
2227  * Gets an array of all of the presets that users have saved to the site.
2228  *
2229  * @param stdClass $context The context that we are looking from.
2230  * @param array $presets
2231  * @return array An array of presets
2232  */
2233 function data_get_available_site_presets($context, array $presets=array()) {
2234     global $USER;
2236     $fs = get_file_storage();
2237     $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2238     $canviewall = has_capability('mod/data:viewalluserpresets', $context);
2239     if (empty($files)) {
2240         return $presets;
2241     }
2242     foreach ($files as $file) {
2243         if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory() || (!$canviewall && $file->get_userid() != $USER->id)) {
2244             continue;
2245         }
2246         $preset = new stdClass;
2247         $preset->path = $file->get_filepath();
2248         $preset->name = trim($preset->path, '/');
2249         $preset->shortname = $preset->name;
2250         $preset->userid = $file->get_userid();
2251         $preset->id = $file->get_id();
2252         $preset->storedfile = $file;
2253         $presets[] = $preset;
2254     }
2255     return $presets;
2258 /**
2259  * Deletes a saved preset.
2260  *
2261  * @param string $name
2262  * @return bool
2263  */
2264 function data_delete_site_preset($name) {
2265     $fs = get_file_storage();
2267     $files = $fs->get_directory_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/');
2268     if (!empty($files)) {
2269         foreach ($files as $file) {
2270             $file->delete();
2271         }
2272     }
2274     $dir = $fs->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/', '.');
2275     if (!empty($dir)) {
2276         $dir->delete();
2277     }
2278     return true;
2281 /**
2282  * Prints the heads for a page
2283  *
2284  * @param stdClass $course
2285  * @param stdClass $cm
2286  * @param stdClass $data
2287  * @param string $currenttab
2288  */
2289 function data_print_header($course, $cm, $data, $currenttab='') {
2291     global $CFG, $displaynoticegood, $displaynoticebad, $OUTPUT, $PAGE;
2293     $PAGE->set_title($data->name);
2294     echo $OUTPUT->header();
2295     echo $OUTPUT->heading(format_string($data->name), 2);
2296     echo $OUTPUT->box(format_module_intro('data', $data, $cm->id), 'generalbox', 'intro');
2298     // Groups needed for Add entry tab
2299     $currentgroup = groups_get_activity_group($cm);
2300     $groupmode = groups_get_activity_groupmode($cm);
2302     // Print the tabs
2304     if ($currenttab) {
2305         include('tabs.php');
2306     }
2308     // Print any notices
2310     if (!empty($displaynoticegood)) {
2311         echo $OUTPUT->notification($displaynoticegood, 'notifysuccess');    // good (usually green)
2312     } else if (!empty($displaynoticebad)) {
2313         echo $OUTPUT->notification($displaynoticebad);                     // bad (usuually red)
2314     }
2317 /**
2318  * Can user add more entries?
2319  *
2320  * @param object $data
2321  * @param mixed $currentgroup
2322  * @param int $groupmode
2323  * @param stdClass $context
2324  * @return bool
2325  */
2326 function data_user_can_add_entry($data, $currentgroup, $groupmode, $context = null) {
2327     global $USER;
2329     if (empty($context)) {
2330         $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
2331         $context = context_module::instance($cm->id);
2332     }
2334     if (has_capability('mod/data:manageentries', $context)) {
2335         // no entry limits apply if user can manage
2337     } else if (!has_capability('mod/data:writeentry', $context)) {
2338         return false;
2340     } else if (data_atmaxentries($data)) {
2341         return false;
2342     } else if (data_in_readonly_period($data)) {
2343         // Check whether we're in a read-only period
2344         return false;
2345     }
2347     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
2348         return true;
2349     }
2351     if ($currentgroup) {
2352         return groups_is_member($currentgroup);
2353     } else {
2354         //else it might be group 0 in visible mode
2355         if ($groupmode == VISIBLEGROUPS){
2356             return true;
2357         } else {
2358             return false;
2359         }
2360     }
2363 /**
2364  * Check whether the current user is allowed to manage the given record considering manageentries capability,
2365  * data_in_readonly_period() result, ownership (determined by data_isowner()) and manageapproved setting.
2366  * @param mixed $record record object or id
2367  * @param object $data data object
2368  * @param object $context context object
2369  * @return bool returns true if the user is allowd to edit the entry, false otherwise
2370  */
2371 function data_user_can_manage_entry($record, $data, $context) {
2372     global $DB;
2374     if (has_capability('mod/data:manageentries', $context)) {
2375         return true;
2376     }
2378     // Check whether this activity is read-only at present.
2379     $readonly = data_in_readonly_period($data);
2381     if (!$readonly) {
2382         // Get record object from db if just id given like in data_isowner.
2383         // ...done before calling data_isowner() to avoid querying db twice.
2384         if (!is_object($record)) {
2385             if (!$record = $DB->get_record('data_records', array('id' => $record))) {
2386                 return false;
2387             }
2388         }
2389         if (data_isowner($record)) {
2390             if ($data->approval && $record->approved) {
2391                 return $data->manageapproved == 1;
2392             } else {
2393                 return true;
2394             }
2395         }
2396     }
2398     return false;
2401 /**
2402  * Check whether the specified database activity is currently in a read-only period
2403  *
2404  * @param object $data
2405  * @return bool returns true if the time fields in $data indicate a read-only period; false otherwise
2406  */
2407 function data_in_readonly_period($data) {
2408     $now = time();
2409     if (!$data->timeviewfrom && !$data->timeviewto) {
2410         return false;
2411     } else if (($data->timeviewfrom && $now < $data->timeviewfrom) || ($data->timeviewto && $now > $data->timeviewto)) {
2412         return false;
2413     }
2414     return true;
2417 /**
2418  * @return bool
2419  */
2420 function is_directory_a_preset($directory) {
2421     $directory = rtrim($directory, '/\\') . '/';
2422     $status = file_exists($directory.'singletemplate.html') &&
2423               file_exists($directory.'listtemplate.html') &&
2424               file_exists($directory.'listtemplateheader.html') &&
2425               file_exists($directory.'listtemplatefooter.html') &&
2426               file_exists($directory.'addtemplate.html') &&
2427               file_exists($directory.'rsstemplate.html') &&
2428               file_exists($directory.'rsstitletemplate.html') &&
2429               file_exists($directory.'csstemplate.css') &&
2430               file_exists($directory.'jstemplate.js') &&
2431               file_exists($directory.'preset.xml');
2433     return $status;
2436 /**
2437  * Abstract class used for data preset importers
2438  */
2439 abstract class data_preset_importer {
2441     protected $course;
2442     protected $cm;
2443     protected $module;
2444     protected $directory;
2446     /**
2447      * Constructor
2448      *
2449      * @param stdClass $course
2450      * @param stdClass $cm
2451      * @param stdClass $module
2452      * @param string $directory
2453      */
2454     public function __construct($course, $cm, $module, $directory) {
2455         $this->course = $course;
2456         $this->cm = $cm;
2457         $this->module = $module;
2458         $this->directory = $directory;
2459     }
2461     /**
2462      * Returns the name of the directory the preset is located in
2463      * @return string
2464      */
2465     public function get_directory() {
2466         return basename($this->directory);
2467     }
2469     /**
2470      * Retreive the contents of a file. That file may either be in a conventional directory of the Moodle file storage
2471      * @param file_storage $filestorage. should be null if using a conventional directory
2472      * @param stored_file $fileobj the directory to look in. null if using a conventional directory
2473      * @param string $dir the directory to look in. null if using the Moodle file storage
2474      * @param string $filename the name of the file we want
2475      * @return string the contents of the file or null if the file doesn't exist.
2476      */
2477     public function data_preset_get_file_contents(&$filestorage, &$fileobj, $dir, $filename) {
2478         if(empty($filestorage) || empty($fileobj)) {
2479             if (substr($dir, -1)!='/') {
2480                 $dir .= '/';
2481             }
2482             if (file_exists($dir.$filename)) {
2483                 return file_get_contents($dir.$filename);
2484             } else {
2485                 return null;
2486             }
2487         } else {
2488             if ($filestorage->file_exists(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename)) {
2489                 $file = $filestorage->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename);
2490                 return $file->get_content();
2491             } else {
2492                 return null;
2493             }
2494         }
2496     }
2497     /**
2498      * Gets the preset settings
2499      * @global moodle_database $DB
2500      * @return stdClass
2501      */
2502     public function get_preset_settings() {
2503         global $DB;
2505         $fs = $fileobj = null;
2506         if (!is_directory_a_preset($this->directory)) {
2507             //maybe the user requested a preset stored in the Moodle file storage
2509             $fs = get_file_storage();
2510             $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2512             //preset name to find will be the final element of the directory
2513             $explodeddirectory = explode('/', $this->directory);
2514             $presettofind = end($explodeddirectory);
2516             //now go through the available files available and see if we can find it
2517             foreach ($files as $file) {
2518                 if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory()) {
2519                     continue;
2520                 }
2521                 $presetname = trim($file->get_filepath(), '/');
2522                 if ($presetname==$presettofind) {
2523                     $this->directory = $presetname;
2524                     $fileobj = $file;
2525                 }
2526             }
2528             if (empty($fileobj)) {
2529                 print_error('invalidpreset', 'data', '', $this->directory);
2530             }
2531         }
2533         $allowed_settings = array(
2534             'intro',
2535             'comments',
2536             'requiredentries',
2537             'requiredentriestoview',
2538             'maxentries',
2539             'rssarticles',
2540             'approval',
2541             'defaultsortdir',
2542             'defaultsort');
2544         $result = new stdClass;
2545         $result->settings = new stdClass;
2546         $result->importfields = array();
2547         $result->currentfields = $DB->get_records('data_fields', array('dataid'=>$this->module->id));
2548         if (!$result->currentfields) {
2549             $result->currentfields = array();
2550         }
2553         /* Grab XML */
2554         $presetxml = $this->data_preset_get_file_contents($fs, $fileobj, $this->directory,'preset.xml');
2555         $parsedxml = xmlize($presetxml, 0);
2557         /* First, do settings. Put in user friendly array. */
2558         $settingsarray = $parsedxml['preset']['#']['settings'][0]['#'];
2559         $result->settings = new StdClass();
2560         foreach ($settingsarray as $setting => $value) {
2561             if (!is_array($value) || !in_array($setting, $allowed_settings)) {
2562                 // unsupported setting
2563                 continue;
2564             }
2565             $result->settings->$setting = $value[0]['#'];
2566         }
2568         /* Now work out fields to user friendly array */
2569         $fieldsarray = $parsedxml['preset']['#']['field'];
2570         foreach ($fieldsarray as $field) {
2571             if (!is_array($field)) {
2572                 continue;
2573             }
2574             $f = new StdClass();
2575             foreach ($field['#'] as $param => $value) {
2576                 if (!is_array($value)) {
2577                     continue;
2578                 }
2579                 $f->$param = $value[0]['#'];
2580             }
2581             $f->dataid = $this->module->id;
2582             $f->type = clean_param($f->type, PARAM_ALPHA);
2583             $result->importfields[] = $f;
2584         }
2585         /* Now add the HTML templates to the settings array so we can update d */
2586         $result->settings->singletemplate     = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"singletemplate.html");
2587         $result->settings->listtemplate       = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplate.html");
2588         $result->settings->listtemplateheader = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplateheader.html");
2589         $result->settings->listtemplatefooter = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplatefooter.html");
2590         $result->settings->addtemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"addtemplate.html");
2591         $result->settings->rsstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstemplate.html");
2592         $result->settings->rsstitletemplate   = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstitletemplate.html");
2593         $result->settings->csstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"csstemplate.css");
2594         $result->settings->jstemplate         = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"jstemplate.js");
2595         $result->settings->asearchtemplate    = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"asearchtemplate.html");
2597         $result->settings->instance = $this->module->id;
2598         return $result;
2599     }
2601     /**
2602      * Import the preset into the given database module
2603      * @return bool
2604      */
2605     function import($overwritesettings) {
2606         global $DB, $CFG;
2608         $params = $this->get_preset_settings();
2609         $settings = $params->settings;
2610         $newfields = $params->importfields;
2611         $currentfields = $params->currentfields;
2612         $preservedfields = array();
2614         /* Maps fields and makes new ones */
2615         if (!empty($newfields)) {
2616             /* We require an injective mapping, and need to know what to protect */
2617             foreach ($newfields as $nid => $newfield) {
2618                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2619                 if ($cid == -1) {
2620                     continue;
2621                 }
2622                 if (array_key_exists($cid, $preservedfields)){
2623                     print_error('notinjectivemap', 'data');
2624                 }
2625                 else $preservedfields[$cid] = true;
2626             }
2628             foreach ($newfields as $nid => $newfield) {
2629                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2631                 /* A mapping. Just need to change field params. Data kept. */
2632                 if ($cid != -1 and isset($currentfields[$cid])) {
2633                     $fieldobject = data_get_field_from_id($currentfields[$cid]->id, $this->module);
2634                     foreach ($newfield as $param => $value) {
2635                         if ($param != "id") {
2636                             $fieldobject->field->$param = $value;
2637                         }
2638                     }
2639                     unset($fieldobject->field->similarfield);
2640                     $fieldobject->update_field();
2641                     unset($fieldobject);
2642                 } else {
2643                     /* Make a new field */
2644                     include_once("field/$newfield->type/field.class.php");
2646                     if (!isset($newfield->description)) {
2647                         $newfield->description = '';
2648                     }
2649                     $classname = 'data_field_'.$newfield->type;
2650                     $fieldclass = new $classname($newfield, $this->module);
2651                     $fieldclass->insert_field();
2652                     unset($fieldclass);
2653                 }
2654             }
2655         }
2657         /* Get rid of all old unused data */
2658         if (!empty($preservedfields)) {
2659             foreach ($currentfields as $cid => $currentfield) {
2660                 if (!array_key_exists($cid, $preservedfields)) {
2661                     /* Data not used anymore so wipe! */
2662                     print "Deleting field $currentfield->name<br />";
2664                     $id = $currentfield->id;
2665                     //Why delete existing data records and related comments/ratings??
2666                     $DB->delete_records('data_content', array('fieldid'=>$id));
2667                     $DB->delete_records('data_fields', array('id'=>$id));
2668                 }
2669             }
2670         }
2672         // handle special settings here
2673         if (!empty($settings->defaultsort)) {
2674             if (is_numeric($settings->defaultsort)) {
2675                 // old broken value
2676                 $settings->defaultsort = 0;
2677             } else {
2678                 $settings->defaultsort = (int)$DB->get_field('data_fields', 'id', array('dataid'=>$this->module->id, 'name'=>$settings->defaultsort));
2679             }
2680         } else {
2681             $settings->defaultsort = 0;
2682         }
2684         // do we want to overwrite all current database settings?
2685         if ($overwritesettings) {
2686             // all supported settings
2687             $overwrite = array_keys((array)$settings);
2688         } else {
2689             // only templates and sorting
2690             $overwrite = array('singletemplate', 'listtemplate', 'listtemplateheader', 'listtemplatefooter',
2691                                'addtemplate', 'rsstemplate', 'rsstitletemplate', 'csstemplate', 'jstemplate',
2692                                'asearchtemplate', 'defaultsortdir', 'defaultsort');
2693         }
2695         // now overwrite current data settings
2696         foreach ($this->module as $prop=>$unused) {
2697             if (in_array($prop, $overwrite)) {
2698                 $this->module->$prop = $settings->$prop;
2699             }
2700         }
2702         data_update_instance($this->module);
2704         return $this->cleanup();
2705     }
2707     /**
2708      * Any clean up routines should go here
2709      * @return bool
2710      */
2711     public function cleanup() {
2712         return true;
2713     }
2716 /**
2717  * Data preset importer for uploaded presets
2718  */
2719 class data_preset_upload_importer extends data_preset_importer {
2720     public function __construct($course, $cm, $module, $filepath) {
2721         global $USER;
2722         if (is_file($filepath)) {
2723             $fp = get_file_packer();
2724             if ($fp->extract_to_pathname($filepath, $filepath.'_extracted')) {
2725                 fulldelete($filepath);
2726             }
2727             $filepath .= '_extracted';
2728         }
2729         parent::__construct($course, $cm, $module, $filepath);
2730     }
2731     public function cleanup() {
2732         return fulldelete($this->directory);
2733     }
2736 /**
2737  * Data preset importer for existing presets
2738  */
2739 class data_preset_existing_importer extends data_preset_importer {
2740     protected $userid;
2741     public function __construct($course, $cm, $module, $fullname) {
2742         global $USER;
2743         list($userid, $shortname) = explode('/', $fullname, 2);
2744         $context = context_module::instance($cm->id);
2745         if ($userid && ($userid != $USER->id) && !has_capability('mod/data:manageuserpresets', $context) && !has_capability('mod/data:viewalluserpresets', $context)) {
2746            throw new coding_exception('Invalid preset provided');
2747         }
2749         $this->userid = $userid;
2750         $filepath = data_preset_path($course, $userid, $shortname);
2751         parent::__construct($course, $cm, $module, $filepath);
2752     }
2753     public function get_userid() {
2754         return $this->userid;
2755     }
2758 /**
2759  * @global object
2760  * @global object
2761  * @param object $course
2762  * @param int $userid
2763  * @param string $shortname
2764  * @return string
2765  */
2766 function data_preset_path($course, $userid, $shortname) {
2767     global $USER, $CFG;
2769     $context = context_course::instance($course->id);
2771     $userid = (int)$userid;
2773     $path = null;
2774     if ($userid > 0 && ($userid == $USER->id || has_capability('mod/data:viewalluserpresets', $context))) {
2775         $path = $CFG->dataroot.'/data/preset/'.$userid.'/'.$shortname;
2776     } else if ($userid == 0) {
2777         $path = $CFG->dirroot.'/mod/data/preset/'.$shortname;
2778     } else if ($userid < 0) {
2779         $path = $CFG->tempdir.'/data/'.-$userid.'/'.$shortname;
2780     }
2782     return $path;
2785 /**
2786  * Implementation of the function for printing the form elements that control
2787  * whether the course reset functionality affects the data.
2788  *
2789  * @param $mform form passed by reference
2790  */
2791 function data_reset_course_form_definition(&$mform) {
2792     $mform->addElement('header', 'dataheader', get_string('modulenameplural', 'data'));
2793     $mform->addElement('checkbox', 'reset_data', get_string('deleteallentries','data'));
2795     $mform->addElement('checkbox', 'reset_data_notenrolled', get_string('deletenotenrolled', 'data'));
2796     $mform->disabledIf('reset_data_notenrolled', 'reset_data', 'checked');
2798     $mform->addElement('checkbox', 'reset_data_ratings', get_string('deleteallratings'));
2799     $mform->disabledIf('reset_data_ratings', 'reset_data', 'checked');
2801     $mform->addElement('checkbox', 'reset_data_comments', get_string('deleteallcomments'));
2802     $mform->disabledIf('reset_data_comments', 'reset_data', 'checked');
2804     $mform->addElement('checkbox', 'reset_data_tags', get_string('removealldatatags', 'data'));
2805     $mform->disabledIf('reset_data_tags', 'reset_data', 'checked');
2808 /**
2809  * Course reset form defaults.
2810  * @return array
2811  */
2812 function data_reset_course_form_defaults($course) {
2813     return array('reset_data'=>0, 'reset_data_ratings'=>1, 'reset_data_comments'=>1, 'reset_data_notenrolled'=>0);
2816 /**
2817  * Removes all grades from gradebook
2818  *
2819  * @global object
2820  * @global object
2821  * @param int $courseid
2822  * @param string $type optional type
2823  */
2824 function data_reset_gradebook($courseid, $type='') {
2825     global $CFG, $DB;
2827     $sql = "SELECT d.*, cm.idnumber as cmidnumber, d.course as courseid
2828               FROM {data} d, {course_modules} cm, {modules} m
2829              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id AND d.course=?";
2831     if ($datas = $DB->get_records_sql($sql, array($courseid))) {
2832         foreach ($datas as $data) {
2833             data_grade_item_update($data, 'reset');
2834         }
2835     }
2838 /**
2839  * Actual implementation of the reset course functionality, delete all the
2840  * data responses for course $data->courseid.
2841  *
2842  * @global object
2843  * @global object
2844  * @param object $data the data submitted from the reset course.
2845  * @return array status array
2846  */
2847 function data_reset_userdata($data) {
2848     global $CFG, $DB;
2849     require_once($CFG->libdir.'/filelib.php');
2850     require_once($CFG->dirroot.'/rating/lib.php');
2852     $componentstr = get_string('modulenameplural', 'data');
2853     $status = array();
2855     $allrecordssql = "SELECT r.id
2856                         FROM {data_records} r
2857                              INNER JOIN {data} d ON r.dataid = d.id
2858                        WHERE d.course = ?";
2860     $alldatassql = "SELECT d.id
2861                       FROM {data} d
2862                      WHERE d.course=?";
2864     $rm = new rating_manager();
2865     $ratingdeloptions = new stdClass;
2866     $ratingdeloptions->component = 'mod_data';
2867     $ratingdeloptions->ratingarea = 'entry';
2869     // Set the file storage - may need it to remove files later.
2870     $fs = get_file_storage();
2872     // delete entries if requested
2873     if (!empty($data->reset_data)) {
2874         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2875         $DB->delete_records_select('data_content', "recordid IN ($allrecordssql)", array($data->courseid));
2876         $DB->delete_records_select('data_records', "dataid IN ($alldatassql)", array($data->courseid));
2878         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2879             foreach ($datas as $dataid=>$unused) {
2880                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2881                     continue;
2882                 }
2883                 $datacontext = context_module::instance($cm->id);
2885                 // Delete any files that may exist.
2886                 $fs->delete_area_files($datacontext->id, 'mod_data', 'content');
2888                 $ratingdeloptions->contextid = $datacontext->id;
2889                 $rm->delete_ratings($ratingdeloptions);
2891                 core_tag_tag::delete_instances('mod_data', null, $datacontext->id);
2892             }
2893         }
2895         if (empty($data->reset_gradebook_grades)) {
2896             // remove all grades from gradebook
2897             data_reset_gradebook($data->courseid);
2898         }
2899         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallentries', 'data'), 'error'=>false);
2900     }
2902     // remove entries by users not enrolled into course
2903     if (!empty($data->reset_data_notenrolled)) {
2904         $recordssql = "SELECT r.id, r.userid, r.dataid, u.id AS userexists, u.deleted AS userdeleted
2905                          FROM {data_records} r
2906                               JOIN {data} d ON r.dataid = d.id
2907                               LEFT JOIN {user} u ON r.userid = u.id
2908                         WHERE d.course = ? AND r.userid > 0";
2910         $course_context = context_course::instance($data->courseid);
2911         $notenrolled = array();
2912         $fields = array();
2913         $rs = $DB->get_recordset_sql($recordssql, array($data->courseid));
2914         foreach ($rs as $record) {
2915             if (array_key_exists($record->userid, $notenrolled) or !$record->userexists or $record->userdeleted
2916               or !is_enrolled($course_context, $record->userid)) {
2917                 //delete ratings
2918                 if (!$cm = get_coursemodule_from_instance('data', $record->dataid)) {
2919                     continue;
2920                 }
2921                 $datacontext = context_module::instance($cm->id);
2922                 $ratingdeloptions->contextid = $datacontext->id;
2923                 $ratingdeloptions->itemid = $record->id;
2924                 $rm->delete_ratings($ratingdeloptions);
2926                 // Delete any files that may exist.
2927                 if ($contents = $DB->get_records('data_content', array('recordid' => $record->id), '', 'id')) {
2928                     foreach ($contents as $content) {
2929                         $fs->delete_area_files($datacontext->id, 'mod_data', 'content', $content->id);
2930                     }
2931                 }
2932                 $notenrolled[$record->userid] = true;
2934                 core_tag_tag::remove_all_item_tags('mod_data', 'data_records', $record->id);
2936                 $DB->delete_records('comments', array('itemid' => $record->id, 'commentarea' => 'database_entry'));
2937                 $DB->delete_records('data_content', array('recordid' => $record->id));
2938                 $DB->delete_records('data_records', array('id' => $record->id));
2939             }
2940         }
2941         $rs->close();
2942         $status[] = array('component'=>$componentstr, 'item'=>get_string('deletenotenrolled', 'data'), 'error'=>false);
2943     }
2945     // remove all ratings
2946     if (!empty($data->reset_data_ratings)) {
2947         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2948             foreach ($datas as $dataid=>$unused) {
2949                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2950                     continue;
2951                 }
2952                 $datacontext = context_module::instance($cm->id);
2954                 $ratingdeloptions->contextid = $datacontext->id;
2955                 $rm->delete_ratings($ratingdeloptions);
2956             }
2957         }
2959         if (empty($data->reset_gradebook_grades)) {
2960             // remove all grades from gradebook
2961             data_reset_gradebook($data->courseid);
2962         }
2964         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallratings'), 'error'=>false);
2965     }
2967     // remove all comments
2968     if (!empty($data->reset_data_comments)) {
2969         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2970         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallcomments'), 'error'=>false);
2971     }
2973     // Remove all the tags.
2974     if (!empty($data->reset_data_tags)) {
2975         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2976             foreach ($datas as $dataid => $unused) {
2977                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2978                     continue;
2979                 }
2981                 $context = context_module::instance($cm->id);
2982                 core_tag_tag::delete_instances('mod_data', null, $context->id);
2984             }
2985         }
2986         $status[] = array('component' => $componentstr, 'item' => get_string('tagsdeleted', 'data'), 'error' => false);
2987     }
2989     // updating dates - shift may be negative too
2990     if ($data->timeshift) {
2991         // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
2992         // See MDL-9367.
2993         shift_course_mod_dates('data', array('timeavailablefrom', 'timeavailableto',
2994             'timeviewfrom', 'timeviewto', 'assesstimestart', 'assesstimefinish'), $data->timeshift, $data->courseid);
2995         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
2996     }
2998     return $status;
3001 /**
3002  * Returns all other caps used in module
3003  *
3004  * @return array
3005  */
3006 function data_get_extra_capabilities() {
3007     return array('moodle/site:accessallgroups', 'moodle/site:viewfullnames', 'moodle/rating:view', 'moodle/rating:viewany', 'moodle/rating:viewall', 'moodle/rating:rate', 'moodle/comment:view', 'moodle/comment:post', 'moodle/comment:delete');
3010 /**
3011  * @param string $feature FEATURE_xx constant for requested feature
3012  * @return mixed True if module supports feature, null if doesn't know
3013  */
3014 function data_supports($feature) {
3015     switch($feature) {
3016         case FEATURE_GROUPS:                  return true;
3017         case FEATURE_GROUPINGS:               return true;
3018         case FEATURE_MOD_INTRO:               return true;
3019         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
3020         case FEATURE_COMPLETION_HAS_RULES:    return true;
3021         case FEATURE_GRADE_HAS_GRADE:         return true;
3022         case FEATURE_GRADE_OUTCOMES:          return true;
3023         case FEATURE_RATE:                    return true;
3024         case FEATURE_BACKUP_MOODLE2:          return true;
3025         case FEATURE_SHOW_DESCRIPTION:        return true;
3026         case FEATURE_COMMENT:                 return true;
3028         default: return null;
3029     }
3031 /**
3032  * @global object
3033  * @param array $export
3034  * @param string $delimiter_name
3035  * @param object $database
3036  * @param int $count
3037  * @param bool $return
3038  * @return string|void
3039  */
3040 function data_export_csv($export, $delimiter_name, $database, $count, $return=false) {
3041     global $CFG;
3042     require_once($CFG->libdir . '/csvlib.class.php');
3044     $filename = $database . '-' . $count . '-record';
3045     if ($count > 1) {
3046         $filename .= 's';
3047     }
3048     if ($return) {
3049         return csv_export_writer::print_array($export, $delimiter_name, '"', true);
3050     } else {
3051         csv_export_writer::download_array($filename, $export, $delimiter_name);
3052     }
3055 /**
3056  * @global object
3057  * @param array $export
3058  * @param string $dataname
3059  * @param int $count
3060  * @return string
3061  */
3062 function data_export_xls($export, $dataname, $count) {
3063     global $CFG;
3064     require_once("$CFG->libdir/excellib.class.php");
3065     $filename = clean_filename("{$dataname}-{$count}_record");
3066     if ($count > 1) {
3067         $filename .= 's';
3068     }
3069     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
3070     $filename .= '.xls';
3072     $filearg = '-';
3073     $workbook = new MoodleExcelWorkbook($filearg);
3074     $workbook->send($filename);
3075     $worksheet = array();
3076     $worksheet[0] = $workbook->add_worksheet('');
3077     $rowno = 0;
3078     foreach ($export as $row) {
3079         $colno = 0;
3080         foreach($row as $col) {
3081             $worksheet[0]->write($rowno, $colno, $col);
3082             $colno++;
3083         }
3084         $rowno++;
3085     }
3086     $workbook->close();
3087     return $filename;
3090 /**
3091  * @global object
3092  * @param array $export
3093  * @param string $dataname
3094  * @param int $count
3095  * @param string
3096  */
3097 function data_export_ods($export, $dataname, $count) {
3098     global $CFG;
3099     require_once("$CFG->libdir/odslib.class.php");
3100     $filename = clean_filename("{$dataname}-{$count}_record");
3101     if ($count > 1) {
3102         $filename .= 's';
3103     }
3104     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
3105     $filename .= '.ods';
3106     $filearg = '-';
3107     $workbook = new MoodleODSWorkbook($filearg);
3108     $workbook->send($filename);
3109     $worksheet = array();
3110     $worksheet[0] = $workbook->add_worksheet('');
3111     $rowno = 0;
3112     foreach ($export as $row) {
3113         $colno = 0;
3114         foreach($row as $col) {
3115             $worksheet[0]->write($rowno, $colno, $col);
3116             $colno++;
3117         }
3118         $rowno++;
3119     }
3120     $workbook->close();
3121     return $filename;
3124 /**
3125  * @global object
3126  * @param int $dataid
3127  * @param array $fields
3128  * @param array $selectedfields
3129  * @param int $currentgroup group ID of the current group. This is used for
3130  * exporting data while maintaining group divisions.
3131  * @param object $context the context in which the operation is performed (for capability checks)
3132  * @param bool $userdetails whether to include the details of the record author
3133  * @param bool $time whether to include time created/modified
3134  * @param bool $approval whether to include approval status
3135  * @param bool $tags whether to include tags
3136  * @return array
3137  */
3138 function data_get_exportdata($dataid, $fields, $selectedfields, $currentgroup=0, $context=null,
3139                              $userdetails=false, $time=false, $approval=false, $tags = false) {
3140     global $DB;
3142     if (is_null($context)) {
3143         $context = context_system::instance();
3144     }
3145     // exporting user data needs special permission
3146     $userdetails = $userdetails && has_capability('mod/data:exportuserinfo', $context);
3148     $exportdata = array();
3150     // populate the header in first row of export
3151     foreach($fields as $key => $field) {
3152         if (!in_array($field->field->id, $selectedfields)) {
3153             // ignore values we aren't exporting
3154             unset($fields[$key]);
3155         } else {
3156             $exportdata[0][] = $field->field->name;
3157         }
3158     }
3159     if ($tags) {
3160         $exportdata[0][] = get_string('tags', 'data');
3161     }
3162     if ($userdetails) {
3163         $exportdata[0][] = get_string('user');
3164         $exportdata[0][] = get_string('username');
3165         $exportdata[0][] = get_string('email');
3166     }
3167     if ($time) {
3168         $exportdata[0][] = get_string('timeadded', 'data');
3169         $exportdata[0][] = get_string('timemodified', 'data');
3170     }
3171     if ($approval) {
3172         $exportdata[0][] = get_string('approved', 'data');
3173     }
3175     $datarecords = $DB->get_records('data_records', array('dataid'=>$dataid));
3176     ksort($datarecords);
3177     $line = 1;
3178     foreach($datarecords as $record) {
3179         // get content indexed by fieldid
3180         if ($currentgroup) {
3181             $select = 'SELECT c.fieldid, c.content, c.content1, c.content2, c.content3, c.content4 FROM {data_content} c, {data_records} r WHERE c.recordid = ? AND r.id = c.recordid AND r.groupid = ?';
3182             $where = array($record->id, $currentgroup);
3183         } else {
3184             $select = 'SELECT fieldid, content, content1, content2, content3, content4 FROM {data_content} WHERE recordid = ?';
3185             $where = array($record->id);
3186         }
3188         if( $content = $DB->get_records_sql($select, $where) ) {
3189             foreach($fields as $field) {
3190                 $contents = '';
3191                 if(isset($content[$field->field->id])) {
3192                     $contents = $field->export_text_value($content[$field->field->id]);
3193                 }
3194                 $exportdata[$line][] = $contents;
3195             }
3196             if ($tags) {
3197                 $itemtags = \core_tag_tag::get_item_tags_array('mod_data', 'data_records', $record->id);
3198                 $exportdata[$line][] = implode(', ', $itemtags);
3199             }
3200             if ($userdetails) { // Add user details to the export data
3201                 $userdata = get_complete_user_data('id', $record->userid);
3202                 $exportdata[$line][] = fullname($userdata);
3203                 $exportdata[$line][] = $userdata->username;
3204                 $exportdata[$line][] = $userdata->email;
3205             }
3206             if ($time) { // Add time added / modified
3207                 $exportdata[$line][] = userdate($record->timecreated);
3208                 $exportdata[$line][] = userdate($record->timemodified);
3209             }
3210             if ($approval) { // Add approval status
3211                 $exportdata[$line][] = (int) $record->approved;
3212             }
3213         }
3214         $line++;
3215     }
3216     $line--;
3217     return $exportdata;
3220 ////////////////////////////////////////////////////////////////////////////////
3221 // File API                                                                   //
3222 ////////////////////////////////////////////////////////////////////////////////
3224 /**
3225  * Lists all browsable file areas
3226  *
3227  * @package  mod_data
3228  * @category files
3229  * @param stdClass $course course object
3230  * @param stdClass $cm course module object
3231  * @param stdClass $context context object
3232  * @return array
3233  */
3234 function data_get_file_areas($course, $cm, $context) {
3235     return array('content' => get_string('areacontent', 'mod_data'));
3238 /**
3239  * File browsing support for data module.
3240  *
3241  * @param file_browser $browser
3242  * @param array $areas
3243  * @param stdClass $course
3244  * @param cm_info $cm
3245  * @param context $context
3246  * @param string $filearea
3247  * @param int $itemid
3248  * @param string $filepath
3249  * @param string $filename
3250  * @return file_info_stored file_info_stored instance or null if not found
3251  */
3252 function data_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
3253     global $CFG, $DB, $USER;
3255     if ($context->contextlevel != CONTEXT_MODULE) {
3256         return null;
3257     }
3259     if (!isset($areas[$filearea])) {
3260         return null;
3261     }
3263     if (is_null($itemid)) {
3264         require_once($CFG->dirroot.'/mod/data/locallib.php');
3265         return new data_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
3266     }
3268     if (!$content = $DB->get_record('data_content', array('id'=>$itemid))) {
3269         return null;
3270     }
3272     if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3273         return null;
3274     }
3276     if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3277         return null;
3278     }
3280     if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3281         return null;
3282     }
3284     //check if approved
3285     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3286         return null;
3287     }
3289     // group access
3290     if ($record->groupid) {
3291         $groupmode = groups_get_activity_groupmode($cm, $course);
3292         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3293             if (!groups_is_member($record->groupid)) {
3294                 return null;
3295             }
3296         }
3297     }
3299     $fieldobj = data_get_field($field, $data, $cm);
3301     $filepath = is_null($filepath) ? '/' : $filepath;
3302     $filename = is_null($filename) ? '.' : $filename;
3303     if (!$fieldobj->file_ok($filepath.$filename)) {
3304         return null;
3305     }
3307     $fs = get_file_storage();
3308     if (!($storedfile = $fs->get_file($context->id, 'mod_data', $filearea, $itemid, $filepath, $filename))) {
3309         return null;
3310     }
3312     // Checks to see if the user can manage files or is the owner.
3313     // TODO MDL-33805 - Do not use userid here and move the capability check above.
3314     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
3315         return null;
3316     }
3318     $urlbase = $CFG->wwwroot.'/pluginfile.php';
3320     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
3323 /**
3324  * Serves the data attachments. Implements needed access control ;-)
3325  *
3326  * @package  mod_data
3327  * @category files
3328  * @param stdClass $course course object
3329  * @param stdClass $cm course module object
3330  * @param stdClass $context context object
3331  * @param string $filearea file area
3332  * @param array $args extra arguments
3333  * @param bool $forcedownload whether or not force download
3334  * @param array $options additional options affecting the file serving
3335  * @return bool false if file not found, does not return if found - justsend the file
3336  */
3337 function data_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
3338     global $CFG, $DB;
3340     if ($context->contextlevel != CONTEXT_MODULE) {
3341         return false;
3342     }
3344     require_course_login($course, true, $cm);
3346     if ($filearea === 'content') {
3347         $contentid = (int)array_shift($args);
3349         if (!$content = $DB->get_record('data_content', array('id'=>$contentid))) {
3350             return false;
3351         }
3353         if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3354             return false;
3355         }
3357         if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3358             return false;
3359         }
3361         if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3362             return false;
3363         }
3365         if ($data->id != $cm->instance) {
3366             // hacker attempt - context does not match the contentid
3367             return false;
3368         }
3370         //check if approved
3371         if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3372             return false;
3373         }
3375         // group access
3376         if ($record->groupid) {
3377             $groupmode = groups_get_activity_groupmode($cm, $course);
3378             if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3379                 if (!groups_is_member($record->groupid)) {
3380                     return false;
3381                 }
3382             }
3383         }
3385         $fieldobj = data_get_field($field, $data, $cm);
3387         $relativepath = implode('/', $args);
3388         $fullpath = "/$context->id/mod_data/content/$content->id/$relativepath";
3390         if (!$fieldobj->file_ok($relativepath)) {
3391             return false;
3392         }
3394         $fs = get_file_storage();
3395         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
3396             return false;
3397         }
3399         // finally send the file
3400         send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
3401     }
3403     return false;
3407 function data_extend_navigation($navigation, $course, $module, $cm) {
3408     global $CFG, $OUTPUT, $USER, $DB;
3409     require_once($CFG->dirroot . '/mod/data/locallib.php');
3411     $rid = optional_param('rid', 0, PARAM_INT);
3413     $data = $DB->get_record('data', array('id'=>$cm->instance));
3414     $currentgroup = groups_get_activity_group($cm);
3415     $groupmode = groups_get_activity_groupmode($cm);
3417      $numentries = data_numentries($data);
3418     $canmanageentries = has_capability('mod/data:manageentries', context_module::instance($cm->id));
3420     if ($data->entriesleft = data_get_entries_left_to_add($data, $numentries, $canmanageentries)) {
3421         $entriesnode = $navigation->add(get_string('entrieslefttoadd', 'data', $data));
3422         $entriesnode->add_class('note');
3423     }
3425     $navigation->add(get_string('list', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance)));
3426     if (!empty($rid)) {
3427         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'rid'=>$rid)));
3428     } else {
3429         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'single')));
3430     }
3431     $navigation->add(get_string('search', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'asearch')));
3434 /**
3435  * Adds module specific settings to the settings block
3436  *
3437  * @param settings_navigation $settings The settings navigation object
3438  * @param navigation_node $datanode The node to add module settings to
3439  */
3440 function data_extend_settings_navigation(settings_navigation $settings, navigation_node $datanode) {
3441     global $PAGE, $DB, $CFG, $USER;
3443     $data = $DB->get_record('data', array("id" => $PAGE->cm->instance));
3445     $currentgroup = groups_get_activity_group($PAGE->cm);
3446     $groupmode = groups_get_activity_groupmode($PAGE->cm);
3448     if (data_user_can_add_entry($data, $currentgroup, $groupmode, $PAGE->cm->context)) { // took out participation list here!
3449         if (empty($editentry)) { //TODO: undefined
3450             $addstring = get_string('add', 'data');
3451         } else {
3452             $addstring = get_string('editentry', 'data');
3453         }
3454         $datanode->add($addstring, new moodle_url('/mod/data/edit.php', array('d'=>$PAGE->cm->instance)));
3455     }
3457     if (has_capability(DATA_CAP_EXPORT, $PAGE->cm->context)) {
3458         // The capability required to Export database records is centrally defined in 'lib.php'
3459         // and should be weaker than those required to edit Templates, Fields and Presets.
3460         $datanode->add(get_string('exportentries', 'data'), new moodle_url('/mod/data/export.php', array('d'=>$data->id)));
3461     }
3462     if (has_capability('mod/data:manageentries', $PAGE->cm->context)) {
3463         $datanode->add(get_string('importentries', 'data'), new moodle_url('/mod/data/import.php', array('d'=>$data->id)));
3464     }
3466     if (has_capability('mod/data:managetemplates', $PAGE->cm->context)) {
3467         $currenttab = '';
3468         if ($currenttab == 'list') {
3469             $defaultemplate = 'listtemplate';
3470         } else if ($currenttab == 'add') {
3471             $defaultemplate = 'addtemplate';
3472         } else if ($currenttab == 'asearch') {
3473             $defaultemplate = 'asearchtemplate';
3474         } else {
3475             $defaultemplate = 'singletemplate';
3476         }
3478         $templates = $datanode->add(get_string('templates', 'data'));
3480         $templatelist = array ('listtemplate', 'singletemplate', 'asearchtemplate', 'addtemplate', 'rsstemplate', 'csstemplate', 'jstemplate');
3481         foreach ($templatelist as $template) {
3482             $templates->add(get_string($template, 'data'), new moodle_url('/mod/data/templates.php', array('d'=>$data->id,'mode'=>$template)));
3483         }
3485         $datanode->add(get_string('fields', 'data'), new moodle_url('/mod/data/field.php', array('d'=>$data->id)));
3486         $datanode->add(get_string('presets', 'data'), new moodle_url('/mod/data/preset.php', array('d'=>$data->id)));
3487     }
3489     if (!empty($CFG->enablerssfeeds) && !empty($CFG->data_enablerssfeeds) && $data->rssarticles > 0) {
3490         require_once("$CFG->libdir/rsslib.php");
3492         $string = get_string('rsstype','forum');
3494         $url = new moodle_url(rss_get_url($PAGE->cm->context->id, $USER->id, 'mod_data', $data->id));
3495         $datanode->add($string, $url, settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
3496     }
3499 /**
3500  * Save the database configuration as a preset.
3501  *
3502  * @param stdClass $course The course the database module belongs to.
3503  * @param stdClass $cm The course module record
3504  * @param stdClass $data The database record
3505  * @param string $path
3506  * @return bool
3507  */
3508 function data_presets_save($course, $cm, $data, $path) {
3509     global $USER;
3510     $fs = get_file_storage();
3511     $filerecord = new stdClass;
3512     $filerecord->contextid = DATA_PRESET_CONTEXT;
3513     $filerecord->component = DATA_PRESET_COMPONENT;
3514     $filerecord->filearea = DATA_PRESET_FILEAREA;
3515     $filerecord->itemid = 0;
3516     $filerecord->filepath = '/'.$path.'/';
3517     $filerecord->userid = $USER->id;
3519     $filerecord->filename = 'preset.xml';
3520     $fs->create_file_from_string($filerecord, data_presets_generate_xml($course, $cm, $data));
3522     $filerecord->filename = 'singletemplate.html';
3523     $fs->create_file_from_string($filerecord, $data->singletemplate);
3525     $filerecord->filename = 'listtemplateheader.html';
3526     $fs->create_file_from_string($filerecord, $data->listtemplateheader);
3528     $filerecord->filename = 'listtemplate.html';
3529     $fs->create_file_from_string($filerecord, $data->listtemplate);
3531     $filerecord->filename = 'listtemplatefooter.html';
3532     $fs->create_file_from_string($filerecord, $data->listtemplatefooter);
3534     $filerecord->filename = 'addtemplate.html';
3535     $fs->create_file_from_string($filerecord, $data->addtemplate);
3537     $filerecord->filename = 'rsstemplate.html';
3538     $fs->create_file_from_string($filerecord, $data->rsstemplate);
3540     $filerecord->filename = 'rsstitletemplate.html';
3541     $fs->create_file_from_string($filerecord, $data->rsstitletemplate);
3543     $filerecord->filename = 'csstemplate.css';
3544     $fs->create_file_from_string($filerecord, $data->csstemplate);
3546     $filerecord->filename = 'jstemplate.js';
3547     $fs->create_file_from_string($filerecord, $data->jstemplate);
3549     $filerecord->filename = 'asearchtemplate.html';
3550     $fs->create_file_from_string($filerecord, $data->asearchtemplate);
3552     return true;
3555 /**
3556  * Generates the XML for the database module provided
3557  *
3558  * @global moodle_database $DB
3559  * @param stdClass $course The course the database module belongs to.
3560  * @param stdClass $cm The course module record
3561  * @param stdClass $data The database record
3562  * @return string The XML for the preset
3563  */
3564 function data_presets_generate_xml($course, $cm, $data) {
3565     global $DB;
3567     // Assemble "preset.xml":
3568     $presetxmldata = "<preset>\n\n";
3570     // Raw settings are not preprocessed during saving of presets
3571     $raw_settings = array(
3572         'intro',
3573         'comments',
3574         'requiredentries',
3575         'requiredentriestoview',
3576         'maxentries',
3577         'rssarticles',
3578         'approval',
3579         'manageapproved',
3580         'defaultsortdir'
3581     );
3583     $presetxmldata .= "<settings>\n";
3584     // First, settings that do not require any conversion
3585     foreach ($raw_settings as $setting) {
3586         $presetxmldata .= "<$setting>" . htmlspecialchars($data->$setting) . "</$setting>\n";
3587     }
3589     // Now specific settings
3590     if ($data->defaultsort > 0 && $sortfield = data_get_field_from_id($data->defaultsort, $data)) {
3591         $presetxmldata .= '<defaultsort>' . htmlspecialchars($sortfield->field->name) . "</defaultsort>\n";
3592     } else {
3593         $presetxmldata .= "<defaultsort>0</defaultsort>\n";
3594     }
3595     $presetxmldata .= "</settings>\n\n";
3596     // Now for the fields. Grab all that are non-empty
3597     $fields = $DB->get_records('data_fields', array('dataid'=>$data->id));
3598     ksort($fields);
3599     if (!empty($fields)) {
3600         foreach ($fields as $field) {
3601             $presetxmldata .= "<field>\n";
3602             foreach ($field as $key => $value) {
3603                 if ($value != '' && $key != 'id' && $key != 'dataid') {
3604                     $presetxmldata .= "<$key>" . htmlspecialchars($value) . "</$key>\n";
3605                 }
3606             }
3607             $presetxmldata .= "</field>\n\n";
3608         }
3609     }
3610     $presetxmldata .= '</preset>';
3611     return $presetxmldata;
3614 function data_presets_export($course, $cm, $data, $tostorage=false) {
3615     global $CFG, $DB;
3617     $presetname = clean_filename($data->name) . '-preset-' . gmdate("Ymd_Hi");
3618     $exportsubdir = "mod_data/presetexport/$presetname";
3619     make_temp_directory($exportsubdir);
3620     $exportdir = "$CFG->tempdir/$exportsubdir";
3622     // Assemble "preset.xml":
3623     $presetxmldata = data_presets_generate_xml($course, $cm, $data);
3625     // After opening a file in write mode, close it asap
3626     $presetxmlfile = fopen($exportdir . '/preset.xml', 'w');
3627     fwrite($presetxmlfile, $presetxmldata);
3628     fclose($presetxmlfile);
3630     // Now write the template files
3631     $singletemplate = fopen($exportdir . '/singletemplate.html', 'w');
3632     fwrite($singletemplate, $data->singletemplate);
3633     fclose($singletemplate);
3635     $listtemplateheader = fopen($exportdir . '/listtemplateheader.html', 'w');
3636     fwrite($listtemplateheader, $data->listtemplateheader);
3637     fclose($listtemplateheader);
3639     $listtemplate = fopen($exportdir . '/listtemplate.html', 'w');
3640     fwrite($listtemplate, $data->listtemplate);
3641     fclose($listtemplate);
3643     $listtemplatefooter = fopen($exportdir . '/listtemplatefooter.html', 'w');
3644     fwrite($listtemplatefooter, $data->listtemplatefooter);
3645     fclose($listtemplatefooter);
3647     $addtemplate = fopen($exportdir . '/addtemplate.html', 'w');
3648     fwrite($addtemplate, $data->addtemplate);
3649     fclose($addtemplate);
3651     $rsstemplate = fopen($exportdir . '/rsstemplate.html', 'w');
3652     fwrite($rsstemplate, $data->rsstemplate);
3653     fclose($rsstemplate);
3655     $rsstitletemplate = fopen($exportdir . '/rsstitletemplate.html', 'w');
3656     fwrite($rsstitletemplate, $data->rsstitletemplate);
3657     fclose($rsstitletemplate);
3659     $csstemplate = fopen($exportdir . '/csstemplate.css', 'w');
3660     fwrite($csstemplate, $data->csstemplate);
3661     fclose($csstemplate);
3663     $jstemplate = fopen($exportdir . '/jstemplate.js', 'w');
3664     fwrite($jstemplate, $data->jstemplate);
3665     fclose($jstemplate);
3667     $asearchtemplate = fopen($exportdir . '/asearchtemplate.html', 'w');
3668     fwrite($asearchtemplate, $data->asearchtemplate);
3669     fclose($asearchtemplate);
3671     // Check if all files have been generated
3672     if (! is_directory_a_preset($exportdir)) {
3673         print_error('generateerror', 'data');
3674     }
3676     $filenames = array(
3677         'preset.xml',
3678         'singletemplate.html',
3679         'listtemplateheader.html',
3680         'listtemplate.html',
3681         'listtemplatefooter.html',
3682         'addtemplate.html',
3683         'rsstemplate.html',
3684         'rsstitletemplate.html',
3685         'csstemplate.css',
3686         'jstemplate.js',
3687         'asearchtemplate.html'
3688     );
3690     $filelist = array();
3691     foreach ($filenames as $filename) {
3692         $filelist[$filename] = $exportdir . '/' . $filename;
3693     }
3695     $exportfile = $exportdir.'.zip';
3696     file_exists($exportfile) && unlink($exportfile);
3698     $fp = get_file_packer('application/zip');
3699     $fp->archive_to_pathname($filelist, $exportfile);
3701     foreach ($filelist as $file) {
3702         unlink($file);
3703     }
3704     rmdir($exportdir);
3706     // Return the full path to the exported preset file:
3707     return $exportfile;
3710 /**
3711  * Running addtional permission check on plugin, for example, plugins
3712  * may have switch to turn on/off comments option, this callback will
3713  * affect UI display, not like pluginname_comment_validate only throw
3714  * exceptions.
3715  * Capability check has been done in comment->check_permissions(), we
3716  * don't need to do it again here.
3717  *
3718  * @package  mod_data
3719  * @category comment
3720  *
3721  * @param stdClass $comment_param {
3722  *              context  => context the context object
3723  *              courseid => int course id
3724  *              cm       => stdClass course module object
3725  *              commentarea => string comment area
3726  *              itemid      => int itemid
3727  * }
3728  * @return array
3729  */
3730 function data_comment_permissions($comment_param) {
3731     global $CFG, $DB;
3732     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3733         throw new comment_exception('invalidcommentitemid');
3734     }
3735     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3736         throw new comment_exception('invalidid', 'data');
3737     }
3738     if ($data->comments) {
3739         return array('post'=>true, 'view'=>true);
3740     } else {
3741         return array('post'=>false, 'view'=>false);
3742     }
3745 /**
3746  * Validate comment parameter before perform other comments actions
3747  *
3748  * @package  mod_data
3749  * @category comment
3750  *
3751  * @param stdClass $comment_param {
3752  *              context  => context the context object
3753  *              courseid => int course id
3754  *              cm       => stdClass course module object
3755  *              commentarea => string comment area
3756  *              itemid      => int itemid
3757  * }
3758  * @return boolean
3759  */
3760 function data_comment_validate($comment_param) {
3761     global $DB;
3762     // validate comment area
3763     if ($comment_param->commentarea != 'database_entry') {
3764         throw new comment_exception('invalidcommentarea');
3765     }
3766     // validate itemid
3767     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3768         throw new comment_exception('invalidcommentitemid');
3769     }
3770     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3771         throw new comment_exception('invalidid', 'data');
3772     }
3773     if (!$course = $DB->get_record('course', array('id'=>$data->course))) {
3774         throw new comment_exception('coursemisconf');
3775     }
3776     if (!$cm = get_coursemodule_from_instance('data', $data->id, $course->id)) {
3777         throw new comment_exception('invalidcoursemodule');
3778     }
3779     if (!$data->comments) {
3780         throw new comment_exception('commentsoff', 'data');
3781     }
3782     $context = context_module::instance($cm->id);
3784     //check if approved
3785     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3786         throw new comment_exception('notapproved', 'data');
3787     }
3789     // group access
3790     if ($record->groupid) {
3791         $groupmode = groups_get_activity_groupmode($cm, $course);
3792         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3793             if (!groups_is_member($record->groupid)) {
3794                 throw new comment_exception('notmemberofgroup');
3795             }
3796         }
3797     }
3798     // validate context id
3799     if ($context->id != $comment_param->context->id) {
3800         throw new comment_exception('invalidcontext');
3801     }
3802     // validation for comment deletion
3803     if (!empty($comment_param->commentid)) {
3804         if ($comment = $DB->get_record('comments', array('id'=>$comment_param->commentid))) {
3805             if ($comment->commentarea != 'database_entry') {
3806                 throw new comment_exception('invalidcommentarea');
3807             }
3808             if ($comment->contextid != $comment_param->context->id) {
3809                 throw new comment_exception('invalidcontext');
3810             }
3811             if ($comment->itemid != $comment_param->itemid) {
3812                 throw new comment_exception('invalidcommentitemid');
3813             }
3814         } else {
3815             throw new comment_exception('invalidcommentid');
3816         }
3817     }
3818     return true;
3821 /**
3822  * Return a list of page types
3823  * @param string $pagetype current page type
3824  * @param stdClass $parentcontext Block's parent context
3825  * @param stdClass $currentcontext Current context of block
3826  */
3827 function data_page_type_list($pagetype, $parentcontext, $currentcontext) {
3828     $module_pagetype = array('mod-data-*'=>get_string('page-mod-data-x', 'data'));
3829     return $module_pagetype;
3832 /**
3833  * Get all of the record ids from a database activity.
3834  *
3835  * @param int    $dataid      The dataid of the database module.
3836  * @param object $selectdata  Contains an additional sql statement for the
3837  *                            where clause for group and approval fields.
3838  * @param array  $params      Parameters that coincide with the sql statement.
3839  * @return array $idarray     An array of record ids
3840  */
3841 function data_get_all_recordids($dataid, $selectdata = '', $params = null) {
3842     global $DB;
3843     $initsql = 'SELECT r.id
3844                   FROM {data_records} r
3845                  WHERE r.dataid = :dataid';
3846     if ($selectdata != '') {
3847         $initsql .= $selectdata;
3848         $params = array_merge(array('dataid' => $dataid), $params);
3849     } else {
3850         $params = array('dataid' => $dataid);
3851     }
3852     $initsql .= ' GROUP BY r.id';
3853     $initrecord = $DB->get_recordset_sql($initsql, $params);
3854     $idarray = array();
3855     foreach ($initrecord as $data) {
3856         $idarray[] = $data->id;
3857     }
3858     // Close the record set and free up resources.
3859     $initrecord->close();
3860     return $idarray;
3863 /**
3864  * Get the ids of all the records that match that advanced search criteria
3865  * This goes and loops through each criterion one at a time until it either
3866  * runs out of records or returns a subset of records.
3867  *
3868  * @param array $recordids    An array of record ids.
3869  * @param array $searcharray  Contains information for the advanced search criteria
3870  * @param int $dataid         The data id of the database.
3871  * @return array $recordids   An array of record ids.
3872  */
3873 function data_get_advance_search_ids($recordids, $searcharray, $dataid) {
3874     // Check to see if we have any record IDs.
3875     if (empty($recordids)) {
3876         // Send back an empty search.
3877         return array();
3878     }
3879     $searchcriteria = array_keys($searcharray);
3880     // Loop through and reduce the IDs one search criteria at a time.
3881     foreach ($searchcriteria as $key) {
3882         $recordids = data_get_recordids($key, $searcharray, $dataid, $recordids);
3883         // If we don't have anymore IDs then stop.
3884         if (!$recordids) {
3885             break;
3886         }
3887     }
3888     return $recordids;
3891 /**
3892  * Gets the record IDs given the search criteria
3893  *
3894  * @param string $alias       Record alias.
3895  * @param array $searcharray  Criteria for the search.
3896  * @param int $dataid         Data ID for the database
3897  * @param array $recordids    An array of record IDs.
3898  * @return array $nestarray   An arry of record IDs
3899  */
3900 function data_get_recordids($alias, $searcharray, $dataid, $recordids) {
3901     global $DB;
3902     $searchcriteria = $alias;   // Keep the criteria.
3903     $nestsearch = $searcharray[$alias];
3904     // searching for content outside of mdl_data_content
3905     if ($alias < 0) {
3906         $alias = '';
3907     }
3908     list($insql, $params) = $DB->get_in_or_equal($recordids, SQL_PARAMS_NAMED);
3909     $nestselect = 'SELECT c' . $alias . '.recordid
3910                      FROM {data_content} c' . $alias . '
3911                INNER JOIN {data_fields} f
3912                        ON f.id = c' . $alias . '.fieldid
3913                INNER JOIN {data_records} r
3914                        ON r.id = c' . $alias . '.recordid
3915                INNER JOIN {user} u
3916                        ON u.id = r.userid ';
3917     $nestwhere = 'WHERE r.dataid = :dataid
3918                     AND c' . $alias .'.recordid ' . $insql . '
3919                     AND ';
3921     $params['dataid'] = $dataid;
3922     if (count($nestsearch->params) != 0) {
3923         $params = array_merge($params, $nestsearch->params);
3924         $nestsql = $nestselect . $nestwhere . $nestsearch->sql;
3925     } else if ($searchcriteria == DATA_TIMEMODIFIED) {
3926         $nestsql = $nestselect . $nestwhere . $nestsearch->field . ' >= :timemodified GROUP BY c' . $alias . '.recordid';
3927         $params['timemodified'] = $nestsearch->data;
3928     } else if ($searchcriteria == DATA_TAGS) {
3929         if (empty($nestsearch->rawtagnames)) {
3930             return [];
3931         }
3932         $i = 0;
3933         $tagwhere = [];
3934         $tagselect = '';
3935         foreach ($nestsearch->rawtagnames as $tagrawname) {
3936             $tagselect .= " INNER JOIN {tag_instance} ti_$i
3937                                     ON ti_$i.component = 'mod_data'
3938                                    AND ti_$i.itemtype = 'data_records'
3939                                    AND ti_$i.itemid = r.id
3940                             INNER JOIN {tag} t_$i
3941                                     ON ti_$i.tagid = t_$i.id ";
3942             $tagwhere[] = " t_$i.rawname = :trawname_$i ";
3943             $params["trawname_$i"] = $tagrawname;
3944             $i++;
3945         }
3946         $nestsql = $nestselect . $tagselect . $nestwhere . implode(' AND ', $tagwhere);
3947     } else {    // First name or last name.
3948         $thing = $DB->sql_like($nestsearch->field, ':search1', false);
3949         $nestsql = $nestselect . $nestwhere . $thing . ' GROUP BY c' . $alias . '.recordid';
3950         $params['search1'] = "%$nestsearch->data%";
3951     }
3952     $nestrecords = $DB->get_recordset_sql($nestsql, $params);
3953     $nestarray = array();
3954     foreach ($nestrecords as $data) {
3955         $nestarray[] = $data->recordid;
3956     }
3957     // Close the record set and free up resources.
3958     $nestrecords->close();
3959     return $nestarray;
3962 /**
3963  * Returns an array with an sql string for advanced searches and the parameters that go with them.
3964  *
3965  * @param int $sort            DATA_*
3966  * @param stdClass $data       Data module object
3967  * @param array $recordids     An array of record IDs.
3968  * @param string $selectdata   Information for the where and select part of the sql statement.
3969  * @param string $sortorder    Additional sort parameters
3970  * @return array sqlselect     sqlselect['sql'] has the sql string, sqlselect['params'] contains an array of parameters.
3971  */
3972 function data_get_advanced_search_sql($sort, $data, $recordids, $selectdata, $sortorder) {
3973     global $DB;
3975     $namefields = user_picture::fields('u');
3976     // Remove the id from the string. This already exists in the sql statement.
3977     $namefields = str_replace('u.id,', '', $namefields);
3979     if ($sort == 0) {
3980         $nestselectsql = 'SELECT r.id, r.approved, r.timecreated, r.timemodified, r.userid, ' . $namefields . '
3981                         FROM {data_content} c,
3982                              {data_records} r,
3983                              {user} u ';
3984         $groupsql = ' GROUP BY r.id, r.approved, r.timecreated, r.timemodified, r.userid, u.firstname, u.lastname, ' . $namefields;
3985     } else {
3986         // Sorting through 'Other' criteria
3987         if ($sort <= 0) {
3988             switch ($sort) {
3989                 case DATA_LASTNAME:
3990                     $sortcontentfull = "u.lastname";
3991                     break;
3992                 case DATA_FIRSTNAME:
3993                     $sortcontentfull = "u.firstname";
3994                     break;
3995                 case DATA_APPROVED:
3996                     $sortcontentfull = "r.approved";
3997                     break;
3998                 case DATA_TIMEMODIFIED:
3999                     $sortcontentfull = "r.timemodified";
4000                     break;
4001                 case DATA_TIMEADDED:
4002                 default:
4003                     $sortcontentfull = "r.timecreated";
4004             }
4005         } else {
4006             $sortfield = data_get_field_from_id($sort, $data);
4007             $sortcontent = $DB->sql_compare_text('c.' . $sortfield->get_sort_field());
4008             $sortcontentfull = $sortfield->get_sort_sql($sortcontent);
4009         }
4011         $nestselectsql = 'SELECT r.id, r.approved, r.timecreated, r.timemodified, r.userid, ' . $namefields . ',
4012                                  ' . $sortcontentfull . '
4013                               AS sortorder
4014                             FROM {data_content} c,
4015                                  {data_records} r,
4016                                  {user} u ';
4017         $groupsql = ' GROUP BY r.id, r.approved, r.timecreated, r.timemodified, r.userid, ' . $namefields . ', ' .$sortcontentfull;
4018     }
4020     // Default to a standard Where statement if $selectdata is empty.
4021     if ($selectdata == '') {
4022         $selectdata = 'WHERE c.recordid = r.id
4023                          AND r.dataid = :dataid
4024                          AND r.userid = u.id ';
4025     }
4027     // Find the field we are sorting on
4028     if ($sort > 0 or data_get_field_from_id($sort, $data)) {
4029         $selectdata .= ' AND c.fieldid = :sort';
4030     }
4032     // If there are no record IDs then return an sql statment that will return no rows.
4033     if (count($recordids) != 0) {
4034         list($insql, $inparam) = $DB->get_in_or_equal($recordids, SQL_PARAMS_NAMED);
4035     } else {
4036         list($insql, $inparam) = $DB->get_in_or_equal(array('-1'), SQL_PARAMS_NAMED);
4037     }
4038     $nestfromsql = $selectdata . ' AND c.recordid ' . $insql . $groupsql;
4039     $sqlselect['sql'] = "$nestselectsql $nestfromsql $sortorder";
4040     $sqlselect['params'] = $inparam;
4041     return $sqlselect;
4044 /**
4045  * Checks to see if the user has permission to delete the preset.
4046  * @param stdClass $context  Context object.
4047  * @param stdClass $preset  The preset object that we are checking for deletion.
4048  * @return bool  Returns true if the user can delete, otherwise false.
4049  */
4050 function data_user_can_delete_preset($context, $preset) {
4051     global $USER;
4053     if (has_capability('mod/data:manageuserpresets', $context)) {
4054         return true;
4055     } else {
4056         $candelete = false;
4057         if ($preset->userid == $USER->id) {
4058             $candelete = true;
4059         }
4060         return $candelete;
4061     }
4064 /**
4065  * Delete a record entry.
4066  *
4067  * @param int $recordid The ID for the record to be deleted.
4068  * @param object $data The data object for this activity.
4069  * @param int $courseid ID for the current course (for logging).
4070  * @param int $cmid The course module ID.
4071  * @return bool True if the record deleted, false if not.
4072  */
4073 function data_delete_record($recordid, $data, $courseid, $cmid) {
4074     global $DB, $CFG;
4076     if ($deleterecord = $DB->get_record('data_records', array('id' => $recordid))) {
4077         if ($deleterecord->dataid == $data->id) {
4078             if ($contents = $DB->get_records('data_content', array('recordid' => $deleterecord->id))) {
4079                 foreach ($contents as $content) {
4080                     if ($field = data_get_field_from_id($content->fieldid, $data)) {
4081                         $field->delete_content($content->recordid);
4082                     }
4083                 }
4084                 $DB->delete_records('data_content', array('recordid'=>$deleterecord->id));
4085                 $DB->delete_records('data_records', array('id'=>$deleterecord->id));
4087                 // Delete cached RSS feeds.
4088                 if (!empty($CFG->enablerssfeeds)) {
4089                     require_once($CFG->dirroot.'/mod/data/rsslib.php');
4090                     data_rss_delete_file($data);
4091                 }
4093                 core_tag_tag::remove_all_item_tags('mod_data', 'data_records', $recordid);
4095                 // Trigger an event for deleting this record.
4096                 $event = \mod_data\event\record_deleted::create(array(
4097                     'objectid' => $deleterecord->id,
4098                     'context' => context_module::instance($cmid),
4099                     'courseid' => $courseid,
4100                     'other' => array(
4101                         'dataid' => $deleterecord->dataid
4102                     )
4103                 ));
4104                 $event->add_record_snapshot('data_records', $deleterecord);
4105                 $event->trigger();
4106                 $course = get_course($courseid);
4107                 $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
4108                 data_update_completion_state($data, $course, $cm);
4110                 return true;
4111             }
4112         }
4113     }
4115     return false;
4118 /**
4119  * Check for required fields, and build a list of fields to be updated in a
4120  * submission.
4121  *
4122  * @param $mod stdClass The current recordid - provided as an optimisation.
4123  * @param $fields array The field data
4124  * @param $datarecord stdClass The submitted data.
4125  * @return stdClass containing:
4126  * * string[] generalnotifications Notifications for the form as a whole.
4127  * * string[] fieldnotifications Notifications for a specific field.
4128  * * bool validated Whether the field was validated successfully.
4129  * * data_field_base[] fields The field objects to be update.
4130  */
4131 function data_process_submission(stdClass $mod, $fields, stdClass $datarecord) {
4132     $result = new stdClass();
4134     // Empty form checking - you can't submit an empty form.
4135     $emptyform = true;
4136     $requiredfieldsfilled = true;
4137     $fieldsvalidated = true;
4139     // Store the notifications.
4140     $result->generalnotifications = array();
4141     $result->fieldnotifications = array();
4143     // Store the instantiated classes as an optimisation when processing the result.
4144     // This prevents the fields being re-initialised when updating.
4145     $result->fields = array();
4147     $submitteddata = array();
4148     foreach ($datarecord as $fieldname => $fieldvalue) {
4149         if (strpos($fieldname, '_')) {
4150             $namearray = explode('_', $fieldname, 3);
4151             $fieldid = $namearray[1];
4152             if (!isset($submitteddata[$fieldid])) {
4153                 $submitteddata[$fieldid] = array();
4154             }
4155             if (count($namearray) === 2) {
4156                 $subfieldid = 0;
4157             } else {
4158                 $subfieldid = $namearray[2];
4159             }
4161             $fielddata = new stdClass();
4162             $fielddata->fieldname = $fieldname;
4163             $fielddata->value = $fieldvalue;
4164             $submitteddata[$fieldid][$subfieldid] = $fielddata;
4165         }
4166     }
4168     // Check all form fields which have the required are filled.
4169     foreach ($fields as $fieldrecord) {
4170         // Check whether the field has any data.
4171         $fieldhascontent = false;
4173         $field = data_get_field($fieldrecord, $mod);
4174         if (isset($submitteddata[$fieldrecord->id])) {
4175             // Field validation check.
4176             if (method_exists($field, 'field_validation')) {
4177                 $errormessage = $field->field_validation($submitteddata[$fieldrecord->id]);
4178                 if ($errormessage) {
4179                     $result->fieldnotifications[$field->field->name][] = $errormessage;
4180                     $fieldsvalidated = false;
4181                 }
4182             }
4183             foreach ($submitteddata[$fieldrecord->id] as $fieldname => $value) {
4184                 if ($field->notemptyfield($value->value, $value->fieldname)) {
4185                     // The field has content and the form is not empty.
4186                     $fieldhascontent = true;
4187                     $emptyform = false;
4188                 }
4189             }
4190         }
4192         // If the field is required, add a notification to that effect.
4193         if ($field->field->required && !$fieldhascontent) {
4194             if (!isset($result->fieldnotifications[$field->field->name])) {
4195                 $result->fieldnotifications[$field->field->name] = array();
4196             }
4197             $result->fieldnotifications[$field->field->name][] = get_string('errormustsupplyvalue', 'data');
4198             $requiredfieldsfilled = false;
4199         }
4201         // Update the field.
4202         if (isset($submitteddata[$fieldrecord->id])) {
4203             foreach ($submitteddata[$fieldrecord->id] as $value) {
4204                 $result->fields[$value->fieldname] = $field;
4205             }
4206         }
4207     }
4209     if ($emptyform) {
4210         // The form is empty.
4211         $result->generalnotifications[] = get_string('emptyaddform', 'data');
4212     }
4214     $result->validated = $requiredfieldsfilled && !$emptyform && $fieldsvalidated;
4216     return $result;
4219 /**
4220  * This standard function will check all instances of this module
4221  * and make sure there are up-to-date events created for each of them.
4222  * If courseid = 0, then every data event in the site is checked, else
4223  * only data events belonging to the course specified are checked.
4224  * This function is used, in its new format, by restore_refresh_events()
4225  *
4226  * @param int $courseid
4227  * @param int|stdClass $instance Data module instance or ID.
4228  * @param int|stdClass $cm Course module object or ID (not used in this module).
4229  * @return bool
4230  */
4231 function data_refresh_events($courseid = 0, $instance = null, $cm = null) {
4232     global $DB, $CFG;
4233     require_once($CFG->dirroot.'/mod/data/locallib.php');
4235     // If we have instance information then we can just update the one event instead of updating all events.
4236     if (isset($instance)) {
4237         if (!is_object($instance)) {
4238             $instance = $DB->get_record('data', array('id' => $instance), '*', MUST_EXIST);
4239         }
4240         data_set_events($instance);
4241         return true;
4242     }
4244     if ($courseid) {
4245         if (! $data = $DB->get_records("data", array("course" => $courseid))) {
4246             return true;
4247         }
4248     } else {
4249         if (! $data = $DB->get_records("data")) {
4250             return true;
4251         }
4252     }
4254     foreach ($data as $datum) {
4255         data_set_events($datum);
4256     }
4257     return true;
4260 /**
4261  * Fetch the configuration for this database activity.
4262  *
4263  * @param   stdClass    $database   The object returned from the database for this instance
4264  * @param   string      $key        The name of the key to retrieve. If none is supplied, then all configuration is returned
4265  * @param   mixed       $default    The default value to use if no value was found for the specified key
4266  * @return  mixed                   The returned value
4267  */
4268 function data_get_config($database, $key = null, $default = null) {
4269     if (!empty($database->config)) {
4270         $config = json_decode($database->config);
4271     } else {
4272         $config = new stdClass();
4273     }
4275     if ($key === null) {
4276         return $config;
4277     }
4279     if (property_exists($config, $key)) {
4280         return $config->$key;
4281     }
4282     return $default;
4285 /**
4286  * Update the configuration for this database activity.
4287  *
4288  * @param   stdClass    $database   The object returned from the database for this instance
4289  * @param   string      $key        The name of the key to set
4290  * @param   mixed       $value      The value to set for the key
4291  */
4292 function data_set_config(&$database, $key, $value) {
4293     // Note: We must pass $database by reference because there may be subsequent calls to update_record and these should
4294     // not overwrite the configuration just set.
4295     global $DB;
4297     $config = data_get_config($database);
4299     if (!isset($config->$key) || $config->$key !== $value) {
4300         $config->$key = $value;
4301         $database->config = json_encode($config);
4302         $DB->set_field('data', 'config', $database->config, ['id' => $database->id]);
4303     }
4305 /**
4306  * Sets the automatic completion state for this database item based on the
4307  * count of on its entries.
4308  * @since Moodle 3.3
4309  * @param object $data The data object for this activity
4310  * @param object $course Course
4311  * @param object $cm course-module
4312  */
4313 function data_update_completion_state($data, $course, $cm) {
4314     // If completion option is enabled, evaluate it and return true/false.
4315     $completion = new completion_info($course);
4316     if ($data->completionentries && $completion->is_enabled($cm)) {
4317         $numentries = data_numentries($data);
4318         // Check the number of entries required against the number of entries already made.
4319         if ($numentries >= $data->completionentries) {
4320             $completion->update_state($cm, COMPLETION_COMPLETE);
4321         } else {
4322             $completion->update_state($cm, COMPLETION_INCOMPLETE);
4323         }
4324     }