MDL-51259 mod_data: ratings of items not activated.
[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 = '';
140         $this->field->required = false;
142         return true;
143     }
145     /**
146      * Set up the field object according to data in an object.  Now is the time to clean it!
147      *
148      * @return bool
149      */
150     function define_field($data) {
151         $this->field->type        = $this->type;
152         $this->field->dataid      = $this->data->id;
154         $this->field->name        = trim($data->name);
155         $this->field->description = trim($data->description);
156         $this->field->required    = !empty($data->required) ? 1 : 0;
158         if (isset($data->param1)) {
159             $this->field->param1 = trim($data->param1);
160         }
161         if (isset($data->param2)) {
162             $this->field->param2 = trim($data->param2);
163         }
164         if (isset($data->param3)) {
165             $this->field->param3 = trim($data->param3);
166         }
167         if (isset($data->param4)) {
168             $this->field->param4 = trim($data->param4);
169         }
170         if (isset($data->param5)) {
171             $this->field->param5 = trim($data->param5);
172         }
174         return true;
175     }
177     /**
178      * Insert a new field in the database
179      * We assume the field object is already defined as $this->field
180      *
181      * @global object
182      * @return bool
183      */
184     function insert_field() {
185         global $DB, $OUTPUT;
187         if (empty($this->field)) {
188             echo $OUTPUT->notification('Programmer error: Field has not been defined yet!  See define_field()');
189             return false;
190         }
192         $this->field->id = $DB->insert_record('data_fields',$this->field);
194         // Trigger an event for creating this field.
195         $event = \mod_data\event\field_created::create(array(
196             'objectid' => $this->field->id,
197             'context' => $this->context,
198             'other' => array(
199                 'fieldname' => $this->field->name,
200                 'dataid' => $this->data->id
201             )
202         ));
203         $event->trigger();
205         return true;
206     }
209     /**
210      * Update a field in the database
211      *
212      * @global object
213      * @return bool
214      */
215     function update_field() {
216         global $DB;
218         $DB->update_record('data_fields', $this->field);
220         // Trigger an event for updating this field.
221         $event = \mod_data\event\field_updated::create(array(
222             'objectid' => $this->field->id,
223             'context' => $this->context,
224             'other' => array(
225                 'fieldname' => $this->field->name,
226                 'dataid' => $this->data->id
227             )
228         ));
229         $event->trigger();
231         return true;
232     }
234     /**
235      * Delete a field completely
236      *
237      * @global object
238      * @return bool
239      */
240     function delete_field() {
241         global $DB;
243         if (!empty($this->field->id)) {
244             // Get the field before we delete it.
245             $field = $DB->get_record('data_fields', array('id' => $this->field->id));
247             $this->delete_content();
248             $DB->delete_records('data_fields', array('id'=>$this->field->id));
250             // Trigger an event for deleting this field.
251             $event = \mod_data\event\field_deleted::create(array(
252                 'objectid' => $this->field->id,
253                 'context' => $this->context,
254                 'other' => array(
255                     'fieldname' => $this->field->name,
256                     'dataid' => $this->data->id
257                  )
258             ));
259             $event->add_record_snapshot('data_fields', $field);
260             $event->trigger();
261         }
263         return true;
264     }
266     /**
267      * Print the relevant form element in the ADD template for this field
268      *
269      * @global object
270      * @param int $recordid
271      * @return string
272      */
273     function display_add_field($recordid=0, $formdata=null) {
274         global $DB, $OUTPUT;
276         if ($formdata) {
277             $fieldname = 'field_' . $this->field->id;
278             $content = $formdata->$fieldname;
279         } else if ($recordid) {
280             $content = $DB->get_field('data_content', 'content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid));
281         } else {
282             $content = '';
283         }
285         // beware get_field returns false for new, empty records MDL-18567
286         if ($content===false) {
287             $content='';
288         }
290         $str = '<div title="' . s($this->field->description) . '">';
291         $str .= '<label for="field_'.$this->field->id.'"><span class="accesshide">'.$this->field->name.'</span>';
292         if ($this->field->required) {
293             $image = html_writer::img($OUTPUT->pix_url('req'), get_string('requiredelement', 'form'),
294                                      array('class' => 'req', 'title' => get_string('requiredelement', 'form')));
295             $str .= html_writer::div($image, 'inline-req');
296         }
297         $str .= '</label><input class="basefieldinput mod-data-input" type="text" name="field_'.$this->field->id.'"';
298         $str .= ' id="field_' . $this->field->id . '" value="'.s($content).'" />';
299         $str .= '</div>';
301         return $str;
302     }
304     /**
305      * Print the relevant form element to define the attributes for this field
306      * viewable by teachers only.
307      *
308      * @global object
309      * @global object
310      * @return void Output is echo'd
311      */
312     function display_edit_field() {
313         global $CFG, $DB, $OUTPUT;
315         if (empty($this->field)) {   // No field has been defined yet, try and make one
316             $this->define_default_field();
317         }
318         echo $OUTPUT->box_start('generalbox boxaligncenter boxwidthwide');
320         echo '<form id="editfield" action="'.$CFG->wwwroot.'/mod/data/field.php" method="post">'."\n";
321         echo '<input type="hidden" name="d" value="'.$this->data->id.'" />'."\n";
322         if (empty($this->field->id)) {
323             echo '<input type="hidden" name="mode" value="add" />'."\n";
324             $savebutton = get_string('add');
325         } else {
326             echo '<input type="hidden" name="fid" value="'.$this->field->id.'" />'."\n";
327             echo '<input type="hidden" name="mode" value="update" />'."\n";
328             $savebutton = get_string('savechanges');
329         }
330         echo '<input type="hidden" name="type" value="'.$this->type.'" />'."\n";
331         echo '<input name="sesskey" value="'.sesskey().'" type="hidden" />'."\n";
333         echo $OUTPUT->heading($this->name(), 3);
335         require_once($CFG->dirroot.'/mod/data/field/'.$this->type.'/mod.html');
337         echo '<div class="mdl-align">';
338         echo '<input type="submit" value="'.$savebutton.'" />'."\n";
339         echo '<input type="submit" name="cancel" value="'.get_string('cancel').'" />'."\n";
340         echo '</div>';
342         echo '</form>';
344         echo $OUTPUT->box_end();
345     }
347     /**
348      * Display the content of the field in browse mode
349      *
350      * @global object
351      * @param int $recordid
352      * @param object $template
353      * @return bool|string
354      */
355     function display_browse_field($recordid, $template) {
356         global $DB;
358         if ($content = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
359             if (isset($content->content)) {
360                 $options = new stdClass();
361                 if ($this->field->param1 == '1') {  // We are autolinking this field, so disable linking within us
362                     //$content->content = '<span class="nolink">'.$content->content.'</span>';
363                     //$content->content1 = FORMAT_HTML;
364                     $options->filter=false;
365                 }
366                 $options->para = false;
367                 $str = format_text($content->content, $content->content1, $options);
368             } else {
369                 $str = '';
370             }
371             return $str;
372         }
373         return false;
374     }
376     /**
377      * Update the content of one data field in the data_content table
378      * @global object
379      * @param int $recordid
380      * @param mixed $value
381      * @param string $name
382      * @return bool
383      */
384     function update_content($recordid, $value, $name=''){
385         global $DB;
387         $content = new stdClass();
388         $content->fieldid = $this->field->id;
389         $content->recordid = $recordid;
390         $content->content = clean_param($value, PARAM_NOTAGS);
392         if ($oldcontent = $DB->get_record('data_content', array('fieldid'=>$this->field->id, 'recordid'=>$recordid))) {
393             $content->id = $oldcontent->id;
394             return $DB->update_record('data_content', $content);
395         } else {
396             return $DB->insert_record('data_content', $content);
397         }
398     }
400     /**
401      * Delete all content associated with the field
402      *
403      * @global object
404      * @param int $recordid
405      * @return bool
406      */
407     function delete_content($recordid=0) {
408         global $DB;
410         if ($recordid) {
411             $conditions = array('fieldid'=>$this->field->id, 'recordid'=>$recordid);
412         } else {
413             $conditions = array('fieldid'=>$this->field->id);
414         }
416         $rs = $DB->get_recordset('data_content', $conditions);
417         if ($rs->valid()) {
418             $fs = get_file_storage();
419             foreach ($rs as $content) {
420                 $fs->delete_area_files($this->context->id, 'mod_data', 'content', $content->id);
421             }
422         }
423         $rs->close();
425         return $DB->delete_records('data_content', $conditions);
426     }
428     /**
429      * Check if a field from an add form is empty
430      *
431      * @param mixed $value
432      * @param mixed $name
433      * @return bool
434      */
435     function notemptyfield($value, $name) {
436         return !empty($value);
437     }
439     /**
440      * Just in case a field needs to print something before the whole form
441      */
442     function print_before_form() {
443     }
445     /**
446      * Just in case a field needs to print something after the whole form
447      */
448     function print_after_form() {
449     }
452     /**
453      * Returns the sortable field for the content. By default, it's just content
454      * but for some plugins, it could be content 1 - content4
455      *
456      * @return string
457      */
458     function get_sort_field() {
459         return 'content';
460     }
462     /**
463      * Returns the SQL needed to refer to the column.  Some fields may need to CAST() etc.
464      *
465      * @param string $fieldname
466      * @return string $fieldname
467      */
468     function get_sort_sql($fieldname) {
469         return $fieldname;
470     }
472     /**
473      * Returns the name/type of the field
474      *
475      * @return string
476      */
477     function name() {
478         return get_string('name'.$this->type, 'data');
479     }
481     /**
482      * Prints the respective type icon
483      *
484      * @global object
485      * @return string
486      */
487     function image() {
488         global $OUTPUT;
490         $params = array('d'=>$this->data->id, 'fid'=>$this->field->id, 'mode'=>'display', 'sesskey'=>sesskey());
491         $link = new moodle_url('/mod/data/field.php', $params);
492         $str = '<a href="'.$link->out().'">';
493         $str .= '<img src="'.$OUTPUT->pix_url('field/'.$this->type, 'data') . '" ';
494         $str .= 'height="'.$this->iconheight.'" width="'.$this->iconwidth.'" alt="'.$this->type.'" title="'.$this->type.'" /></a>';
495         return $str;
496     }
498     /**
499      * Per default, it is assumed that fields support text exporting.
500      * Override this (return false) on fields not supporting text exporting.
501      *
502      * @return bool true
503      */
504     function text_export_supported() {
505         return true;
506     }
508     /**
509      * Per default, return the record's text value only from the "content" field.
510      * Override this in fields class if necesarry.
511      *
512      * @param string $record
513      * @return string
514      */
515     function export_text_value($record) {
516         if ($this->text_export_supported()) {
517             return $record->content;
518         }
519     }
521     /**
522      * @param string $relativepath
523      * @return bool false
524      */
525     function file_ok($relativepath) {
526         return false;
527     }
531 /**
532  * Given a template and a dataid, generate a default case template
533  *
534  * @global object
535  * @param object $data
536  * @param string template [addtemplate, singletemplate, listtempalte, rsstemplate]
537  * @param int $recordid
538  * @param bool $form
539  * @param bool $update
540  * @return bool|string
541  */
542 function data_generate_default_template(&$data, $template, $recordid=0, $form=false, $update=true) {
543     global $DB;
545     if (!$data && !$template) {
546         return false;
547     }
548     if ($template == 'csstemplate' or $template == 'jstemplate' ) {
549         return '';
550     }
552     // get all the fields for that database
553     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'id')) {
555         $table = new html_table();
556         $table->attributes['class'] = 'mod-data-default-template ##approvalstatus##';
557         $table->colclasses = array('template-field', 'template-token');
558         $table->data = array();
559         foreach ($fields as $field) {
560             if ($form) {   // Print forms instead of data
561                 $fieldobj = data_get_field($field, $data);
562                 $token = $fieldobj->display_add_field($recordid, null);
563             } else {           // Just print the tag
564                 $token = '[['.$field->name.']]';
565             }
566             $table->data[] = array(
567                 $field->name.': ',
568                 $token
569             );
570         }
571         if ($template == 'listtemplate') {
572             $cell = new html_table_cell('##edit##  ##more##  ##delete##  ##approve##  ##disapprove##  ##export##');
573             $cell->colspan = 2;
574             $cell->attributes['class'] = 'controls';
575             $table->data[] = new html_table_row(array($cell));
576         } else if ($template == 'singletemplate') {
577             $cell = new html_table_cell('##edit##  ##delete##  ##approve##  ##disapprove##  ##export##');
578             $cell->colspan = 2;
579             $cell->attributes['class'] = 'controls';
580             $table->data[] = new html_table_row(array($cell));
581         } else if ($template == 'asearchtemplate') {
582             $row = new html_table_row(array(get_string('authorfirstname', 'data').': ', '##firstname##'));
583             $row->attributes['class'] = 'searchcontrols';
584             $table->data[] = $row;
585             $row = new html_table_row(array(get_string('authorlastname', 'data').': ', '##lastname##'));
586             $row->attributes['class'] = 'searchcontrols';
587             $table->data[] = $row;
588         }
590         $str = '';
591         if ($template == 'listtemplate'){
592             $str .= '##delcheck##';
593             $str .= html_writer::empty_tag('br');
594         }
596         $str .= html_writer::start_tag('div', array('class' => 'defaulttemplate'));
597         $str .= html_writer::table($table);
598         $str .= html_writer::end_tag('div');
599         if ($template == 'listtemplate'){
600             $str .= html_writer::empty_tag('hr');
601         }
603         if ($update) {
604             $newdata = new stdClass();
605             $newdata->id = $data->id;
606             $newdata->{$template} = $str;
607             $DB->update_record('data', $newdata);
608             $data->{$template} = $str;
609         }
611         return $str;
612     }
616 /**
617  * Search for a field name and replaces it with another one in all the
618  * form templates. Set $newfieldname as '' if you want to delete the
619  * field from the form.
620  *
621  * @global object
622  * @param object $data
623  * @param string $searchfieldname
624  * @param string $newfieldname
625  * @return bool
626  */
627 function data_replace_field_in_templates($data, $searchfieldname, $newfieldname) {
628     global $DB;
630     if (!empty($newfieldname)) {
631         $prestring = '[[';
632         $poststring = ']]';
633         $idpart = '#id';
635     } else {
636         $prestring = '';
637         $poststring = '';
638         $idpart = '';
639     }
641     $newdata = new stdClass();
642     $newdata->id = $data->id;
643     $newdata->singletemplate = str_ireplace('[['.$searchfieldname.']]',
644             $prestring.$newfieldname.$poststring, $data->singletemplate);
646     $newdata->listtemplate = str_ireplace('[['.$searchfieldname.']]',
647             $prestring.$newfieldname.$poststring, $data->listtemplate);
649     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.']]',
650             $prestring.$newfieldname.$poststring, $data->addtemplate);
652     $newdata->addtemplate = str_ireplace('[['.$searchfieldname.'#id]]',
653             $prestring.$newfieldname.$idpart.$poststring, $data->addtemplate);
655     $newdata->rsstemplate = str_ireplace('[['.$searchfieldname.']]',
656             $prestring.$newfieldname.$poststring, $data->rsstemplate);
658     return $DB->update_record('data', $newdata);
662 /**
663  * Appends a new field at the end of the form template.
664  *
665  * @global object
666  * @param object $data
667  * @param string $newfieldname
668  */
669 function data_append_new_field_to_templates($data, $newfieldname) {
670     global $DB;
672     $newdata = new stdClass();
673     $newdata->id = $data->id;
674     $change = false;
676     if (!empty($data->singletemplate)) {
677         $newdata->singletemplate = $data->singletemplate.' [[' . $newfieldname .']]';
678         $change = true;
679     }
680     if (!empty($data->addtemplate)) {
681         $newdata->addtemplate = $data->addtemplate.' [[' . $newfieldname . ']]';
682         $change = true;
683     }
684     if (!empty($data->rsstemplate)) {
685         $newdata->rsstemplate = $data->singletemplate.' [[' . $newfieldname . ']]';
686         $change = true;
687     }
688     if ($change) {
689         $DB->update_record('data', $newdata);
690     }
694 /**
695  * given a field name
696  * this function creates an instance of the particular subfield class
697  *
698  * @global object
699  * @param string $name
700  * @param object $data
701  * @return object|bool
702  */
703 function data_get_field_from_name($name, $data){
704     global $DB;
706     $field = $DB->get_record('data_fields', array('name'=>$name, 'dataid'=>$data->id));
708     if ($field) {
709         return data_get_field($field, $data);
710     } else {
711         return false;
712     }
715 /**
716  * given a field id
717  * this function creates an instance of the particular subfield class
718  *
719  * @global object
720  * @param int $fieldid
721  * @param object $data
722  * @return bool|object
723  */
724 function data_get_field_from_id($fieldid, $data){
725     global $DB;
727     $field = $DB->get_record('data_fields', array('id'=>$fieldid, 'dataid'=>$data->id));
729     if ($field) {
730         return data_get_field($field, $data);
731     } else {
732         return false;
733     }
736 /**
737  * given a field id
738  * this function creates an instance of the particular subfield class
739  *
740  * @global object
741  * @param string $type
742  * @param object $data
743  * @return object
744  */
745 function data_get_field_new($type, $data) {
746     global $CFG;
748     require_once($CFG->dirroot.'/mod/data/field/'.$type.'/field.class.php');
749     $newfield = 'data_field_'.$type;
750     $newfield = new $newfield(0, $data);
751     return $newfield;
754 /**
755  * returns a subclass field object given a record of the field, used to
756  * invoke plugin methods
757  * input: $param $field - record from db
758  *
759  * @global object
760  * @param object $field
761  * @param object $data
762  * @param object $cm
763  * @return object
764  */
765 function data_get_field($field, $data, $cm=null) {
766     global $CFG;
768     if ($field) {
769         require_once('field/'.$field->type.'/field.class.php');
770         $newfield = 'data_field_'.$field->type;
771         $newfield = new $newfield($field, $data, $cm);
772         return $newfield;
773     }
777 /**
778  * Given record object (or id), returns true if the record belongs to the current user
779  *
780  * @global object
781  * @global object
782  * @param mixed $record record object or id
783  * @return bool
784  */
785 function data_isowner($record) {
786     global $USER, $DB;
788     if (!isloggedin()) { // perf shortcut
789         return false;
790     }
792     if (!is_object($record)) {
793         if (!$record = $DB->get_record('data_records', array('id'=>$record))) {
794             return false;
795         }
796     }
798     return ($record->userid == $USER->id);
801 /**
802  * has a user reached the max number of entries?
803  *
804  * @param object $data
805  * @return bool
806  */
807 function data_atmaxentries($data){
808     if (!$data->maxentries){
809         return false;
811     } else {
812         return (data_numentries($data) >= $data->maxentries);
813     }
816 /**
817  * returns the number of entries already made by this user
818  *
819  * @global object
820  * @global object
821  * @param object $data
822  * @return int
823  */
824 function data_numentries($data){
825     global $USER, $DB;
826     $sql = 'SELECT COUNT(*) FROM {data_records} WHERE dataid=? AND userid=?';
827     return $DB->count_records_sql($sql, array($data->id, $USER->id));
830 /**
831  * function that takes in a dataid and adds a record
832  * this is used everytime an add template is submitted
833  *
834  * @global object
835  * @global object
836  * @param object $data
837  * @param int $groupid
838  * @return bool
839  */
840 function data_add_record($data, $groupid=0){
841     global $USER, $DB;
843     $cm = get_coursemodule_from_instance('data', $data->id);
844     $context = context_module::instance($cm->id);
846     $record = new stdClass();
847     $record->userid = $USER->id;
848     $record->dataid = $data->id;
849     $record->groupid = $groupid;
850     $record->timecreated = $record->timemodified = time();
851     if (has_capability('mod/data:approve', $context)) {
852         $record->approved = 1;
853     } else {
854         $record->approved = 0;
855     }
856     $record->id = $DB->insert_record('data_records', $record);
858     // Trigger an event for creating this record.
859     $event = \mod_data\event\record_created::create(array(
860         'objectid' => $record->id,
861         'context' => $context,
862         'other' => array(
863             'dataid' => $data->id
864         )
865     ));
866     $event->trigger();
868     return $record->id;
871 /**
872  * check the multple existence any tag in a template
873  *
874  * check to see if there are 2 or more of the same tag being used.
875  *
876  * @global object
877  * @param int $dataid,
878  * @param string $template
879  * @return bool
880  */
881 function data_tags_check($dataid, $template) {
882     global $DB, $OUTPUT;
884     // first get all the possible tags
885     $fields = $DB->get_records('data_fields', array('dataid'=>$dataid));
886     // then we generate strings to replace
887     $tagsok = true; // let's be optimistic
888     foreach ($fields as $field){
889         $pattern="/\[\[" . preg_quote($field->name, '/') . "\]\]/i";
890         if (preg_match_all($pattern, $template, $dummy)>1){
891             $tagsok = false;
892             echo $OUTPUT->notification('[['.$field->name.']] - '.get_string('multipletags','data'));
893         }
894     }
895     // else return true
896     return $tagsok;
899 /**
900  * Adds an instance of a data
901  *
902  * @param stdClass $data
903  * @param mod_data_mod_form $mform
904  * @return int intance id
905  */
906 function data_add_instance($data, $mform = null) {
907     global $DB;
909     if (empty($data->assessed)) {
910         $data->assessed = 0;
911     }
913     if (empty($data->ratingtime) || empty($data->assessed)) {
914         $data->assesstimestart  = 0;
915         $data->assesstimefinish = 0;
916     }
918     $data->timemodified = time();
920     $data->id = $DB->insert_record('data', $data);
922     data_grade_item_update($data);
924     return $data->id;
927 /**
928  * updates an instance of a data
929  *
930  * @global object
931  * @param object $data
932  * @return bool
933  */
934 function data_update_instance($data) {
935     global $DB, $OUTPUT;
937     $data->timemodified = time();
938     $data->id           = $data->instance;
940     if (empty($data->assessed)) {
941         $data->assessed = 0;
942     }
944     if (empty($data->ratingtime) or empty($data->assessed)) {
945         $data->assesstimestart  = 0;
946         $data->assesstimefinish = 0;
947     }
949     if (empty($data->notification)) {
950         $data->notification = 0;
951     }
953     $DB->update_record('data', $data);
955     data_grade_item_update($data);
957     return true;
961 /**
962  * deletes an instance of a data
963  *
964  * @global object
965  * @param int $id
966  * @return bool
967  */
968 function data_delete_instance($id) {    // takes the dataid
969     global $DB, $CFG;
971     if (!$data = $DB->get_record('data', array('id'=>$id))) {
972         return false;
973     }
975     $cm = get_coursemodule_from_instance('data', $data->id);
976     $context = context_module::instance($cm->id);
978 /// Delete all the associated information
980     // files
981     $fs = get_file_storage();
982     $fs->delete_area_files($context->id, 'mod_data');
984     // get all the records in this data
985     $sql = "SELECT r.id
986               FROM {data_records} r
987              WHERE r.dataid = ?";
989     $DB->delete_records_select('data_content', "recordid IN ($sql)", array($id));
991     // delete all the records and fields
992     $DB->delete_records('data_records', array('dataid'=>$id));
993     $DB->delete_records('data_fields', array('dataid'=>$id));
995     // Delete the instance itself
996     $result = $DB->delete_records('data', array('id'=>$id));
998     // cleanup gradebook
999     data_grade_item_delete($data);
1001     return $result;
1004 /**
1005  * returns a summary of data activity of this user
1006  *
1007  * @global object
1008  * @param object $course
1009  * @param object $user
1010  * @param object $mod
1011  * @param object $data
1012  * @return object|null
1013  */
1014 function data_user_outline($course, $user, $mod, $data) {
1015     global $DB, $CFG;
1016     require_once("$CFG->libdir/gradelib.php");
1018     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1019     if (empty($grades->items[0]->grades)) {
1020         $grade = false;
1021     } else {
1022         $grade = reset($grades->items[0]->grades);
1023     }
1026     if ($countrecords = $DB->count_records('data_records', array('dataid'=>$data->id, 'userid'=>$user->id))) {
1027         $result = new stdClass();
1028         $result->info = get_string('numrecords', 'data', $countrecords);
1029         $lastrecord   = $DB->get_record_sql('SELECT id,timemodified FROM {data_records}
1030                                               WHERE dataid = ? AND userid = ?
1031                                            ORDER BY timemodified DESC', array($data->id, $user->id), true);
1032         $result->time = $lastrecord->timemodified;
1033         if ($grade) {
1034             $result->info .= ', ' . get_string('grade') . ': ' . $grade->str_long_grade;
1035         }
1036         return $result;
1037     } else if ($grade) {
1038         $result = new stdClass();
1039         $result->info = get_string('grade') . ': ' . $grade->str_long_grade;
1041         //datesubmitted == time created. dategraded == time modified or time overridden
1042         //if grade was last modified by the user themselves use date graded. Otherwise use date submitted
1043         //TODO: move this copied & pasted code somewhere in the grades API. See MDL-26704
1044         if ($grade->usermodified == $user->id || empty($grade->datesubmitted)) {
1045             $result->time = $grade->dategraded;
1046         } else {
1047             $result->time = $grade->datesubmitted;
1048         }
1050         return $result;
1051     }
1052     return NULL;
1055 /**
1056  * Prints all the records uploaded by this user
1057  *
1058  * @global object
1059  * @param object $course
1060  * @param object $user
1061  * @param object $mod
1062  * @param object $data
1063  */
1064 function data_user_complete($course, $user, $mod, $data) {
1065     global $DB, $CFG, $OUTPUT;
1066     require_once("$CFG->libdir/gradelib.php");
1068     $grades = grade_get_grades($course->id, 'mod', 'data', $data->id, $user->id);
1069     if (!empty($grades->items[0]->grades)) {
1070         $grade = reset($grades->items[0]->grades);
1071         echo $OUTPUT->container(get_string('grade').': '.$grade->str_long_grade);
1072         if ($grade->str_feedback) {
1073             echo $OUTPUT->container(get_string('feedback').': '.$grade->str_feedback);
1074         }
1075     }
1077     if ($records = $DB->get_records('data_records', array('dataid'=>$data->id,'userid'=>$user->id), 'timemodified DESC')) {
1078         data_print_template('singletemplate', $records, $data);
1079     }
1082 /**
1083  * Return grade for given user or all users.
1084  *
1085  * @global object
1086  * @param object $data
1087  * @param int $userid optional user id, 0 means all users
1088  * @return array array of grades, false if none
1089  */
1090 function data_get_user_grades($data, $userid=0) {
1091     global $CFG;
1093     require_once($CFG->dirroot.'/rating/lib.php');
1095     $ratingoptions = new stdClass;
1096     $ratingoptions->component = 'mod_data';
1097     $ratingoptions->ratingarea = 'entry';
1098     $ratingoptions->modulename = 'data';
1099     $ratingoptions->moduleid   = $data->id;
1101     $ratingoptions->userid = $userid;
1102     $ratingoptions->aggregationmethod = $data->assessed;
1103     $ratingoptions->scaleid = $data->scale;
1104     $ratingoptions->itemtable = 'data_records';
1105     $ratingoptions->itemtableusercolumn = 'userid';
1107     $rm = new rating_manager();
1108     return $rm->get_user_grades($ratingoptions);
1111 /**
1112  * Update activity grades
1113  *
1114  * @category grade
1115  * @param object $data
1116  * @param int $userid specific user only, 0 means all
1117  * @param bool $nullifnone
1118  */
1119 function data_update_grades($data, $userid=0, $nullifnone=true) {
1120     global $CFG, $DB;
1121     require_once($CFG->libdir.'/gradelib.php');
1123     if (!$data->assessed) {
1124         data_grade_item_update($data);
1126     } else if ($grades = data_get_user_grades($data, $userid)) {
1127         data_grade_item_update($data, $grades);
1129     } else if ($userid and $nullifnone) {
1130         $grade = new stdClass();
1131         $grade->userid   = $userid;
1132         $grade->rawgrade = NULL;
1133         data_grade_item_update($data, $grade);
1135     } else {
1136         data_grade_item_update($data);
1137     }
1140 /**
1141  * Update/create grade item for given data
1142  *
1143  * @category grade
1144  * @param stdClass $data A database instance with extra cmidnumber property
1145  * @param mixed $grades Optional array/object of grade(s); 'reset' means reset grades in gradebook
1146  * @return object grade_item
1147  */
1148 function data_grade_item_update($data, $grades=NULL) {
1149     global $CFG;
1150     require_once($CFG->libdir.'/gradelib.php');
1152     $params = array('itemname'=>$data->name, 'idnumber'=>$data->cmidnumber);
1154     if (!$data->assessed or $data->scale == 0) {
1155         $params['gradetype'] = GRADE_TYPE_NONE;
1157     } else if ($data->scale > 0) {
1158         $params['gradetype'] = GRADE_TYPE_VALUE;
1159         $params['grademax']  = $data->scale;
1160         $params['grademin']  = 0;
1162     } else if ($data->scale < 0) {
1163         $params['gradetype'] = GRADE_TYPE_SCALE;
1164         $params['scaleid']   = -$data->scale;
1165     }
1167     if ($grades  === 'reset') {
1168         $params['reset'] = true;
1169         $grades = NULL;
1170     }
1172     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, $grades, $params);
1175 /**
1176  * Delete grade item for given data
1177  *
1178  * @category grade
1179  * @param object $data object
1180  * @return object grade_item
1181  */
1182 function data_grade_item_delete($data) {
1183     global $CFG;
1184     require_once($CFG->libdir.'/gradelib.php');
1186     return grade_update('mod/data', $data->course, 'mod', 'data', $data->id, 0, NULL, array('deleted'=>1));
1189 // junk functions
1190 /**
1191  * takes a list of records, the current data, a search string,
1192  * and mode to display prints the translated template
1193  *
1194  * @global object
1195  * @global object
1196  * @param string $template
1197  * @param array $records
1198  * @param object $data
1199  * @param string $search
1200  * @param int $page
1201  * @param bool $return
1202  * @param object $jumpurl a moodle_url by which to jump back to the record list (can be null)
1203  * @return mixed
1204  */
1205 function data_print_template($template, $records, $data, $search='', $page=0, $return=false, moodle_url $jumpurl=null) {
1206     global $CFG, $DB, $OUTPUT;
1208     $cm = get_coursemodule_from_instance('data', $data->id);
1209     $context = context_module::instance($cm->id);
1211     static $fields = NULL;
1212     static $isteacher;
1213     static $dataid = NULL;
1215     if (empty($dataid)) {
1216         $dataid = $data->id;
1217     } else if ($dataid != $data->id) {
1218         $fields = NULL;
1219     }
1221     if (empty($fields)) {
1222         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1223         foreach ($fieldrecords as $fieldrecord) {
1224             $fields[]= data_get_field($fieldrecord, $data);
1225         }
1226         $isteacher = has_capability('mod/data:managetemplates', $context);
1227     }
1229     if (empty($records)) {
1230         return;
1231     }
1233     if (!$jumpurl) {
1234         $jumpurl = new moodle_url('/mod/data/view.php', array('d' => $data->id));
1235     }
1236     $jumpurl = new moodle_url($jumpurl, array('page' => $page, 'sesskey' => sesskey()));
1238     // Check whether this activity is read-only at present
1239     $readonly = data_in_readonly_period($data);
1241     foreach ($records as $record) {   // Might be just one for the single template
1243     // Replacing tags
1244         $patterns = array();
1245         $replacement = array();
1247     // Then we generate strings to replace for normal tags
1248         foreach ($fields as $field) {
1249             $patterns[]='[['.$field->field->name.']]';
1250             $replacement[] = highlight($search, $field->display_browse_field($record->id, $template));
1251         }
1253         $canmanageentries = has_capability('mod/data:manageentries', $context);
1255     // Replacing special tags (##Edit##, ##Delete##, ##More##)
1256         $patterns[]='##edit##';
1257         $patterns[]='##delete##';
1258         if ($canmanageentries || (!$readonly && data_isowner($record->id))) {
1259             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/edit.php?d='
1260                              .$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>';
1261             $replacement[] = '<a href="'.$CFG->wwwroot.'/mod/data/view.php?d='
1262                              .$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>';
1263         } else {
1264             $replacement[] = '';
1265             $replacement[] = '';
1266         }
1268         $moreurl = $CFG->wwwroot . '/mod/data/view.php?d=' . $data->id . '&amp;rid=' . $record->id;
1269         if ($search) {
1270             $moreurl .= '&amp;filter=1';
1271         }
1272         $patterns[]='##more##';
1273         $replacement[] = '<a href="'.$moreurl.'"><img src="'.$OUTPUT->pix_url('t/preview').
1274                         '" class="iconsmall" alt="'.get_string('more', 'data').'" title="'.get_string('more', 'data').
1275                         '" /></a>';
1277         $patterns[]='##moreurl##';
1278         $replacement[] = $moreurl;
1280         $patterns[]='##delcheck##';
1281         if ($canmanageentries) {
1282             $replacement[] = html_writer::checkbox('delcheck[]', $record->id, false, '', array('class' => 'recordcheckbox'));
1283         } else {
1284             $replacement[] = '';
1285         }
1287         $patterns[]='##user##';
1288         $replacement[] = '<a href="'.$CFG->wwwroot.'/user/view.php?id='.$record->userid.
1289                                '&amp;course='.$data->course.'">'.fullname($record).'</a>';
1291         $patterns[] = '##userpicture##';
1292         $ruser = user_picture::unalias($record, null, 'userid');
1293         $replacement[] = $OUTPUT->user_picture($ruser, array('courseid' => $data->course));
1295         $patterns[]='##export##';
1297         if (!empty($CFG->enableportfolios) && ($template == 'singletemplate' || $template == 'listtemplate')
1298             && ((has_capability('mod/data:exportentry', $context)
1299                 || (data_isowner($record->id) && has_capability('mod/data:exportownentry', $context))))) {
1300             require_once($CFG->libdir . '/portfoliolib.php');
1301             $button = new portfolio_add_button();
1302             $button->set_callback_options('data_portfolio_caller', array('id' => $cm->id, 'recordid' => $record->id), 'mod_data');
1303             list($formats, $files) = data_portfolio_caller::formats($fields, $record);
1304             $button->set_formats($formats);
1305             $replacement[] = $button->to_html(PORTFOLIO_ADD_ICON_LINK);
1306         } else {
1307             $replacement[] = '';
1308         }
1310         $patterns[] = '##timeadded##';
1311         $replacement[] = userdate($record->timecreated);
1313         $patterns[] = '##timemodified##';
1314         $replacement [] = userdate($record->timemodified);
1316         $patterns[]='##approve##';
1317         if (has_capability('mod/data:approve', $context) && ($data->approval) && (!$record->approved)) {
1318             $approveurl = new moodle_url($jumpurl, array('approve' => $record->id));
1319             $approveicon = new pix_icon('t/approve', get_string('approve', 'data'), '', array('class' => 'iconsmall'));
1320             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($approveurl, $approveicon),
1321                     array('class' => 'approve'));
1322         } else {
1323             $replacement[] = '';
1324         }
1326         $patterns[]='##disapprove##';
1327         if (has_capability('mod/data:approve', $context) && ($data->approval) && ($record->approved)) {
1328             $disapproveurl = new moodle_url($jumpurl, array('disapprove' => $record->id));
1329             $disapproveicon = new pix_icon('t/block', get_string('disapprove', 'data'), '', array('class' => 'iconsmall'));
1330             $replacement[] = html_writer::tag('span', $OUTPUT->action_icon($disapproveurl, $disapproveicon),
1331                     array('class' => 'disapprove'));
1332         } else {
1333             $replacement[] = '';
1334         }
1336         $patterns[] = '##approvalstatus##';
1337         if (!$data->approval) {
1338             $replacement[] = '';
1339         } else if ($record->approved) {
1340             $replacement[] = 'approved';
1341         } else {
1342             $replacement[] = 'notapproved';
1343         }
1345         $patterns[]='##comments##';
1346         if (($template == 'listtemplate') && ($data->comments)) {
1348             if (!empty($CFG->usecomments)) {
1349                 require_once($CFG->dirroot  . '/comment/lib.php');
1350                 list($context, $course, $cm) = get_context_info_array($context->id);
1351                 $cmt = new stdClass();
1352                 $cmt->context = $context;
1353                 $cmt->course  = $course;
1354                 $cmt->cm      = $cm;
1355                 $cmt->area    = 'database_entry';
1356                 $cmt->itemid  = $record->id;
1357                 $cmt->showcount = true;
1358                 $cmt->component = 'mod_data';
1359                 $comment = new comment($cmt);
1360                 $replacement[] = $comment->output(true);
1361             }
1362         } else {
1363             $replacement[] = '';
1364         }
1366         // actual replacement of the tags
1367         $newtext = str_ireplace($patterns, $replacement, $data->{$template});
1369         // no more html formatting and filtering - see MDL-6635
1370         if ($return) {
1371             return $newtext;
1372         } else {
1373             echo $newtext;
1375             // hack alert - return is always false in singletemplate anyway ;-)
1376             /**********************************
1377              *    Printing Ratings Form       *
1378              *********************************/
1379             if ($template == 'singletemplate') {    //prints ratings options
1380                 data_print_ratings($data, $record);
1381             }
1383             /**********************************
1384              *    Printing Comments Form       *
1385              *********************************/
1386             if (($template == 'singletemplate') && ($data->comments)) {
1387                 if (!empty($CFG->usecomments)) {
1388                     require_once($CFG->dirroot . '/comment/lib.php');
1389                     list($context, $course, $cm) = get_context_info_array($context->id);
1390                     $cmt = new stdClass();
1391                     $cmt->context = $context;
1392                     $cmt->course  = $course;
1393                     $cmt->cm      = $cm;
1394                     $cmt->area    = 'database_entry';
1395                     $cmt->itemid  = $record->id;
1396                     $cmt->showcount = true;
1397                     $cmt->component = 'mod_data';
1398                     $comment = new comment($cmt);
1399                     $comment->output(false);
1400                 }
1401             }
1402         }
1403     }
1406 /**
1407  * Return rating related permissions
1408  *
1409  * @param string $contextid the context id
1410  * @param string $component the component to get rating permissions for
1411  * @param string $ratingarea the rating area to get permissions for
1412  * @return array an associative array of the user's rating permissions
1413  */
1414 function data_rating_permissions($contextid, $component, $ratingarea) {
1415     $context = context::instance_by_id($contextid, MUST_EXIST);
1416     if ($component != 'mod_data' || $ratingarea != 'entry') {
1417         return null;
1418     }
1419     return array(
1420         'view'    => has_capability('mod/data:viewrating',$context),
1421         'viewany' => has_capability('mod/data:viewanyrating',$context),
1422         'viewall' => has_capability('mod/data:viewallratings',$context),
1423         'rate'    => has_capability('mod/data:rate',$context)
1424     );
1427 /**
1428  * Validates a submitted rating
1429  * @param array $params submitted data
1430  *            context => object the context in which the rated items exists [required]
1431  *            itemid => int the ID of the object being rated
1432  *            scaleid => int the scale from which the user can select a rating. Used for bounds checking. [required]
1433  *            rating => int the submitted rating
1434  *            rateduserid => int the id of the user whose items have been rated. NOT the user who submitted the ratings. 0 to update all. [required]
1435  *            aggregation => int the aggregation method to apply when calculating grades ie RATING_AGGREGATE_AVERAGE [required]
1436  * @return boolean true if the rating is valid. Will throw rating_exception if not
1437  */
1438 function data_rating_validate($params) {
1439     global $DB, $USER;
1441     // Check the component is mod_data
1442     if ($params['component'] != 'mod_data') {
1443         throw new rating_exception('invalidcomponent');
1444     }
1446     // Check the ratingarea is entry (the only rating area in data module)
1447     if ($params['ratingarea'] != 'entry') {
1448         throw new rating_exception('invalidratingarea');
1449     }
1451     // Check the rateduserid is not the current user .. you can't rate your own entries
1452     if ($params['rateduserid'] == $USER->id) {
1453         throw new rating_exception('nopermissiontorate');
1454     }
1456     $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
1457                   FROM {data_records} r
1458                   JOIN {data} d ON r.dataid = d.id
1459                  WHERE r.id = :itemid";
1460     $dataparams = array('itemid'=>$params['itemid']);
1461     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1462         //item doesn't exist
1463         throw new rating_exception('invaliditemid');
1464     }
1466     if ($info->scale != $params['scaleid']) {
1467         //the scale being submitted doesnt match the one in the database
1468         throw new rating_exception('invalidscaleid');
1469     }
1471     //check that the submitted rating is valid for the scale
1473     // lower limit
1474     if ($params['rating'] < 0  && $params['rating'] != RATING_UNSET_RATING) {
1475         throw new rating_exception('invalidnum');
1476     }
1478     // upper limit
1479     if ($info->scale < 0) {
1480         //its a custom scale
1481         $scalerecord = $DB->get_record('scale', array('id' => -$info->scale));
1482         if ($scalerecord) {
1483             $scalearray = explode(',', $scalerecord->scale);
1484             if ($params['rating'] > count($scalearray)) {
1485                 throw new rating_exception('invalidnum');
1486             }
1487         } else {
1488             throw new rating_exception('invalidscaleid');
1489         }
1490     } else if ($params['rating'] > $info->scale) {
1491         //if its numeric and submitted rating is above maximum
1492         throw new rating_exception('invalidnum');
1493     }
1495     if ($info->approval && !$info->approved) {
1496         //database requires approval but this item isnt approved
1497         throw new rating_exception('nopermissiontorate');
1498     }
1500     // check the item we're rating was created in the assessable time window
1501     if (!empty($info->assesstimestart) && !empty($info->assesstimefinish)) {
1502         if ($info->timecreated < $info->assesstimestart || $info->timecreated > $info->assesstimefinish) {
1503             throw new rating_exception('notavailable');
1504         }
1505     }
1507     $course = $DB->get_record('course', array('id'=>$info->course), '*', MUST_EXIST);
1508     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1509     $context = context_module::instance($cm->id);
1511     // if the supplied context doesnt match the item's context
1512     if ($context->id != $params['context']->id) {
1513         throw new rating_exception('invalidcontext');
1514     }
1516     // Make sure groups allow this user to see the item they're rating
1517     $groupid = $info->groupid;
1518     if ($groupid > 0 and $groupmode = groups_get_activity_groupmode($cm, $course)) {   // Groups are being used
1519         if (!groups_group_exists($groupid)) { // Can't find group
1520             throw new rating_exception('cannotfindgroup');//something is wrong
1521         }
1523         if (!groups_is_member($groupid) and !has_capability('moodle/site:accessallgroups', $context)) {
1524             // do not allow rating of posts from other groups when in SEPARATEGROUPS or VISIBLEGROUPS
1525             throw new rating_exception('notmemberofgroup');
1526         }
1527     }
1529     return true;
1532 /**
1533  * Can the current user see ratings for a given itemid?
1534  *
1535  * @param array $params submitted data
1536  *            contextid => int contextid [required]
1537  *            component => The component for this module - should always be mod_data [required]
1538  *            ratingarea => object the context in which the rated items exists [required]
1539  *            itemid => int the ID of the object being rated [required]
1540  *            scaleid => int scale id [optional]
1541  * @return bool
1542  * @throws coding_exception
1543  * @throws rating_exception
1544  */
1545 function mod_data_rating_can_see_item_ratings($params) {
1546     global $DB;
1548     // Check the component is mod_data.
1549     if (!isset($params['component']) || $params['component'] != 'mod_data') {
1550         throw new rating_exception('invalidcomponent');
1551     }
1553     // Check the ratingarea is entry (the only rating area in data).
1554     if (!isset($params['ratingarea']) || $params['ratingarea'] != 'entry') {
1555         throw new rating_exception('invalidratingarea');
1556     }
1558     if (!isset($params['itemid'])) {
1559         throw new rating_exception('invaliditemid');
1560     }
1562     $datasql = "SELECT d.id as dataid, d.course, r.groupid
1563                   FROM {data_records} r
1564                   JOIN {data} d ON r.dataid = d.id
1565                  WHERE r.id = :itemid";
1566     $dataparams = array('itemid' => $params['itemid']);
1567     if (!$info = $DB->get_record_sql($datasql, $dataparams)) {
1568         // Item doesn't exist.
1569         throw new rating_exception('invaliditemid');
1570     }
1572     $course = $DB->get_record('course', array('id' => $info->course), '*', MUST_EXIST);
1573     $cm = get_coursemodule_from_instance('data', $info->dataid, $course->id, false, MUST_EXIST);
1575     // Make sure groups allow this user to see the item they're rating.
1576     return groups_group_visible($info->groupid, $course, $cm);
1580 /**
1581  * function that takes in the current data, number of items per page,
1582  * a search string and prints a preference box in view.php
1583  *
1584  * This preference box prints a searchable advanced search template if
1585  *     a) A template is defined
1586  *  b) The advanced search checkbox is checked.
1587  *
1588  * @global object
1589  * @global object
1590  * @param object $data
1591  * @param int $perpage
1592  * @param string $search
1593  * @param string $sort
1594  * @param string $order
1595  * @param array $search_array
1596  * @param int $advanced
1597  * @param string $mode
1598  * @return void
1599  */
1600 function data_print_preference_form($data, $perpage, $search, $sort='', $order='ASC', $search_array = '', $advanced = 0, $mode= ''){
1601     global $CFG, $DB, $PAGE, $OUTPUT;
1603     $cm = get_coursemodule_from_instance('data', $data->id);
1604     $context = context_module::instance($cm->id);
1605     echo '<br /><div class="datapreferences">';
1606     echo '<form id="options" action="view.php" method="get">';
1607     echo '<div>';
1608     echo '<input type="hidden" name="d" value="'.$data->id.'" />';
1609     if ($mode =='asearch') {
1610         $advanced = 1;
1611         echo '<input type="hidden" name="mode" value="list" />';
1612     }
1613     echo '<label for="pref_perpage">'.get_string('pagesize','data').'</label> ';
1614     $pagesizes = array(2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,15=>15,
1615                        20=>20,30=>30,40=>40,50=>50,100=>100,200=>200,300=>300,400=>400,500=>500,1000=>1000);
1616     echo html_writer::select($pagesizes, 'perpage', $perpage, false, array('id'=>'pref_perpage'));
1618     if ($advanced) {
1619         $regsearchclass = 'search_none';
1620         $advancedsearchclass = 'search_inline';
1621     } else {
1622         $regsearchclass = 'search_inline';
1623         $advancedsearchclass = 'search_none';
1624     }
1625     echo '<div id="reg_search" class="' . $regsearchclass . '" >&nbsp;&nbsp;&nbsp;';
1626     echo '<label for="pref_search">'.get_string('search').'</label> <input type="text" size="16" name="search" id= "pref_search" value="'.s($search).'" /></div>';
1627     echo '&nbsp;&nbsp;&nbsp;<label for="pref_sortby">'.get_string('sortby').'</label> ';
1628     // foreach field, print the option
1629     echo '<select name="sort" id="pref_sortby">';
1630     if ($fields = $DB->get_records('data_fields', array('dataid'=>$data->id), 'name')) {
1631         echo '<optgroup label="'.get_string('fields', 'data').'">';
1632         foreach ($fields as $field) {
1633             if ($field->id == $sort) {
1634                 echo '<option value="'.$field->id.'" selected="selected">'.$field->name.'</option>';
1635             } else {
1636                 echo '<option value="'.$field->id.'">'.$field->name.'</option>';
1637             }
1638         }
1639         echo '</optgroup>';
1640     }
1641     $options = array();
1642     $options[DATA_TIMEADDED]    = get_string('timeadded', 'data');
1643     $options[DATA_TIMEMODIFIED] = get_string('timemodified', 'data');
1644     $options[DATA_FIRSTNAME]    = get_string('authorfirstname', 'data');
1645     $options[DATA_LASTNAME]     = get_string('authorlastname', 'data');
1646     if ($data->approval and has_capability('mod/data:approve', $context)) {
1647         $options[DATA_APPROVED] = get_string('approved', 'data');
1648     }
1649     echo '<optgroup label="'.get_string('other', 'data').'">';
1650     foreach ($options as $key => $name) {
1651         if ($key == $sort) {
1652             echo '<option value="'.$key.'" selected="selected">'.$name.'</option>';
1653         } else {
1654             echo '<option value="'.$key.'">'.$name.'</option>';
1655         }
1656     }
1657     echo '</optgroup>';
1658     echo '</select>';
1659     echo '<label for="pref_order" class="accesshide">'.get_string('order').'</label>';
1660     echo '<select id="pref_order" name="order">';
1661     if ($order == 'ASC') {
1662         echo '<option value="ASC" selected="selected">'.get_string('ascending','data').'</option>';
1663     } else {
1664         echo '<option value="ASC">'.get_string('ascending','data').'</option>';
1665     }
1666     if ($order == 'DESC') {
1667         echo '<option value="DESC" selected="selected">'.get_string('descending','data').'</option>';
1668     } else {
1669         echo '<option value="DESC">'.get_string('descending','data').'</option>';
1670     }
1671     echo '</select>';
1673     if ($advanced) {
1674         $checked = ' checked="checked" ';
1675     }
1676     else {
1677         $checked = '';
1678     }
1679     $PAGE->requires->js('/mod/data/data.js');
1680     echo '&nbsp;<input type="hidden" name="advanced" value="0" />';
1681     echo '&nbsp;<input type="hidden" name="filter" value="1" />';
1682     echo '&nbsp;<input type="checkbox" id="advancedcheckbox" name="advanced" value="1" '.$checked.' onchange="showHideAdvSearch(this.checked);" /><label for="advancedcheckbox">'.get_string('advancedsearch', 'data').'</label>';
1683     echo '&nbsp;<input type="submit" value="'.get_string('savesettings','data').'" />';
1685     echo '<br />';
1686     echo '<div class="' . $advancedsearchclass . '" id="data_adv_form">';
1687     echo '<table class="boxaligncenter">';
1689     // print ASC or DESC
1690     echo '<tr><td colspan="2">&nbsp;</td></tr>';
1691     $i = 0;
1693     // Determine if we are printing all fields for advanced search, or the template for advanced search
1694     // If a template is not defined, use the deafault template and display all fields.
1695     if(empty($data->asearchtemplate)) {
1696         data_generate_default_template($data, 'asearchtemplate');
1697     }
1699     static $fields = NULL;
1700     static $isteacher;
1701     static $dataid = NULL;
1703     if (empty($dataid)) {
1704         $dataid = $data->id;
1705     } else if ($dataid != $data->id) {
1706         $fields = NULL;
1707     }
1709     if (empty($fields)) {
1710         $fieldrecords = $DB->get_records('data_fields', array('dataid'=>$data->id));
1711         foreach ($fieldrecords as $fieldrecord) {
1712             $fields[]= data_get_field($fieldrecord, $data);
1713         }
1715         $isteacher = has_capability('mod/data:managetemplates', $context);
1716     }
1718     // Replacing tags
1719     $patterns = array();
1720     $replacement = array();
1722     // Then we generate strings to replace for normal tags
1723     foreach ($fields as $field) {
1724         $fieldname = $field->field->name;
1725         $fieldname = preg_quote($fieldname, '/');
1726         $patterns[] = "/\[\[$fieldname\]\]/i";
1727         $searchfield = data_get_field_from_id($field->field->id, $data);
1728         if (!empty($search_array[$field->field->id]->data)) {
1729             $replacement[] = $searchfield->display_search_field($search_array[$field->field->id]->data);
1730         } else {
1731             $replacement[] = $searchfield->display_search_field();
1732         }
1733     }
1734     $fn = !empty($search_array[DATA_FIRSTNAME]->data) ? $search_array[DATA_FIRSTNAME]->data : '';
1735     $ln = !empty($search_array[DATA_LASTNAME]->data) ? $search_array[DATA_LASTNAME]->data : '';
1736     $patterns[]    = '/##firstname##/';
1737     $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.'" />';
1738     $patterns[]    = '/##lastname##/';
1739     $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.'" />';
1741     // actual replacement of the tags
1742     $newtext = preg_replace($patterns, $replacement, $data->asearchtemplate);
1744     $options = new stdClass();
1745     $options->para=false;
1746     $options->noclean=true;
1747     echo '<tr><td>';
1748     echo format_text($newtext, FORMAT_HTML, $options);
1749     echo '</td></tr>';
1751     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>';
1752     echo '</table>';
1753     echo '</div>';
1754     echo '</div>';
1755     echo '</form>';
1756     echo '</div>';
1759 /**
1760  * @global object
1761  * @global object
1762  * @param object $data
1763  * @param object $record
1764  * @return void Output echo'd
1765  */
1766 function data_print_ratings($data, $record) {
1767     global $OUTPUT;
1768     if (!empty($record->rating)){
1769         echo $OUTPUT->render($record->rating);
1770     }
1773 /**
1774  * List the actions that correspond to a view of this module.
1775  * This is used by the participation report.
1776  *
1777  * Note: This is not used by new logging system. Event with
1778  *       crud = 'r' and edulevel = LEVEL_PARTICIPATING will
1779  *       be considered as view action.
1780  *
1781  * @return array
1782  */
1783 function data_get_view_actions() {
1784     return array('view');
1787 /**
1788  * List the actions that correspond to a post of this module.
1789  * This is used by the participation report.
1790  *
1791  * Note: This is not used by new logging system. Event with
1792  *       crud = ('c' || 'u' || 'd') and edulevel = LEVEL_PARTICIPATING
1793  *       will be considered as post action.
1794  *
1795  * @return array
1796  */
1797 function data_get_post_actions() {
1798     return array('add','update','record delete');
1801 /**
1802  * @param string $name
1803  * @param int $dataid
1804  * @param int $fieldid
1805  * @return bool
1806  */
1807 function data_fieldname_exists($name, $dataid, $fieldid = 0) {
1808     global $DB;
1810     if (!is_numeric($name)) {
1811         $like = $DB->sql_like('df.name', ':name', false);
1812     } else {
1813         $like = "df.name = :name";
1814     }
1815     $params = array('name'=>$name);
1816     if ($fieldid) {
1817         $params['dataid']   = $dataid;
1818         $params['fieldid1'] = $fieldid;
1819         $params['fieldid2'] = $fieldid;
1820         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1821                                         WHERE $like AND df.dataid = :dataid
1822                                               AND ((df.id < :fieldid1) OR (df.id > :fieldid2))", $params);
1823     } else {
1824         $params['dataid']   = $dataid;
1825         return $DB->record_exists_sql("SELECT * FROM {data_fields} df
1826                                         WHERE $like AND df.dataid = :dataid", $params);
1827     }
1830 /**
1831  * @param array $fieldinput
1832  */
1833 function data_convert_arrays_to_strings(&$fieldinput) {
1834     foreach ($fieldinput as $key => $val) {
1835         if (is_array($val)) {
1836             $str = '';
1837             foreach ($val as $inner) {
1838                 $str .= $inner . ',';
1839             }
1840             $str = substr($str, 0, -1);
1842             $fieldinput->$key = $str;
1843         }
1844     }
1848 /**
1849  * Converts a database (module instance) to use the Roles System
1850  *
1851  * @global object
1852  * @global object
1853  * @uses CONTEXT_MODULE
1854  * @uses CAP_PREVENT
1855  * @uses CAP_ALLOW
1856  * @param object $data a data object with the same attributes as a record
1857  *                     from the data database table
1858  * @param int $datamodid the id of the data module, from the modules table
1859  * @param array $teacherroles array of roles that have archetype teacher
1860  * @param array $studentroles array of roles that have archetype student
1861  * @param array $guestroles array of roles that have archetype guest
1862  * @param int $cmid the course_module id for this data instance
1863  * @return boolean data module was converted or not
1864  */
1865 function data_convert_to_roles($data, $teacherroles=array(), $studentroles=array(), $cmid=NULL) {
1866     global $CFG, $DB, $OUTPUT;
1868     if (!isset($data->participants) && !isset($data->assesspublic)
1869             && !isset($data->groupmode)) {
1870         // We assume that this database has already been converted to use the
1871         // Roles System. above fields get dropped the data module has been
1872         // upgraded to use Roles.
1873         return false;
1874     }
1876     if (empty($cmid)) {
1877         // We were not given the course_module id. Try to find it.
1878         if (!$cm = get_coursemodule_from_instance('data', $data->id)) {
1879             echo $OUTPUT->notification('Could not get the course module for the data');
1880             return false;
1881         } else {
1882             $cmid = $cm->id;
1883         }
1884     }
1885     $context = context_module::instance($cmid);
1888     // $data->participants:
1889     // 1 - Only teachers can add entries
1890     // 3 - Teachers and students can add entries
1891     switch ($data->participants) {
1892         case 1:
1893             foreach ($studentroles as $studentrole) {
1894                 assign_capability('mod/data:writeentry', CAP_PREVENT, $studentrole->id, $context->id);
1895             }
1896             foreach ($teacherroles as $teacherrole) {
1897                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
1898             }
1899             break;
1900         case 3:
1901             foreach ($studentroles as $studentrole) {
1902                 assign_capability('mod/data:writeentry', CAP_ALLOW, $studentrole->id, $context->id);
1903             }
1904             foreach ($teacherroles as $teacherrole) {
1905                 assign_capability('mod/data:writeentry', CAP_ALLOW, $teacherrole->id, $context->id);
1906             }
1907             break;
1908     }
1910     // $data->assessed:
1911     // 2 - Only teachers can rate posts
1912     // 1 - Everyone can rate posts
1913     // 0 - No one can rate posts
1914     switch ($data->assessed) {
1915         case 0:
1916             foreach ($studentroles as $studentrole) {
1917                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
1918             }
1919             foreach ($teacherroles as $teacherrole) {
1920                 assign_capability('mod/data:rate', CAP_PREVENT, $teacherrole->id, $context->id);
1921             }
1922             break;
1923         case 1:
1924             foreach ($studentroles as $studentrole) {
1925                 assign_capability('mod/data:rate', CAP_ALLOW, $studentrole->id, $context->id);
1926             }
1927             foreach ($teacherroles as $teacherrole) {
1928                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
1929             }
1930             break;
1931         case 2:
1932             foreach ($studentroles as $studentrole) {
1933                 assign_capability('mod/data:rate', CAP_PREVENT, $studentrole->id, $context->id);
1934             }
1935             foreach ($teacherroles as $teacherrole) {
1936                 assign_capability('mod/data:rate', CAP_ALLOW, $teacherrole->id, $context->id);
1937             }
1938             break;
1939     }
1941     // $data->assesspublic:
1942     // 0 - Students can only see their own ratings
1943     // 1 - Students can see everyone's ratings
1944     switch ($data->assesspublic) {
1945         case 0:
1946             foreach ($studentroles as $studentrole) {
1947                 assign_capability('mod/data:viewrating', CAP_PREVENT, $studentrole->id, $context->id);
1948             }
1949             foreach ($teacherroles as $teacherrole) {
1950                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
1951             }
1952             break;
1953         case 1:
1954             foreach ($studentroles as $studentrole) {
1955                 assign_capability('mod/data:viewrating', CAP_ALLOW, $studentrole->id, $context->id);
1956             }
1957             foreach ($teacherroles as $teacherrole) {
1958                 assign_capability('mod/data:viewrating', CAP_ALLOW, $teacherrole->id, $context->id);
1959             }
1960             break;
1961     }
1963     if (empty($cm)) {
1964         $cm = $DB->get_record('course_modules', array('id'=>$cmid));
1965     }
1967     switch ($cm->groupmode) {
1968         case NOGROUPS:
1969             break;
1970         case SEPARATEGROUPS:
1971             foreach ($studentroles as $studentrole) {
1972                 assign_capability('moodle/site:accessallgroups', CAP_PREVENT, $studentrole->id, $context->id);
1973             }
1974             foreach ($teacherroles as $teacherrole) {
1975                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
1976             }
1977             break;
1978         case VISIBLEGROUPS:
1979             foreach ($studentroles as $studentrole) {
1980                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $studentrole->id, $context->id);
1981             }
1982             foreach ($teacherroles as $teacherrole) {
1983                 assign_capability('moodle/site:accessallgroups', CAP_ALLOW, $teacherrole->id, $context->id);
1984             }
1985             break;
1986     }
1987     return true;
1990 /**
1991  * Returns the best name to show for a preset
1992  *
1993  * @param string $shortname
1994  * @param  string $path
1995  * @return string
1996  */
1997 function data_preset_name($shortname, $path) {
1999     // We are looking inside the preset itself as a first choice, but also in normal data directory
2000     $string = get_string('modulename', 'datapreset_'.$shortname);
2002     if (substr($string, 0, 1) == '[') {
2003         return $shortname;
2004     } else {
2005         return $string;
2006     }
2009 /**
2010  * Returns an array of all the available presets.
2011  *
2012  * @return array
2013  */
2014 function data_get_available_presets($context) {
2015     global $CFG, $USER;
2017     $presets = array();
2019     // First load the ratings sub plugins that exist within the modules preset dir
2020     if ($dirs = core_component::get_plugin_list('datapreset')) {
2021         foreach ($dirs as $dir=>$fulldir) {
2022             if (is_directory_a_preset($fulldir)) {
2023                 $preset = new stdClass();
2024                 $preset->path = $fulldir;
2025                 $preset->userid = 0;
2026                 $preset->shortname = $dir;
2027                 $preset->name = data_preset_name($dir, $fulldir);
2028                 if (file_exists($fulldir.'/screenshot.jpg')) {
2029                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.jpg';
2030                 } else if (file_exists($fulldir.'/screenshot.png')) {
2031                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.png';
2032                 } else if (file_exists($fulldir.'/screenshot.gif')) {
2033                     $preset->screenshot = $CFG->wwwroot.'/mod/data/preset/'.$dir.'/screenshot.gif';
2034                 }
2035                 $presets[] = $preset;
2036             }
2037         }
2038     }
2039     // Now add to that the site presets that people have saved
2040     $presets = data_get_available_site_presets($context, $presets);
2041     return $presets;
2044 /**
2045  * Gets an array of all of the presets that users have saved to the site.
2046  *
2047  * @param stdClass $context The context that we are looking from.
2048  * @param array $presets
2049  * @return array An array of presets
2050  */
2051 function data_get_available_site_presets($context, array $presets=array()) {
2052     global $USER;
2054     $fs = get_file_storage();
2055     $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2056     $canviewall = has_capability('mod/data:viewalluserpresets', $context);
2057     if (empty($files)) {
2058         return $presets;
2059     }
2060     foreach ($files as $file) {
2061         if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory() || (!$canviewall && $file->get_userid() != $USER->id)) {
2062             continue;
2063         }
2064         $preset = new stdClass;
2065         $preset->path = $file->get_filepath();
2066         $preset->name = trim($preset->path, '/');
2067         $preset->shortname = $preset->name;
2068         $preset->userid = $file->get_userid();
2069         $preset->id = $file->get_id();
2070         $preset->storedfile = $file;
2071         $presets[] = $preset;
2072     }
2073     return $presets;
2076 /**
2077  * Deletes a saved preset.
2078  *
2079  * @param string $name
2080  * @return bool
2081  */
2082 function data_delete_site_preset($name) {
2083     $fs = get_file_storage();
2085     $files = $fs->get_directory_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/');
2086     if (!empty($files)) {
2087         foreach ($files as $file) {
2088             $file->delete();
2089         }
2090     }
2092     $dir = $fs->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, '/'.$name.'/', '.');
2093     if (!empty($dir)) {
2094         $dir->delete();
2095     }
2096     return true;
2099 /**
2100  * Prints the heads for a page
2101  *
2102  * @param stdClass $course
2103  * @param stdClass $cm
2104  * @param stdClass $data
2105  * @param string $currenttab
2106  */
2107 function data_print_header($course, $cm, $data, $currenttab='') {
2109     global $CFG, $displaynoticegood, $displaynoticebad, $OUTPUT, $PAGE;
2111     $PAGE->set_title($data->name);
2112     echo $OUTPUT->header();
2113     echo $OUTPUT->heading(format_string($data->name), 2);
2114     echo $OUTPUT->box(format_module_intro('data', $data, $cm->id), 'generalbox', 'intro');
2116     // Groups needed for Add entry tab
2117     $currentgroup = groups_get_activity_group($cm);
2118     $groupmode = groups_get_activity_groupmode($cm);
2120     // Print the tabs
2122     if ($currenttab) {
2123         include('tabs.php');
2124     }
2126     // Print any notices
2128     if (!empty($displaynoticegood)) {
2129         echo $OUTPUT->notification($displaynoticegood, 'notifysuccess');    // good (usually green)
2130     } else if (!empty($displaynoticebad)) {
2131         echo $OUTPUT->notification($displaynoticebad);                     // bad (usuually red)
2132     }
2135 /**
2136  * Can user add more entries?
2137  *
2138  * @param object $data
2139  * @param mixed $currentgroup
2140  * @param int $groupmode
2141  * @param stdClass $context
2142  * @return bool
2143  */
2144 function data_user_can_add_entry($data, $currentgroup, $groupmode, $context = null) {
2145     global $USER;
2147     if (empty($context)) {
2148         $cm = get_coursemodule_from_instance('data', $data->id, 0, false, MUST_EXIST);
2149         $context = context_module::instance($cm->id);
2150     }
2152     if (has_capability('mod/data:manageentries', $context)) {
2153         // no entry limits apply if user can manage
2155     } else if (!has_capability('mod/data:writeentry', $context)) {
2156         return false;
2158     } else if (data_atmaxentries($data)) {
2159         return false;
2160     } else if (data_in_readonly_period($data)) {
2161         // Check whether we're in a read-only period
2162         return false;
2163     }
2165     if (!$groupmode or has_capability('moodle/site:accessallgroups', $context)) {
2166         return true;
2167     }
2169     if ($currentgroup) {
2170         return groups_is_member($currentgroup);
2171     } else {
2172         //else it might be group 0 in visible mode
2173         if ($groupmode == VISIBLEGROUPS){
2174             return true;
2175         } else {
2176             return false;
2177         }
2178     }
2181 /**
2182  * Check whether the specified database activity is currently in a read-only period
2183  *
2184  * @param object $data
2185  * @return bool returns true if the time fields in $data indicate a read-only period; false otherwise
2186  */
2187 function data_in_readonly_period($data) {
2188     $now = time();
2189     if (!$data->timeviewfrom && !$data->timeviewto) {
2190         return false;
2191     } else if (($data->timeviewfrom && $now < $data->timeviewfrom) || ($data->timeviewto && $now > $data->timeviewto)) {
2192         return false;
2193     }
2194     return true;
2197 /**
2198  * @return bool
2199  */
2200 function is_directory_a_preset($directory) {
2201     $directory = rtrim($directory, '/\\') . '/';
2202     $status = file_exists($directory.'singletemplate.html') &&
2203               file_exists($directory.'listtemplate.html') &&
2204               file_exists($directory.'listtemplateheader.html') &&
2205               file_exists($directory.'listtemplatefooter.html') &&
2206               file_exists($directory.'addtemplate.html') &&
2207               file_exists($directory.'rsstemplate.html') &&
2208               file_exists($directory.'rsstitletemplate.html') &&
2209               file_exists($directory.'csstemplate.css') &&
2210               file_exists($directory.'jstemplate.js') &&
2211               file_exists($directory.'preset.xml');
2213     return $status;
2216 /**
2217  * Abstract class used for data preset importers
2218  */
2219 abstract class data_preset_importer {
2221     protected $course;
2222     protected $cm;
2223     protected $module;
2224     protected $directory;
2226     /**
2227      * Constructor
2228      *
2229      * @param stdClass $course
2230      * @param stdClass $cm
2231      * @param stdClass $module
2232      * @param string $directory
2233      */
2234     public function __construct($course, $cm, $module, $directory) {
2235         $this->course = $course;
2236         $this->cm = $cm;
2237         $this->module = $module;
2238         $this->directory = $directory;
2239     }
2241     /**
2242      * Returns the name of the directory the preset is located in
2243      * @return string
2244      */
2245     public function get_directory() {
2246         return basename($this->directory);
2247     }
2249     /**
2250      * Retreive the contents of a file. That file may either be in a conventional directory of the Moodle file storage
2251      * @param file_storage $filestorage. should be null if using a conventional directory
2252      * @param stored_file $fileobj the directory to look in. null if using a conventional directory
2253      * @param string $dir the directory to look in. null if using the Moodle file storage
2254      * @param string $filename the name of the file we want
2255      * @return string the contents of the file or null if the file doesn't exist.
2256      */
2257     public function data_preset_get_file_contents(&$filestorage, &$fileobj, $dir, $filename) {
2258         if(empty($filestorage) || empty($fileobj)) {
2259             if (substr($dir, -1)!='/') {
2260                 $dir .= '/';
2261             }
2262             if (file_exists($dir.$filename)) {
2263                 return file_get_contents($dir.$filename);
2264             } else {
2265                 return null;
2266             }
2267         } else {
2268             if ($filestorage->file_exists(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename)) {
2269                 $file = $filestorage->get_file(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA, 0, $fileobj->get_filepath(), $filename);
2270                 return $file->get_content();
2271             } else {
2272                 return null;
2273             }
2274         }
2276     }
2277     /**
2278      * Gets the preset settings
2279      * @global moodle_database $DB
2280      * @return stdClass
2281      */
2282     public function get_preset_settings() {
2283         global $DB;
2285         $fs = $fileobj = null;
2286         if (!is_directory_a_preset($this->directory)) {
2287             //maybe the user requested a preset stored in the Moodle file storage
2289             $fs = get_file_storage();
2290             $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);
2292             //preset name to find will be the final element of the directory
2293             $explodeddirectory = explode('/', $this->directory);
2294             $presettofind = end($explodeddirectory);
2296             //now go through the available files available and see if we can find it
2297             foreach ($files as $file) {
2298                 if (($file->is_directory() && $file->get_filepath()=='/') || !$file->is_directory()) {
2299                     continue;
2300                 }
2301                 $presetname = trim($file->get_filepath(), '/');
2302                 if ($presetname==$presettofind) {
2303                     $this->directory = $presetname;
2304                     $fileobj = $file;
2305                 }
2306             }
2308             if (empty($fileobj)) {
2309                 print_error('invalidpreset', 'data', '', $this->directory);
2310             }
2311         }
2313         $allowed_settings = array(
2314             'intro',
2315             'comments',
2316             'requiredentries',
2317             'requiredentriestoview',
2318             'maxentries',
2319             'rssarticles',
2320             'approval',
2321             'defaultsortdir',
2322             'defaultsort');
2324         $result = new stdClass;
2325         $result->settings = new stdClass;
2326         $result->importfields = array();
2327         $result->currentfields = $DB->get_records('data_fields', array('dataid'=>$this->module->id));
2328         if (!$result->currentfields) {
2329             $result->currentfields = array();
2330         }
2333         /* Grab XML */
2334         $presetxml = $this->data_preset_get_file_contents($fs, $fileobj, $this->directory,'preset.xml');
2335         $parsedxml = xmlize($presetxml, 0);
2337         /* First, do settings. Put in user friendly array. */
2338         $settingsarray = $parsedxml['preset']['#']['settings'][0]['#'];
2339         $result->settings = new StdClass();
2340         foreach ($settingsarray as $setting => $value) {
2341             if (!is_array($value) || !in_array($setting, $allowed_settings)) {
2342                 // unsupported setting
2343                 continue;
2344             }
2345             $result->settings->$setting = $value[0]['#'];
2346         }
2348         /* Now work out fields to user friendly array */
2349         $fieldsarray = $parsedxml['preset']['#']['field'];
2350         foreach ($fieldsarray as $field) {
2351             if (!is_array($field)) {
2352                 continue;
2353             }
2354             $f = new StdClass();
2355             foreach ($field['#'] as $param => $value) {
2356                 if (!is_array($value)) {
2357                     continue;
2358                 }
2359                 $f->$param = $value[0]['#'];
2360             }
2361             $f->dataid = $this->module->id;
2362             $f->type = clean_param($f->type, PARAM_ALPHA);
2363             $result->importfields[] = $f;
2364         }
2365         /* Now add the HTML templates to the settings array so we can update d */
2366         $result->settings->singletemplate     = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"singletemplate.html");
2367         $result->settings->listtemplate       = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplate.html");
2368         $result->settings->listtemplateheader = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplateheader.html");
2369         $result->settings->listtemplatefooter = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"listtemplatefooter.html");
2370         $result->settings->addtemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"addtemplate.html");
2371         $result->settings->rsstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstemplate.html");
2372         $result->settings->rsstitletemplate   = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"rsstitletemplate.html");
2373         $result->settings->csstemplate        = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"csstemplate.css");
2374         $result->settings->jstemplate         = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"jstemplate.js");
2375         $result->settings->asearchtemplate    = $this->data_preset_get_file_contents($fs, $fileobj,$this->directory,"asearchtemplate.html");
2377         $result->settings->instance = $this->module->id;
2378         return $result;
2379     }
2381     /**
2382      * Import the preset into the given database module
2383      * @return bool
2384      */
2385     function import($overwritesettings) {
2386         global $DB, $CFG;
2388         $params = $this->get_preset_settings();
2389         $settings = $params->settings;
2390         $newfields = $params->importfields;
2391         $currentfields = $params->currentfields;
2392         $preservedfields = array();
2394         /* Maps fields and makes new ones */
2395         if (!empty($newfields)) {
2396             /* We require an injective mapping, and need to know what to protect */
2397             foreach ($newfields as $nid => $newfield) {
2398                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2399                 if ($cid == -1) {
2400                     continue;
2401                 }
2402                 if (array_key_exists($cid, $preservedfields)){
2403                     print_error('notinjectivemap', 'data');
2404                 }
2405                 else $preservedfields[$cid] = true;
2406             }
2408             foreach ($newfields as $nid => $newfield) {
2409                 $cid = optional_param("field_$nid", -1, PARAM_INT);
2411                 /* A mapping. Just need to change field params. Data kept. */
2412                 if ($cid != -1 and isset($currentfields[$cid])) {
2413                     $fieldobject = data_get_field_from_id($currentfields[$cid]->id, $this->module);
2414                     foreach ($newfield as $param => $value) {
2415                         if ($param != "id") {
2416                             $fieldobject->field->$param = $value;
2417                         }
2418                     }
2419                     unset($fieldobject->field->similarfield);
2420                     $fieldobject->update_field();
2421                     unset($fieldobject);
2422                 } else {
2423                     /* Make a new field */
2424                     include_once("field/$newfield->type/field.class.php");
2426                     if (!isset($newfield->description)) {
2427                         $newfield->description = '';
2428                     }
2429                     $classname = 'data_field_'.$newfield->type;
2430                     $fieldclass = new $classname($newfield, $this->module);
2431                     $fieldclass->insert_field();
2432                     unset($fieldclass);
2433                 }
2434             }
2435         }
2437         /* Get rid of all old unused data */
2438         if (!empty($preservedfields)) {
2439             foreach ($currentfields as $cid => $currentfield) {
2440                 if (!array_key_exists($cid, $preservedfields)) {
2441                     /* Data not used anymore so wipe! */
2442                     print "Deleting field $currentfield->name<br />";
2444                     $id = $currentfield->id;
2445                     //Why delete existing data records and related comments/ratings??
2446                     $DB->delete_records('data_content', array('fieldid'=>$id));
2447                     $DB->delete_records('data_fields', array('id'=>$id));
2448                 }
2449             }
2450         }
2452         // handle special settings here
2453         if (!empty($settings->defaultsort)) {
2454             if (is_numeric($settings->defaultsort)) {
2455                 // old broken value
2456                 $settings->defaultsort = 0;
2457             } else {
2458                 $settings->defaultsort = (int)$DB->get_field('data_fields', 'id', array('dataid'=>$this->module->id, 'name'=>$settings->defaultsort));
2459             }
2460         } else {
2461             $settings->defaultsort = 0;
2462         }
2464         // do we want to overwrite all current database settings?
2465         if ($overwritesettings) {
2466             // all supported settings
2467             $overwrite = array_keys((array)$settings);
2468         } else {
2469             // only templates and sorting
2470             $overwrite = array('singletemplate', 'listtemplate', 'listtemplateheader', 'listtemplatefooter',
2471                                'addtemplate', 'rsstemplate', 'rsstitletemplate', 'csstemplate', 'jstemplate',
2472                                'asearchtemplate', 'defaultsortdir', 'defaultsort');
2473         }
2475         // now overwrite current data settings
2476         foreach ($this->module as $prop=>$unused) {
2477             if (in_array($prop, $overwrite)) {
2478                 $this->module->$prop = $settings->$prop;
2479             }
2480         }
2482         data_update_instance($this->module);
2484         return $this->cleanup();
2485     }
2487     /**
2488      * Any clean up routines should go here
2489      * @return bool
2490      */
2491     public function cleanup() {
2492         return true;
2493     }
2496 /**
2497  * Data preset importer for uploaded presets
2498  */
2499 class data_preset_upload_importer extends data_preset_importer {
2500     public function __construct($course, $cm, $module, $filepath) {
2501         global $USER;
2502         if (is_file($filepath)) {
2503             $fp = get_file_packer();
2504             if ($fp->extract_to_pathname($filepath, $filepath.'_extracted')) {
2505                 fulldelete($filepath);
2506             }
2507             $filepath .= '_extracted';
2508         }
2509         parent::__construct($course, $cm, $module, $filepath);
2510     }
2511     public function cleanup() {
2512         return fulldelete($this->directory);
2513     }
2516 /**
2517  * Data preset importer for existing presets
2518  */
2519 class data_preset_existing_importer extends data_preset_importer {
2520     protected $userid;
2521     public function __construct($course, $cm, $module, $fullname) {
2522         global $USER;
2523         list($userid, $shortname) = explode('/', $fullname, 2);
2524         $context = context_module::instance($cm->id);
2525         if ($userid && ($userid != $USER->id) && !has_capability('mod/data:manageuserpresets', $context) && !has_capability('mod/data:viewalluserpresets', $context)) {
2526            throw new coding_exception('Invalid preset provided');
2527         }
2529         $this->userid = $userid;
2530         $filepath = data_preset_path($course, $userid, $shortname);
2531         parent::__construct($course, $cm, $module, $filepath);
2532     }
2533     public function get_userid() {
2534         return $this->userid;
2535     }
2538 /**
2539  * @global object
2540  * @global object
2541  * @param object $course
2542  * @param int $userid
2543  * @param string $shortname
2544  * @return string
2545  */
2546 function data_preset_path($course, $userid, $shortname) {
2547     global $USER, $CFG;
2549     $context = context_course::instance($course->id);
2551     $userid = (int)$userid;
2553     $path = null;
2554     if ($userid > 0 && ($userid == $USER->id || has_capability('mod/data:viewalluserpresets', $context))) {
2555         $path = $CFG->dataroot.'/data/preset/'.$userid.'/'.$shortname;
2556     } else if ($userid == 0) {
2557         $path = $CFG->dirroot.'/mod/data/preset/'.$shortname;
2558     } else if ($userid < 0) {
2559         $path = $CFG->tempdir.'/data/'.-$userid.'/'.$shortname;
2560     }
2562     return $path;
2565 /**
2566  * Implementation of the function for printing the form elements that control
2567  * whether the course reset functionality affects the data.
2568  *
2569  * @param $mform form passed by reference
2570  */
2571 function data_reset_course_form_definition(&$mform) {
2572     $mform->addElement('header', 'dataheader', get_string('modulenameplural', 'data'));
2573     $mform->addElement('checkbox', 'reset_data', get_string('deleteallentries','data'));
2575     $mform->addElement('checkbox', 'reset_data_notenrolled', get_string('deletenotenrolled', 'data'));
2576     $mform->disabledIf('reset_data_notenrolled', 'reset_data', 'checked');
2578     $mform->addElement('checkbox', 'reset_data_ratings', get_string('deleteallratings'));
2579     $mform->disabledIf('reset_data_ratings', 'reset_data', 'checked');
2581     $mform->addElement('checkbox', 'reset_data_comments', get_string('deleteallcomments'));
2582     $mform->disabledIf('reset_data_comments', 'reset_data', 'checked');
2585 /**
2586  * Course reset form defaults.
2587  * @return array
2588  */
2589 function data_reset_course_form_defaults($course) {
2590     return array('reset_data'=>0, 'reset_data_ratings'=>1, 'reset_data_comments'=>1, 'reset_data_notenrolled'=>0);
2593 /**
2594  * Removes all grades from gradebook
2595  *
2596  * @global object
2597  * @global object
2598  * @param int $courseid
2599  * @param string $type optional type
2600  */
2601 function data_reset_gradebook($courseid, $type='') {
2602     global $CFG, $DB;
2604     $sql = "SELECT d.*, cm.idnumber as cmidnumber, d.course as courseid
2605               FROM {data} d, {course_modules} cm, {modules} m
2606              WHERE m.name='data' AND m.id=cm.module AND cm.instance=d.id AND d.course=?";
2608     if ($datas = $DB->get_records_sql($sql, array($courseid))) {
2609         foreach ($datas as $data) {
2610             data_grade_item_update($data, 'reset');
2611         }
2612     }
2615 /**
2616  * Actual implementation of the reset course functionality, delete all the
2617  * data responses for course $data->courseid.
2618  *
2619  * @global object
2620  * @global object
2621  * @param object $data the data submitted from the reset course.
2622  * @return array status array
2623  */
2624 function data_reset_userdata($data) {
2625     global $CFG, $DB;
2626     require_once($CFG->libdir.'/filelib.php');
2627     require_once($CFG->dirroot.'/rating/lib.php');
2629     $componentstr = get_string('modulenameplural', 'data');
2630     $status = array();
2632     $allrecordssql = "SELECT r.id
2633                         FROM {data_records} r
2634                              INNER JOIN {data} d ON r.dataid = d.id
2635                        WHERE d.course = ?";
2637     $alldatassql = "SELECT d.id
2638                       FROM {data} d
2639                      WHERE d.course=?";
2641     $rm = new rating_manager();
2642     $ratingdeloptions = new stdClass;
2643     $ratingdeloptions->component = 'mod_data';
2644     $ratingdeloptions->ratingarea = 'entry';
2646     // Set the file storage - may need it to remove files later.
2647     $fs = get_file_storage();
2649     // delete entries if requested
2650     if (!empty($data->reset_data)) {
2651         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2652         $DB->delete_records_select('data_content', "recordid IN ($allrecordssql)", array($data->courseid));
2653         $DB->delete_records_select('data_records', "dataid IN ($alldatassql)", array($data->courseid));
2655         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2656             foreach ($datas as $dataid=>$unused) {
2657                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2658                     continue;
2659                 }
2660                 $datacontext = context_module::instance($cm->id);
2662                 // Delete any files that may exist.
2663                 $fs->delete_area_files($datacontext->id, 'mod_data', 'content');
2665                 $ratingdeloptions->contextid = $datacontext->id;
2666                 $rm->delete_ratings($ratingdeloptions);
2667             }
2668         }
2670         if (empty($data->reset_gradebook_grades)) {
2671             // remove all grades from gradebook
2672             data_reset_gradebook($data->courseid);
2673         }
2674         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallentries', 'data'), 'error'=>false);
2675     }
2677     // remove entries by users not enrolled into course
2678     if (!empty($data->reset_data_notenrolled)) {
2679         $recordssql = "SELECT r.id, r.userid, r.dataid, u.id AS userexists, u.deleted AS userdeleted
2680                          FROM {data_records} r
2681                               JOIN {data} d ON r.dataid = d.id
2682                               LEFT JOIN {user} u ON r.userid = u.id
2683                         WHERE d.course = ? AND r.userid > 0";
2685         $course_context = context_course::instance($data->courseid);
2686         $notenrolled = array();
2687         $fields = array();
2688         $rs = $DB->get_recordset_sql($recordssql, array($data->courseid));
2689         foreach ($rs as $record) {
2690             if (array_key_exists($record->userid, $notenrolled) or !$record->userexists or $record->userdeleted
2691               or !is_enrolled($course_context, $record->userid)) {
2692                 //delete ratings
2693                 if (!$cm = get_coursemodule_from_instance('data', $record->dataid)) {
2694                     continue;
2695                 }
2696                 $datacontext = context_module::instance($cm->id);
2697                 $ratingdeloptions->contextid = $datacontext->id;
2698                 $ratingdeloptions->itemid = $record->id;
2699                 $rm->delete_ratings($ratingdeloptions);
2701                 // Delete any files that may exist.
2702                 if ($contents = $DB->get_records('data_content', array('recordid' => $record->id), '', 'id')) {
2703                     foreach ($contents as $content) {
2704                         $fs->delete_area_files($datacontext->id, 'mod_data', 'content', $content->id);
2705                     }
2706                 }
2707                 $notenrolled[$record->userid] = true;
2709                 $DB->delete_records('comments', array('itemid' => $record->id, 'commentarea' => 'database_entry'));
2710                 $DB->delete_records('data_content', array('recordid' => $record->id));
2711                 $DB->delete_records('data_records', array('id' => $record->id));
2712             }
2713         }
2714         $rs->close();
2715         $status[] = array('component'=>$componentstr, 'item'=>get_string('deletenotenrolled', 'data'), 'error'=>false);
2716     }
2718     // remove all ratings
2719     if (!empty($data->reset_data_ratings)) {
2720         if ($datas = $DB->get_records_sql($alldatassql, array($data->courseid))) {
2721             foreach ($datas as $dataid=>$unused) {
2722                 if (!$cm = get_coursemodule_from_instance('data', $dataid)) {
2723                     continue;
2724                 }
2725                 $datacontext = context_module::instance($cm->id);
2727                 $ratingdeloptions->contextid = $datacontext->id;
2728                 $rm->delete_ratings($ratingdeloptions);
2729             }
2730         }
2732         if (empty($data->reset_gradebook_grades)) {
2733             // remove all grades from gradebook
2734             data_reset_gradebook($data->courseid);
2735         }
2737         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallratings'), 'error'=>false);
2738     }
2740     // remove all comments
2741     if (!empty($data->reset_data_comments)) {
2742         $DB->delete_records_select('comments', "itemid IN ($allrecordssql) AND commentarea='database_entry'", array($data->courseid));
2743         $status[] = array('component'=>$componentstr, 'item'=>get_string('deleteallcomments'), 'error'=>false);
2744     }
2746     // updating dates - shift may be negative too
2747     if ($data->timeshift) {
2748         shift_course_mod_dates('data', array('timeavailablefrom', 'timeavailableto', 'timeviewfrom', 'timeviewto'), $data->timeshift, $data->courseid);
2749         $status[] = array('component'=>$componentstr, 'item'=>get_string('datechanged'), 'error'=>false);
2750     }
2752     return $status;
2755 /**
2756  * Returns all other caps used in module
2757  *
2758  * @return array
2759  */
2760 function data_get_extra_capabilities() {
2761     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');
2764 /**
2765  * @param string $feature FEATURE_xx constant for requested feature
2766  * @return mixed True if module supports feature, null if doesn't know
2767  */
2768 function data_supports($feature) {
2769     switch($feature) {
2770         case FEATURE_GROUPS:                  return true;
2771         case FEATURE_GROUPINGS:               return true;
2772         case FEATURE_MOD_INTRO:               return true;
2773         case FEATURE_COMPLETION_TRACKS_VIEWS: return true;
2774         case FEATURE_GRADE_HAS_GRADE:         return true;
2775         case FEATURE_GRADE_OUTCOMES:          return true;
2776         case FEATURE_RATE:                    return true;
2777         case FEATURE_BACKUP_MOODLE2:          return true;
2778         case FEATURE_SHOW_DESCRIPTION:        return true;
2780         default: return null;
2781     }
2783 /**
2784  * @global object
2785  * @param array $export
2786  * @param string $delimiter_name
2787  * @param object $database
2788  * @param int $count
2789  * @param bool $return
2790  * @return string|void
2791  */
2792 function data_export_csv($export, $delimiter_name, $database, $count, $return=false) {
2793     global $CFG;
2794     require_once($CFG->libdir . '/csvlib.class.php');
2796     $filename = $database . '-' . $count . '-record';
2797     if ($count > 1) {
2798         $filename .= 's';
2799     }
2800     if ($return) {
2801         return csv_export_writer::print_array($export, $delimiter_name, '"', true);
2802     } else {
2803         csv_export_writer::download_array($filename, $export, $delimiter_name);
2804     }
2807 /**
2808  * @global object
2809  * @param array $export
2810  * @param string $dataname
2811  * @param int $count
2812  * @return string
2813  */
2814 function data_export_xls($export, $dataname, $count) {
2815     global $CFG;
2816     require_once("$CFG->libdir/excellib.class.php");
2817     $filename = clean_filename("{$dataname}-{$count}_record");
2818     if ($count > 1) {
2819         $filename .= 's';
2820     }
2821     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
2822     $filename .= '.xls';
2824     $filearg = '-';
2825     $workbook = new MoodleExcelWorkbook($filearg);
2826     $workbook->send($filename);
2827     $worksheet = array();
2828     $worksheet[0] = $workbook->add_worksheet('');
2829     $rowno = 0;
2830     foreach ($export as $row) {
2831         $colno = 0;
2832         foreach($row as $col) {
2833             $worksheet[0]->write($rowno, $colno, $col);
2834             $colno++;
2835         }
2836         $rowno++;
2837     }
2838     $workbook->close();
2839     return $filename;
2842 /**
2843  * @global object
2844  * @param array $export
2845  * @param string $dataname
2846  * @param int $count
2847  * @param string
2848  */
2849 function data_export_ods($export, $dataname, $count) {
2850     global $CFG;
2851     require_once("$CFG->libdir/odslib.class.php");
2852     $filename = clean_filename("{$dataname}-{$count}_record");
2853     if ($count > 1) {
2854         $filename .= 's';
2855     }
2856     $filename .= clean_filename('-' . gmdate("Ymd_Hi"));
2857     $filename .= '.ods';
2858     $filearg = '-';
2859     $workbook = new MoodleODSWorkbook($filearg);
2860     $workbook->send($filename);
2861     $worksheet = array();
2862     $worksheet[0] = $workbook->add_worksheet('');
2863     $rowno = 0;
2864     foreach ($export as $row) {
2865         $colno = 0;
2866         foreach($row as $col) {
2867             $worksheet[0]->write($rowno, $colno, $col);
2868             $colno++;
2869         }
2870         $rowno++;
2871     }
2872     $workbook->close();
2873     return $filename;
2876 /**
2877  * @global object
2878  * @param int $dataid
2879  * @param array $fields
2880  * @param array $selectedfields
2881  * @param int $currentgroup group ID of the current group. This is used for
2882  * exporting data while maintaining group divisions.
2883  * @param object $context the context in which the operation is performed (for capability checks)
2884  * @param bool $userdetails whether to include the details of the record author
2885  * @param bool $time whether to include time created/modified
2886  * @param bool $approval whether to include approval status
2887  * @return array
2888  */
2889 function data_get_exportdata($dataid, $fields, $selectedfields, $currentgroup=0, $context=null,
2890                              $userdetails=false, $time=false, $approval=false) {
2891     global $DB;
2893     if (is_null($context)) {
2894         $context = context_system::instance();
2895     }
2896     // exporting user data needs special permission
2897     $userdetails = $userdetails && has_capability('mod/data:exportuserinfo', $context);
2899     $exportdata = array();
2901     // populate the header in first row of export
2902     foreach($fields as $key => $field) {
2903         if (!in_array($field->field->id, $selectedfields)) {
2904             // ignore values we aren't exporting
2905             unset($fields[$key]);
2906         } else {
2907             $exportdata[0][] = $field->field->name;
2908         }
2909     }
2910     if ($userdetails) {
2911         $exportdata[0][] = get_string('user');
2912         $exportdata[0][] = get_string('username');
2913         $exportdata[0][] = get_string('email');
2914     }
2915     if ($time) {
2916         $exportdata[0][] = get_string('timeadded', 'data');
2917         $exportdata[0][] = get_string('timemodified', 'data');
2918     }
2919     if ($approval) {
2920         $exportdata[0][] = get_string('approved', 'data');
2921     }
2923     $datarecords = $DB->get_records('data_records', array('dataid'=>$dataid));
2924     ksort($datarecords);
2925     $line = 1;
2926     foreach($datarecords as $record) {
2927         // get content indexed by fieldid
2928         if ($currentgroup) {
2929             $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 = ?';
2930             $where = array($record->id, $currentgroup);
2931         } else {
2932             $select = 'SELECT fieldid, content, content1, content2, content3, content4 FROM {data_content} WHERE recordid = ?';
2933             $where = array($record->id);
2934         }
2936         if( $content = $DB->get_records_sql($select, $where) ) {
2937             foreach($fields as $field) {
2938                 $contents = '';
2939                 if(isset($content[$field->field->id])) {
2940                     $contents = $field->export_text_value($content[$field->field->id]);
2941                 }
2942                 $exportdata[$line][] = $contents;
2943             }
2944             if ($userdetails) { // Add user details to the export data
2945                 $userdata = get_complete_user_data('id', $record->userid);
2946                 $exportdata[$line][] = fullname($userdata);
2947                 $exportdata[$line][] = $userdata->username;
2948                 $exportdata[$line][] = $userdata->email;
2949             }
2950             if ($time) { // Add time added / modified
2951                 $exportdata[$line][] = userdate($record->timecreated);
2952                 $exportdata[$line][] = userdate($record->timemodified);
2953             }
2954             if ($approval) { // Add approval status
2955                 $exportdata[$line][] = (int) $record->approved;
2956             }
2957         }
2958         $line++;
2959     }
2960     $line--;
2961     return $exportdata;
2964 ////////////////////////////////////////////////////////////////////////////////
2965 // File API                                                                   //
2966 ////////////////////////////////////////////////////////////////////////////////
2968 /**
2969  * Lists all browsable file areas
2970  *
2971  * @package  mod_data
2972  * @category files
2973  * @param stdClass $course course object
2974  * @param stdClass $cm course module object
2975  * @param stdClass $context context object
2976  * @return array
2977  */
2978 function data_get_file_areas($course, $cm, $context) {
2979     return array('content' => get_string('areacontent', 'mod_data'));
2982 /**
2983  * File browsing support for data module.
2984  *
2985  * @param file_browser $browser
2986  * @param array $areas
2987  * @param stdClass $course
2988  * @param cm_info $cm
2989  * @param context $context
2990  * @param string $filearea
2991  * @param int $itemid
2992  * @param string $filepath
2993  * @param string $filename
2994  * @return file_info_stored file_info_stored instance or null if not found
2995  */
2996 function data_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {
2997     global $CFG, $DB, $USER;
2999     if ($context->contextlevel != CONTEXT_MODULE) {
3000         return null;
3001     }
3003     if (!isset($areas[$filearea])) {
3004         return null;
3005     }
3007     if (is_null($itemid)) {
3008         require_once($CFG->dirroot.'/mod/data/locallib.php');
3009         return new data_file_info_container($browser, $course, $cm, $context, $areas, $filearea);
3010     }
3012     if (!$content = $DB->get_record('data_content', array('id'=>$itemid))) {
3013         return null;
3014     }
3016     if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3017         return null;
3018     }
3020     if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3021         return null;
3022     }
3024     if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3025         return null;
3026     }
3028     //check if approved
3029     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3030         return null;
3031     }
3033     // group access
3034     if ($record->groupid) {
3035         $groupmode = groups_get_activity_groupmode($cm, $course);
3036         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3037             if (!groups_is_member($record->groupid)) {
3038                 return null;
3039             }
3040         }
3041     }
3043     $fieldobj = data_get_field($field, $data, $cm);
3045     $filepath = is_null($filepath) ? '/' : $filepath;
3046     $filename = is_null($filename) ? '.' : $filename;
3047     if (!$fieldobj->file_ok($filepath.$filename)) {
3048         return null;
3049     }
3051     $fs = get_file_storage();
3052     if (!($storedfile = $fs->get_file($context->id, 'mod_data', $filearea, $itemid, $filepath, $filename))) {
3053         return null;
3054     }
3056     // Checks to see if the user can manage files or is the owner.
3057     // TODO MDL-33805 - Do not use userid here and move the capability check above.
3058     if (!has_capability('moodle/course:managefiles', $context) && $storedfile->get_userid() != $USER->id) {
3059         return null;
3060     }
3062     $urlbase = $CFG->wwwroot.'/pluginfile.php';
3064     return new file_info_stored($browser, $context, $storedfile, $urlbase, $itemid, true, true, false, false);
3067 /**
3068  * Serves the data attachments. Implements needed access control ;-)
3069  *
3070  * @package  mod_data
3071  * @category files
3072  * @param stdClass $course course object
3073  * @param stdClass $cm course module object
3074  * @param stdClass $context context object
3075  * @param string $filearea file area
3076  * @param array $args extra arguments
3077  * @param bool $forcedownload whether or not force download
3078  * @param array $options additional options affecting the file serving
3079  * @return bool false if file not found, does not return if found - justsend the file
3080  */
3081 function data_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, array $options=array()) {
3082     global $CFG, $DB;
3084     if ($context->contextlevel != CONTEXT_MODULE) {
3085         return false;
3086     }
3088     require_course_login($course, true, $cm);
3090     if ($filearea === 'content') {
3091         $contentid = (int)array_shift($args);
3093         if (!$content = $DB->get_record('data_content', array('id'=>$contentid))) {
3094             return false;
3095         }
3097         if (!$field = $DB->get_record('data_fields', array('id'=>$content->fieldid))) {
3098             return false;
3099         }
3101         if (!$record = $DB->get_record('data_records', array('id'=>$content->recordid))) {
3102             return false;
3103         }
3105         if (!$data = $DB->get_record('data', array('id'=>$field->dataid))) {
3106             return false;
3107         }
3109         if ($data->id != $cm->instance) {
3110             // hacker attempt - context does not match the contentid
3111             return false;
3112         }
3114         //check if approved
3115         if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3116             return false;
3117         }
3119         // group access
3120         if ($record->groupid) {
3121             $groupmode = groups_get_activity_groupmode($cm, $course);
3122             if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3123                 if (!groups_is_member($record->groupid)) {
3124                     return false;
3125                 }
3126             }
3127         }
3129         $fieldobj = data_get_field($field, $data, $cm);
3131         $relativepath = implode('/', $args);
3132         $fullpath = "/$context->id/mod_data/content/$content->id/$relativepath";
3134         if (!$fieldobj->file_ok($relativepath)) {
3135             return false;
3136         }
3138         $fs = get_file_storage();
3139         if (!$file = $fs->get_file_by_hash(sha1($fullpath)) or $file->is_directory()) {
3140             return false;
3141         }
3143         // finally send the file
3144         send_stored_file($file, 0, 0, true, $options); // download MUST be forced - security!
3145     }
3147     return false;
3151 function data_extend_navigation($navigation, $course, $module, $cm) {
3152     global $CFG, $OUTPUT, $USER, $DB;
3154     $rid = optional_param('rid', 0, PARAM_INT);
3156     $data = $DB->get_record('data', array('id'=>$cm->instance));
3157     $currentgroup = groups_get_activity_group($cm);
3158     $groupmode = groups_get_activity_groupmode($cm);
3160      $numentries = data_numentries($data);
3161     /// Check the number of entries required against the number of entries already made (doesn't apply to teachers)
3162     if ($data->requiredentries > 0 && $numentries < $data->requiredentries && !has_capability('mod/data:manageentries', context_module::instance($cm->id))) {
3163         $data->entriesleft = $data->requiredentries - $numentries;
3164         $entriesnode = $navigation->add(get_string('entrieslefttoadd', 'data', $data));
3165         $entriesnode->add_class('note');
3166     }
3168     $navigation->add(get_string('list', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance)));
3169     if (!empty($rid)) {
3170         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'rid'=>$rid)));
3171     } else {
3172         $navigation->add(get_string('single', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'single')));
3173     }
3174     $navigation->add(get_string('search', 'data'), new moodle_url('/mod/data/view.php', array('d'=>$cm->instance, 'mode'=>'asearch')));
3177 /**
3178  * Adds module specific settings to the settings block
3179  *
3180  * @param settings_navigation $settings The settings navigation object
3181  * @param navigation_node $datanode The node to add module settings to
3182  */
3183 function data_extend_settings_navigation(settings_navigation $settings, navigation_node $datanode) {
3184     global $PAGE, $DB, $CFG, $USER;
3186     $data = $DB->get_record('data', array("id" => $PAGE->cm->instance));
3188     $currentgroup = groups_get_activity_group($PAGE->cm);
3189     $groupmode = groups_get_activity_groupmode($PAGE->cm);
3191     if (data_user_can_add_entry($data, $currentgroup, $groupmode, $PAGE->cm->context)) { // took out participation list here!
3192         if (empty($editentry)) { //TODO: undefined
3193             $addstring = get_string('add', 'data');
3194         } else {
3195             $addstring = get_string('editentry', 'data');
3196         }
3197         $datanode->add($addstring, new moodle_url('/mod/data/edit.php', array('d'=>$PAGE->cm->instance)));
3198     }
3200     if (has_capability(DATA_CAP_EXPORT, $PAGE->cm->context)) {
3201         // The capability required to Export database records is centrally defined in 'lib.php'
3202         // and should be weaker than those required to edit Templates, Fields and Presets.
3203         $datanode->add(get_string('exportentries', 'data'), new moodle_url('/mod/data/export.php', array('d'=>$data->id)));
3204     }
3205     if (has_capability('mod/data:manageentries', $PAGE->cm->context)) {
3206         $datanode->add(get_string('importentries', 'data'), new moodle_url('/mod/data/import.php', array('d'=>$data->id)));
3207     }
3209     if (has_capability('mod/data:managetemplates', $PAGE->cm->context)) {
3210         $currenttab = '';
3211         if ($currenttab == 'list') {
3212             $defaultemplate = 'listtemplate';
3213         } else if ($currenttab == 'add') {
3214             $defaultemplate = 'addtemplate';
3215         } else if ($currenttab == 'asearch') {
3216             $defaultemplate = 'asearchtemplate';
3217         } else {
3218             $defaultemplate = 'singletemplate';
3219         }
3221         $templates = $datanode->add(get_string('templates', 'data'));
3223         $templatelist = array ('listtemplate', 'singletemplate', 'asearchtemplate', 'addtemplate', 'rsstemplate', 'csstemplate', 'jstemplate');
3224         foreach ($templatelist as $template) {
3225             $templates->add(get_string($template, 'data'), new moodle_url('/mod/data/templates.php', array('d'=>$data->id,'mode'=>$template)));
3226         }
3228         $datanode->add(get_string('fields', 'data'), new moodle_url('/mod/data/field.php', array('d'=>$data->id)));
3229         $datanode->add(get_string('presets', 'data'), new moodle_url('/mod/data/preset.php', array('d'=>$data->id)));
3230     }
3232     if (!empty($CFG->enablerssfeeds) && !empty($CFG->data_enablerssfeeds) && $data->rssarticles > 0) {
3233         require_once("$CFG->libdir/rsslib.php");
3235         $string = get_string('rsstype','forum');
3237         $url = new moodle_url(rss_get_url($PAGE->cm->context->id, $USER->id, 'mod_data', $data->id));
3238         $datanode->add($string, $url, settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
3239     }
3242 /**
3243  * Save the database configuration as a preset.
3244  *
3245  * @param stdClass $course The course the database module belongs to.
3246  * @param stdClass $cm The course module record
3247  * @param stdClass $data The database record
3248  * @param string $path
3249  * @return bool
3250  */
3251 function data_presets_save($course, $cm, $data, $path) {
3252     global $USER;
3253     $fs = get_file_storage();
3254     $filerecord = new stdClass;
3255     $filerecord->contextid = DATA_PRESET_CONTEXT;
3256     $filerecord->component = DATA_PRESET_COMPONENT;
3257     $filerecord->filearea = DATA_PRESET_FILEAREA;
3258     $filerecord->itemid = 0;
3259     $filerecord->filepath = '/'.$path.'/';
3260     $filerecord->userid = $USER->id;
3262     $filerecord->filename = 'preset.xml';
3263     $fs->create_file_from_string($filerecord, data_presets_generate_xml($course, $cm, $data));
3265     $filerecord->filename = 'singletemplate.html';
3266     $fs->create_file_from_string($filerecord, $data->singletemplate);
3268     $filerecord->filename = 'listtemplateheader.html';
3269     $fs->create_file_from_string($filerecord, $data->listtemplateheader);
3271     $filerecord->filename = 'listtemplate.html';
3272     $fs->create_file_from_string($filerecord, $data->listtemplate);
3274     $filerecord->filename = 'listtemplatefooter.html';
3275     $fs->create_file_from_string($filerecord, $data->listtemplatefooter);
3277     $filerecord->filename = 'addtemplate.html';
3278     $fs->create_file_from_string($filerecord, $data->addtemplate);
3280     $filerecord->filename = 'rsstemplate.html';
3281     $fs->create_file_from_string($filerecord, $data->rsstemplate);
3283     $filerecord->filename = 'rsstitletemplate.html';
3284     $fs->create_file_from_string($filerecord, $data->rsstitletemplate);
3286     $filerecord->filename = 'csstemplate.css';
3287     $fs->create_file_from_string($filerecord, $data->csstemplate);
3289     $filerecord->filename = 'jstemplate.js';
3290     $fs->create_file_from_string($filerecord, $data->jstemplate);
3292     $filerecord->filename = 'asearchtemplate.html';
3293     $fs->create_file_from_string($filerecord, $data->asearchtemplate);
3295     return true;
3298 /**
3299  * Generates the XML for the database module provided
3300  *
3301  * @global moodle_database $DB
3302  * @param stdClass $course The course the database module belongs to.
3303  * @param stdClass $cm The course module record
3304  * @param stdClass $data The database record
3305  * @return string The XML for the preset
3306  */
3307 function data_presets_generate_xml($course, $cm, $data) {
3308     global $DB;
3310     // Assemble "preset.xml":
3311     $presetxmldata = "<preset>\n\n";
3313     // Raw settings are not preprocessed during saving of presets
3314     $raw_settings = array(
3315         'intro',
3316         'comments',
3317         'requiredentries',
3318         'requiredentriestoview',
3319         'maxentries',
3320         'rssarticles',
3321         'approval',
3322         'defaultsortdir'
3323     );
3325     $presetxmldata .= "<settings>\n";
3326     // First, settings that do not require any conversion
3327     foreach ($raw_settings as $setting) {
3328         $presetxmldata .= "<$setting>" . htmlspecialchars($data->$setting) . "</$setting>\n";
3329     }
3331     // Now specific settings
3332     if ($data->defaultsort > 0 && $sortfield = data_get_field_from_id($data->defaultsort, $data)) {
3333         $presetxmldata .= '<defaultsort>' . htmlspecialchars($sortfield->field->name) . "</defaultsort>\n";
3334     } else {
3335         $presetxmldata .= "<defaultsort>0</defaultsort>\n";
3336     }
3337     $presetxmldata .= "</settings>\n\n";
3338     // Now for the fields. Grab all that are non-empty
3339     $fields = $DB->get_records('data_fields', array('dataid'=>$data->id));
3340     ksort($fields);
3341     if (!empty($fields)) {
3342         foreach ($fields as $field) {
3343             $presetxmldata .= "<field>\n";
3344             foreach ($field as $key => $value) {
3345                 if ($value != '' && $key != 'id' && $key != 'dataid') {
3346                     $presetxmldata .= "<$key>" . htmlspecialchars($value) . "</$key>\n";
3347                 }
3348             }
3349             $presetxmldata .= "</field>\n\n";
3350         }
3351     }
3352     $presetxmldata .= '</preset>';
3353     return $presetxmldata;
3356 function data_presets_export($course, $cm, $data, $tostorage=false) {
3357     global $CFG, $DB;
3359     $presetname = clean_filename($data->name) . '-preset-' . gmdate("Ymd_Hi");
3360     $exportsubdir = "mod_data/presetexport/$presetname";
3361     make_temp_directory($exportsubdir);
3362     $exportdir = "$CFG->tempdir/$exportsubdir";
3364     // Assemble "preset.xml":
3365     $presetxmldata = data_presets_generate_xml($course, $cm, $data);
3367     // After opening a file in write mode, close it asap
3368     $presetxmlfile = fopen($exportdir . '/preset.xml', 'w');
3369     fwrite($presetxmlfile, $presetxmldata);
3370     fclose($presetxmlfile);
3372     // Now write the template files
3373     $singletemplate = fopen($exportdir . '/singletemplate.html', 'w');
3374     fwrite($singletemplate, $data->singletemplate);
3375     fclose($singletemplate);
3377     $listtemplateheader = fopen($exportdir . '/listtemplateheader.html', 'w');
3378     fwrite($listtemplateheader, $data->listtemplateheader);
3379     fclose($listtemplateheader);
3381     $listtemplate = fopen($exportdir . '/listtemplate.html', 'w');
3382     fwrite($listtemplate, $data->listtemplate);
3383     fclose($listtemplate);
3385     $listtemplatefooter = fopen($exportdir . '/listtemplatefooter.html', 'w');
3386     fwrite($listtemplatefooter, $data->listtemplatefooter);
3387     fclose($listtemplatefooter);
3389     $addtemplate = fopen($exportdir . '/addtemplate.html', 'w');
3390     fwrite($addtemplate, $data->addtemplate);
3391     fclose($addtemplate);
3393     $rsstemplate = fopen($exportdir . '/rsstemplate.html', 'w');
3394     fwrite($rsstemplate, $data->rsstemplate);
3395     fclose($rsstemplate);
3397     $rsstitletemplate = fopen($exportdir . '/rsstitletemplate.html', 'w');
3398     fwrite($rsstitletemplate, $data->rsstitletemplate);
3399     fclose($rsstitletemplate);
3401     $csstemplate = fopen($exportdir . '/csstemplate.css', 'w');
3402     fwrite($csstemplate, $data->csstemplate);
3403     fclose($csstemplate);
3405     $jstemplate = fopen($exportdir . '/jstemplate.js', 'w');
3406     fwrite($jstemplate, $data->jstemplate);
3407     fclose($jstemplate);
3409     $asearchtemplate = fopen($exportdir . '/asearchtemplate.html', 'w');
3410     fwrite($asearchtemplate, $data->asearchtemplate);
3411     fclose($asearchtemplate);
3413     // Check if all files have been generated
3414     if (! is_directory_a_preset($exportdir)) {
3415         print_error('generateerror', 'data');
3416     }
3418     $filenames = array(
3419         'preset.xml',
3420         'singletemplate.html',
3421         'listtemplateheader.html',
3422         'listtemplate.html',
3423         'listtemplatefooter.html',
3424         'addtemplate.html',
3425         'rsstemplate.html',
3426         'rsstitletemplate.html',
3427         'csstemplate.css',
3428         'jstemplate.js',
3429         'asearchtemplate.html'
3430     );
3432     $filelist = array();
3433     foreach ($filenames as $filename) {
3434         $filelist[$filename] = $exportdir . '/' . $filename;
3435     }
3437     $exportfile = $exportdir.'.zip';
3438     file_exists($exportfile) && unlink($exportfile);
3440     $fp = get_file_packer('application/zip');
3441     $fp->archive_to_pathname($filelist, $exportfile);
3443     foreach ($filelist as $file) {
3444         unlink($file);
3445     }
3446     rmdir($exportdir);
3448     // Return the full path to the exported preset file:
3449     return $exportfile;
3452 /**
3453  * Running addtional permission check on plugin, for example, plugins
3454  * may have switch to turn on/off comments option, this callback will
3455  * affect UI display, not like pluginname_comment_validate only throw
3456  * exceptions.
3457  * Capability check has been done in comment->check_permissions(), we
3458  * don't need to do it again here.
3459  *
3460  * @package  mod_data
3461  * @category comment
3462  *
3463  * @param stdClass $comment_param {
3464  *              context  => context the context object
3465  *              courseid => int course id
3466  *              cm       => stdClass course module object
3467  *              commentarea => string comment area
3468  *              itemid      => int itemid
3469  * }
3470  * @return array
3471  */
3472 function data_comment_permissions($comment_param) {
3473     global $CFG, $DB;
3474     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3475         throw new comment_exception('invalidcommentitemid');
3476     }
3477     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3478         throw new comment_exception('invalidid', 'data');
3479     }
3480     if ($data->comments) {
3481         return array('post'=>true, 'view'=>true);
3482     } else {
3483         return array('post'=>false, 'view'=>false);
3484     }
3487 /**
3488  * Validate comment parameter before perform other comments actions
3489  *
3490  * @package  mod_data
3491  * @category comment
3492  *
3493  * @param stdClass $comment_param {
3494  *              context  => context the context object
3495  *              courseid => int course id
3496  *              cm       => stdClass course module object
3497  *              commentarea => string comment area
3498  *              itemid      => int itemid
3499  * }
3500  * @return boolean
3501  */
3502 function data_comment_validate($comment_param) {
3503     global $DB;
3504     // validate comment area
3505     if ($comment_param->commentarea != 'database_entry') {
3506         throw new comment_exception('invalidcommentarea');
3507     }
3508     // validate itemid
3509     if (!$record = $DB->get_record('data_records', array('id'=>$comment_param->itemid))) {
3510         throw new comment_exception('invalidcommentitemid');
3511     }
3512     if (!$data = $DB->get_record('data', array('id'=>$record->dataid))) {
3513         throw new comment_exception('invalidid', 'data');
3514     }
3515     if (!$course = $DB->get_record('course', array('id'=>$data->course))) {
3516         throw new comment_exception('coursemisconf');
3517     }
3518     if (!$cm = get_coursemodule_from_instance('data', $data->id, $course->id)) {
3519         throw new comment_exception('invalidcoursemodule');
3520     }
3521     if (!$data->comments) {
3522         throw new comment_exception('commentsoff', 'data');
3523     }
3524     $context = context_module::instance($cm->id);
3526     //check if approved
3527     if ($data->approval and !$record->approved and !data_isowner($record) and !has_capability('mod/data:approve', $context)) {
3528         throw new comment_exception('notapproved', 'data');
3529     }
3531     // group access
3532     if ($record->groupid) {
3533         $groupmode = groups_get_activity_groupmode($cm, $course);
3534         if ($groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $context)) {
3535             if (!groups_is_member($record->groupid)) {
3536                 throw new comment_exception('notmemberofgroup');
3537             }
3538         }
3539     }
3540     // validate context id
3541     if ($context->id != $comment_param->context->id) {
3542         throw new comment_exception('invalidcontext');
3543     }
3544     // validation for comment deletion
3545     if (!empty($comment_param->commentid)) {
3546         if ($comment = $DB->get_record('comments', array('id'=>$comment_param->commentid))) {
3547             if ($comment->commentarea != 'database_entry') {
3548                 throw new comment_exception('invalidcommentarea');
3549             }
3550             if ($comment->contextid != $comment_param->context->id) {
3551                 throw new comment_exception('invalidcontext');
3552             }
3553             if ($comment->itemid != $comment_param->itemid) {
3554                 throw new comment_exception('invalidcommentitemid');
3555             }
3556         } else {
3557             throw new comment_exception('invalidcommentid');
3558         }
3559     }
3560     return true;
3563 /**
3564  * Return a list of page types
3565  * @param string $pagetype current page type
3566  * @param stdClass $parentcontext Block's parent context
3567  * @param stdClass $currentcontext Current context of block
3568  */
3569 function data_page_type_list($pagetype, $parentcontext, $currentcontext) {
3570     $module_pagetype = array('mod-data-*'=>get_string('page-mod-data-x', 'data'));
3571     return $module_pagetype;
3574 /**
3575  * Get all of the record ids from a database activity.
3576  *
3577  * @param int    $dataid      The dataid of the database module.
3578  * @param object $selectdata  Contains an additional sql statement for the
3579  *                            where clause for group and approval fields.
3580  * @param array  $params      Parameters that coincide with the sql statement.
3581  * @return array $idarray     An array of record ids
3582  */
3583 function data_get_all_recordids($dataid, $selectdata = '', $params = null) {
3584     global $DB;
3585     $initsql = 'SELECT r.id
3586                   FROM {data_records} r
3587                  WHERE r.dataid = :dataid';
3588     if ($selectdata != '') {
3589         $initsql .= $selectdata;
3590         $params = array_merge(array('dataid' => $dataid), $params);
3591     } else {
3592         $params = array('dataid' => $dataid);
3593     }
3594     $initsql .= ' GROUP BY r.id';
3595     $initrecord = $DB->get_recordset_sql($initsql, $params);
3596     $idarray = array();
3597     foreach ($initrecord as $data) {
3598         $idarray[] = $data->id;
3599     }
3600     // Close the record set and free up resources.
3601     $initrecord->close();
3602     return $idarray;
3605 /**
3606  * Get the ids of all the records that match that advanced search criteria
3607  * This goes and loops through each criterion one at a time until it either
3608  * runs out of records or returns a subset of records.
3609  *
3610  * @param array $recordids    An array of record ids.
3611  * @param array $searcharray  Contains information for the advanced search criteria
3612  * @param int $dataid         The data id of the database.
3613  * @return array $recordids   An array of record ids.
3614  */
3615 function data_get_advance_search_ids($recordids, $searcharray, $dataid) {
3616     $searchcriteria = array_keys($searcharray);
3617     // Loop through and reduce the IDs one search criteria at a time.
3618     foreach ($searchcriteria as $key) {
3619         $recordids = data_get_recordids($key, $searcharray, $dataid, $recordids);
3620         // If we don't have anymore IDs then stop.
3621         if (!$recordids) {
3622             break;
3623         }
3624     }
3625     return $recordids;
3628 /**
3629  * Gets the record IDs given the search criteria
3630  *
3631  * @param string $alias       Record alias.
3632  * @param array $searcharray  Criteria for the search.
3633  * @param int $dataid         Data ID for the database
3634  * @param array $recordids    An array of record IDs.
3635  * @return array $nestarray   An arry of record IDs
3636  */
3637 function data_get_recordids($alias, $searcharray, $dataid, $recordids) {
3638     global $DB;
3640     $nestsearch = $searcharray[$alias];
3641     // searching for content outside of mdl_data_content
3642     if ($alias < 0) {
3643         $alias = '';
3644     }
3645     list($insql, $params) = $DB->get_in_or_equal($recordids, SQL_PARAMS_NAMED);
3646     $nestselect = 'SELECT c' . $alias . '.recordid
3647                      FROM {data_content} c' . $alias . ',
3648                           {data_fields} f,
3649                           {data_records} r,
3650                           {user} u ';
3651     $nestwhere = 'WHERE u.id = r.userid
3652                     AND f.id = c' . $alias . '.fieldid
3653                     AND r.id = c' . $alias . '.recordid
3654                     AND r.dataid = :dataid
3655                     AND c' . $alias .'.recordid ' . $insql . '
3656                     AND ';
3658     $params['dataid'] = $dataid;
3659     if (count($nestsearch->params) != 0) {
3660         $params = array_merge($params, $nestsearch->params);
3661         $nestsql = $nestselect . $nestwhere . $nestsearch->sql;
3662     } else {
3663         $thing = $DB->sql_like($nestsearch->field, ':search1', false);
3664         $nestsql = $nestselect . $nestwhere . $thing . ' GROUP BY c' . $alias . '.recordid';
3665         $params['search1'] = "%$nestsearch->data%";
3666     }
3667     $nestrecords = $DB->get_recordset_sql($nestsql, $params);
3668     $nestarray = array();
3669     foreach ($nestrecords as $data) {
3670         $nestarray[] = $data->recordid;
3671     }
3672     // Close the record set and free up resources.
3673     $nestrecords->close();
3674     return $nestarray;