MDL-57455 mod_data: Extend advanced search to cover tags
[moodle.git] / mod / data / lib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * @package   mod_data
20  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
21  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
22  */
24 defined('MOODLE_INTERNAL') || die();
26 // Some constants
27 define ('DATA_MAX_ENTRIES', 50);
28 define ('DATA_PERPAGE_SINGLE', 1);
30 define ('DATA_FIRSTNAME', -1);
31 define ('DATA_LASTNAME', -2);
32 define ('DATA_APPROVED', -3);
33 define ('DATA_TIMEADDED', 0);
34 define ('DATA_TIMEMODIFIED', -4);
35 define ('DATA_TAGS', -5);
37 define ('DATA_CAP_EXPORT', 'mod/data:viewalluserpresets');
39 define('DATA_PRESET_COMPONENT', 'mod_data');
40 define('DATA_PRESET_FILEAREA', 'site_presets');
41 define('DATA_PRESET_CONTEXT', SYSCONTEXTID);
43 define('DATA_EVENT_TYPE_OPEN', 'open');
44 define('DATA_EVENT_TYPE_CLOSE', 'close');
46 // Users having assigned the default role "Non-editing teacher" can export database records
47 // Using the mod/data capability "viewalluserpresets" existing in Moodle 1.9.x.
48 // In Moodle >= 2, new roles may be introduced and used instead.
50 /**
51  * @package   mod_data
52  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
53  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
54  */
55 class data_field_base {     // Base class for Database Field Types (see field/*/field.class.php)
57     /** @var string Subclasses must override the type with their name */
58     var $type = 'unknown';
59     /** @var object The database object that this field belongs to */
60     var $data = NULL;
61     /** @var object The field object itself, if we know it */
62     var $field = NULL;
63     /** @var int Width of the icon for this fieldtype */
64     var $iconwidth = 16;
65     /** @var int Width of the icon for this fieldtype */
66     var $iconheight = 16;
67     /** @var object course module or cmifno */
68     var $cm;
69     /** @var object activity context */
70     var $context;
71     /** @var priority for globalsearch indexing */
72     protected static $priority = self::NO_PRIORITY;
73     /** priority value for invalid fields regarding indexing */
74     const NO_PRIORITY = 0;
75     /** priority value for minimum priority */
76     const MIN_PRIORITY = 1;
77     /** priority value for low priority */
78     const LOW_PRIORITY = 2;
79     /** priority value for high priority */
80     const HIGH_PRIORITY = 3;
81     /** priority value for maximum priority */
82     const MAX_PRIORITY = 4;
84     /**
85      * Constructor function
86      *
87      * @global object
88      * @uses CONTEXT_MODULE
89      * @param int $field
90      * @param int $data
91      * @param int $cm
92      */
93     function __construct($field=0, $data=0, $cm=0) {   // Field or data or both, each can be id or object
94         global $DB;
96         if (empty($field) && empty($data)) {
97             print_error('missingfield', 'data');
98         }
100         if (!empty($field)) {
101             if (is_object($field)) {
102                 $this->field = $field;  // Programmer knows what they are doing, we hope
103             } else if (!$this->field = $DB->get_record('data_fields', array('id'=>$field))) {
104                 print_error('invalidfieldid', 'data');
105             }
106             if (empty($data)) {
107                 if (!$this->data = $DB->get_record('data', array('id'=>$this->field->dataid))) {
108                     print_error('invalidid', 'data');
109                 }
110             }
111         }
113         if (empty($this->data)) {         // We need to define this properly
114             if (!empty($data)) {
115                 if (is_object($data)) {
116                     $this->data = $data;  // Programmer knows what they are doing, we hope
117                 } else if (!$this->data = $DB->get_record('data', array('id'=>$data))) {
118                     print_error('invalidid', 'data');
119                 }
120             } else {                      // No way to define it!
121                 print_error('missingdata', 'data');
122             }
123         }
125         if ($cm) {
126             $this->cm = $cm;
127         } else {
128             $this->cm = get_coursemodule_from_instance('data', $this->data->id);
129         }
131         if (empty($this->field)) {         // We need to define some default values
132             $this->define_default_field();
133         }
135         $this->context = context_module::instance($this->cm->id);
136     }
139     /**
140      * This field just sets up a default field object
141      *
142      * @return bool
143      */
144     function define_default_field() {
145         global $OUTPUT;
146         if (empty($this->data->id)) {
147             echo $OUTPUT->notification('Programmer error: dataid not defined in field class');
148         }
149         $this->field = new stdClass();
150         $this->field->id = 0;
151         $this->field->dataid = $this->data->id;
152         $this->field->type   = $this->type;
153         $this->field->param1 = '';
154         $this->field->param2 = '';
155         $this->field->param3 = '';
156         $this->field->name = '';
157         $this->field->description = '';
158         $this->field->required = false;
160         return true;
161     }
163     /**
164      * Set up the field object according to data in an object.  Now is the time to clean it!
165      *
166      * @return bool
167      */
168     function define_field($data) {
169         $this->field->type        = $this->type;
170         $this->field->dataid      = $this->data->id;
172         $this->field->name        = trim($data->name);
173         $this->field->description = trim($data->description);
174         $this->field->required    = !empty($data->required) ? 1 : 0;
176         if (isset($data->param1)) {
177             $this->field->param1 = trim($data->param1);
178         }
179         if (isset($data->param2)) {
180             $this->field->param2 = trim($data->param2);
181         }
182         if (isset($data->param3)) {
183             $this->field->param3 = trim($data->param3);
184         }
185         if (isset($data->param4)) {
186             $this->field->param4 = trim($data->param4);
187         }
188         if (isset($data->param5)) {
189             $this->field->param5 = trim($data->param5);
190         }
192         return true;
193     }
195     /**
196      * Insert a new field in the database
197      * We assume the field object is already defined as $this->field
198      *
199      * @global object
200      * @return bool
201      */
202     function insert_field() {
203         global $DB, $OUTPUT;
205         if (empty($this->field)) {
206             echo $OUTPUT->notification('Programmer error: Field has not been defined yet!  See define_field()');
207             return false;
208         }
210         $this->field->id = $DB->insert_record('data_fields',$this->field);
212         // Trigger an event for creating this field.
213         $event = \mod_data\event\field_created::create(array(
214             'objectid' => $this->field->id,
215             'context' => $this->context,
216             'other' => array(
217                 'fieldname' => $this->field->name,
218                 'dataid' => $this->data->id
219             )
220         ));
221         $event->trigger();
223         return true;
224     }
227     /**
228      * Update a field in the database
229      *
230      * @global object
231      * @return bool
232      */
233     function update_field() {
234         global $DB;
236         $DB->update_record('data_fields', $this->field);
238         // Trigger an event for updating this field.
239         $event = \mod_data\event\field_updated::create(array(
240             'objectid' => $this->field->id,
241             'context' => $this->context,
242             'other' => array(
243                 'fieldname' => $this->field->name,
244                 'dataid' => $this->data->id
245             )
246         ));
247         $event->trigger();
249         return true;
250     }
252     /**
253      * Delete a field completely
254      *
255      * @global object
256      * @return bool
257      */
258     function delete_field() {
259         global $DB;
261         if (!empty($this->field->id)) {
262             // Get the field before we delete it.
263             $field = $DB->get_record('data_fields', array('id' => $this->field->id));
265             $this->delete_content();
266             $DB->delete_records('data_fields', array('id'=>$this->field->id));
268             // Trigger an event for deleting this field.
269             $event = \mod_data\event\field_deleted::create(array(
270                 'objectid' => $this->field->id,
271                 'context' => $this->context,
272                 'other' => array(
273                     'fieldname' => $this->field->name,
274                     'dataid' => $this->data->id
275                  )
276             ));
277             $event->add_record_snapshot('data_fields', $field);
278             $event->trigger();
279         }
281         return true;
282     }
284     /**
285      * Print the relevant form element in the ADD template for this field
286      *
287      * @global object
288      * @param int $recordid
289      * @return string
290      */
291     function display_add_field($recordid=0, $formdata=null) {
292         global $DB, $OUTPUT;
294         if ($formdata) {
295             $fieldname = 'field_' . $this->field->id;
296             $content = $formdata->$fieldname;
297         } else if ($recordid) {
298             $content = $DB->get_field('data_content', 'content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid));
299         } else {
300             $content = '';
301         }
303         // beware get_field returns false for new, empty records MDL-18567
304         if ($content===false) {
305             $content='';
306         }
308         $str = '<div title="' . s($this->field->description) . '">';
309         $str .= '<label for="field_'.$this->field->id.'"><span class="accesshide">'.$this->field->name.'</span>';
310         if ($this->field->required) {
311             $image = $OUTPUT->pix_icon('req', get_string('requiredelement', 'form'));
312             $str .= html_writer::div($image, 'inline-req');
313         }
314         $str .= '</label><input class="basefieldinput form-control d-inline mod-data-input" ' .
315                 'type="text" name="field_' . $this->field->id . '" ' .
316                 'id="field_' . $this->field->id . '" value="' . s($content) . '" />';
317         $str .= '</div>';
319         return $str;
320     }
322     /**
323      * Print the relevant form element to define the attributes for this field
324      * viewable by teachers only.
325      *
326      * @global object
327      * @global object
328      * @return void Output is echo'd
329      */
330     function display_edit_field() {
331         global $CFG, $DB, $OUTPUT;
333         if (empty($this->field)) {   // No field has been defined yet, try and make one
334             $this->define_default_field();
335         }
336         echo $OUTPUT->box_start('generalbox boxaligncenter boxwidthwide');
338         echo '<form id="editfield" action="'.$CFG->wwwroot.'/mod/data/field.php" method="post">'."\n";
339         echo '<input type="hidden" name="d" value="'.$this->data->id.'" />'."\n";
340         if (empty($this->field->id)) {
341             echo '<input type="hidden" name="mode" value="add" />'."\n";
342             $savebutton = get_string('add');
343         } else {
344             echo '<input type="hidden" name="fid" value="'.$this->field->id.'" />'."\n";
345             echo '<input type="hidden" name="mode" value="update" />'."\n";
346             $savebutton = get_string('savechanges');
347         }
348         echo '<input type="hidden" name="type" value="'.$this->type.'" />'."\n";
349         echo '<input name="sesskey" value="'.sesskey().'" type="hidden" />'."\n";
351         echo $OUTPUT->heading($this->name(), 3);
353         require_once($CFG->dirroot.'/mod/data/field/'.$this->type.'/mod.html');
355         echo '<div class="mdl-align">';
356         echo '<input type="submit" class="btn btn-primary" value="'.$savebutton.'" />'."\n";
357         echo '<input type="submit" class="btn btn-secondary" name="cancel" value="'.get_string('cancel').'" />'."\n";
358         echo '</div>';
360         echo '</form>';
362         echo $OUTPUT->box_end();
363     }
365     /**
366      * Display the content of the field in browse mode
367      *
368      * @global object
369      * @param int $recordid
370      * @param object $template
371      * @return bool|string
372      */
373     function display_browse_field($recordid, $template) {
374         global $DB;
376         if ($content = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
377             if (isset($content->content)) {
378                 $options = new stdClass();
379                 if ($this->field->param1 == '1') {  // We are autolinking this field, so disable linking within us
380                     //$content->content = '<span class="nolink">'.$content->content.'</span>';
381                     //$content->content1 = FORMAT_HTML;
382                     $options->filter=false;
383                 }
384                 $options->para = false;
385                 $str = format_text($content->content, $content->content1, $options);
386             } else {
387                 $str = '';
388             }
389             return $str;
390         }
391         return false;
392     }
394     /**
395      * Update the content of one data field in the data_content table
396      * @global object
397      * @param int $recordid
398      * @param mixed $value
399      * @param string $name
400      * @return bool
401      */
402     function update_content($recordid, $value, $name=''){
403         global $DB;
405         $content = new stdClass();
406         $content->fieldid = $this->field->id;
407         $content->recordid = $recordid;
408         $content->content = clean_param($value, PARAM_NOTAGS);
410         if ($oldcontent = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
411             $content->id = $oldcontent->id;
412             return $DB->update_record('data_content', $content);
413         } else {
414             return $DB->insert_record('data_content', $content);
415         }
416     }
418     /**
419      * Delete all content associated with the field
420      *
421      * @global object
422      * @param int $recordid
423      * @return bool
424      */
425     function delete_content($recordid=0) {
426         global $DB;
428         if ($recordid) {
429             $conditions = array('fieldid'=>$this->field->id, 'recordid'=>$recordid);
430         } else {
431             $conditions = array('fieldid'=>$this->field->id);
432         }
434         $rs = $DB->get_recordset('data_content', $conditions);
435         if ($rs->valid()) {
436             $fs = get_file_storage();
437             foreach ($rs as $content) {
438                 $fs->delete_area_files($this->context->id, 'mod_data', 'content', $content->id);
439             }
440         }
441         $rs->close();
443         return $DB->delete_records('data_content', $conditions);
444     }
446     /**
447      * Check if a field from an add form is empty
448      *
449      * @param mixed $value
450      * @param mixed $name
451      * @return bool
452      */
453     function notemptyfield($value, $name) {
454         return !empty($value);
455     }
457     /**
458      * Just in case a field needs to print something before the whole form
459      */
460     function print_before_form() {
461     }
463     /**
464      * Just in case a field needs to print something after the whole form
465      */
466     function print_after_form() {
467     }
470     /**
471      * Returns the sortable field for the content. By default, it's just content
472      * but for some plugins, it could be content 1 - content4
473      *
474      * @return string
475      */
476     function get_sort_field() {
477         return 'content';
478     }
480     /**
481      * Returns the SQL needed to refer to the column.  Some fields may need to CAST() etc.
482      *
483      * @param string $fieldname
484      * @return string $fieldname
485      */
486     function get_sort_sql($fieldname) {
487         return $fieldname;
488     }
490     /**
491      * Returns the name/type of the field
492      *
493      * @return string
494      */
495     function name() {
496         return get_string('fieldtypelabel', "datafield_$this->type");
497     }
499     /**
500      * Prints the respective type icon
501      *
502      * @global object
503      * @return string
504      */
505     function image() {
506         global $OUTPUT;
508         $params = array('d'=>$this->data->id, 'fid'=>$this->field->id, 'mode'=>'display', 'sesskey'=>sesskey());
509         $link = new moodle_url('/mod/data/field.php', $params);
510         $str = '<a href="'.$link->out().'">';
511         $str .= $OUTPUT->pix_icon('field/' . $this->type, $this->type, 'data');
512         $str .= '</a>';
513         return $str;
514     }
516     /**
517      * Per default, it is assumed that fields support text exporting.
518      * Override this (return false) on fields not supporting text exporting.
519      *
520      * @return bool true
521      */
522     function text_export_supported() {
523         return true;
524     }
526     /**
527      * Per default, return the record's text value only from the "content" field.
528      * Override this in fields class if necesarry.
529      *
530      * @param string $record
531      * @return string
532      */
533     function export_text_value($record) {
534         if ($this->text_export_supported()) {
535             return $record->content;
536         }
537     }
539     /**
540      * @param string $relativepath
541      * @return bool false
542      */
543     function file_ok($relativepath) {
544         return false;
545     }
547     /**
548      * Returns the priority for being indexed by globalsearch
549      *
550      * @return int
551      */
552     public static function get_priority() {
553         return static::$priority;
554     }
556     /**
557      * Returns the presentable string value for a field content.
558      *
559      * The returned string should be plain text.
560      *
561      * @param stdClass $content
562      * @return string
563      */
564     public static function get_content_value($content) {
565         return trim($content->content, "\r\n ");
566     }
568     /**
569      * Return the plugin configs for external functions,
570      * in some cases the configs will need formatting or be returned only if the current user has some capabilities enabled.
571      *
572      * @return array the list of config parameters
573      * @since Moodle 3.3
574      */
575     public function get_config_for_external() {
576         // Return all the field configs to null (maybe there is a private key for a service or something similar there).
577         $configs = [];
578         for ($i = 1; $i <= 10; $i++) {
579             $configs["param$i"] = null;
580         }
581         return $configs;
582     }
586 /**
587  * Given a template and a dataid, generate a default case template
588  *
589  * @global object
590  * @param object $data
591  * @param string template [addtemplate, singletemplate, listtempalte, rsstemplate]
592  * @param int $recordid
593  * @param bool $form
594  * @param bool $update
595  * @return bool|string
596  */
597 function data_generate_default_template(&$data, $template, $recordid=0, $form=false, $update=true) {
598     global $DB;
600     if (!$data && !$template) {
601         return false;
602     }
603     if ($template == 'csstemplate' or $template == 'jstemplate' ) {
604         return '';
605     }
607     // get all the fields for that database
608     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'id')) {
610         $table = new html_table();
611         $table->attributes['class'] = 'mod-data-default-template ##approvalstatus##';
612         $table->colclasses = array('template-field', 'template-token');
613         $table->data = array();
614         foreach ($fields as $field) {
615             if ($form) {   // Print forms instead of data
616                 $fieldobj = data_get_field($field, $data);
617                 $token = $fieldobj->display_add_field($recordid, null);
618             } else {           // Just print the tag
619                 $token = '[['.$field->name.']]';
620             }
621             $table->data[] = array(
622                 $field->name.': ',
623                 $token
624             );
625         }
627         if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
628             $label = new html_table_cell(get_string('tags') . ':');
629             if ($form) {
630                 $cell = data_generate_tag_form();
631             } else {
632                 $cell = new html_table_cell('##tags##');
633             }
634             $table->data[] = new html_table_row(array($label, $cell));
635         }
637         if ($template == 'listtemplate') {
638             $cell = new html_table_cell('##edit##  ##more##  ##delete##  ##approve##  ##disapprove##  ##export##');
639             $cell->colspan = 2;
640             $cell->attributes['class'] = 'controls';
641             $table->data[] = new html_table_row(array($cell));
642         } else if ($template == 'singletemplate') {
643             $cell = new html_table_cell('##edit##  ##delete##  ##approve##  ##disapprove##  ##export##');
644             $cell->colspan = 2;
645             $cell->attributes['class'] = 'controls';
646             $table->data[] = new html_table_row(array($cell));
647         } else if ($template == 'asearchtemplate') {
648             $row = new html_table_row(array(get_string('authorfirstname', 'data').': ', '##firstname##'));
649             $row->attributes['class'] = 'searchcontrols';
650             $table->data[] = $row;
651             $row = new html_table_row(array(get_string('authorlastname', 'data').': ', '##lastname##'));
652             $row->attributes['class'] = 'searchcontrols';
653             $table->data[] = $row;
654         }
656         $str = '';
657         if ($template == 'listtemplate'){
658             $str .= '##delcheck##';
659             $str .= html_writer::empty_tag('br');
660         }
662         $str .= html_writer::start_tag('div', array('class' => 'defaulttemplate'));
663         $str .= html_writer::table($table);
664         $str .= html_writer::end_tag('div');
665         if ($template == 'listtemplate'){
666             $str .= html_writer::empty_tag('hr');
667         }
669         if ($update) {
670             $newdata = new stdClass();
671             $newdata->id = $data->id;
672             $newdata->{$template} = $str;
673             $DB->update_record('data', $newdata);
674             $data->{$template} = $str;
675         }
677         return $str;
678     }
681 /**
682  * Build the form elements to manage tags for a record.
683  *
684  * @param int|bool $recordid
685  * @param string[] $selected raw tag names
686  * @return string
687  */
688 function data_generate_tag_form($recordid = false, $selected = []) {
689     global $CFG, $DB, $PAGE;
691     $tagtypestoshow = \core_tag_area::get_showstandard('mod_data', 'data_records');
692     $showstandard = ($tagtypestoshow != core_tag_tag::HIDE_STANDARD);
693     $typenewtags = ($tagtypestoshow != core_tag_tag::STANDARD_ONLY);
695     $str = html_writer::start_tag('div', array('class' => 'datatagcontrol'));
697     $namefield = empty($CFG->keeptagnamecase) ? 'name' : 'rawname';
699     $tagcollid = \core_tag_area::get_collection('mod_data', 'data_records');
700     $tags = [];
701     $selectedtags = [];
703     if ($showstandard) {
704         $tags += $DB->get_records_menu('tag', array('isstandard' => 1, 'tagcollid' => $tagcollid),
705             $namefield, 'id,' . $namefield . ' as fieldname');
706     }
708     if ($recordid) {
709         $selectedtags += core_tag_tag::get_item_tags_array('mod_data', 'data_records', $recordid);
710     }
712     if (!empty($selected)) {
713         list($sql, $params) = $DB->get_in_or_equal($selected, SQL_PARAMS_NAMED);
714         $params['tagcollid'] = $tagcollid;
715         $sql = "SELECT id, $namefield FROM {tag} WHERE tagcollid = :tagcollid AND rawname $sql";
716         $selectedtags += $DB->get_records_sql_menu($sql, $params);
717     }
719     $tags += $selectedtags;
721     $str .= '<select class="custom-select" name="tags[]" id="tags" multiple>';
722     foreach ($tags as $tagid => $tag) {
723         $selected = key_exists($tagid, $selectedtags) ? 'selected' : '';
724         $str .= "<option value='$tag' $selected>$tag</option>";
725     }
726     $str .= '</select>';
728     $PAGE->requires->js_call_amd('core/form-autocomplete', 'enhance', $params = array(
729             '#tags',
730             $typenewtags,
731             '',
732             get_string('entertags', 'tag'),
733             false,
734             $showstandard,
735             get_string('noselection', 'form')
736         )
737     );
739     $str .= html_writer::end_tag('div');
741     return $str;
745 /**
746  * Search for a field name and replaces it with another one in all the
747  * form templates. Set $newfieldname as '' if you want to delete the
748  * field from the form.
749  *
750  * @global object
751  * @param object $data
752  * @param string $searchfieldname
753  * @param string $newfieldname
754  * @return bool
755  */
756 function data_replace_field_in_templates($data, $searchfieldname, $newfieldname) {
757     global $DB;
759     if (!empty($newfieldname)) {
760         $prestring = '[[';
761         $poststring = ']]';
762         $idpart = '#id';
764     } else {
765         $prestring = '';
766         $poststring = '';
767         $idpart = '';
768     }
770     $newdata = new stdClass();
771     $newdata->id = $data->id;
772     $newdata->singletemplate = str_ireplace('[['.$searchfieldname.']]',
773             $prestring.$newfieldname.$poststring, $data->singletemplate);
775     $newdata->listtemplate = str_ireplace('[['.$searchfieldname.']]',
776             $prestring.$newfieldname.$poststring, $data->listtemplate);
778     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.']]',
779             $prestring.$newfieldname.$poststring, $data->addtemplate);
781     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.'#id]]',
782             $prestring.$newfieldname.$idpart.$poststring, $data->addtemplate);
784     $newdata->rsstemplate = str_ireplace('[['.$searchfieldname.']]',
785             $prestring.$newfieldname.$poststring, $data->rsstemplate);
787     return $DB->update_record('data', $newdata);
791 /**
792  * Appends a new field at the end of the form template.
793  *
794  * @global object
795  * @param object $data
796  * @param string $newfieldname
797  */
798 function data_append_new_field_to_templates($data, $newfieldname) {
799     global $DB;
801     $newdata = new stdClass();
802     $newdata->id = $data->id;
803     $change = false;
805     if (!empty($data->singletemplate)) {
806         $newdata->singletemplate = $data->singletemplate.' [[' . $newfieldname .']]';
807         $change = true;
808     }
809     if (!empty($data->addtemplate)) {
810         $newdata->addtemplate = $data->addtemplate.' [[' . $newfieldname . ']]';
811         $change = true;
812     }
813     if (!empty($data->rsstemplate)) {
814         $newdata->rsstemplate = $data->singletemplate.' [[' . $newfieldname . ']]';
815         $change = true;
816     }
817     if ($change) {
818         $DB->update_record('data', $newdata);
819     }
823 /**
824  * given a field name
825  * this function creates an instance of the particular subfield class
826  *
827  * @global object
828  * @param string $name
829  * @param object $data
830  * @return object|bool
831  */
832 function data_get_field_from_name($name, $data){
833     global $DB;
835     $field = $DB->get_record('data_fields', array('name'=>$name, 'dataid'=>$data->id));
837     if ($field) {
838         return data_get_field($field, $data);
839     } else {
840         return false;
841     }
844 /**
845  * given a field id
846  * this function creates an instance of the particular subfield class
847  *
848  * @global object
849  * @param int $fieldid
850  * @param object $data
851  * @return bool|object
852  */
853 function data_get_field_from_id($fieldid, $data){
854     global $DB;
856     $field = $DB->get_record('data_fields', array('id'=>$fieldid, 'dataid'=>$data->id));
858     if ($field) {
859         return data_get_field($field, $data);
860     } else {
861         return false;
862     }
865 /**
866  * given a field id
867  * this function creates an instance of the particular subfield class
868  *
869  * @global object
870  * @param string $type
871  * @param object $data
872  * @return object
873  */
874 function data_get_field_new($type, $data) {
875     global $CFG;
877     require_once($CFG->dirroot.'/mod/data/field/'.$type.'/field.class.php');
878     $newfield = 'data_field_'.$type;
879     $newfield = new $newfield(0, $data);
880     return $newfield;
883 /**
884  * returns a subclass field object given a record of the field, used to
885  * invoke plugin methods
886  * input: $param $field - record from db
887  *
888  * @global object
889  * @param object $field
890  * @param object $data
891  * @param object $cm
892  * @return object
893  */
894 function data_get_field($field, $data, $cm=null) {
895     global $CFG;
897     if ($field) {
898         require_once('field/'.$field->type.'/field.class.php');
899         $newfield = 'data_field_'.$field->type;
900         $newfield = new $newfield($field, $data, $cm);
901         return $newfield;
902     }
906 /**
907  * Given record object (or id), returns true if the record belongs to the current user
908  *
909  * @global object
910  * @global object
911  * @param mixed $record record object or id
912  * @return bool
913  */
914 function data_isowner($record) {
915     global $USER, $DB;
917     if (!isloggedin()) { // perf shortcut
918         return false;
919     }
921     if (!is_object($record)) {
922         if (!$record = $DB->get_record('data_records', array('id'=>$record))) {
923             return false;
924         }
925     }
927     return ($record->userid == $USER->id);
930 /**
931  * has a user reached the max number of entries?
932  *
933  * @param object $data
934  * @return bool
935  */
936 function data_atmaxentries($data){
937     if (!$data->maxentries){
938         return false;
940     } else {
941         return (data_numentries($data) >= $data->maxentries);
942     }
945 /**
946  * returns the number of entries already made by this user
947  *
948  * @global object
949  * @global object
950  * @param object $data
951  * @return int
952  */
953 function data_numentries($data, $userid=null) {
954     global $USER, $DB;
955     if ($userid === null) {
956         $userid = $USER->id;
957     }
958     $sql = 'SELECT COUNT(*) FROM {data_records} WHERE dataid=? AND userid=?';
959     return $DB->count_records_sql($sql, array($data->id, $userid));
962 /**
963  * function that takes in a dataid and adds a record
964  * this is used everytime an add template is submitted
965  *
966  * @global object
967  * @global object
968  * @param object $data
969  * @param int $groupid
970  * @return bool
971  */
972 function data_add_record($data, $groupid=0){
973     global $USER, $DB;
975     $cm = get_coursemodule_from_instance('data', $data->id);
976     $context = context_module::instance($cm->id);
978     $record = new stdClass();
979     $record->userid = $USER->id;
980     $record->dataid = $data->id;
981     $record->groupid = $groupid;
982     $record->timecreated = $record->timemodified = time();
983     if (has_capability('mod/data:approve', $context)) {
984         $record->approved = 1;
985     } else {
986         $record->approved = 0;
987     }
988     $record->id = $DB->insert_record('data_records', $record);
990     // Trigger an event for creating this record.
991     $event = \mod_data\event\record_created::create(array(
992         'objectid' => $record->id,
993         'context' => $context,
994         'other' => array(
995             'dataid' => $data->id
996         )
997     ));
998     $event->trigger();
1000     $course = get_course($cm->course);
1001     data_update_completion_state($data, $course, $cm);
1003     return $record->id;
1006 /**
1007  * check the multple existence any tag in a template
1008  *
1009  * check to see if there are 2 or more of the same tag being used.
1010  *
1011  * @global object
1012  * @param int $dataid,
1013  * @param string $template
1014  * @return bool
1015  */
1016 function data_tags_check($dataid, $template) {
1017     global $DB, $OUTPUT;
1019     // first get all the possible tags
1020     $fields = $DB->get_records('data_fields', array('dataid'=>$dataid));
1021     // then we generate strings to replace
1022     $tagsok = true; // let's be optimistic
1023     foreach ($fields as $field){
1024         $pattern="/\[\[" . preg_quote($field->name, '/') . "\]\]/i";
1025         if (preg_match_all($pattern, $template, $dummy)>1){
1026             $tagsok = false;
1027             echo $OUTPUT->notification('[['.$field->name.']] - '.get_string('multipletags','data'));
1028         }
1029     }
1030     // else return true
1031     return $tagsok;
1034 /**
1035  * Adds an instance of a data
1036  *
1037  * @param stdClass $data
1038  * @param mod_data_mod_form $mform
1039  * @return int intance id
1040  */
1041 function data_add_instance($data, $mform = null) {
1042     global $DB, $CFG;
1043     require_once($CFG->dirroot.'/mod/data/locallib.php');
1045     if (empty($data->assessed)) {
1046         $data->assessed = 0;
1047     }
1049     if (empty($data->ratingtime) || empty($data->assessed)) {
1050         $data->assesstimestart  = 0;
1051         $data->assesstimefinish = 0;
1052     }
1054     $data->timemodified = time();
1056     $data->id = $DB->insert_record('data', $data);
1058     // Add calendar events if necessary.
1059     data_set_events($data);
1060     if (!empty($data->completionexpected)) {
1061         \core_completion\api::update_completion_date_event($data->coursemodule, 'data', $data->id, $data->completionexpected);
1062     }
1064     data_grade_item_update($data);
1066     return $data->id;
1069 /**
1070  * updates an instance of a data
1071  *
1072  * @global object
1073  * @param object $data
1074  * @return bool
1075  */
1076 function data_update_instance($data) {
1077     global $DB, $CFG;
1078     require_once($CFG->dirroot.'/mod/data/locallib.php');
1080     $data->timemodified = time();
1081     $data->id           = $data->instance;
1083     if (empty($data->assessed)) {
1084         $data->assessed = 0;
1085     }
1087     if (empty($data->ratingtime) or empty($data->assessed)) {
1088         $data->assesstimestart  = 0;
1089         $data->assesstimefinish = 0;
1090     }
1092     if (empty($data->notification)) {
1093         $data->notification = 0;
1094     }
1096     $DB->update_record('data', $data);
1098     // Add calendar events if necessary.
1099     data_set_events($data);
1100     $completionexpected = (!empty($data->completionexpected)) ? $data->completionexpected : null;
1101     \core_completion\api::update_completion_date_event($data->coursemodule, 'data', $data->id, $completionexpected);
1103     data_grade_item_update($data);
1105     return true;
1109 /**
1110  * deletes an instance of a data
1111  *
1112  * @global object
1113  * @param int $id
1114  * @return bool
1115  */
1116 function data_delete_instance($id) {    // takes the dataid
1117     global $DB, $CFG;
1119     if (!$data = $DB->get_record('data', array('id'=>$id))) {
1120         return false;
1121     }
1123     $cm = get_coursemodule_from_instance('data', $data->id);
1124     $context = context_module::instance($cm->id);
1126 /// Delete all the associated information
1128     // files
1129     $fs = get_file_storage();
1130     $fs->delete_area_files($context->id, 'mod_data');
1132     // get all the records in this data
1133     $sql = "SELECT r.id
1134               FROM {data_records} r
1135              WHERE r.dataid = ?";
1137     $DB->delete_records_select('data_content', "recordid IN ($sql)", array($id));
1139     // delete all the records and fields
1140     $DB->delete_records('data_records', array('dataid'=>$id));
1141     $DB->delete_records('data_fields', array('dataid'=>$id));
1143     // Remove old calendar events.
1144     $events = $DB->get_records('event', array('modulename' => 'data', 'instance' => $id));
1145     foreach ($events as $event) {
1146         $event = calendar_event::load($event);
1147         $event->delete();
1148     }
1150     // Delete the instance itself
1151     $result = $DB->delete_records('data', array('id'=>$id));
1153     // cleanup gradebook
1154     data_grade_item_delete($data);
1156     return $result;
1159 /**
1160  * returns a summary of data activity of this user
1161  *
1162  * @global object
1163  * @param object $course
1164  * @param object $user
1165  * @param object $mod
1166  * @param object $data
1167  * @return object|null
1168  */
1169 function data_user_outline($course, $user, $mod, $data) {
1170     global $DB, $CFG;
1171     require_once("$CFG->libdir/gradelib.php");
1173     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1174     if (empty($grades->items[0]->grades)) {
1175         $grade = false;
1176     } else {
1177         $grade = reset($grades->items[0]->grades);
1178     }
1181     if ($countrecords = $DB->count_records('data_records', array('dataid'=>$data->id, 'userid'=>$user->id))) {
1182         $result = new stdClass();
1183         $result->info = get_string('numrecords', 'data', $countrecords);
1184         $lastrecord   = $DB->get_record_sql('SELECT id,timemodified FROM {data_records}
1185                                               WHERE dataid = ? AND userid = ?
1186                                            ORDER BY timemodified DESC', array($data->id, $user->id), true);
1187         $result->time = $lastrecord->timemodified;
1188         if ($grade) {
1189             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1190         }
1191         return $result;
1192     } else if ($grade) {
1193         $result = new stdClass();
1194         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1196         //datesubmitted == time created. dategraded == time modified or time overridden
1197         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1198         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1199         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1200             $result->time = $grade->dategraded;
1201         } else {
1202             $result->time = $grade->datesubmitted;
1203         }
1205         return $result;
1206     }
1207     return NULL;
1210 /**
1211  * Prints all the records uploaded by this user
1212  *
1213  * @global object
1214  * @param object $course
1215  * @param object $user
1216  * @param object $mod
1217  * @param object $data
1218  */
1219 function data_user_complete($course, $user, $mod, $data) {
1220     global $DB, $CFG, $OUTPUT;
1221     require_once("$CFG->libdir/gradelib.php");
1223     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1224     if (!empty($grades->items[0]->grades)) {
1225         $grade = reset($grades->items[0]->grades);
1226         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1227         if ($grade->str_feedback) {
1228             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1229         }
1230     }
1232     if ($records = $DB->get_records('data_records', array('dataid'=>$data->id,'userid'=>$user->id), 'timemodified DESC')) {
1233         data_print_template('singletemplate', $records, $data);
1234     }
1237 /**
1238  * Return grade for given user or all users.
1239  *
1240  * @global object
1241  * @param object $data
1242  * @param int $userid optional user id, 0 means all users
1243  * @return array array of grades, false if none
1244  */
1245 function data_get_user_grades($data, $userid=0) {
1246     global $CFG;
1248     require_once($CFG->dirroot.'/rating/lib.php');
1250     $ratingoptions = new stdClass;
1251     $ratingoptions->component = 'mod_data';
1252     $ratingoptions->ratingarea = 'entry';
1253     $ratingoptions->modulename = 'data';
1254     $ratingoptions->moduleid   = $data->id;
1256     $ratingoptions->userid = $userid;
1257     $ratingoptions->aggregationmethod = $data->assessed;
1258     $ratingoptions->scaleid = $data->scale;
1259     $ratingoptions->itemtable = 'data_records';
1260     $ratingoptions->itemtableusercolumn = 'userid';
1262     $rm = new rating_manager();
1263     return $rm->get_user_grades($ratingoptions);
1266 /**
1267  * Update activity grades
1268  *
1269  * @category grade
1270  * @param object $data
1271  * @param int $userid specific user only, 0 means all
1272  * @param bool $nullifnone
1273  */
1274 function data_update_grades($data, $userid=0, $nullifnone=true) {
1275     global $CFG, $DB;
1276     require_once($CFG->libdir.'/gradelib.php');
1278     if (!$data->assessed) {
1279         data_grade_item_update($data);
1281     } else if ($grades = data_get_user_grades($data, $userid)) {
1282         data_grade_item_update($data, $grades);
1284     } else if ($userid and $nullifnone) {
1285         $grade = new stdClass();
1286         $grade->userid   = $userid;
1287         $grade->rawgrade = NULL;
1288         data_grade_item_update($data, $grade);
1290     } else {
1291         data_grade_item_update($data);
1292     }
1295 /**
1296  * Update/create grade item for given data
1297  *
1298  * @category grade
1299  * @param stdClass $data A database instance with extra cmidnumber property
1300  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1301  * @return object grade_item
1302  */
1303 function data_grade_item_update($data, $grades=NULL) {
1304     global $CFG;
1305     require_once($CFG->libdir.'/gradelib.php');
1307     $params = array('itemname'=>$data->name, 'idnumber'=>$data->cmidnumber);
1309     if (!$data->assessed or $data->scale == 0) {
1310         $params['gradetype'] = GRADE_TYPE_NONE;
1312     } else if ($data->scale > 0) {
1313         $params['gradetype'] = GRADE_TYPE_VALUE;
1314         $params['grademax']  = $data->scale;
1315         $params['grademin']  = 0;
1317     } else if ($data->scale < 0) {
1318         $params['gradetype'] = GRADE_TYPE_SCALE;
1319         $params['scaleid']   = -$data->scale;
1320     }
1322     if ($grades  === 'reset') {
1323         $params['reset'] = true;
1324         $grades = NULL;
1325     }
1327     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, $grades, $params);
1330 /**
1331  * Delete grade item for given data
1332  *
1333  * @category grade
1334  * @param object $data object
1335  * @return object grade_item
1336  */
1337 function data_grade_item_delete($data) {
1338     global $CFG;
1339     require_once($CFG->libdir.'/gradelib.php');
1341     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, NULL, array('deleted'=>1));
1344 // junk functions
1345 /**
1346  * takes a list of records, the current data, a search string,
1347  * and mode to display prints the translated template
1348  *
1349  * @global object
1350  * @global object
1351  * @param string $template
1352  * @param array $records
1353  * @param object $data
1354  * @param string $search
1355  * @param int $page
1356  * @param bool $return
1357  * @param object $jumpurl a moodle_url by which to jump back to the record list (can be null)
1358  * @return mixed
1359  */
1360 function data_print_template($template, $records, $data, $search='', $page=0, $return=false, moodle_url $jumpurl=null) {
1361     global $CFG, $DB, $OUTPUT;
1363     $cm = get_coursemodule_from_instance('data', $data->id);
1364     $context = context_module::instance($cm->id);
1366     static $fields = array();
1367     static $dataid = null;
1369     if (empty($dataid)) {
1370         $dataid = $data->id;
1371     } else if ($dataid != $data->id) {
1372         $fields = array();
1373     }
1375     if (empty($fields)) {
1376         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1377         foreach ($fieldrecords as $fieldrecord) {
1378             $fields[]= data_get_field($fieldrecord, $data);
1379         }
1380     }
1382     if (empty($records)) {
1383         return;
1384     }
1386     if (!$jumpurl) {
1387         $jumpurl = new moodle_url('/mod/data/view.php', array('d' => $data->id));
1388     }
1389     $jumpurl = new moodle_url($jumpurl, array('page' => $page, 'sesskey' => sesskey()));
1391     foreach ($records as $record) {   // Might be just one for the single template
1393     // Replacing tags
1394         $patterns = array();
1395         $replacement = array();
1397     // Then we generate strings to replace for normal tags
1398         foreach ($fields as $field) {
1399             $patterns[]='[['.$field->field->name.']]';
1400             $replacement[] = highlight($search, $field->display_browse_field($record->id, $template));
1401         }
1403         $canmanageentries = has_capability('mod/data:manageentries', $context);
1405     // Replacing special tags (##Edit##, ##Delete##, ##More##)
1406         $patterns[]='##edit##';
1407         $patterns[]='##delete##';
1408         if (data_user_can_manage_entry($record, $data, $context)) {
1409             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/edit.php?d='
1410                              .$data->id.'&amp;rid='.$record->id.'&amp;sesskey='.sesskey().'">' .
1411                              $OUTPUT->pix_icon('t/edit', get_string('edit')) . '</a>';
1412             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/view.php?d='
1413                              .$data->id.'&amp;delete='.$record->id.'&amp;sesskey='.sesskey().'">' .
1414                              $OUTPUT->pix_icon('t/delete', get_string('delete')) . '</a>';
1415         } else {
1416             $replacement[] = '';
1417             $replacement[] = '';
1418         }
1420         $moreurl = $CFG->wwwroot . '/mod/data/view.php?d=' . $data->id . '&amp;rid=' . $record->id;
1421         if ($search) {
1422             $moreurl .= '&amp;filter=1';
1423         }
1424         $patterns[]='##more##';
1425         $replacement[] = '<a href="'.$moreurl.'">' . $OUTPUT->pix_icon('t/preview', get_string('more', 'data')) . '</a>';
1427         $patterns[]='##moreurl##';
1428         $replacement[] = $moreurl;
1430         $patterns[]='##delcheck##';
1431         if ($canmanageentries) {
1432             $replacement[] = html_writer::checkbox('delcheck[]', $record->id, false, '', array('class' => 'recordcheckbox'));
1433         } else {
1434             $replacement[] = '';
1435         }
1437         $patterns[]='##user##';
1438         $replacement[] = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$record->userid.
1439                                '&amp;course='.$data->course.'">'.fullname($record).'</a>';
1441         $patterns[] = '##userpicture##';
1442         $ruser = user_picture::unalias($record, null, 'userid');
1443         // If the record didn't come with user data, retrieve the user from database.
1444         if (!isset($ruser->picture)) {
1445             $ruser = core_user::get_user($record->userid);
1446         }
1447         $replacement[] = $OUTPUT->user_picture($ruser, array('courseid' => $data->course));
1449         $patterns[]='##export##';
1451         if (!empty($CFG->enableportfolios) && ($template == 'singletemplate' || $template == 'listtemplate')
1452             && ((has_capability('mod/data:exportentry', $context)
1453                 || (data_isowner($record->id) && has_capability('mod/data:exportownentry', $context))))) {
1454             require_once($CFG->libdir . '/portfoliolib.php');
1455             $button = new portfolio_add_button();
1456             $button->set_callback_options('data_portfolio_caller', array('id' => $cm->id, 'recordid' => $record->id), 'mod_data');
1457             list($formats, $files) = data_portfolio_caller::formats($fields, $record);
1458             $button->set_formats($formats);
1459             $replacement[] = $button->to_html(PORTFOLIO_ADD_ICON_LINK);
1460         } else {
1461             $replacement[] = '';
1462         }
1464         $patterns[] = '##timeadded##';
1465         $replacement[] = userdate($record->timecreated);
1467         $patterns[] = '##timemodified##';
1468         $replacement [] = userdate($record->timemodified);
1470         $patterns[]='##approve##';
1471         if (has_capability('mod/data:approve', $context) && ($data->approval) && (!$record->approved)) {
1472             $approveurl = new moodle_url($jumpurl, array('approve' => $record->id));
1473             $approveicon = new pix_icon('t/approve', get_string('approve', 'data'), '', array('class' => 'iconsmall'));
1474             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($approveurl, $approveicon),
1475                     array('class' => 'approve'));
1476         } else {
1477             $replacement[] = '';
1478         }
1480         $patterns[]='##disapprove##';
1481         if (has_capability('mod/data:approve', $context) && ($data->approval) && ($record->approved)) {
1482             $disapproveurl = new moodle_url($jumpurl, array('disapprove' => $record->id));
1483             $disapproveicon = new pix_icon('t/block', get_string('disapprove', 'data'), '', array('class' => 'iconsmall'));
1484             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($disapproveurl, $disapproveicon),
1485                     array('class' => 'disapprove'));
1486         } else {
1487             $replacement[] = '';
1488         }
1490         $patterns[] = '##approvalstatus##';
1491         if (!$data->approval) {
1492             $replacement[] = '';
1493         } else if ($record->approved) {
1494             $replacement[] = get_string('approved', 'data');
1495         } else {
1496             $replacement[] = get_string('notapproved', 'data');
1497         }
1499         $patterns[]='##comments##';
1500         if (($template == 'listtemplate') && ($data->comments)) {
1502             if (!empty($CFG->usecomments)) {
1503                 require_once($CFG->dirroot  . '/comment/lib.php');
1504                 list($context, $course, $cm) = get_context_info_array($context->id);
1505                 $cmt = new stdClass();
1506                 $cmt->context = $context;
1507                 $cmt->course  = $course;
1508                 $cmt->cm      = $cm;
1509                 $cmt->area    = 'database_entry';
1510                 $cmt->itemid  = $record->id;
1511                 $cmt->showcount = true;
1512                 $cmt->component = 'mod_data';
1513                 $comment = new comment($cmt);
1514                 $replacement[] = $comment->output(true);
1515             }
1516         } else {
1517             $replacement[] = '';
1518         }
1520         if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
1521             $patterns[] = "##tags##";
1522             $replacement[] = $OUTPUT->tag_list(
1523                 core_tag_tag::get_item_tags('mod_data', 'data_records', $record->id), '', 'data-tags');
1524         }
1526         // actual replacement of the tags
1527         $newtext = str_ireplace($patterns, $replacement, $data->{$template});
1529         // no more html formatting and filtering - see MDL-6635
1530         if ($return) {
1531             return $newtext;
1532         } else {
1533             echo $newtext;
1535             // hack alert - return is always false in singletemplate anyway ;-)
1536             /**********************************
1537              *    Printing Ratings Form       *
1538              *********************************/
1539             if ($template == 'singletemplate') {    //prints ratings options
1540                 data_print_ratings($data, $record);
1541             }
1543             /**********************************
1544              *    Printing Comments Form       *
1545              *********************************/
1546             if (($template == 'singletemplate') && ($data->comments)) {
1547                 if (!empty($CFG->usecomments)) {
1548                     require_once($CFG->dirroot . '/comment/lib.php');
1549                     list($context, $course, $cm) = get_context_info_array($context->id);
1550                     $cmt = new stdClass();
1551                     $cmt->context = $context;
1552                     $cmt->course  = $course;
1553                     $cmt->cm      = $cm;
1554                     $cmt->area    = 'database_entry';
1555                     $cmt->itemid  = $record->id;
1556                     $cmt->showcount = true;
1557                     $cmt->component = 'mod_data';
1558                     $comment = new comment($cmt);
1559                     $comment->output(false);
1560                 }
1561             }
1562         }
1563     }
1566 /**
1567  * Return rating related permissions
1568  *
1569  * @param string $contextid the context id
1570  * @param string $component the component to get rating permissions for
1571  * @param string $ratingarea the rating area to get permissions for
1572  * @return array an associative array of the user's rating permissions
1573  */
1574 function data_rating_permissions($contextid, $component, $ratingarea) {
1575     $context = context::instance_by_id($contextid, MUST_EXIST);
1576     if ($component != 'mod_data' || $ratingarea != 'entry') {
1577         return null;
1578     }
1579     return array(
1580         'view'    => has_capability('mod/data:viewrating',$context),
1581         'viewany' => has_capability('mod/data:viewanyrating',$context),
1582         'viewall' => has_capability('mod/data:viewallratings',$context),
1583         'rate'    => has_capability('mod/data:rate',$context)
1584     );
1587 /**
1588  * Validates a submitted rating
1589  * @param array $params submitted data
1590  *            context => object the context in which the rated items exists [required]
1591  *            itemid => int the ID of the object being rated
1592  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
1593  *            rating => int the submitted rating
1594  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
1595  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
1596  * @return boolean true if the rating is valid. Will throw rating_exception if not
1597  */
1598 function data_rating_validate($params) {
1599     global $DB, $USER;
1601     // Check the component is mod_data
1602     if ($params['component'] != 'mod_data') {
1603         throw new rating_exception('invalidcomponent');
1604     }
1606     // Check the ratingarea is entry (the only rating area in data module)
1607     if ($params['ratingarea'] != 'entry') {
1608         throw new rating_exception('invalidratingarea');
1609     }
1611     // Check the rateduserid is not the current user .. you can't rate your own entries
1612     if ($params['rateduserid'] == $USER->id) {
1613         throw new rating_exception('nopermissiontorate');
1614     }
1616     $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
1617                   FROM {data_records} r
1618                   JOIN {data} d ON r.dataid = d.id
1619                  WHERE r.id = :itemid";
1620     $dataparams = array('itemid'=>$params['itemid']);
1621     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1622         //item doesn't exist
1623         throw new rating_exception('invaliditemid');
1624     }
1626     if ($info->scale != $params['scaleid']) {
1627         //the scale being submitted doesnt match the one in the database
1628         throw new rating_exception('invalidscaleid');
1629     }
1631     //check that the submitted rating is valid for the scale
1633     // lower limit
1634     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
1635         throw new rating_exception('invalidnum');
1636     }
1638     // upper limit
1639     if ($info->scale < 0) {
1640         //its a custom scale
1641         $scalerecord = $DB->get_record('scale', array('id' => -$info->scale));
1642         if ($scalerecord) {
1643             $scalearray = explode(',', $scalerecord->scale);
1644             if ($params['rating'] > count($scalearray)) {
1645                 throw new rating_exception('invalidnum');
1646             }
1647         } else {
1648             throw new rating_exception('invalidscaleid');
1649         }
1650     } else if ($params['rating'] > $info->scale) {
1651         //if its numeric and submitted rating is above maximum
1652         throw new rating_exception('invalidnum');
1653     }
1655     if ($info->approval && !$info->approved) {
1656         //database requires approval but this item isnt approved
1657         throw new rating_exception('nopermissiontorate');
1658     }
1660     // check the item we're rating was created in the assessable time window
1661     if (!empty($info->assesstimestart) && !empty($info->assesstimefinish)) {
1662         if ($info->timecreated < $info->assesstimestart || $info->timecreated > $info->assesstimefinish) {
1663             throw new rating_exception('notavailable');
1664         }
1665     }
1667     $course = $DB->get_record('course', array('id'=>$info->course), '*', MUST_EXIST);
1668     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1669     $context = context_module::instance($cm->id);
1671     // if the supplied context doesnt match the item's context
1672     if ($context->id != $params['context']->id) {
1673         throw new rating_exception('invalidcontext');
1674     }
1676     // Make sure groups allow this user to see the item they're rating
1677     $groupid = $info->groupid;
1678     if ($groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
1679         if (!groups_group_exists($groupid)) { // Can't find group
1680             throw new rating_exception('cannotfindgroup');//something is wrong
1681         }
1683         if (!groups_is_member($groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
1684             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
1685             throw new rating_exception('notmemberofgroup');
1686         }
1687     }
1689     return true;
1692 /**
1693  * Can the current user see ratings for a given itemid?
1694  *
1695  * @param array $params submitted data
1696  *            contextid => int contextid [required]
1697  *            component => The component for this module - should always be mod_data [required]
1698  *            ratingarea => object the context in which the rated items exists [required]
1699  *            itemid => int the ID of the object being rated [required]
1700  *            scaleid => int scale id [optional]
1701  * @return bool
1702  * @throws coding_exception
1703  * @throws rating_exception
1704  */
1705 function mod_data_rating_can_see_item_ratings($params) {
1706     global $DB;
1708     // Check the component is mod_data.
1709     if (!isset($params['component']) || $params['component'] != 'mod_data') {
1710         throw new rating_exception('invalidcomponent');
1711     }
1713     // Check the ratingarea is entry (the only rating area in data).
1714     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'entry') {
1715         throw new rating_exception('invalidratingarea');
1716     }
1718     if (!isset($params['itemid'])) {
1719         throw new rating_exception('invaliditemid');
1720     }
1722     $datasql = "SELECT d.id as dataid, d.course, r.groupid
1723                   FROM {data_records} r
1724                   JOIN {data} d ON r.dataid = d.id
1725                  WHERE r.id = :itemid";
1726     $dataparams = array('itemid' => $params['itemid']);
1727     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1728         // Item doesn't exist.
1729         throw new rating_exception('invaliditemid');
1730     }
1732     // User can see ratings of all participants.
1733     if ($info->groupid == 0) {
1734         return true;
1735     }
1737     $course = $DB->get_record('course', array('id' => $info->course), '*', MUST_EXIST);
1738     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1740     // Make sure groups allow this user to see the item they're rating.
1741     return groups_group_visible($info->groupid, $course, $cm);
1745 /**
1746  * function that takes in the current data, number of items per page,
1747  * a search string and prints a preference box in view.php
1748  *
1749  * This preference box prints a searchable advanced search template if
1750  *     a) A template is defined
1751  *  b) The advanced search checkbox is checked.
1752  *
1753  * @global object
1754  * @global object
1755  * @param object $data
1756  * @param int $perpage
1757  * @param string $search
1758  * @param string $sort
1759  * @param string $order
1760  * @param array $search_array
1761  * @param int $advanced
1762  * @param string $mode
1763  * @return void
1764  */
1765 function data_print_preference_form($data, $perpage, $search, $sort='', $order='ASC', $search_array = '', $advanced = 0, $mode= ''){
1766     global $CFG, $DB, $PAGE, $OUTPUT;
1768     $cm = get_coursemodule_from_instance('data', $data->id);
1769     $context = context_module::instance($cm->id);
1770     echo '<br /><div class="datapreferences">';
1771     echo '<form id="options" action="view.php" method="get">';
1772     echo '<div>';
1773     echo '<input type="hidden" name="d" value="'.$data->id.'" />';
1774     if ($mode =='asearch') {
1775         $advanced = 1;
1776         echo '<input type="hidden" name="mode" value="list" />';
1777     }
1778     echo '<label for="pref_perpage">'.get_string('pagesize','data').'</label> ';
1779     $pagesizes = array(2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,15=>15,
1780                        20=>20,30=>30,40=>40,50=>50,100=>100,200=>200,300=>300,400=>400,500=>500,1000=>1000);
1781     echo html_writer::select($pagesizes, 'perpage', $perpage, false, array('id' => 'pref_perpage', 'class' => 'custom-select'));
1783     if ($advanced) {
1784         $regsearchclass = 'search_none';
1785         $advancedsearchclass = 'search_inline';
1786     } else {
1787         $regsearchclass = 'search_inline';
1788         $advancedsearchclass = 'search_none';
1789     }
1790     echo '<div id="reg_search" class="' . $regsearchclass . ' form-inline" >&nbsp;&nbsp;&nbsp;';
1791     echo '<label for="pref_search">' . get_string('search') . '</label> <input type="text" ' .
1792          'class="form-control" size="16" name="search" id= "pref_search" value="' . s($search) . '" /></div>';
1793     echo '&nbsp;&nbsp;&nbsp;<label for="pref_sortby">'.get_string('sortby').'</label> ';
1794     // foreach field, print the option
1795     echo '<select name="sort" id="pref_sortby" class="custom-select m-r-1">';
1796     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'name')) {
1797         echo '<optgroup label="'.get_string('fields', 'data').'">';
1798         foreach ($fields as $field) {
1799             if ($field->id == $sort) {
1800                 echo '<option value="'.$field->id.'" selected="selected">'.$field->name.'</option>';
1801             } else {
1802                 echo '<option value="'.$field->id.'">'.$field->name.'</option>';
1803             }
1804         }
1805         echo '</optgroup>';
1806     }
1807     $options = array();
1808     $options[DATA_TIMEADDED]    = get_string('timeadded', 'data');
1809     $options[DATA_TIMEMODIFIED] = get_string('timemodified', 'data');
1810     $options[DATA_FIRSTNAME]    = get_string('authorfirstname', 'data');
1811     $options[DATA_LASTNAME]     = get_string('authorlastname', 'data');
1812     if ($data->approval and has_capability('mod/data:approve', $context)) {
1813         $options[DATA_APPROVED] = get_string('approved', 'data');
1814     }
1815     echo '<optgroup label="'.get_string('other', 'data').'">';
1816     foreach ($options as $key => $name) {
1817         if ($key == $sort) {
1818             echo '<option value="'.$key.'" selected="selected">'.$name.'</option>';
1819         } else {
1820             echo '<option value="'.$key.'">'.$name.'</option>';
1821         }
1822     }
1823     echo '</optgroup>';
1824     echo '</select>';
1825     echo '<label for="pref_order" class="accesshide">'.get_string('order').'</label>';
1826     echo '<select id="pref_order" name="order" class="custom-select m-r-1">';
1827     if ($order == 'ASC') {
1828         echo '<option value="ASC" selected="selected">'.get_string('ascending','data').'</option>';
1829     } else {
1830         echo '<option value="ASC">'.get_string('ascending','data').'</option>';
1831     }
1832     if ($order == 'DESC') {
1833         echo '<option value="DESC" selected="selected">'.get_string('descending','data').'</option>';
1834     } else {
1835         echo '<option value="DESC">'.get_string('descending','data').'</option>';
1836     }
1837     echo '</select>';
1839     if ($advanced) {
1840         $checked = ' checked="checked" ';
1841     }
1842     else {
1843         $checked = '';
1844     }
1845     $PAGE->requires->js('/mod/data/data.js');
1846     echo '&nbsp;<input type="hidden" name="advanced" value="0" />';
1847     echo '&nbsp;<input type="hidden" name="filter" value="1" />';
1848     echo '&nbsp;<input type="checkbox" id="advancedcheckbox" name="advanced" value="1" ' . $checked . ' ' .
1849          'onchange="showHideAdvSearch(this.checked);" class="m-x-1" />' .
1850          '<label for="advancedcheckbox">' . get_string('advancedsearch', 'data') . '</label>';
1851     echo '&nbsp;<input type="submit" class="btn btn-secondary" value="' . get_string('savesettings', 'data') . '" />';
1853     echo '<br />';
1854     echo '<div class="' . $advancedsearchclass . '" id="data_adv_form">';
1855     echo '<table class="boxaligncenter">';
1857     // print ASC or DESC
1858     echo '<tr><td colspan="2">&nbsp;</td></tr>';
1859     $i = 0;
1861     // Determine if we are printing all fields for advanced search, or the template for advanced search
1862     // If a template is not defined, use the deafault template and display all fields.
1863     if(empty($data->asearchtemplate)) {
1864         data_generate_default_template($data, 'asearchtemplate');
1865     }
1867     static $fields = array();
1868     static $dataid = null;
1870     if (empty($dataid)) {
1871         $dataid = $data->id;
1872     } else if ($dataid != $data->id) {
1873         $fields = array();
1874     }
1876     if (empty($fields)) {
1877         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1878         foreach ($fieldrecords as $fieldrecord) {
1879             $fields[]= data_get_field($fieldrecord, $data);
1880         }
1881     }
1883     // Replacing tags
1884     $patterns = array();
1885     $replacement = array();
1887     // Then we generate strings to replace for normal tags
1888     foreach ($fields as $field) {
1889         $fieldname = $field->field->name;
1890         $fieldname = preg_quote($fieldname, '/');
1891         $patterns[] = "/\[\[$fieldname\]\]/i";
1892         $searchfield = data_get_field_from_id($field->field->id, $data);
1893         if (!empty($search_array[$field->field->id]->data)) {
1894             $replacement[] = $searchfield->display_search_field($search_array[$field->field->id]->data);
1895         } else {
1896             $replacement[] = $searchfield->display_search_field();
1897         }
1898     }
1899     $fn = !empty($search_array[DATA_FIRSTNAME]->data) ? $search_array[DATA_FIRSTNAME]->data : '';
1900     $ln = !empty($search_array[DATA_LASTNAME]->data) ? $search_array[DATA_LASTNAME]->data : '';
1901     $patterns[]    = '/##firstname##/';
1902     $replacement[] = '<label class="accesshide" for="u_fn">' . get_string('authorfirstname', 'data') . '</label>' .
1903                      '<input type="text" class="form-control" size="16" id="u_fn" name="u_fn" value="' . s($fn) . '" />';
1904     $patterns[]    = '/##lastname##/';
1905     $replacement[] = '<label class="accesshide" for="u_ln">' . get_string('authorlastname', 'data') . '</label>' .
1906                      '<input type="text" class="form-control" size="16" id="u_ln" name="u_ln" value="' . s($ln) . '" />';
1908     if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
1909         $patterns[] = "/##tags##/";
1910         $selectedtags = isset($search_array[DATA_TAGS]->rawtagnames) ? $search_array[DATA_TAGS]->rawtagnames : [];
1911         $replacement[] = data_generate_tag_form(false, $selectedtags);
1912     }
1914     // actual replacement of the tags
1915     $newtext = preg_replace($patterns, $replacement, $data->asearchtemplate);
1917     $options = new stdClass();
1918     $options->para=false;
1919     $options->noclean=true;
1920     echo '<tr><td>';
1921     echo format_text($newtext, FORMAT_HTML, $options);
1922     echo '</td></tr>';
1924     echo '<tr><td colspan="4"><br/>' .
1925          '<input type="submit" class="btn btn-primary m-r-1" value="' . get_string('savesettings', 'data') . '" />' .
1926          '<input type="submit" class="btn btn-secondary" name="resetadv" value="' . get_string('resetsettings', 'data') . '" />' .
1927          '</td></tr>';
1928     echo '</table>';
1929     echo '</div>';
1930     echo '</div>';
1931     echo '</form>';
1932     echo '</div>';
1935 /**
1936  * @global object
1937  * @global object
1938  * @param object $data
1939  * @param object $record
1940  * @return void Output echo'd
1941  */
1942 function data_print_ratings($data, $record) {
1943     global $OUTPUT;
1944     if (!empty($record->rating)){
1945         echo $OUTPUT->render($record->rating);
1946     }
1949 /**
1950  * List the actions that correspond to a view of this module.
1951  * This is used by the participation report.
1952  *
1953  * Note: This is not used by new logging system. Event with
1954  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
1955  *       be considered as view action.
1956  *
1957  * @return array
1958  */
1959 function data_get_view_actions() {
1960     return array('view');
1963 /**
1964  * List the actions that correspond to a post of this module.
1965  * This is used by the participation report.
1966  *
1967  * Note: This is not used by new logging system. Event with
1968  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
1969  *       will be considered as post action.
1970  *
1971  * @return array
1972  */
1973 function data_get_post_actions() {
1974     return array('add','update','record delete');
1977 /**
1978  * @param string $name
1979  * @param int $dataid
1980  * @param int $fieldid
1981  * @return bool
1982  */
1983 function data_fieldname_exists($name, $dataid, $fieldid = 0) {
1984     global $DB;
1986     if (!is_numeric($name)) {
1987         $like = $DB->sql_like('df.name', ':name', false);
1988     } else {
1989         $like = "df.name = :name";
1990     }
1991     $params = array('name'=>$name);
1992     if ($fieldid) {
1993         $params['dataid']   = $dataid;
1994         $params['fieldid1'] = $fieldid;
1995         $params['fieldid2'] = $fieldid;
1996         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1997                                         WHERE $like AND df.dataid = :dataid
1998                                               AND ((df.id < :fieldid1) OR (df.id > :fieldid2))", $params);
1999     } else {
2000         $params['dataid']   = $dataid;
2001         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
2002                                         WHERE $like AND df.dataid = :dataid", $params);
2003     }
2006 /**
2007  * @param array $fieldinput
2008  */
2009 function data_convert_arrays_to_strings(&$fieldinput) {
2010     foreach ($fieldinput as $key => $val) {
2011         if (is_array($val)) {
2012             $str = '';
2013             foreach ($val as $inner) {
2014                 $str .= $inner . ',';
2015             }
2016             $str = substr($str, 0, -1);
2018             $fieldinput->$key = $str;
2019         }
2020     }
2024 /**
2025  * Converts a database (module instance) to use the Roles System
2026  *
2027  * @global object
2028  * @global object
2029  * @uses CONTEXT_MODULE
2030  * @uses CAP_PREVENT
2031  * @uses CAP_ALLOW
2032  * @param object $data a data object with the same attributes as a record
2033  *                     from the data database table
2034  * @param int $datamodid the id of the data module, from the modules table
2035  * @param array $teacherroles array of roles that have archetype teacher
2036  * @param array $studentroles array of roles that have archetype student
2037  * @param array $guestroles array of roles that have archetype guest
2038  * @param int $cmid the course_module id for this data instance
2039  * @return boolean data module was converted or not
2040  */
2041 function data_convert_to_roles($data, $teacherroles=array(), $studentroles=array(), $cmid=NULL) {
2042     global $CFG, $DB, $OUTPUT;
2044     if (!isset($data->participants) && !isset($data->assesspublic)
2045             && !isset($data->groupmode)) {
2046         // We assume that this database has already been converted to use the
2047         // Roles System. above fields get dropped the data module has been
2048         // upgraded to use Roles.
2049         return false;
2050     }
2052     if (empty($cmid)) {
2053         // We were not given the course_module id. Try to find it.
2054         if (!$cm = get_coursemodule_from_instance('data', $data->id)) {
2055             echo $OUTPUT->notification('Could not get the course module for the data');
2056             return false;
2057         } else {
2058             $cmid = $cm->id;
2059         }
2060     }
2061     $context = context_module::instance($cmid);
2064     // $data->participants:
2065     // 1 - Only teachers can add entries
2066     // 3 - Teachers and students can add entries
2067     switch ($data->participants) {
2068         case 1:
2069             foreach ($studentroles as $studentrole) {
2070                 assign_capability('mod/data:writeentry', CAP_PREVENT, $studentrole->id, $context->id);
2071             }
2072             foreach ($teacherroles as $teacherrole) {
2073                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
2074             }
2075             break;
2076         case 3:
2077             foreach ($studentroles as $studentrole) {
2078                 assign_capability('mod/data:writeentry', CAP_ALLOW, $studentrole->id, $context->id);
2079             }
2080             foreach ($teacherroles as $teacherrole) {
2081                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
2082             }
2083             break;
2084     }
2086     // $data->assessed:
2087     // 2 - Only teachers can rate posts
2088     // 1 - Everyone can rate posts
2089     // 0 - No one can rate posts
2090     switch ($data->assessed) {
2091         case 0:
2092             foreach ($studentroles as $studentrole) {
2093                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2094             }
2095             foreach ($teacherroles as $teacherrole) {
2096                 assign_capability('mod/data:rate', CAP_PREVENT, $teacherrole->id, $context->id);
2097             }
2098             break;
2099         case 1:
2100             foreach ($studentroles as $studentrole) {
2101                 assign_capability('mod/data:rate', CAP_ALLOW, $studentrole->id, $context->id);
2102             }
2103             foreach ($teacherroles as $teacherrole) {
2104                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2105             }
2106             break;
2107         case 2:
2108             foreach ($studentroles as $studentrole) {
2109                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
2110             }
2111             foreach ($teacherroles as $teacherrole) {
2112                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
2113             }
2114             break;
2115     }
2117     // $data->assesspublic:
2118     // 0 - Students can only see their own ratings
2119     // 1 - Students can see everyone's ratings
2120     switch ($data->assesspublic) {
2121         case 0:
2122             foreach ($studentroles as $studentrole) {
2123                 assign_capability('mod/data:viewrating', CAP_PREVENT, $studentrole->id, $context->id);
2124             }
2125             foreach ($teacherroles as $teacherrole) {
2126                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2127             }
2128             break;
2129         case 1:
2130             foreach ($studentroles as $studentrole) {
2131                 assign_capability('mod/data:viewrating', CAP_ALLOW, $studentrole->id, $context->id);
2132             }
2133             foreach ($teacherroles as $teacherrole) {
2134                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
2135             }
2136             break;
2137     }
2139     if (empty($cm)) {
2140         $cm = $DB->get_record('course_modules', array('id'=>$cmid));
2141     }
2143     switch ($cm->groupmode) {
2144         case NOGROUPS:
2145             break;
2146         case SEPARATEGROUPS:
2147             foreach ($studentroles as $studentrole) {
2148                 assign_capability('moodle/site:accessallgroups', CAP_PREVENT, $studentrole->id, $context->id);
2149             }
2150             foreach ($teacherroles as $teacherrole) {
2151                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2152             }
2153             break;
2154         case VISIBLEGROUPS:
2155             foreach ($studentroles as $studentrole) {
2156                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $studentrole->id, $context->id);
2157             }
2158             foreach ($teacherroles as $teacherrole) {
2159                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
2160             }
2161             break;
2162     }
2163     return true;
2166 /**
2167  * Returns the best name to show for a preset
2168  *
2169  * @param string $shortname
2170  * @param  string $path
2171  * @return string
2172  */
2173 function data_preset_name($shortname, $path) {
2175     // We are looking inside the preset itself as a first choice, but also in normal data directory
2176     $string = get_string('modulename', 'datapreset_'.$shortname);
2178     if (substr($string, 0, 1) == '[') {
2179         return $shortname;
2180     } else {
2181         return $string;
2182     }
2185 /**
2186  * Returns an array of all the available presets.
2187  *
2188  * @return array
2189  */
2190 function data_get_available_presets($context) {
2191     global $CFG, $USER;
2193     $presets = array();
2195     // First load the ratings sub plugins that exist within the modules preset dir
2196     if ($dirs = core_component::get_plugin_list('datapreset')) {
2197         foreach ($dirs as $dir=>$fulldir) {
2198             if (is_directory_a_preset($fulldir)) {
2199                 $preset = new stdClass();
2200                 $preset->path = $fulldir;
2201                 $preset->userid = 0;
2202                 $preset->shortname = $dir;
2203                 $preset->name = data_preset_name($dir, $fulldir);
2204                 if (file_exists($fulldir.'/screenshot.jpg')) {
2205                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.jpg';
2206                 } else if (file_exists($fulldir.'/screenshot.png')) {
2207                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.png';
2208                 } else if (file_exists($fulldir.'/screenshot.gif')) {
2209                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.gif';
2210                 }
2211                 $presets[] = $preset;
2212             }
2213         }
2214     }
2215     // Now add to that the site presets that people have saved
2216     $presets = data_get_available_site_presets($context, $presets);
2217     return $presets;
2220 /**
2221  * Gets an array of all of the presets that users have saved to the site.
2222  *
2223  * @param stdClass $context The context that we are looking from.
2224  * @param array $presets
2225  * @return array An array of presets
2226  */
2227 function data_get_available_site_presets($context, array $presets=array()) {
2228     global $USER;
2230     $fs = get_file_storage();
2231     $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2232     $canviewall = has_capability('mod/data:viewalluserpresets', $context);
2233     if (empty($files)) {
2234         return $presets;
2235     }
2236     foreach ($files as $file) {
2237         if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory() || (!$canviewall && $file->get_userid() != $USER->id)) {
2238             continue;
2239         }
2240         $preset = new stdClass;
2241         $preset->path = $file->get_filepath();
2242         $preset->name = trim($preset->path, '/');
2243         $preset->shortname = $preset->name;
2244         $preset->userid = $file->get_userid();
2245         $preset->id = $file->get_id();
2246         $preset->storedfile = $file;
2247         $presets[] = $preset;
2248     }
2249     return $presets;
2252 /**
2253  * Deletes a saved preset.
2254  *
2255  * @param string $name
2256  * @return bool
2257  */
2258 function data_delete_site_preset($name) {
2259     $fs = get_file_storage();
2261     $files = $fs->get_directory_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/');
2262     if (!empty($files)) {
2263         foreach ($files as $file) {
2264             $file->delete();
2265         }
2266     }
2268     $dir = $fs->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/', '.');
2269     if (!empty($dir)) {
2270         $dir->delete();
2271     }
2272     return true;
2275 /**
2276  * Prints the heads for a page
2277  *
2278  * @param stdClass $course
2279  * @param stdClass $cm
2280  * @param stdClass $data
2281  * @param string $currenttab
2282  */
2283 function data_print_header($course, $cm, $data, $currenttab='') {
2285     global $CFG, $displaynoticegood, $displaynoticebad, $OUTPUT, $PAGE;
2287     $PAGE->set_title($data->name);
2288     echo $OUTPUT->header();
2289     echo $OUTPUT->heading(format_string($data->name), 2);
2290     echo $OUTPUT->box(format_module_intro('data', $data, $cm->id), 'generalbox', 'intro');
2292     // Groups needed for Add entry tab
2293     $currentgroup = groups_get_activity_group($cm);
2294     $groupmode = groups_get_activity_groupmode($cm);
2296     // Print the tabs
2298     if ($currenttab) {
2299         include('tabs.php');
2300     }
2302     // Print any notices
2304     if (!empty($displaynoticegood)) {
2305         echo $OUTPUT->notification($displaynoticegood, 'notifysuccess');    // good (usually green)
2306     } else if (!empty($displaynoticebad)) {
2307         echo $OUTPUT->notification($displaynoticebad);                     // bad (usuually red)
2308     }
2311 /**
2312  * Can user add more entries?
2313  *
2314  * @param object $data
2315  * @param mixed $currentgroup
2316  * @param int $groupmode
2317  * @param stdClass $context
2318  * @return bool
2319  */
2320 function data_user_can_add_entry($data, $currentgroup, $groupmode, $context = null) {
2321     global $USER;
2323     if (empty($context)) {
2324         $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
2325         $context = context_module::instance($cm->id);
2326     }
2328     if (has_capability('mod/data:manageentries', $context)) {
2329         // no entry limits apply if user can manage
2331     } else if (!has_capability('mod/data:writeentry', $context)) {
2332         return false;
2334     } else if (data_atmaxentries($data)) {
2335         return false;
2336     } else if (data_in_readonly_period($data)) {
2337         // Check whether we're in a read-only period
2338         return false;
2339     }
2341     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
2342         return true;
2343     }
2345     if ($currentgroup) {
2346         return groups_is_member($currentgroup);
2347     } else {
2348         //else it might be group 0 in visible mode
2349         if ($groupmode == VISIBLEGROUPS){
2350             return true;
2351         } else {
2352             return false;
2353         }
2354     }
2357 /**
2358  * Check whether the current user is allowed to manage the given record considering manageentries capability,
2359  * data_in_readonly_period() result, ownership (determined by data_isowner()) and manageapproved setting.
2360  * @param mixed $record record object or id
2361  * @param object $data data object
2362  * @param object $context context object
2363  * @return bool returns true if the user is allowd to edit the entry, false otherwise
2364  */
2365 function data_user_can_manage_entry($record, $data, $context) {
2366     global $DB;
2368     if (has_capability('mod/data:manageentries', $context)) {
2369         return true;
2370     }
2372     // Check whether this activity is read-only at present.
2373     $readonly = data_in_readonly_period($data);
2375     if (!$readonly) {
2376         // Get record object from db if just id given like in data_isowner.
2377         // ...done before calling data_isowner() to avoid querying db twice.
2378         if (!is_object($record)) {
2379             if (!$record = $DB->get_record('data_records', array('id' => $record))) {
2380                 return false;
2381             }
2382         }
2383         if (data_isowner($record)) {
2384             if ($data->approval && $record->approved) {
2385                 return $data->manageapproved == 1;
2386             } else {
2387                 return true;
2388             }
2389         }
2390     }
2392     return false;
2395 /**
2396  * Check whether the specified database activity is currently in a read-only period
2397  *
2398  * @param object $data
2399  * @return bool returns true if the time fields in $data indicate a read-only period; false otherwise
2400  */
2401 function data_in_readonly_period($data) {
2402     $now = time();
2403     if (!$data->timeviewfrom && !$data->timeviewto) {
2404         return false;
2405     } else if (($data->timeviewfrom && $now < $data->timeviewfrom) || ($data->timeviewto && $now > $data->timeviewto)) {
2406         return false;
2407     }
2408     return true;
2411 /**
2412  * @return bool
2413  */
2414 function is_directory_a_preset($directory) {
2415     $directory = rtrim($directory, '/\\') . '/';
2416     $status = file_exists($directory.'singletemplate.html') &&
2417               file_exists($directory.'listtemplate.html') &&
2418               file_exists($directory.'listtemplateheader.html') &&
2419               file_exists($directory.'listtemplatefooter.html') &&
2420               file_exists($directory.'addtemplate.html') &&
2421               file_exists($directory.'rsstemplate.html') &&
2422               file_exists($directory.'rsstitletemplate.html') &&
2423               file_exists($directory.'csstemplate.css') &&
2424               file_exists($directory.'jstemplate.js') &&
2425               file_exists($directory.'preset.xml');
2427     return $status;
2430 /**
2431  * Abstract class used for data preset importers
2432  */
2433 abstract class data_preset_importer {
2435     protected $course;
2436     protected $cm;
2437     protected $module;
2438     protected $directory;
2440     /**
2441      * Constructor
2442      *
2443      * @param stdClass $course
2444      * @param stdClass $cm
2445      * @param stdClass $module
2446      * @param string $directory
2447      */
2448     public function __construct($course, $cm, $module, $directory) {
2449         $this->course = $course;
2450         $this->cm = $cm;
2451         $this->module = $module;
2452         $this->directory = $directory;
2453     }
2455     /**
2456      * Returns the name of the directory the preset is located in
2457      * @return string
2458      */
2459     public function get_directory() {
2460         return basename($this->directory);
2461     }
2463     /**
2464      * Retreive the contents of a file. That file may either be in a conventional directory of the Moodle file storage
2465      * @param file_storage $filestorage. should be null if using a conventional directory
2466      * @param stored_file $fileobj the directory to look in. null if using a conventional directory
2467      * @param string $dir the directory to look in. null if using the Moodle file storage
2468      * @param string $filename the name of the file we want
2469      * @return string the contents of the file or null if the file doesn't exist.
2470      */
2471     public function data_preset_get_file_contents(&$filestorage, &$fileobj, $dir, $filename) {
2472         if(empty($filestorage) || empty($fileobj)) {
2473             if (substr($dir, -1)!='/') {
2474                 $dir .= '/';
2475             }
2476             if (file_exists($dir.$filename)) {
2477                 return file_get_contents($dir.$filename);
2478             } else {
2479                 return null;
2480             }
2481         } else {
2482             if ($filestorage->file_exists(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename)) {
2483                 $file = $filestorage->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename);
2484                 return $file->get_content();
2485             } else {
2486                 return null;
2487             }
2488         }
2490     }
2491     /**
2492      * Gets the preset settings
2493      * @global moodle_database $DB
2494      * @return stdClass
2495      */
2496     public function get_preset_settings() {
2497         global $DB;
2499         $fs = $fileobj = null;
2500         if (!is_directory_a_preset($this->directory)) {
2501             //maybe the user requested a preset stored in the Moodle file storage
2503             $fs = get_file_storage();
2504             $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2506             //preset name to find will be the final element of the directory
2507             $explodeddirectory = explode('/', $this->directory);
2508             $presettofind = end($explodeddirectory);
2510             //now go through the available files available and see if we can find it
2511             foreach ($files as $file) {
2512                 if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory()) {
2513                     continue;
2514                 }
2515                 $presetname = trim($file->get_filepath(), '/');
2516                 if ($presetname==$presettofind) {
2517                     $this->directory = $presetname;
2518                     $fileobj = $file;
2519                 }
2520             }
2522             if (empty($fileobj)) {
2523                 print_error('invalidpreset', 'data', '', $this->directory);
2524             }
2525         }
2527         $allowed_settings = array(
2528             'intro',
2529             'comments',
2530             'requiredentries',
2531             'requiredentriestoview',
2532             'maxentries',
2533             'rssarticles',
2534             'approval',
2535             'defaultsortdir',
2536             'defaultsort');
2538         $result = new stdClass;
2539         $result->settings = new stdClass;
2540         $result->importfields = array();
2541         $result->currentfields = $DB->get_records('data_fields', array('dataid'=>$this->module->id));
2542         if (!$result->currentfields) {
2543             $result->currentfields = array();
2544         }
2547         /* Grab XML */
2548         $presetxml = $this->data_preset_get_file_contents($fs, $fileobj, $this->directory,'preset.xml');
2549         $parsedxml = xmlize($presetxml, 0);
2551         /* First, do settings. Put in user friendly array. */
2552         $settingsarray = $parsedxml['preset']['#']['settings'][0]['#'];
2553         $result->settings = new StdClass();
2554         foreach ($settingsarray as $setting => $value) {
2555             if (!is_array($value) || !in_array($setting, $allowed_settings)) {
2556                 // unsupported setting
2557                 continue;
2558             }
2559             $result->settings->$setting = $value[0]['#'];
2560         }
2562         /* Now work out fields to user friendly array */
2563         $fieldsarray = $parsedxml['preset']['#']['field'];
2564         foreach ($fieldsarray as $field) {
2565             if (!is_array($field)) {
2566                 continue;
2567             }
2568             $f = new StdClass();
2569             foreach ($field['#'] as $param => $value) {
2570                 if (!is_array($value)) {
2571                     continue;
2572                 }
2573                 $f->$param = $value[0]['#'];
2574             }
2575             $f->dataid = $this->module->id;
2576             $f->type = clean_param($f->type, PARAM_ALPHA);
2577             $result->importfields[] = $f;
2578         }
2579         /* Now add the HTML templates to the settings array so we can update d */
2580         $result->settings->singletemplate     = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"singletemplate.html");
2581         $result->settings->listtemplate       = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplate.html");
2582         $result->settings->listtemplateheader = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplateheader.html");
2583         $result->settings->listtemplatefooter = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplatefooter.html");
2584         $result->settings->addtemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"addtemplate.html");
2585         $result->settings->rsstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstemplate.html");
2586         $result->settings->rsstitletemplate   = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstitletemplate.html");
2587         $result->settings->csstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"csstemplate.css");
2588         $result->settings->jstemplate         = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"jstemplate.js");
2589         $result->settings->asearchtemplate    = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"asearchtemplate.html");
2591         $result->settings->instance = $this->module->id;
2592         return $result;
2593     }
2595     /**
2596      * Import the preset into the given database module
2597      * @return bool
2598      */
2599     function import($overwritesettings) {
2600         global $DB, $CFG;
2602         $params = $this->get_preset_settings();
2603         $settings = $params->settings;
2604         $newfields = $params->importfields;
2605         $currentfields = $params->currentfields;
2606         $preservedfields = array();
2608         /* Maps fields and makes new ones */
2609         if (!empty($newfields)) {
2610             /* We require an injective mapping, and need to know what to protect */
2611             foreach ($newfields as $nid => $newfield) {
2612                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2613                 if ($cid == -1) {
2614                     continue;
2615                 }
2616                 if (array_key_exists($cid, $preservedfields)){
2617                     print_error('notinjectivemap', 'data');
2618                 }
2619                 else $preservedfields[$cid] = true;
2620             }
2622             foreach ($newfields as $nid => $newfield) {
2623                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2625                 /* A mapping. Just need to change field params. Data kept. */
2626                 if ($cid != -1 and isset($currentfields[$cid])) {
2627                     $fieldobject = data_get_field_from_id($currentfields[$cid]->id, $this->module);
2628                     foreach ($newfield as $param => $value) {
2629                         if ($param != "id") {
2630                             $fieldobject->field->$param = $value;
2631                         }
2632                     }
2633                     unset($fieldobject->field->similarfield);
2634                     $fieldobject->update_field();
2635                     unset($fieldobject);
2636                 } else {
2637                     /* Make a new field */
2638                     include_once("field/$newfield->type/field.class.php");
2640                     if (!isset($newfield->description)) {
2641                         $newfield->description = '';
2642                     }
2643                     $classname = 'data_field_'.$newfield->type;
2644                     $fieldclass = new $classname($newfield, $this->module);
2645                     $fieldclass->insert_field();
2646                     unset($fieldclass);
2647                 }
2648             }
2649         }
2651         /* Get rid of all old unused data */
2652         if (!empty($preservedfields)) {
2653             foreach ($currentfields as $cid => $currentfield) {
2654                 if (!array_key_exists($cid, $preservedfields)) {
2655                     /* Data not used anymore so wipe! */
2656                     print "Deleting field $currentfield->name<br />";
2658                     $id = $currentfield->id;
2659                     //Why delete existing data records and related comments/ratings??
2660                     $DB->delete_records('data_content', array('fieldid'=>$id));
2661                     $DB->delete_records('data_fields', array('id'=>$id));
2662                 }
2663             }
2664         }
2666         // handle special settings here
2667         if (!empty($settings->defaultsort)) {
2668             if (is_numeric($settings->defaultsort)) {
2669                 // old broken value
2670                 $settings->defaultsort = 0;
2671             } else {
2672                 $settings->defaultsort = (int)$DB->get_field('data_fields', 'id', array('dataid'=>$this->module->id, 'name'=>$settings->defaultsort));
2673             }
2674         } else {
2675             $settings->defaultsort = 0;
2676         }
2678         // do we want to overwrite all current database settings?
2679         if ($overwritesettings) {
2680             // all supported settings
2681             $overwrite = array_keys((array)$settings);
2682         } else {
2683             // only templates and sorting
2684             $overwrite = array('singletemplate', 'listtemplate', 'listtemplateheader', 'listtemplatefooter',
2685                                'addtemplate', 'rsstemplate', 'rsstitletemplate', 'csstemplate', 'jstemplate',
2686                                'asearchtemplate', 'defaultsortdir', 'defaultsort');
2687         }
2689         // now overwrite current data settings
2690         foreach ($this->module as $prop=>$unused) {
2691             if (in_array($prop, $overwrite)) {
2692                 $this->module->$prop = $settings->$prop;
2693             }
2694         }
2696         data_update_instance($this->module);
2698         return $this->cleanup();
2699     }
2701     /**
2702      * Any clean up routines should go here
2703      * @return bool
2704      */
2705     public function cleanup() {
2706         return true;
2707     }
2710 /**
2711  * Data preset importer for uploaded presets
2712  */
2713 class data_preset_upload_importer extends data_preset_importer {
2714     public function __construct($course, $cm, $module, $filepath) {
2715         global $USER;
2716         if (is_file($filepath)) {
2717             $fp = get_file_packer();
2718             if ($fp->extract_to_pathname($filepath, $filepath.'_extracted')) {
2719                 fulldelete($filepath);
2720             }
2721             $filepath .= '_extracted';
2722         }
2723         parent::__construct($course, $cm, $module, $filepath);
2724     }
2725     public function cleanup() {
2726         return fulldelete($this->directory);
2727     }
2730 /**
2731  * Data preset importer for existing presets
2732  */
2733 class data_preset_existing_importer extends data_preset_importer {
2734     protected $userid;
2735     public function __construct($course, $cm, $module, $fullname) {
2736         global $USER;
2737         list($userid, $shortname) = explode('/', $fullname, 2);
2738         $context = context_module::instance($cm->id);
2739         if ($userid && ($userid != $USER->id) && !has_capability('mod/data:manageuserpresets', $context) && !has_capability('mod/data:viewalluserpresets', $context)) {
2740            throw new coding_exception('Invalid preset provided');
2741         }
2743         $this->userid = $userid;
2744         $filepath = data_preset_path($course, $userid, $shortname);
2745         parent::__construct($course, $cm, $module, $filepath);
2746     }
2747     public function get_userid() {
2748         return $this->userid;
2749     }
2752 /**
2753  * @global object
2754  * @global object
2755  * @param object $course
2756  * @param int $userid
2757  * @param string $shortname
2758  * @return string
2759  */
2760 function data_preset_path($course, $userid, $shortname) {
2761     global $USER, $CFG;
2763     $context = context_course::instance($course->id);
2765     $userid = (int)$userid;
2767     $path = null;
2768     if ($userid > 0 && ($userid == $USER->id || has_capability('mod/data:viewalluserpresets', $context))) {
2769         $path = $CFG->dataroot.'/data/preset/'.$userid.'/'.$shortname;
2770     } else if ($userid == 0) {
2771         $path = $CFG->dirroot.'/mod/data/preset/'.$shortname;
2772     } else if ($userid < 0) {
2773         $path = $CFG->tempdir.'/data/'.-$userid.'/'.$shortname;
2774     }
2776     return $path;
2779 /**
2780  * Implementation of the function for printing the form elements that control
2781  * whether the course reset functionality affects the data.
2782  *
2783  * @param $mform form passed by reference
2784  */
2785 function data_reset_course_form_definition(&$mform) {
2786     $mform->addElement('header', 'dataheader', get_string('modulenameplural', 'data'));
2787     $mform->addElement('checkbox', 'reset_data', get_string('deleteallentries','data'));
2789     $mform->addElement('checkbox', 'reset_data_notenrolled', get_string('deletenotenrolled', 'data'));
2790     $mform->disabledIf('reset_data_notenrolled', 'reset_data', 'checked');
2792     $mform->addElement('checkbox', 'reset_data_ratings', get_string('deleteallratings'));
2793     $mform->disabledIf('reset_data_ratings', 'reset_data', 'checked');
2795     $mform->addElement('checkbox', 'reset_data_comments', get_string('deleteallcomments'));
2796     $mform->disabledIf('reset_data_comments', 'reset_data', 'checked');
2799 /**
2800  * Course reset form defaults.
2801  * @return array
2802  */
2803 function data_reset_course_form_defaults($course) {
2804     return array('reset_data'=>0, 'reset_data_ratings'=>1, 'reset_data_comments'=>1, 'reset_data_notenrolled'=>0);
2807 /**
2808  * Removes all grades from gradebook
2809  *
2810  * @global object
2811  * @global object
2812  * @param int $courseid
2813  * @param string $type optional type
2814  */
2815 function data_reset_gradebook($courseid, $type='') {
2816     global $CFG, $DB;
2818     $sql = "SELECT d.*, cm.idnumber as cmidnumber, d.course as courseid
2819               FROM {data} d, {course_modules} cm, {modules} m
2820              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id AND d.course=?";
2822     if ($datas = $DB->get_records_sql($sql, array($courseid))) {
2823         foreach ($datas as $data) {
2824             data_grade_item_update($data, 'reset');
2825         }
2826     }
2829 /**
2830  * Actual implementation of the reset course functionality, delete all the
2831  * data responses for course $data->courseid.
2832  *
2833  * @global object
2834  * @global object
2835  * @param object $data the data submitted from the reset course.
2836  * @return array status array
2837  */
2838 function data_reset_userdata($data) {
2839     global $CFG, $DB;
2840     require_once($CFG->libdir.'/filelib.php');
2841     require_once($CFG->dirroot.'/rating/lib.php');
2843     $componentstr = get_string('modulenameplural', 'data');
2844     $status = array();
2846     $allrecordssql = "SELECT r.id
2847                         FROM {data_records} r
2848                              INNER JOIN {data} d ON r.dataid = d.id
2849                        WHERE d.course = ?";
2851     $alldatassql = "SELECT d.id
2852                       FROM {data} d
2853                      WHERE d.course=?";
2855     $rm = new rating_manager();
2856     $ratingdeloptions = new stdClass;
2857     $ratingdeloptions->component = 'mod_data';
2858     $ratingdeloptions->ratingarea = 'entry';
2860     // Set the file storage - may need it to remove files later.
2861     $fs = get_file_storage();
2863     // delete entries if requested
2864     if (!empty($data->reset_data)) {
2865         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2866         $DB->delete_records_select('data_content', "recordid IN ($allrecordssql)", array($data->courseid));
2867         $DB->delete_records_select('data_records', "dataid IN ($alldatassql)", array($data->courseid));
2869         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2870             foreach ($datas as $dataid=>$unused) {
2871                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2872                     continue;
2873                 }
2874                 $datacontext = context_module::instance($cm->id);
2876                 // Delete any files that may exist.
2877                 $fs->delete_area_files($datacontext->id, 'mod_data', 'content');
2879                 $ratingdeloptions->contextid = $datacontext->id;
2880                 $rm->delete_ratings($ratingdeloptions);
2881             }
2882         }
2884         if (empty($data->reset_gradebook_grades)) {
2885             // remove all grades from gradebook
2886             data_reset_gradebook($data->courseid);
2887         }
2888         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallentries', 'data'), 'error'=>false);
2889     }
2891     // remove entries by users not enrolled into course
2892     if (!empty($data->reset_data_notenrolled)) {
2893         $recordssql = "SELECT r.id, r.userid, r.dataid, u.id AS userexists, u.deleted AS userdeleted
2894                          FROM {data_records} r
2895                               JOIN {data} d ON r.dataid = d.id
2896                               LEFT JOIN {user} u ON r.userid = u.id
2897                         WHERE d.course = ? AND r.userid > 0";
2899         $course_context = context_course::instance($data->courseid);
2900         $notenrolled = array();
2901         $fields = array();
2902         $rs = $DB->get_recordset_sql($recordssql, array($data->courseid));
2903         foreach ($rs as $record) {
2904             if (array_key_exists($record->userid, $notenrolled) or !$record->userexists or $record->userdeleted
2905               or !is_enrolled($course_context, $record->userid)) {
2906                 //delete ratings
2907                 if (!$cm = get_coursemodule_from_instance('data', $record->dataid)) {
2908                     continue;
2909                 }
2910                 $datacontext = context_module::instance($cm->id);
2911                 $ratingdeloptions->contextid = $datacontext->id;
2912                 $ratingdeloptions->itemid = $record->id;
2913                 $rm->delete_ratings($ratingdeloptions);
2915                 // Delete any files that may exist.
2916                 if ($contents = $DB->get_records('data_content', array('recordid' => $record->id), '', 'id')) {
2917                     foreach ($contents as $content) {
2918                         $fs->delete_area_files($datacontext->id, 'mod_data', 'content', $content->id);
2919                     }
2920                 }
2921                 $notenrolled[$record->userid] = true;
2923                 $DB->delete_records('comments', array('itemid' => $record->id, 'commentarea' => 'database_entry'));
2924                 $DB->delete_records('data_content', array('recordid' => $record->id));
2925                 $DB->delete_records('data_records', array('id' => $record->id));
2926             }
2927         }
2928         $rs->close();
2929         $status[] = array('component'=>$componentstr, 'item'=>get_string('deletenotenrolled', 'data'), 'error'=>false);
2930     }
2932     // remove all ratings
2933     if (!empty($data->reset_data_ratings)) {
2934         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2935             foreach ($datas as $dataid=>$unused) {
2936                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2937                     continue;
2938                 }
2939                 $datacontext = context_module::instance($cm->id);
2941                 $ratingdeloptions->contextid = $datacontext->id;
2942                 $rm->delete_ratings($ratingdeloptions);
2943             }
2944         }
2946         if (empty($data->reset_gradebook_grades)) {
2947             // remove all grades from gradebook
2948             data_reset_gradebook($data->courseid);
2949         }
2951         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallratings'), 'error'=>false);
2952     }
2954     // remove all comments
2955     if (!empty($data->reset_data_comments)) {
2956         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2957         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallcomments'), 'error'=>false);
2958     }
2960     // updating dates - shift may be negative too
2961     if ($data->timeshift) {
2962         // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
2963         // See MDL-9367.
2964         shift_course_mod_dates('data', array('timeavailablefrom', 'timeavailableto',
2965             'timeviewfrom', 'timeviewto', 'assesstimestart', 'assesstimefinish'), $data->timeshift, $data->courseid);
2966         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
2967     }
2969     return $status;
2972 /**
2973  * Returns all other caps used in module
2974  *
2975  * @return array
2976  */
2977 function data_get_extra_capabilities() {
2978     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');
2981 /**
2982  * @param string $feature FEATURE_xx constant for requested feature
2983  * @return mixed True if module supports feature, null if doesn't know
2984  */
2985 function data_supports($feature) {
2986     switch($feature) {
2987         case FEATURE_GROUPS:                  return true;
2988         case FEATURE_GROUPINGS:               return true;
2989         case FEATURE_MOD_INTRO:               return true;
2990         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
2991         case FEATURE_COMPLETION_HAS_RULES:    return true;
2992         case FEATURE_GRADE_HAS_GRADE:         return true;
2993         case FEATURE_GRADE_OUTCOMES:          return true;
2994         case FEATURE_RATE:                    return true;
2995         case FEATURE_BACKUP_MOODLE2:          return true;
2996         case FEATURE_SHOW_DESCRIPTION:        return true;
2997         case FEATURE_COMMENT:                 return true;
2999         default: return null;
3000     }
3002 /**
3003  * @global object
3004  * @param array $export
3005  * @param string $delimiter_name
3006  * @param object $database
3007  * @param int $count
3008  * @param bool $return
3009  * @return string|void
3010  */
3011 function data_export_csv($export, $delimiter_name, $database, $count, $return=false) {
3012     global $CFG;
3013     require_once($CFG->libdir . '/csvlib.class.php');
3015     $filename = $database . '-' . $count . '-record';
3016     if ($count > 1) {
3017         $filename .= 's';
3018     }
3019     if ($return) {
3020         return csv_export_writer::print_array($export, $delimiter_name, '"', true);
3021     } else {
3022         csv_export_writer::download_array($filename, $export, $delimiter_name);
3023     }
3026 /**
3027  * @global object
3028  * @param array $export
3029  * @param string $dataname
3030  * @param int $count
3031  * @return string
3032  */
3033 function data_export_xls($export, $dataname, $count) {
3034     global $CFG;
3035     require_once("$CFG->libdir/excellib.class.php");
3036     $filename = clean_filename("{$dataname}-{$count}_record");
3037     if ($count > 1) {
3038         $filename .= 's';
3039     }
3040     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
3041     $filename .= '.xls';
3043     $filearg = '-';
3044     $workbook = new MoodleExcelWorkbook($filearg);
3045     $workbook->send($filename);
3046     $worksheet = array();
3047     $worksheet[0] = $workbook->add_worksheet('');
3048     $rowno = 0;
3049     foreach ($export as $row) {
3050         $colno = 0;
3051         foreach($row as $col) {
3052             $worksheet[0]->write($rowno, $colno, $col);
3053             $colno++;
3054         }
3055         $rowno++;
3056     }
3057     $workbook->close();
3058     return $filename;
3061 /**
3062  * @global object
3063  * @param array $export
3064  * @param string $dataname
3065  * @param int $count
3066  * @param string
3067  */
3068 function data_export_ods($export, $dataname, $count) {
3069     global $CFG;
3070     require_once("$CFG->libdir/odslib.class.php");
3071     $filename = clean_filename("{$dataname}-{$count}_record");
3072     if ($count > 1) {
3073         $filename .= 's';
3074     }
3075     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
3076     $filename .= '.ods';
3077     $filearg = '-';
3078     $workbook = new MoodleODSWorkbook($filearg);
3079     $workbook->send($filename);
3080     $worksheet = array();
3081     $worksheet[0] = $workbook->add_worksheet('');
3082     $rowno = 0;
3083     foreach ($export as $row) {
3084         $colno = 0;
3085         foreach($row as $col) {
3086             $worksheet[0]->write($rowno, $colno, $col);
3087             $colno++;
3088         }
3089         $rowno++;
3090     }
3091     $workbook->close();
3092     return $filename;
3095 /**
3096  * @global object
3097  * @param int $dataid
3098  * @param array $fields
3099  * @param array $selectedfields
3100  * @param int $currentgroup group ID of the current group. This is used for
3101  * exporting data while maintaining group divisions.
3102  * @param object $context the context in which the operation is performed (for capability checks)
3103  * @param bool $userdetails whether to include the details of the record author
3104  * @param bool $time whether to include time created/modified
3105  * @param bool $approval whether to include approval status
3106  * @return array
3107  */
3108 function data_get_exportdata($dataid, $fields, $selectedfields, $currentgroup=0, $context=null,
3109                              $userdetails=false, $time=false, $approval=false) {
3110     global $DB;
3112     if (is_null($context)) {
3113         $context = context_system::instance();
3114     }
3115     // exporting user data needs special permission
3116     $userdetails = $userdetails && has_capability('mod/data:exportuserinfo', $context);
3118     $exportdata = array();
3120     // populate the header in first row of export
3121     foreach($fields as $key => $field) {
3122         if (!in_array($field->field->id, $selectedfields)) {
3123             // ignore values we aren't exporting
3124             unset($fields[$key]);
3125         } else {
3126             $exportdata[0][] = $field->field->name;
3127         }
3128     }
3129     if ($userdetails) {
3130         $exportdata[0][] = get_string('user');
3131         $exportdata[0][] = get_string('username');
3132         $exportdata[0][] = get_string('email');
3133     }
3134     if ($time) {
3135         $exportdata[0][] = get_string('timeadded', 'data');
3136         $exportdata[0][] = get_string('timemodified', 'data');
3137     }
3138     if ($approval) {
3139         $exportdata[0][] = get_string('approved', 'data');
3140     }
3142     $datarecords = $DB->get_records('data_records', array('dataid'=>$dataid));
3143     ksort($datarecords);
3144     $line = 1;
3145     foreach($datarecords as $record) {
3146         // get content indexed by fieldid
3147         if ($currentgroup) {
3148             $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 = ?';
3149             $where = array($record->id, $currentgroup);
3150         } else {
3151             $select = 'SELECT fieldid, content, content1, content2, content3, content4 FROM {data_content} WHERE recordid = ?';
3152             $where = array($record->id);
3153         }
3155         if( $content = $DB->get_records_sql($select, $where) ) {
3156             foreach($fields as $field) {
3157                 $contents = '';
3158                 if(isset($content[$field->field->id])) {
3159                     $contents = $field->export_text_value($content[$field->field->id]);
3160                 }
3161                 $exportdata[$line][] = $contents;
3162             }
3163             if ($userdetails) { // Add user details to the export data
3164                 $userdata = get_complete_user_data('id', $record->userid);
3165                 $exportdata[$line][] = fullname($userdata);
3166                 $exportdata[$line][] = $userdata->username;
3167                 $exportdata[$line][] = $userdata->email;
3168             }
3169             if ($time) { // Add time added / modified
3170                 $exportdata[$line][] = userdate($record->timecreated);
3171                 $exportdata[$line][] = userdate($record->timemodified);
3172             }
3173             if ($approval) { // Add approval status
3174                 $exportdata[$line][] = (int) $record->approved;
3175             }
3176         }
3177         $line++;
3178     }
3179     $line--;
3180     return $exportdata;
3183 ////////////////////////////////////////////////////////////////////////////////
3184 // File API                                                                   //
3185 ////////////////////////////////////////////////////////////////////////////////
3187 /**
3188  * Lists all browsable file areas
3189  *
3190  * @package  mod_data
3191  * @category files
3192  * @param stdClass $course course object
3193  * @param stdClass $cm course module object
3194  * @param stdClass $context context object
3195  * @return array
3196  */
3197 function data_get_file_areas($course, $cm, $context) {
3198     return array('content' => get_string('areacontent', 'mod_data'));
3201 /**
3202  * File browsing support for data module.
3203  *
3204  * @param file_browser $browser
3205  * @param array $areas
3206  * @param stdClass $course
3207  * @param cm_info $cm
3208  * @param context $context
3209  * @param string $filearea
3210  * @param int $itemid
3211  * @param string $filepath
3212  * @param string $filename
3213  * @return file_info_stored file_info_stored instance or null if not found
3214  */
3215 function data_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
3216     global $CFG, $DB, $USER;
3218     if ($context->contextlevel != CONTEXT_MODULE) {
3219         return null;
3220     }
3222     if (!isset($areas[$filearea])) {
3223         return null;
3224     }
3226     if (is_null($itemid)) {
3227         require_once($CFG->dirroot.'/mod/data/locallib.php');
3228         return new data_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
3229     }
3231     if (!$content = $DB->get_record('data_content', array('id'=>$itemid))) {
3232         return null;
3233     }
3235     if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3236         return null;
3237     }
3239     if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3240         return null;
3241     }
3243     if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3244         return null;
3245     }
3247     //check if approved
3248     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3249         return null;
3250     }
3252     // group access
3253     if ($record->groupid) {
3254         $groupmode = groups_get_activity_groupmode($cm, $course);
3255         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3256             if (!groups_is_member($record->groupid)) {
3257                 return null;
3258             }
3259         }
3260     }
3262     $fieldobj = data_get_field($field, $data, $cm);
3264     $filepath = is_null($filepath) ? '/' : $filepath;
3265     $filename = is_null($filename) ? '.' : $filename;
3266     if (!$fieldobj->file_ok($filepath.$filename)) {
3267         return null;
3268     }
3270     $fs = get_file_storage();
3271     if (!($storedfile = $fs->get_file($context->id, 'mod_data', $filearea, $itemid, $filepath, $filename))) {
3272         return null;
3273     }
3275     // Checks to see if the user can manage files or is the owner.
3276     // TODO MDL-33805 - Do not use userid here and move the capability check above.
3277     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
3278         return null;
3279     }
3281     $urlbase = $CFG->wwwroot.'/pluginfile.php';
3283     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
3286 /**
3287  * Serves the data attachments. Implements needed access control ;-)
3288  *
3289  * @package  mod_data
3290  * @category files
3291  * @param stdClass $course course object
3292  * @param stdClass $cm course module object
3293  * @param stdClass $context context object
3294  * @param string $filearea file area
3295  * @param array $args extra arguments
3296  * @param bool $forcedownload whether or not force download
3297  * @param array $options additional options affecting the file serving
3298  * @return bool false if file not found, does not return if found - justsend the file
3299  */
3300 function data_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
3301     global $CFG, $DB;
3303     if ($context->contextlevel != CONTEXT_MODULE) {
3304         return false;
3305     }
3307     require_course_login($course, true, $cm);
3309     if ($filearea === 'content') {
3310         $contentid = (int)array_shift($args);
3312         if (!$content = $DB->get_record('data_content', array('id'=>$contentid))) {
3313             return false;
3314         }
3316         if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3317             return false;
3318         }
3320         if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3321             return false;
3322         }
3324         if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3325             return false;
3326         }
3328         if ($data->id != $cm->instance) {
3329             // hacker attempt - context does not match the contentid
3330             return false;
3331         }
3333         //check if approved
3334         if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3335             return false;
3336         }
3338         // group access
3339         if ($record->groupid) {
3340             $groupmode = groups_get_activity_groupmode($cm, $course);
3341             if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3342                 if (!groups_is_member($record->groupid)) {
3343                     return false;
3344                 }
3345             }
3346         }
3348         $fieldobj = data_get_field($field, $data, $cm);
3350         $relativepath = implode('/', $args);
3351         $fullpath = "/$context->id/mod_data/content/$content->id/$relativepath";
3353         if (!$fieldobj->file_ok($relativepath)) {
3354             return false;
3355         }
3357         $fs = get_file_storage();
3358         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
3359             return false;
3360         }
3362         // finally send the file
3363         send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
3364     }
3366     return false;
3370 function data_extend_navigation($navigation, $course, $module, $cm) {
3371     global $CFG, $OUTPUT, $USER, $DB;
3372     require_once($CFG->dirroot . '/mod/data/locallib.php');
3374     $rid = optional_param('rid', 0, PARAM_INT);
3376     $data = $DB->get_record('data', array('id'=>$cm->instance));
3377     $currentgroup = groups_get_activity_group($cm);
3378     $groupmode = groups_get_activity_groupmode($cm);
3380      $numentries = data_numentries($data);
3381     $canmanageentries = has_capability('mod/data:manageentries', context_module::instance($cm->id));
3383     if ($data->entriesleft = data_get_entries_left_to_add($data, $numentries, $canmanageentries)) {
3384         $entriesnode = $navigation->add(get_string('entrieslefttoadd', 'data', $data));
3385         $entriesnode->add_class('note');
3386     }
3388     $navigation->add(get_string('list', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance)));
3389     if (!empty($rid)) {
3390         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'rid'=>$rid)));
3391     } else {
3392         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'single')));
3393     }
3394     $navigation->add(get_string('search', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'asearch')));
3397 /**
3398  * Adds module specific settings to the settings block
3399  *
3400  * @param settings_navigation $settings The settings navigation object
3401  * @param navigation_node $datanode The node to add module settings to
3402  */
3403 function data_extend_settings_navigation(settings_navigation $settings, navigation_node $datanode) {
3404     global $PAGE, $DB, $CFG, $USER;
3406     $data = $DB->get_record('data', array("id" => $PAGE->cm->instance));
3408     $currentgroup = groups_get_activity_group($PAGE->cm);
3409     $groupmode = groups_get_activity_groupmode($PAGE->cm);
3411     if (data_user_can_add_entry($data, $currentgroup, $groupmode, $PAGE->cm->context)) { // took out participation list here!
3412         if (empty($editentry)) { //TODO: undefined
3413             $addstring = get_string('add', 'data');
3414         } else {
3415             $addstring = get_string('editentry', 'data');
3416         }
3417         $datanode->add($addstring, new moodle_url('/mod/data/edit.php', array('d'=>$PAGE->cm->instance)));
3418     }
3420     if (has_capability(DATA_CAP_EXPORT, $PAGE->cm->context)) {
3421         // The capability required to Export database records is centrally defined in 'lib.php'
3422         // and should be weaker than those required to edit Templates, Fields and Presets.
3423         $datanode->add(get_string('exportentries', 'data'), new moodle_url('/mod/data/export.php', array('d'=>$data->id)));
3424     }
3425     if (has_capability('mod/data:manageentries', $PAGE->cm->context)) {
3426         $datanode->add(get_string('importentries', 'data'), new moodle_url('/mod/data/import.php', array('d'=>$data->id)));
3427     }
3429     if (has_capability('mod/data:managetemplates', $PAGE->cm->context)) {
3430         $currenttab = '';
3431         if ($currenttab == 'list') {
3432             $defaultemplate = 'listtemplate';
3433         } else if ($currenttab == 'add') {
3434             $defaultemplate = 'addtemplate';
3435         } else if ($currenttab == 'asearch') {
3436             $defaultemplate = 'asearchtemplate';
3437         } else {
3438             $defaultemplate = 'singletemplate';
3439         }
3441         $templates = $datanode->add(get_string('templates', 'data'));
3443         $templatelist = array ('listtemplate', 'singletemplate', 'asearchtemplate', 'addtemplate', 'rsstemplate', 'csstemplate', 'jstemplate');
3444         foreach ($templatelist as $template) {
3445             $templates->add(get_string($template, 'data'), new moodle_url('/mod/data/templates.php', array('d'=>$data->id,'mode'=>$template)));
3446         }
3448         $datanode->add(get_string('fields', 'data'), new moodle_url('/mod/data/field.php', array('d'=>$data->id)));
3449         $datanode->add(get_string('presets', 'data'), new moodle_url('/mod/data/preset.php', array('d'=>$data->id)));
3450     }
3452     if (!empty($CFG->enablerssfeeds) && !empty($CFG->data_enablerssfeeds) && $data->rssarticles > 0) {
3453         require_once("$CFG->libdir/rsslib.php");
3455         $string = get_string('rsstype','forum');
3457         $url = new moodle_url(rss_get_url($PAGE->cm->context->id, $USER->id, 'mod_data', $data->id));
3458         $datanode->add($string, $url, settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
3459     }
3462 /**
3463  * Save the database configuration as a preset.
3464  *
3465  * @param stdClass $course The course the database module belongs to.
3466  * @param stdClass $cm The course module record
3467  * @param stdClass $data The database record
3468  * @param string $path
3469  * @return bool
3470  */
3471 function data_presets_save($course, $cm, $data, $path) {
3472     global $USER;
3473     $fs = get_file_storage();
3474     $filerecord = new stdClass;
3475     $filerecord->contextid = DATA_PRESET_CONTEXT;
3476     $filerecord->component = DATA_PRESET_COMPONENT;
3477     $filerecord->filearea = DATA_PRESET_FILEAREA;
3478     $filerecord->itemid = 0;
3479     $filerecord->filepath = '/'.$path.'/';
3480     $filerecord->userid = $USER->id;
3482     $filerecord->filename = 'preset.xml';
3483     $fs->create_file_from_string($filerecord, data_presets_generate_xml($course, $cm, $data));
3485     $filerecord->filename = 'singletemplate.html';
3486     $fs->create_file_from_string($filerecord, $data->singletemplate);
3488     $filerecord->filename = 'listtemplateheader.html';
3489     $fs->create_file_from_string($filerecord, $data->listtemplateheader);
3491     $filerecord->filename = 'listtemplate.html';
3492     $fs->create_file_from_string($filerecord, $data->listtemplate);
3494     $filerecord->filename = 'listtemplatefooter.html';
3495     $fs->create_file_from_string($filerecord, $data->listtemplatefooter);
3497     $filerecord->filename = 'addtemplate.html';
3498     $fs->create_file_from_string($filerecord, $data->addtemplate);
3500     $filerecord->filename = 'rsstemplate.html';
3501     $fs->create_file_from_string($filerecord, $data->rsstemplate);
3503     $filerecord->filename = 'rsstitletemplate.html';
3504     $fs->create_file_from_string($filerecord, $data->rsstitletemplate);
3506     $filerecord->filename = 'csstemplate.css';
3507     $fs->create_file_from_string($filerecord, $data->csstemplate);
3509     $filerecord->filename = 'jstemplate.js';
3510     $fs->create_file_from_string($filerecord, $data->jstemplate);
3512     $filerecord->filename = 'asearchtemplate.html';
3513     $fs->create_file_from_string($filerecord, $data->asearchtemplate);
3515     return true;
3518 /**
3519  * Generates the XML for the database module provided
3520  *
3521  * @global moodle_database $DB
3522  * @param stdClass $course The course the database module belongs to.
3523  * @param stdClass $cm The course module record
3524  * @param stdClass $data The database record
3525  * @return string The XML for the preset
3526  */
3527 function data_presets_generate_xml($course, $cm, $data) {
3528     global $DB;
3530     // Assemble "preset.xml":
3531     $presetxmldata = "<preset>\n\n";
3533     // Raw settings are not preprocessed during saving of presets
3534     $raw_settings = array(
3535         'intro',
3536         'comments',
3537         'requiredentries',
3538         'requiredentriestoview',
3539         'maxentries',
3540         'rssarticles',
3541         'approval',
3542         'manageapproved',
3543         'defaultsortdir'
3544     );
3546     $presetxmldata .= "<settings>\n";
3547     // First, settings that do not require any conversion
3548     foreach ($raw_settings as $setting) {
3549         $presetxmldata .= "<$setting>" . htmlspecialchars($data->$setting) . "</$setting>\n";
3550     }
3552     // Now specific settings
3553     if ($data->defaultsort > 0 && $sortfield = data_get_field_from_id($data->defaultsort, $data)) {
3554         $presetxmldata .= '<defaultsort>' . htmlspecialchars($sortfield->field->name) . "</defaultsort>\n";
3555     } else {
3556         $presetxmldata .= "<defaultsort>0</defaultsort>\n";
3557     }
3558     $presetxmldata .= "</settings>\n\n";
3559     // Now for the fields. Grab all that are non-empty
3560     $fields = $DB->get_records('data_fields', array('dataid'=>$data->id));
3561     ksort($fields);
3562     if (!empty($fields)) {
3563         foreach ($fields as $field) {
3564             $presetxmldata .= "<field>\n";
3565             foreach ($field as $key => $value) {
3566                 if ($value != '' && $key != 'id' && $key != 'dataid') {
3567                     $presetxmldata .= "<$key>" . htmlspecialchars($value) . "</$key>\n";
3568                 }
3569             }
3570             $presetxmldata .= "</field>\n\n";
3571         }
3572     }
3573     $presetxmldata .= '</preset>';
3574     return $presetxmldata;
3577 function data_presets_export($course, $cm, $data, $tostorage=false) {
3578     global $CFG, $DB;
3580     $presetname = clean_filename($data->name) . '-preset-' . gmdate("Ymd_Hi");
3581     $exportsubdir = "mod_data/presetexport/$presetname";
3582     make_temp_directory($exportsubdir);
3583     $exportdir = "$CFG->tempdir/$exportsubdir";
3585     // Assemble "preset.xml":
3586     $presetxmldata = data_presets_generate_xml($course, $cm, $data);
3588     // After opening a file in write mode, close it asap
3589     $presetxmlfile = fopen($exportdir . '/preset.xml', 'w');
3590     fwrite($presetxmlfile, $presetxmldata);
3591     fclose($presetxmlfile);
3593     // Now write the template files
3594     $singletemplate = fopen($exportdir . '/singletemplate.html', 'w');
3595     fwrite($singletemplate, $data->singletemplate);
3596     fclose($singletemplate);
3598     $listtemplateheader = fopen($exportdir . '/listtemplateheader.html', 'w');
3599     fwrite($listtemplateheader, $data->listtemplateheader);
3600     fclose($listtemplateheader);
3602     $listtemplate = fopen($exportdir . '/listtemplate.html', 'w');
3603     fwrite($listtemplate, $data->listtemplate);
3604     fclose($listtemplate);
3606     $listtemplatefooter = fopen($exportdir . '/listtemplatefooter.html', 'w');
3607     fwrite($listtemplatefooter, $data->listtemplatefooter);
3608     fclose($listtemplatefooter);
3610     $addtemplate = fopen($exportdir . '/addtemplate.html', 'w');
3611     fwrite($addtemplate, $data->addtemplate);
3612     fclose($addtemplate);
3614     $rsstemplate = fopen($exportdir . '/rsstemplate.html', 'w');
3615     fwrite($rsstemplate, $data->rsstemplate);
3616     fclose($rsstemplate);
3618     $rsstitletemplate = fopen($exportdir . '/rsstitletemplate.html', 'w');
3619     fwrite($rsstitletemplate, $data->rsstitletemplate);
3620     fclose($rsstitletemplate);
3622     $csstemplate = fopen($exportdir . '/csstemplate.css', 'w');
3623     fwrite($csstemplate, $data->csstemplate);
3624     fclose($csstemplate);
3626     $jstemplate = fopen($exportdir . '/jstemplate.js', 'w');
3627     fwrite($jstemplate, $data->jstemplate);
3628     fclose($jstemplate);
3630     $asearchtemplate = fopen($exportdir . '/asearchtemplate.html', 'w');
3631     fwrite($asearchtemplate, $data->asearchtemplate);
3632     fclose($asearchtemplate);
3634     // Check if all files have been generated
3635     if (! is_directory_a_preset($exportdir)) {
3636         print_error('generateerror', 'data');
3637     }
3639     $filenames = array(
3640         'preset.xml',
3641         'singletemplate.html',
3642         'listtemplateheader.html',
3643         'listtemplate.html',
3644         'listtemplatefooter.html',
3645         'addtemplate.html',
3646         'rsstemplate.html',
3647         'rsstitletemplate.html',
3648         'csstemplate.css',
3649         'jstemplate.js',
3650         'asearchtemplate.html'
3651     );
3653     $filelist = array();
3654     foreach ($filenames as $filename) {
3655         $filelist[$filename] = $exportdir . '/' . $filename;
3656     }
3658     $exportfile = $exportdir.'.zip';
3659     file_exists($exportfile) && unlink($exportfile);
3661     $fp = get_file_packer('application/zip');
3662     $fp->archive_to_pathname($filelist, $exportfile);
3664     foreach ($filelist as $file) {
3665         unlink($file);
3666     }
3667     rmdir($exportdir);
3669     // Return the full path to the exported preset file:
3670     return $exportfile;
3673 /**
3674  * Running addtional permission check on plugin, for example, plugins
3675  * may have switch to turn on/off comments option, this callback will
3676  * affect UI display, not like pluginname_comment_validate only throw
3677  * exceptions.
3678  * Capability check has been done in comment->check_permissions(), we
3679  * don't need to do it again here.
3680  *
3681  * @package  mod_data