MDL-57455 mod_data: Implement tagging
[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         }
626         if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
627             $label = new html_table_cell(get_string('tags') . ':');
628             if ($form) {
629                 $cell = data_generate_tag_form();
630             } else {
631                 $cell = new html_table_cell('##tags##');
632             }
633             $table->data[] = new html_table_row(array($label, $cell));
634         }
636         if ($template == 'listtemplate') {
637             $cell = new html_table_cell('##edit##  ##more##  ##delete##  ##approve##  ##disapprove##  ##export##');
638             $cell->colspan = 2;
639             $cell->attributes['class'] = 'controls';
640             $table->data[] = new html_table_row(array($cell));
641         } else if ($template == 'singletemplate') {
642             $cell = new html_table_cell('##edit##  ##delete##  ##approve##  ##disapprove##  ##export##');
643             $cell->colspan = 2;
644             $cell->attributes['class'] = 'controls';
645             $table->data[] = new html_table_row(array($cell));
646         } else if ($template == 'asearchtemplate') {
647             $row = new html_table_row(array(get_string('authorfirstname', 'data').': ', '##firstname##'));
648             $row->attributes['class'] = 'searchcontrols';
649             $table->data[] = $row;
650             $row = new html_table_row(array(get_string('authorlastname', 'data').': ', '##lastname##'));
651             $row->attributes['class'] = 'searchcontrols';
652             $table->data[] = $row;
653         }
655         $str = '';
656         if ($template == 'listtemplate'){
657             $str .= '##delcheck##';
658             $str .= html_writer::empty_tag('br');
659         }
661         $str .= html_writer::start_tag('div', array('class' => 'defaulttemplate'));
662         $str .= html_writer::table($table);
663         $str .= html_writer::end_tag('div');
664         if ($template == 'listtemplate'){
665             $str .= html_writer::empty_tag('hr');
666         }
668         if ($update) {
669             $newdata = new stdClass();
670             $newdata->id = $data->id;
671             $newdata->{$template} = $str;
672             $DB->update_record('data', $newdata);
673             $data->{$template} = $str;
674         }
676         return $str;
677     }
680 /**
681  * Build the form elements to manage tags for a record.
682  *
683  * @param int $recordid
684  * @return string
685  */
686 function data_generate_tag_form($recordid) {
687     global $CFG, $DB, $PAGE;
689     $tagtypestoshow = \core_tag_area::get_showstandard('mod_data', 'data_records');
690     $showstandard = ($tagtypestoshow != core_tag_tag::HIDE_STANDARD);
691     $typenewtags = ($tagtypestoshow != core_tag_tag::STANDARD_ONLY);
693     $str = html_writer::start_tag('div', array('class' => 'datatagcontrol'));
695     $namefield = empty($CFG->keeptagnamecase) ? 'name' : 'rawname';
697     $existingtags = core_tag_tag::get_item_tags_array('mod_data', 'data_records', $recordid);
699     if ($showstandard) {
700         $tags = $DB->get_records_menu('tag', array(
701             'isstandard' => 1,
702             'tagcollid'  => \core_tag_area::get_collection('mod_data', 'data_records')
703         ), $namefield, 'id,' . $namefield . ' as fieldname');
705         $tags = $existingtags + $tags;
706     } else {
707         $tags = $existingtags;
708     }
710     $str .= '<select class="custom-select" name="tags[]" id="tags" multiple>';
711     foreach ($tags as $tagid => $tag) {
712         $selected = key_exists($tagid, $existingtags) ? 'selected' : '';
713         $str .= "<option value='$tag' $selected>$tag</option>";
714     }
715     $str .= '</select>';
717     $PAGE->requires->js_call_amd('core/form-autocomplete', 'enhance', $params = array(
718             '#tags',
719             $typenewtags,
720             '',
721             get_string('entertags', 'tag'),
722             false,
723             $showstandard,
724             get_string('noselection', 'form')
725         )
726     );
728     $str .= html_writer::end_tag('div');
730     return $str;
734 /**
735  * Search for a field name and replaces it with another one in all the
736  * form templates. Set $newfieldname as '' if you want to delete the
737  * field from the form.
738  *
739  * @global object
740  * @param object $data
741  * @param string $searchfieldname
742  * @param string $newfieldname
743  * @return bool
744  */
745 function data_replace_field_in_templates($data, $searchfieldname, $newfieldname) {
746     global $DB;
748     if (!empty($newfieldname)) {
749         $prestring = '[[';
750         $poststring = ']]';
751         $idpart = '#id';
753     } else {
754         $prestring = '';
755         $poststring = '';
756         $idpart = '';
757     }
759     $newdata = new stdClass();
760     $newdata->id = $data->id;
761     $newdata->singletemplate = str_ireplace('[['.$searchfieldname.']]',
762             $prestring.$newfieldname.$poststring, $data->singletemplate);
764     $newdata->listtemplate = str_ireplace('[['.$searchfieldname.']]',
765             $prestring.$newfieldname.$poststring, $data->listtemplate);
767     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.']]',
768             $prestring.$newfieldname.$poststring, $data->addtemplate);
770     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.'#id]]',
771             $prestring.$newfieldname.$idpart.$poststring, $data->addtemplate);
773     $newdata->rsstemplate = str_ireplace('[['.$searchfieldname.']]',
774             $prestring.$newfieldname.$poststring, $data->rsstemplate);
776     return $DB->update_record('data', $newdata);
780 /**
781  * Appends a new field at the end of the form template.
782  *
783  * @global object
784  * @param object $data
785  * @param string $newfieldname
786  */
787 function data_append_new_field_to_templates($data, $newfieldname) {
788     global $DB;
790     $newdata = new stdClass();
791     $newdata->id = $data->id;
792     $change = false;
794     if (!empty($data->singletemplate)) {
795         $newdata->singletemplate = $data->singletemplate.' [[' . $newfieldname .']]';
796         $change = true;
797     }
798     if (!empty($data->addtemplate)) {
799         $newdata->addtemplate = $data->addtemplate.' [[' . $newfieldname . ']]';
800         $change = true;
801     }
802     if (!empty($data->rsstemplate)) {
803         $newdata->rsstemplate = $data->singletemplate.' [[' . $newfieldname . ']]';
804         $change = true;
805     }
806     if ($change) {
807         $DB->update_record('data', $newdata);
808     }
812 /**
813  * given a field name
814  * this function creates an instance of the particular subfield class
815  *
816  * @global object
817  * @param string $name
818  * @param object $data
819  * @return object|bool
820  */
821 function data_get_field_from_name($name, $data){
822     global $DB;
824     $field = $DB->get_record('data_fields', array('name'=>$name, 'dataid'=>$data->id));
826     if ($field) {
827         return data_get_field($field, $data);
828     } else {
829         return false;
830     }
833 /**
834  * given a field id
835  * this function creates an instance of the particular subfield class
836  *
837  * @global object
838  * @param int $fieldid
839  * @param object $data
840  * @return bool|object
841  */
842 function data_get_field_from_id($fieldid, $data){
843     global $DB;
845     $field = $DB->get_record('data_fields', array('id'=>$fieldid, 'dataid'=>$data->id));
847     if ($field) {
848         return data_get_field($field, $data);
849     } else {
850         return false;
851     }
854 /**
855  * given a field id
856  * this function creates an instance of the particular subfield class
857  *
858  * @global object
859  * @param string $type
860  * @param object $data
861  * @return object
862  */
863 function data_get_field_new($type, $data) {
864     global $CFG;
866     require_once($CFG->dirroot.'/mod/data/field/'.$type.'/field.class.php');
867     $newfield = 'data_field_'.$type;
868     $newfield = new $newfield(0, $data);
869     return $newfield;
872 /**
873  * returns a subclass field object given a record of the field, used to
874  * invoke plugin methods
875  * input: $param $field - record from db
876  *
877  * @global object
878  * @param object $field
879  * @param object $data
880  * @param object $cm
881  * @return object
882  */
883 function data_get_field($field, $data, $cm=null) {
884     global $CFG;
886     if ($field) {
887         require_once('field/'.$field->type.'/field.class.php');
888         $newfield = 'data_field_'.$field->type;
889         $newfield = new $newfield($field, $data, $cm);
890         return $newfield;
891     }
895 /**
896  * Given record object (or id), returns true if the record belongs to the current user
897  *
898  * @global object
899  * @global object
900  * @param mixed $record record object or id
901  * @return bool
902  */
903 function data_isowner($record) {
904     global $USER, $DB;
906     if (!isloggedin()) { // perf shortcut
907         return false;
908     }
910     if (!is_object($record)) {
911         if (!$record = $DB->get_record('data_records', array('id'=>$record))) {
912             return false;
913         }
914     }
916     return ($record->userid == $USER->id);
919 /**
920  * has a user reached the max number of entries?
921  *
922  * @param object $data
923  * @return bool
924  */
925 function data_atmaxentries($data){
926     if (!$data->maxentries){
927         return false;
929     } else {
930         return (data_numentries($data) >= $data->maxentries);
931     }
934 /**
935  * returns the number of entries already made by this user
936  *
937  * @global object
938  * @global object
939  * @param object $data
940  * @return int
941  */
942 function data_numentries($data, $userid=null) {
943     global $USER, $DB;
944     if ($userid === null) {
945         $userid = $USER->id;
946     }
947     $sql = 'SELECT COUNT(*) FROM {data_records} WHERE dataid=? AND userid=?';
948     return $DB->count_records_sql($sql, array($data->id, $userid));
951 /**
952  * function that takes in a dataid and adds a record
953  * this is used everytime an add template is submitted
954  *
955  * @global object
956  * @global object
957  * @param object $data
958  * @param int $groupid
959  * @return bool
960  */
961 function data_add_record($data, $groupid=0){
962     global $USER, $DB;
964     $cm = get_coursemodule_from_instance('data', $data->id);
965     $context = context_module::instance($cm->id);
967     $record = new stdClass();
968     $record->userid = $USER->id;
969     $record->dataid = $data->id;
970     $record->groupid = $groupid;
971     $record->timecreated = $record->timemodified = time();
972     if (has_capability('mod/data:approve', $context)) {
973         $record->approved = 1;
974     } else {
975         $record->approved = 0;
976     }
977     $record->id = $DB->insert_record('data_records', $record);
979     // Trigger an event for creating this record.
980     $event = \mod_data\event\record_created::create(array(
981         'objectid' => $record->id,
982         'context' => $context,
983         'other' => array(
984             'dataid' => $data->id
985         )
986     ));
987     $event->trigger();
989     $course = get_course($cm->course);
990     data_update_completion_state($data, $course, $cm);
992     return $record->id;
995 /**
996  * check the multple existence any tag in a template
997  *
998  * check to see if there are 2 or more of the same tag being used.
999  *
1000  * @global object
1001  * @param int $dataid,
1002  * @param string $template
1003  * @return bool
1004  */
1005 function data_tags_check($dataid, $template) {
1006     global $DB, $OUTPUT;
1008     // first get all the possible tags
1009     $fields = $DB->get_records('data_fields', array('dataid'=>$dataid));
1010     // then we generate strings to replace
1011     $tagsok = true; // let's be optimistic
1012     foreach ($fields as $field){
1013         $pattern="/\[\[" . preg_quote($field->name, '/') . "\]\]/i";
1014         if (preg_match_all($pattern, $template, $dummy)>1){
1015             $tagsok = false;
1016             echo $OUTPUT->notification('[['.$field->name.']] - '.get_string('multipletags','data'));
1017         }
1018     }
1019     // else return true
1020     return $tagsok;
1023 /**
1024  * Adds an instance of a data
1025  *
1026  * @param stdClass $data
1027  * @param mod_data_mod_form $mform
1028  * @return int intance id
1029  */
1030 function data_add_instance($data, $mform = null) {
1031     global $DB, $CFG;
1032     require_once($CFG->dirroot.'/mod/data/locallib.php');
1034     if (empty($data->assessed)) {
1035         $data->assessed = 0;
1036     }
1038     if (empty($data->ratingtime) || empty($data->assessed)) {
1039         $data->assesstimestart  = 0;
1040         $data->assesstimefinish = 0;
1041     }
1043     $data->timemodified = time();
1045     $data->id = $DB->insert_record('data', $data);
1047     // Add calendar events if necessary.
1048     data_set_events($data);
1049     if (!empty($data->completionexpected)) {
1050         \core_completion\api::update_completion_date_event($data->coursemodule, 'data', $data->id, $data->completionexpected);
1051     }
1053     data_grade_item_update($data);
1055     return $data->id;
1058 /**
1059  * updates an instance of a data
1060  *
1061  * @global object
1062  * @param object $data
1063  * @return bool
1064  */
1065 function data_update_instance($data) {
1066     global $DB, $CFG;
1067     require_once($CFG->dirroot.'/mod/data/locallib.php');
1069     $data->timemodified = time();
1070     $data->id           = $data->instance;
1072     if (empty($data->assessed)) {
1073         $data->assessed = 0;
1074     }
1076     if (empty($data->ratingtime) or empty($data->assessed)) {
1077         $data->assesstimestart  = 0;
1078         $data->assesstimefinish = 0;
1079     }
1081     if (empty($data->notification)) {
1082         $data->notification = 0;
1083     }
1085     $DB->update_record('data', $data);
1087     // Add calendar events if necessary.
1088     data_set_events($data);
1089     $completionexpected = (!empty($data->completionexpected)) ? $data->completionexpected : null;
1090     \core_completion\api::update_completion_date_event($data->coursemodule, 'data', $data->id, $completionexpected);
1092     data_grade_item_update($data);
1094     return true;
1098 /**
1099  * deletes an instance of a data
1100  *
1101  * @global object
1102  * @param int $id
1103  * @return bool
1104  */
1105 function data_delete_instance($id) {    // takes the dataid
1106     global $DB, $CFG;
1108     if (!$data = $DB->get_record('data', array('id'=>$id))) {
1109         return false;
1110     }
1112     $cm = get_coursemodule_from_instance('data', $data->id);
1113     $context = context_module::instance($cm->id);
1115 /// Delete all the associated information
1117     // files
1118     $fs = get_file_storage();
1119     $fs->delete_area_files($context->id, 'mod_data');
1121     // get all the records in this data
1122     $sql = "SELECT r.id
1123               FROM {data_records} r
1124              WHERE r.dataid = ?";
1126     $DB->delete_records_select('data_content', "recordid IN ($sql)", array($id));
1128     // delete all the records and fields
1129     $DB->delete_records('data_records', array('dataid'=>$id));
1130     $DB->delete_records('data_fields', array('dataid'=>$id));
1132     // Remove old calendar events.
1133     $events = $DB->get_records('event', array('modulename' => 'data', 'instance' => $id));
1134     foreach ($events as $event) {
1135         $event = calendar_event::load($event);
1136         $event->delete();
1137     }
1139     // Delete the instance itself
1140     $result = $DB->delete_records('data', array('id'=>$id));
1142     // cleanup gradebook
1143     data_grade_item_delete($data);
1145     return $result;
1148 /**
1149  * returns a summary of data activity of this user
1150  *
1151  * @global object
1152  * @param object $course
1153  * @param object $user
1154  * @param object $mod
1155  * @param object $data
1156  * @return object|null
1157  */
1158 function data_user_outline($course, $user, $mod, $data) {
1159     global $DB, $CFG;
1160     require_once("$CFG->libdir/gradelib.php");
1162     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1163     if (empty($grades->items[0]->grades)) {
1164         $grade = false;
1165     } else {
1166         $grade = reset($grades->items[0]->grades);
1167     }
1170     if ($countrecords = $DB->count_records('data_records', array('dataid'=>$data->id, 'userid'=>$user->id))) {
1171         $result = new stdClass();
1172         $result->info = get_string('numrecords', 'data', $countrecords);
1173         $lastrecord   = $DB->get_record_sql('SELECT id,timemodified FROM {data_records}
1174                                               WHERE dataid = ? AND userid = ?
1175                                            ORDER BY timemodified DESC', array($data->id, $user->id), true);
1176         $result->time = $lastrecord->timemodified;
1177         if ($grade) {
1178             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1179         }
1180         return $result;
1181     } else if ($grade) {
1182         $result = new stdClass();
1183         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1185         //datesubmitted == time created. dategraded == time modified or time overridden
1186         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1187         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1188         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1189             $result->time = $grade->dategraded;
1190         } else {
1191             $result->time = $grade->datesubmitted;
1192         }
1194         return $result;
1195     }
1196     return NULL;
1199 /**
1200  * Prints all the records uploaded by this user
1201  *
1202  * @global object
1203  * @param object $course
1204  * @param object $user
1205  * @param object $mod
1206  * @param object $data
1207  */
1208 function data_user_complete($course, $user, $mod, $data) {
1209     global $DB, $CFG, $OUTPUT;
1210     require_once("$CFG->libdir/gradelib.php");
1212     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1213     if (!empty($grades->items[0]->grades)) {
1214         $grade = reset($grades->items[0]->grades);
1215         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1216         if ($grade->str_feedback) {
1217             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1218         }
1219     }
1221     if ($records = $DB->get_records('data_records', array('dataid'=>$data->id,'userid'=>$user->id), 'timemodified DESC')) {
1222         data_print_template('singletemplate', $records, $data);
1223     }
1226 /**
1227  * Return grade for given user or all users.
1228  *
1229  * @global object
1230  * @param object $data
1231  * @param int $userid optional user id, 0 means all users
1232  * @return array array of grades, false if none
1233  */
1234 function data_get_user_grades($data, $userid=0) {
1235     global $CFG;
1237     require_once($CFG->dirroot.'/rating/lib.php');
1239     $ratingoptions = new stdClass;
1240     $ratingoptions->component = 'mod_data';
1241     $ratingoptions->ratingarea = 'entry';
1242     $ratingoptions->modulename = 'data';
1243     $ratingoptions->moduleid   = $data->id;
1245     $ratingoptions->userid = $userid;
1246     $ratingoptions->aggregationmethod = $data->assessed;
1247     $ratingoptions->scaleid = $data->scale;
1248     $ratingoptions->itemtable = 'data_records';
1249     $ratingoptions->itemtableusercolumn = 'userid';
1251     $rm = new rating_manager();
1252     return $rm->get_user_grades($ratingoptions);
1255 /**
1256  * Update activity grades
1257  *
1258  * @category grade
1259  * @param object $data
1260  * @param int $userid specific user only, 0 means all
1261  * @param bool $nullifnone
1262  */
1263 function data_update_grades($data, $userid=0, $nullifnone=true) {
1264     global $CFG, $DB;
1265     require_once($CFG->libdir.'/gradelib.php');
1267     if (!$data->assessed) {
1268         data_grade_item_update($data);
1270     } else if ($grades = data_get_user_grades($data, $userid)) {
1271         data_grade_item_update($data, $grades);
1273     } else if ($userid and $nullifnone) {
1274         $grade = new stdClass();
1275         $grade->userid   = $userid;
1276         $grade->rawgrade = NULL;
1277         data_grade_item_update($data, $grade);
1279     } else {
1280         data_grade_item_update($data);
1281     }
1284 /**
1285  * Update/create grade item for given data
1286  *
1287  * @category grade
1288  * @param stdClass $data A database instance with extra cmidnumber property
1289  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1290  * @return object grade_item
1291  */
1292 function data_grade_item_update($data, $grades=NULL) {
1293     global $CFG;
1294     require_once($CFG->libdir.'/gradelib.php');
1296     $params = array('itemname'=>$data->name, 'idnumber'=>$data->cmidnumber);
1298     if (!$data->assessed or $data->scale == 0) {
1299         $params['gradetype'] = GRADE_TYPE_NONE;
1301     } else if ($data->scale > 0) {
1302         $params['gradetype'] = GRADE_TYPE_VALUE;
1303         $params['grademax']  = $data->scale;
1304         $params['grademin']  = 0;
1306     } else if ($data->scale < 0) {
1307         $params['gradetype'] = GRADE_TYPE_SCALE;
1308         $params['scaleid']   = -$data->scale;
1309     }
1311     if ($grades  === 'reset') {
1312         $params['reset'] = true;
1313         $grades = NULL;
1314     }
1316     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, $grades, $params);
1319 /**
1320  * Delete grade item for given data
1321  *
1322  * @category grade
1323  * @param object $data object
1324  * @return object grade_item
1325  */
1326 function data_grade_item_delete($data) {
1327     global $CFG;
1328     require_once($CFG->libdir.'/gradelib.php');
1330     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, NULL, array('deleted'=>1));
1333 // junk functions
1334 /**
1335  * takes a list of records, the current data, a search string,
1336  * and mode to display prints the translated template
1337  *
1338  * @global object
1339  * @global object
1340  * @param string $template
1341  * @param array $records
1342  * @param object $data
1343  * @param string $search
1344  * @param int $page
1345  * @param bool $return
1346  * @param object $jumpurl a moodle_url by which to jump back to the record list (can be null)
1347  * @return mixed
1348  */
1349 function data_print_template($template, $records, $data, $search='', $page=0, $return=false, moodle_url $jumpurl=null) {
1350     global $CFG, $DB, $OUTPUT;
1352     $cm = get_coursemodule_from_instance('data', $data->id);
1353     $context = context_module::instance($cm->id);
1355     static $fields = array();
1356     static $dataid = null;
1358     if (empty($dataid)) {
1359         $dataid = $data->id;
1360     } else if ($dataid != $data->id) {
1361         $fields = array();
1362     }
1364     if (empty($fields)) {
1365         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1366         foreach ($fieldrecords as $fieldrecord) {
1367             $fields[]= data_get_field($fieldrecord, $data);
1368         }
1369     }
1371     if (empty($records)) {
1372         return;
1373     }
1375     if (!$jumpurl) {
1376         $jumpurl = new moodle_url('/mod/data/view.php', array('d' => $data->id));
1377     }
1378     $jumpurl = new moodle_url($jumpurl, array('page' => $page, 'sesskey' => sesskey()));
1380     foreach ($records as $record) {   // Might be just one for the single template
1382     // Replacing tags
1383         $patterns = array();
1384         $replacement = array();
1386     // Then we generate strings to replace for normal tags
1387         foreach ($fields as $field) {
1388             $patterns[]='[['.$field->field->name.']]';
1389             $replacement[] = highlight($search, $field->display_browse_field($record->id, $template));
1390         }
1392         $canmanageentries = has_capability('mod/data:manageentries', $context);
1394     // Replacing special tags (##Edit##, ##Delete##, ##More##)
1395         $patterns[]='##edit##';
1396         $patterns[]='##delete##';
1397         if (data_user_can_manage_entry($record, $data, $context)) {
1398             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/edit.php?d='
1399                              .$data->id.'&amp;rid='.$record->id.'&amp;sesskey='.sesskey().'">' .
1400                              $OUTPUT->pix_icon('t/edit', get_string('edit')) . '</a>';
1401             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/view.php?d='
1402                              .$data->id.'&amp;delete='.$record->id.'&amp;sesskey='.sesskey().'">' .
1403                              $OUTPUT->pix_icon('t/delete', get_string('delete')) . '</a>';
1404         } else {
1405             $replacement[] = '';
1406             $replacement[] = '';
1407         }
1409         $moreurl = $CFG->wwwroot . '/mod/data/view.php?d=' . $data->id . '&amp;rid=' . $record->id;
1410         if ($search) {
1411             $moreurl .= '&amp;filter=1';
1412         }
1413         $patterns[]='##more##';
1414         $replacement[] = '<a href="'.$moreurl.'">' . $OUTPUT->pix_icon('t/preview', get_string('more', 'data')) . '</a>';
1416         $patterns[]='##moreurl##';
1417         $replacement[] = $moreurl;
1419         $patterns[]='##delcheck##';
1420         if ($canmanageentries) {
1421             $replacement[] = html_writer::checkbox('delcheck[]', $record->id, false, '', array('class' => 'recordcheckbox'));
1422         } else {
1423             $replacement[] = '';
1424         }
1426         $patterns[]='##user##';
1427         $replacement[] = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$record->userid.
1428                                '&amp;course='.$data->course.'">'.fullname($record).'</a>';
1430         $patterns[] = '##userpicture##';
1431         $ruser = user_picture::unalias($record, null, 'userid');
1432         // If the record didn't come with user data, retrieve the user from database.
1433         if (!isset($ruser->picture)) {
1434             $ruser = core_user::get_user($record->userid);
1435         }
1436         $replacement[] = $OUTPUT->user_picture($ruser, array('courseid' => $data->course));
1438         $patterns[]='##export##';
1440         if (!empty($CFG->enableportfolios) && ($template == 'singletemplate' || $template == 'listtemplate')
1441             && ((has_capability('mod/data:exportentry', $context)
1442                 || (data_isowner($record->id) && has_capability('mod/data:exportownentry', $context))))) {
1443             require_once($CFG->libdir . '/portfoliolib.php');
1444             $button = new portfolio_add_button();
1445             $button->set_callback_options('data_portfolio_caller', array('id' => $cm->id, 'recordid' => $record->id), 'mod_data');
1446             list($formats, $files) = data_portfolio_caller::formats($fields, $record);
1447             $button->set_formats($formats);
1448             $replacement[] = $button->to_html(PORTFOLIO_ADD_ICON_LINK);
1449         } else {
1450             $replacement[] = '';
1451         }
1453         $patterns[] = '##timeadded##';
1454         $replacement[] = userdate($record->timecreated);
1456         $patterns[] = '##timemodified##';
1457         $replacement [] = userdate($record->timemodified);
1459         $patterns[]='##approve##';
1460         if (has_capability('mod/data:approve', $context) && ($data->approval) && (!$record->approved)) {
1461             $approveurl = new moodle_url($jumpurl, array('approve' => $record->id));
1462             $approveicon = new pix_icon('t/approve', get_string('approve', 'data'), '', array('class' => 'iconsmall'));
1463             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($approveurl, $approveicon),
1464                     array('class' => 'approve'));
1465         } else {
1466             $replacement[] = '';
1467         }
1469         $patterns[]='##disapprove##';
1470         if (has_capability('mod/data:approve', $context) && ($data->approval) && ($record->approved)) {
1471             $disapproveurl = new moodle_url($jumpurl, array('disapprove' => $record->id));
1472             $disapproveicon = new pix_icon('t/block', get_string('disapprove', 'data'), '', array('class' => 'iconsmall'));
1473             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($disapproveurl, $disapproveicon),
1474                     array('class' => 'disapprove'));
1475         } else {
1476             $replacement[] = '';
1477         }
1479         $patterns[] = '##approvalstatus##';
1480         if (!$data->approval) {
1481             $replacement[] = '';
1482         } else if ($record->approved) {
1483             $replacement[] = get_string('approved', 'data');
1484         } else {
1485             $replacement[] = get_string('notapproved', 'data');
1486         }
1488         $patterns[]='##comments##';
1489         if (($template == 'listtemplate') && ($data->comments)) {
1491             if (!empty($CFG->usecomments)) {
1492                 require_once($CFG->dirroot  . '/comment/lib.php');
1493                 list($context, $course, $cm) = get_context_info_array($context->id);
1494                 $cmt = new stdClass();
1495                 $cmt->context = $context;
1496                 $cmt->course  = $course;
1497                 $cmt->cm      = $cm;
1498                 $cmt->area    = 'database_entry';
1499                 $cmt->itemid  = $record->id;
1500                 $cmt->showcount = true;
1501                 $cmt->component = 'mod_data';
1502                 $comment = new comment($cmt);
1503                 $replacement[] = $comment->output(true);
1504             }
1505         } else {
1506             $replacement[] = '';
1507         }
1509         if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
1510             $patterns[] = "##tags##";
1511             $replacement[] = $OUTPUT->tag_list(
1512                 core_tag_tag::get_item_tags('mod_data', 'data_records', $record->id), '', 'data-tags');
1513         }
1515         // actual replacement of the tags
1516         $newtext = str_ireplace($patterns, $replacement, $data->{$template});
1518         // no more html formatting and filtering - see MDL-6635
1519         if ($return) {
1520             return $newtext;
1521         } else {
1522             echo $newtext;
1524             // hack alert - return is always false in singletemplate anyway ;-)
1525             /**********************************
1526              *    Printing Ratings Form       *
1527              *********************************/
1528             if ($template == 'singletemplate') {    //prints ratings options
1529                 data_print_ratings($data, $record);
1530             }
1532             /**********************************
1533              *    Printing Comments Form       *
1534              *********************************/
1535             if (($template == 'singletemplate') && ($data->comments)) {
1536                 if (!empty($CFG->usecomments)) {
1537                     require_once($CFG->dirroot . '/comment/lib.php');
1538                     list($context, $course, $cm) = get_context_info_array($context->id);
1539                     $cmt = new stdClass();
1540                     $cmt->context = $context;
1541                     $cmt->course  = $course;
1542                     $cmt->cm      = $cm;
1543                     $cmt->area    = 'database_entry';
1544                     $cmt->itemid  = $record->id;
1545                     $cmt->showcount = true;
1546                     $cmt->component = 'mod_data';
1547                     $comment = new comment($cmt);
1548                     $comment->output(false);
1549                 }
1550             }
1551         }
1552     }
1555 /**
1556  * Return rating related permissions
1557  *
1558  * @param string $contextid the context id
1559  * @param string $component the component to get rating permissions for
1560  * @param string $ratingarea the rating area to get permissions for
1561  * @return array an associative array of the user's rating permissions
1562  */
1563 function data_rating_permissions($contextid, $component, $ratingarea) {
1564     $context = context::instance_by_id($contextid, MUST_EXIST);
1565     if ($component != 'mod_data' || $ratingarea != 'entry') {
1566         return null;
1567     }
1568     return array(
1569         'view'    => has_capability('mod/data:viewrating',$context),
1570         'viewany' => has_capability('mod/data:viewanyrating',$context),
1571         'viewall' => has_capability('mod/data:viewallratings',$context),
1572         'rate'    => has_capability('mod/data:rate',$context)
1573     );
1576 /**
1577  * Validates a submitted rating
1578  * @param array $params submitted data
1579  *            context => object the context in which the rated items exists [required]
1580  *            itemid => int the ID of the object being rated
1581  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
1582  *            rating => int the submitted rating
1583  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
1584  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
1585  * @return boolean true if the rating is valid. Will throw rating_exception if not
1586  */
1587 function data_rating_validate($params) {
1588     global $DB, $USER;
1590     // Check the component is mod_data
1591     if ($params['component'] != 'mod_data') {
1592         throw new rating_exception('invalidcomponent');
1593     }
1595     // Check the ratingarea is entry (the only rating area in data module)
1596     if ($params['ratingarea'] != 'entry') {
1597         throw new rating_exception('invalidratingarea');
1598     }
1600     // Check the rateduserid is not the current user .. you can't rate your own entries
1601     if ($params['rateduserid'] == $USER->id) {
1602         throw new rating_exception('nopermissiontorate');
1603     }
1605     $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
1606                   FROM {data_records} r
1607                   JOIN {data} d ON r.dataid = d.id
1608                  WHERE r.id = :itemid";
1609     $dataparams = array('itemid'=>$params['itemid']);
1610     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1611         //item doesn't exist
1612         throw new rating_exception('invaliditemid');
1613     }
1615     if ($info->scale != $params['scaleid']) {
1616         //the scale being submitted doesnt match the one in the database
1617         throw new rating_exception('invalidscaleid');
1618     }
1620     //check that the submitted rating is valid for the scale
1622     // lower limit
1623     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
1624         throw new rating_exception('invalidnum');
1625     }
1627     // upper limit
1628     if ($info->scale < 0) {
1629         //its a custom scale
1630         $scalerecord = $DB->get_record('scale', array('id' => -$info->scale));
1631         if ($scalerecord) {
1632             $scalearray = explode(',', $scalerecord->scale);
1633             if ($params['rating'] > count($scalearray)) {
1634                 throw new rating_exception('invalidnum');
1635             }
1636         } else {
1637             throw new rating_exception('invalidscaleid');
1638         }
1639     } else if ($params['rating'] > $info->scale) {
1640         //if its numeric and submitted rating is above maximum
1641         throw new rating_exception('invalidnum');
1642     }
1644     if ($info->approval && !$info->approved) {
1645         //database requires approval but this item isnt approved
1646         throw new rating_exception('nopermissiontorate');
1647     }
1649     // check the item we're rating was created in the assessable time window
1650     if (!empty($info->assesstimestart) && !empty($info->assesstimefinish)) {
1651         if ($info->timecreated < $info->assesstimestart || $info->timecreated > $info->assesstimefinish) {
1652             throw new rating_exception('notavailable');
1653         }
1654     }
1656     $course = $DB->get_record('course', array('id'=>$info->course), '*', MUST_EXIST);
1657     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1658     $context = context_module::instance($cm->id);
1660     // if the supplied context doesnt match the item's context
1661     if ($context->id != $params['context']->id) {
1662         throw new rating_exception('invalidcontext');
1663     }
1665     // Make sure groups allow this user to see the item they're rating
1666     $groupid = $info->groupid;
1667     if ($groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
1668         if (!groups_group_exists($groupid)) { // Can't find group
1669             throw new rating_exception('cannotfindgroup');//something is wrong
1670         }
1672         if (!groups_is_member($groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
1673             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
1674             throw new rating_exception('notmemberofgroup');
1675         }
1676     }
1678     return true;
1681 /**
1682  * Can the current user see ratings for a given itemid?
1683  *
1684  * @param array $params submitted data
1685  *            contextid => int contextid [required]
1686  *            component => The component for this module - should always be mod_data [required]
1687  *            ratingarea => object the context in which the rated items exists [required]
1688  *            itemid => int the ID of the object being rated [required]
1689  *            scaleid => int scale id [optional]
1690  * @return bool
1691  * @throws coding_exception
1692  * @throws rating_exception
1693  */
1694 function mod_data_rating_can_see_item_ratings($params) {
1695     global $DB;
1697     // Check the component is mod_data.
1698     if (!isset($params['component']) || $params['component'] != 'mod_data') {
1699         throw new rating_exception('invalidcomponent');
1700     }
1702     // Check the ratingarea is entry (the only rating area in data).
1703     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'entry') {
1704         throw new rating_exception('invalidratingarea');
1705     }
1707     if (!isset($params['itemid'])) {
1708         throw new rating_exception('invaliditemid');
1709     }
1711     $datasql = "SELECT d.id as dataid, d.course, r.groupid
1712                   FROM {data_records} r
1713                   JOIN {data} d ON r.dataid = d.id
1714                  WHERE r.id = :itemid";
1715     $dataparams = array('itemid' => $params['itemid']);
1716     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1717         // Item doesn't exist.
1718         throw new rating_exception('invaliditemid');
1719     }
1721     // User can see ratings of all participants.
1722     if ($info->groupid == 0) {
1723         return true;
1724     }
1726     $course = $DB->get_record('course', array('id' => $info->course), '*', MUST_EXIST);
1727     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1729     // Make sure groups allow this user to see the item they're rating.
1730     return groups_group_visible($info->groupid, $course, $cm);
1734 /**
1735  * function that takes in the current data, number of items per page,
1736  * a search string and prints a preference box in view.php
1737  *
1738  * This preference box prints a searchable advanced search template if
1739  *     a) A template is defined
1740  *  b) The advanced search checkbox is checked.
1741  *
1742  * @global object
1743  * @global object
1744  * @param object $data
1745  * @param int $perpage
1746  * @param string $search
1747  * @param string $sort
1748  * @param string $order
1749  * @param array $search_array
1750  * @param int $advanced
1751  * @param string $mode
1752  * @return void
1753  */
1754 function data_print_preference_form($data, $perpage, $search, $sort='', $order='ASC', $search_array = '', $advanced = 0, $mode= ''){
1755     global $CFG, $DB, $PAGE, $OUTPUT;
1757     $cm = get_coursemodule_from_instance('data', $data->id);
1758     $context = context_module::instance($cm->id);
1759     echo '<br /><div class="datapreferences">';
1760     echo '<form id="options" action="view.php" method="get">';
1761     echo '<div>';
1762     echo '<input type="hidden" name="d" value="'.$data->id.'" />';
1763     if ($mode =='asearch') {
1764         $advanced = 1;
1765         echo '<input type="hidden" name="mode" value="list" />';
1766     }
1767     echo '<label for="pref_perpage">'.get_string('pagesize','data').'</label> ';
1768     $pagesizes = array(2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,15=>15,
1769                        20=>20,30=>30,40=>40,50=>50,100=>100,200=>200,300=>300,400=>400,500=>500,1000=>1000);
1770     echo html_writer::select($pagesizes, 'perpage', $perpage, false, array('id' => 'pref_perpage', 'class' => 'custom-select'));
1772     if ($advanced) {
1773         $regsearchclass = 'search_none';
1774         $advancedsearchclass = 'search_inline';
1775     } else {
1776         $regsearchclass = 'search_inline';
1777         $advancedsearchclass = 'search_none';
1778     }
1779     echo '<div id="reg_search" class="' . $regsearchclass . ' form-inline" >&nbsp;&nbsp;&nbsp;';
1780     echo '<label for="pref_search">' . get_string('search') . '</label> <input type="text" ' .
1781          'class="form-control" size="16" name="search" id= "pref_search" value="' . s($search) . '" /></div>';
1782     echo '&nbsp;&nbsp;&nbsp;<label for="pref_sortby">'.get_string('sortby').'</label> ';
1783     // foreach field, print the option
1784     echo '<select name="sort" id="pref_sortby" class="custom-select m-r-1">';
1785     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'name')) {
1786         echo '<optgroup label="'.get_string('fields', 'data').'">';
1787         foreach ($fields as $field) {
1788             if ($field->id == $sort) {
1789                 echo '<option value="'.$field->id.'" selected="selected">'.$field->name.'</option>';
1790             } else {
1791                 echo '<option value="'.$field->id.'">'.$field->name.'</option>';
1792             }
1793         }
1794         echo '</optgroup>';
1795     }
1796     $options = array();
1797     $options[DATA_TIMEADDED]    = get_string('timeadded', 'data');
1798     $options[DATA_TIMEMODIFIED] = get_string('timemodified', 'data');
1799     $options[DATA_FIRSTNAME]    = get_string('authorfirstname', 'data');
1800     $options[DATA_LASTNAME]     = get_string('authorlastname', 'data');
1801     if ($data->approval and has_capability('mod/data:approve', $context)) {
1802         $options[DATA_APPROVED] = get_string('approved', 'data');
1803     }
1804     echo '<optgroup label="'.get_string('other', 'data').'">';
1805     foreach ($options as $key => $name) {
1806         if ($key == $sort) {
1807             echo '<option value="'.$key.'" selected="selected">'.$name.'</option>';
1808         } else {
1809             echo '<option value="'.$key.'">'.$name.'</option>';
1810         }
1811     }
1812     echo '</optgroup>';
1813     echo '</select>';
1814     echo '<label for="pref_order" class="accesshide">'.get_string('order').'</label>';
1815     echo '<select id="pref_order" name="order" class="custom-select m-r-1">';
1816     if ($order == 'ASC') {
1817         echo '<option value="ASC" selected="selected">'.get_string('ascending','data').'</option>';
1818     } else {
1819         echo '<option value="ASC">'.get_string('ascending','data').'</option>';
1820     }
1821     if ($order == 'DESC') {
1822         echo '<option value="DESC" selected="selected">'.get_string('descending','data').'</option>';
1823     } else {
1824         echo '<option value="DESC">'.get_string('descending','data').'</option>';
1825     }
1826     echo '</select>';
1828     if ($advanced) {
1829         $checked = ' checked="checked" ';
1830     }
1831     else {
1832         $checked = '';
1833     }
1834     $PAGE->requires->js('/mod/data/data.js');
1835     echo '&nbsp;<input type="hidden" name="advanced" value="0" />';
1836     echo '&nbsp;<input type="hidden" name="filter" value="1" />';
1837     echo '&nbsp;<input type="checkbox" id="advancedcheckbox" name="advanced" value="1" ' . $checked . ' ' .
1838          'onchange="showHideAdvSearch(this.checked);" class="m-x-1" />' .
1839          '<label for="advancedcheckbox">' . get_string('advancedsearch', 'data') . '</label>';
1840     echo '&nbsp;<input type="submit" class="btn btn-secondary" value="' . get_string('savesettings', 'data') . '" />';
1842     echo '<br />';
1843     echo '<div class="' . $advancedsearchclass . '" id="data_adv_form">';
1844     echo '<table class="boxaligncenter">';
1846     // print ASC or DESC
1847     echo '<tr><td colspan="2">&nbsp;</td></tr>';
1848     $i = 0;
1850     // Determine if we are printing all fields for advanced search, or the template for advanced search
1851     // If a template is not defined, use the deafault template and display all fields.
1852     if(empty($data->asearchtemplate)) {
1853         data_generate_default_template($data, 'asearchtemplate');
1854     }
1856     static $fields = array();
1857     static $dataid = null;
1859     if (empty($dataid)) {
1860         $dataid = $data->id;
1861     } else if ($dataid != $data->id) {
1862         $fields = array();
1863     }
1865     if (empty($fields)) {
1866         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1867         foreach ($fieldrecords as $fieldrecord) {
1868             $fields[]= data_get_field($fieldrecord, $data);
1869         }
1870     }
1872     // Replacing tags
1873     $patterns = array();
1874     $replacement = array();
1876     // Then we generate strings to replace for normal tags
1877     foreach ($fields as $field) {
1878         $fieldname = $field->field->name;
1879         $fieldname = preg_quote($fieldname, '/');
1880         $patterns[] = "/\[\[$fieldname\]\]/i";
1881         $searchfield = data_get_field_from_id($field->field->id, $data);
1882         if (!empty($search_array[$field->field->id]->data)) {
1883             $replacement[] = $searchfield->display_search_field($search_array[$field->field->id]->data);
1884         } else {
1885             $replacement[] = $searchfield->display_search_field();
1886         }
1887     }
1888     $fn = !empty($search_array[DATA_FIRSTNAME]->data) ? $search_array[DATA_FIRSTNAME]->data : '';
1889     $ln = !empty($search_array[DATA_LASTNAME]->data) ? $search_array[DATA_LASTNAME]->data : '';
1890     $patterns[]    = '/##firstname##/';
1891     $replacement[] = '<label class="accesshide" for="u_fn">' . get_string('authorfirstname', 'data') . '</label>' .
1892                      '<input type="text" class="form-control" size="16" id="u_fn" name="u_fn" value="' . s($fn) . '" />';
1893     $patterns[]    = '/##lastname##/';
1894     $replacement[] = '<label class="accesshide" for="u_ln">' . get_string('authorlastname', 'data') . '</label>' .
1895                      '<input type="text" class="form-control" size="16" id="u_ln" name="u_ln" value="' . s($ln) . '" />';
1897     // actual replacement of the tags
1898     $newtext = preg_replace($patterns, $replacement, $data->asearchtemplate);
1900     $options = new stdClass();
1901     $options->para=false;
1902     $options->noclean=true;
1903     echo '<tr><td>';
1904     echo format_text($newtext, FORMAT_HTML, $options);
1905     echo '</td></tr>';
1907     echo '<tr><td colspan="4"><br/>' .
1908          '<input type="submit" class="btn btn-primary m-r-1" value="' . get_string('savesettings', 'data') . '" />' .
1909          '<input type="submit" class="btn btn-secondary" name="resetadv" value="' . get_string('resetsettings', 'data') . '" />' .
1910          '</td></tr>';
1911     echo '</table>';
1912     echo '</div>';
1913     echo '</div>';
1914     echo '</form>';
1915     echo '</div>';
1918 /**
1919  * @global object
1920  * @global object
1921  * @param object $data
1922  * @param object $record
1923  * @return void Output echo'd
1924  */
1925 function data_print_ratings($data, $record) {
1926     global $OUTPUT;
1927     if (!empty($record->rating)){
1928         echo $OUTPUT->render($record->rating);
1929     }
1932 /**
1933  * List the actions that correspond to a view of this module.
1934  * This is used by the participation report.
1935  *
1936  * Note: This is not used by new logging system. Event with
1937  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
1938  *       be considered as view action.
1939  *
1940  * @return array
1941  */
1942 function data_get_view_actions() {
1943     return array('view');
1946 /**
1947  * List the actions that correspond to a post of this module.
1948  * This is used by the participation report.
1949  *
1950  * Note: This is not used by new logging system. Event with
1951  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
1952  *       will be considered as post action.
1953  *
1954  * @return array
1955  */
1956 function data_get_post_actions() {
1957     return array('add','update','record delete');
1960 /**
1961  * @param string $name
1962  * @param int $dataid
1963  * @param int $fieldid
1964  * @return bool
1965  */
1966 function data_fieldname_exists($name, $dataid, $fieldid = 0) {
1967     global $DB;
1969     if (!is_numeric($name)) {
1970         $like = $DB->sql_like('df.name', ':name', false);
1971     } else {
1972         $like = "df.name = :name";
1973     }
1974     $params = array('name'=>$name);
1975     if ($fieldid) {
1976         $params['dataid']   = $dataid;
1977         $params['fieldid1'] = $fieldid;
1978         $params['fieldid2'] = $fieldid;
1979         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1980                                         WHERE $like AND df.dataid = :dataid
1981                                               AND ((df.id < :fieldid1) OR (df.id > :fieldid2))", $params);
1982     } else {
1983         $params['dataid']   = $dataid;
1984         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1985                                         WHERE $like AND df.dataid = :dataid", $params);
1986     }
1989 /**
1990  * @param array $fieldinput
1991  */
1992 function data_convert_arrays_to_strings(&$fieldinput) {
1993     foreach ($fieldinput as $key => $val) {
1994         if (is_array($val)) {
1995             $str = '';
1996             foreach ($val as $inner) {
1997                 $str .= $inner . ',';
1998             }
1999             $str = substr($str, 0, -1);
2001             $fieldinput->$key = $str;
2002         }
2003     }
2007 /**
2008  * Converts a database (module instance) to use the Roles System
2009  *
2010  * @global object
2011  * @global object
2012  * @uses CONTEXT_MODULE
2013  * @uses CAP_PREVENT
2014  * @uses CAP_ALLOW
2015  * @param object $data a data object with the same attributes as a record
2016  *                     from the data database table
2017  * @param int $datamodid the id of the data module, from the modules table
2018  * @param array $teacherroles array of roles that have archetype teacher
2019  * @param array $studentroles array of roles that have archetype student
2020  * @param array $guestroles array of roles that have archetype guest
2021  * @param int $cmid the course_module id for this data instance
2022  * @return boolean data module was converted or not
2023  */
2024 function data_convert_to_roles($data, $teacherroles=array(), $studentroles=array(), $cmid=NULL) {
2025     global $CFG, $DB, $OUTPUT;
2027     if (!isset($data->participants) && !isset($data->assesspublic)
2028             && !isset($data->groupmode)) {
2029         // We assume that this database has already been converted to use the
2030         // Roles System. above fields get dropped the data module has been
2031         // upgraded to use Roles.
2032         return false;
2033     }
2035     if (empty($cmid)) {
2036         // We were not given the course_module id. Try to find it.
2037         if (!$cm = get_coursemodule_from_instance('data', $data->id)) {
2038             echo $OUTPUT->notification('Could not get the course module for the data');
2039             return false;
2040         } else {
2041             $cmid = $cm->id;
2042         }
2043     }
2044     $context = context_module::instance($cmid);
2047     // $data->participants:
2048     // 1 - Only teachers can add entries
2049     // 3 - Teachers and students can add entries
2050     switch ($data->participants) {
2051         case 1:
2052             foreach ($studentroles as $studentrole) {
2053                 assign_capability('mod/data:writeentry', CAP_PREVENT, $studentrole->id, $context->id);
2054             }
2055             foreach ($teacherroles as $teacherrole) {
2056                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
2057             }
2058             break;
2059         case 3:
2060             foreach ($studentroles as $studentrole) {
2061                 assign_capability('mod/data:writeentry', CAP_ALLOW, $studentrole->id, $context->id);
2062             }
2063             foreach ($teacherroles as $teacherrole) {
2064                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
2065             }
2066             break;
2067     }
2069     // $data->assessed:
2070     // 2 - Only teachers can rate posts
2071     // 1 - Everyone can rate posts
2072     // 0 - No one can rate posts
2073     switch ($data->assessed) {
2074         case 0:
2075             foreach ($studentroles as $studentrole) {
2076                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2077             }
2078             foreach ($teacherroles as $teacherrole) {
2079                 assign_capability('mod/data:rate', CAP_PREVENT, $teacherrole->id, $context->id);
2080             }
2081             break;
2082         case 1:
2083             foreach ($studentroles as $studentrole) {
2084                 assign_capability('mod/data:rate', CAP_ALLOW, $studentrole->id, $context->id);
2085             }
2086             foreach ($teacherroles as $teacherrole) {
2087                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2088             }
2089             break;
2090         case 2:
2091             foreach ($studentroles as $studentrole) {
2092                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2093             }
2094             foreach ($teacherroles as $teacherrole) {
2095                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2096             }
2097             break;
2098     }
2100     // $data->assesspublic:
2101     // 0 - Students can only see their own ratings
2102     // 1 - Students can see everyone's ratings
2103     switch ($data->assesspublic) {
2104         case 0:
2105             foreach ($studentroles as $studentrole) {
2106                 assign_capability('mod/data:viewrating', CAP_PREVENT, $studentrole->id, $context->id);
2107             }
2108             foreach ($teacherroles as $teacherrole) {
2109                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2110             }
2111             break;
2112         case 1:
2113             foreach ($studentroles as $studentrole) {
2114                 assign_capability('mod/data:viewrating', CAP_ALLOW, $studentrole->id, $context->id);
2115             }
2116             foreach ($teacherroles as $teacherrole) {
2117                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2118             }
2119             break;
2120     }
2122     if (empty($cm)) {
2123         $cm = $DB->get_record('course_modules', array('id'=>$cmid));
2124     }
2126     switch ($cm->groupmode) {
2127         case NOGROUPS:
2128             break;
2129         case SEPARATEGROUPS:
2130             foreach ($studentroles as $studentrole) {
2131                 assign_capability('moodle/site:accessallgroups', CAP_PREVENT, $studentrole->id, $context->id);
2132             }
2133             foreach ($teacherroles as $teacherrole) {
2134                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2135             }
2136             break;
2137         case VISIBLEGROUPS:
2138             foreach ($studentroles as $studentrole) {
2139                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $studentrole->id, $context->id);
2140             }
2141             foreach ($teacherroles as $teacherrole) {
2142                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2143             }
2144             break;
2145     }
2146     return true;
2149 /**
2150  * Returns the best name to show for a preset
2151  *
2152  * @param string $shortname
2153  * @param  string $path
2154  * @return string
2155  */
2156 function data_preset_name($shortname, $path) {
2158     // We are looking inside the preset itself as a first choice, but also in normal data directory
2159     $string = get_string('modulename', 'datapreset_'.$shortname);
2161     if (substr($string, 0, 1) == '[') {
2162         return $shortname;
2163     } else {
2164         return $string;
2165     }
2168 /**
2169  * Returns an array of all the available presets.
2170  *
2171  * @return array
2172  */
2173 function data_get_available_presets($context) {
2174     global $CFG, $USER;
2176     $presets = array();
2178     // First load the ratings sub plugins that exist within the modules preset dir
2179     if ($dirs = core_component::get_plugin_list('datapreset')) {
2180         foreach ($dirs as $dir=>$fulldir) {
2181             if (is_directory_a_preset($fulldir)) {
2182                 $preset = new stdClass();
2183                 $preset->path = $fulldir;
2184                 $preset->userid = 0;
2185                 $preset->shortname = $dir;
2186                 $preset->name = data_preset_name($dir, $fulldir);
2187                 if (file_exists($fulldir.'/screenshot.jpg')) {
2188                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.jpg';
2189                 } else if (file_exists($fulldir.'/screenshot.png')) {
2190                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.png';
2191                 } else if (file_exists($fulldir.'/screenshot.gif')) {
2192                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.gif';
2193                 }
2194                 $presets[] = $preset;
2195             }
2196         }
2197     }
2198     // Now add to that the site presets that people have saved
2199     $presets = data_get_available_site_presets($context, $presets);
2200     return $presets;
2203 /**
2204  * Gets an array of all of the presets that users have saved to the site.
2205  *
2206  * @param stdClass $context The context that we are looking from.
2207  * @param array $presets
2208  * @return array An array of presets
2209  */
2210 function data_get_available_site_presets($context, array $presets=array()) {
2211     global $USER;
2213     $fs = get_file_storage();
2214     $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2215     $canviewall = has_capability('mod/data:viewalluserpresets', $context);
2216     if (empty($files)) {
2217         return $presets;
2218     }
2219     foreach ($files as $file) {
2220         if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory() || (!$canviewall && $file->get_userid() != $USER->id)) {
2221             continue;
2222         }
2223         $preset = new stdClass;
2224         $preset->path = $file->get_filepath();
2225         $preset->name = trim($preset->path, '/');
2226         $preset->shortname = $preset->name;
2227         $preset->userid = $file->get_userid();
2228         $preset->id = $file->get_id();
2229         $preset->storedfile = $file;
2230         $presets[] = $preset;
2231     }
2232     return $presets;
2235 /**
2236  * Deletes a saved preset.
2237  *
2238  * @param string $name
2239  * @return bool
2240  */
2241 function data_delete_site_preset($name) {
2242     $fs = get_file_storage();
2244     $files = $fs->get_directory_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/');
2245     if (!empty($files)) {
2246         foreach ($files as $file) {
2247             $file->delete();
2248         }
2249     }
2251     $dir = $fs->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/', '.');
2252     if (!empty($dir)) {
2253         $dir->delete();
2254     }
2255     return true;
2258 /**
2259  * Prints the heads for a page
2260  *
2261  * @param stdClass $course
2262  * @param stdClass $cm
2263  * @param stdClass $data
2264  * @param string $currenttab
2265  */
2266 function data_print_header($course, $cm, $data, $currenttab='') {
2268     global $CFG, $displaynoticegood, $displaynoticebad, $OUTPUT, $PAGE;
2270     $PAGE->set_title($data->name);
2271     echo $OUTPUT->header();
2272     echo $OUTPUT->heading(format_string($data->name), 2);
2273     echo $OUTPUT->box(format_module_intro('data', $data, $cm->id), 'generalbox', 'intro');
2275     // Groups needed for Add entry tab
2276     $currentgroup = groups_get_activity_group($cm);
2277     $groupmode = groups_get_activity_groupmode($cm);
2279     // Print the tabs
2281     if ($currenttab) {
2282         include('tabs.php');
2283     }
2285     // Print any notices
2287     if (!empty($displaynoticegood)) {
2288         echo $OUTPUT->notification($displaynoticegood, 'notifysuccess');    // good (usually green)
2289     } else if (!empty($displaynoticebad)) {
2290         echo $OUTPUT->notification($displaynoticebad);                     // bad (usuually red)
2291     }
2294 /**
2295  * Can user add more entries?
2296  *
2297  * @param object $data
2298  * @param mixed $currentgroup
2299  * @param int $groupmode
2300  * @param stdClass $context
2301  * @return bool
2302  */
2303 function data_user_can_add_entry($data, $currentgroup, $groupmode, $context = null) {
2304     global $USER;
2306     if (empty($context)) {
2307         $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
2308         $context = context_module::instance($cm->id);
2309     }
2311     if (has_capability('mod/data:manageentries', $context)) {
2312         // no entry limits apply if user can manage
2314     } else if (!has_capability('mod/data:writeentry', $context)) {
2315         return false;
2317     } else if (data_atmaxentries($data)) {
2318         return false;
2319     } else if (data_in_readonly_period($data)) {
2320         // Check whether we're in a read-only period
2321         return false;
2322     }
2324     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
2325         return true;
2326     }
2328     if ($currentgroup) {
2329         return groups_is_member($currentgroup);
2330     } else {
2331         //else it might be group 0 in visible mode
2332         if ($groupmode == VISIBLEGROUPS){
2333             return true;
2334         } else {
2335             return false;
2336         }
2337     }
2340 /**
2341  * Check whether the current user is allowed to manage the given record considering manageentries capability,
2342  * data_in_readonly_period() result, ownership (determined by data_isowner()) and manageapproved setting.
2343  * @param mixed $record record object or id
2344  * @param object $data data object
2345  * @param object $context context object
2346  * @return bool returns true if the user is allowd to edit the entry, false otherwise
2347  */
2348 function data_user_can_manage_entry($record, $data, $context) {
2349     global $DB;
2351     if (has_capability('mod/data:manageentries', $context)) {
2352         return true;
2353     }
2355     // Check whether this activity is read-only at present.
2356     $readonly = data_in_readonly_period($data);
2358     if (!$readonly) {
2359         // Get record object from db if just id given like in data_isowner.
2360         // ...done before calling data_isowner() to avoid querying db twice.
2361         if (!is_object($record)) {
2362             if (!$record = $DB->get_record('data_records', array('id' => $record))) {
2363                 return false;
2364             }
2365         }
2366         if (data_isowner($record)) {
2367             if ($data->approval && $record->approved) {
2368                 return $data->manageapproved == 1;
2369             } else {
2370                 return true;
2371             }
2372         }
2373     }
2375     return false;
2378 /**
2379  * Check whether the specified database activity is currently in a read-only period
2380  *
2381  * @param object $data
2382  * @return bool returns true if the time fields in $data indicate a read-only period; false otherwise
2383  */
2384 function data_in_readonly_period($data) {
2385     $now = time();
2386     if (!$data->timeviewfrom && !$data->timeviewto) {
2387         return false;
2388     } else if (($data->timeviewfrom && $now < $data->timeviewfrom) || ($data->timeviewto && $now > $data->timeviewto)) {
2389         return false;
2390     }
2391     return true;
2394 /**
2395  * @return bool
2396  */
2397 function is_directory_a_preset($directory) {
2398     $directory = rtrim($directory, '/\\') . '/';
2399     $status = file_exists($directory.'singletemplate.html') &&
2400               file_exists($directory.'listtemplate.html') &&
2401               file_exists($directory.'listtemplateheader.html') &&
2402               file_exists($directory.'listtemplatefooter.html') &&
2403               file_exists($directory.'addtemplate.html') &&
2404               file_exists($directory.'rsstemplate.html') &&
2405               file_exists($directory.'rsstitletemplate.html') &&
2406               file_exists($directory.'csstemplate.css') &&
2407               file_exists($directory.'jstemplate.js') &&
2408               file_exists($directory.'preset.xml');
2410     return $status;
2413 /**
2414  * Abstract class used for data preset importers
2415  */
2416 abstract class data_preset_importer {
2418     protected $course;
2419     protected $cm;
2420     protected $module;
2421     protected $directory;
2423     /**
2424      * Constructor
2425      *
2426      * @param stdClass $course
2427      * @param stdClass $cm
2428      * @param stdClass $module
2429      * @param string $directory
2430      */
2431     public function __construct($course, $cm, $module, $directory) {
2432         $this->course = $course;
2433         $this->cm = $cm;
2434         $this->module = $module;
2435         $this->directory = $directory;
2436     }
2438     /**
2439      * Returns the name of the directory the preset is located in
2440      * @return string
2441      */
2442     public function get_directory() {
2443         return basename($this->directory);
2444     }
2446     /**
2447      * Retreive the contents of a file. That file may either be in a conventional directory of the Moodle file storage
2448      * @param file_storage $filestorage. should be null if using a conventional directory
2449      * @param stored_file $fileobj the directory to look in. null if using a conventional directory
2450      * @param string $dir the directory to look in. null if using the Moodle file storage
2451      * @param string $filename the name of the file we want
2452      * @return string the contents of the file or null if the file doesn't exist.
2453      */
2454     public function data_preset_get_file_contents(&$filestorage, &$fileobj, $dir, $filename) {
2455         if(empty($filestorage) || empty($fileobj)) {
2456             if (substr($dir, -1)!='/') {
2457                 $dir .= '/';
2458             }
2459             if (file_exists($dir.$filename)) {
2460                 return file_get_contents($dir.$filename);
2461             } else {
2462                 return null;
2463             }
2464         } else {
2465             if ($filestorage->file_exists(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename)) {
2466                 $file = $filestorage->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename);
2467                 return $file->get_content();
2468             } else {
2469                 return null;
2470             }
2471         }
2473     }
2474     /**
2475      * Gets the preset settings
2476      * @global moodle_database $DB
2477      * @return stdClass
2478      */
2479     public function get_preset_settings() {
2480         global $DB;
2482         $fs = $fileobj = null;
2483         if (!is_directory_a_preset($this->directory)) {
2484             //maybe the user requested a preset stored in the Moodle file storage
2486             $fs = get_file_storage();
2487             $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2489             //preset name to find will be the final element of the directory
2490             $explodeddirectory = explode('/', $this->directory);
2491             $presettofind = end($explodeddirectory);
2493             //now go through the available files available and see if we can find it
2494             foreach ($files as $file) {
2495                 if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory()) {
2496                     continue;
2497                 }
2498                 $presetname = trim($file->get_filepath(), '/');
2499                 if ($presetname==$presettofind) {
2500                     $this->directory = $presetname;
2501                     $fileobj = $file;
2502                 }
2503             }
2505             if (empty($fileobj)) {
2506                 print_error('invalidpreset', 'data', '', $this->directory);
2507             }
2508         }
2510         $allowed_settings = array(
2511             'intro',
2512             'comments',
2513             'requiredentries',
2514             'requiredentriestoview',
2515             'maxentries',
2516             'rssarticles',
2517             'approval',
2518             'defaultsortdir',
2519             'defaultsort');
2521         $result = new stdClass;
2522         $result->settings = new stdClass;
2523         $result->importfields = array();
2524         $result->currentfields = $DB->get_records('data_fields', array('dataid'=>$this->module->id));
2525         if (!$result->currentfields) {
2526             $result->currentfields = array();
2527         }
2530         /* Grab XML */
2531         $presetxml = $this->data_preset_get_file_contents($fs, $fileobj, $this->directory,'preset.xml');
2532         $parsedxml = xmlize($presetxml, 0);
2534         /* First, do settings. Put in user friendly array. */
2535         $settingsarray = $parsedxml['preset']['#']['settings'][0]['#'];
2536         $result->settings = new StdClass();
2537         foreach ($settingsarray as $setting => $value) {
2538             if (!is_array($value) || !in_array($setting, $allowed_settings)) {
2539                 // unsupported setting
2540                 continue;
2541             }
2542             $result->settings->$setting = $value[0]['#'];
2543         }
2545         /* Now work out fields to user friendly array */
2546         $fieldsarray = $parsedxml['preset']['#']['field'];
2547         foreach ($fieldsarray as $field) {
2548             if (!is_array($field)) {
2549                 continue;
2550             }
2551             $f = new StdClass();
2552             foreach ($field['#'] as $param => $value) {
2553                 if (!is_array($value)) {
2554                     continue;
2555                 }
2556                 $f->$param = $value[0]['#'];
2557             }
2558             $f->dataid = $this->module->id;
2559             $f->type = clean_param($f->type, PARAM_ALPHA);
2560             $result->importfields[] = $f;
2561         }
2562         /* Now add the HTML templates to the settings array so we can update d */
2563         $result->settings->singletemplate     = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"singletemplate.html");
2564         $result->settings->listtemplate       = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplate.html");
2565         $result->settings->listtemplateheader = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplateheader.html");
2566         $result->settings->listtemplatefooter = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplatefooter.html");
2567         $result->settings->addtemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"addtemplate.html");
2568         $result->settings->rsstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstemplate.html");
2569         $result->settings->rsstitletemplate   = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstitletemplate.html");
2570         $result->settings->csstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"csstemplate.css");
2571         $result->settings->jstemplate         = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"jstemplate.js");
2572         $result->settings->asearchtemplate    = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"asearchtemplate.html");
2574         $result->settings->instance = $this->module->id;
2575         return $result;
2576     }
2578     /**
2579      * Import the preset into the given database module
2580      * @return bool
2581      */
2582     function import($overwritesettings) {
2583         global $DB, $CFG;
2585         $params = $this->get_preset_settings();
2586         $settings = $params->settings;
2587         $newfields = $params->importfields;
2588         $currentfields = $params->currentfields;
2589         $preservedfields = array();
2591         /* Maps fields and makes new ones */
2592         if (!empty($newfields)) {
2593             /* We require an injective mapping, and need to know what to protect */
2594             foreach ($newfields as $nid => $newfield) {
2595                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2596                 if ($cid == -1) {
2597                     continue;
2598                 }
2599                 if (array_key_exists($cid, $preservedfields)){
2600                     print_error('notinjectivemap', 'data');
2601                 }
2602                 else $preservedfields[$cid] = true;
2603             }
2605             foreach ($newfields as $nid => $newfield) {
2606                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2608                 /* A mapping. Just need to change field params. Data kept. */
2609                 if ($cid != -1 and isset($currentfields[$cid])) {
2610                     $fieldobject = data_get_field_from_id($currentfields[$cid]->id, $this->module);
2611                     foreach ($newfield as $param => $value) {
2612                         if ($param != "id") {
2613                             $fieldobject->field->$param = $value;
2614                         }
2615                     }
2616                     unset($fieldobject->field->similarfield);
2617                     $fieldobject->update_field();
2618                     unset($fieldobject);
2619                 } else {
2620                     /* Make a new field */
2621                     include_once("field/$newfield->type/field.class.php");
2623                     if (!isset($newfield->description)) {
2624                         $newfield->description = '';
2625                     }
2626                     $classname = 'data_field_'.$newfield->type;
2627                     $fieldclass = new $classname($newfield, $this->module);
2628                     $fieldclass->insert_field();
2629                     unset($fieldclass);
2630                 }
2631             }
2632         }
2634         /* Get rid of all old unused data */
2635         if (!empty($preservedfields)) {
2636             foreach ($currentfields as $cid => $currentfield) {
2637                 if (!array_key_exists($cid, $preservedfields)) {
2638                     /* Data not used anymore so wipe! */
2639                     print "Deleting field $currentfield->name<br />";
2641                     $id = $currentfield->id;
2642                     //Why delete existing data records and related comments/ratings??
2643                     $DB->delete_records('data_content', array('fieldid'=>$id));
2644                     $DB->delete_records('data_fields', array('id'=>$id));
2645                 }
2646             }
2647         }
2649         // handle special settings here
2650         if (!empty($settings->defaultsort)) {
2651             if (is_numeric($settings->defaultsort)) {
2652                 // old broken value
2653                 $settings->defaultsort = 0;
2654             } else {
2655                 $settings->defaultsort = (int)$DB->get_field('data_fields', 'id', array('dataid'=>$this->module->id, 'name'=>$settings->defaultsort));
2656             }
2657         } else {
2658             $settings->defaultsort = 0;
2659         }
2661         // do we want to overwrite all current database settings?
2662         if ($overwritesettings) {
2663             // all supported settings
2664             $overwrite = array_keys((array)$settings);
2665         } else {
2666             // only templates and sorting
2667             $overwrite = array('singletemplate', 'listtemplate', 'listtemplateheader', 'listtemplatefooter',
2668                                'addtemplate', 'rsstemplate', 'rsstitletemplate', 'csstemplate', 'jstemplate',
2669                                'asearchtemplate', 'defaultsortdir', 'defaultsort');
2670         }
2672         // now overwrite current data settings
2673         foreach ($this->module as $prop=>$unused) {
2674             if (in_array($prop, $overwrite)) {
2675                 $this->module->$prop = $settings->$prop;
2676             }
2677         }
2679         data_update_instance($this->module);
2681         return $this->cleanup();
2682     }
2684     /**
2685      * Any clean up routines should go here
2686      * @return bool
2687      */
2688     public function cleanup() {
2689         return true;
2690     }
2693 /**
2694  * Data preset importer for uploaded presets
2695  */
2696 class data_preset_upload_importer extends data_preset_importer {
2697     public function __construct($course, $cm, $module, $filepath) {
2698         global $USER;
2699         if (is_file($filepath)) {
2700             $fp = get_file_packer();
2701             if ($fp->extract_to_pathname($filepath, $filepath.'_extracted')) {
2702                 fulldelete($filepath);
2703             }
2704             $filepath .= '_extracted';
2705         }
2706         parent::__construct($course, $cm, $module, $filepath);
2707     }
2708     public function cleanup() {
2709         return fulldelete($this->directory);
2710     }
2713 /**
2714  * Data preset importer for existing presets
2715  */
2716 class data_preset_existing_importer extends data_preset_importer {
2717     protected $userid;
2718     public function __construct($course, $cm, $module, $fullname) {
2719         global $USER;
2720         list($userid, $shortname) = explode('/', $fullname, 2);
2721         $context = context_module::instance($cm->id);
2722         if ($userid && ($userid != $USER->id) && !has_capability('mod/data:manageuserpresets', $context) && !has_capability('mod/data:viewalluserpresets', $context)) {
2723            throw new coding_exception('Invalid preset provided');
2724         }
2726         $this->userid = $userid;
2727         $filepath = data_preset_path($course, $userid, $shortname);
2728         parent::__construct($course, $cm, $module, $filepath);
2729     }
2730     public function get_userid() {
2731         return $this->userid;
2732     }
2735 /**
2736  * @global object
2737  * @global object
2738  * @param object $course
2739  * @param int $userid
2740  * @param string $shortname
2741  * @return string
2742  */
2743 function data_preset_path($course, $userid, $shortname) {
2744     global $USER, $CFG;
2746     $context = context_course::instance($course->id);
2748     $userid = (int)$userid;
2750     $path = null;
2751     if ($userid > 0 && ($userid == $USER->id || has_capability('mod/data:viewalluserpresets', $context))) {
2752         $path = $CFG->dataroot.'/data/preset/'.$userid.'/'.$shortname;
2753     } else if ($userid == 0) {
2754         $path = $CFG->dirroot.'/mod/data/preset/'.$shortname;
2755     } else if ($userid < 0) {
2756         $path = $CFG->tempdir.'/data/'.-$userid.'/'.$shortname;
2757     }
2759     return $path;
2762 /**
2763  * Implementation of the function for printing the form elements that control
2764  * whether the course reset functionality affects the data.
2765  *
2766  * @param $mform form passed by reference
2767  */
2768 function data_reset_course_form_definition(&$mform) {
2769     $mform->addElement('header', 'dataheader', get_string('modulenameplural', 'data'));
2770     $mform->addElement('checkbox', 'reset_data', get_string('deleteallentries','data'));
2772     $mform->addElement('checkbox', 'reset_data_notenrolled', get_string('deletenotenrolled', 'data'));
2773     $mform->disabledIf('reset_data_notenrolled', 'reset_data', 'checked');
2775     $mform->addElement('checkbox', 'reset_data_ratings', get_string('deleteallratings'));
2776     $mform->disabledIf('reset_data_ratings', 'reset_data', 'checked');
2778     $mform->addElement('checkbox', 'reset_data_comments', get_string('deleteallcomments'));
2779     $mform->disabledIf('reset_data_comments', 'reset_data', 'checked');
2782 /**
2783  * Course reset form defaults.
2784  * @return array
2785  */
2786 function data_reset_course_form_defaults($course) {
2787     return array('reset_data'=>0, 'reset_data_ratings'=>1, 'reset_data_comments'=>1, 'reset_data_notenrolled'=>0);
2790 /**
2791  * Removes all grades from gradebook
2792  *
2793  * @global object
2794  * @global object
2795  * @param int $courseid
2796  * @param string $type optional type
2797  */
2798 function data_reset_gradebook($courseid, $type='') {
2799     global $CFG, $DB;
2801     $sql = "SELECT d.*, cm.idnumber as cmidnumber, d.course as courseid
2802               FROM {data} d, {course_modules} cm, {modules} m
2803              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id AND d.course=?";
2805     if ($datas = $DB->get_records_sql($sql, array($courseid))) {
2806         foreach ($datas as $data) {
2807             data_grade_item_update($data, 'reset');
2808         }
2809     }
2812 /**
2813  * Actual implementation of the reset course functionality, delete all the
2814  * data responses for course $data->courseid.
2815  *
2816  * @global object
2817  * @global object
2818  * @param object $data the data submitted from the reset course.
2819  * @return array status array
2820  */
2821 function data_reset_userdata($data) {
2822     global $CFG, $DB;
2823     require_once($CFG->libdir.'/filelib.php');
2824     require_once($CFG->dirroot.'/rating/lib.php');
2826     $componentstr = get_string('modulenameplural', 'data');
2827     $status = array();
2829     $allrecordssql = "SELECT r.id
2830                         FROM {data_records} r
2831                              INNER JOIN {data} d ON r.dataid = d.id
2832                        WHERE d.course = ?";
2834     $alldatassql = "SELECT d.id
2835                       FROM {data} d
2836                      WHERE d.course=?";
2838     $rm = new rating_manager();
2839     $ratingdeloptions = new stdClass;
2840     $ratingdeloptions->component = 'mod_data';
2841     $ratingdeloptions->ratingarea = 'entry';
2843     // Set the file storage - may need it to remove files later.
2844     $fs = get_file_storage();
2846     // delete entries if requested
2847     if (!empty($data->reset_data)) {
2848         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2849         $DB->delete_records_select('data_content', "recordid IN ($allrecordssql)", array($data->courseid));
2850         $DB->delete_records_select('data_records', "dataid IN ($alldatassql)", array($data->courseid));
2852         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2853             foreach ($datas as $dataid=>$unused) {
2854                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2855                     continue;
2856                 }
2857                 $datacontext = context_module::instance($cm->id);
2859                 // Delete any files that may exist.
2860                 $fs->delete_area_files($datacontext->id, 'mod_data', 'content');
2862                 $ratingdeloptions->contextid = $datacontext->id;
2863                 $rm->delete_ratings($ratingdeloptions);
2864             }
2865         }
2867         if (empty($data->reset_gradebook_grades)) {
2868             // remove all grades from gradebook
2869             data_reset_gradebook($data->courseid);
2870         }
2871         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallentries', 'data'), 'error'=>false);
2872     }
2874     // remove entries by users not enrolled into course
2875     if (!empty($data->reset_data_notenrolled)) {
2876         $recordssql = "SELECT r.id, r.userid, r.dataid, u.id AS userexists, u.deleted AS userdeleted
2877                          FROM {data_records} r
2878                               JOIN {data} d ON r.dataid = d.id
2879                               LEFT JOIN {user} u ON r.userid = u.id
2880                         WHERE d.course = ? AND r.userid > 0";
2882         $course_context = context_course::instance($data->courseid);
2883         $notenrolled = array();
2884         $fields = array();
2885         $rs = $DB->get_recordset_sql($recordssql, array($data->courseid));
2886         foreach ($rs as $record) {
2887             if (array_key_exists($record->userid, $notenrolled) or !$record->userexists or $record->userdeleted
2888               or !is_enrolled($course_context, $record->userid)) {
2889                 //delete ratings
2890                 if (!$cm = get_coursemodule_from_instance('data', $record->dataid)) {
2891                     continue;
2892                 }
2893                 $datacontext = context_module::instance($cm->id);
2894                 $ratingdeloptions->contextid = $datacontext->id;
2895                 $ratingdeloptions->itemid = $record->id;
2896                 $rm->delete_ratings($ratingdeloptions);
2898                 // Delete any files that may exist.
2899                 if ($contents = $DB->get_records('data_content', array('recordid' => $record->id), '', 'id')) {
2900                     foreach ($contents as $content) {
2901                         $fs->delete_area_files($datacontext->id, 'mod_data', 'content', $content->id);
2902                     }
2903                 }
2904                 $notenrolled[$record->userid] = true;
2906                 $DB->delete_records('comments', array('itemid' => $record->id, 'commentarea' => 'database_entry'));
2907                 $DB->delete_records('data_content', array('recordid' => $record->id));
2908                 $DB->delete_records('data_records', array('id' => $record->id));
2909             }
2910         }
2911         $rs->close();
2912         $status[] = array('component'=>$componentstr, 'item'=>get_string('deletenotenrolled', 'data'), 'error'=>false);
2913     }
2915     // remove all ratings
2916     if (!empty($data->reset_data_ratings)) {
2917         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2918             foreach ($datas as $dataid=>$unused) {
2919                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2920                     continue;
2921                 }
2922                 $datacontext = context_module::instance($cm->id);
2924                 $ratingdeloptions->contextid = $datacontext->id;
2925                 $rm->delete_ratings($ratingdeloptions);
2926             }
2927         }
2929         if (empty($data->reset_gradebook_grades)) {
2930             // remove all grades from gradebook
2931             data_reset_gradebook($data->courseid);
2932         }
2934         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallratings'), 'error'=>false);
2935     }
2937     // remove all comments
2938     if (!empty($data->reset_data_comments)) {
2939         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2940         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallcomments'), 'error'=>false);
2941     }
2943     // updating dates - shift may be negative too
2944     if ($data->timeshift) {
2945         // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
2946         // See MDL-9367.
2947         shift_course_mod_dates('data', array('timeavailablefrom', 'timeavailableto',
2948             'timeviewfrom', 'timeviewto', 'assesstimestart', 'assesstimefinish'), $data->timeshift, $data->courseid);
2949         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
2950     }
2952     return $status;
2955 /**
2956  * Returns all other caps used in module
2957  *
2958  * @return array
2959  */
2960 function data_get_extra_capabilities() {
2961     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');
2964 /**
2965  * @param string $feature FEATURE_xx constant for requested feature
2966  * @return mixed True if module supports feature, null if doesn't know
2967  */
2968 function data_supports($feature) {
2969     switch($feature) {
2970         case FEATURE_GROUPS:                  return true;
2971         case FEATURE_GROUPINGS:               return true;
2972         case FEATURE_MOD_INTRO:               return true;
2973         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
2974         case FEATURE_COMPLETION_HAS_RULES:    return true;
2975         case FEATURE_GRADE_HAS_GRADE:         return true;
2976         case FEATURE_GRADE_OUTCOMES:          return true;
2977         case FEATURE_RATE:                    return true;
2978         case FEATURE_BACKUP_MOODLE2:          return true;
2979         case FEATURE_SHOW_DESCRIPTION:        return true;
2980         case FEATURE_COMMENT:                 return true;
2982         default: return null;
2983     }
2985 /**
2986  * @global object
2987  * @param array $export
2988  * @param string $delimiter_name
2989  * @param object $database
2990  * @param int $count
2991  * @param bool $return
2992  * @return string|void
2993  */
2994 function data_export_csv($export, $delimiter_name, $database, $count, $return=false) {
2995     global $CFG;
2996     require_once($CFG->libdir . '/csvlib.class.php');
2998     $filename = $database . '-' . $count . '-record';
2999     if ($count > 1) {
3000         $filename .= 's';
3001     }
3002     if ($return) {
3003         return csv_export_writer::print_array($export, $delimiter_name, '"', true);
3004     } else {
3005         csv_export_writer::download_array($filename, $export, $delimiter_name);
3006     }
3009 /**
3010  * @global object
3011  * @param array $export
3012  * @param string $dataname
3013  * @param int $count
3014  * @return string
3015  */
3016 function data_export_xls($export, $dataname, $count) {
3017     global $CFG;
3018     require_once("$CFG->libdir/excellib.class.php");
3019     $filename = clean_filename("{$dataname}-{$count}_record");
3020     if ($count > 1) {
3021         $filename .= 's';
3022     }
3023     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
3024     $filename .= '.xls';
3026     $filearg = '-';
3027     $workbook = new MoodleExcelWorkbook($filearg);
3028     $workbook->send($filename);
3029     $worksheet = array();
3030     $worksheet[0] = $workbook->add_worksheet('');
3031     $rowno = 0;
3032     foreach ($export as $row) {
3033         $colno = 0;
3034         foreach($row as $col) {
3035             $worksheet[0]->write($rowno, $colno, $col);
3036             $colno++;
3037         }
3038         $rowno++;
3039     }
3040     $workbook->close();
3041     return $filename;
3044 /**
3045  * @global object
3046  * @param array $export
3047  * @param string $dataname
3048  * @param int $count
3049  * @param string
3050  */
3051 function data_export_ods($export, $dataname, $count) {
3052     global $CFG;
3053     require_once("$CFG->libdir/odslib.class.php");
3054     $filename = clean_filename("{$dataname}-{$count}_record");
3055     if ($count > 1) {
3056         $filename .= 's';
3057     }
3058     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
3059     $filename .= '.ods';
3060     $filearg = '-';
3061     $workbook = new MoodleODSWorkbook($filearg);
3062     $workbook->send($filename);
3063     $worksheet = array();
3064     $worksheet[0] = $workbook->add_worksheet('');
3065     $rowno = 0;
3066     foreach ($export as $row) {
3067         $colno = 0;
3068         foreach($row as $col) {
3069             $worksheet[0]->write($rowno, $colno, $col);
3070             $colno++;
3071         }
3072         $rowno++;
3073     }
3074     $workbook->close();
3075     return $filename;
3078 /**
3079  * @global object
3080  * @param int $dataid
3081  * @param array $fields
3082  * @param array $selectedfields
3083  * @param int $currentgroup group ID of the current group. This is used for
3084  * exporting data while maintaining group divisions.
3085  * @param object $context the context in which the operation is performed (for capability checks)
3086  * @param bool $userdetails whether to include the details of the record author
3087  * @param bool $time whether to include time created/modified
3088  * @param bool $approval whether to include approval status
3089  * @return array
3090  */
3091 function data_get_exportdata($dataid, $fields, $selectedfields, $currentgroup=0, $context=null,
3092                              $userdetails=false, $time=false, $approval=false) {
3093     global $DB;
3095     if (is_null($context)) {
3096         $context = context_system::instance();
3097     }
3098     // exporting user data needs special permission
3099     $userdetails = $userdetails && has_capability('mod/data:exportuserinfo', $context);
3101     $exportdata = array();
3103     // populate the header in first row of export
3104     foreach($fields as $key => $field) {
3105         if (!in_array($field->field->id, $selectedfields)) {
3106             // ignore values we aren't exporting
3107             unset($fields[$key]);
3108         } else {
3109             $exportdata[0][] = $field->field->name;
3110         }
3111     }
3112     if ($userdetails) {
3113         $exportdata[0][] = get_string('user');
3114         $exportdata[0][] = get_string('username');
3115         $exportdata[0][] = get_string('email');
3116     }
3117     if ($time) {
3118         $exportdata[0][] = get_string('timeadded', 'data');
3119         $exportdata[0][] = get_string('timemodified', 'data');
3120     }
3121     if ($approval) {
3122         $exportdata[0][] = get_string('approved', 'data');
3123     }
3125     $datarecords = $DB->get_records('data_records', array('dataid'=>$dataid));
3126     ksort($datarecords);
3127     $line = 1;
3128     foreach($datarecords as $record) {
3129         // get content indexed by fieldid
3130         if ($currentgroup) {
3131             $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 = ?';
3132             $where = array($record->id, $currentgroup);
3133         } else {
3134             $select = 'SELECT fieldid, content, content1, content2, content3, content4 FROM {data_content} WHERE recordid = ?';
3135             $where = array($record->id);
3136         }
3138         if( $content = $DB->get_records_sql($select, $where) ) {
3139             foreach($fields as $field) {
3140                 $contents = '';
3141                 if(isset($content[$field->field->id])) {
3142                     $contents = $field->export_text_value($content[$field->field->id]);
3143                 }
3144                 $exportdata[$line][] = $contents;
3145             }
3146             if ($userdetails) { // Add user details to the export data
3147                 $userdata = get_complete_user_data('id', $record->userid);
3148                 $exportdata[$line][] = fullname($userdata);
3149                 $exportdata[$line][] = $userdata->username;
3150                 $exportdata[$line][] = $userdata->email;
3151             }
3152             if ($time) { // Add time added / modified
3153                 $exportdata[$line][] = userdate($record->timecreated);
3154                 $exportdata[$line][] = userdate($record->timemodified);
3155             }
3156             if ($approval) { // Add approval status
3157                 $exportdata[$line][] = (int) $record->approved;
3158             }
3159         }
3160         $line++;
3161     }
3162     $line--;
3163     return $exportdata;
3166 ////////////////////////////////////////////////////////////////////////////////
3167 // File API                                                                   //
3168 ////////////////////////////////////////////////////////////////////////////////
3170 /**
3171  * Lists all browsable file areas
3172  *
3173  * @package  mod_data
3174  * @category files
3175  * @param stdClass $course course object
3176  * @param stdClass $cm course module object
3177  * @param stdClass $context context object
3178  * @return array
3179  */
3180 function data_get_file_areas($course, $cm, $context) {
3181     return array('content' => get_string('areacontent', 'mod_data'));
3184 /**
3185  * File browsing support for data module.
3186  *
3187  * @param file_browser $browser
3188  * @param array $areas
3189  * @param stdClass $course
3190  * @param cm_info $cm
3191  * @param context $context
3192  * @param string $filearea
3193  * @param int $itemid
3194  * @param string $filepath
3195  * @param string $filename
3196  * @return file_info_stored file_info_stored instance or null if not found
3197  */
3198 function data_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
3199     global $CFG, $DB, $USER;
3201     if ($context->contextlevel != CONTEXT_MODULE) {
3202         return null;
3203     }
3205     if (!isset($areas[$filearea])) {
3206         return null;
3207     }
3209     if (is_null($itemid)) {
3210         require_once($CFG->dirroot.'/mod/data/locallib.php');
3211         return new data_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
3212     }
3214     if (!$content = $DB->get_record('data_content', array('id'=>$itemid))) {
3215         return null;
3216     }
3218     if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3219         return null;
3220     }
3222     if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3223         return null;
3224     }
3226     if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3227         return null;
3228     }
3230     //check if approved
3231     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3232         return null;
3233     }
3235     // group access
3236     if ($record->groupid) {
3237         $groupmode = groups_get_activity_groupmode($cm, $course);
3238         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3239             if (!groups_is_member($record->groupid)) {
3240                 return null;
3241             }
3242         }
3243     }
3245     $fieldobj = data_get_field($field, $data, $cm);
3247     $filepath = is_null($filepath) ? '/' : $filepath;
3248     $filename = is_null($filename) ? '.' : $filename;
3249     if (!$fieldobj->file_ok($filepath.$filename)) {
3250         return null;
3251     }
3253     $fs = get_file_storage();
3254     if (!($storedfile = $fs->get_file($context->id, 'mod_data', $filearea, $itemid, $filepath, $filename))) {
3255         return null;
3256     }
3258     // Checks to see if the user can manage files or is the owner.
3259     // TODO MDL-33805 - Do not use userid here and move the capability check above.
3260     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
3261         return null;
3262     }
3264     $urlbase = $CFG->wwwroot.'/pluginfile.php';
3266     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
3269 /**
3270  * Serves the data attachments. Implements needed access control ;-)
3271  *
3272  * @package  mod_data
3273  * @category files
3274  * @param stdClass $course course object
3275  * @param stdClass $cm course module object
3276  * @param stdClass $context context object
3277  * @param string $filearea file area
3278  * @param array $args extra arguments
3279  * @param bool $forcedownload whether or not force download
3280  * @param array $options additional options affecting the file serving
3281  * @return bool false if file not found, does not return if found - justsend the file
3282  */
3283 function data_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
3284     global $CFG, $DB;
3286     if ($context->contextlevel != CONTEXT_MODULE) {
3287         return false;
3288     }
3290     require_course_login($course, true, $cm);
3292     if ($filearea === 'content') {
3293         $contentid = (int)array_shift($args);
3295         if (!$content = $DB->get_record('data_content', array('id'=>$contentid))) {
3296             return false;
3297         }
3299         if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3300             return false;
3301         }
3303         if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3304             return false;
3305         }
3307         if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3308             return false;
3309         }
3311         if ($data->id != $cm->instance) {
3312             // hacker attempt - context does not match the contentid
3313             return false;
3314         }
3316         //check if approved
3317         if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3318             return false;
3319         }
3321         // group access
3322         if ($record->groupid) {
3323             $groupmode = groups_get_activity_groupmode($cm, $course);
3324             if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3325                 if (!groups_is_member($record->groupid)) {
3326                     return false;
3327                 }
3328             }
3329         }
3331         $fieldobj = data_get_field($field, $data, $cm);
3333         $relativepath = implode('/', $args);
3334         $fullpath = "/$context->id/mod_data/content/$content->id/$relativepath";
3336         if (!$fieldobj->file_ok($relativepath)) {
3337             return false;
3338         }
3340         $fs = get_file_storage();
3341         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
3342             return false;
3343         }
3345         // finally send the file
3346         send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
3347     }
3349     return false;
3353 function data_extend_navigation($navigation, $course, $module, $cm) {
3354     global $CFG, $OUTPUT, $USER, $DB;
3355     require_once($CFG->dirroot . '/mod/data/locallib.php');
3357     $rid = optional_param('rid', 0, PARAM_INT);
3359     $data = $DB->get_record('data', array('id'=>$cm->instance));
3360     $currentgroup = groups_get_activity_group($cm);
3361     $groupmode = groups_get_activity_groupmode($cm);
3363      $numentries = data_numentries($data);
3364     $canmanageentries = has_capability('mod/data:manageentries', context_module::instance($cm->id));
3366     if ($data->entriesleft = data_get_entries_left_to_add($data, $numentries, $canmanageentries)) {
3367         $entriesnode = $navigation->add(get_string('entrieslefttoadd', 'data', $data));
3368         $entriesnode->add_class('note');
3369     }
3371     $navigation->add(get_string('list', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance)));
3372     if (!empty($rid)) {
3373         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'rid'=>$rid)));
3374     } else {
3375         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'single')));
3376     }
3377     $navigation->add(get_string('search', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'asearch')));
3380 /**
3381  * Adds module specific settings to the settings block
3382  *
3383  * @param settings_navigation $settings The settings navigation object
3384  * @param navigation_node $datanode The node to add module settings to
3385  */
3386 function data_extend_settings_navigation(settings_navigation $settings, navigation_node $datanode) {
3387     global $PAGE, $DB, $CFG, $USER;
3389     $data = $DB->get_record('data', array("id" => $PAGE->cm->instance));
3391     $currentgroup = groups_get_activity_group($PAGE->cm);
3392     $groupmode = groups_get_activity_groupmode($PAGE->cm);
3394     if (data_user_can_add_entry($data, $currentgroup, $groupmode, $PAGE->cm->context)) { // took out participation list here!
3395         if (empty($editentry)) { //TODO: undefined
3396             $addstring = get_string('add', 'data');
3397         } else {
3398             $addstring = get_string('editentry', 'data');
3399         }
3400         $datanode->add($addstring, new moodle_url('/mod/data/edit.php', array('d'=>$PAGE->cm->instance)));
3401     }
3403     if (has_capability(DATA_CAP_EXPORT, $PAGE->cm->context)) {
3404         // The capability required to Export database records is centrally defined in 'lib.php'
3405         // and should be weaker than those required to edit Templates, Fields and Presets.
3406         $datanode->add(get_string('exportentries', 'data'), new moodle_url('/mod/data/export.php', array('d'=>$data->id)));
3407     }
3408     if (has_capability('mod/data:manageentries', $PAGE->cm->context)) {
3409         $datanode->add(get_string('importentries', 'data'), new moodle_url('/mod/data/import.php', array('d'=>$data->id)));
3410     }
3412     if (has_capability('mod/data:managetemplates', $PAGE->cm->context)) {
3413         $currenttab = '';
3414         if ($currenttab == 'list') {
3415             $defaultemplate = 'listtemplate';
3416         } else if ($currenttab == 'add') {
3417             $defaultemplate = 'addtemplate';
3418         } else if ($currenttab == 'asearch') {
3419             $defaultemplate = 'asearchtemplate';
3420         } else {
3421             $defaultemplate = 'singletemplate';
3422         }
3424         $templates = $datanode->add(get_string('templates', 'data'));
3426         $templatelist = array ('listtemplate', 'singletemplate', 'asearchtemplate', 'addtemplate', 'rsstemplate', 'csstemplate', 'jstemplate');
3427         foreach ($templatelist as $template) {
3428             $templates->add(get_string($template, 'data'), new moodle_url('/mod/data/templates.php', array('d'=>$data->id,'mode'=>$template)));
3429         }
3431         $datanode->add(get_string('fields', 'data'), new moodle_url('/mod/data/field.php', array('d'=>$data->id)));
3432         $datanode->add(get_string('presets', 'data'), new moodle_url('/mod/data/preset.php', array('d'=>$data->id)));
3433     }
3435     if (!empty($CFG->enablerssfeeds) && !empty($CFG->data_enablerssfeeds) && $data->rssarticles > 0) {
3436         require_once("$CFG->libdir/rsslib.php");
3438         $string = get_string('rsstype','forum');
3440         $url = new moodle_url(rss_get_url($PAGE->cm->context->id, $USER->id, 'mod_data', $data->id));
3441         $datanode->add($string, $url, settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
3442     }
3445 /**
3446  * Save the database configuration as a preset.
3447  *
3448  * @param stdClass $course The course the database module belongs to.
3449  * @param stdClass $cm The course module record
3450  * @param stdClass $data The database record
3451  * @param string $path
3452  * @return bool
3453  */
3454 function data_presets_save($course, $cm, $data, $path) {
3455     global $USER;
3456     $fs = get_file_storage();
3457     $filerecord = new stdClass;
3458     $filerecord->contextid = DATA_PRESET_CONTEXT;
3459     $filerecord->component = DATA_PRESET_COMPONENT;
3460     $filerecord->filearea = DATA_PRESET_FILEAREA;
3461     $filerecord->itemid = 0;
3462     $filerecord->filepath = '/'.$path.'/';
3463     $filerecord->userid = $USER->id;
3465     $filerecord->filename = 'preset.xml';
3466     $fs->create_file_from_string($filerecord, data_presets_generate_xml($course, $cm, $data));
3468     $filerecord->filename = 'singletemplate.html';
3469     $fs->create_file_from_string($filerecord, $data->singletemplate);
3471     $filerecord->filename = 'listtemplateheader.html';
3472     $fs->create_file_from_string($filerecord, $data->listtemplateheader);
3474     $filerecord->filename = 'listtemplate.html';
3475     $fs->create_file_from_string($filerecord, $data->listtemplate);
3477     $filerecord->filename = 'listtemplatefooter.html';
3478     $fs->create_file_from_string($filerecord, $data->listtemplatefooter);
3480     $filerecord->filename = 'addtemplate.html';
3481     $fs->create_file_from_string($filerecord, $data->addtemplate);
3483     $filerecord->filename = 'rsstemplate.html';
3484     $fs->create_file_from_string($filerecord, $data->rsstemplate);
3486     $filerecord->filename = 'rsstitletemplate.html';
3487     $fs->create_file_from_string($filerecord, $data->rsstitletemplate);
3489     $filerecord->filename = 'csstemplate.css';
3490     $fs->create_file_from_string($filerecord, $data->csstemplate);
3492     $filerecord->filename = 'jstemplate.js';
3493     $fs->create_file_from_string($filerecord, $data->jstemplate);
3495     $filerecord->filename = 'asearchtemplate.html';
3496     $fs->create_file_from_string($filerecord, $data->asearchtemplate);
3498     return true;
3501 /**
3502  * Generates the XML for the database module provided
3503  *
3504  * @global moodle_database $DB
3505  * @param stdClass $course The course the database module belongs to.
3506  * @param stdClass $cm The course module record
3507  * @param stdClass $data The database record
3508  * @return string The XML for the preset
3509  */
3510 function data_presets_generate_xml($course, $cm, $data) {
3511     global $DB;
3513     // Assemble "preset.xml":
3514     $presetxmldata = "<preset>\n\n";
3516     // Raw settings are not preprocessed during saving of presets
3517     $raw_settings = array(
3518         'intro',
3519         'comments',
3520         'requiredentries',
3521         'requiredentriestoview',
3522         'maxentries',
3523         'rssarticles',
3524         'approval',
3525         'manageapproved',
3526         'defaultsortdir'
3527     );
3529     $presetxmldata .= "<settings>\n";
3530     // First, settings that do not require any conversion
3531     foreach ($raw_settings as $setting) {
3532         $presetxmldata .= "<$setting>" . htmlspecialchars($data->$setting) . "</$setting>\n";
3533     }
3535     // Now specific settings
3536     if ($data->defaultsort > 0 && $sortfield = data_get_field_from_id($data->defaultsort, $data)) {
3537         $presetxmldata .= '<defaultsort>' . htmlspecialchars($sortfield->field->name) . "</defaultsort>\n";
3538     } else {
3539         $presetxmldata .= "<defaultsort>0</defaultsort>\n";
3540     }
3541     $presetxmldata .= "</settings>\n\n";
3542     // Now for the fields. Grab all that are non-empty
3543     $fields = $DB->get_records('data_fields', array('dataid'=>$data->id));
3544     ksort($fields);
3545     if (!empty($fields)) {
3546         foreach ($fields as $field) {
3547             $presetxmldata .= "<field>\n";
3548             foreach ($field as $key => $value) {
3549                 if ($value != '' && $key != 'id' && $key != 'dataid') {
3550                     $presetxmldata .= "<$key>" . htmlspecialchars($value) . "</$key>\n";
3551                 }
3552             }
3553             $presetxmldata .= "</field>\n\n";
3554         }
3555     }
3556     $presetxmldata .= '</preset>';
3557     return $presetxmldata;
3560 function data_presets_export($course, $cm, $data, $tostorage=false) {
3561     global $CFG, $DB;
3563     $presetname = clean_filename($data->name) . '-preset-' . gmdate("Ymd_Hi");
3564     $exportsubdir = "mod_data/presetexport/$presetname";
3565     make_temp_directory($exportsubdir);
3566     $exportdir = "$CFG->tempdir/$exportsubdir";
3568     // Assemble "preset.xml":
3569     $presetxmldata = data_presets_generate_xml($course, $cm, $data);
3571     // After opening a file in write mode, close it asap
3572     $presetxmlfile = fopen($exportdir . '/preset.xml', 'w');
3573     fwrite($presetxmlfile, $presetxmldata);
3574     fclose($presetxmlfile);
3576     // Now write the template files
3577     $singletemplate = fopen($exportdir . '/singletemplate.html', 'w');
3578     fwrite($singletemplate, $data->singletemplate);
3579     fclose($singletemplate);
3581     $listtemplateheader = fopen($exportdir . '/listtemplateheader.html', 'w');
3582     fwrite($listtemplateheader, $data->listtemplateheader);
3583     fclose($listtemplateheader);
3585     $listtemplate = fopen($exportdir . '/listtemplate.html', 'w');
3586     fwrite($listtemplate, $data->listtemplate);
3587     fclose($listtemplate);
3589     $listtemplatefooter = fopen($exportdir . '/listtemplatefooter.html', 'w');
3590     fwrite($listtemplatefooter, $data->listtemplatefooter);
3591     fclose($listtemplatefooter);
3593     $addtemplate = fopen($exportdir . '/addtemplate.html', 'w');
3594     fwrite($addtemplate, $data->addtemplate);
3595     fclose($addtemplate);
3597     $rsstemplate = fopen($exportdir . '/rsstemplate.html', 'w');
3598     fwrite($rsstemplate, $data->rsstemplate);
3599     fclose($rsstemplate);
3601     $rsstitletemplate = fopen($exportdir . '/rsstitletemplate.html', 'w');
3602     fwrite($rsstitletemplate, $data->rsstitletemplate);
3603     fclose($rsstitletemplate);
3605     $csstemplate = fopen($exportdir . '/csstemplate.css', 'w');
3606     fwrite($csstemplate, $data->csstemplate);
3607     fclose($csstemplate);
3609     $jstemplate = fopen($exportdir . '/jstemplate.js', 'w');
3610     fwrite($jstemplate, $data->jstemplate);
3611     fclose($jstemplate);
3613     $asearchtemplate = fopen($exportdir . '/asearchtemplate.html', 'w');
3614     fwrite($asearchtemplate, $data->asearchtemplate);
3615     fclose($asearchtemplate);
3617     // Check if all files have been generated
3618     if (! is_directory_a_preset($exportdir)) {
3619         print_error('generateerror', 'data');
3620     }
3622     $filenames = array(
3623         'preset.xml',
3624         'singletemplate.html',
3625         'listtemplateheader.html',
3626         'listtemplate.html',
3627         'listtemplatefooter.html',
3628         'addtemplate.html',
3629         'rsstemplate.html',
3630         'rsstitletemplate.html',
3631         'csstemplate.css',
3632         'jstemplate.js',
3633         'asearchtemplate.html'
3634     );
3636     $filelist = array();
3637     foreach ($filenames as $filename) {
3638         $filelist[$filename] = $exportdir . '/' . $filename;
3639     }
3641     $exportfile = $exportdir.'.zip';
3642     file_exists($exportfile) && unlink($exportfile);
3644     $fp = get_file_packer('application/zip');
3645     $fp->archive_to_pathname($filelist, $exportfile);
3647     foreach ($filelist as $file) {
3648         unlink($file);
3649     }
3650     rmdir($exportdir);
3652     // Return the full path to the exported preset file:
3653     return $exportfile;
3656 /**
3657  * Running addtional permission check on plugin, for example, plugins
3658  * may have switch to turn on/off comments option, this callback will
3659  * affect UI display, not like pluginname_comment_validate only throw
3660  * exceptions.
3661  * Capability check has been done in comment->check_permissions(), we
3662  * don't need to do it again here.
3663  *
3664  * @package  mod_data
3665  * @category comment
3666  *
3667  * @param stdClass $comment_param {
3668  *              context  => context the context object
3669  *              courseid => int course id
3670  *              cm       => stdClass course module object
3671  *              commentarea => string comment area
3672  *              itemid      => int itemid
3673  * }
3674  * @return array
3675  */
3676 function data_comment_permissions($comment_param) {
3677     global $CFG, $DB;
3678     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3679         throw new comment_exception('invalidcommentitemid');
3680     }
3681     if (!$data = $DB->get_record('data', a