MDL-39040 - mod_data: Database description available in single view tab.
[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 // Some constants
25 define ('DATA_MAX_ENTRIES', 50);
26 define ('DATA_PERPAGE_SINGLE', 1);
28 define ('DATA_FIRSTNAME', -1);
29 define ('DATA_LASTNAME', -2);
30 define ('DATA_APPROVED', -3);
31 define ('DATA_TIMEADDED', 0);
32 define ('DATA_TIMEMODIFIED', -4);
34 define ('DATA_CAP_EXPORT', 'mod/data:viewalluserpresets');
36 define('DATA_PRESET_COMPONENT', 'mod_data');
37 define('DATA_PRESET_FILEAREA', 'site_presets');
38 define('DATA_PRESET_CONTEXT', SYSCONTEXTID);
40 // Users having assigned the default role "Non-editing teacher" can export database records
41 // Using the mod/data capability "viewalluserpresets" existing in Moodle 1.9.x.
42 // In Moodle >= 2, new roles may be introduced and used instead.
44 /**
45  * @package   mod-data
46  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
47  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
48  */
49 class data_field_base {     // Base class for Database Field Types (see field/*/field.class.php)
51     /** @var string Subclasses must override the type with their name */
52     var $type = 'unknown';
53     /** @var object The database object that this field belongs to */
54     var $data = NULL;
55     /** @var object The field object itself, if we know it */
56     var $field = NULL;
57     /** @var int Width of the icon for this fieldtype */
58     var $iconwidth = 16;
59     /** @var int Width of the icon for this fieldtype */
60     var $iconheight = 16;
61     /** @var object course module or cmifno */
62     var $cm;
63     /** @var object activity context */
64     var $context;
66     /**
67      * Constructor function
68      *
69      * @global object
70      * @uses CONTEXT_MODULE
71      * @param int $field
72      * @param int $data
73      * @param int $cm
74      */
75     function __construct($field=0, $data=0, $cm=0) {   // Field or data or both, each can be id or object
76         global $DB;
78         if (empty($field) && empty($data)) {
79             print_error('missingfield', 'data');
80         }
82         if (!empty($field)) {
83             if (is_object($field)) {
84                 $this->field = $field;  // Programmer knows what they are doing, we hope
85             } else if (!$this->field = $DB->get_record('data_fields', array('id'=>$field))) {
86                 print_error('invalidfieldid', 'data');
87             }
88             if (empty($data)) {
89                 if (!$this->data = $DB->get_record('data', array('id'=>$this->field->dataid))) {
90                     print_error('invalidid', 'data');
91                 }
92             }
93         }
95         if (empty($this->data)) {         // We need to define this properly
96             if (!empty($data)) {
97                 if (is_object($data)) {
98                     $this->data = $data;  // Programmer knows what they are doing, we hope
99                 } else if (!$this->data = $DB->get_record('data', array('id'=>$data))) {
100                     print_error('invalidid', 'data');
101                 }
102             } else {                      // No way to define it!
103                 print_error('missingdata', 'data');
104             }
105         }
107         if ($cm) {
108             $this->cm = $cm;
109         } else {
110             $this->cm = get_coursemodule_from_instance('data', $this->data->id);
111         }
113         if (empty($this->field)) {         // We need to define some default values
114             $this->define_default_field();
115         }
117         $this->context = context_module::instance($this->cm->id);
118     }
121     /**
122      * This field just sets up a default field object
123      *
124      * @return bool
125      */
126     function define_default_field() {
127         global $OUTPUT;
128         if (empty($this->data->id)) {
129             echo $OUTPUT->notification('Programmer error: dataid not defined in field class');
130         }
131         $this->field = new stdClass();
132         $this->field->id = 0;
133         $this->field->dataid = $this->data->id;
134         $this->field->type   = $this->type;
135         $this->field->param1 = '';
136         $this->field->param2 = '';
137         $this->field->param3 = '';
138         $this->field->name = '';
139         $this->field->description = '';
141         return true;
142     }
144     /**
145      * Set up the field object according to data in an object.  Now is the time to clean it!
146      *
147      * @return bool
148      */
149     function define_field($data) {
150         $this->field->type        = $this->type;
151         $this->field->dataid      = $this->data->id;
153         $this->field->name        = trim($data->name);
154         $this->field->description = trim($data->description);
156         if (isset($data->param1)) {
157             $this->field->param1 = trim($data->param1);
158         }
159         if (isset($data->param2)) {
160             $this->field->param2 = trim($data->param2);
161         }
162         if (isset($data->param3)) {
163             $this->field->param3 = trim($data->param3);
164         }
165         if (isset($data->param4)) {
166             $this->field->param4 = trim($data->param4);
167         }
168         if (isset($data->param5)) {
169             $this->field->param5 = trim($data->param5);
170         }
172         return true;
173     }
175     /**
176      * Insert a new field in the database
177      * We assume the field object is already defined as $this->field
178      *
179      * @global object
180      * @return bool
181      */
182     function insert_field() {
183         global $DB, $OUTPUT;
185         if (empty($this->field)) {
186             echo $OUTPUT->notification('Programmer error: Field has not been defined yet!  See define_field()');
187             return false;
188         }
190         $this->field->id = $DB->insert_record('data_fields',$this->field);
191         return true;
192     }
195     /**
196      * Update a field in the database
197      *
198      * @global object
199      * @return bool
200      */
201     function update_field() {
202         global $DB;
204         $DB->update_record('data_fields', $this->field);
205         return true;
206     }
208     /**
209      * Delete a field completely
210      *
211      * @global object
212      * @return bool
213      */
214     function delete_field() {
215         global $DB;
217         if (!empty($this->field->id)) {
218             $this->delete_content();
219             $DB->delete_records('data_fields', array('id'=>$this->field->id));
220         }
221         return true;
222     }
224     /**
225      * Print the relevant form element in the ADD template for this field
226      *
227      * @global object
228      * @param int $recordid
229      * @return string
230      */
231     function display_add_field($recordid=0){
232         global $DB;
234         if ($recordid){
235             $content = $DB->get_field('data_content', 'content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid));
236         } else {
237             $content = '';
238         }
240         // beware get_field returns false for new, empty records MDL-18567
241         if ($content===false) {
242             $content='';
243         }
245         $str = '<div title="'.s($this->field->description).'">';
246         $str .= '<label class="accesshide" for="field_'.$this->field->id.'">'.$this->field->description.'</label>';
247         $str .= '<input class="basefieldinput" type="text" name="field_'.$this->field->id.'" id="field_'.$this->field->id.'" value="'.s($content).'" />';
248         $str .= '</div>';
250         return $str;
251     }
253     /**
254      * Print the relevant form element to define the attributes for this field
255      * viewable by teachers only.
256      *
257      * @global object
258      * @global object
259      * @return void Output is echo'd
260      */
261     function display_edit_field() {
262         global $CFG, $DB, $OUTPUT;
264         if (empty($this->field)) {   // No field has been defined yet, try and make one
265             $this->define_default_field();
266         }
267         echo $OUTPUT->box_start('generalbox boxaligncenter boxwidthwide');
269         echo '<form id="editfield" action="'.$CFG->wwwroot.'/mod/data/field.php" method="post">'."\n";
270         echo '<input type="hidden" name="d" value="'.$this->data->id.'" />'."\n";
271         if (empty($this->field->id)) {
272             echo '<input type="hidden" name="mode" value="add" />'."\n";
273             $savebutton = get_string('add');
274         } else {
275             echo '<input type="hidden" name="fid" value="'.$this->field->id.'" />'."\n";
276             echo '<input type="hidden" name="mode" value="update" />'."\n";
277             $savebutton = get_string('savechanges');
278         }
279         echo '<input type="hidden" name="type" value="'.$this->type.'" />'."\n";
280         echo '<input name="sesskey" value="'.sesskey().'" type="hidden" />'."\n";
282         echo $OUTPUT->heading($this->name());
284         require_once($CFG->dirroot.'/mod/data/field/'.$this->type.'/mod.html');
286         echo '<div class="mdl-align">';
287         echo '<input type="submit" value="'.$savebutton.'" />'."\n";
288         echo '<input type="submit" name="cancel" value="'.get_string('cancel').'" />'."\n";
289         echo '</div>';
291         echo '</form>';
293         echo $OUTPUT->box_end();
294     }
296     /**
297      * Display the content of the field in browse mode
298      *
299      * @global object
300      * @param int $recordid
301      * @param object $template
302      * @return bool|string
303      */
304     function display_browse_field($recordid, $template) {
305         global $DB;
307         if ($content = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
308             if (isset($content->content)) {
309                 $options = new stdClass();
310                 if ($this->field->param1 == '1') {  // We are autolinking this field, so disable linking within us
311                     //$content->content = '<span class="nolink">'.$content->content.'</span>';
312                     //$content->content1 = FORMAT_HTML;
313                     $options->filter=false;
314                 }
315                 $options->para = false;
316                 $str = format_text($content->content, $content->content1, $options);
317             } else {
318                 $str = '';
319             }
320             return $str;
321         }
322         return false;
323     }
325     /**
326      * Update the content of one data field in the data_content table
327      * @global object
328      * @param int $recordid
329      * @param mixed $value
330      * @param string $name
331      * @return bool
332      */
333     function update_content($recordid, $value, $name=''){
334         global $DB;
336         $content = new stdClass();
337         $content->fieldid = $this->field->id;
338         $content->recordid = $recordid;
339         $content->content = clean_param($value, PARAM_NOTAGS);
341         if ($oldcontent = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
342             $content->id = $oldcontent->id;
343             return $DB->update_record('data_content', $content);
344         } else {
345             return $DB->insert_record('data_content', $content);
346         }
347     }
349     /**
350      * Delete all content associated with the field
351      *
352      * @global object
353      * @param int $recordid
354      * @return bool
355      */
356     function delete_content($recordid=0) {
357         global $DB;
359         if ($recordid) {
360             $conditions = array('fieldid'=>$this->field->id, 'recordid'=>$recordid);
361         } else {
362             $conditions = array('fieldid'=>$this->field->id);
363         }
365         $rs = $DB->get_recordset('data_content', $conditions);
366         if ($rs->valid()) {
367             $fs = get_file_storage();
368             foreach ($rs as $content) {
369                 $fs->delete_area_files($this->context->id, 'mod_data', 'content', $content->id);
370             }
371         }
372         $rs->close();
374         return $DB->delete_records('data_content', $conditions);
375     }
377     /**
378      * Check if a field from an add form is empty
379      *
380      * @param mixed $value
381      * @param mixed $name
382      * @return bool
383      */
384     function notemptyfield($value, $name) {
385         return !empty($value);
386     }
388     /**
389      * Just in case a field needs to print something before the whole form
390      */
391     function print_before_form() {
392     }
394     /**
395      * Just in case a field needs to print something after the whole form
396      */
397     function print_after_form() {
398     }
401     /**
402      * Returns the sortable field for the content. By default, it's just content
403      * but for some plugins, it could be content 1 - content4
404      *
405      * @return string
406      */
407     function get_sort_field() {
408         return 'content';
409     }
411     /**
412      * Returns the SQL needed to refer to the column.  Some fields may need to CAST() etc.
413      *
414      * @param string $fieldname
415      * @return string $fieldname
416      */
417     function get_sort_sql($fieldname) {
418         return $fieldname;
419     }
421     /**
422      * Returns the name/type of the field
423      *
424      * @return string
425      */
426     function name() {
427         return get_string('name'.$this->type, 'data');
428     }
430     /**
431      * Prints the respective type icon
432      *
433      * @global object
434      * @return string
435      */
436     function image() {
437         global $OUTPUT;
439         $params = array('d'=>$this->data->id, 'fid'=>$this->field->id, 'mode'=>'display', 'sesskey'=>sesskey());
440         $link = new moodle_url('/mod/data/field.php', $params);
441         $str = '<a href="'.$link->out().'">';
442         $str .= '<img src="'.$OUTPUT->pix_url('field/'.$this->type, 'data') . '" ';
443         $str .= 'height="'.$this->iconheight.'" width="'.$this->iconwidth.'" alt="'.$this->type.'" title="'.$this->type.'" /></a>';
444         return $str;
445     }
447     /**
448      * Per default, it is assumed that fields support text exporting.
449      * Override this (return false) on fields not supporting text exporting.
450      *
451      * @return bool true
452      */
453     function text_export_supported() {
454         return true;
455     }
457     /**
458      * Per default, return the record's text value only from the "content" field.
459      * Override this in fields class if necesarry.
460      *
461      * @param string $record
462      * @return string
463      */
464     function export_text_value($record) {
465         if ($this->text_export_supported()) {
466             return $record->content;
467         }
468     }
470     /**
471      * @param string $relativepath
472      * @return bool false
473      */
474     function file_ok($relativepath) {
475         return false;
476     }
480 /**
481  * Given a template and a dataid, generate a default case template
482  *
483  * @global object
484  * @param object $data
485  * @param string template [addtemplate, singletemplate, listtempalte, rsstemplate]
486  * @param int $recordid
487  * @param bool $form
488  * @param bool $update
489  * @return bool|string
490  */
491 function data_generate_default_template(&$data, $template, $recordid=0, $form=false, $update=true) {
492     global $DB;
494     if (!$data && !$template) {
495         return false;
496     }
497     if ($template == 'csstemplate' or $template == 'jstemplate' ) {
498         return '';
499     }
501     // get all the fields for that database
502     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'id')) {
504         $table = new html_table();
505         $table->attributes['class'] = 'mod-data-default-template';
506         $table->colclasses = array('template-field', 'template-token');
507         $table->data = array();
508         foreach ($fields as $field) {
509             if ($form) {   // Print forms instead of data
510                 $fieldobj = data_get_field($field, $data);
511                 $token = $fieldobj->display_add_field($recordid);
512             } else {           // Just print the tag
513                 $token = '[['.$field->name.']]';
514             }
515             $table->data[] = array(
516                 $field->name.': ',
517                 $token
518             );
519         }
520         if ($template == 'listtemplate') {
521             $cell = new html_table_cell('##edit##  ##more##  ##delete##  ##approve##  ##export##');
522             $cell->colspan = 2;
523             $cell->attributes['class'] = 'controls';
524             $table->data[] = new html_table_row(array($cell));
525         } else if ($template == 'singletemplate') {
526             $cell = new html_table_cell('##edit##  ##delete##  ##approve##  ##export##');
527             $cell->colspan = 2;
528             $cell->attributes['class'] = 'controls';
529             $table->data[] = new html_table_row(array($cell));
530         } else if ($template == 'asearchtemplate') {
531             $row = new html_table_row(array(get_string('authorfirstname', 'data').': ', '##firstname##'));
532             $row->attributes['class'] = 'searchcontrols';
533             $table->data[] = $row;
534             $row = new html_table_row(array(get_string('authorlastname', 'data').': ', '##lastname##'));
535             $row->attributes['class'] = 'searchcontrols';
536             $table->data[] = $row;
537         }
539         $str  = html_writer::start_tag('div', array('class' => 'defaulttemplate'));
540         $str .= html_writer::table($table);
541         $str .= html_writer::end_tag('div');
542         if ($template == 'listtemplate'){
543             $str .= html_writer::empty_tag('hr');
544         }
546         if ($update) {
547             $newdata = new stdClass();
548             $newdata->id = $data->id;
549             $newdata->{$template} = $str;
550             $DB->update_record('data', $newdata);
551             $data->{$template} = $str;
552         }
554         return $str;
555     }
559 /**
560  * Search for a field name and replaces it with another one in all the
561  * form templates. Set $newfieldname as '' if you want to delete the
562  * field from the form.
563  *
564  * @global object
565  * @param object $data
566  * @param string $searchfieldname
567  * @param string $newfieldname
568  * @return bool
569  */
570 function data_replace_field_in_templates($data, $searchfieldname, $newfieldname) {
571     global $DB;
573     if (!empty($newfieldname)) {
574         $prestring = '[[';
575         $poststring = ']]';
576         $idpart = '#id';
578     } else {
579         $prestring = '';
580         $poststring = '';
581         $idpart = '';
582     }
584     $newdata = new stdClass();
585     $newdata->id = $data->id;
586     $newdata->singletemplate = str_ireplace('[['.$searchfieldname.']]',
587             $prestring.$newfieldname.$poststring, $data->singletemplate);
589     $newdata->listtemplate = str_ireplace('[['.$searchfieldname.']]',
590             $prestring.$newfieldname.$poststring, $data->listtemplate);
592     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.']]',
593             $prestring.$newfieldname.$poststring, $data->addtemplate);
595     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.'#id]]',
596             $prestring.$newfieldname.$idpart.$poststring, $data->addtemplate);
598     $newdata->rsstemplate = str_ireplace('[['.$searchfieldname.']]',
599             $prestring.$newfieldname.$poststring, $data->rsstemplate);
601     return $DB->update_record('data', $newdata);
605 /**
606  * Appends a new field at the end of the form template.
607  *
608  * @global object
609  * @param object $data
610  * @param string $newfieldname
611  */
612 function data_append_new_field_to_templates($data, $newfieldname) {
613     global $DB;
615     $newdata = new stdClass();
616     $newdata->id = $data->id;
617     $change = false;
619     if (!empty($data->singletemplate)) {
620         $newdata->singletemplate = $data->singletemplate.' [[' . $newfieldname .']]';
621         $change = true;
622     }
623     if (!empty($data->addtemplate)) {
624         $newdata->addtemplate = $data->addtemplate.' [[' . $newfieldname . ']]';
625         $change = true;
626     }
627     if (!empty($data->rsstemplate)) {
628         $newdata->rsstemplate = $data->singletemplate.' [[' . $newfieldname . ']]';
629         $change = true;
630     }
631     if ($change) {
632         $DB->update_record('data', $newdata);
633     }
637 /**
638  * given a field name
639  * this function creates an instance of the particular subfield class
640  *
641  * @global object
642  * @param string $name
643  * @param object $data
644  * @return object|bool
645  */
646 function data_get_field_from_name($name, $data){
647     global $DB;
649     $field = $DB->get_record('data_fields', array('name'=>$name, 'dataid'=>$data->id));
651     if ($field) {
652         return data_get_field($field, $data);
653     } else {
654         return false;
655     }
658 /**
659  * given a field id
660  * this function creates an instance of the particular subfield class
661  *
662  * @global object
663  * @param int $fieldid
664  * @param object $data
665  * @return bool|object
666  */
667 function data_get_field_from_id($fieldid, $data){
668     global $DB;
670     $field = $DB->get_record('data_fields', array('id'=>$fieldid, 'dataid'=>$data->id));
672     if ($field) {
673         return data_get_field($field, $data);
674     } else {
675         return false;
676     }
679 /**
680  * given a field id
681  * this function creates an instance of the particular subfield class
682  *
683  * @global object
684  * @param string $type
685  * @param object $data
686  * @return object
687  */
688 function data_get_field_new($type, $data) {
689     global $CFG;
691     require_once($CFG->dirroot.'/mod/data/field/'.$type.'/field.class.php');
692     $newfield = 'data_field_'.$type;
693     $newfield = new $newfield(0, $data);
694     return $newfield;
697 /**
698  * returns a subclass field object given a record of the field, used to
699  * invoke plugin methods
700  * input: $param $field - record from db
701  *
702  * @global object
703  * @param object $field
704  * @param object $data
705  * @param object $cm
706  * @return object
707  */
708 function data_get_field($field, $data, $cm=null) {
709     global $CFG;
711     if ($field) {
712         require_once('field/'.$field->type.'/field.class.php');
713         $newfield = 'data_field_'.$field->type;
714         $newfield = new $newfield($field, $data, $cm);
715         return $newfield;
716     }
720 /**
721  * Given record object (or id), returns true if the record belongs to the current user
722  *
723  * @global object
724  * @global object
725  * @param mixed $record record object or id
726  * @return bool
727  */
728 function data_isowner($record) {
729     global $USER, $DB;
731     if (!isloggedin()) { // perf shortcut
732         return false;
733     }
735     if (!is_object($record)) {
736         if (!$record = $DB->get_record('data_records', array('id'=>$record))) {
737             return false;
738         }
739     }
741     return ($record->userid == $USER->id);
744 /**
745  * has a user reached the max number of entries?
746  *
747  * @param object $data
748  * @return bool
749  */
750 function data_atmaxentries($data){
751     if (!$data->maxentries){
752         return false;
754     } else {
755         return (data_numentries($data) >= $data->maxentries);
756     }
759 /**
760  * returns the number of entries already made by this user
761  *
762  * @global object
763  * @global object
764  * @param object $data
765  * @return int
766  */
767 function data_numentries($data){
768     global $USER, $DB;
769     $sql = 'SELECT COUNT(*) FROM {data_records} WHERE dataid=? AND userid=?';
770     return $DB->count_records_sql($sql, array($data->id, $USER->id));
773 /**
774  * function that takes in a dataid and adds a record
775  * this is used everytime an add template is submitted
776  *
777  * @global object
778  * @global object
779  * @param object $data
780  * @param int $groupid
781  * @return bool
782  */
783 function data_add_record($data, $groupid=0){
784     global $USER, $DB;
786     $cm = get_coursemodule_from_instance('data', $data->id);
787     $context = context_module::instance($cm->id);
789     $record = new stdClass();
790     $record->userid = $USER->id;
791     $record->dataid = $data->id;
792     $record->groupid = $groupid;
793     $record->timecreated = $record->timemodified = time();
794     if (has_capability('mod/data:approve', $context)) {
795         $record->approved = 1;
796     } else {
797         $record->approved = 0;
798     }
799     return $DB->insert_record('data_records', $record);
802 /**
803  * check the multple existence any tag in a template
804  *
805  * check to see if there are 2 or more of the same tag being used.
806  *
807  * @global object
808  * @param int $dataid,
809  * @param string $template
810  * @return bool
811  */
812 function data_tags_check($dataid, $template) {
813     global $DB, $OUTPUT;
815     // first get all the possible tags
816     $fields = $DB->get_records('data_fields', array('dataid'=>$dataid));
817     // then we generate strings to replace
818     $tagsok = true; // let's be optimistic
819     foreach ($fields as $field){
820         $pattern="/\[\[".$field->name."\]\]/i";
821         if (preg_match_all($pattern, $template, $dummy)>1){
822             $tagsok = false;
823             echo $OUTPUT->notification('[['.$field->name.']] - '.get_string('multipletags','data'));
824         }
825     }
826     // else return true
827     return $tagsok;
830 /**
831  * Adds an instance of a data
832  *
833  * @param stdClass $data
834  * @param mod_data_mod_form $mform
835  * @return int intance id
836  */
837 function data_add_instance($data, $mform = null) {
838     global $DB;
840     if (empty($data->assessed)) {
841         $data->assessed = 0;
842     }
844     $data->timemodified = time();
846     $data->id = $DB->insert_record('data', $data);
848     data_grade_item_update($data);
850     return $data->id;
853 /**
854  * updates an instance of a data
855  *
856  * @global object
857  * @param object $data
858  * @return bool
859  */
860 function data_update_instance($data) {
861     global $DB, $OUTPUT;
863     $data->timemodified = time();
864     $data->id           = $data->instance;
866     if (empty($data->assessed)) {
867         $data->assessed = 0;
868     }
870     if (empty($data->ratingtime) or empty($data->assessed)) {
871         $data->assesstimestart  = 0;
872         $data->assesstimefinish = 0;
873     }
875     if (empty($data->notification)) {
876         $data->notification = 0;
877     }
879     $DB->update_record('data', $data);
881     data_grade_item_update($data);
883     return true;
887 /**
888  * deletes an instance of a data
889  *
890  * @global object
891  * @param int $id
892  * @return bool
893  */
894 function data_delete_instance($id) {    // takes the dataid
895     global $DB, $CFG;
897     if (!$data = $DB->get_record('data', array('id'=>$id))) {
898         return false;
899     }
901     $cm = get_coursemodule_from_instance('data', $data->id);
902     $context = context_module::instance($cm->id);
904 /// Delete all the associated information
906     // files
907     $fs = get_file_storage();
908     $fs->delete_area_files($context->id, 'mod_data');
910     // get all the records in this data
911     $sql = "SELECT r.id
912               FROM {data_records} r
913              WHERE r.dataid = ?";
915     $DB->delete_records_select('data_content', "recordid IN ($sql)", array($id));
917     // delete all the records and fields
918     $DB->delete_records('data_records', array('dataid'=>$id));
919     $DB->delete_records('data_fields', array('dataid'=>$id));
921     // Delete the instance itself
922     $result = $DB->delete_records('data', array('id'=>$id));
924     // cleanup gradebook
925     data_grade_item_delete($data);
927     return $result;
930 /**
931  * returns a summary of data activity of this user
932  *
933  * @global object
934  * @param object $course
935  * @param object $user
936  * @param object $mod
937  * @param object $data
938  * @return object|null
939  */
940 function data_user_outline($course, $user, $mod, $data) {
941     global $DB, $CFG;
942     require_once("$CFG->libdir/gradelib.php");
944     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
945     if (empty($grades->items[0]->grades)) {
946         $grade = false;
947     } else {
948         $grade = reset($grades->items[0]->grades);
949     }
952     if ($countrecords = $DB->count_records('data_records', array('dataid'=>$data->id, 'userid'=>$user->id))) {
953         $result = new stdClass();
954         $result->info = get_string('numrecords', 'data', $countrecords);
955         $lastrecord   = $DB->get_record_sql('SELECT id,timemodified FROM {data_records}
956                                               WHERE dataid = ? AND userid = ?
957                                            ORDER BY timemodified DESC', array($data->id, $user->id), true);
958         $result->time = $lastrecord->timemodified;
959         if ($grade) {
960             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
961         }
962         return $result;
963     } else if ($grade) {
964         $result = new stdClass();
965         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
967         //datesubmitted == time created. dategraded == time modified or time overridden
968         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
969         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
970         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
971             $result->time = $grade->dategraded;
972         } else {
973             $result->time = $grade->datesubmitted;
974         }
976         return $result;
977     }
978     return NULL;
981 /**
982  * Prints all the records uploaded by this user
983  *
984  * @global object
985  * @param object $course
986  * @param object $user
987  * @param object $mod
988  * @param object $data
989  */
990 function data_user_complete($course, $user, $mod, $data) {
991     global $DB, $CFG, $OUTPUT;
992     require_once("$CFG->libdir/gradelib.php");
994     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
995     if (!empty($grades->items[0]->grades)) {
996         $grade = reset($grades->items[0]->grades);
997         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
998         if ($grade->str_feedback) {
999             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1000         }
1001     }
1003     if ($records = $DB->get_records('data_records', array('dataid'=>$data->id,'userid'=>$user->id), 'timemodified DESC')) {
1004         data_print_template('singletemplate', $records, $data);
1005     }
1008 /**
1009  * Return grade for given user or all users.
1010  *
1011  * @global object
1012  * @param object $data
1013  * @param int $userid optional user id, 0 means all users
1014  * @return array array of grades, false if none
1015  */
1016 function data_get_user_grades($data, $userid=0) {
1017     global $CFG;
1019     require_once($CFG->dirroot.'/rating/lib.php');
1021     $ratingoptions = new stdClass;
1022     $ratingoptions->component = 'mod_data';
1023     $ratingoptions->ratingarea = 'entry';
1024     $ratingoptions->modulename = 'data';
1025     $ratingoptions->moduleid   = $data->id;
1027     $ratingoptions->userid = $userid;
1028     $ratingoptions->aggregationmethod = $data->assessed;
1029     $ratingoptions->scaleid = $data->scale;
1030     $ratingoptions->itemtable = 'data_records';
1031     $ratingoptions->itemtableusercolumn = 'userid';
1033     $rm = new rating_manager();
1034     return $rm->get_user_grades($ratingoptions);
1037 /**
1038  * Update activity grades
1039  *
1040  * @category grade
1041  * @param object $data
1042  * @param int $userid specific user only, 0 means all
1043  * @param bool $nullifnone
1044  */
1045 function data_update_grades($data, $userid=0, $nullifnone=true) {
1046     global $CFG, $DB;
1047     require_once($CFG->libdir.'/gradelib.php');
1049     if (!$data->assessed) {
1050         data_grade_item_update($data);
1052     } else if ($grades = data_get_user_grades($data, $userid)) {
1053         data_grade_item_update($data, $grades);
1055     } else if ($userid and $nullifnone) {
1056         $grade = new stdClass();
1057         $grade->userid   = $userid;
1058         $grade->rawgrade = NULL;
1059         data_grade_item_update($data, $grade);
1061     } else {
1062         data_grade_item_update($data);
1063     }
1066 /**
1067  * Update all grades in gradebook.
1068  *
1069  * @global object
1070  */
1071 function data_upgrade_grades() {
1072     global $DB;
1074     $sql = "SELECT COUNT('x')
1075               FROM {data} d, {course_modules} cm, {modules} m
1076              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id";
1077     $count = $DB->count_records_sql($sql);
1079     $sql = "SELECT d.*, cm.idnumber AS cmidnumber, d.course AS courseid
1080               FROM {data} d, {course_modules} cm, {modules} m
1081              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id";
1082     $rs = $DB->get_recordset_sql($sql);
1083     if ($rs->valid()) {
1084         // too much debug output
1085         $pbar = new progress_bar('dataupgradegrades', 500, true);
1086         $i=0;
1087         foreach ($rs as $data) {
1088             $i++;
1089             upgrade_set_timeout(60*5); // set up timeout, may also abort execution
1090             data_update_grades($data, 0, false);
1091             $pbar->update($i, $count, "Updating Database grades ($i/$count).");
1092         }
1093     }
1094     $rs->close();
1097 /**
1098  * Update/create grade item for given data
1099  *
1100  * @category grade
1101  * @param stdClass $data A database instance with extra cmidnumber property
1102  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1103  * @return object grade_item
1104  */
1105 function data_grade_item_update($data, $grades=NULL) {
1106     global $CFG;
1107     require_once($CFG->libdir.'/gradelib.php');
1109     $params = array('itemname'=>$data->name, 'idnumber'=>$data->cmidnumber);
1111     if (!$data->assessed or $data->scale == 0) {
1112         $params['gradetype'] = GRADE_TYPE_NONE;
1114     } else if ($data->scale > 0) {
1115         $params['gradetype'] = GRADE_TYPE_VALUE;
1116         $params['grademax']  = $data->scale;
1117         $params['grademin']  = 0;
1119     } else if ($data->scale < 0) {
1120         $params['gradetype'] = GRADE_TYPE_SCALE;
1121         $params['scaleid']   = -$data->scale;
1122     }
1124     if ($grades  === 'reset') {
1125         $params['reset'] = true;
1126         $grades = NULL;
1127     }
1129     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, $grades, $params);
1132 /**
1133  * Delete grade item for given data
1134  *
1135  * @category grade
1136  * @param object $data object
1137  * @return object grade_item
1138  */
1139 function data_grade_item_delete($data) {
1140     global $CFG;
1141     require_once($CFG->libdir.'/gradelib.php');
1143     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, NULL, array('deleted'=>1));
1146 // junk functions
1147 /**
1148  * takes a list of records, the current data, a search string,
1149  * and mode to display prints the translated template
1150  *
1151  * @global object
1152  * @global object
1153  * @param string $template
1154  * @param array $records
1155  * @param object $data
1156  * @param string $search
1157  * @param int $page
1158  * @param bool $return
1159  * @return mixed
1160  */
1161 function data_print_template($template, $records, $data, $search='', $page=0, $return=false) {
1162     global $CFG, $DB, $OUTPUT;
1163     $cm = get_coursemodule_from_instance('data', $data->id);
1164     $context = context_module::instance($cm->id);
1166     static $fields = NULL;
1167     static $isteacher;
1168     static $dataid = NULL;
1170     if (empty($dataid)) {
1171         $dataid = $data->id;
1172     } else if ($dataid != $data->id) {
1173         $fields = NULL;
1174     }
1176     if (empty($fields)) {
1177         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1178         foreach ($fieldrecords as $fieldrecord) {
1179             $fields[]= data_get_field($fieldrecord, $data);
1180         }
1181         $isteacher = has_capability('mod/data:managetemplates', $context);
1182     }
1184     if (empty($records)) {
1185         return;
1186     }
1188     // Check whether this activity is read-only at present
1189     $readonly = data_in_readonly_period($data);
1191     foreach ($records as $record) {   // Might be just one for the single template
1193     // Replacing tags
1194         $patterns = array();
1195         $replacement = array();
1197     // Then we generate strings to replace for normal tags
1198         foreach ($fields as $field) {
1199             $patterns[]='[['.$field->field->name.']]';
1200             $replacement[] = highlight($search, $field->display_browse_field($record->id, $template));
1201         }
1203     // Replacing special tags (##Edit##, ##Delete##, ##More##)
1204         $patterns[]='##edit##';
1205         $patterns[]='##delete##';
1206         if (has_capability('mod/data:manageentries', $context) || (!$readonly && data_isowner($record->id))) {
1207             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/edit.php?d='
1208                              .$data->id.'&amp;rid='.$record->id.'&amp;sesskey='.sesskey().'"><img src="'.$OUTPUT->pix_url('t/edit') . '" class="iconsmall" alt="'.get_string('edit').'" title="'.get_string('edit').'" /></a>';
1209             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/view.php?d='
1210                              .$data->id.'&amp;delete='.$record->id.'&amp;sesskey='.sesskey().'"><img src="'.$OUTPUT->pix_url('t/delete') . '" class="iconsmall" alt="'.get_string('delete').'" title="'.get_string('delete').'" /></a>';
1211         } else {
1212             $replacement[] = '';
1213             $replacement[] = '';
1214         }
1216         $moreurl = $CFG->wwwroot . '/mod/data/view.php?d=' . $data->id . '&amp;rid=' . $record->id;
1217         if ($search) {
1218             $moreurl .= '&amp;filter=1';
1219         }
1220         $patterns[]='##more##';
1221         $replacement[] = '<a href="'.$moreurl.'"><img src="'.$OUTPUT->pix_url('t/preview').
1222                         '" class="iconsmall" alt="'.get_string('more', 'data').'" title="'.get_string('more', 'data').
1223                         '" /></a>';
1225         $patterns[]='##moreurl##';
1226         $replacement[] = $moreurl;
1228         $patterns[]='##user##';
1229         $replacement[] = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$record->userid.
1230                                '&amp;course='.$data->course.'">'.fullname($record).'</a>';
1232         $patterns[]='##export##';
1234         if (!empty($CFG->enableportfolios) && ($template == 'singletemplate' || $template == 'listtemplate')
1235             && ((has_capability('mod/data:exportentry', $context)
1236                 || (data_isowner($record->id) && has_capability('mod/data:exportownentry', $context))))) {
1237             require_once($CFG->libdir . '/portfoliolib.php');
1238             $button = new portfolio_add_button();
1239             $button->set_callback_options('data_portfolio_caller', array('id' => $cm->id, 'recordid' => $record->id), 'mod_data');
1240             list($formats, $files) = data_portfolio_caller::formats($fields, $record);
1241             $button->set_formats($formats);
1242             $replacement[] = $button->to_html(PORTFOLIO_ADD_ICON_LINK);
1243         } else {
1244             $replacement[] = '';
1245         }
1247         $patterns[] = '##timeadded##';
1248         $replacement[] = userdate($record->timecreated);
1250         $patterns[] = '##timemodified##';
1251         $replacement [] = userdate($record->timemodified);
1253         $patterns[]='##approve##';
1254         if (has_capability('mod/data:approve', $context) && ($data->approval) && (!$record->approved)) {
1255             $approveurl = new moodle_url('/mod/data/view.php',
1256                     array('d' => $data->id, 'approve' => $record->id, 'sesskey' => sesskey()));
1257             $approveicon = new pix_icon('t/approve', get_string('approve'), '', array('class' => 'iconsmall'));
1258             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($approveurl, $approveicon),
1259                     array('class' => 'approve'));
1260         } else {
1261             $replacement[] = '';
1262         }
1264         $patterns[]='##comments##';
1265         if (($template == 'listtemplate') && ($data->comments)) {
1267             if (!empty($CFG->usecomments)) {
1268                 require_once($CFG->dirroot  . '/comment/lib.php');
1269                 list($context, $course, $cm) = get_context_info_array($context->id);
1270                 $cmt = new stdClass();
1271                 $cmt->context = $context;
1272                 $cmt->course  = $course;
1273                 $cmt->cm      = $cm;
1274                 $cmt->area    = 'database_entry';
1275                 $cmt->itemid  = $record->id;
1276                 $cmt->showcount = true;
1277                 $cmt->component = 'mod_data';
1278                 $comment = new comment($cmt);
1279                 $replacement[] = $comment->output(true);
1280             }
1281         } else {
1282             $replacement[] = '';
1283         }
1285         // actual replacement of the tags
1286         $newtext = str_ireplace($patterns, $replacement, $data->{$template});
1288         // no more html formatting and filtering - see MDL-6635
1289         if ($return) {
1290             return $newtext;
1291         } else {
1292             echo $newtext;
1294             // hack alert - return is always false in singletemplate anyway ;-)
1295             /**********************************
1296              *    Printing Ratings Form       *
1297              *********************************/
1298             if ($template == 'singletemplate') {    //prints ratings options
1299                 data_print_ratings($data, $record);
1300             }
1302             /**********************************
1303              *    Printing Comments Form       *
1304              *********************************/
1305             if (($template == 'singletemplate') && ($data->comments)) {
1306                 if (!empty($CFG->usecomments)) {
1307                     require_once($CFG->dirroot . '/comment/lib.php');
1308                     list($context, $course, $cm) = get_context_info_array($context->id);
1309                     $cmt = new stdClass();
1310                     $cmt->context = $context;
1311                     $cmt->course  = $course;
1312                     $cmt->cm      = $cm;
1313                     $cmt->area    = 'database_entry';
1314                     $cmt->itemid  = $record->id;
1315                     $cmt->showcount = true;
1316                     $cmt->component = 'mod_data';
1317                     $comment = new comment($cmt);
1318                     $comment->output(false);
1319                 }
1320             }
1321         }
1322     }
1325 /**
1326  * Return rating related permissions
1327  *
1328  * @param string $contextid the context id
1329  * @param string $component the component to get rating permissions for
1330  * @param string $ratingarea the rating area to get permissions for
1331  * @return array an associative array of the user's rating permissions
1332  */
1333 function data_rating_permissions($contextid, $component, $ratingarea) {
1334     $context = context::instance_by_id($contextid, MUST_EXIST);
1335     if ($component != 'mod_data' || $ratingarea != 'entry') {
1336         return null;
1337     }
1338     return array(
1339         'view'    => has_capability('mod/data:viewrating',$context),
1340         'viewany' => has_capability('mod/data:viewanyrating',$context),
1341         'viewall' => has_capability('mod/data:viewallratings',$context),
1342         'rate'    => has_capability('mod/data:rate',$context)
1343     );
1346 /**
1347  * Validates a submitted rating
1348  * @param array $params submitted data
1349  *            context => object the context in which the rated items exists [required]
1350  *            itemid => int the ID of the object being rated
1351  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
1352  *            rating => int the submitted rating
1353  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
1354  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
1355  * @return boolean true if the rating is valid. Will throw rating_exception if not
1356  */
1357 function data_rating_validate($params) {
1358     global $DB, $USER;
1360     // Check the component is mod_data
1361     if ($params['component'] != 'mod_data') {
1362         throw new rating_exception('invalidcomponent');
1363     }
1365     // Check the ratingarea is entry (the only rating area in data module)
1366     if ($params['ratingarea'] != 'entry') {
1367         throw new rating_exception('invalidratingarea');
1368     }
1370     // Check the rateduserid is not the current user .. you can't rate your own entries
1371     if ($params['rateduserid'] == $USER->id) {
1372         throw new rating_exception('nopermissiontorate');
1373     }
1375     $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
1376                   FROM {data_records} r
1377                   JOIN {data} d ON r.dataid = d.id
1378                  WHERE r.id = :itemid";
1379     $dataparams = array('itemid'=>$params['itemid']);
1380     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1381         //item doesn't exist
1382         throw new rating_exception('invaliditemid');
1383     }
1385     if ($info->scale != $params['scaleid']) {
1386         //the scale being submitted doesnt match the one in the database
1387         throw new rating_exception('invalidscaleid');
1388     }
1390     //check that the submitted rating is valid for the scale
1392     // lower limit
1393     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
1394         throw new rating_exception('invalidnum');
1395     }
1397     // upper limit
1398     if ($info->scale < 0) {
1399         //its a custom scale
1400         $scalerecord = $DB->get_record('scale', array('id' => -$info->scale));
1401         if ($scalerecord) {
1402             $scalearray = explode(',', $scalerecord->scale);
1403             if ($params['rating'] > count($scalearray)) {
1404                 throw new rating_exception('invalidnum');
1405             }
1406         } else {
1407             throw new rating_exception('invalidscaleid');
1408         }
1409     } else if ($params['rating'] > $info->scale) {
1410         //if its numeric and submitted rating is above maximum
1411         throw new rating_exception('invalidnum');
1412     }
1414     if ($info->approval && !$info->approved) {
1415         //database requires approval but this item isnt approved
1416         throw new rating_exception('nopermissiontorate');
1417     }
1419     // check the item we're rating was created in the assessable time window
1420     if (!empty($info->assesstimestart) && !empty($info->assesstimefinish)) {
1421         if ($info->timecreated < $info->assesstimestart || $info->timecreated > $info->assesstimefinish) {
1422             throw new rating_exception('notavailable');
1423         }
1424     }
1426     $course = $DB->get_record('course', array('id'=>$info->course), '*', MUST_EXIST);
1427     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1428     $context = context_module::instance($cm->id);
1430     // if the supplied context doesnt match the item's context
1431     if ($context->id != $params['context']->id) {
1432         throw new rating_exception('invalidcontext');
1433     }
1435     // Make sure groups allow this user to see the item they're rating
1436     $groupid = $info->groupid;
1437     if ($groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
1438         if (!groups_group_exists($groupid)) { // Can't find group
1439             throw new rating_exception('cannotfindgroup');//something is wrong
1440         }
1442         if (!groups_is_member($groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
1443             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
1444             throw new rating_exception('notmemberofgroup');
1445         }
1446     }
1448     return true;
1452 /**
1453  * function that takes in the current data, number of items per page,
1454  * a search string and prints a preference box in view.php
1455  *
1456  * This preference box prints a searchable advanced search template if
1457  *     a) A template is defined
1458  *  b) The advanced search checkbox is checked.
1459  *
1460  * @global object
1461  * @global object
1462  * @param object $data
1463  * @param int $perpage
1464  * @param string $search
1465  * @param string $sort
1466  * @param string $order
1467  * @param array $search_array
1468  * @param int $advanced
1469  * @param string $mode
1470  * @return void
1471  */
1472 function data_print_preference_form($data, $perpage, $search, $sort='', $order='ASC', $search_array = '', $advanced = 0, $mode= ''){
1473     global $CFG, $DB, $PAGE, $OUTPUT;
1475     $cm = get_coursemodule_from_instance('data', $data->id);
1476     $context = context_module::instance($cm->id);
1477     echo '<br /><div class="datapreferences">';
1478     echo '<form id="options" action="view.php" method="get">';
1479     echo '<div>';
1480     echo '<input type="hidden" name="d" value="'.$data->id.'" />';
1481     if ($mode =='asearch') {
1482         $advanced = 1;
1483         echo '<input type="hidden" name="mode" value="list" />';
1484     }
1485     echo '<label for="pref_perpage">'.get_string('pagesize','data').'</label> ';
1486     $pagesizes = array(2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,15=>15,
1487                        20=>20,30=>30,40=>40,50=>50,100=>100,200=>200,300=>300,400=>400,500=>500,1000=>1000);
1488     echo html_writer::select($pagesizes, 'perpage', $perpage, false, array('id'=>'pref_perpage'));
1490     if ($advanced) {
1491         $regsearchclass = 'search_none';
1492         $advancedsearchclass = 'search_inline';
1493     } else {
1494         $regsearchclass = 'search_inline';
1495         $advancedsearchclass = 'search_none';
1496     }
1497     echo '<div id="reg_search" class="' . $regsearchclass . '" >&nbsp;&nbsp;&nbsp;';
1498     echo '<label for="pref_search">'.get_string('search').'</label> <input type="text" size="16" name="search" id= "pref_search" value="'.s($search).'" /></div>';
1499     echo '&nbsp;&nbsp;&nbsp;<label for="pref_sortby">'.get_string('sortby').'</label> ';
1500     // foreach field, print the option
1501     echo '<select name="sort" id="pref_sortby">';
1502     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'name')) {
1503         echo '<optgroup label="'.get_string('fields', 'data').'">';
1504         foreach ($fields as $field) {
1505             if ($field->id == $sort) {
1506                 echo '<option value="'.$field->id.'" selected="selected">'.$field->name.'</option>';
1507             } else {
1508                 echo '<option value="'.$field->id.'">'.$field->name.'</option>';
1509             }
1510         }
1511         echo '</optgroup>';
1512     }
1513     $options = array();
1514     $options[DATA_TIMEADDED]    = get_string('timeadded', 'data');
1515     $options[DATA_TIMEMODIFIED] = get_string('timemodified', 'data');
1516     $options[DATA_FIRSTNAME]    = get_string('authorfirstname', 'data');
1517     $options[DATA_LASTNAME]     = get_string('authorlastname', 'data');
1518     if ($data->approval and has_capability('mod/data:approve', $context)) {
1519         $options[DATA_APPROVED] = get_string('approved', 'data');
1520     }
1521     echo '<optgroup label="'.get_string('other', 'data').'">';
1522     foreach ($options as $key => $name) {
1523         if ($key == $sort) {
1524             echo '<option value="'.$key.'" selected="selected">'.$name.'</option>';
1525         } else {
1526             echo '<option value="'.$key.'">'.$name.'</option>';
1527         }
1528     }
1529     echo '</optgroup>';
1530     echo '</select>';
1531     echo '<label for="pref_order" class="accesshide">'.get_string('order').'</label>';
1532     echo '<select id="pref_order" name="order">';
1533     if ($order == 'ASC') {
1534         echo '<option value="ASC" selected="selected">'.get_string('ascending','data').'</option>';
1535     } else {
1536         echo '<option value="ASC">'.get_string('ascending','data').'</option>';
1537     }
1538     if ($order == 'DESC') {
1539         echo '<option value="DESC" selected="selected">'.get_string('descending','data').'</option>';
1540     } else {
1541         echo '<option value="DESC">'.get_string('descending','data').'</option>';
1542     }
1543     echo '</select>';
1545     if ($advanced) {
1546         $checked = ' checked="checked" ';
1547     }
1548     else {
1549         $checked = '';
1550     }
1551     $PAGE->requires->js('/mod/data/data.js');
1552     echo '&nbsp;<input type="hidden" name="advanced" value="0" />';
1553     echo '&nbsp;<input type="hidden" name="filter" value="1" />';
1554     echo '&nbsp;<input type="checkbox" id="advancedcheckbox" name="advanced" value="1" '.$checked.' onchange="showHideAdvSearch(this.checked);" /><label for="advancedcheckbox">'.get_string('advancedsearch', 'data').'</label>';
1555     echo '&nbsp;<input type="submit" value="'.get_string('savesettings','data').'" />';
1557     echo '<br />';
1558     echo '<div class="' . $advancedsearchclass . '" id="data_adv_form">';
1559     echo '<table class="boxaligncenter">';
1561     // print ASC or DESC
1562     echo '<tr><td colspan="2">&nbsp;</td></tr>';
1563     $i = 0;
1565     // Determine if we are printing all fields for advanced search, or the template for advanced search
1566     // If a template is not defined, use the deafault template and display all fields.
1567     if(empty($data->asearchtemplate)) {
1568         data_generate_default_template($data, 'asearchtemplate');
1569     }
1571     static $fields = NULL;
1572     static $isteacher;
1573     static $dataid = NULL;
1575     if (empty($dataid)) {
1576         $dataid = $data->id;
1577     } else if ($dataid != $data->id) {
1578         $fields = NULL;
1579     }
1581     if (empty($fields)) {
1582         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1583         foreach ($fieldrecords as $fieldrecord) {
1584             $fields[]= data_get_field($fieldrecord, $data);
1585         }
1587         $isteacher = has_capability('mod/data:managetemplates', $context);
1588     }
1590     // Replacing tags
1591     $patterns = array();
1592     $replacement = array();
1594     // Then we generate strings to replace for normal tags
1595     foreach ($fields as $field) {
1596         $fieldname = $field->field->name;
1597         $fieldname = preg_quote($fieldname, '/');
1598         $patterns[] = "/\[\[$fieldname\]\]/i";
1599         $searchfield = data_get_field_from_id($field->field->id, $data);
1600         if (!empty($search_array[$field->field->id]->data)) {
1601             $replacement[] = $searchfield->display_search_field($search_array[$field->field->id]->data);
1602         } else {
1603             $replacement[] = $searchfield->display_search_field();
1604         }
1605     }
1606     $fn = !empty($search_array[DATA_FIRSTNAME]->data) ? $search_array[DATA_FIRSTNAME]->data : '';
1607     $ln = !empty($search_array[DATA_LASTNAME]->data) ? $search_array[DATA_LASTNAME]->data : '';
1608     $patterns[]    = '/##firstname##/';
1609     $replacement[] = '<label class="accesshide" for="u_fn">'.get_string('authorfirstname', 'data').'</label><input type="text" size="16" id="u_fn" name="u_fn" value="'.$fn.'" />';
1610     $patterns[]    = '/##lastname##/';
1611     $replacement[] = '<label class="accesshide" for="u_ln">'.get_string('authorlastname', 'data').'</label><input type="text" size="16" id="u_ln" name="u_ln" value="'.$ln.'" />';
1613     // actual replacement of the tags
1614     $newtext = preg_replace($patterns, $replacement, $data->asearchtemplate);
1616     $options = new stdClass();
1617     $options->para=false;
1618     $options->noclean=true;
1619     echo '<tr><td>';
1620     echo format_text($newtext, FORMAT_HTML, $options);
1621     echo '</td></tr>';
1623     echo '<tr><td colspan="4"><br/><input type="submit" value="'.get_string('savesettings','data').'" /><input type="submit" name="resetadv" value="'.get_string('resetsettings','data').'" /></td></tr>';
1624     echo '</table>';
1625     echo '</div>';
1626     echo '</div>';
1627     echo '</form>';
1628     echo '</div>';
1631 /**
1632  * @global object
1633  * @global object
1634  * @param object $data
1635  * @param object $record
1636  * @return void Output echo'd
1637  */
1638 function data_print_ratings($data, $record) {
1639     global $OUTPUT;
1640     if (!empty($record->rating)){
1641         echo $OUTPUT->render($record->rating);
1642     }
1645 /**
1646  * For Participantion Reports
1647  *
1648  * @return array
1649  */
1650 function data_get_view_actions() {
1651     return array('view');
1654 /**
1655  * @return array
1656  */
1657 function data_get_post_actions() {
1658     return array('add','update','record delete');
1661 /**
1662  * @param string $name
1663  * @param int $dataid
1664  * @param int $fieldid
1665  * @return bool
1666  */
1667 function data_fieldname_exists($name, $dataid, $fieldid = 0) {
1668     global $DB;
1670     if (!is_numeric($name)) {
1671         $like = $DB->sql_like('df.name', ':name', false);
1672     } else {
1673         $like = "df.name = :name";
1674     }
1675     $params = array('name'=>$name);
1676     if ($fieldid) {
1677         $params['dataid']   = $dataid;
1678         $params['fieldid1'] = $fieldid;
1679         $params['fieldid2'] = $fieldid;
1680         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1681                                         WHERE $like AND df.dataid = :dataid
1682                                               AND ((df.id < :fieldid1) OR (df.id > :fieldid2))", $params);
1683     } else {
1684         $params['dataid']   = $dataid;
1685         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1686                                         WHERE $like AND df.dataid = :dataid", $params);
1687     }
1690 /**
1691  * @param array $fieldinput
1692  */
1693 function data_convert_arrays_to_strings(&$fieldinput) {
1694     foreach ($fieldinput as $key => $val) {
1695         if (is_array($val)) {
1696             $str = '';
1697             foreach ($val as $inner) {
1698                 $str .= $inner . ',';
1699             }
1700             $str = substr($str, 0, -1);
1702             $fieldinput->$key = $str;
1703         }
1704     }
1708 /**
1709  * Converts a database (module instance) to use the Roles System
1710  *
1711  * @global object
1712  * @global object
1713  * @uses CONTEXT_MODULE
1714  * @uses CAP_PREVENT
1715  * @uses CAP_ALLOW
1716  * @param object $data a data object with the same attributes as a record
1717  *                     from the data database table
1718  * @param int $datamodid the id of the data module, from the modules table
1719  * @param array $teacherroles array of roles that have archetype teacher
1720  * @param array $studentroles array of roles that have archetype student
1721  * @param array $guestroles array of roles that have archetype guest
1722  * @param int $cmid the course_module id for this data instance
1723  * @return boolean data module was converted or not
1724  */
1725 function data_convert_to_roles($data, $teacherroles=array(), $studentroles=array(), $cmid=NULL) {
1726     global $CFG, $DB, $OUTPUT;
1728     if (!isset($data->participants) && !isset($data->assesspublic)
1729             && !isset($data->groupmode)) {
1730         // We assume that this database has already been converted to use the
1731         // Roles System. above fields get dropped the data module has been
1732         // upgraded to use Roles.
1733         return false;
1734     }
1736     if (empty($cmid)) {
1737         // We were not given the course_module id. Try to find it.
1738         if (!$cm = get_coursemodule_from_instance('data', $data->id)) {
1739             echo $OUTPUT->notification('Could not get the course module for the data');
1740             return false;
1741         } else {
1742             $cmid = $cm->id;
1743         }
1744     }
1745     $context = context_module::instance($cmid);
1748     // $data->participants:
1749     // 1 - Only teachers can add entries
1750     // 3 - Teachers and students can add entries
1751     switch ($data->participants) {
1752         case 1:
1753             foreach ($studentroles as $studentrole) {
1754                 assign_capability('mod/data:writeentry', CAP_PREVENT, $studentrole->id, $context->id);
1755             }
1756             foreach ($teacherroles as $teacherrole) {
1757                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
1758             }
1759             break;
1760         case 3:
1761             foreach ($studentroles as $studentrole) {
1762                 assign_capability('mod/data:writeentry', CAP_ALLOW, $studentrole->id, $context->id);
1763             }
1764             foreach ($teacherroles as $teacherrole) {
1765                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
1766             }
1767             break;
1768     }
1770     // $data->assessed:
1771     // 2 - Only teachers can rate posts
1772     // 1 - Everyone can rate posts
1773     // 0 - No one can rate posts
1774     switch ($data->assessed) {
1775         case 0:
1776             foreach ($studentroles as $studentrole) {
1777                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
1778             }
1779             foreach ($teacherroles as $teacherrole) {
1780                 assign_capability('mod/data:rate', CAP_PREVENT, $teacherrole->id, $context->id);
1781             }
1782             break;
1783         case 1:
1784             foreach ($studentroles as $studentrole) {
1785                 assign_capability('mod/data:rate', CAP_ALLOW, $studentrole->id, $context->id);
1786             }
1787             foreach ($teacherroles as $teacherrole) {
1788                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
1789             }
1790             break;
1791         case 2:
1792             foreach ($studentroles as $studentrole) {
1793                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
1794             }
1795             foreach ($teacherroles as $teacherrole) {
1796                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
1797             }
1798             break;
1799     }
1801     // $data->assesspublic:
1802     // 0 - Students can only see their own ratings
1803     // 1 - Students can see everyone's ratings
1804     switch ($data->assesspublic) {
1805         case 0:
1806             foreach ($studentroles as $studentrole) {
1807                 assign_capability('mod/data:viewrating', CAP_PREVENT, $studentrole->id, $context->id);
1808             }
1809             foreach ($teacherroles as $teacherrole) {
1810                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
1811             }
1812             break;
1813         case 1:
1814             foreach ($studentroles as $studentrole) {
1815                 assign_capability('mod/data:viewrating', CAP_ALLOW, $studentrole->id, $context->id);
1816             }
1817             foreach ($teacherroles as $teacherrole) {
1818                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
1819             }
1820             break;
1821     }
1823     if (empty($cm)) {
1824         $cm = $DB->get_record('course_modules', array('id'=>$cmid));
1825     }
1827     switch ($cm->groupmode) {
1828         case NOGROUPS:
1829             break;
1830         case SEPARATEGROUPS:
1831             foreach ($studentroles as $studentrole) {
1832                 assign_capability('moodle/site:accessallgroups', CAP_PREVENT, $studentrole->id, $context->id);
1833             }
1834             foreach ($teacherroles as $teacherrole) {
1835                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
1836             }
1837             break;
1838         case VISIBLEGROUPS:
1839             foreach ($studentroles as $studentrole) {
1840                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $studentrole->id, $context->id);
1841             }
1842             foreach ($teacherroles as $teacherrole) {
1843                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
1844             }
1845             break;
1846     }
1847     return true;
1850 /**
1851  * Returns the best name to show for a preset
1852  *
1853  * @param string $shortname
1854  * @param  string $path
1855  * @return string
1856  */
1857 function data_preset_name($shortname, $path) {
1859     // We are looking inside the preset itself as a first choice, but also in normal data directory
1860     $string = get_string('modulename', 'datapreset_'.$shortname);
1862     if (substr($string, 0, 1) == '[') {
1863         return $shortname;
1864     } else {
1865         return $string;
1866     }
1869 /**
1870  * Returns an array of all the available presets.
1871  *
1872  * @return array
1873  */
1874 function data_get_available_presets($context) {
1875     global $CFG, $USER;
1877     $presets = array();
1879     // First load the ratings sub plugins that exist within the modules preset dir
1880     if ($dirs = get_list_of_plugins('mod/data/preset')) {
1881         foreach ($dirs as $dir) {
1882             $fulldir = $CFG->dirroot.'/mod/data/preset/'.$dir;
1883             if (is_directory_a_preset($fulldir)) {
1884                 $preset = new stdClass();
1885                 $preset->path = $fulldir;
1886                 $preset->userid = 0;
1887                 $preset->shortname = $dir;
1888                 $preset->name = data_preset_name($dir, $fulldir);
1889                 if (file_exists($fulldir.'/screenshot.jpg')) {
1890                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.jpg';
1891                 } else if (file_exists($fulldir.'/screenshot.png')) {
1892                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.png';
1893                 } else if (file_exists($fulldir.'/screenshot.gif')) {
1894                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.gif';
1895                 }
1896                 $presets[] = $preset;
1897             }
1898         }
1899     }
1900     // Now add to that the site presets that people have saved
1901     $presets = data_get_available_site_presets($context, $presets);
1902     return $presets;
1905 /**
1906  * Gets an array of all of the presets that users have saved to the site.
1907  *
1908  * @param stdClass $context The context that we are looking from.
1909  * @param array $presets
1910  * @return array An array of presets
1911  */
1912 function data_get_available_site_presets($context, array $presets=array()) {
1913     global $USER;
1915     $fs = get_file_storage();
1916     $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
1917     $canviewall = has_capability('mod/data:viewalluserpresets', $context);
1918     if (empty($files)) {
1919         return $presets;
1920     }
1921     foreach ($files as $file) {
1922         if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory() || (!$canviewall && $file->get_userid() != $USER->id)) {
1923             continue;
1924         }
1925         $preset = new stdClass;
1926         $preset->path = $file->get_filepath();
1927         $preset->name = trim($preset->path, '/');
1928         $preset->shortname = $preset->name;
1929         $preset->userid = $file->get_userid();
1930         $preset->id = $file->get_id();
1931         $preset->storedfile = $file;
1932         $presets[] = $preset;
1933     }
1934     return $presets;
1937 /**
1938  * Deletes a saved preset.
1939  *
1940  * @param string $name
1941  * @return bool
1942  */
1943 function data_delete_site_preset($name) {
1944     $fs = get_file_storage();
1946     $files = $fs->get_directory_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/');
1947     if (!empty($files)) {
1948         foreach ($files as $file) {
1949             $file->delete();
1950         }
1951     }
1953     $dir = $fs->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/', '.');
1954     if (!empty($dir)) {
1955         $dir->delete();
1956     }
1957     return true;
1960 /**
1961  * Prints the heads for a page
1962  *
1963  * @param stdClass $course
1964  * @param stdClass $cm
1965  * @param stdClass $data
1966  * @param string $currenttab
1967  */
1968 function data_print_header($course, $cm, $data, $currenttab='') {
1970     global $CFG, $displaynoticegood, $displaynoticebad, $OUTPUT, $PAGE;
1972     $PAGE->set_title($data->name);
1973     echo $OUTPUT->header();
1974     echo $OUTPUT->heading(format_string($data->name));
1976 // Groups needed for Add entry tab
1977     $currentgroup = groups_get_activity_group($cm);
1978     $groupmode = groups_get_activity_groupmode($cm);
1980     echo $OUTPUT->box(format_module_intro('data', $data, $cm->id), 'generalbox', 'intro');
1982     // Print the tabs
1984     if ($currenttab) {
1985         include('tabs.php');
1986     }
1988     // Print any notices
1990     if (!empty($displaynoticegood)) {
1991         echo $OUTPUT->notification($displaynoticegood, 'notifysuccess');    // good (usually green)
1992     } else if (!empty($displaynoticebad)) {
1993         echo $OUTPUT->notification($displaynoticebad);                     // bad (usuually red)
1994     }
1997 /**
1998  * Can user add more entries?
1999  *
2000  * @param object $data
2001  * @param mixed $currentgroup
2002  * @param int $groupmode
2003  * @param stdClass $context
2004  * @return bool
2005  */
2006 function data_user_can_add_entry($data, $currentgroup, $groupmode, $context = null) {
2007     global $USER;
2009     if (empty($context)) {
2010         $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
2011         $context = context_module::instance($cm->id);
2012     }
2014     if (has_capability('mod/data:manageentries', $context)) {
2015         // no entry limits apply if user can manage
2017     } else if (!has_capability('mod/data:writeentry', $context)) {
2018         return false;
2020     } else if (data_atmaxentries($data)) {
2021         return false;
2022     } else if (data_in_readonly_period($data)) {
2023         // Check whether we're in a read-only period
2024         return false;
2025     }
2027     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
2028         return true;
2029     }
2031     if ($currentgroup) {
2032         return groups_is_member($currentgroup);
2033     } else {
2034         //else it might be group 0 in visible mode
2035         if ($groupmode == VISIBLEGROUPS){
2036             return true;
2037         } else {
2038             return false;
2039         }
2040     }
2043 /**
2044  * Check whether the specified database activity is currently in a read-only period
2045  *
2046  * @param object $data
2047  * @return bool returns true if the time fields in $data indicate a read-only period; false otherwise
2048  */
2049 function data_in_readonly_period($data) {
2050     $now = time();
2051     if (!$data->timeviewfrom && !$data->timeviewto) {
2052         return false;
2053     } else if (($data->timeviewfrom && $now < $data->timeviewfrom) || ($data->timeviewto && $now > $data->timeviewto)) {
2054         return false;
2055     }
2056     return true;
2059 /**
2060  * @return bool
2061  */
2062 function is_directory_a_preset($directory) {
2063     $directory = rtrim($directory, '/\\') . '/';
2064     $status = file_exists($directory.'singletemplate.html') &&
2065               file_exists($directory.'listtemplate.html') &&
2066               file_exists($directory.'listtemplateheader.html') &&
2067               file_exists($directory.'listtemplatefooter.html') &&
2068               file_exists($directory.'addtemplate.html') &&
2069               file_exists($directory.'rsstemplate.html') &&
2070               file_exists($directory.'rsstitletemplate.html') &&
2071               file_exists($directory.'csstemplate.css') &&
2072               file_exists($directory.'jstemplate.js') &&
2073               file_exists($directory.'preset.xml');
2075     return $status;
2078 /**
2079  * Abstract class used for data preset importers
2080  */
2081 abstract class data_preset_importer {
2083     protected $course;
2084     protected $cm;
2085     protected $module;
2086     protected $directory;
2088     /**
2089      * Constructor
2090      *
2091      * @param stdClass $course
2092      * @param stdClass $cm
2093      * @param stdClass $module
2094      * @param string $directory
2095      */
2096     public function __construct($course, $cm, $module, $directory) {
2097         $this->course = $course;
2098         $this->cm = $cm;
2099         $this->module = $module;
2100         $this->directory = $directory;
2101     }
2103     /**
2104      * Returns the name of the directory the preset is located in
2105      * @return string
2106      */
2107     public function get_directory() {
2108         return basename($this->directory);
2109     }
2111     /**
2112      * Retreive the contents of a file. That file may either be in a conventional directory of the Moodle file storage
2113      * @param file_storage $filestorage. should be null if using a conventional directory
2114      * @param stored_file $fileobj the directory to look in. null if using a conventional directory
2115      * @param string $dir the directory to look in. null if using the Moodle file storage
2116      * @param string $filename the name of the file we want
2117      * @return string the contents of the file or null if the file doesn't exist.
2118      */
2119     public function data_preset_get_file_contents(&$filestorage, &$fileobj, $dir, $filename) {
2120         if(empty($filestorage) || empty($fileobj)) {
2121             if (substr($dir, -1)!='/') {
2122                 $dir .= '/';
2123             }
2124             if (file_exists($dir.$filename)) {
2125                 return file_get_contents($dir.$filename);
2126             } else {
2127                 return null;
2128             }
2129         } else {
2130             if ($filestorage->file_exists(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename)) {
2131                 $file = $filestorage->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename);
2132                 return $file->get_content();
2133             } else {
2134                 return null;
2135             }
2136         }
2138     }
2139     /**
2140      * Gets the preset settings
2141      * @global moodle_database $DB
2142      * @return stdClass
2143      */
2144     public function get_preset_settings() {
2145         global $DB;
2147         $fs = $fileobj = null;
2148         if (!is_directory_a_preset($this->directory)) {
2149             //maybe the user requested a preset stored in the Moodle file storage
2151             $fs = get_file_storage();
2152             $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2154             //preset name to find will be the final element of the directory
2155             $explodeddirectory = explode('/', $this->directory);
2156             $presettofind = end($explodeddirectory);
2158             //now go through the available files available and see if we can find it
2159             foreach ($files as $file) {
2160                 if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory()) {
2161                     continue;
2162                 }
2163                 $presetname = trim($file->get_filepath(), '/');
2164                 if ($presetname==$presettofind) {
2165                     $this->directory = $presetname;
2166                     $fileobj = $file;
2167                 }
2168             }
2170             if (empty($fileobj)) {
2171                 print_error('invalidpreset', 'data', '', $this->directory);
2172             }
2173         }
2175         $allowed_settings = array(
2176             'intro',
2177             'comments',
2178             'requiredentries',
2179             'requiredentriestoview',
2180             'maxentries',
2181             'rssarticles',
2182             'approval',
2183             'defaultsortdir',
2184             'defaultsort');
2186         $result = new stdClass;
2187         $result->settings = new stdClass;
2188         $result->importfields = array();
2189         $result->currentfields = $DB->get_records('data_fields', array('dataid'=>$this->module->id));
2190         if (!$result->currentfields) {
2191             $result->currentfields = array();
2192         }
2195         /* Grab XML */
2196         $presetxml = $this->data_preset_get_file_contents($fs, $fileobj, $this->directory,'preset.xml');
2197         $parsedxml = xmlize($presetxml, 0);
2199         /* First, do settings. Put in user friendly array. */
2200         $settingsarray = $parsedxml['preset']['#']['settings'][0]['#'];
2201         $result->settings = new StdClass();
2202         foreach ($settingsarray as $setting => $value) {
2203             if (!is_array($value) || !in_array($setting, $allowed_settings)) {
2204                 // unsupported setting
2205                 continue;
2206             }
2207             $result->settings->$setting = $value[0]['#'];
2208         }
2210         /* Now work out fields to user friendly array */
2211         $fieldsarray = $parsedxml['preset']['#']['field'];
2212         foreach ($fieldsarray as $field) {
2213             if (!is_array($field)) {
2214                 continue;
2215             }
2216             $f = new StdClass();
2217             foreach ($field['#'] as $param => $value) {
2218                 if (!is_array($value)) {
2219                     continue;
2220                 }
2221                 $f->$param = $value[0]['#'];
2222             }
2223             $f->dataid = $this->module->id;
2224             $f->type = clean_param($f->type, PARAM_ALPHA);
2225             $result->importfields[] = $f;
2226         }
2227         /* Now add the HTML templates to the settings array so we can update d */
2228         $result->settings->singletemplate     = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"singletemplate.html");
2229         $result->settings->listtemplate       = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplate.html");
2230         $result->settings->listtemplateheader = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplateheader.html");
2231         $result->settings->listtemplatefooter = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplatefooter.html");
2232         $result->settings->addtemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"addtemplate.html");
2233         $result->settings->rsstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstemplate.html");
2234         $result->settings->rsstitletemplate   = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstitletemplate.html");
2235         $result->settings->csstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"csstemplate.css");
2236         $result->settings->jstemplate         = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"jstemplate.js");
2237         $result->settings->asearchtemplate    = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"asearchtemplate.html");
2239         $result->settings->instance = $this->module->id;
2240         return $result;
2241     }
2243     /**
2244      * Import the preset into the given database module
2245      * @return bool
2246      */
2247     function import($overwritesettings) {
2248         global $DB, $CFG;
2250         $params = $this->get_preset_settings();
2251         $settings = $params->settings;
2252         $newfields = $params->importfields;
2253         $currentfields = $params->currentfields;
2254         $preservedfields = array();
2256         /* Maps fields and makes new ones */
2257         if (!empty($newfields)) {
2258             /* We require an injective mapping, and need to know what to protect */
2259             foreach ($newfields as $nid => $newfield) {
2260                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2261                 if ($cid == -1) {
2262                     continue;
2263                 }
2264                 if (array_key_exists($cid, $preservedfields)){
2265                     print_error('notinjectivemap', 'data');
2266                 }
2267                 else $preservedfields[$cid] = true;
2268             }
2270             foreach ($newfields as $nid => $newfield) {
2271                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2273                 /* A mapping. Just need to change field params. Data kept. */
2274                 if ($cid != -1 and isset($currentfields[$cid])) {
2275                     $fieldobject = data_get_field_from_id($currentfields[$cid]->id, $this->module);
2276                     foreach ($newfield as $param => $value) {
2277                         if ($param != "id") {
2278                             $fieldobject->field->$param = $value;
2279                         }
2280                     }
2281                     unset($fieldobject->field->similarfield);
2282                     $fieldobject->update_field();
2283                     unset($fieldobject);
2284                 } else {
2285                     /* Make a new field */
2286                     include_once("field/$newfield->type/field.class.php");
2288                     if (!isset($newfield->description)) {
2289                         $newfield->description = '';
2290                     }
2291                     $classname = 'data_field_'.$newfield->type;
2292                     $fieldclass = new $classname($newfield, $this->module);
2293                     $fieldclass->insert_field();
2294                     unset($fieldclass);
2295                 }
2296             }
2297         }
2299         /* Get rid of all old unused data */
2300         if (!empty($preservedfields)) {
2301             foreach ($currentfields as $cid => $currentfield) {
2302                 if (!array_key_exists($cid, $preservedfields)) {
2303                     /* Data not used anymore so wipe! */
2304                     print "Deleting field $currentfield->name<br />";
2306                     $id = $currentfield->id;
2307                     //Why delete existing data records and related comments/ratings??
2308                     $DB->delete_records('data_content', array('fieldid'=>$id));
2309                     $DB->delete_records('data_fields', array('id'=>$id));
2310                 }
2311             }
2312         }
2314         // handle special settings here
2315         if (!empty($settings->defaultsort)) {
2316             if (is_numeric($settings->defaultsort)) {
2317                 // old broken value
2318                 $settings->defaultsort = 0;
2319             } else {
2320                 $settings->defaultsort = (int)$DB->get_field('data_fields', 'id', array('dataid'=>$this->module->id, 'name'=>$settings->defaultsort));
2321             }
2322         } else {
2323             $settings->defaultsort = 0;
2324         }
2326         // do we want to overwrite all current database settings?
2327         if ($overwritesettings) {
2328             // all supported settings
2329             $overwrite = array_keys((array)$settings);
2330         } else {
2331             // only templates and sorting
2332             $overwrite = array('singletemplate', 'listtemplate', 'listtemplateheader', 'listtemplatefooter',
2333                                'addtemplate', 'rsstemplate', 'rsstitletemplate', 'csstemplate', 'jstemplate',
2334                                'asearchtemplate', 'defaultsortdir', 'defaultsort');
2335         }
2337         // now overwrite current data settings
2338         foreach ($this->module as $prop=>$unused) {
2339             if (in_array($prop, $overwrite)) {
2340                 $this->module->$prop = $settings->$prop;
2341             }
2342         }
2344         data_update_instance($this->module);
2346         return $this->cleanup();
2347     }
2349     /**
2350      * Any clean up routines should go here
2351      * @return bool
2352      */
2353     public function cleanup() {
2354         return true;
2355     }
2358 /**
2359  * Data preset importer for uploaded presets
2360  */
2361 class data_preset_upload_importer extends data_preset_importer {
2362     public function __construct($course, $cm, $module, $filepath) {
2363         global $USER;
2364         if (is_file($filepath)) {
2365             $fp = get_file_packer();
2366             if ($fp->extract_to_pathname($filepath, $filepath.'_extracted')) {
2367                 fulldelete($filepath);
2368             }
2369             $filepath .= '_extracted';
2370         }
2371         parent::__construct($course, $cm, $module, $filepath);
2372     }
2373     public function cleanup() {
2374         return fulldelete($this->directory);
2375     }
2378 /**
2379  * Data preset importer for existing presets
2380  */
2381 class data_preset_existing_importer extends data_preset_importer {
2382     protected $userid;
2383     public function __construct($course, $cm, $module, $fullname) {
2384         global $USER;
2385         list($userid, $shortname) = explode('/', $fullname, 2);
2386         $context = context_module::instance($cm->id);
2387         if ($userid && ($userid != $USER->id) && !has_capability('mod/data:manageuserpresets', $context) && !has_capability('mod/data:viewalluserpresets', $context)) {
2388            throw new coding_exception('Invalid preset provided');
2389         }
2391         $this->userid = $userid;
2392         $filepath = data_preset_path($course, $userid, $shortname);
2393         parent::__construct($course, $cm, $module, $filepath);
2394     }
2395     public function get_userid() {
2396         return $this->userid;
2397     }
2400 /**
2401  * @global object
2402  * @global object
2403  * @param object $course
2404  * @param int $userid
2405  * @param string $shortname
2406  * @return string
2407  */
2408 function data_preset_path($course, $userid, $shortname) {
2409     global $USER, $CFG;
2411     $context = context_course::instance($course->id);
2413     $userid = (int)$userid;
2415     $path = null;
2416     if ($userid > 0 && ($userid == $USER->id || has_capability('mod/data:viewalluserpresets', $context))) {
2417         $path = $CFG->dataroot.'/data/preset/'.$userid.'/'.$shortname;
2418     } else if ($userid == 0) {
2419         $path = $CFG->dirroot.'/mod/data/preset/'.$shortname;
2420     } else if ($userid < 0) {
2421         $path = $CFG->tempdir.'/data/'.-$userid.'/'.$shortname;
2422     }
2424     return $path;
2427 /**
2428  * Implementation of the function for printing the form elements that control
2429  * whether the course reset functionality affects the data.
2430  *
2431  * @param $mform form passed by reference
2432  */
2433 function data_reset_course_form_definition(&$mform) {
2434     $mform->addElement('header', 'dataheader', get_string('modulenameplural', 'data'));
2435     $mform->addElement('checkbox', 'reset_data', get_string('deleteallentries','data'));
2437     $mform->addElement('checkbox', 'reset_data_notenrolled', get_string('deletenotenrolled', 'data'));
2438     $mform->disabledIf('reset_data_notenrolled', 'reset_data', 'checked');
2440     $mform->addElement('checkbox', 'reset_data_ratings', get_string('deleteallratings'));
2441     $mform->disabledIf('reset_data_ratings', 'reset_data', 'checked');
2443     $mform->addElement('checkbox', 'reset_data_comments', get_string('deleteallcomments'));
2444     $mform->disabledIf('reset_data_comments', 'reset_data', 'checked');
2447 /**
2448  * Course reset form defaults.
2449  * @return array
2450  */
2451 function data_reset_course_form_defaults($course) {
2452     return array('reset_data'=>0, 'reset_data_ratings'=>1, 'reset_data_comments'=>1, 'reset_data_notenrolled'=>0);
2455 /**
2456  * Removes all grades from gradebook
2457  *
2458  * @global object
2459  * @global object
2460  * @param int $courseid
2461  * @param string $type optional type
2462  */
2463 function data_reset_gradebook($courseid, $type='') {
2464     global $CFG, $DB;
2466     $sql = "SELECT d.*, cm.idnumber as cmidnumber, d.course as courseid
2467               FROM {data} d, {course_modules} cm, {modules} m
2468              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id AND d.course=?";
2470     if ($datas = $DB->get_records_sql($sql, array($courseid))) {
2471         foreach ($datas as $data) {
2472             data_grade_item_update($data, 'reset');
2473         }
2474     }
2477 /**
2478  * Actual implementation of the reset course functionality, delete all the
2479  * data responses for course $data->courseid.
2480  *
2481  * @global object
2482  * @global object
2483  * @param object $data the data submitted from the reset course.
2484  * @return array status array
2485  */
2486 function data_reset_userdata($data) {
2487     global $CFG, $DB;
2488     require_once($CFG->libdir.'/filelib.php');
2489     require_once($CFG->dirroot.'/rating/lib.php');
2491     $componentstr = get_string('modulenameplural', 'data');
2492     $status = array();
2494     $allrecordssql = "SELECT r.id
2495                         FROM {data_records} r
2496                              INNER JOIN {data} d ON r.dataid = d.id
2497                        WHERE d.course = ?";
2499     $alldatassql = "SELECT d.id
2500                       FROM {data} d
2501                      WHERE d.course=?";
2503     $rm = new rating_manager();
2504     $ratingdeloptions = new stdClass;
2505     $ratingdeloptions->component = 'mod_data';
2506     $ratingdeloptions->ratingarea = 'entry';
2508     // delete entries if requested
2509     if (!empty($data->reset_data)) {
2510         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2511         $DB->delete_records_select('data_content', "recordid IN ($allrecordssql)", array($data->courseid));
2512         $DB->delete_records_select('data_records', "dataid IN ($alldatassql)", array($data->courseid));
2514         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2515             foreach ($datas as $dataid=>$unused) {
2516                 fulldelete("$CFG->dataroot/$data->courseid/moddata/data/$dataid");
2518                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2519                     continue;
2520                 }
2521                 $datacontext = context_module::instance($cm->id);
2523                 $ratingdeloptions->contextid = $datacontext->id;
2524                 $rm->delete_ratings($ratingdeloptions);
2525             }
2526         }
2528         if (empty($data->reset_gradebook_grades)) {
2529             // remove all grades from gradebook
2530             data_reset_gradebook($data->courseid);
2531         }
2532         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallentries', 'data'), 'error'=>false);
2533     }
2535     // remove entries by users not enrolled into course
2536     if (!empty($data->reset_data_notenrolled)) {
2537         $recordssql = "SELECT r.id, r.userid, r.dataid, u.id AS userexists, u.deleted AS userdeleted
2538                          FROM {data_records} r
2539                               JOIN {data} d ON r.dataid = d.id
2540                               LEFT JOIN {user} u ON r.userid = u.id
2541                         WHERE d.course = ? AND r.userid > 0";
2543         $course_context = context_course::instance($data->courseid);
2544         $notenrolled = array();
2545         $fields = array();
2546         $rs = $DB->get_recordset_sql($recordssql, array($data->courseid));
2547         foreach ($rs as $record) {
2548             if (array_key_exists($record->userid, $notenrolled) or !$record->userexists or $record->userdeleted
2549               or !is_enrolled($course_context, $record->userid)) {
2550                 //delete ratings
2551                 if (!$cm = get_coursemodule_from_instance('data', $record->dataid)) {
2552                     continue;
2553                 }
2554                 $datacontext = context_module::instance($cm->id);
2555                 $ratingdeloptions->contextid = $datacontext->id;
2556                 $ratingdeloptions->itemid = $record->id;
2557                 $rm->delete_ratings($ratingdeloptions);
2559                 $DB->delete_records('comments', array('itemid'=>$record->id, 'commentarea'=>'database_entry'));
2560                 $DB->delete_records('data_content', array('recordid'=>$record->id));
2561                 $DB->delete_records('data_records', array('id'=>$record->id));
2562                 // HACK: this is ugly - the recordid should be before the fieldid!
2563                 if (!array_key_exists($record->dataid, $fields)) {
2564                     if ($fs = $DB->get_records('data_fields', array('dataid'=>$record->dataid))) {
2565                         $fields[$record->dataid] = array_keys($fs);
2566                     } else {
2567                         $fields[$record->dataid] = array();
2568                     }
2569                 }
2570                 foreach($fields[$record->dataid] as $fieldid) {
2571                     fulldelete("$CFG->dataroot/$data->courseid/moddata/data/$record->dataid/$fieldid/$record->id");
2572                 }
2573                 $notenrolled[$record->userid] = true;
2574             }
2575         }
2576         $rs->close();
2577         $status[] = array('component'=>$componentstr, 'item'=>get_string('deletenotenrolled', 'data'), 'error'=>false);
2578     }
2580     // remove all ratings
2581     if (!empty($data->reset_data_ratings)) {
2582         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2583             foreach ($datas as $dataid=>$unused) {
2584                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2585                     continue;
2586                 }
2587                 $datacontext = context_module::instance($cm->id);
2589                 $ratingdeloptions->contextid = $datacontext->id;
2590                 $rm->delete_ratings($ratingdeloptions);
2591             }
2592         }
2594         if (empty($data->reset_gradebook_grades)) {
2595             // remove all grades from gradebook
2596             data_reset_gradebook($data->courseid);
2597         }
2599         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallratings'), 'error'=>false);
2600     }
2602     // remove all comments
2603     if (!empty($data->reset_data_comments)) {
2604         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2605         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallcomments'), 'error'=>false);
2606     }
2608     // updating dates - shift may be negative too
2609     if ($data->timeshift) {
2610         shift_course_mod_dates('data', array('timeavailablefrom', 'timeavailableto', 'timeviewfrom', 'timeviewto'), $data->timeshift, $data->courseid);
2611         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
2612     }
2614     return $status;
2617 /**
2618  * Returns all other caps used in module
2619  *
2620  * @return array
2621  */
2622 function data_get_extra_capabilities() {
2623     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');
2626 /**
2627  * @param string $feature FEATURE_xx constant for requested feature
2628  * @return mixed True if module supports feature, null if doesn't know
2629  */
2630 function data_supports($feature) {
2631     switch($feature) {
2632         case FEATURE_GROUPS:                  return true;
2633         case FEATURE_GROUPINGS:               return true;
2634         case FEATURE_GROUPMEMBERSONLY:        return true;
2635         case FEATURE_MOD_INTRO:               return true;
2636         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
2637         case FEATURE_GRADE_HAS_GRADE:         return true;
2638         case FEATURE_GRADE_OUTCOMES:          return true;
2639         case FEATURE_RATE:                    return true;
2640         case FEATURE_BACKUP_MOODLE2:          return true;
2641         case FEATURE_SHOW_DESCRIPTION:        return true;
2643         default: return null;
2644     }
2646 /**
2647  * @global object
2648  * @param array $export
2649  * @param string $delimiter_name
2650  * @param object $database
2651  * @param int $count
2652  * @param bool $return
2653  * @return string|void
2654  */
2655 function data_export_csv($export, $delimiter_name, $database, $count, $return=false) {
2656     global $CFG;
2657     require_once($CFG->libdir . '/csvlib.class.php');
2659     $filename = $database . '-' . $count . '-record';
2660     if ($count > 1) {
2661         $filename .= 's';
2662     }
2663     if ($return) {
2664         return csv_export_writer::print_array($export, $delimiter_name, '"', true);
2665     } else {
2666         csv_export_writer::download_array($filename, $export, $delimiter_name);
2667     }
2670 /**
2671  * @global object
2672  * @param array $export
2673  * @param string $dataname
2674  * @param int $count
2675  * @return string
2676  */
2677 function data_export_xls($export, $dataname, $count) {
2678     global $CFG;
2679     require_once("$CFG->libdir/excellib.class.php");
2680     $filename = clean_filename("{$dataname}-{$count}_record");
2681     if ($count > 1) {
2682         $filename .= 's';
2683     }
2684     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
2685     $filename .= '.xls';
2687     $filearg = '-';
2688     $workbook = new MoodleExcelWorkbook($filearg);
2689     $workbook->send($filename);
2690     $worksheet = array();
2691     $worksheet[0] = $workbook->add_worksheet('');
2692     $rowno = 0;
2693     foreach ($export as $row) {
2694         $colno = 0;
2695         foreach($row as $col) {
2696             $worksheet[0]->write($rowno, $colno, $col);
2697             $colno++;
2698         }
2699         $rowno++;
2700     }
2701     $workbook->close();
2702     return $filename;
2705 /**
2706  * @global object
2707  * @param array $export
2708  * @param string $dataname
2709  * @param int $count
2710  * @param string
2711  */
2712 function data_export_ods($export, $dataname, $count) {
2713     global $CFG;
2714     require_once("$CFG->libdir/odslib.class.php");
2715     $filename = clean_filename("{$dataname}-{$count}_record");
2716     if ($count > 1) {
2717         $filename .= 's';
2718     }
2719     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
2720     $filename .= '.ods';
2721     $filearg = '-';
2722     $workbook = new MoodleODSWorkbook($filearg);
2723     $workbook->send($filename);
2724     $worksheet = array();
2725     $worksheet[0] = $workbook->add_worksheet('');
2726     $rowno = 0;
2727     foreach ($export as $row) {
2728         $colno = 0;
2729         foreach($row as $col) {
2730             $worksheet[0]->write($rowno, $colno, $col);
2731             $colno++;
2732         }
2733         $rowno++;
2734     }
2735     $workbook->close();
2736     return $filename;
2739 /**
2740  * @global object
2741  * @param int $dataid
2742  * @param array $fields
2743  * @param array $selectedfields
2744  * @param int $currentgroup group ID of the current group. This is used for
2745  * exporting data while maintaining group divisions.
2746  * @param object $context the context in which the operation is performed (for capability checks)
2747  * @param bool $userdetails whether to include the details of the record author
2748  * @param bool $time whether to include time created/modified
2749  * @param bool $approval whether to include approval status
2750  * @return array
2751  */
2752 function data_get_exportdata($dataid, $fields, $selectedfields, $currentgroup=0, $context=null,
2753                              $userdetails=false, $time=false, $approval=false) {
2754     global $DB;
2756     if (is_null($context)) {
2757         $context = context_system::instance();
2758     }
2759     // exporting user data needs special permission
2760     $userdetails = $userdetails && has_capability('mod/data:exportuserinfo', $context);
2762     $exportdata = array();
2764     // populate the header in first row of export
2765     foreach($fields as $key => $field) {
2766         if (!in_array($field->field->id, $selectedfields)) {
2767             // ignore values we aren't exporting
2768             unset($fields[$key]);
2769         } else {
2770             $exportdata[0][] = $field->field->name;
2771         }
2772     }
2773     if ($userdetails) {
2774         $exportdata[0][] = get_string('user');
2775         $exportdata[0][] = get_string('username');
2776         $exportdata[0][] = get_string('email');
2777     }
2778     if ($time) {
2779         $exportdata[0][] = get_string('timeadded', 'data');
2780         $exportdata[0][] = get_string('timemodified', 'data');
2781     }
2782     if ($approval) {
2783         $exportdata[0][] = get_string('approved', 'data');
2784     }
2786     $datarecords = $DB->get_records('data_records', array('dataid'=>$dataid));
2787     ksort($datarecords);
2788     $line = 1;
2789     foreach($datarecords as $record) {
2790         // get content indexed by fieldid
2791         if ($currentgroup) {
2792             $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 = ?';
2793             $where = array($record->id, $currentgroup);
2794         } else {
2795             $select = 'SELECT fieldid, content, content1, content2, content3, content4 FROM {data_content} WHERE recordid = ?';
2796             $where = array($record->id);
2797         }
2799         if( $content = $DB->get_records_sql($select, $where) ) {
2800             foreach($fields as $field) {
2801                 $contents = '';
2802                 if(isset($content[$field->field->id])) {
2803                     $contents = $field->export_text_value($content[$field->field->id]);
2804                 }
2805                 $exportdata[$line][] = $contents;
2806             }
2807             if ($userdetails) { // Add user details to the export data
2808                 $userdata = get_complete_user_data('id', $record->userid);
2809                 $exportdata[$line][] = fullname($userdata);
2810                 $exportdata[$line][] = $userdata->username;
2811                 $exportdata[$line][] = $userdata->email;
2812             }
2813             if ($time) { // Add time added / modified
2814                 $exportdata[$line][] = userdate($record->timecreated);
2815                 $exportdata[$line][] = userdate($record->timemodified);
2816             }
2817             if ($approval) { // Add approval status
2818                 $exportdata[$line][] = (int) $record->approved;
2819             }
2820         }
2821         $line++;
2822     }
2823     $line--;
2824     return $exportdata;
2827 ////////////////////////////////////////////////////////////////////////////////
2828 // File API                                                                   //
2829 ////////////////////////////////////////////////////////////////////////////////
2831 /**
2832  * Lists all browsable file areas
2833  *
2834  * @package  mod_data
2835  * @category files
2836  * @param stdClass $course course object
2837  * @param stdClass $cm course module object
2838  * @param stdClass $context context object
2839  * @return array
2840  */
2841 function data_get_file_areas($course, $cm, $context) {
2842     return array('content' => get_string('areacontent', 'mod_data'));
2845 /**
2846  * File browsing support for data module.
2847  *
2848  * @param file_browser $browser
2849  * @param array $areas
2850  * @param stdClass $course
2851  * @param cm_info $cm
2852  * @param context $context
2853  * @param string $filearea
2854  * @param int $itemid
2855  * @param string $filepath
2856  * @param string $filename
2857  * @return file_info_stored file_info_stored instance or null if not found
2858  */
2859 function data_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
2860     global $CFG, $DB, $USER;
2862     if ($context->contextlevel != CONTEXT_MODULE) {
2863         return null;
2864     }
2866     if (!isset($areas[$filearea])) {
2867         return null;
2868     }
2870     if (is_null($itemid)) {
2871         require_once($CFG->dirroot.'/mod/data/locallib.php');
2872         return new data_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
2873     }
2875     if (!$content = $DB->get_record('data_content', array('id'=>$itemid))) {
2876         return null;
2877     }
2879     if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
2880         return null;
2881     }
2883     if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
2884         return null;
2885     }
2887     if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
2888         return null;
2889     }
2891     //check if approved
2892     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
2893         return null;
2894     }
2896     // group access
2897     if ($record->groupid) {
2898         $groupmode = groups_get_activity_groupmode($cm, $course);
2899         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
2900             if (!groups_is_member($record->groupid)) {
2901                 return null;
2902             }
2903         }
2904     }
2906     $fieldobj = data_get_field($field, $data, $cm);
2908     $filepath = is_null($filepath) ? '/' : $filepath;
2909     $filename = is_null($filename) ? '.' : $filename;
2910     if (!$fieldobj->file_ok($filepath.$filename)) {
2911         return null;
2912     }
2914     $fs = get_file_storage();
2915     if (!($storedfile = $fs->get_file($context->id, 'mod_data', $filearea, $itemid, $filepath, $filename))) {
2916         return null;
2917     }
2919     // Checks to see if the user can manage files or is the owner.
2920     // TODO MDL-33805 - Do not use userid here and move the capability check above.
2921     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
2922         return null;
2923     }
2925     $urlbase = $CFG->wwwroot.'/pluginfile.php';
2927     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
2930 /**
2931  * Serves the data attachments. Implements needed access control ;-)
2932  *
2933  * @package  mod_data
2934  * @category files
2935  * @param stdClass $course course object
2936  * @param stdClass $cm course module object
2937  * @param stdClass $context context object
2938  * @param string $filearea file area
2939  * @param array $args extra arguments
2940  * @param bool $forcedownload whether or not force download
2941  * @param array $options additional options affecting the file serving
2942  * @return bool false if file not found, does not return if found - justsend the file
2943  */
2944 function data_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
2945     global $CFG, $DB;
2947     if ($context->contextlevel != CONTEXT_MODULE) {
2948         return false;
2949     }
2951     require_course_login($course, true, $cm);
2953     if ($filearea === 'content') {
2954         $contentid = (int)array_shift($args);
2956         if (!$content = $DB->get_record('data_content', array('id'=>$contentid))) {
2957             return false;
2958         }
2960         if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
2961             return false;
2962         }
2964         if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
2965             return false;
2966         }
2968         if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
2969             return false;
2970         }
2972         if ($data->id != $cm->instance) {
2973             // hacker attempt - context does not match the contentid
2974             return false;
2975         }
2977         //check if approved
2978         if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
2979             return false;
2980         }
2982         // group access
2983         if ($record->groupid) {
2984             $groupmode = groups_get_activity_groupmode($cm, $course);
2985             if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
2986                 if (!groups_is_member($record->groupid)) {
2987                     return false;
2988                 }
2989             }
2990         }
2992         $fieldobj = data_get_field($field, $data, $cm);
2994         $relativepath = implode('/', $args);
2995         $fullpath = "/$context->id/mod_data/content/$content->id/$relativepath";
2997         if (!$fieldobj->file_ok($relativepath)) {
2998             return false;
2999         }
3001         $fs = get_file_storage();
3002         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
3003             return false;
3004         }
3006         // finally send the file
3007         send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
3008     }
3010     return false;
3014 function data_extend_navigation($navigation, $course, $module, $cm) {
3015     global $CFG, $OUTPUT, $USER, $DB;
3017     $rid = optional_param('rid', 0, PARAM_INT);
3019     $data = $DB->get_record('data', array('id'=>$cm->instance));
3020     $currentgroup = groups_get_activity_group($cm);
3021     $groupmode = groups_get_activity_groupmode($cm);
3023      $numentries = data_numentries($data);
3024     /// Check the number of entries required against the number of entries already made (doesn't apply to teachers)
3025     if ($data->requiredentries > 0 && $numentries < $data->requiredentries && !has_capability('mod/data:manageentries', context_module::instance($cm->id))) {
3026         $data->entriesleft = $data->requiredentries - $numentries;
3027         $entriesnode = $navigation->add(get_string('entrieslefttoadd', 'data', $data));
3028         $entriesnode->add_class('note');
3029     }
3031     $navigation->add(get_string('list', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance)));
3032     if (!empty($rid)) {
3033         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'rid'=>$rid)));
3034     } else {
3035         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'single')));
3036     }
3037     $navigation->add(get_string('search', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'asearch')));
3040 /**
3041  * Adds module specific settings to the settings block
3042  *
3043  * @param settings_navigation $settings The settings navigation object
3044  * @param navigation_node $datanode The node to add module settings to
3045  */
3046 function data_extend_settings_navigation(settings_navigation $settings, navigation_node $datanode) {
3047     global $PAGE, $DB, $CFG, $USER;
3049     $data = $DB->get_record('data', array("id" => $PAGE->cm->instance));
3051     $currentgroup = groups_get_activity_group($PAGE->cm);
3052     $groupmode = groups_get_activity_groupmode($PAGE->cm);
3054     if (data_user_can_add_entry($data, $currentgroup, $groupmode, $PAGE->cm->context)) { // took out participation list here!
3055         if (empty($editentry)) { //TODO: undefined
3056             $addstring = get_string('add', 'data');
3057         } else {
3058             $addstring = get_string('editentry', 'data');
3059         }
3060         $datanode->add($addstring, new moodle_url('/mod/data/edit.php', array('d'=>$PAGE->cm->instance)));
3061     }
3063     if (has_capability(DATA_CAP_EXPORT, $PAGE->cm->context)) {
3064         // The capability required to Export database records is centrally defined in 'lib.php'
3065         // and should be weaker than those required to edit Templates, Fields and Presets.
3066         $datanode->add(get_string('exportentries', 'data'), new moodle_url('/mod/data/export.php', array('d'=>$data->id)));
3067     }
3068     if (has_capability('mod/data:manageentries', $PAGE->cm->context)) {
3069         $datanode->add(get_string('importentries', 'data'), new moodle_url('/mod/data/import.php', array('d'=>$data->id)));
3070     }
3072     if (has_capability('mod/data:managetemplates', $PAGE->cm->context)) {
3073         $currenttab = '';
3074         if ($currenttab == 'list') {
3075             $defaultemplate = 'listtemplate';
3076         } else if ($currenttab == 'add') {
3077             $defaultemplate = 'addtemplate';
3078         } else if ($currenttab == 'asearch') {
3079             $defaultemplate = 'asearchtemplate';
3080         } else {
3081             $defaultemplate = 'singletemplate';
3082         }
3084         $templates = $datanode->add(get_string('templates', 'data'));
3086         $templatelist = array ('listtemplate', 'singletemplate', 'asearchtemplate', 'addtemplate', 'rsstemplate', 'csstemplate', 'jstemplate');
3087         foreach ($templatelist as $template) {
3088             $templates->add(get_string($template, 'data'), new moodle_url('/mod/data/templates.php', array('d'=>$data->id,'mode'=>$template)));
3089         }
3091         $datanode->add(get_string('fields', 'data'), new moodle_url('/mod/data/field.php', array('d'=>$data->id)));
3092         $datanode->add(get_string('presets', 'data'), new moodle_url('/mod/data/preset.php', array('d'=>$data->id)));
3093     }
3095     if (!empty($CFG->enablerssfeeds) && !empty($CFG->data_enablerssfeeds) && $data->rssarticles > 0) {
3096         require_once("$CFG->libdir/rsslib.php");
3098         $string = get_string('rsstype','forum');
3100         $url = new moodle_url(rss_get_url($PAGE->cm->context->id, $USER->id, 'mod_data', $data->id));
3101         $datanode->add($string, $url, settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
3102     }
3105 /**
3106  * Save the database configuration as a preset.
3107  *
3108  * @param stdClass $course The course the database module belongs to.
3109  * @param stdClass $cm The course module record
3110  * @param stdClass $data The database record
3111  * @param string $path
3112  * @return bool
3113  */
3114 function data_presets_save($course, $cm, $data, $path) {
3115     global $USER;
3116     $fs = get_file_storage();
3117     $filerecord = new stdClass;
3118     $filerecord->contextid = DATA_PRESET_CONTEXT;
3119     $filerecord->component = DATA_PRESET_COMPONENT;
3120     $filerecord->filearea = DATA_PRESET_FILEAREA;
3121     $filerecord->itemid = 0;
3122     $filerecord->filepath = '/'.$path.'/';
3123     $filerecord->userid = $USER->id;
3125     $filerecord->filename = 'preset.xml';
3126     $fs->create_file_from_string($filerecord, data_presets_generate_xml($course, $cm, $data));
3128     $filerecord->filename = 'singletemplate.html';
3129     $fs->create_file_from_string($filerecord, $data->singletemplate);
3131     $filerecord->filename = 'listtemplateheader.html';
3132     $fs->create_file_from_string($filerecord, $data->listtemplateheader);
3134     $filerecord->filename = 'listtemplate.html';
3135     $fs->create_file_from_string($filerecord, $data->listtemplate);
3137     $filerecord->filename = 'listtemplatefooter.html';
3138     $fs->create_file_from_string($filerecord, $data->listtemplatefooter);
3140     $filerecord->filename = 'addtemplate.html';
3141     $fs->create_file_from_string($filerecord, $data->addtemplate);
3143     $filerecord->filename = 'rsstemplate.html';
3144     $fs->create_file_from_string($filerecord, $data->rsstemplate);
3146     $filerecord->filename = 'rsstitletemplate.html';
3147     $fs->create_file_from_string($filerecord, $data->rsstitletemplate);
3149     $filerecord->filename = 'csstemplate.css';
3150     $fs->create_file_from_string($filerecord, $data->csstemplate);
3152     $filerecord->filename = 'jstemplate.js';
3153     $fs->create_file_from_string($filerecord, $data->jstemplate);
3155     $filerecord->filename = 'asearchtemplate.html';
3156     $fs->create_file_from_string($filerecord, $data->asearchtemplate);
3158     return true;
3161 /**
3162  * Generates the XML for the database module provided
3163  *
3164  * @global moodle_database $DB
3165  * @param stdClass $course The course the database module belongs to.
3166  * @param stdClass $cm The course module record
3167  * @param stdClass $data The database record
3168  * @return string The XML for the preset
3169  */
3170 function data_presets_generate_xml($course, $cm, $data) {
3171     global $DB;
3173     // Assemble "preset.xml":
3174     $presetxmldata = "<preset>\n\n";
3176     // Raw settings are not preprocessed during saving of presets
3177     $raw_settings = array(
3178         'intro',
3179         'comments',
3180         'requiredentries',
3181         'requiredentriestoview',
3182         'maxentries',
3183         'rssarticles',
3184         'approval',
3185         'defaultsortdir'
3186     );
3188     $presetxmldata .= "<settings>\n";
3189     // First, settings that do not require any conversion
3190     foreach ($raw_settings as $setting) {
3191         $presetxmldata .= "<$setting>" . htmlspecialchars($data->$setting) . "</$setting>\n";
3192     }
3194     // Now specific settings
3195     if ($data->defaultsort > 0 && $sortfield = data_get_field_from_id($data->defaultsort, $data)) {
3196         $presetxmldata .= '<defaultsort>' . htmlspecialchars($sortfield->field->name) . "</defaultsort>\n";
3197     } else {
3198         $presetxmldata .= "<defaultsort>0</defaultsort>\n";
3199     }
3200     $presetxmldata .= "</settings>\n\n";
3201     // Now for the fields. Grab all that are non-empty
3202     $fields = $DB->get_records('data_fields', array('dataid'=>$data->id));
3203     ksort($fields);
3204     if (!empty($fields)) {
3205         foreach ($fields as $field) {
3206             $presetxmldata .= "<field>\n";
3207             foreach ($field as $key => $value) {
3208                 if ($value != '' && $key != 'id' && $key != 'dataid') {
3209                     $presetxmldata .= "<$key>" . htmlspecialchars($value) . "</$key>\n";
3210                 }
3211             }
3212             $presetxmldata .= "</field>\n\n";
3213         }
3214     }
3215     $presetxmldata .= '</preset>';
3216     return $presetxmldata;
3219 function data_presets_export($course, $cm, $data, $tostorage=false) {
3220     global $CFG, $DB;
3222     $presetname = clean_filename($data->name) . '-preset-' . gmdate("Ymd_Hi");
3223     $exportsubdir = "mod_data/presetexport/$presetname";
3224     make_temp_directory($exportsubdir);
3225     $exportdir = "$CFG->tempdir/$exportsubdir";
3227     // Assemble "preset.xml":
3228     $presetxmldata = data_presets_generate_xml($course, $cm, $data);
3230     // After opening a file in write mode, close it asap
3231     $presetxmlfile = fopen($exportdir . '/preset.xml', 'w');
3232     fwrite($presetxmlfile, $presetxmldata);
3233     fclose($presetxmlfile);
3235     // Now write the template files
3236     $singletemplate = fopen($exportdir . '/singletemplate.html', 'w');
3237     fwrite($singletemplate, $data->singletemplate);
3238     fclose($singletemplate);
3240     $listtemplateheader = fopen($exportdir . '/listtemplateheader.html', 'w');
3241     fwrite($listtemplateheader, $data->listtemplateheader);
3242     fclose($listtemplateheader);
3244     $listtemplate = fopen($exportdir . '/listtemplate.html', 'w');
3245     fwrite($listtemplate, $data->listtemplate);
3246     fclose($listtemplate);
3248     $listtemplatefooter = fopen($exportdir . '/listtemplatefooter.html', 'w');
3249     fwrite($listtemplatefooter, $data->listtemplatefooter);
3250     fclose($listtemplatefooter);
3252     $addtemplate = fopen($exportdir . '/addtemplate.html', 'w');
3253     fwrite($addtemplate, $data->addtemplate);
3254     fclose($addtemplate);
3256     $rsstemplate = fopen($exportdir . '/rsstemplate.html', 'w');
3257     fwrite($rsstemplate, $data->rsstemplate);
3258     fclose($rsstemplate);
3260     $rsstitletemplate = fopen($exportdir . '/rsstitletemplate.html', 'w');
3261     fwrite($rsstitletemplate, $data->rsstitletemplate);
3262     fclose($rsstitletemplate);
3264     $csstemplate = fopen($exportdir . '/csstemplate.css', 'w');
3265     fwrite($csstemplate, $data->csstemplate);
3266     fclose($csstemplate);
3268     $jstemplate = fopen($exportdir . '/jstemplate.js', 'w');
3269     fwrite($jstemplate, $data->jstemplate);
3270     fclose($jstemplate);
3272     $asearchtemplate = fopen($exportdir . '/asearchtemplate.html', 'w');
3273     fwrite($asearchtemplate, $data->asearchtemplate);
3274     fclose($asearchtemplate);
3276     // Check if all files have been generated
3277     if (! is_directory_a_preset($exportdir)) {
3278         print_error('generateerror', 'data');
3279     }
3281     $filenames = array(
3282         'preset.xml',
3283         'singletemplate.html',
3284         'listtemplateheader.html',
3285         'listtemplate.html',
3286         'listtemplatefooter.html',
3287         'addtemplate.html',
3288         'rsstemplate.html',
3289         'rsstitletemplate.html',
3290         'csstemplate.css',
3291         'jstemplate.js',
3292         'asearchtemplate.html'
3293     );
3295     $filelist = array();
3296     foreach ($filenames as $filename) {
3297         $filelist[$filename] = $exportdir . '/' . $filename;
3298     }
3300     $exportfile = $exportdir.'.zip';
3301     file_exists($exportfile) && unlink($exportfile);
3303     $fp = get_file_packer('application/zip');
3304     $fp->archive_to_pathname($filelist, $exportfile);
3306     foreach ($filelist as $file) {
3307         unlink($file);
3308     }
3309     rmdir($exportdir);
3311     // Return the full path to the exported preset file:
3312     return $exportfile;
3315 /**
3316  * Running addtional permission check on plugin, for example, plugins
3317  * may have switch to turn on/off comments option, this callback will
3318  * affect UI display, not like pluginname_comment_validate only throw
3319  * exceptions.
3320  * Capability check has been done in comment->check_permissions(), we
3321  * don't need to do it again here.
3322  *
3323  * @package  mod_data
3324  * @category comment
3325  *
3326  * @param stdClass $comment_param {
3327  *              context  => context the context object
3328  *              courseid => int course id
3329  *              cm       => stdClass course module object
3330  *              commentarea => string comment area
3331  *              itemid      => int itemid
3332  * }
3333  * @return array
3334  */
3335 function data_comment_permissions($comment_param) {
3336     global $CFG, $DB;
3337     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3338         throw new comment_exception('invalidcommentitemid');
3339     }
3340     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3341         throw new comment_exception('invalidid', 'data');
3342     }
3343     if ($data->comments) {
3344         return array('post'=>true, 'view'=>true);
3345     } else {
3346         return array('post'=>false, 'view'=>false);
3347     }
3350 /**
3351  * Validate comment parameter before perform other comments actions
3352  *
3353  * @package  mod_data
3354  * @category comment
3355  *
3356  * @param stdClass $comment_param {
3357  *              context  => context the context object
3358  *              courseid => int course id
3359  *              cm       => stdClass course module object
3360  *              commentarea => string comment area
3361  *              itemid      => int itemid
3362  * }
3363  * @return boolean
3364  */
3365 function data_comment_validate($comment_param) {
3366     global $DB;
3367     // validate comment area
3368     if ($comment_param->commentarea != 'database_entry') {
3369         throw new comment_exception('invalidcommentarea');
3370     }
3371     // validate itemid
3372     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3373         throw new comment_exception('invalidcommentitemid');
3374     }
3375     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3376         throw new comment_exception('invalidid', 'data');
3377     }
3378     if (!$course = $DB->get_record('course', array('id'=>$data->course))) {
3379         throw new comment_exception('coursemisconf');
3380     }
3381     if (!$cm = get_coursemodule_from_instance('data', $data->id, $course->id)) {
3382         throw new comment_exception('invalidcoursemodule');
3383     }
3384     if (!$data->comments) {
3385         throw new comment_exception('commentsoff', 'data');
3386     }
3387     $context = context_module::instance($cm->id);
3389     //check if approved
3390     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3391         throw new comment_exception('notapproved', 'data');
3392     }
3394     // group access
3395     if ($record->groupid) {
3396         $groupmode = groups_get_activity_groupmode($cm, $course);
3397         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3398             if (!groups_is_member($record->groupid)) {
3399                 throw new comment_exception('notmemberofgroup');
3400             }
3401         }
3402     }
3403     // validate context id
3404     if ($context->id != $comment_param->context->id) {
3405         throw new comment_exception('invalidcontext');
3406     }
3407     // validation for comment deletion
3408     if (!empty($comment_param->commentid)) {
3409         if ($comment = $DB->get_record('comments', array('id'=>$comment_param->commentid))) {
3410             if ($comment->commentarea != 'database_entry') {
3411                 throw new comment_exception('invalidcommentarea');
3412             }
3413             if ($comment->contextid != $comment_param->context->id) {
3414                 throw new comment_exception('invalidcontext');
3415             }
3416             if ($comment->itemid != $comment_param->itemid) {
3417                 throw new comment_exception('invalidcommentitemid');
3418             }
3419         } else {
3420             throw new comment_exception('invalidcommentid');
3421         }
3422     }
3423     return true;
3426 /**
3427  * Return a list of page types
3428  * @param string $pagetype current page type
3429  * @param stdClass $parentcontext Block's parent context
3430  * @param stdClass $currentcontext Current context of block
3431  */
3432 function data_page_type_list($pagetype, $parentcontext, $currentcontext) {
3433     $module_pagetype = array('mod-data-*'=>get_string('page-mod-data-x', 'data'));
3434     return $module_pagetype;
3437 /**
3438  * Get all of the record ids from a database activity.
3439  *
3440  * @param int    $dataid      The dataid of the database module.
3441  * @param object $selectdata  Contains an additional sql statement for the
3442  *                            where clause for group and approval fields.
3443  * @param array  $params      Parameters that coincide with the sql statement.
3444  * @return array $idarray     An array of record ids
3445  */
3446 function data_get_all_recordids($dataid, $selectdata = '', $params = null) {
3447     global $DB;
3448     $initsql = 'SELECT r.id
3449                   FROM {data_records} r
3450                  WHERE r.dataid = :dataid';
3451     if ($selectdata != '') {
3452         $initsql .= $selectdata;
3453         $params = array_merge(array('dataid' => $dataid), $params);
3454     } else {
3455         $params = array('dataid' => $dataid);
3456     }
3457     $initsql .= ' GROUP BY r.id';
3458     $initrecord = $DB->get_recordset_sql($initsql, $params);
3459     $idarray = array();
3460     foreach ($initrecord as $data) {
3461         $idarray[] = $data->id;
3462     }
3463     // Close the record set and free up resources.
3464     $initrecord->close();
3465     return $idarray;
3468 /**
3469  * Get the ids of all the records that match that advanced search criteria
3470  * This goes and loops through each criterion one at a time until it either
3471  * runs out of records or returns a subset of records.
3472  *
3473  * @param array $recordids    An array of record ids.
3474  * @param array $searcharray  Contains information for the advanced search criteria
3475  * @param int $dataid         The data id of the database.
3476  * @return array $recordids   An array of record ids.
3477  */
3478 function data_get_advance_search_ids($recordids, $searcharray, $dataid) {
3479     $searchcriteria = array_keys($searcharray);
3480     // Loop through and reduce the IDs one search criteria at a time.
3481     foreach ($searchcriteria as $key) {
3482         $recordids = data_get_recordids($key, $searcharray, $dataid, $recordids);
3483         // If we don't have anymore IDs then stop.
3484         if (!$recordids) {
3485             break;
3486         }
3487     }
3488     return $recordids;
3491 /**
3492  * Gets the record IDs given the search criteria
3493  *
3494  * @param string $alias       Record alias.
3495  * @param array $searcharray  Criteria for the search.
3496  * @param int $dataid         Data ID for the database
3497  * @param array $recordids    An array of record IDs.
3498  * @return array $nestarray   An arry of record IDs
3499  */
3500 function data_get_recordids($alias, $searcharray, $dataid, $recordids) {
3501     global $DB;
3503     $nestsearch = $searcharray[$alias];
3504     // searching for content outside of mdl_data_content
3505     if ($alias < 0) {
3506         $alias = '';
3507     }
3508     list($insql, $params) = $DB->get_in_or_equal($recordids, SQL_PARAMS_NAMED);
3509     $nestselect = 'SELECT c' . $alias . '.recordid
3510                      FROM {data_content} c' . $alias . ',
3511                           {data_fields} f,
3512                           {data_records} r,
3513                           {user} u ';
3514     $nestwhere = 'WHERE u.id = r.userid
3515                     AND f.id = c' . $alias . '.fieldid
3516                     AND r.id = c' . $alias . '.recordid
3517                     AND r.dataid = :dataid
3518                     AND c' . $alias .'.recordid ' . $insql . '
3519                     AND ';
3521     $params['dataid'] = $dataid;
3522     if (count($nestsearch->params) != 0) {
3523         $params = array_merge($params, $nestsearch->params);
3524         $nestsql = $nestselect . $nestwhere . $nestsearch->sql;
3525     } else {
3526         $thing = $DB->sql_like($nestsearch->field, ':search1', false);
3527         $nestsql = $nestselect . $nestwhere . $thing . ' GROUP BY c' . $alias . '.recordid';
3528         $params['search1'] = "%$nestsearch->data%";
3529     }
3530     $nestrecords = $DB->get_recordset_sql($nestsql, $params);
3531     $nestarray = array();
3532     foreach ($nestrecords as $data) {
3533         $nestarray[] = $data->recordid;
3534     }
3535     // Close the record set and free up resources.
3536     $nestrecords->close();
3537     return $nestarray;
3540 /**
3541  * Returns an array with an sql string for advanced searches and the parameters that go with them.
3542  *
3543  * @param int $sort            DATA_*
3544  * @param stdClass $data       Data module object
3545  * @param array $recordids     An array of record IDs.
3546  * @param string $selectdata   Information for the where and select part of the sql statement.
3547  * @param string $sortorder    Additional sort parameters
3548  * @return array sqlselect     sqlselect['sql'] has the sql string, sqlselect['params'] contains an array of parameters.
3549  */
3550 function data_get_advanced_search_sql($sort, $data, $recordids, $selectdata, $sortorder) {
3551     global $DB;
3552     if ($sort == 0) {
3553         $nestselectsql = 'SELECT r.id, r.approved, r.timecreated, r.timemodified, r.userid, u.firstname, u.lastname
3554                         FROM {data_content} c,
3555                              {data_records} r,
3556                              {user} u ';
3557         $groupsql = ' GROUP BY r.id, r.approved, r.timecreated, r.timemodified, r.userid, u.firstname, u.lastname ';
3558     } else {
3559         // Sorting through 'Other' criteria
3560         if ($sort <= 0) {
3561             switch ($sort) {
3562                 case DATA_LASTNAME:
3563                     $sortcontentfull = "u.lastname";
3564                     break;
3565                 case DATA_FIRSTNAME:
3566                     $sortcontentfull = "u.firstname";
3567                     break;
3568                 case DATA_APPROVED:
3569                     $sortcontentfull = "r.approved";
3570                     break;
3571                 case DATA_TIMEMODIFIED:
3572                     $sortcontentfull = "r.timemodified";
3573                     break;
3574                 case DATA_TIMEADDED:
3575                 default:
3576                     $sortcontentfull = "r.timecreated";
3577             }
3578         } else {
3579             $sortfield = data_get_field_from_id($sort, $data);
3580             $sortcontent = $DB->sql_compare_text('c.' . $sortfield->get_sort_field());
3581             $sortcontentfull = $sortfield->get_sort_sql($sortcontent);
3582         }
3584         $nestselectsql = 'SELECT r.id, r.approved, r.timecreated, r.timemodified, r.userid, u.firstname, u.lastname, ' . $sortcontentfull . '
3585                               AS sortorder
3586                             FROM {data_content} c,
3587                                  {data_records} r,
3588                                  {user} u ';
3589         $groupsql = ' GROUP BY r.id, r.approved, r.timecreated, r.timemodified, r.userid, u.firstname, u.lastname, ' .$sortcontentfull;
3590     }
3592     // Default to a standard Where statement if $selectdata is empty.
3593     if ($selectdata == '') {
3594         $selectdata = 'WHERE c.recordid = r.id
3595                          AND r.dataid = :dataid
3596                          AND r.userid = u.id ';
3597     }
3599     // Find the field we are sorting on
3600     if ($sort > 0 or data_get_field_from_id($sort, $data)) {
3601         $selectdata .= ' AND c.fieldid = :sort';
3602     }
3604     // If there are no record IDs then return an sql statment that will return no rows.
3605     if (count($recordids) != 0) {
3606         list($insql, $inparam) = $DB->get_in_or_equal($recordids, SQL_PARAMS_NAMED);
3607     } else {
3608         list($insql, $inparam) = $DB->get_in_or_equal(array('-1'), SQL_PARAMS_NAMED);
3609     }
3610     $nestfromsql = $selectdata . ' AND c.recordid ' . $insql . $groupsql;
3611     $sqlselect['sql'] = "$nestselectsql $nestfromsql $sortorder";
3612     $sqlselect['params'] = $inparam;
3613     return $sqlselect;
3616 /**
3617  * Checks to see if the user has permission to delete the preset.
3618  * @param stdClass $context  Context object.
3619  * @param stdClass $preset  The preset object that we are checking for deletion.
3620  * @return bool  Returns true if the user can delete, otherwise false.
3621  */
3622 function data_user_can_delete_preset($context, $preset) {
3623     global $USER;
3625     if (has_capability('mod/data:manageuserpresets', $context)) {
3626         return true;
3627     } else {
3628         $candelete = false;
3629         if ($preset->userid == $USER->id) {
3630             $candelete = true;
3631         }
3632         return $candelete;
3633     }