fba383982f6fd032731d0b0c253d132f52d1baa7
[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);
36 define ('DATA_CAP_EXPORT', 'mod/data:viewalluserpresets');
38 define('DATA_PRESET_COMPONENT', 'mod_data');
39 define('DATA_PRESET_FILEAREA', 'site_presets');
40 define('DATA_PRESET_CONTEXT', SYSCONTEXTID);
42 define('DATA_EVENT_TYPE_OPEN', 'open');
43 define('DATA_EVENT_TYPE_CLOSE', 'close');
45 // Users having assigned the default role "Non-editing teacher" can export database records
46 // Using the mod/data capability "viewalluserpresets" existing in Moodle 1.9.x.
47 // In Moodle >= 2, new roles may be introduced and used instead.
49 /**
50  * @package   mod_data
51  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
52  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
53  */
54 class data_field_base {     // Base class for Database Field Types (see field/*/field.class.php)
56     /** @var string Subclasses must override the type with their name */
57     var $type = 'unknown';
58     /** @var object The database object that this field belongs to */
59     var $data = NULL;
60     /** @var object The field object itself, if we know it */
61     var $field = NULL;
62     /** @var int Width of the icon for this fieldtype */
63     var $iconwidth = 16;
64     /** @var int Width of the icon for this fieldtype */
65     var $iconheight = 16;
66     /** @var object course module or cmifno */
67     var $cm;
68     /** @var object activity context */
69     var $context;
70     /** @var priority for globalsearch indexing */
71     protected static $priority = self::NO_PRIORITY;
72     /** priority value for invalid fields regarding indexing */
73     const NO_PRIORITY = 0;
74     /** priority value for minimum priority */
75     const MIN_PRIORITY = 1;
76     /** priority value for low priority */
77     const LOW_PRIORITY = 2;
78     /** priority value for high priority */
79     const HIGH_PRIORITY = 3;
80     /** priority value for maximum priority */
81     const MAX_PRIORITY = 4;
83     /**
84      * Constructor function
85      *
86      * @global object
87      * @uses CONTEXT_MODULE
88      * @param int $field
89      * @param int $data
90      * @param int $cm
91      */
92     function __construct($field=0, $data=0, $cm=0) {   // Field or data or both, each can be id or object
93         global $DB;
95         if (empty($field) && empty($data)) {
96             print_error('missingfield', 'data');
97         }
99         if (!empty($field)) {
100             if (is_object($field)) {
101                 $this->field = $field;  // Programmer knows what they are doing, we hope
102             } else if (!$this->field = $DB->get_record('data_fields', array('id'=>$field))) {
103                 print_error('invalidfieldid', 'data');
104             }
105             if (empty($data)) {
106                 if (!$this->data = $DB->get_record('data', array('id'=>$this->field->dataid))) {
107                     print_error('invalidid', 'data');
108                 }
109             }
110         }
112         if (empty($this->data)) {         // We need to define this properly
113             if (!empty($data)) {
114                 if (is_object($data)) {
115                     $this->data = $data;  // Programmer knows what they are doing, we hope
116                 } else if (!$this->data = $DB->get_record('data', array('id'=>$data))) {
117                     print_error('invalidid', 'data');
118                 }
119             } else {                      // No way to define it!
120                 print_error('missingdata', 'data');
121             }
122         }
124         if ($cm) {
125             $this->cm = $cm;
126         } else {
127             $this->cm = get_coursemodule_from_instance('data', $this->data->id);
128         }
130         if (empty($this->field)) {         // We need to define some default values
131             $this->define_default_field();
132         }
134         $this->context = context_module::instance($this->cm->id);
135     }
138     /**
139      * This field just sets up a default field object
140      *
141      * @return bool
142      */
143     function define_default_field() {
144         global $OUTPUT;
145         if (empty($this->data->id)) {
146             echo $OUTPUT->notification('Programmer error: dataid not defined in field class');
147         }
148         $this->field = new stdClass();
149         $this->field->id = 0;
150         $this->field->dataid = $this->data->id;
151         $this->field->type   = $this->type;
152         $this->field->param1 = '';
153         $this->field->param2 = '';
154         $this->field->param3 = '';
155         $this->field->name = '';
156         $this->field->description = '';
157         $this->field->required = false;
159         return true;
160     }
162     /**
163      * Set up the field object according to data in an object.  Now is the time to clean it!
164      *
165      * @return bool
166      */
167     function define_field($data) {
168         $this->field->type        = $this->type;
169         $this->field->dataid      = $this->data->id;
171         $this->field->name        = trim($data->name);
172         $this->field->description = trim($data->description);
173         $this->field->required    = !empty($data->required) ? 1 : 0;
175         if (isset($data->param1)) {
176             $this->field->param1 = trim($data->param1);
177         }
178         if (isset($data->param2)) {
179             $this->field->param2 = trim($data->param2);
180         }
181         if (isset($data->param3)) {
182             $this->field->param3 = trim($data->param3);
183         }
184         if (isset($data->param4)) {
185             $this->field->param4 = trim($data->param4);
186         }
187         if (isset($data->param5)) {
188             $this->field->param5 = trim($data->param5);
189         }
191         return true;
192     }
194     /**
195      * Insert a new field in the database
196      * We assume the field object is already defined as $this->field
197      *
198      * @global object
199      * @return bool
200      */
201     function insert_field() {
202         global $DB, $OUTPUT;
204         if (empty($this->field)) {
205             echo $OUTPUT->notification('Programmer error: Field has not been defined yet!  See define_field()');
206             return false;
207         }
209         $this->field->id = $DB->insert_record('data_fields',$this->field);
211         // Trigger an event for creating this field.
212         $event = \mod_data\event\field_created::create(array(
213             'objectid' => $this->field->id,
214             'context' => $this->context,
215             'other' => array(
216                 'fieldname' => $this->field->name,
217                 'dataid' => $this->data->id
218             )
219         ));
220         $event->trigger();
222         return true;
223     }
226     /**
227      * Update a field in the database
228      *
229      * @global object
230      * @return bool
231      */
232     function update_field() {
233         global $DB;
235         $DB->update_record('data_fields', $this->field);
237         // Trigger an event for updating this field.
238         $event = \mod_data\event\field_updated::create(array(
239             'objectid' => $this->field->id,
240             'context' => $this->context,
241             'other' => array(
242                 'fieldname' => $this->field->name,
243                 'dataid' => $this->data->id
244             )
245         ));
246         $event->trigger();
248         return true;
249     }
251     /**
252      * Delete a field completely
253      *
254      * @global object
255      * @return bool
256      */
257     function delete_field() {
258         global $DB;
260         if (!empty($this->field->id)) {
261             // Get the field before we delete it.
262             $field = $DB->get_record('data_fields', array('id' => $this->field->id));
264             $this->delete_content();
265             $DB->delete_records('data_fields', array('id'=>$this->field->id));
267             // Trigger an event for deleting this field.
268             $event = \mod_data\event\field_deleted::create(array(
269                 'objectid' => $this->field->id,
270                 'context' => $this->context,
271                 'other' => array(
272                     'fieldname' => $this->field->name,
273                     'dataid' => $this->data->id
274                  )
275             ));
276             $event->add_record_snapshot('data_fields', $field);
277             $event->trigger();
278         }
280         return true;
281     }
283     /**
284      * Print the relevant form element in the ADD template for this field
285      *
286      * @global object
287      * @param int $recordid
288      * @return string
289      */
290     function display_add_field($recordid=0, $formdata=null) {
291         global $DB, $OUTPUT;
293         if ($formdata) {
294             $fieldname = 'field_' . $this->field->id;
295             $content = $formdata->$fieldname;
296         } else if ($recordid) {
297             $content = $DB->get_field('data_content', 'content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid));
298         } else {
299             $content = '';
300         }
302         // beware get_field returns false for new, empty records MDL-18567
303         if ($content===false) {
304             $content='';
305         }
307         $str = '<div title="' . s($this->field->description) . '">';
308         $str .= '<label for="field_'.$this->field->id.'"><span class="accesshide">'.$this->field->name.'</span>';
309         if ($this->field->required) {
310             $image = $OUTPUT->pix_icon('req', get_string('requiredelement', 'form'));
311             $str .= html_writer::div($image, 'inline-req');
312         }
313         $str .= '</label><input class="basefieldinput form-control d-inline mod-data-input" ' .
314                 'type="text" name="field_' . $this->field->id . '" ' .
315                 'id="field_' . $this->field->id . '" value="' . s($content) . '" />';
316         $str .= '</div>';
318         return $str;
319     }
321     /**
322      * Print the relevant form element to define the attributes for this field
323      * viewable by teachers only.
324      *
325      * @global object
326      * @global object
327      * @return void Output is echo'd
328      */
329     function display_edit_field() {
330         global $CFG, $DB, $OUTPUT;
332         if (empty($this->field)) {   // No field has been defined yet, try and make one
333             $this->define_default_field();
334         }
335         echo $OUTPUT->box_start('generalbox boxaligncenter boxwidthwide');
337         echo '<form id="editfield" action="'.$CFG->wwwroot.'/mod/data/field.php" method="post">'."\n";
338         echo '<input type="hidden" name="d" value="'.$this->data->id.'" />'."\n";
339         if (empty($this->field->id)) {
340             echo '<input type="hidden" name="mode" value="add" />'."\n";
341             $savebutton = get_string('add');
342         } else {
343             echo '<input type="hidden" name="fid" value="'.$this->field->id.'" />'."\n";
344             echo '<input type="hidden" name="mode" value="update" />'."\n";
345             $savebutton = get_string('savechanges');
346         }
347         echo '<input type="hidden" name="type" value="'.$this->type.'" />'."\n";
348         echo '<input name="sesskey" value="'.sesskey().'" type="hidden" />'."\n";
350         echo $OUTPUT->heading($this->name(), 3);
352         require_once($CFG->dirroot.'/mod/data/field/'.$this->type.'/mod.html');
354         echo '<div class="mdl-align">';
355         echo '<input type="submit" class="btn btn-primary" value="'.$savebutton.'" />'."\n";
356         echo '<input type="submit" class="btn btn-secondary" name="cancel" value="'.get_string('cancel').'" />'."\n";
357         echo '</div>';
359         echo '</form>';
361         echo $OUTPUT->box_end();
362     }
364     /**
365      * Display the content of the field in browse mode
366      *
367      * @global object
368      * @param int $recordid
369      * @param object $template
370      * @return bool|string
371      */
372     function display_browse_field($recordid, $template) {
373         global $DB;
375         if ($content = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
376             if (isset($content->content)) {
377                 $options = new stdClass();
378                 if ($this->field->param1 == '1') {  // We are autolinking this field, so disable linking within us
379                     //$content->content = '<span class="nolink">'.$content->content.'</span>';
380                     //$content->content1 = FORMAT_HTML;
381                     $options->filter=false;
382                 }
383                 $options->para = false;
384                 $str = format_text($content->content, $content->content1, $options);
385             } else {
386                 $str = '';
387             }
388             return $str;
389         }
390         return false;
391     }
393     /**
394      * Update the content of one data field in the data_content table
395      * @global object
396      * @param int $recordid
397      * @param mixed $value
398      * @param string $name
399      * @return bool
400      */
401     function update_content($recordid, $value, $name=''){
402         global $DB;
404         $content = new stdClass();
405         $content->fieldid = $this->field->id;
406         $content->recordid = $recordid;
407         $content->content = clean_param($value, PARAM_NOTAGS);
409         if ($oldcontent = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
410             $content->id = $oldcontent->id;
411             return $DB->update_record('data_content', $content);
412         } else {
413             return $DB->insert_record('data_content', $content);
414         }
415     }
417     /**
418      * Delete all content associated with the field
419      *
420      * @global object
421      * @param int $recordid
422      * @return bool
423      */
424     function delete_content($recordid=0) {
425         global $DB;
427         if ($recordid) {
428             $conditions = array('fieldid'=>$this->field->id, 'recordid'=>$recordid);
429         } else {
430             $conditions = array('fieldid'=>$this->field->id);
431         }
433         $rs = $DB->get_recordset('data_content', $conditions);
434         if ($rs->valid()) {
435             $fs = get_file_storage();
436             foreach ($rs as $content) {
437                 $fs->delete_area_files($this->context->id, 'mod_data', 'content', $content->id);
438             }
439         }
440         $rs->close();
442         return $DB->delete_records('data_content', $conditions);
443     }
445     /**
446      * Check if a field from an add form is empty
447      *
448      * @param mixed $value
449      * @param mixed $name
450      * @return bool
451      */
452     function notemptyfield($value, $name) {
453         return !empty($value);
454     }
456     /**
457      * Just in case a field needs to print something before the whole form
458      */
459     function print_before_form() {
460     }
462     /**
463      * Just in case a field needs to print something after the whole form
464      */
465     function print_after_form() {
466     }
469     /**
470      * Returns the sortable field for the content. By default, it's just content
471      * but for some plugins, it could be content 1 - content4
472      *
473      * @return string
474      */
475     function get_sort_field() {
476         return 'content';
477     }
479     /**
480      * Returns the SQL needed to refer to the column.  Some fields may need to CAST() etc.
481      *
482      * @param string $fieldname
483      * @return string $fieldname
484      */
485     function get_sort_sql($fieldname) {
486         return $fieldname;
487     }
489     /**
490      * Returns the name/type of the field
491      *
492      * @return string
493      */
494     function name() {
495         return get_string('fieldtypelabel', "datafield_$this->type");
496     }
498     /**
499      * Prints the respective type icon
500      *
501      * @global object
502      * @return string
503      */
504     function image() {
505         global $OUTPUT;
507         $params = array('d'=>$this->data->id, 'fid'=>$this->field->id, 'mode'=>'display', 'sesskey'=>sesskey());
508         $link = new moodle_url('/mod/data/field.php', $params);
509         $str = '<a href="'.$link->out().'">';
510         $str .= $OUTPUT->pix_icon('field/' . $this->type, $this->type, 'data');
511         $str .= '</a>';
512         return $str;
513     }
515     /**
516      * Per default, it is assumed that fields support text exporting.
517      * Override this (return false) on fields not supporting text exporting.
518      *
519      * @return bool true
520      */
521     function text_export_supported() {
522         return true;
523     }
525     /**
526      * Per default, return the record's text value only from the "content" field.
527      * Override this in fields class if necesarry.
528      *
529      * @param string $record
530      * @return string
531      */
532     function export_text_value($record) {
533         if ($this->text_export_supported()) {
534             return $record->content;
535         }
536     }
538     /**
539      * @param string $relativepath
540      * @return bool false
541      */
542     function file_ok($relativepath) {
543         return false;
544     }
546     /**
547      * Returns the priority for being indexed by globalsearch
548      *
549      * @return int
550      */
551     public static function get_priority() {
552         return static::$priority;
553     }
555     /**
556      * Returns the presentable string value for a field content.
557      *
558      * The returned string should be plain text.
559      *
560      * @param stdClass $content
561      * @return string
562      */
563     public static function get_content_value($content) {
564         return trim($content->content, "\r\n ");
565     }
567     /**
568      * Return the plugin configs for external functions,
569      * in some cases the configs will need formatting or be returned only if the current user has some capabilities enabled.
570      *
571      * @return array the list of config parameters
572      * @since Moodle 3.3
573      */
574     public function get_config_for_external() {
575         // Return all the field configs to null (maybe there is a private key for a service or something similar there).
576         $configs = [];
577         for ($i = 1; $i <= 10; $i++) {
578             $configs["param$i"] = null;
579         }
580         return $configs;
581     }
585 /**
586  * Given a template and a dataid, generate a default case template
587  *
588  * @global object
589  * @param object $data
590  * @param string template [addtemplate, singletemplate, listtempalte, rsstemplate]
591  * @param int $recordid
592  * @param bool $form
593  * @param bool $update
594  * @return bool|string
595  */
596 function data_generate_default_template(&$data, $template, $recordid=0, $form=false, $update=true) {
597     global $DB;
599     if (!$data && !$template) {
600         return false;
601     }
602     if ($template == 'csstemplate' or $template == 'jstemplate' ) {
603         return '';
604     }
606     // get all the fields for that database
607     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'id')) {
609         $table = new html_table();
610         $table->attributes['class'] = 'mod-data-default-template ##approvalstatus##';
611         $table->colclasses = array('template-field', 'template-token');
612         $table->data = array();
613         foreach ($fields as $field) {
614             if ($form) {   // Print forms instead of data
615                 $fieldobj = data_get_field($field, $data);
616                 $token = $fieldobj->display_add_field($recordid, null);
617             } else {           // Just print the tag
618                 $token = '[['.$field->name.']]';
619             }
620             $table->data[] = array(
621                 $field->name.': ',
622                 $token
623             );
624         }
625         if ($template == 'listtemplate') {
626             $cell = new html_table_cell('##edit##  ##more##  ##delete##  ##approve##  ##disapprove##  ##export##');
627             $cell->colspan = 2;
628             $cell->attributes['class'] = 'controls';
629             $table->data[] = new html_table_row(array($cell));
630         } else if ($template == 'singletemplate') {
631             $cell = new html_table_cell('##edit##  ##delete##  ##approve##  ##disapprove##  ##export##');
632             $cell->colspan = 2;
633             $cell->attributes['class'] = 'controls';
634             $table->data[] = new html_table_row(array($cell));
635         } else if ($template == 'asearchtemplate') {
636             $row = new html_table_row(array(get_string('authorfirstname', 'data').': ', '##firstname##'));
637             $row->attributes['class'] = 'searchcontrols';
638             $table->data[] = $row;
639             $row = new html_table_row(array(get_string('authorlastname', 'data').': ', '##lastname##'));
640             $row->attributes['class'] = 'searchcontrols';
641             $table->data[] = $row;
642         }
644         $str = '';
645         if ($template == 'listtemplate'){
646             $str .= '##delcheck##';
647             $str .= html_writer::empty_tag('br');
648         }
650         $str .= html_writer::start_tag('div', array('class' => 'defaulttemplate'));
651         $str .= html_writer::table($table);
652         $str .= html_writer::end_tag('div');
653         if ($template == 'listtemplate'){
654             $str .= html_writer::empty_tag('hr');
655         }
657         if ($update) {
658             $newdata = new stdClass();
659             $newdata->id = $data->id;
660             $newdata->{$template} = $str;
661             $DB->update_record('data', $newdata);
662             $data->{$template} = $str;
663         }
665         return $str;
666     }
670 /**
671  * Search for a field name and replaces it with another one in all the
672  * form templates. Set $newfieldname as '' if you want to delete the
673  * field from the form.
674  *
675  * @global object
676  * @param object $data
677  * @param string $searchfieldname
678  * @param string $newfieldname
679  * @return bool
680  */
681 function data_replace_field_in_templates($data, $searchfieldname, $newfieldname) {
682     global $DB;
684     if (!empty($newfieldname)) {
685         $prestring = '[[';
686         $poststring = ']]';
687         $idpart = '#id';
689     } else {
690         $prestring = '';
691         $poststring = '';
692         $idpart = '';
693     }
695     $newdata = new stdClass();
696     $newdata->id = $data->id;
697     $newdata->singletemplate = str_ireplace('[['.$searchfieldname.']]',
698             $prestring.$newfieldname.$poststring, $data->singletemplate);
700     $newdata->listtemplate = str_ireplace('[['.$searchfieldname.']]',
701             $prestring.$newfieldname.$poststring, $data->listtemplate);
703     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.']]',
704             $prestring.$newfieldname.$poststring, $data->addtemplate);
706     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.'#id]]',
707             $prestring.$newfieldname.$idpart.$poststring, $data->addtemplate);
709     $newdata->rsstemplate = str_ireplace('[['.$searchfieldname.']]',
710             $prestring.$newfieldname.$poststring, $data->rsstemplate);
712     return $DB->update_record('data', $newdata);
716 /**
717  * Appends a new field at the end of the form template.
718  *
719  * @global object
720  * @param object $data
721  * @param string $newfieldname
722  */
723 function data_append_new_field_to_templates($data, $newfieldname) {
724     global $DB;
726     $newdata = new stdClass();
727     $newdata->id = $data->id;
728     $change = false;
730     if (!empty($data->singletemplate)) {
731         $newdata->singletemplate = $data->singletemplate.' [[' . $newfieldname .']]';
732         $change = true;
733     }
734     if (!empty($data->addtemplate)) {
735         $newdata->addtemplate = $data->addtemplate.' [[' . $newfieldname . ']]';
736         $change = true;
737     }
738     if (!empty($data->rsstemplate)) {
739         $newdata->rsstemplate = $data->singletemplate.' [[' . $newfieldname . ']]';
740         $change = true;
741     }
742     if ($change) {
743         $DB->update_record('data', $newdata);
744     }
748 /**
749  * given a field name
750  * this function creates an instance of the particular subfield class
751  *
752  * @global object
753  * @param string $name
754  * @param object $data
755  * @return object|bool
756  */
757 function data_get_field_from_name($name, $data){
758     global $DB;
760     $field = $DB->get_record('data_fields', array('name'=>$name, 'dataid'=>$data->id));
762     if ($field) {
763         return data_get_field($field, $data);
764     } else {
765         return false;
766     }
769 /**
770  * given a field id
771  * this function creates an instance of the particular subfield class
772  *
773  * @global object
774  * @param int $fieldid
775  * @param object $data
776  * @return bool|object
777  */
778 function data_get_field_from_id($fieldid, $data){
779     global $DB;
781     $field = $DB->get_record('data_fields', array('id'=>$fieldid, 'dataid'=>$data->id));
783     if ($field) {
784         return data_get_field($field, $data);
785     } else {
786         return false;
787     }
790 /**
791  * given a field id
792  * this function creates an instance of the particular subfield class
793  *
794  * @global object
795  * @param string $type
796  * @param object $data
797  * @return object
798  */
799 function data_get_field_new($type, $data) {
800     global $CFG;
802     require_once($CFG->dirroot.'/mod/data/field/'.$type.'/field.class.php');
803     $newfield = 'data_field_'.$type;
804     $newfield = new $newfield(0, $data);
805     return $newfield;
808 /**
809  * returns a subclass field object given a record of the field, used to
810  * invoke plugin methods
811  * input: $param $field - record from db
812  *
813  * @global object
814  * @param object $field
815  * @param object $data
816  * @param object $cm
817  * @return object
818  */
819 function data_get_field($field, $data, $cm=null) {
820     global $CFG;
822     if ($field) {
823         require_once('field/'.$field->type.'/field.class.php');
824         $newfield = 'data_field_'.$field->type;
825         $newfield = new $newfield($field, $data, $cm);
826         return $newfield;
827     }
831 /**
832  * Given record object (or id), returns true if the record belongs to the current user
833  *
834  * @global object
835  * @global object
836  * @param mixed $record record object or id
837  * @return bool
838  */
839 function data_isowner($record) {
840     global $USER, $DB;
842     if (!isloggedin()) { // perf shortcut
843         return false;
844     }
846     if (!is_object($record)) {
847         if (!$record = $DB->get_record('data_records', array('id'=>$record))) {
848             return false;
849         }
850     }
852     return ($record->userid == $USER->id);
855 /**
856  * has a user reached the max number of entries?
857  *
858  * @param object $data
859  * @return bool
860  */
861 function data_atmaxentries($data){
862     if (!$data->maxentries){
863         return false;
865     } else {
866         return (data_numentries($data) >= $data->maxentries);
867     }
870 /**
871  * returns the number of entries already made by this user
872  *
873  * @global object
874  * @global object
875  * @param object $data
876  * @return int
877  */
878 function data_numentries($data, $userid=null) {
879     global $USER, $DB;
880     if ($userid === null) {
881         $userid = $USER->id;
882     }
883     $sql = 'SELECT COUNT(*) FROM {data_records} WHERE dataid=? AND userid=?';
884     return $DB->count_records_sql($sql, array($data->id, $userid));
887 /**
888  * function that takes in a dataid and adds a record
889  * this is used everytime an add template is submitted
890  *
891  * @global object
892  * @global object
893  * @param object $data
894  * @param int $groupid
895  * @return bool
896  */
897 function data_add_record($data, $groupid=0){
898     global $USER, $DB;
900     $cm = get_coursemodule_from_instance('data', $data->id);
901     $context = context_module::instance($cm->id);
903     $record = new stdClass();
904     $record->userid = $USER->id;
905     $record->dataid = $data->id;
906     $record->groupid = $groupid;
907     $record->timecreated = $record->timemodified = time();
908     if (has_capability('mod/data:approve', $context)) {
909         $record->approved = 1;
910     } else {
911         $record->approved = 0;
912     }
913     $record->id = $DB->insert_record('data_records', $record);
915     // Trigger an event for creating this record.
916     $event = \mod_data\event\record_created::create(array(
917         'objectid' => $record->id,
918         'context' => $context,
919         'other' => array(
920             'dataid' => $data->id
921         )
922     ));
923     $event->trigger();
925     $course = get_course($cm->course);
926     data_update_completion_state($data, $course, $cm);
928     return $record->id;
931 /**
932  * check the multple existence any tag in a template
933  *
934  * check to see if there are 2 or more of the same tag being used.
935  *
936  * @global object
937  * @param int $dataid,
938  * @param string $template
939  * @return bool
940  */
941 function data_tags_check($dataid, $template) {
942     global $DB, $OUTPUT;
944     // first get all the possible tags
945     $fields = $DB->get_records('data_fields', array('dataid'=>$dataid));
946     // then we generate strings to replace
947     $tagsok = true; // let's be optimistic
948     foreach ($fields as $field){
949         $pattern="/\[\[" . preg_quote($field->name, '/') . "\]\]/i";
950         if (preg_match_all($pattern, $template, $dummy)>1){
951             $tagsok = false;
952             echo $OUTPUT->notification('[['.$field->name.']] - '.get_string('multipletags','data'));
953         }
954     }
955     // else return true
956     return $tagsok;
959 /**
960  * Adds an instance of a data
961  *
962  * @param stdClass $data
963  * @param mod_data_mod_form $mform
964  * @return int intance id
965  */
966 function data_add_instance($data, $mform = null) {
967     global $DB, $CFG;
968     require_once($CFG->dirroot.'/mod/data/locallib.php');
970     if (empty($data->assessed)) {
971         $data->assessed = 0;
972     }
974     if (empty($data->ratingtime) || empty($data->assessed)) {
975         $data->assesstimestart  = 0;
976         $data->assesstimefinish = 0;
977     }
979     $data->timemodified = time();
981     $data->id = $DB->insert_record('data', $data);
983     // Add calendar events if necessary.
984     data_set_events($data);
986     data_grade_item_update($data);
988     return $data->id;
991 /**
992  * updates an instance of a data
993  *
994  * @global object
995  * @param object $data
996  * @return bool
997  */
998 function data_update_instance($data) {
999     global $DB, $CFG;
1000     require_once($CFG->dirroot.'/mod/data/locallib.php');
1002     $data->timemodified = time();
1003     $data->id           = $data->instance;
1005     if (empty($data->assessed)) {
1006         $data->assessed = 0;
1007     }
1009     if (empty($data->ratingtime) or empty($data->assessed)) {
1010         $data->assesstimestart  = 0;
1011         $data->assesstimefinish = 0;
1012     }
1014     if (empty($data->notification)) {
1015         $data->notification = 0;
1016     }
1018     $DB->update_record('data', $data);
1020     // Add calendar events if necessary.
1021     data_set_events($data);
1023     data_grade_item_update($data);
1025     return true;
1029 /**
1030  * deletes an instance of a data
1031  *
1032  * @global object
1033  * @param int $id
1034  * @return bool
1035  */
1036 function data_delete_instance($id) {    // takes the dataid
1037     global $DB, $CFG;
1039     if (!$data = $DB->get_record('data', array('id'=>$id))) {
1040         return false;
1041     }
1043     $cm = get_coursemodule_from_instance('data', $data->id);
1044     $context = context_module::instance($cm->id);
1046 /// Delete all the associated information
1048     // files
1049     $fs = get_file_storage();
1050     $fs->delete_area_files($context->id, 'mod_data');
1052     // get all the records in this data
1053     $sql = "SELECT r.id
1054               FROM {data_records} r
1055              WHERE r.dataid = ?";
1057     $DB->delete_records_select('data_content', "recordid IN ($sql)", array($id));
1059     // delete all the records and fields
1060     $DB->delete_records('data_records', array('dataid'=>$id));
1061     $DB->delete_records('data_fields', array('dataid'=>$id));
1063     // Remove old calendar events.
1064     $events = $DB->get_records('event', array('modulename' => 'data', 'instance' => $id));
1065     foreach ($events as $event) {
1066         $event = calendar_event::load($event);
1067         $event->delete();
1068     }
1070     // Delete the instance itself
1071     $result = $DB->delete_records('data', array('id'=>$id));
1073     // cleanup gradebook
1074     data_grade_item_delete($data);
1076     return $result;
1079 /**
1080  * returns a summary of data activity of this user
1081  *
1082  * @global object
1083  * @param object $course
1084  * @param object $user
1085  * @param object $mod
1086  * @param object $data
1087  * @return object|null
1088  */
1089 function data_user_outline($course, $user, $mod, $data) {
1090     global $DB, $CFG;
1091     require_once("$CFG->libdir/gradelib.php");
1093     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1094     if (empty($grades->items[0]->grades)) {
1095         $grade = false;
1096     } else {
1097         $grade = reset($grades->items[0]->grades);
1098     }
1101     if ($countrecords = $DB->count_records('data_records', array('dataid'=>$data->id, 'userid'=>$user->id))) {
1102         $result = new stdClass();
1103         $result->info = get_string('numrecords', 'data', $countrecords);
1104         $lastrecord   = $DB->get_record_sql('SELECT id,timemodified FROM {data_records}
1105                                               WHERE dataid = ? AND userid = ?
1106                                            ORDER BY timemodified DESC', array($data->id, $user->id), true);
1107         $result->time = $lastrecord->timemodified;
1108         if ($grade) {
1109             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1110         }
1111         return $result;
1112     } else if ($grade) {
1113         $result = new stdClass();
1114         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1116         //datesubmitted == time created. dategraded == time modified or time overridden
1117         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1118         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1119         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1120             $result->time = $grade->dategraded;
1121         } else {
1122             $result->time = $grade->datesubmitted;
1123         }
1125         return $result;
1126     }
1127     return NULL;
1130 /**
1131  * Prints all the records uploaded by this user
1132  *
1133  * @global object
1134  * @param object $course
1135  * @param object $user
1136  * @param object $mod
1137  * @param object $data
1138  */
1139 function data_user_complete($course, $user, $mod, $data) {
1140     global $DB, $CFG, $OUTPUT;
1141     require_once("$CFG->libdir/gradelib.php");
1143     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1144     if (!empty($grades->items[0]->grades)) {
1145         $grade = reset($grades->items[0]->grades);
1146         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1147         if ($grade->str_feedback) {
1148             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1149         }
1150     }
1152     if ($records = $DB->get_records('data_records', array('dataid'=>$data->id,'userid'=>$user->id), 'timemodified DESC')) {
1153         data_print_template('singletemplate', $records, $data);
1154     }
1157 /**
1158  * Return grade for given user or all users.
1159  *
1160  * @global object
1161  * @param object $data
1162  * @param int $userid optional user id, 0 means all users
1163  * @return array array of grades, false if none
1164  */
1165 function data_get_user_grades($data, $userid=0) {
1166     global $CFG;
1168     require_once($CFG->dirroot.'/rating/lib.php');
1170     $ratingoptions = new stdClass;
1171     $ratingoptions->component = 'mod_data';
1172     $ratingoptions->ratingarea = 'entry';
1173     $ratingoptions->modulename = 'data';
1174     $ratingoptions->moduleid   = $data->id;
1176     $ratingoptions->userid = $userid;
1177     $ratingoptions->aggregationmethod = $data->assessed;
1178     $ratingoptions->scaleid = $data->scale;
1179     $ratingoptions->itemtable = 'data_records';
1180     $ratingoptions->itemtableusercolumn = 'userid';
1182     $rm = new rating_manager();
1183     return $rm->get_user_grades($ratingoptions);
1186 /**
1187  * Update activity grades
1188  *
1189  * @category grade
1190  * @param object $data
1191  * @param int $userid specific user only, 0 means all
1192  * @param bool $nullifnone
1193  */
1194 function data_update_grades($data, $userid=0, $nullifnone=true) {
1195     global $CFG, $DB;
1196     require_once($CFG->libdir.'/gradelib.php');
1198     if (!$data->assessed) {
1199         data_grade_item_update($data);
1201     } else if ($grades = data_get_user_grades($data, $userid)) {
1202         data_grade_item_update($data, $grades);
1204     } else if ($userid and $nullifnone) {
1205         $grade = new stdClass();
1206         $grade->userid   = $userid;
1207         $grade->rawgrade = NULL;
1208         data_grade_item_update($data, $grade);
1210     } else {
1211         data_grade_item_update($data);
1212     }
1215 /**
1216  * Update/create grade item for given data
1217  *
1218  * @category grade
1219  * @param stdClass $data A database instance with extra cmidnumber property
1220  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1221  * @return object grade_item
1222  */
1223 function data_grade_item_update($data, $grades=NULL) {
1224     global $CFG;
1225     require_once($CFG->libdir.'/gradelib.php');
1227     $params = array('itemname'=>$data->name, 'idnumber'=>$data->cmidnumber);
1229     if (!$data->assessed or $data->scale == 0) {
1230         $params['gradetype'] = GRADE_TYPE_NONE;
1232     } else if ($data->scale > 0) {
1233         $params['gradetype'] = GRADE_TYPE_VALUE;
1234         $params['grademax']  = $data->scale;
1235         $params['grademin']  = 0;
1237     } else if ($data->scale < 0) {
1238         $params['gradetype'] = GRADE_TYPE_SCALE;
1239         $params['scaleid']   = -$data->scale;
1240     }
1242     if ($grades  === 'reset') {
1243         $params['reset'] = true;
1244         $grades = NULL;
1245     }
1247     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, $grades, $params);
1250 /**
1251  * Delete grade item for given data
1252  *
1253  * @category grade
1254  * @param object $data object
1255  * @return object grade_item
1256  */
1257 function data_grade_item_delete($data) {
1258     global $CFG;
1259     require_once($CFG->libdir.'/gradelib.php');
1261     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, NULL, array('deleted'=>1));
1264 // junk functions
1265 /**
1266  * takes a list of records, the current data, a search string,
1267  * and mode to display prints the translated template
1268  *
1269  * @global object
1270  * @global object
1271  * @param string $template
1272  * @param array $records
1273  * @param object $data
1274  * @param string $search
1275  * @param int $page
1276  * @param bool $return
1277  * @param object $jumpurl a moodle_url by which to jump back to the record list (can be null)
1278  * @return mixed
1279  */
1280 function data_print_template($template, $records, $data, $search='', $page=0, $return=false, moodle_url $jumpurl=null) {
1281     global $CFG, $DB, $OUTPUT;
1283     $cm = get_coursemodule_from_instance('data', $data->id);
1284     $context = context_module::instance($cm->id);
1286     static $fields = array();
1287     static $dataid = null;
1289     if (empty($dataid)) {
1290         $dataid = $data->id;
1291     } else if ($dataid != $data->id) {
1292         $fields = array();
1293     }
1295     if (empty($fields)) {
1296         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1297         foreach ($fieldrecords as $fieldrecord) {
1298             $fields[]= data_get_field($fieldrecord, $data);
1299         }
1300     }
1302     if (empty($records)) {
1303         return;
1304     }
1306     if (!$jumpurl) {
1307         $jumpurl = new moodle_url('/mod/data/view.php', array('d' => $data->id));
1308     }
1309     $jumpurl = new moodle_url($jumpurl, array('page' => $page, 'sesskey' => sesskey()));
1311     foreach ($records as $record) {   // Might be just one for the single template
1313     // Replacing tags
1314         $patterns = array();
1315         $replacement = array();
1317     // Then we generate strings to replace for normal tags
1318         foreach ($fields as $field) {
1319             $patterns[]='[['.$field->field->name.']]';
1320             $replacement[] = highlight($search, $field->display_browse_field($record->id, $template));
1321         }
1323         $canmanageentries = has_capability('mod/data:manageentries', $context);
1325     // Replacing special tags (##Edit##, ##Delete##, ##More##)
1326         $patterns[]='##edit##';
1327         $patterns[]='##delete##';
1328         if (data_user_can_manage_entry($record, $data, $context)) {
1329             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/edit.php?d='
1330                              .$data->id.'&amp;rid='.$record->id.'&amp;sesskey='.sesskey().'">' .
1331                              $OUTPUT->pix_icon('t/edit', get_string('edit')) . '</a>';
1332             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/view.php?d='
1333                              .$data->id.'&amp;delete='.$record->id.'&amp;sesskey='.sesskey().'">' .
1334                              $OUTPUT->pix_icon('t/delete', get_string('delete')) . '</a>';
1335         } else {
1336             $replacement[] = '';
1337             $replacement[] = '';
1338         }
1340         $moreurl = $CFG->wwwroot . '/mod/data/view.php?d=' . $data->id . '&amp;rid=' . $record->id;
1341         if ($search) {
1342             $moreurl .= '&amp;filter=1';
1343         }
1344         $patterns[]='##more##';
1345         $replacement[] = '<a href="'.$moreurl.'">' . $OUTPUT->pix_icon('t/preview', get_string('more', 'data')) . '</a>';
1347         $patterns[]='##moreurl##';
1348         $replacement[] = $moreurl;
1350         $patterns[]='##delcheck##';
1351         if ($canmanageentries) {
1352             $replacement[] = html_writer::checkbox('delcheck[]', $record->id, false, '', array('class' => 'recordcheckbox'));
1353         } else {
1354             $replacement[] = '';
1355         }
1357         $patterns[]='##user##';
1358         $replacement[] = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$record->userid.
1359                                '&amp;course='.$data->course.'">'.fullname($record).'</a>';
1361         $patterns[] = '##userpicture##';
1362         $ruser = user_picture::unalias($record, null, 'userid');
1363         // If the record didn't come with user data, retrieve the user from database.
1364         if (!isset($ruser->picture)) {
1365             $ruser = core_user::get_user($record->userid);
1366         }
1367         $replacement[] = $OUTPUT->user_picture($ruser, array('courseid' => $data->course));
1369         $patterns[]='##export##';
1371         if (!empty($CFG->enableportfolios) && ($template == 'singletemplate' || $template == 'listtemplate')
1372             && ((has_capability('mod/data:exportentry', $context)
1373                 || (data_isowner($record->id) && has_capability('mod/data:exportownentry', $context))))) {
1374             require_once($CFG->libdir . '/portfoliolib.php');
1375             $button = new portfolio_add_button();
1376             $button->set_callback_options('data_portfolio_caller', array('id' => $cm->id, 'recordid' => $record->id), 'mod_data');
1377             list($formats, $files) = data_portfolio_caller::formats($fields, $record);
1378             $button->set_formats($formats);
1379             $replacement[] = $button->to_html(PORTFOLIO_ADD_ICON_LINK);
1380         } else {
1381             $replacement[] = '';
1382         }
1384         $patterns[] = '##timeadded##';
1385         $replacement[] = userdate($record->timecreated);
1387         $patterns[] = '##timemodified##';
1388         $replacement [] = userdate($record->timemodified);
1390         $patterns[]='##approve##';
1391         if (has_capability('mod/data:approve', $context) && ($data->approval) && (!$record->approved)) {
1392             $approveurl = new moodle_url($jumpurl, array('approve' => $record->id));
1393             $approveicon = new pix_icon('t/approve', get_string('approve', 'data'), '', array('class' => 'iconsmall'));
1394             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($approveurl, $approveicon),
1395                     array('class' => 'approve'));
1396         } else {
1397             $replacement[] = '';
1398         }
1400         $patterns[]='##disapprove##';
1401         if (has_capability('mod/data:approve', $context) && ($data->approval) && ($record->approved)) {
1402             $disapproveurl = new moodle_url($jumpurl, array('disapprove' => $record->id));
1403             $disapproveicon = new pix_icon('t/block', get_string('disapprove', 'data'), '', array('class' => 'iconsmall'));
1404             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($disapproveurl, $disapproveicon),
1405                     array('class' => 'disapprove'));
1406         } else {
1407             $replacement[] = '';
1408         }
1410         $patterns[] = '##approvalstatus##';
1411         if (!$data->approval) {
1412             $replacement[] = '';
1413         } else if ($record->approved) {
1414             $replacement[] = get_string('approved', 'data');
1415         } else {
1416             $replacement[] = get_string('notapproved', 'data');
1417         }
1419         $patterns[]='##comments##';
1420         if (($template == 'listtemplate') && ($data->comments)) {
1422             if (!empty($CFG->usecomments)) {
1423                 require_once($CFG->dirroot  . '/comment/lib.php');
1424                 list($context, $course, $cm) = get_context_info_array($context->id);
1425                 $cmt = new stdClass();
1426                 $cmt->context = $context;
1427                 $cmt->course  = $course;
1428                 $cmt->cm      = $cm;
1429                 $cmt->area    = 'database_entry';
1430                 $cmt->itemid  = $record->id;
1431                 $cmt->showcount = true;
1432                 $cmt->component = 'mod_data';
1433                 $comment = new comment($cmt);
1434                 $replacement[] = $comment->output(true);
1435             }
1436         } else {
1437             $replacement[] = '';
1438         }
1440         // actual replacement of the tags
1441         $newtext = str_ireplace($patterns, $replacement, $data->{$template});
1443         // no more html formatting and filtering - see MDL-6635
1444         if ($return) {
1445             return $newtext;
1446         } else {
1447             echo $newtext;
1449             // hack alert - return is always false in singletemplate anyway ;-)
1450             /**********************************
1451              *    Printing Ratings Form       *
1452              *********************************/
1453             if ($template == 'singletemplate') {    //prints ratings options
1454                 data_print_ratings($data, $record);
1455             }
1457             /**********************************
1458              *    Printing Comments Form       *
1459              *********************************/
1460             if (($template == 'singletemplate') && ($data->comments)) {
1461                 if (!empty($CFG->usecomments)) {
1462                     require_once($CFG->dirroot . '/comment/lib.php');
1463                     list($context, $course, $cm) = get_context_info_array($context->id);
1464                     $cmt = new stdClass();
1465                     $cmt->context = $context;
1466                     $cmt->course  = $course;
1467                     $cmt->cm      = $cm;
1468                     $cmt->area    = 'database_entry';
1469                     $cmt->itemid  = $record->id;
1470                     $cmt->showcount = true;
1471                     $cmt->component = 'mod_data';
1472                     $comment = new comment($cmt);
1473                     $comment->output(false);
1474                 }
1475             }
1476         }
1477     }
1480 /**
1481  * Return rating related permissions
1482  *
1483  * @param string $contextid the context id
1484  * @param string $component the component to get rating permissions for
1485  * @param string $ratingarea the rating area to get permissions for
1486  * @return array an associative array of the user's rating permissions
1487  */
1488 function data_rating_permissions($contextid, $component, $ratingarea) {
1489     $context = context::instance_by_id($contextid, MUST_EXIST);
1490     if ($component != 'mod_data' || $ratingarea != 'entry') {
1491         return null;
1492     }
1493     return array(
1494         'view'    => has_capability('mod/data:viewrating',$context),
1495         'viewany' => has_capability('mod/data:viewanyrating',$context),
1496         'viewall' => has_capability('mod/data:viewallratings',$context),
1497         'rate'    => has_capability('mod/data:rate',$context)
1498     );
1501 /**
1502  * Validates a submitted rating
1503  * @param array $params submitted data
1504  *            context => object the context in which the rated items exists [required]
1505  *            itemid => int the ID of the object being rated
1506  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
1507  *            rating => int the submitted rating
1508  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
1509  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
1510  * @return boolean true if the rating is valid. Will throw rating_exception if not
1511  */
1512 function data_rating_validate($params) {
1513     global $DB, $USER;
1515     // Check the component is mod_data
1516     if ($params['component'] != 'mod_data') {
1517         throw new rating_exception('invalidcomponent');
1518     }
1520     // Check the ratingarea is entry (the only rating area in data module)
1521     if ($params['ratingarea'] != 'entry') {
1522         throw new rating_exception('invalidratingarea');
1523     }
1525     // Check the rateduserid is not the current user .. you can't rate your own entries
1526     if ($params['rateduserid'] == $USER->id) {
1527         throw new rating_exception('nopermissiontorate');
1528     }
1530     $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
1531                   FROM {data_records} r
1532                   JOIN {data} d ON r.dataid = d.id
1533                  WHERE r.id = :itemid";
1534     $dataparams = array('itemid'=>$params['itemid']);
1535     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1536         //item doesn't exist
1537         throw new rating_exception('invaliditemid');
1538     }
1540     if ($info->scale != $params['scaleid']) {
1541         //the scale being submitted doesnt match the one in the database
1542         throw new rating_exception('invalidscaleid');
1543     }
1545     //check that the submitted rating is valid for the scale
1547     // lower limit
1548     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
1549         throw new rating_exception('invalidnum');
1550     }
1552     // upper limit
1553     if ($info->scale < 0) {
1554         //its a custom scale
1555         $scalerecord = $DB->get_record('scale', array('id' => -$info->scale));
1556         if ($scalerecord) {
1557             $scalearray = explode(',', $scalerecord->scale);
1558             if ($params['rating'] > count($scalearray)) {
1559                 throw new rating_exception('invalidnum');
1560             }
1561         } else {
1562             throw new rating_exception('invalidscaleid');
1563         }
1564     } else if ($params['rating'] > $info->scale) {
1565         //if its numeric and submitted rating is above maximum
1566         throw new rating_exception('invalidnum');
1567     }
1569     if ($info->approval && !$info->approved) {
1570         //database requires approval but this item isnt approved
1571         throw new rating_exception('nopermissiontorate');
1572     }
1574     // check the item we're rating was created in the assessable time window
1575     if (!empty($info->assesstimestart) && !empty($info->assesstimefinish)) {
1576         if ($info->timecreated < $info->assesstimestart || $info->timecreated > $info->assesstimefinish) {
1577             throw new rating_exception('notavailable');
1578         }
1579     }
1581     $course = $DB->get_record('course', array('id'=>$info->course), '*', MUST_EXIST);
1582     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1583     $context = context_module::instance($cm->id);
1585     // if the supplied context doesnt match the item's context
1586     if ($context->id != $params['context']->id) {
1587         throw new rating_exception('invalidcontext');
1588     }
1590     // Make sure groups allow this user to see the item they're rating
1591     $groupid = $info->groupid;
1592     if ($groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
1593         if (!groups_group_exists($groupid)) { // Can't find group
1594             throw new rating_exception('cannotfindgroup');//something is wrong
1595         }
1597         if (!groups_is_member($groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
1598             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
1599             throw new rating_exception('notmemberofgroup');
1600         }
1601     }
1603     return true;
1606 /**
1607  * Can the current user see ratings for a given itemid?
1608  *
1609  * @param array $params submitted data
1610  *            contextid => int contextid [required]
1611  *            component => The component for this module - should always be mod_data [required]
1612  *            ratingarea => object the context in which the rated items exists [required]
1613  *            itemid => int the ID of the object being rated [required]
1614  *            scaleid => int scale id [optional]
1615  * @return bool
1616  * @throws coding_exception
1617  * @throws rating_exception
1618  */
1619 function mod_data_rating_can_see_item_ratings($params) {
1620     global $DB;
1622     // Check the component is mod_data.
1623     if (!isset($params['component']) || $params['component'] != 'mod_data') {
1624         throw new rating_exception('invalidcomponent');
1625     }
1627     // Check the ratingarea is entry (the only rating area in data).
1628     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'entry') {
1629         throw new rating_exception('invalidratingarea');
1630     }
1632     if (!isset($params['itemid'])) {
1633         throw new rating_exception('invaliditemid');
1634     }
1636     $datasql = "SELECT d.id as dataid, d.course, r.groupid
1637                   FROM {data_records} r
1638                   JOIN {data} d ON r.dataid = d.id
1639                  WHERE r.id = :itemid";
1640     $dataparams = array('itemid' => $params['itemid']);
1641     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1642         // Item doesn't exist.
1643         throw new rating_exception('invaliditemid');
1644     }
1646     // User can see ratings of all participants.
1647     if ($info->groupid == 0) {
1648         return true;
1649     }
1651     $course = $DB->get_record('course', array('id' => $info->course), '*', MUST_EXIST);
1652     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1654     // Make sure groups allow this user to see the item they're rating.
1655     return groups_group_visible($info->groupid, $course, $cm);
1659 /**
1660  * function that takes in the current data, number of items per page,
1661  * a search string and prints a preference box in view.php
1662  *
1663  * This preference box prints a searchable advanced search template if
1664  *     a) A template is defined
1665  *  b) The advanced search checkbox is checked.
1666  *
1667  * @global object
1668  * @global object
1669  * @param object $data
1670  * @param int $perpage
1671  * @param string $search
1672  * @param string $sort
1673  * @param string $order
1674  * @param array $search_array
1675  * @param int $advanced
1676  * @param string $mode
1677  * @return void
1678  */
1679 function data_print_preference_form($data, $perpage, $search, $sort='', $order='ASC', $search_array = '', $advanced = 0, $mode= ''){
1680     global $CFG, $DB, $PAGE, $OUTPUT;
1682     $cm = get_coursemodule_from_instance('data', $data->id);
1683     $context = context_module::instance($cm->id);
1684     echo '<br /><div class="datapreferences">';
1685     echo '<form id="options" action="view.php" method="get">';
1686     echo '<div>';
1687     echo '<input type="hidden" name="d" value="'.$data->id.'" />';
1688     if ($mode =='asearch') {
1689         $advanced = 1;
1690         echo '<input type="hidden" name="mode" value="list" />';
1691     }
1692     echo '<label for="pref_perpage">'.get_string('pagesize','data').'</label> ';
1693     $pagesizes = array(2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,15=>15,
1694                        20=>20,30=>30,40=>40,50=>50,100=>100,200=>200,300=>300,400=>400,500=>500,1000=>1000);
1695     echo html_writer::select($pagesizes, 'perpage', $perpage, false, array('id' => 'pref_perpage', 'class' => 'custom-select'));
1697     if ($advanced) {
1698         $regsearchclass = 'search_none';
1699         $advancedsearchclass = 'search_inline';
1700     } else {
1701         $regsearchclass = 'search_inline';
1702         $advancedsearchclass = 'search_none';
1703     }
1704     echo '<div id="reg_search" class="' . $regsearchclass . ' form-inline" >&nbsp;&nbsp;&nbsp;';
1705     echo '<label for="pref_search">' . get_string('search') . '</label> <input type="text" ' .
1706          'class="form-control" size="16" name="search" id= "pref_search" value="' . s($search) . '" /></div>';
1707     echo '&nbsp;&nbsp;&nbsp;<label for="pref_sortby">'.get_string('sortby').'</label> ';
1708     // foreach field, print the option
1709     echo '<select name="sort" id="pref_sortby" class="custom-select m-r-1">';
1710     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'name')) {
1711         echo '<optgroup label="'.get_string('fields', 'data').'">';
1712         foreach ($fields as $field) {
1713             if ($field->id == $sort) {
1714                 echo '<option value="'.$field->id.'" selected="selected">'.$field->name.'</option>';
1715             } else {
1716                 echo '<option value="'.$field->id.'">'.$field->name.'</option>';
1717             }
1718         }
1719         echo '</optgroup>';
1720     }
1721     $options = array();
1722     $options[DATA_TIMEADDED]    = get_string('timeadded', 'data');
1723     $options[DATA_TIMEMODIFIED] = get_string('timemodified', 'data');
1724     $options[DATA_FIRSTNAME]    = get_string('authorfirstname', 'data');
1725     $options[DATA_LASTNAME]     = get_string('authorlastname', 'data');
1726     if ($data->approval and has_capability('mod/data:approve', $context)) {
1727         $options[DATA_APPROVED] = get_string('approved', 'data');
1728     }
1729     echo '<optgroup label="'.get_string('other', 'data').'">';
1730     foreach ($options as $key => $name) {
1731         if ($key == $sort) {
1732             echo '<option value="'.$key.'" selected="selected">'.$name.'</option>';
1733         } else {
1734             echo '<option value="'.$key.'">'.$name.'</option>';
1735         }
1736     }
1737     echo '</optgroup>';
1738     echo '</select>';
1739     echo '<label for="pref_order" class="accesshide">'.get_string('order').'</label>';
1740     echo '<select id="pref_order" name="order" class="custom-select m-r-1">';
1741     if ($order == 'ASC') {
1742         echo '<option value="ASC" selected="selected">'.get_string('ascending','data').'</option>';
1743     } else {
1744         echo '<option value="ASC">'.get_string('ascending','data').'</option>';
1745     }
1746     if ($order == 'DESC') {
1747         echo '<option value="DESC" selected="selected">'.get_string('descending','data').'</option>';
1748     } else {
1749         echo '<option value="DESC">'.get_string('descending','data').'</option>';
1750     }
1751     echo '</select>';
1753     if ($advanced) {
1754         $checked = ' checked="checked" ';
1755     }
1756     else {
1757         $checked = '';
1758     }
1759     $PAGE->requires->js('/mod/data/data.js');
1760     echo '&nbsp;<input type="hidden" name="advanced" value="0" />';
1761     echo '&nbsp;<input type="hidden" name="filter" value="1" />';
1762     echo '&nbsp;<input type="checkbox" id="advancedcheckbox" name="advanced" value="1" ' . $checked . ' ' .
1763          'onchange="showHideAdvSearch(this.checked);" class="m-x-1" />' .
1764          '<label for="advancedcheckbox">' . get_string('advancedsearch', 'data') . '</label>';
1765     echo '&nbsp;<input type="submit" class="btn btn-secondary" value="' . get_string('savesettings', 'data') . '" />';
1767     echo '<br />';
1768     echo '<div class="' . $advancedsearchclass . '" id="data_adv_form">';
1769     echo '<table class="boxaligncenter">';
1771     // print ASC or DESC
1772     echo '<tr><td colspan="2">&nbsp;</td></tr>';
1773     $i = 0;
1775     // Determine if we are printing all fields for advanced search, or the template for advanced search
1776     // If a template is not defined, use the deafault template and display all fields.
1777     if(empty($data->asearchtemplate)) {
1778         data_generate_default_template($data, 'asearchtemplate');
1779     }
1781     static $fields = array();
1782     static $dataid = null;
1784     if (empty($dataid)) {
1785         $dataid = $data->id;
1786     } else if ($dataid != $data->id) {
1787         $fields = array();
1788     }
1790     if (empty($fields)) {
1791         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1792         foreach ($fieldrecords as $fieldrecord) {
1793             $fields[]= data_get_field($fieldrecord, $data);
1794         }
1795     }
1797     // Replacing tags
1798     $patterns = array();
1799     $replacement = array();
1801     // Then we generate strings to replace for normal tags
1802     foreach ($fields as $field) {
1803         $fieldname = $field->field->name;
1804         $fieldname = preg_quote($fieldname, '/');
1805         $patterns[] = "/\[\[$fieldname\]\]/i";
1806         $searchfield = data_get_field_from_id($field->field->id, $data);
1807         if (!empty($search_array[$field->field->id]->data)) {
1808             $replacement[] = $searchfield->display_search_field($search_array[$field->field->id]->data);
1809         } else {
1810             $replacement[] = $searchfield->display_search_field();
1811         }
1812     }
1813     $fn = !empty($search_array[DATA_FIRSTNAME]->data) ? $search_array[DATA_FIRSTNAME]->data : '';
1814     $ln = !empty($search_array[DATA_LASTNAME]->data) ? $search_array[DATA_LASTNAME]->data : '';
1815     $patterns[]    = '/##firstname##/';
1816     $replacement[] = '<label class="accesshide" for="u_fn">' . get_string('authorfirstname', 'data') . '</label>' .
1817                      '<input type="text" class="form-control" size="16" id="u_fn" name="u_fn" value="' . s($fn) . '" />';
1818     $patterns[]    = '/##lastname##/';
1819     $replacement[] = '<label class="accesshide" for="u_ln">' . get_string('authorlastname', 'data') . '</label>' .
1820                      '<input type="text" class="form-control" size="16" id="u_ln" name="u_ln" value="' . s($ln) . '" />';
1822     // actual replacement of the tags
1823     $newtext = preg_replace($patterns, $replacement, $data->asearchtemplate);
1825     $options = new stdClass();
1826     $options->para=false;
1827     $options->noclean=true;
1828     echo '<tr><td>';
1829     echo format_text($newtext, FORMAT_HTML, $options);
1830     echo '</td></tr>';
1832     echo '<tr><td colspan="4"><br/>' .
1833          '<input type="submit" class="btn btn-primary m-r-1" value="' . get_string('savesettings', 'data') . '" />' .
1834          '<input type="submit" class="btn btn-secondary" name="resetadv" value="' . get_string('resetsettings', 'data') . '" />' .
1835          '</td></tr>';
1836     echo '</table>';
1837     echo '</div>';
1838     echo '</div>';
1839     echo '</form>';
1840     echo '</div>';
1843 /**
1844  * @global object
1845  * @global object
1846  * @param object $data
1847  * @param object $record
1848  * @return void Output echo'd
1849  */
1850 function data_print_ratings($data, $record) {
1851     global $OUTPUT;
1852     if (!empty($record->rating)){
1853         echo $OUTPUT->render($record->rating);
1854     }
1857 /**
1858  * List the actions that correspond to a view of this module.
1859  * This is used by the participation report.
1860  *
1861  * Note: This is not used by new logging system. Event with
1862  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
1863  *       be considered as view action.
1864  *
1865  * @return array
1866  */
1867 function data_get_view_actions() {
1868     return array('view');
1871 /**
1872  * List the actions that correspond to a post of this module.
1873  * This is used by the participation report.
1874  *
1875  * Note: This is not used by new logging system. Event with
1876  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
1877  *       will be considered as post action.
1878  *
1879  * @return array
1880  */
1881 function data_get_post_actions() {
1882     return array('add','update','record delete');
1885 /**
1886  * @param string $name
1887  * @param int $dataid
1888  * @param int $fieldid
1889  * @return bool
1890  */
1891 function data_fieldname_exists($name, $dataid, $fieldid = 0) {
1892     global $DB;
1894     if (!is_numeric($name)) {
1895         $like = $DB->sql_like('df.name', ':name', false);
1896     } else {
1897         $like = "df.name = :name";
1898     }
1899     $params = array('name'=>$name);
1900     if ($fieldid) {
1901         $params['dataid']   = $dataid;
1902         $params['fieldid1'] = $fieldid;
1903         $params['fieldid2'] = $fieldid;
1904         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1905                                         WHERE $like AND df.dataid = :dataid
1906                                               AND ((df.id < :fieldid1) OR (df.id > :fieldid2))", $params);
1907     } else {
1908         $params['dataid']   = $dataid;
1909         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1910                                         WHERE $like AND df.dataid = :dataid", $params);
1911     }
1914 /**
1915  * @param array $fieldinput
1916  */
1917 function data_convert_arrays_to_strings(&$fieldinput) {
1918     foreach ($fieldinput as $key => $val) {
1919         if (is_array($val)) {
1920             $str = '';
1921             foreach ($val as $inner) {
1922                 $str .= $inner . ',';
1923             }
1924             $str = substr($str, 0, -1);
1926             $fieldinput->$key = $str;
1927         }
1928     }
1932 /**
1933  * Converts a database (module instance) to use the Roles System
1934  *
1935  * @global object
1936  * @global object
1937  * @uses CONTEXT_MODULE
1938  * @uses CAP_PREVENT
1939  * @uses CAP_ALLOW
1940  * @param object $data a data object with the same attributes as a record
1941  *                     from the data database table
1942  * @param int $datamodid the id of the data module, from the modules table
1943  * @param array $teacherroles array of roles that have archetype teacher
1944  * @param array $studentroles array of roles that have archetype student
1945  * @param array $guestroles array of roles that have archetype guest
1946  * @param int $cmid the course_module id for this data instance
1947  * @return boolean data module was converted or not
1948  */
1949 function data_convert_to_roles($data, $teacherroles=array(), $studentroles=array(), $cmid=NULL) {
1950     global $CFG, $DB, $OUTPUT;
1952     if (!isset($data->participants) && !isset($data->assesspublic)
1953             && !isset($data->groupmode)) {
1954         // We assume that this database has already been converted to use the
1955         // Roles System. above fields get dropped the data module has been
1956         // upgraded to use Roles.
1957         return false;
1958     }
1960     if (empty($cmid)) {
1961         // We were not given the course_module id. Try to find it.
1962         if (!$cm = get_coursemodule_from_instance('data', $data->id)) {
1963             echo $OUTPUT->notification('Could not get the course module for the data');
1964             return false;
1965         } else {
1966             $cmid = $cm->id;
1967         }
1968     }
1969     $context = context_module::instance($cmid);
1972     // $data->participants:
1973     // 1 - Only teachers can add entries
1974     // 3 - Teachers and students can add entries
1975     switch ($data->participants) {
1976         case 1:
1977             foreach ($studentroles as $studentrole) {
1978                 assign_capability('mod/data:writeentry', CAP_PREVENT, $studentrole->id, $context->id);
1979             }
1980             foreach ($teacherroles as $teacherrole) {
1981                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
1982             }
1983             break;
1984         case 3:
1985             foreach ($studentroles as $studentrole) {
1986                 assign_capability('mod/data:writeentry', CAP_ALLOW, $studentrole->id, $context->id);
1987             }
1988             foreach ($teacherroles as $teacherrole) {
1989                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
1990             }
1991             break;
1992     }
1994     // $data->assessed:
1995     // 2 - Only teachers can rate posts
1996     // 1 - Everyone can rate posts
1997     // 0 - No one can rate posts
1998     switch ($data->assessed) {
1999         case 0:
2000             foreach ($studentroles as $studentrole) {
2001                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2002             }
2003             foreach ($teacherroles as $teacherrole) {
2004                 assign_capability('mod/data:rate', CAP_PREVENT, $teacherrole->id, $context->id);
2005             }
2006             break;
2007         case 1:
2008             foreach ($studentroles as $studentrole) {
2009                 assign_capability('mod/data:rate', CAP_ALLOW, $studentrole->id, $context->id);
2010             }
2011             foreach ($teacherroles as $teacherrole) {
2012                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2013             }
2014             break;
2015         case 2:
2016             foreach ($studentroles as $studentrole) {
2017                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2018             }
2019             foreach ($teacherroles as $teacherrole) {
2020                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2021             }
2022             break;
2023     }
2025     // $data->assesspublic:
2026     // 0 - Students can only see their own ratings
2027     // 1 - Students can see everyone's ratings
2028     switch ($data->assesspublic) {
2029         case 0:
2030             foreach ($studentroles as $studentrole) {
2031                 assign_capability('mod/data:viewrating', CAP_PREVENT, $studentrole->id, $context->id);
2032             }
2033             foreach ($teacherroles as $teacherrole) {
2034                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2035             }
2036             break;
2037         case 1:
2038             foreach ($studentroles as $studentrole) {
2039                 assign_capability('mod/data:viewrating', CAP_ALLOW, $studentrole->id, $context->id);
2040             }
2041             foreach ($teacherroles as $teacherrole) {
2042                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2043             }
2044             break;
2045     }
2047     if (empty($cm)) {
2048         $cm = $DB->get_record('course_modules', array('id'=>$cmid));
2049     }
2051     switch ($cm->groupmode) {
2052         case NOGROUPS:
2053             break;
2054         case SEPARATEGROUPS:
2055             foreach ($studentroles as $studentrole) {
2056                 assign_capability('moodle/site:accessallgroups', CAP_PREVENT, $studentrole->id, $context->id);
2057             }
2058             foreach ($teacherroles as $teacherrole) {
2059                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2060             }
2061             break;
2062         case VISIBLEGROUPS:
2063             foreach ($studentroles as $studentrole) {
2064                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $studentrole->id, $context->id);
2065             }
2066             foreach ($teacherroles as $teacherrole) {
2067                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2068             }
2069             break;
2070     }
2071     return true;
2074 /**
2075  * Returns the best name to show for a preset
2076  *
2077  * @param string $shortname
2078  * @param  string $path
2079  * @return string
2080  */
2081 function data_preset_name($shortname, $path) {
2083     // We are looking inside the preset itself as a first choice, but also in normal data directory
2084     $string = get_string('modulename', 'datapreset_'.$shortname);
2086     if (substr($string, 0, 1) == '[') {
2087         return $shortname;
2088     } else {
2089         return $string;
2090     }
2093 /**
2094  * Returns an array of all the available presets.
2095  *
2096  * @return array
2097  */
2098 function data_get_available_presets($context) {
2099     global $CFG, $USER;
2101     $presets = array();
2103     // First load the ratings sub plugins that exist within the modules preset dir
2104     if ($dirs = core_component::get_plugin_list('datapreset')) {
2105         foreach ($dirs as $dir=>$fulldir) {
2106             if (is_directory_a_preset($fulldir)) {
2107                 $preset = new stdClass();
2108                 $preset->path = $fulldir;
2109                 $preset->userid = 0;
2110                 $preset->shortname = $dir;
2111                 $preset->name = data_preset_name($dir, $fulldir);
2112                 if (file_exists($fulldir.'/screenshot.jpg')) {
2113                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.jpg';
2114                 } else if (file_exists($fulldir.'/screenshot.png')) {
2115                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.png';
2116                 } else if (file_exists($fulldir.'/screenshot.gif')) {
2117                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.gif';
2118                 }
2119                 $presets[] = $preset;
2120             }
2121         }
2122     }
2123     // Now add to that the site presets that people have saved
2124     $presets = data_get_available_site_presets($context, $presets);
2125     return $presets;
2128 /**
2129  * Gets an array of all of the presets that users have saved to the site.
2130  *
2131  * @param stdClass $context The context that we are looking from.
2132  * @param array $presets
2133  * @return array An array of presets
2134  */
2135 function data_get_available_site_presets($context, array $presets=array()) {
2136     global $USER;
2138     $fs = get_file_storage();
2139     $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2140     $canviewall = has_capability('mod/data:viewalluserpresets', $context);
2141     if (empty($files)) {
2142         return $presets;
2143     }
2144     foreach ($files as $file) {
2145         if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory() || (!$canviewall && $file->get_userid() != $USER->id)) {
2146             continue;
2147         }
2148         $preset = new stdClass;
2149         $preset->path = $file->get_filepath();
2150         $preset->name = trim($preset->path, '/');
2151         $preset->shortname = $preset->name;
2152         $preset->userid = $file->get_userid();
2153         $preset->id = $file->get_id();
2154         $preset->storedfile = $file;
2155         $presets[] = $preset;
2156     }
2157     return $presets;
2160 /**
2161  * Deletes a saved preset.
2162  *
2163  * @param string $name
2164  * @return bool
2165  */
2166 function data_delete_site_preset($name) {
2167     $fs = get_file_storage();
2169     $files = $fs->get_directory_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/');
2170     if (!empty($files)) {
2171         foreach ($files as $file) {
2172             $file->delete();
2173         }
2174     }
2176     $dir = $fs->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/', '.');
2177     if (!empty($dir)) {
2178         $dir->delete();
2179     }
2180     return true;
2183 /**
2184  * Prints the heads for a page
2185  *
2186  * @param stdClass $course
2187  * @param stdClass $cm
2188  * @param stdClass $data
2189  * @param string $currenttab
2190  */
2191 function data_print_header($course, $cm, $data, $currenttab='') {
2193     global $CFG, $displaynoticegood, $displaynoticebad, $OUTPUT, $PAGE;
2195     $PAGE->set_title($data->name);
2196     echo $OUTPUT->header();
2197     echo $OUTPUT->heading(format_string($data->name), 2);
2198     echo $OUTPUT->box(format_module_intro('data', $data, $cm->id), 'generalbox', 'intro');
2200     // Groups needed for Add entry tab
2201     $currentgroup = groups_get_activity_group($cm);
2202     $groupmode = groups_get_activity_groupmode($cm);
2204     // Print the tabs
2206     if ($currenttab) {
2207         include('tabs.php');
2208     }
2210     // Print any notices
2212     if (!empty($displaynoticegood)) {
2213         echo $OUTPUT->notification($displaynoticegood, 'notifysuccess');    // good (usually green)
2214     } else if (!empty($displaynoticebad)) {
2215         echo $OUTPUT->notification($displaynoticebad);                     // bad (usuually red)
2216     }
2219 /**
2220  * Can user add more entries?
2221  *
2222  * @param object $data
2223  * @param mixed $currentgroup
2224  * @param int $groupmode
2225  * @param stdClass $context
2226  * @return bool
2227  */
2228 function data_user_can_add_entry($data, $currentgroup, $groupmode, $context = null) {
2229     global $USER;
2231     if (empty($context)) {
2232         $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
2233         $context = context_module::instance($cm->id);
2234     }
2236     if (has_capability('mod/data:manageentries', $context)) {
2237         // no entry limits apply if user can manage
2239     } else if (!has_capability('mod/data:writeentry', $context)) {
2240         return false;
2242     } else if (data_atmaxentries($data)) {
2243         return false;
2244     } else if (data_in_readonly_period($data)) {
2245         // Check whether we're in a read-only period
2246         return false;
2247     }
2249     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
2250         return true;
2251     }
2253     if ($currentgroup) {
2254         return groups_is_member($currentgroup);
2255     } else {
2256         //else it might be group 0 in visible mode
2257         if ($groupmode == VISIBLEGROUPS){
2258             return true;
2259         } else {
2260             return false;
2261         }
2262     }
2265 /**
2266  * Check whether the current user is allowed to manage the given record considering manageentries capability,
2267  * data_in_readonly_period() result, ownership (determined by data_isowner()) and manageapproved setting.
2268  * @param mixed $record record object or id
2269  * @param object $data data object
2270  * @param object $context context object
2271  * @return bool returns true if the user is allowd to edit the entry, false otherwise
2272  */
2273 function data_user_can_manage_entry($record, $data, $context) {
2274     global $DB;
2276     if (has_capability('mod/data:manageentries', $context)) {
2277         return true;
2278     }
2280     // Check whether this activity is read-only at present.
2281     $readonly = data_in_readonly_period($data);
2283     if (!$readonly) {
2284         // Get record object from db if just id given like in data_isowner.
2285         // ...done before calling data_isowner() to avoid querying db twice.
2286         if (!is_object($record)) {
2287             if (!$record = $DB->get_record('data_records', array('id' => $record))) {
2288                 return false;
2289             }
2290         }
2291         if (data_isowner($record)) {
2292             if ($data->approval && $record->approved) {
2293                 return $data->manageapproved == 1;
2294             } else {
2295                 return true;
2296             }
2297         }
2298     }
2300     return false;
2303 /**
2304  * Check whether the specified database activity is currently in a read-only period
2305  *
2306  * @param object $data
2307  * @return bool returns true if the time fields in $data indicate a read-only period; false otherwise
2308  */
2309 function data_in_readonly_period($data) {
2310     $now = time();
2311     if (!$data->timeviewfrom && !$data->timeviewto) {
2312         return false;
2313     } else if (($data->timeviewfrom && $now < $data->timeviewfrom) || ($data->timeviewto && $now > $data->timeviewto)) {
2314         return false;
2315     }
2316     return true;
2319 /**
2320  * @return bool
2321  */
2322 function is_directory_a_preset($directory) {
2323     $directory = rtrim($directory, '/\\') . '/';
2324     $status = file_exists($directory.'singletemplate.html') &&
2325               file_exists($directory.'listtemplate.html') &&
2326               file_exists($directory.'listtemplateheader.html') &&
2327               file_exists($directory.'listtemplatefooter.html') &&
2328               file_exists($directory.'addtemplate.html') &&
2329               file_exists($directory.'rsstemplate.html') &&
2330               file_exists($directory.'rsstitletemplate.html') &&
2331               file_exists($directory.'csstemplate.css') &&
2332               file_exists($directory.'jstemplate.js') &&
2333               file_exists($directory.'preset.xml');
2335     return $status;
2338 /**
2339  * Abstract class used for data preset importers
2340  */
2341 abstract class data_preset_importer {
2343     protected $course;
2344     protected $cm;
2345     protected $module;
2346     protected $directory;
2348     /**
2349      * Constructor
2350      *
2351      * @param stdClass $course
2352      * @param stdClass $cm
2353      * @param stdClass $module
2354      * @param string $directory
2355      */
2356     public function __construct($course, $cm, $module, $directory) {
2357         $this->course = $course;
2358         $this->cm = $cm;
2359         $this->module = $module;
2360         $this->directory = $directory;
2361     }
2363     /**
2364      * Returns the name of the directory the preset is located in
2365      * @return string
2366      */
2367     public function get_directory() {
2368         return basename($this->directory);
2369     }
2371     /**
2372      * Retreive the contents of a file. That file may either be in a conventional directory of the Moodle file storage
2373      * @param file_storage $filestorage. should be null if using a conventional directory
2374      * @param stored_file $fileobj the directory to look in. null if using a conventional directory
2375      * @param string $dir the directory to look in. null if using the Moodle file storage
2376      * @param string $filename the name of the file we want
2377      * @return string the contents of the file or null if the file doesn't exist.
2378      */
2379     public function data_preset_get_file_contents(&$filestorage, &$fileobj, $dir, $filename) {
2380         if(empty($filestorage) || empty($fileobj)) {
2381             if (substr($dir, -1)!='/') {
2382                 $dir .= '/';
2383             }
2384             if (file_exists($dir.$filename)) {
2385                 return file_get_contents($dir.$filename);
2386             } else {
2387                 return null;
2388             }
2389         } else {
2390             if ($filestorage->file_exists(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename)) {
2391                 $file = $filestorage->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename);
2392                 return $file->get_content();
2393             } else {
2394                 return null;
2395             }
2396         }
2398     }
2399     /**
2400      * Gets the preset settings
2401      * @global moodle_database $DB
2402      * @return stdClass
2403      */
2404     public function get_preset_settings() {
2405         global $DB;
2407         $fs = $fileobj = null;
2408         if (!is_directory_a_preset($this->directory)) {
2409             //maybe the user requested a preset stored in the Moodle file storage
2411             $fs = get_file_storage();
2412             $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2414             //preset name to find will be the final element of the directory
2415             $explodeddirectory = explode('/', $this->directory);
2416             $presettofind = end($explodeddirectory);
2418             //now go through the available files available and see if we can find it
2419             foreach ($files as $file) {
2420                 if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory()) {
2421                     continue;
2422                 }
2423                 $presetname = trim($file->get_filepath(), '/');
2424                 if ($presetname==$presettofind) {
2425                     $this->directory = $presetname;
2426                     $fileobj = $file;
2427                 }
2428             }
2430             if (empty($fileobj)) {
2431                 print_error('invalidpreset', 'data', '', $this->directory);
2432             }
2433         }
2435         $allowed_settings = array(
2436             'intro',
2437             'comments',
2438             'requiredentries',
2439             'requiredentriestoview',
2440             'maxentries',
2441             'rssarticles',
2442             'approval',
2443             'defaultsortdir',
2444             'defaultsort');
2446         $result = new stdClass;
2447         $result->settings = new stdClass;
2448         $result->importfields = array();
2449         $result->currentfields = $DB->get_records('data_fields', array('dataid'=>$this->module->id));
2450         if (!$result->currentfields) {
2451             $result->currentfields = array();
2452         }
2455         /* Grab XML */
2456         $presetxml = $this->data_preset_get_file_contents($fs, $fileobj, $this->directory,'preset.xml');
2457         $parsedxml = xmlize($presetxml, 0);
2459         /* First, do settings. Put in user friendly array. */
2460         $settingsarray = $parsedxml['preset']['#']['settings'][0]['#'];
2461         $result->settings = new StdClass();
2462         foreach ($settingsarray as $setting => $value) {
2463             if (!is_array($value) || !in_array($setting, $allowed_settings)) {
2464                 // unsupported setting
2465                 continue;
2466             }
2467             $result->settings->$setting = $value[0]['#'];
2468         }
2470         /* Now work out fields to user friendly array */
2471         $fieldsarray = $parsedxml['preset']['#']['field'];
2472         foreach ($fieldsarray as $field) {
2473             if (!is_array($field)) {
2474                 continue;
2475             }
2476             $f = new StdClass();
2477             foreach ($field['#'] as $param => $value) {
2478                 if (!is_array($value)) {
2479                     continue;
2480                 }
2481                 $f->$param = $value[0]['#'];
2482             }
2483             $f->dataid = $this->module->id;
2484             $f->type = clean_param($f->type, PARAM_ALPHA);
2485             $result->importfields[] = $f;
2486         }
2487         /* Now add the HTML templates to the settings array so we can update d */
2488         $result->settings->singletemplate     = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"singletemplate.html");
2489         $result->settings->listtemplate       = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplate.html");
2490         $result->settings->listtemplateheader = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplateheader.html");
2491         $result->settings->listtemplatefooter = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplatefooter.html");
2492         $result->settings->addtemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"addtemplate.html");
2493         $result->settings->rsstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstemplate.html");
2494         $result->settings->rsstitletemplate   = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstitletemplate.html");
2495         $result->settings->csstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"csstemplate.css");
2496         $result->settings->jstemplate         = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"jstemplate.js");
2497         $result->settings->asearchtemplate    = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"asearchtemplate.html");
2499         $result->settings->instance = $this->module->id;
2500         return $result;
2501     }
2503     /**
2504      * Import the preset into the given database module
2505      * @return bool
2506      */
2507     function import($overwritesettings) {
2508         global $DB, $CFG;
2510         $params = $this->get_preset_settings();
2511         $settings = $params->settings;
2512         $newfields = $params->importfields;
2513         $currentfields = $params->currentfields;
2514         $preservedfields = array();
2516         /* Maps fields and makes new ones */
2517         if (!empty($newfields)) {
2518             /* We require an injective mapping, and need to know what to protect */
2519             foreach ($newfields as $nid => $newfield) {
2520                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2521                 if ($cid == -1) {
2522                     continue;
2523                 }
2524                 if (array_key_exists($cid, $preservedfields)){
2525                     print_error('notinjectivemap', 'data');
2526                 }
2527                 else $preservedfields[$cid] = true;
2528             }
2530             foreach ($newfields as $nid => $newfield) {
2531                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2533                 /* A mapping. Just need to change field params. Data kept. */
2534                 if ($cid != -1 and isset($currentfields[$cid])) {
2535                     $fieldobject = data_get_field_from_id($currentfields[$cid]->id, $this->module);
2536                     foreach ($newfield as $param => $value) {
2537                         if ($param != "id") {
2538                             $fieldobject->field->$param = $value;
2539                         }
2540                     }
2541                     unset($fieldobject->field->similarfield);
2542                     $fieldobject->update_field();
2543                     unset($fieldobject);
2544                 } else {
2545                     /* Make a new field */
2546                     include_once("field/$newfield->type/field.class.php");
2548                     if (!isset($newfield->description)) {
2549                         $newfield->description = '';
2550                     }
2551                     $classname = 'data_field_'.$newfield->type;
2552                     $fieldclass = new $classname($newfield, $this->module);
2553                     $fieldclass->insert_field();
2554                     unset($fieldclass);
2555                 }
2556             }
2557         }
2559         /* Get rid of all old unused data */
2560         if (!empty($preservedfields)) {
2561             foreach ($currentfields as $cid => $currentfield) {
2562                 if (!array_key_exists($cid, $preservedfields)) {
2563                     /* Data not used anymore so wipe! */
2564                     print "Deleting field $currentfield->name<br />";
2566                     $id = $currentfield->id;
2567                     //Why delete existing data records and related comments/ratings??
2568                     $DB->delete_records('data_content', array('fieldid'=>$id));
2569                     $DB->delete_records('data_fields', array('id'=>$id));
2570                 }
2571             }
2572         }
2574         // handle special settings here
2575         if (!empty($settings->defaultsort)) {
2576             if (is_numeric($settings->defaultsort)) {
2577                 // old broken value
2578                 $settings->defaultsort = 0;
2579             } else {
2580                 $settings->defaultsort = (int)$DB->get_field('data_fields', 'id', array('dataid'=>$this->module->id, 'name'=>$settings->defaultsort));
2581             }
2582         } else {
2583             $settings->defaultsort = 0;
2584         }
2586         // do we want to overwrite all current database settings?
2587         if ($overwritesettings) {
2588             // all supported settings
2589             $overwrite = array_keys((array)$settings);
2590         } else {
2591             // only templates and sorting
2592             $overwrite = array('singletemplate', 'listtemplate', 'listtemplateheader', 'listtemplatefooter',
2593                                'addtemplate', 'rsstemplate', 'rsstitletemplate', 'csstemplate', 'jstemplate',
2594                                'asearchtemplate', 'defaultsortdir', 'defaultsort');
2595         }
2597         // now overwrite current data settings
2598         foreach ($this->module as $prop=>$unused) {
2599             if (in_array($prop, $overwrite)) {
2600                 $this->module->$prop = $settings->$prop;
2601             }
2602         }
2604         data_update_instance($this->module);
2606         return $this->cleanup();
2607     }
2609     /**
2610      * Any clean up routines should go here
2611      * @return bool
2612      */
2613     public function cleanup() {
2614         return true;
2615     }
2618 /**
2619  * Data preset importer for uploaded presets
2620  */
2621 class data_preset_upload_importer extends data_preset_importer {
2622     public function __construct($course, $cm, $module, $filepath) {
2623         global $USER;
2624         if (is_file($filepath)) {
2625             $fp = get_file_packer();
2626             if ($fp->extract_to_pathname($filepath, $filepath.'_extracted')) {
2627                 fulldelete($filepath);
2628             }
2629             $filepath .= '_extracted';
2630         }
2631         parent::__construct($course, $cm, $module, $filepath);
2632     }
2633     public function cleanup() {
2634         return fulldelete($this->directory);
2635     }
2638 /**
2639  * Data preset importer for existing presets
2640  */
2641 class data_preset_existing_importer extends data_preset_importer {
2642     protected $userid;
2643     public function __construct($course, $cm, $module, $fullname) {
2644         global $USER;
2645         list($userid, $shortname) = explode('/', $fullname, 2);
2646         $context = context_module::instance($cm->id);
2647         if ($userid && ($userid != $USER->id) && !has_capability('mod/data:manageuserpresets', $context) && !has_capability('mod/data:viewalluserpresets', $context)) {
2648            throw new coding_exception('Invalid preset provided');
2649         }
2651         $this->userid = $userid;
2652         $filepath = data_preset_path($course, $userid, $shortname);
2653         parent::__construct($course, $cm, $module, $filepath);
2654     }
2655     public function get_userid() {
2656         return $this->userid;
2657     }
2660 /**
2661  * @global object
2662  * @global object
2663  * @param object $course
2664  * @param int $userid
2665  * @param string $shortname
2666  * @return string
2667  */
2668 function data_preset_path($course, $userid, $shortname) {
2669     global $USER, $CFG;
2671     $context = context_course::instance($course->id);
2673     $userid = (int)$userid;
2675     $path = null;
2676     if ($userid > 0 && ($userid == $USER->id || has_capability('mod/data:viewalluserpresets', $context))) {
2677         $path = $CFG->dataroot.'/data/preset/'.$userid.'/'.$shortname;
2678     } else if ($userid == 0) {
2679         $path = $CFG->dirroot.'/mod/data/preset/'.$shortname;
2680     } else if ($userid < 0) {
2681         $path = $CFG->tempdir.'/data/'.-$userid.'/'.$shortname;
2682     }
2684     return $path;
2687 /**
2688  * Implementation of the function for printing the form elements that control
2689  * whether the course reset functionality affects the data.
2690  *
2691  * @param $mform form passed by reference
2692  */
2693 function data_reset_course_form_definition(&$mform) {
2694     $mform->addElement('header', 'dataheader', get_string('modulenameplural', 'data'));
2695     $mform->addElement('checkbox', 'reset_data', get_string('deleteallentries','data'));
2697     $mform->addElement('checkbox', 'reset_data_notenrolled', get_string('deletenotenrolled', 'data'));
2698     $mform->disabledIf('reset_data_notenrolled', 'reset_data', 'checked');
2700     $mform->addElement('checkbox', 'reset_data_ratings', get_string('deleteallratings'));
2701     $mform->disabledIf('reset_data_ratings', 'reset_data', 'checked');
2703     $mform->addElement('checkbox', 'reset_data_comments', get_string('deleteallcomments'));
2704     $mform->disabledIf('reset_data_comments', 'reset_data', 'checked');
2707 /**
2708  * Course reset form defaults.
2709  * @return array
2710  */
2711 function data_reset_course_form_defaults($course) {
2712     return array('reset_data'=>0, 'reset_data_ratings'=>1, 'reset_data_comments'=>1, 'reset_data_notenrolled'=>0);
2715 /**
2716  * Removes all grades from gradebook
2717  *
2718  * @global object
2719  * @global object
2720  * @param int $courseid
2721  * @param string $type optional type
2722  */
2723 function data_reset_gradebook($courseid, $type='') {
2724     global $CFG, $DB;
2726     $sql = "SELECT d.*, cm.idnumber as cmidnumber, d.course as courseid
2727               FROM {data} d, {course_modules} cm, {modules} m
2728              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id AND d.course=?";
2730     if ($datas = $DB->get_records_sql($sql, array($courseid))) {
2731         foreach ($datas as $data) {
2732             data_grade_item_update($data, 'reset');
2733         }
2734     }
2737 /**
2738  * Actual implementation of the reset course functionality, delete all the
2739  * data responses for course $data->courseid.
2740  *
2741  * @global object
2742  * @global object
2743  * @param object $data the data submitted from the reset course.
2744  * @return array status array
2745  */
2746 function data_reset_userdata($data) {
2747     global $CFG, $DB;
2748     require_once($CFG->libdir.'/filelib.php');
2749     require_once($CFG->dirroot.'/rating/lib.php');
2751     $componentstr = get_string('modulenameplural', 'data');
2752     $status = array();
2754     $allrecordssql = "SELECT r.id
2755                         FROM {data_records} r
2756                              INNER JOIN {data} d ON r.dataid = d.id
2757                        WHERE d.course = ?";
2759     $alldatassql = "SELECT d.id
2760                       FROM {data} d
2761                      WHERE d.course=?";
2763     $rm = new rating_manager();
2764     $ratingdeloptions = new stdClass;
2765     $ratingdeloptions->component = 'mod_data';
2766     $ratingdeloptions->ratingarea = 'entry';
2768     // Set the file storage - may need it to remove files later.
2769     $fs = get_file_storage();
2771     // delete entries if requested
2772     if (!empty($data->reset_data)) {
2773         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2774         $DB->delete_records_select('data_content', "recordid IN ($allrecordssql)", array($data->courseid));
2775         $DB->delete_records_select('data_records', "dataid IN ($alldatassql)", array($data->courseid));
2777         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2778             foreach ($datas as $dataid=>$unused) {
2779                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2780                     continue;
2781                 }
2782                 $datacontext = context_module::instance($cm->id);
2784                 // Delete any files that may exist.
2785                 $fs->delete_area_files($datacontext->id, 'mod_data', 'content');
2787                 $ratingdeloptions->contextid = $datacontext->id;
2788                 $rm->delete_ratings($ratingdeloptions);
2789             }
2790         }
2792         if (empty($data->reset_gradebook_grades)) {
2793             // remove all grades from gradebook
2794             data_reset_gradebook($data->courseid);
2795         }
2796         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallentries', 'data'), 'error'=>false);
2797     }
2799     // remove entries by users not enrolled into course
2800     if (!empty($data->reset_data_notenrolled)) {
2801         $recordssql = "SELECT r.id, r.userid, r.dataid, u.id AS userexists, u.deleted AS userdeleted
2802                          FROM {data_records} r
2803                               JOIN {data} d ON r.dataid = d.id
2804                               LEFT JOIN {user} u ON r.userid = u.id
2805                         WHERE d.course = ? AND r.userid > 0";
2807         $course_context = context_course::instance($data->courseid);
2808         $notenrolled = array();
2809         $fields = array();
2810         $rs = $DB->get_recordset_sql($recordssql, array($data->courseid));
2811         foreach ($rs as $record) {
2812             if (array_key_exists($record->userid, $notenrolled) or !$record->userexists or $record->userdeleted
2813               or !is_enrolled($course_context, $record->userid)) {
2814                 //delete ratings
2815                 if (!$cm = get_coursemodule_from_instance('data', $record->dataid)) {
2816                     continue;
2817                 }
2818                 $datacontext = context_module::instance($cm->id);
2819                 $ratingdeloptions->contextid = $datacontext->id;
2820                 $ratingdeloptions->itemid = $record->id;
2821                 $rm->delete_ratings($ratingdeloptions);
2823                 // Delete any files that may exist.
2824                 if ($contents = $DB->get_records('data_content', array('recordid' => $record->id), '', 'id')) {
2825                     foreach ($contents as $content) {
2826                         $fs->delete_area_files($datacontext->id, 'mod_data', 'content', $content->id);
2827                     }
2828                 }
2829                 $notenrolled[$record->userid] = true;
2831                 $DB->delete_records('comments', array('itemid' => $record->id, 'commentarea' => 'database_entry'));
2832                 $DB->delete_records('data_content', array('recordid' => $record->id));
2833                 $DB->delete_records('data_records', array('id' => $record->id));
2834             }
2835         }
2836         $rs->close();
2837         $status[] = array('component'=>$componentstr, 'item'=>get_string('deletenotenrolled', 'data'), 'error'=>false);
2838     }
2840     // remove all ratings
2841     if (!empty($data->reset_data_ratings)) {
2842         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2843             foreach ($datas as $dataid=>$unused) {
2844                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2845                     continue;
2846                 }
2847                 $datacontext = context_module::instance($cm->id);
2849                 $ratingdeloptions->contextid = $datacontext->id;
2850                 $rm->delete_ratings($ratingdeloptions);
2851             }
2852         }
2854         if (empty($data->reset_gradebook_grades)) {
2855             // remove all grades from gradebook
2856             data_reset_gradebook($data->courseid);
2857         }
2859         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallratings'), 'error'=>false);
2860     }
2862     // remove all comments
2863     if (!empty($data->reset_data_comments)) {
2864         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2865         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallcomments'), 'error'=>false);
2866     }
2868     // updating dates - shift may be negative too
2869     if ($data->timeshift) {
2870         shift_course_mod_dates('data', array('timeavailablefrom', 'timeavailableto', 'timeviewfrom', 'timeviewto'), $data->timeshift, $data->courseid);
2871         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
2872     }
2874     return $status;
2877 /**
2878  * Returns all other caps used in module
2879  *
2880  * @return array
2881  */
2882 function data_get_extra_capabilities() {
2883     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');
2886 /**
2887  * @param string $feature FEATURE_xx constant for requested feature
2888  * @return mixed True if module supports feature, null if doesn't know
2889  */
2890 function data_supports($feature) {
2891     switch($feature) {
2892         case FEATURE_GROUPS:                  return true;
2893         case FEATURE_GROUPINGS:               return true;
2894         case FEATURE_MOD_INTRO:               return true;
2895         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
2896         case FEATURE_COMPLETION_HAS_RULES:    return true;
2897         case FEATURE_GRADE_HAS_GRADE:         return true;
2898         case FEATURE_GRADE_OUTCOMES:          return true;
2899         case FEATURE_RATE:                    return true;
2900         case FEATURE_BACKUP_MOODLE2:          return true;
2901         case FEATURE_SHOW_DESCRIPTION:        return true;
2902         case FEATURE_COMMENT:                 return true;
2904         default: return null;
2905     }
2907 /**
2908  * @global object
2909  * @param array $export
2910  * @param string $delimiter_name
2911  * @param object $database
2912  * @param int $count
2913  * @param bool $return
2914  * @return string|void
2915  */
2916 function data_export_csv($export, $delimiter_name, $database, $count, $return=false) {
2917     global $CFG;
2918     require_once($CFG->libdir . '/csvlib.class.php');
2920     $filename = $database . '-' . $count . '-record';
2921     if ($count > 1) {
2922         $filename .= 's';
2923     }
2924     if ($return) {
2925         return csv_export_writer::print_array($export, $delimiter_name, '"', true);
2926     } else {
2927         csv_export_writer::download_array($filename, $export, $delimiter_name);
2928     }
2931 /**
2932  * @global object
2933  * @param array $export
2934  * @param string $dataname
2935  * @param int $count
2936  * @return string
2937  */
2938 function data_export_xls($export, $dataname, $count) {
2939     global $CFG;
2940     require_once("$CFG->libdir/excellib.class.php");
2941     $filename = clean_filename("{$dataname}-{$count}_record");
2942     if ($count > 1) {
2943         $filename .= 's';
2944     }
2945     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
2946     $filename .= '.xls';
2948     $filearg = '-';
2949     $workbook = new MoodleExcelWorkbook($filearg);
2950     $workbook->send($filename);
2951     $worksheet = array();
2952     $worksheet[0] = $workbook->add_worksheet('');
2953     $rowno = 0;
2954     foreach ($export as $row) {
2955         $colno = 0;
2956         foreach($row as $col) {
2957             $worksheet[0]->write($rowno, $colno, $col);
2958             $colno++;
2959         }
2960         $rowno++;
2961     }
2962     $workbook->close();
2963     return $filename;
2966 /**
2967  * @global object
2968  * @param array $export
2969  * @param string $dataname
2970  * @param int $count
2971  * @param string
2972  */
2973 function data_export_ods($export, $dataname, $count) {
2974     global $CFG;
2975     require_once("$CFG->libdir/odslib.class.php");
2976     $filename = clean_filename("{$dataname}-{$count}_record");
2977     if ($count > 1) {
2978         $filename .= 's';
2979     }
2980     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
2981     $filename .= '.ods';
2982     $filearg = '-';
2983     $workbook = new MoodleODSWorkbook($filearg);
2984     $workbook->send($filename);
2985     $worksheet = array();
2986     $worksheet[0] = $workbook->add_worksheet('');
2987     $rowno = 0;
2988     foreach ($export as $row) {
2989         $colno = 0;
2990         foreach($row as $col) {
2991             $worksheet[0]->write($rowno, $colno, $col);
2992             $colno++;
2993         }
2994         $rowno++;
2995     }
2996     $workbook->close();
2997     return $filename;
3000 /**
3001  * @global object
3002  * @param int $dataid
3003  * @param array $fields
3004  * @param array $selectedfields
3005  * @param int $currentgroup group ID of the current group. This is used for
3006  * exporting data while maintaining group divisions.
3007  * @param object $context the context in which the operation is performed (for capability checks)
3008  * @param bool $userdetails whether to include the details of the record author
3009  * @param bool $time whether to include time created/modified
3010  * @param bool $approval whether to include approval status
3011  * @return array
3012  */
3013 function data_get_exportdata($dataid, $fields, $selectedfields, $currentgroup=0, $context=null,
3014                              $userdetails=false, $time=false, $approval=false) {
3015     global $DB;
3017     if (is_null($context)) {
3018         $context = context_system::instance();
3019     }
3020     // exporting user data needs special permission
3021     $userdetails = $userdetails && has_capability('mod/data:exportuserinfo', $context);
3023     $exportdata = array();
3025     // populate the header in first row of export
3026     foreach($fields as $key => $field) {
3027         if (!in_array($field->field->id, $selectedfields)) {
3028             // ignore values we aren't exporting
3029             unset($fields[$key]);
3030         } else {
3031             $exportdata[0][] = $field->field->name;
3032         }
3033     }
3034     if ($userdetails) {
3035         $exportdata[0][] = get_string('user');
3036         $exportdata[0][] = get_string('username');
3037         $exportdata[0][] = get_string('email');
3038     }
3039     if ($time) {
3040         $exportdata[0][] = get_string('timeadded', 'data');
3041         $exportdata[0][] = get_string('timemodified', 'data');
3042     }
3043     if ($approval) {
3044         $exportdata[0][] = get_string('approved', 'data');
3045     }
3047     $datarecords = $DB->get_records('data_records', array('dataid'=>$dataid));
3048     ksort($datarecords);
3049     $line = 1;
3050     foreach($datarecords as $record) {
3051         // get content indexed by fieldid
3052         if ($currentgroup) {
3053             $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 = ?';
3054             $where = array($record->id, $currentgroup);
3055         } else {
3056             $select = 'SELECT fieldid, content, content1, content2, content3, content4 FROM {data_content} WHERE recordid = ?';
3057             $where = array($record->id);
3058         }
3060         if( $content = $DB->get_records_sql($select, $where) ) {
3061             foreach($fields as $field) {
3062                 $contents = '';
3063                 if(isset($content[$field->field->id])) {
3064                     $contents = $field->export_text_value($content[$field->field->id]);
3065                 }
3066                 $exportdata[$line][] = $contents;
3067             }
3068             if ($userdetails) { // Add user details to the export data
3069                 $userdata = get_complete_user_data('id', $record->userid);
3070                 $exportdata[$line][] = fullname($userdata);
3071                 $exportdata[$line][] = $userdata->username;
3072                 $exportdata[$line][] = $userdata->email;
3073             }
3074             if ($time) { // Add time added / modified
3075                 $exportdata[$line][] = userdate($record->timecreated);
3076                 $exportdata[$line][] = userdate($record->timemodified);
3077             }
3078             if ($approval) { // Add approval status
3079                 $exportdata[$line][] = (int) $record->approved;
3080             }
3081         }
3082         $line++;
3083     }
3084     $line--;
3085     return $exportdata;
3088 ////////////////////////////////////////////////////////////////////////////////
3089 // File API                                                                   //
3090 ////////////////////////////////////////////////////////////////////////////////
3092 /**
3093  * Lists all browsable file areas
3094  *
3095  * @package  mod_data
3096  * @category files
3097  * @param stdClass $course course object
3098  * @param stdClass $cm course module object
3099  * @param stdClass $context context object
3100  * @return array
3101  */
3102 function data_get_file_areas($course, $cm, $context) {
3103     return array('content' => get_string('areacontent', 'mod_data'));
3106 /**
3107  * File browsing support for data module.
3108  *
3109  * @param file_browser $browser
3110  * @param array $areas
3111  * @param stdClass $course
3112  * @param cm_info $cm
3113  * @param context $context
3114  * @param string $filearea
3115  * @param int $itemid
3116  * @param string $filepath
3117  * @param string $filename
3118  * @return file_info_stored file_info_stored instance or null if not found
3119  */
3120 function data_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
3121     global $CFG, $DB, $USER;
3123     if ($context->contextlevel != CONTEXT_MODULE) {
3124         return null;
3125     }
3127     if (!isset($areas[$filearea])) {
3128         return null;
3129     }
3131     if (is_null($itemid)) {
3132         require_once($CFG->dirroot.'/mod/data/locallib.php');
3133         return new data_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
3134     }
3136     if (!$content = $DB->get_record('data_content', array('id'=>$itemid))) {
3137         return null;
3138     }
3140     if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3141         return null;
3142     }
3144     if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3145         return null;
3146     }
3148     if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3149         return null;
3150     }
3152     //check if approved
3153     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3154         return null;
3155     }
3157     // group access
3158     if ($record->groupid) {
3159         $groupmode = groups_get_activity_groupmode($cm, $course);
3160         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3161             if (!groups_is_member($record->groupid)) {
3162                 return null;
3163             }
3164         }
3165     }
3167     $fieldobj = data_get_field($field, $data, $cm);
3169     $filepath = is_null($filepath) ? '/' : $filepath;
3170     $filename = is_null($filename) ? '.' : $filename;
3171     if (!$fieldobj->file_ok($filepath.$filename)) {
3172         return null;
3173     }
3175     $fs = get_file_storage();
3176     if (!($storedfile = $fs->get_file($context->id, 'mod_data', $filearea, $itemid, $filepath, $filename))) {
3177         return null;
3178     }
3180     // Checks to see if the user can manage files or is the owner.
3181     // TODO MDL-33805 - Do not use userid here and move the capability check above.
3182     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
3183         return null;
3184     }
3186     $urlbase = $CFG->wwwroot.'/pluginfile.php';
3188     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
3191 /**
3192  * Serves the data attachments. Implements needed access control ;-)
3193  *
3194  * @package  mod_data
3195  * @category files
3196  * @param stdClass $course course object
3197  * @param stdClass $cm course module object
3198  * @param stdClass $context context object
3199  * @param string $filearea file area
3200  * @param array $args extra arguments
3201  * @param bool $forcedownload whether or not force download
3202  * @param array $options additional options affecting the file serving
3203  * @return bool false if file not found, does not return if found - justsend the file
3204  */
3205 function data_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
3206     global $CFG, $DB;
3208     if ($context->contextlevel != CONTEXT_MODULE) {
3209         return false;
3210     }
3212     require_course_login($course, true, $cm);
3214     if ($filearea === 'content') {
3215         $contentid = (int)array_shift($args);
3217         if (!$content = $DB->get_record('data_content', array('id'=>$contentid))) {
3218             return false;
3219         }
3221         if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3222             return false;
3223         }
3225         if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3226             return false;
3227         }
3229         if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3230             return false;
3231         }
3233         if ($data->id != $cm->instance) {
3234             // hacker attempt - context does not match the contentid
3235             return false;
3236         }
3238         //check if approved
3239         if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3240             return false;
3241         }
3243         // group access
3244         if ($record->groupid) {
3245             $groupmode = groups_get_activity_groupmode($cm, $course);
3246             if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3247                 if (!groups_is_member($record->groupid)) {
3248                     return false;
3249                 }
3250             }
3251         }
3253         $fieldobj = data_get_field($field, $data, $cm);
3255         $relativepath = implode('/', $args);
3256         $fullpath = "/$context->id/mod_data/content/$content->id/$relativepath";
3258         if (!$fieldobj->file_ok($relativepath)) {
3259             return false;
3260         }
3262         $fs = get_file_storage();
3263         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
3264             return false;
3265         }
3267         // finally send the file
3268         send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
3269     }
3271     return false;
3275 function data_extend_navigation($navigation, $course, $module, $cm) {
3276     global $CFG, $OUTPUT, $USER, $DB;
3277     require_once($CFG->dirroot . '/mod/data/locallib.php');
3279     $rid = optional_param('rid', 0, PARAM_INT);
3281     $data = $DB->get_record('data', array('id'=>$cm->instance));
3282     $currentgroup = groups_get_activity_group($cm);
3283     $groupmode = groups_get_activity_groupmode($cm);
3285      $numentries = data_numentries($data);
3286     $canmanageentries = has_capability('mod/data:manageentries', context_module::instance($cm->id));
3288     if ($data->entriesleft = data_get_entries_left_to_add($data, $numentries, $canmanageentries)) {
3289         $entriesnode = $navigation->add(get_string('entrieslefttoadd', 'data', $data));
3290         $entriesnode->add_class('note');
3291     }
3293     $navigation->add(get_string('list', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance)));
3294     if (!empty($rid)) {
3295         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'rid'=>$rid)));
3296     } else {
3297         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'single')));
3298     }
3299     $navigation->add(get_string('search', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'asearch')));
3302 /**
3303  * Adds module specific settings to the settings block
3304  *
3305  * @param settings_navigation $settings The settings navigation object
3306  * @param navigation_node $datanode The node to add module settings to
3307  */
3308 function data_extend_settings_navigation(settings_navigation $settings, navigation_node $datanode) {
3309     global $PAGE, $DB, $CFG, $USER;
3311     $data = $DB->get_record('data', array("id" => $PAGE->cm->instance));
3313     $currentgroup = groups_get_activity_group($PAGE->cm);
3314     $groupmode = groups_get_activity_groupmode($PAGE->cm);
3316     if (data_user_can_add_entry($data, $currentgroup, $groupmode, $PAGE->cm->context)) { // took out participation list here!
3317         if (empty($editentry)) { //TODO: undefined
3318             $addstring = get_string('add', 'data');
3319         } else {
3320             $addstring = get_string('editentry', 'data');
3321         }
3322         $datanode->add($addstring, new moodle_url('/mod/data/edit.php', array('d'=>$PAGE->cm->instance)));
3323     }
3325     if (has_capability(DATA_CAP_EXPORT, $PAGE->cm->context)) {
3326         // The capability required to Export database records is centrally defined in 'lib.php'
3327         // and should be weaker than those required to edit Templates, Fields and Presets.
3328         $datanode->add(get_string('exportentries', 'data'), new moodle_url('/mod/data/export.php', array('d'=>$data->id)));
3329     }
3330     if (has_capability('mod/data:manageentries', $PAGE->cm->context)) {
3331         $datanode->add(get_string('importentries', 'data'), new moodle_url('/mod/data/import.php', array('d'=>$data->id)));
3332     }
3334     if (has_capability('mod/data:managetemplates', $PAGE->cm->context)) {
3335         $currenttab = '';
3336         if ($currenttab == 'list') {
3337             $defaultemplate = 'listtemplate';
3338         } else if ($currenttab == 'add') {
3339             $defaultemplate = 'addtemplate';
3340         } else if ($currenttab == 'asearch') {
3341             $defaultemplate = 'asearchtemplate';
3342         } else {
3343             $defaultemplate = 'singletemplate';
3344         }
3346         $templates = $datanode->add(get_string('templates', 'data'));
3348         $templatelist = array ('listtemplate', 'singletemplate', 'asearchtemplate', 'addtemplate', 'rsstemplate', 'csstemplate', 'jstemplate');
3349         foreach ($templatelist as $template) {
3350             $templates->add(get_string($template, 'data'), new moodle_url('/mod/data/templates.php', array('d'=>$data->id,'mode'=>$template)));
3351         }
3353         $datanode->add(get_string('fields', 'data'), new moodle_url('/mod/data/field.php', array('d'=>$data->id)));
3354         $datanode->add(get_string('presets', 'data'), new moodle_url('/mod/data/preset.php', array('d'=>$data->id)));
3355     }
3357     if (!empty($CFG->enablerssfeeds) && !empty($CFG->data_enablerssfeeds) && $data->rssarticles > 0) {
3358         require_once("$CFG->libdir/rsslib.php");
3360         $string = get_string('rsstype','forum');
3362         $url = new moodle_url(rss_get_url($PAGE->cm->context->id, $USER->id, 'mod_data', $data->id));
3363         $datanode->add($string, $url, settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
3364     }
3367 /**
3368  * Save the database configuration as a preset.
3369  *
3370  * @param stdClass $course The course the database module belongs to.
3371  * @param stdClass $cm The course module record
3372  * @param stdClass $data The database record
3373  * @param string $path
3374  * @return bool
3375  */
3376 function data_presets_save($course, $cm, $data, $path) {
3377     global $USER;
3378     $fs = get_file_storage();
3379     $filerecord = new stdClass;
3380     $filerecord->contextid = DATA_PRESET_CONTEXT;
3381     $filerecord->component = DATA_PRESET_COMPONENT;
3382     $filerecord->filearea = DATA_PRESET_FILEAREA;
3383     $filerecord->itemid = 0;
3384     $filerecord->filepath = '/'.$path.'/';
3385     $filerecord->userid = $USER->id;
3387     $filerecord->filename = 'preset.xml';
3388     $fs->create_file_from_string($filerecord, data_presets_generate_xml($course, $cm, $data));
3390     $filerecord->filename = 'singletemplate.html';
3391     $fs->create_file_from_string($filerecord, $data->singletemplate);
3393     $filerecord->filename = 'listtemplateheader.html';
3394     $fs->create_file_from_string($filerecord, $data->listtemplateheader);
3396     $filerecord->filename = 'listtemplate.html';
3397     $fs->create_file_from_string($filerecord, $data->listtemplate);
3399     $filerecord->filename = 'listtemplatefooter.html';
3400     $fs->create_file_from_string($filerecord, $data->listtemplatefooter);
3402     $filerecord->filename = 'addtemplate.html';
3403     $fs->create_file_from_string($filerecord, $data->addtemplate);
3405     $filerecord->filename = 'rsstemplate.html';
3406     $fs->create_file_from_string($filerecord, $data->rsstemplate);
3408     $filerecord->filename = 'rsstitletemplate.html';
3409     $fs->create_file_from_string($filerecord, $data->rsstitletemplate);
3411     $filerecord->filename = 'csstemplate.css';
3412     $fs->create_file_from_string($filerecord, $data->csstemplate);
3414     $filerecord->filename = 'jstemplate.js';
3415     $fs->create_file_from_string($filerecord, $data->jstemplate);
3417     $filerecord->filename = 'asearchtemplate.html';
3418     $fs->create_file_from_string($filerecord, $data->asearchtemplate);
3420     return true;
3423 /**
3424  * Generates the XML for the database module provided
3425  *
3426  * @global moodle_database $DB
3427  * @param stdClass $course The course the database module belongs to.
3428  * @param stdClass $cm The course module record
3429  * @param stdClass $data The database record
3430  * @return string The XML for the preset
3431  */
3432 function data_presets_generate_xml($course, $cm, $data) {
3433     global $DB;
3435     // Assemble "preset.xml":
3436     $presetxmldata = "<preset>\n\n";
3438     // Raw settings are not preprocessed during saving of presets
3439     $raw_settings = array(
3440         'intro',
3441         'comments',
3442         'requiredentries',
3443         'requiredentriestoview',
3444         'maxentries',
3445         'rssarticles',
3446         'approval',
3447         'manageapproved',
3448         'defaultsortdir'
3449     );
3451     $presetxmldata .= "<settings>\n";
3452     // First, settings that do not require any conversion
3453     foreach ($raw_settings as $setting) {
3454         $presetxmldata .= "<$setting>" . htmlspecialchars($data->$setting) . "</$setting>\n";
3455     }
3457     // Now specific settings
3458     if ($data->defaultsort > 0 && $sortfield = data_get_field_from_id($data->defaultsort, $data)) {
3459         $presetxmldata .= '<defaultsort>' . htmlspecialchars($sortfield->field->name) . "</defaultsort>\n";
3460     } else {
3461         $presetxmldata .= "<defaultsort>0</defaultsort>\n";
3462     }
3463     $presetxmldata .= "</settings>\n\n";
3464     // Now for the fields. Grab all that are non-empty
3465     $fields = $DB->get_records('data_fields', array('dataid'=>$data->id));
3466     ksort($fields);
3467     if (!empty($fields)) {
3468         foreach ($fields as $field) {
3469             $presetxmldata .= "<field>\n";
3470             foreach ($field as $key => $value) {
3471                 if ($value != '' && $key != 'id' && $key != 'dataid') {
3472                     $presetxmldata .= "<$key>" . htmlspecialchars($value) . "</$key>\n";
3473                 }
3474             }
3475             $presetxmldata .= "</field>\n\n";
3476         }
3477     }
3478     $presetxmldata .= '</preset>';
3479     return $presetxmldata;
3482 function data_presets_export($course, $cm, $data, $tostorage=false) {
3483     global $CFG, $DB;
3485     $presetname = clean_filename($data->name) . '-preset-' . gmdate("Ymd_Hi");
3486     $exportsubdir = "mod_data/presetexport/$presetname";
3487     make_temp_directory($exportsubdir);
3488     $exportdir = "$CFG->tempdir/$exportsubdir";
3490     // Assemble "preset.xml":
3491     $presetxmldata = data_presets_generate_xml($course, $cm, $data);
3493     // After opening a file in write mode, close it asap
3494     $presetxmlfile = fopen($exportdir . '/preset.xml', 'w');
3495     fwrite($presetxmlfile, $presetxmldata);
3496     fclose($presetxmlfile);
3498     // Now write the template files
3499     $singletemplate = fopen($exportdir . '/singletemplate.html', 'w');
3500     fwrite($singletemplate, $data->singletemplate);
3501     fclose($singletemplate);
3503     $listtemplateheader = fopen($exportdir . '/listtemplateheader.html', 'w');
3504     fwrite($listtemplateheader, $data->listtemplateheader);
3505     fclose($listtemplateheader);
3507     $listtemplate = fopen($exportdir . '/listtemplate.html', 'w');
3508     fwrite($listtemplate, $data->listtemplate);
3509     fclose($listtemplate);
3511     $listtemplatefooter = fopen($exportdir . '/listtemplatefooter.html', 'w');
3512     fwrite($listtemplatefooter, $data->listtemplatefooter);
3513     fclose($listtemplatefooter);
3515     $addtemplate = fopen($exportdir . '/addtemplate.html', 'w');
3516     fwrite($addtemplate, $data->addtemplate);
3517     fclose($addtemplate);
3519     $rsstemplate = fopen($exportdir . '/rsstemplate.html', 'w');
3520     fwrite($rsstemplate, $data->rsstemplate);
3521     fclose($rsstemplate);
3523     $rsstitletemplate = fopen($exportdir . '/rsstitletemplate.html', 'w');
3524     fwrite($rsstitletemplate, $data->rsstitletemplate);
3525     fclose($rsstitletemplate);
3527     $csstemplate = fopen($exportdir . '/csstemplate.css', 'w');
3528     fwrite($csstemplate, $data->csstemplate);
3529     fclose($csstemplate);
3531     $jstemplate = fopen($exportdir . '/jstemplate.js', 'w');
3532     fwrite($jstemplate, $data->jstemplate);
3533     fclose($jstemplate);
3535     $asearchtemplate = fopen($exportdir . '/asearchtemplate.html', 'w');
3536     fwrite($asearchtemplate, $data->asearchtemplate);
3537     fclose($asearchtemplate);
3539     // Check if all files have been generated
3540     if (! is_directory_a_preset($exportdir)) {
3541         print_error('generateerror', 'data');
3542     }
3544     $filenames = array(
3545         'preset.xml',
3546         'singletemplate.html',
3547         'listtemplateheader.html',
3548         'listtemplate.html',
3549         'listtemplatefooter.html',
3550         'addtemplate.html',
3551         'rsstemplate.html',
3552         'rsstitletemplate.html',
3553         'csstemplate.css',
3554         'jstemplate.js',
3555         'asearchtemplate.html'
3556     );
3558     $filelist = array();
3559     foreach ($filenames as $filename) {
3560         $filelist[$filename] = $exportdir . '/' . $filename;
3561     }
3563     $exportfile = $exportdir.'.zip';
3564     file_exists($exportfile) && unlink($exportfile);
3566     $fp = get_file_packer('application/zip');
3567     $fp->archive_to_pathname($filelist, $exportfile);
3569     foreach ($filelist as $file) {
3570         unlink($file);
3571     }
3572     rmdir($exportdir);
3574     // Return the full path to the exported preset file:
3575     return $exportfile;
3578 /**
3579  * Running addtional permission check on plugin, for example, plugins
3580  * may have switch to turn on/off comments option, this callback will
3581  * affect UI display, not like pluginname_comment_validate only throw
3582  * exceptions.
3583  * Capability check has been done in comment->check_permissions(), we
3584  * don't need to do it again here.
3585  *
3586  * @package  mod_data
3587  * @category comment
3588  *
3589  * @param stdClass $comment_param {
3590  *              context  => context the context object
3591  *              courseid => int course id
3592  *              cm       => stdClass course module object
3593  *              commentarea => string comment area
3594  *              itemid      => int itemid
3595  * }
3596  * @return array
3597  */
3598 function data_comment_permissions($comment_param) {
3599     global $CFG, $DB;
3600     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3601         throw new comment_exception('invalidcommentitemid');
3602     }
3603     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3604         throw new comment_exception('invalidid', 'data');
3605     }
3606     if ($data->comments) {
3607         return array('post'=>true, 'view'=>true);
3608     } else {
3609         return array('post'=>false, 'view'=>false);
3610     }
3613 /**
3614  * Validate comment parameter before perform other comments actions
3615  *
3616  * @package  mod_data
3617  * @category comment
3618  *
3619  * @param stdClass $comment_param {
3620  *              context  => context the context object
3621  *              courseid => int course id
3622  *              cm       => stdClass course module object
3623  *              commentarea => string comment area
3624  *              itemid      => int itemid
3625  * }
3626  * @return boolean
3627  */
3628 function data_comment_validate($comment_param) {
3629     global $DB;
3630     // validate comment area
3631     if ($comment_param->commentarea != 'database_entry') {
3632         throw new comment_exception('invalidcommentarea');
3633     }
3634     // validate itemid
3635     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3636         throw new comment_exception('invalidcommentitemid');
3637     }
3638     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3639         throw new comment_exception('invalidid', 'data');
3640     }
3641     if (!$course = $DB->get_record('course', array('id'=>$data->course))) {
3642         throw new comment_exception('coursemisconf');
3643     }
3644     if (!$cm = get_coursemodule_from_instance('data', $data->id, $course->id)) {
3645         throw new comment_exception('invalidcoursemodule');
3646     }
3647     if (!$data->comments) {
3648         throw new comment_exception('commentsoff', 'data');
3649     }
3650     $context = context_module::instance($cm->id);
3652     //check if approved
3653     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3654         throw new comment_exception('notapproved', 'data');
3655     }
3657     // group access
3658     if ($record->groupid) {
3659         $groupmode = groups_get_activity_groupmode($cm, $course);
3660         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3661             if (!groups_is_member($record->groupid)) {
3662                 throw new comment_exception('notmemberofgroup');
3663             }
3664         }
3665     }
3666     // validate context id
3667     if ($context->id != $comment_param->context->id) {
3668         throw new comment_exception('invalidcontext');
3669     }
3670     // validation for comment deletion
3671     if (!empty($comment_param->commentid)) {
3672         if ($comment = $DB->get_record('comments', array('id'=>$comment_param->commentid))) {
3673             if ($comment->commentarea != 'database_entry') {
3674                 throw new comment_exception('invalidcommentarea');
3675             }
3676             if ($comment->contextid != $comment_param->context->id) {
3677                 throw new comment_exception('invalidcontext');
3678             }
3679             if ($comment->itemid != $comment_param->itemid) {
3680                 throw new comment_exception('invalidcommentitemid');
3681             }
3682         } else {
3683             throw new comment_exception('invalidcommentid');
3684         }
3685     }
3686     return true;
3689 /**
3690  * Return a list of page types
3691  * @param string $pagetype current page type
3692  * @param stdClass $parentcontext Block's parent context
3693  * @param stdClass $currentcontext Current context of block
3694  */
3695 function data_page_type_list($pagetype, $parentcontext, $currentcontext) {
3696     $module_pagetype = array('mod-data-*'=>get_string('page-mod-data-x', 'data'));
3697     return $module_pagetype;
3700 /**
3701  * Get all of the record ids from a database activity.
3702  *
3703  * @param int    $dataid      The dataid of the database module.
3704  * @param object $selectdata  Contains an additional sql statement for the
3705  *                            where clause for group and approval fields.
3706  * @param array  $params      Parameters that coincide with the sql statement.
3707  * @return array $idarray     An array of record ids
3708  */
3709 function data_get_all_recordids($dataid, $selectdata = '', $params = null) {
3710     global $DB;
3711     $initsql = 'SELECT r.id
3712                   FROM {data_records} r
3713                  WHERE r.dataid = :dataid';
3714     if ($selectdata != '') {
3715         $initsql .= $selectdata;
3716         $params = array_merge(array('dataid' => $dataid), $params);
3717     } else {
3718         $params = array('dataid' => $dataid);
3719     }
3720     $initsql .= ' GROUP BY r.id';
3721     $initrecord = $DB->get_recordset_sql($initsql, $params);
3722     $idarray = array();
3723     foreach ($initrecord as $data) {
3724         $idarray[] = $data->id;
3725     }
3726     // Close the record set and free up resources.
3727     $initrecord->close();
3728     return $idarray;
3731 /**
3732  * Get the ids of all the records that match that advanced search criteria
3733  * This goes and loops through each criterion one at a time until it either
3734  * runs out of records or returns a subset of records.
3735  *
3736  * @param array $recordids    An array of record ids.
3737  * @param array $searcharray  Contains information for the advanced search criteria
3738  * @param int $dataid         The data id of the database.
3739  * @return array $recordids   An array of record ids.
3740  */
3741 function data_get_advance_search_ids($recordids, $searcharray, $dataid) {
3742     // Check to see if we have any record IDs.
3743     if (empty($recordids)) {
3744         // Send back an empty search.
3745         return array();
3746     }
3747     $searchcriteria = array_keys($searcharray);
3748     // Loop through and reduce the IDs one search criteria at a time.
3749     foreach ($searchcriteria as $key) {
3750         $recordids = data_get_recordids($key, $searcharray, $dataid, $recordids);
3751         // If we don't have anymore IDs then stop.
3752         if (!$recordids) {
3753             break;
3754         }
3755     }
3756     return $recordids;
3759 /**
3760  * Gets the record IDs given the search criteria
3761  *
3762  * @param string $alias       Record alias.
3763  * @param array $searcharray  Criteria for the search.
3764  * @param int $dataid         Data ID for the database
3765  * @param array $recordids    An array of record IDs.
3766  * @return array $nestarray   An arry of record IDs
3767  */
3768 function data_get_recordids($alias, $searcharray, $dataid, $recordids) {
3769     global $DB;
3770     $searchcriteria = $alias;   // Keep the criteria.
3771     $nestsearch = $searcharray[$alias];
3772     // searching for content outside of mdl_data_content
3773     if ($alias < 0) {
3774         $alias = '';
3775     }
3776     list($insql, $params) = $DB->get_in_or_equal($recordids, SQL_PARAMS_NAMED);
3777     $nestselect = 'SELECT c' . $alias . '.recordid
3778                      FROM {data_content} c' . $alias . ',
3779                           {data_fields} f,
3780                           {data_records} r,
3781                           {user} u ';
3782     $nestwhere = 'WHERE u.id = r.userid
3783                     AND f.id = c' . $alias . '.fieldid
3784                     AND r.id = c' . $alias . '.recordid
3785                     AND r.dataid = :dataid
3786                     AND c' . $alias .'.recordid ' . $insql . '
3787                     AND ';
3789     $params['dataid'] = $dataid;
3790     if (count($nestsearch->params) != 0) {
3791         $params = array_merge($params, $nestsearch->params);
3792         $nestsql = $nestselect . $nestwhere . $nestsearch->sql;
3793     } else if ($searchcriteria == DATA_TIMEMODIFIED) {
3794         $nestsql = $nestselect . $nestwhere . $nestsearch->field . ' >= :timemodified GROUP BY c' . $alias . '.recordid';
3795         $params['timemodified'] = $nestsearch->data;
3796     } else {    // First name or last name.
3797         $thing = $DB->sql_like($nestsearch->field, ':search1', false);
3798         $nestsql = $nestselect . $nestwhere . $thing . ' GROUP BY c' . $alias . '.recordid';
3799         $params['search1'] = "%$nestsearch->data%";
3800     }
3801     $nestrecords = $DB->get_recordset_sql($nestsql, $params);
3802     $nestarray = array();
3803     foreach ($nestrecords as $data) {
3804         $nestarray[] = $data->recordid;
3805     }
3806     // Close the record set and free up resources.
3807     $nestrecords->close();
3808     return $nestarray;
3811 /**
3812  * Returns an array with an sql string for advanced searches and the parameters that go with them.
3813  *
3814  * @param int $sort            DATA_*
3815  * @param stdClass $data       Data module object
3816  * @param array $recordids     An array of record IDs.
3817  * @param string $selectdata   Information for the where and select part of the sql statement.
3818  * @param string $sortorder    Additional sort parameters
3819  * @return array sqlselect     sqlselect['sql'] has the sql string, sqlselect['params'] contains an array of parameters.
3820  */
3821 function data_get_advanced_search_sql($sort, $data, $recordids, $selectdata, $sortorder) {
3822     global $DB;
3824     $namefields = user_picture::fields('u');
3825     // Remove the id from the string. This already exists in the sql statement.
3826     $namefields = str_replace('u.id,', '', $namefields);
3828     if ($sort == 0) {
3829         $nestselectsql = 'SELECT r.id, r.approved, r.timecreated, r.timemodified, r.userid, ' . $namefields . '
3830                         FROM {data_content} c,
3831                              {data_records} r,
3832                              {user} u ';
3833         $groupsql = ' GROUP BY r.id, r.approved, r.timecreated, r.timemodified, r.userid, u.firstname, u.lastname, ' . $namefields;
3834     } else {
3835         // Sorting through 'Other' criteria
3836         if ($sort <= 0) {
3837             switch ($sort) {
3838                 case DATA_LASTNAME:
3839                     $sortcontentfull = "u.lastname";
3840                     break;
3841                 case DATA_FIRSTNAME:
3842                     $sortcontentfull = "u.firstname";
3843                     break;
3844                 case DATA_APPROVED:
3845                     $sortcontentfull = "r.approved";
3846                     break;
3847                 case DATA_TIMEMODIFIED:
3848                     $sortcontentfull = "r.timemodified";
3849                     break;
3850                 case DATA_TIMEADDED:
3851                 default:
3852                     $sortcontentfull = "r.timecreated";
3853             }
3854         } else {
3855             $sortfield = data_get_field_from_id($sort, $data);
3856             $sortcontent = $DB->sql_compare_text('c.' . $sortfield->get_sort_field());
3857             $sortcontentfull = $sortfield->get_sort_sql($sortcontent);
3858         }
3860         $nestselectsql = 'SELECT r.id, r.approved, r.timecreated, r.timemodified, r.userid, ' . $namefields . ',
3861                                  ' . $sortcontentfull . '
3862                               AS sortorder
3863                             FROM {data_content} c,
3864                                  {data_records} r,
3865                                  {user} u ';
3866         $groupsql = ' GROUP BY r.id, r.approved, r.timecreated, r.timemodified, r.userid, ' . $namefields . ', ' .$sortcontentfull;
3867     }
3869     // Default to a standard Where statement if $selectdata is empty.
3870     if ($selectdata == '') {
3871         $selectdata = 'WHERE c.recordid = r.id
3872                          AND r.dataid = :dataid
3873                          AND r.userid = u.id ';
3874     }
3876     // Find the field we are sorting on
3877     if ($sort > 0 or data_get_field_from_id($sort, $data)) {
3878         $selectdata .= ' AND c.fieldid = :sort';
3879     }
3881     // If there are no record IDs then return an sql statment that will return no rows.
3882     if (count($recordids) != 0) {
3883         list($insql, $inparam) = $DB->get_in_or_equal($recordids, SQL_PARAMS_NAMED);
3884     } else {
3885         list($insql, $inparam) = $DB->get_in_or_equal(array('-1'), SQL_PARAMS_NAMED);
3886     }
3887     $nestfromsql = $selectdata . ' AND c.recordid ' . $insql . $groupsql;
3888     $sqlselect['sql'] = "$nestselectsql $nestfromsql $sortorder";
3889     $sqlselect['params'] = $inparam;
3890     return $sqlselect;
3893 /**
3894  * Checks to see if the user has permission to delete the preset.
3895  * @param stdClass $context  Context object.
3896  * @param stdClass $preset  The preset object that we are checking for deletion.
3897  * @return bool  Returns true if the user can delete, otherwise false.
3898  */
3899 function data_user_can_delete_preset($context, $preset) {
3900     global $USER;
3902     if (has_capability('mod/data:manageuserpresets', $context)) {
3903         return true;
3904     } else {
3905         $candelete = false;
3906         if ($preset->userid == $USER->id) {
3907             $candelete = true;
3908         }
3909         return $candelete;
3910     }
3913 /**
3914  * Delete a record entry.
3915  *
3916  * @param int $recordid The ID for the record to be deleted.
3917  * @param object $data The data object for this activity.
3918  * @param int $courseid ID for the current course (for logging).
3919  * @param int $cmid The course module ID.
3920  * @return bool True if the record deleted, false if not.
3921  */
3922 function data_delete_record($recordid, $data, $courseid, $cmid) {
3923     global $DB, $CFG;
3925     if ($deleterecord = $DB->get_record('data_records', array('id' => $recordid))) {
3926         if ($deleterecord->dataid == $data->id) {
3927             if ($contents = $DB->get_records('data_content', array('recordid' => $deleterecord->id))) {
3928                 foreach ($contents as $content) {
3929                     if ($field = data_get_field_from_id($content->fieldid, $data)) {
3930                         $field->delete_content($content->recordid);
3931                     }
3932                 }
3933                 $DB->delete_records('data_content', array('recordid'=>$deleterecord->id));
3934                 $DB->delete_records('data_records', array('id'=>$deleterecord->id));
3936                 // Delete cached RSS feeds.
3937                 if (!empty($CFG->enablerssfeeds)) {
3938                     require_once($CFG->dirroot.'/mod/data/rsslib.php');
3939                     data_rss_delete_file($data);
3940                 }
3942                 // Trigger an event for deleting this record.
3943                 $event = \mod_data\event\record_deleted::create(array(
3944                     'objectid' => $deleterecord->id,
3945                     'context' => context_module::instance($cmid),
3946                     'courseid' => $courseid,
3947                     'other' => array(
3948                         'dataid' => $deleterecord->dataid
3949                     )
3950                 ));
3951                 $event->add_record_snapshot('data_records', $deleterecord);
3952                 $event->trigger();
3953                 $course = get_course($courseid);
3954                 $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
3955                 data_update_completion_state($data, $course, $cm);
3957                 return true;
3958             }
3959         }
3960     }
3962     return false;
3965 /**
3966  * Check for required fields, and build a list of fields to be updated in a
3967  * submission.
3968  *
3969  * @param $mod stdClass The current recordid - provided as an optimisation.
3970  * @param $fields array The field data
3971  * @param $datarecord stdClass The submitted data.
3972  * @return stdClass containing:
3973  * * string[] generalnotifications Notifications for the form as a whole.
3974  * * string[] fieldnotifications Notifications for a specific field.
3975  * * bool validated Whether the field was validated successfully.
3976  * * data_field_base[] fields The field objects to be update.
3977  */
3978 function data_process_submission(stdClass $mod, $fields, stdClass $datarecord) {
3979     $result = new stdClass();
3981     // Empty form checking - you can't submit an empty form.
3982     $emptyform = true;
3983     $requiredfieldsfilled = true;
3984     $fieldsvalidated = true;
3986     // Store the notifications.
3987     $result->generalnotifications = array();
3988     $result->fieldnotifications = array();
3990     // Store the instantiated classes as an optimisation when processing the result.
3991     // This prevents the fields being re-initialised when updating.
3992     $result->fields = array();
3994     $submitteddata = array();
3995     foreach ($datarecord as $fieldname => $fieldvalue) {
3996         if (strpos($fieldname, '_')) {
3997             $namearray = explode('_', $fieldname, 3);
3998             $fieldid = $namearray[1];
3999             if (!isset($submitteddata[$fieldid])) {
4000                 $submitteddata[$fieldid] = array();
4001             }
4002             if (count($namearray) === 2) {
4003                 $subfieldid = 0;
4004             } else {
4005                 $subfieldid = $namearray[2];
4006             }
4008             $fielddata = new stdClass();
4009             $fielddata->fieldname = $fieldname;
4010             $fielddata->value = $fieldvalue;
4011             $submitteddata[$fieldid][$subfieldid] = $fielddata;
4012         }
4013     }
4015     // Check all form fields which have the required are filled.
4016     foreach ($fields as $fieldrecord) {
4017         // Check whether the field has any data.
4018         $fieldhascontent = false;
4020         $field = data_get_field($fieldrecord, $mod);
4021         if (isset($submitteddata[$fieldrecord->id])) {
4022             // Field validation check.
4023             if (method_exists($field, 'field_validation')) {
4024                 $errormessage = $field->field_validation($submitteddata[$fieldrecord->id]);
4025                 if ($errormessage) {
4026                     $result->fieldnotifications[$field->field->name][] = $errormessage;
4027                     $fieldsvalidated = false;
4028                 }
4029             }
4030             foreach ($submitteddata[$fieldrecord->id] as $fieldname => $value) {
4031                 if ($field->notemptyfield($value->value, $value->fieldname)) {
4032                     // The field has content and the form is not empty.
4033                     $fieldhascontent = true;
4034                     $emptyform = false;
4035                 }
4036             }
4037         }
4039         // If the field is required, add a notification to that effect.
4040         if ($field->field->required && !$fieldhascontent) {
4041             if (!isset($result->fieldnotifications[$field->field->name])) {
4042                 $result->fieldnotifications[$field->field->name] = array();
4043             }
4044             $result->fieldnotifications[$field->field->name][] = get_string('errormustsupplyvalue', 'data');
4045             $requiredfieldsfilled = false;
4046         }
4048         // Update the field.
4049         if (isset($submitteddata[$fieldrecord->id])) {
4050             foreach ($submitteddata[$fieldrecord->id] as $value) {
4051                 $result->fields[$value->fieldname] = $field;
4052             }
4053         }
4054     }
4056     if ($emptyform) {
4057         // The form is empty.
4058         $result->generalnotifications[] = get_string('emptyaddform', 'data');
4059     }
4061     $result->validated = $requiredfieldsfilled && !$emptyform && $fieldsvalidated;
4063     return $result;
4066 /**
4067  * This standard function will check all instances of this module
4068  * and make sure there are up-to-date events created for each of them.
4069  * If courseid = 0, then every data event in the site is checked, else
4070  * only data events belonging to the course specified are checked.
4071  * This function is used, in its new format, by restore_refresh_events()
4072  *
4073  * @param int $courseid
4074  * @return bool
4075  */
4076 function data_refresh_events($courseid = 0) {
4077     global $DB, $CFG;
4078     require_once($CFG->dirroot.'/mod/data/locallib.php');
4080     if ($courseid) {
4081         if (! $data = $DB->get_records("data", array("course" => $courseid))) {
4082             return true;
4083         }
4084     } else {
4085         if (! $data = $DB->get_records("data")) {
4086             return true;
4087         }
4088     }
4090     foreach ($data as $datum) {
4091         data_set_events($datum);
4092     }
4093     return true;
4096 /**
4097  * Fetch the configuration for this database activity.
4098  *
4099  * @param   stdClass    $database   The object returned from the database for this instance
4100  * @param   string      $key        The name of the key to retrieve. If none is supplied, then all configuration is returned
4101  * @param   mixed       $default    The default value to use if no value was found for the specified key
4102  * @return  mixed                   The returned value
4103  */
4104 function data_get_config($database, $key = null, $default = null) {
4105     if (!empty($database->config)) {
4106         $config = json_decode($database->config);
4107     } else {
4108         $config = new stdClass();
4109     }
4111     if ($key === null) {
4112         return $config;
4113     }
4115     if (property_exists($config, $key)) {
4116         return $config->$key;
4117     }
4118     return $default;
4121 /**
4122  * Update the configuration for this database activity.
4123  *
4124  * @param   stdClass    $database   The object returned from the database for this instance
4125  * @param   string      $key        The name of the key to set
4126  * @param   mixed       $value      The value to set for the key
4127  */
4128 function data_set_config(&$database, $key, $value) {
4129     // Note: We must pass $database by reference because there may be subsequent calls to update_record and these should
4130     // not overwrite the configuration just set.
4131     global $DB;
4133     $config = data_get_config($database);
4135     if (!isset($config->$key) || $config->$key !== $value) {
4136         $config->$key = $value;
4137         $database->config = json_encode($config);
4138         $DB->set_field('data', 'config', $database->config, ['id' => $database->id]);
4139     }
4141 /**
4142  * Sets the automatic completion state for this database item based on the
4143  * count of on its entries.
4144  * @since Moodle 3.3
4145  * @param object $data The data object for this activity
4146  * @param object $course Course
4147  * @param object $cm course-module
4148  */
4149 function data_update_completion_state($data, $course, $cm) {
4150     // If completion option is enabled, evaluate it and return true/false.
4151     $completion = new completion_info($course);
4152     if ($data->completionentries && $completion->is_enabled($cm)) {
4153         $numentries = data_numentries($data);
4154         // Check the number of entries required against the number of entries already made.
4155         if ($numentries >= $data->completionentries) {
4156             $completion->update_state($cm, COMPLETION_COMPLETE);
4157         } else {
4158             $completion->update_state($cm, COMPLETION_INCOMPLETE);
4159         }
4160     }
4163 /**
4164  * Obtains the automatic completion state for this database item based on any conditions
4165  * on its settings. The call for this is in completion lib where the modulename is appended
4166  * to the function name. This is why there are unused parameters.
4167  *
4168  * @since Moodle 3.3
4169  * @param stdClass $course Course
4170  * @param cm_info|stdClass $cm course-module
4171  * @param int $userid User ID
4172  * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)
4173  * @return bool True if completed, false if not, $type if conditions not set.
4174  */
4175 function data_get_completion_state($course, $cm, $userid, $type) {
4176     global $DB, $PAGE;
4177     $result = $type; // Default return value
4178     // Get data details.
4179     if (isset($PAGE->cm->id) && $PAGE->cm->id == $cm->id) {
4180         $data = $PAGE->activityrecord;
4181     } else {
4182         $data = $DB->get_record('data', array('id' => $cm->instance), '*', MUST_EXIST);
4183     }
4184     // If completion option is enabled, evaluate it and return true/false.
4185     if ($data->completionentries) {
4186         $numentries = data_numentries($data, $userid);
4187         // Check the number of entries required against the number of entries already made.
4188         if ($numentries >= $data->completionentries) {
4189             $result = true;
4190         } else {
4191             $result = false;
4192         }
4193     }
4194     return $result;
4197 /**
4198  * Mark the activity completed (if required) and trigger the course_module_viewed event.
4199  *
4200  * @param  stdClass $data       data object
4201  * @param  stdClass $course     course object
4202  * @param  stdClass $cm         course module object
4203  * @param  stdClass $context    context object
4204  * @since Moodle 3.3
4205  */
4206 function data_view($data, $course, $cm, $context) {
4207     global $CFG;
4208     require_once($CFG->libdir . '/completionlib.php');
4210     // Trigger course_module_viewed event.
4211     $params = array(
4212         'context' => $context,
4213         'objectid' => $data->id
4214     );
4216     $event = \mod_data\event\course_module_viewed::create($params);
4217     $event->add_record_snapshot('course_modules', $cm);
4218     $event->add_record_snapshot('course', $course);
4219     $event->add_record_snapshot('data', $data);
4220     $event->trigger();
4222     // Completion.
4223     $completion = new completion_info($course);
4224     $completion->set_module_viewed($cm);
4227 /**
4228  * Get icon mapping for font-awesome.
4229  */
4230 function mod_data_get_fontawesome_icon_map() {
4231     return [
4232         'mod_data:field/checkbox' => 'fa-check-square-o',
4233         'mod_data:field/date' => 'fa-calendar-o',
4234         'mod_data:field/file' => 'fa-file',
4235         'mod_data:field/latlong' => 'fa-globe',
4236         'mod_data:field/menu' => 'fa-bars',
4237         'mod_data:field/multimenu' => 'fa-bars',
4238         'mod_data:field/number' => 'fa-hashtag',
4239         'mod_data:field/picture' => 'fa-picture-o',
4240         'mod_data:field/radiobutton' => 'fa-circle-o',
4241         'mod_data:field/textarea' => 'fa-font',
4242         'mod_data:field/text' => 'fa-i-cursor',
4243         'mod_data:field/url' => 'fa-link',
4244     ];
4247 /*
4248  * Check if the module has any update that affects the current user since a given time.
4249  *
4250  * @param  cm_info $cm course module data
4251  * @param  int $from the time to check updates from
4252  * @param  array $filter  if we need to check only specific updates
4253  * @return stdClass an object with the different type of areas indicating if they were updated or not
4254  * @since Moodle 3.2
4255  */
4256 function data_check_updates_since(cm_info $cm, $from, $filter = array()) {
4257     global $DB, $CFG;
4258     require_once($CFG->dirroot . '/mod/data/locallib.php');
4260     $updates = course_check_module_updates_since($cm, $from, array(), $filter);
4262     // Check for new entries.
4263     $updates->entries = (object) array('updated' => false);
4265     $data = $DB->get_record('data', array('id' => $cm->instance), '*', MUST_EXIST);
4266     $searcharray = [];
4267     $searcharray[DATA_TIMEMODIFIED] = new stdClass();
4268     $searcharray[DATA_TIMEMODIFIED]->sql     = '';
4269     $searcharray[DATA_TIMEMODIFIED]->params  = array();
4270     $searcharray[DATA_TIMEMODIFIED]->field   = 'r.timemodified';
4271     $searcharray[DATA_TIMEMODIFIED]->data    = $from;
4273     $currentgroup = groups_get_activity_group($cm);
4274     // Teachers should retrieve all entries when not in separate groups.
4275     if (has_capability('mod/data:manageentries', $cm->context) && groups_get_activity_groupmode($cm) != SEPARATEGROUPS) {
4276         $currentgroup = 0;
4277     }
4278     list($entries, $maxcount, $totalcount, $page, $nowperpage, $sort, $mode) =
4279         data_search_entries($data, $cm, $cm->context, 'list', $currentgroup, '', null, null, 0, 0, true, $searcharray);
4281     if (!empty($entries)) {
4282         $updates->entries->updated = true;
4283         $updates->entries->itemids = array_keys($entries);
4284     }
4286     return $updates;
4289 /**
4290  * This function receives a calendar event and returns the action associated with it, or null if there is none.
4291  *
4292  * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
4293  * is not displayed on the block.
4294  *
4295  * @param calendar_event $event
4296  * @param \core_calendar\action_factory $factory
4297  * @return \core_calendar\local\event\entities\action_interface|null
4298  */
4299 function mod_data_core_calendar_provide_event_action(calendar_event $event,
4300                                                        \core_calendar\action_factory $factory) {
4302     $cm = get_fast_modinfo($event->courseid)->instances['data'][$event->instance];
4303     $now = time();
4305     if (!empty($cm->customdata['timeavailableto']) && $cm->customdata['timeavailableto'] < $now) {
4306         // The module has closed so the user can no longer submit anything.
4307         return null;
4308     }
4310     // The module is actionable if we don't have a start time or the start time is
4311     // in the past.
4312     $actionable = (empty($cm->customdata['timeavailablefrom']) || $cm->customdata['timeavailablefrom'] <= $now);
4314     return $factory->create_instance(
4315         get_string('add', 'data'),
4316         new \moodle_url('/mod/data/view.php', array('id' => $cm->id)),
4317         1,
4318         $actionable
4319     );
4322 /**
4323  * Add a get_coursemodule_info function in case any database type wants to add 'extra' information
4324  * for the course (see resource).
4325  *
4326  * Given a course_module object, this function returns any "extra" information that may be needed
4327  * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.
4328  *
4329  * @param stdClass $coursemodule The coursemodule object (record).
4330  * @return cached_cm_info An object on information that the courses
4331  *                        will know about (most noticeably, an icon).
4332  */
4333 function data_get_coursemodule_info($coursemodule) {
4334     global $DB;
4336     $dbparams = ['id' => $coursemodule->instance];
4337     $fields = 'id, name, intro, introformat, completionentries, timeavailablefrom, timeavailableto';