mod/data/lib.php

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