mod/data/locallib.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 require_once($CFG->dirroot . '/mod/data/lib.php');
  25 require_once($CFG->libdir . '/portfolio/caller.php');
  26 require_once($CFG->libdir . '/filelib.php');
  27
  28 /**
  29  * The class to handle entry exports of a database module
  30  */
  31 class data_portfolio_caller extends portfolio_module_caller_base {
  32
  33     /** @var int the single record to export */
  34     protected $recordid;
  35
  36     /** @var object the record from the data table */
  37     private $data;
  38
  39     /**#@+ @var array the fields used and their fieldtypes */
  40     private $fields;
  41     private $fieldtypes;
  42
  43     /** @var object the records to export */
  44     private $records;
  45
  46     /** @var int how many records are 'mine' */
  47     private $minecount;
  48
  49     /**
  50      * the required callback arguments for a single-record export
  51      *
  52      * @return array
  53      */
  54     public static function expected_callbackargs() {
  55         return array(
  56             'id'       => true,
  57             'recordid' => false,
  58         );
  59     }
  60
  61     /**
  62      * @param array $callbackargs the arguments passed through
  63      */
  64     public function __construct($callbackargs) {
  65         parent::__construct($callbackargs);
  66         // set up the list of fields to export
  67         $this->selectedfields = array();
  68         foreach ($callbackargs as $key => $value) {
  69             if (strpos($key, 'field_') === 0) {
  70                 $this->selectedfields[] = substr($key, 6);
  71             }
  72         }
  73     }
  74
  75     /**
  76      * load up the data needed for the export
  77      *
  78      * @global object $DB
  79      */
  80     public function load_data() {
  81         global $DB, $USER;
  82         if (!$this->cm = get_coursemodule_from_id('data', $this->id)) {
  83             throw new portfolio_caller_exception('invalidid', 'data');
  84         }
  85         if (!$this->data = $DB->get_record('data', array('id' => $this->cm->instance))) {
  86             throw new portfolio_caller_exception('invalidid', 'data');
  87         }
  88         $fieldrecords = $DB->get_records('data_fields', array('dataid' => $this->cm->instance), 'id');
  89         // populate objets for this databases fields
  90         $this->fields = array();
  91         foreach ($fieldrecords as $fieldrecord) {
  92             $tmp = data_get_field($fieldrecord, $this->data);
  93             $this->fields[] = $tmp;
  94             $this->fieldtypes[]  = $tmp->type;
  95         }
  96
  97         $this->records = array();
  98         if ($this->recordid) {
  99             $tmp = $DB->get_record('data_records', array('id' => $this->recordid));
 100             $tmp->content = $DB->get_records('data_content', array('recordid' => $this->recordid));
 101             $this->records[] = $tmp;
 102         } else {
 103             $where = array('dataid' => $this->data->id);
 104             if (!has_capability('mod/data:exportallentries', context_module::instance($this->cm->id))) {
 105                 $where['userid'] = $USER->id; // get them all in case, we'll unset ones that aren't ours later if necessary
 106             }
 107             $tmp = $DB->get_records('data_records', $where);
 108             foreach ($tmp as $t) {
 109                 $t->content = $DB->get_records('data_content', array('recordid' => $t->id));
 110                 $this->records[] = $t;
 111             }
 112             $this->minecount = $DB->count_records('data_records', array('dataid' => $this->data->id, 'userid' => $USER->id));
 113         }
 114
 115         if ($this->recordid) {
 116             list($formats, $files) = self::formats($this->fields, $this->records[0]);
 117             $this->set_file_and_format_data($files);
 118         }
 119     }
 120
 121     /**
 122      * How long we think the export will take
 123      * Single entry is probably not too long.
 124      * But we check for filesizes
 125      * Else base it on the number of records
 126      *
 127      * @return one of PORTFOLIO_TIME_XX constants
 128      */
 129     public function expected_time() {
 130         if ($this->recordid) {
 131             return $this->expected_time_file();
 132         } else {
 133             return portfolio_expected_time_db(count($this->records));
 134         }
 135     }
 136
 137     /**
 138      * Calculate the shal1 of this export
 139      * Dependent on the export format.
 140      * @return string
 141      */
 142     public function get_sha1() {
 143         // in the case that we're exporting a subclass of 'file' and we have a singlefile,
 144         // then we're not exporting any metadata, just the file by itself by mimetype.
 145         if ($this->exporter->get('format') instanceof portfolio_format_file && $this->singlefile) {
 146             return $this->get_sha1_file();
 147         }
 148         // otherwise we're exporting some sort of multipart content so use the data
 149         $str = '';
 150         foreach ($this->records as $record) {
 151             foreach ($record as $data) {
 152                 if (is_array($data) || is_object($data)) {
 153                     $keys = array_keys($data);
 154                     $testkey = array_pop($keys);
 155                     if (is_array($data[$testkey]) || is_object($data[$testkey])) {
 156                         foreach ($data as $d) {
 157                             $str .= implode(',', (array)$d);
 158                         }
 159                     } else {
 160                         $str .= implode(',', (array)$data);
 161                     }
 162                 } else {
 163                     $str .= $data;
 164                 }
 165             }
 166         }
 167         return sha1($str . ',' . $this->exporter->get('formatclass'));
 168     }
 169
 170     /**
 171      * Prepare the package for export
 172      *
 173      * @return stored_file object
 174      */
 175     public function prepare_package() {
 176         global $DB;
 177         $leapwriter = null;
 178         $content = '';
 179         $filename = '';
 180         $uid = $this->exporter->get('user')->id;
 181         $users = array(); //cache
 182         $onlymine = $this->get_export_config('mineonly');
 183         if ($this->exporter->get('formatclass') == PORTFOLIO_FORMAT_LEAP2A) {
 184             $leapwriter = $this->exporter->get('format')->leap2a_writer();
 185             $ids = array();
 186         }
 187
 188         if ($this->exporter->get('format') instanceof portfolio_format_file && $this->singlefile) {
 189             return $this->get('exporter')->copy_existing_file($this->singlefile);
 190         }
 191         foreach ($this->records  as $key => $record) {
 192             if ($onlymine && $record->userid != $uid) {
 193                 unset($this->records[$key]); // sha1
 194                 continue;
 195             }
 196             list($tmpcontent, $files)  = $this->exportentry($record);
 197             $content .= $tmpcontent;
 198             if ($leapwriter) {
 199                 $entry = new portfolio_format_leap2a_entry('dataentry' . $record->id, $this->data->name, 'resource', $tmpcontent);
 200                 $entry->published = $record->timecreated;
 201                 $entry->updated = $record->timemodified;
 202                 if ($record->userid != $uid) {
 203                     if (!array_key_exists($record->userid, $users)) {
 204                         $users[$record->userid] = $DB->get_record('user', array('id' => $record->userid), 'id,firstname,lastname');
 205                     }
 206                     $entry->author = $users[$record->userid];
 207                 }
 208                 $ids[] = $entry->id;
 209                 $leapwriter->link_files($entry, $files, 'dataentry' . $record->id . 'file');
 210                 $leapwriter->add_entry($entry);
 211             }
 212         }
 213         if ($leapwriter) {
 214             if (count($this->records) > 1) { // make a selection element to tie them all together
 215                 $selection = new portfolio_format_leap2a_entry('datadb' . $this->data->id,
 216                     get_string('entries', 'data') . ': ' . $this->data->name, 'selection');
 217                 $leapwriter->add_entry($selection);
 218                 $leapwriter->make_selection($selection, $ids, 'Grouping');
 219             }
 220             $filename = $this->exporter->get('format')->manifest_name();
 221             $content = $leapwriter->to_xml();
 222         } else {
 223             if (count($this->records) == 1) {
 224                 $filename = clean_filename($this->cm->name . '-entry.html');
 225             } else {
 226                 $filename = clean_filename($this->cm->name . '-full.html');
 227             }
 228         }
 229         return $this->exporter->write_new_file(
 230             $content,
 231             $filename,
 232             ($this->exporter->get('format') instanceof PORTFOLIO_FORMAT_RICH) // if we have associate files, this is a 'manifest'
 233         );
 234     }
 235
 236     /**
 237      * Verify the user can still export this entry
 238      *
 239      * @return bool
 240      */
 241     public function check_permissions() {
 242         if ($this->recordid) {
 243             if (data_isowner($this->recordid)) {
 244                 return has_capability('mod/data:exportownentry', context_module::instance($this->cm->id));
 245             }
 246             return has_capability('mod/data:exportentry', context_module::instance($this->cm->id));
 247         }
 248         if ($this->has_export_config() && !$this->get_export_config('mineonly')) {
 249             return has_capability('mod/data:exportallentries', context_module::instance($this->cm->id));
 250         }
 251         return has_capability('mod/data:exportownentry', context_module::instance($this->cm->id));
 252     }
 253
 254     /**
 255      *  @return string
 256      */
 257     public static function display_name() {
 258         return get_string('modulename', 'data');
 259     }
 260
 261     /**
 262      * @global object
 263      * @return bool|void
 264      */
 265     public function __wakeup() {
 266         global $CFG;
 267         if (empty($CFG)) {
 268             return true; // too early yet
 269         }
 270         foreach ($this->fieldtypes as $key => $field) {
 271             require_once($CFG->dirroot . '/mod/data/field/' . $field .'/field.class.php');
 272             $this->fields[$key] = unserialize(serialize($this->fields[$key]));
 273         }
 274     }
 275
 276     /**
 277      * Prepare a single entry for export, replacing all the content etc
 278      *
 279      * @param stdclass $record the entry to export
 280      *
 281      * @return array with key 0 = the html content, key 1 = array of attachments
 282      */
 283     private function exportentry($record) {
 284     // Replacing tags
 285         $patterns = array();
 286         $replacement = array();
 287
 288         $files = array();
 289     // Then we generate strings to replace for normal tags
 290         $format = $this->get('exporter')->get('format');
 291         foreach ($this->fields as $field) {
 292             $patterns[]='[['.$field->field->name.']]';
 293             if (is_callable(array($field, 'get_file'))) {
 294                 if (!$file = $field->get_file($record->id)) {
 295                     $replacement[] = '';
 296                     continue; // probably left empty
 297                 }
 298                 $replacement[] = $format->file_output($file);
 299                 $this->get('exporter')->copy_existing_file($file);
 300                 $files[] = $file;
 301             } else {
 302                 $replacement[] = $field->display_browse_field($record->id, 'singletemplate');
 303             }
 304         }
 305
 306     // Replacing special tags (##Edit##, ##Delete##, ##More##)
 307         $patterns[]='##edit##';
 308         $patterns[]='##delete##';
 309         $patterns[]='##export##';
 310         $patterns[]='##more##';
 311         $patterns[]='##moreurl##';
 312         $patterns[]='##user##';
 313         $patterns[]='##approve##';
 314         $patterns[]='##disapprove##';
 315         $patterns[]='##comments##';
 316         $patterns[] = '##timeadded##';
 317         $patterns[] = '##timemodified##';
 318         $replacement[] = '';
 319         $replacement[] = '';
 320         $replacement[] = '';
 321         $replacement[] = '';
 322         $replacement[] = '';
 323         $replacement[] = '';
 324         $replacement[] = '';
 325         $replacement[] = '';
 326         $replacement[] = '';
 327         $replacement[] = userdate($record->timecreated);
 328         $replacement[] = userdate($record->timemodified);
 329
 330         // actual replacement of the tags
 331         return array(str_ireplace($patterns, $replacement, $this->data->singletemplate), $files);
 332     }
 333
 334     /**
 335      * Given the fields being exported, and the single record,
 336      * work out which export format(s) we can use
 337      *
 338      * @param array $fields array of field objects
 339      * @param object $record The data record object
 340      *
 341      * @uses PORTFOLIO_FORMAT_PLAINHTML
 342      * @uses PORTFOLIO_FORMAT_RICHHTML
 343      *
 344      * @return array of PORTFOLIO_XX constants
 345      */
 346     public static function formats($fields, $record) {
 347         $formats = array(PORTFOLIO_FORMAT_PLAINHTML);
 348         $includedfiles = array();
 349         foreach ($fields as $singlefield) {
 350             if (is_callable(array($singlefield, 'get_file'))) {
 351                 if ($file = $singlefield->get_file($record->id)) {
 352                     $includedfiles[] = $file;
 353                 }
 354             }
 355         }
 356         if (count($includedfiles) == 1 && count($fields) == 1) {
 357             $formats = array(portfolio_format_from_mimetype($includedfiles[0]->get_mimetype()));
 358         } else if (count($includedfiles) > 0) {
 359             $formats = array(PORTFOLIO_FORMAT_RICHHTML);
 360         }
 361         return array($formats, $includedfiles);
 362     }
 363
 364     public static function has_files($data) {
 365         global $DB;
 366         $fieldrecords = $DB->get_records('data_fields', array('dataid' => $data->id), 'id');
 367         // populate objets for this databases fields
 368         foreach ($fieldrecords as $fieldrecord) {
 369             $field = data_get_field($fieldrecord, $data);
 370             if (is_callable(array($field, 'get_file'))) {
 371                 return true;
 372             }
 373         }
 374         return false;
 375     }
 376
 377     /**
 378      * base supported formats before we know anything about the export
 379      */
 380     public static function base_supported_formats() {
 381         return array(PORTFOLIO_FORMAT_RICHHTML, PORTFOLIO_FORMAT_PLAINHTML, PORTFOLIO_FORMAT_LEAP2A);
 382     }
 383
 384     public function has_export_config() {
 385         // if we're exporting more than just a single entry,
 386         // and we have the capability to export all entries,
 387         // then ask whether we want just our own, or all of them
 388         return (empty($this->recordid) // multi-entry export
 389             && $this->minecount > 0    // some of them are mine
 390             && $this->minecount != count($this->records) // not all of them are mine
 391             && has_capability('mod/data:exportallentries', context_module::instance($this->cm->id))); // they actually have a choice in the matter
 392     }
 393
 394     public function export_config_form(&$mform, $instance) {
 395         if (!$this->has_export_config()) {
 396             return;
 397         }
 398         $mform->addElement('selectyesno', 'mineonly', get_string('exportownentries', 'data', (object)array('mine' => $this->minecount, 'all' => count($this->records))));
 399         $mform->setDefault('mineonly', 1);
 400     }
 401
 402     public function get_allowed_export_config() {
 403         return array('mineonly');
 404     }
 405 }
 406
 407
 408 /**
 409  * Class representing the virtual node with all itemids in the file browser
 410  *
 411  * @category  files
 412  * @copyright 2012 David Mudrak <david@moodle.com>
 413  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 414  */
 415 class data_file_info_container extends file_info {
 416     /** @var file_browser */
 417     protected $browser;
 418     /** @var stdClass */
 419     protected $course;
 420     /** @var stdClass */
 421     protected $cm;
 422     /** @var string */
 423     protected $component;
 424     /** @var stdClass */
 425     protected $context;
 426     /** @var array */
 427     protected $areas;
 428     /** @var string */
 429     protected $filearea;
 430
 431     /**
 432      * Constructor (in case you did not realize it ;-)
 433      *
 434      * @param file_browser $browser
 435      * @param stdClass $course
 436      * @param stdClass $cm
 437      * @param stdClass $context
 438      * @param array $areas
 439      * @param string $filearea
 440      */
 441     public function __construct($browser, $course, $cm, $context, $areas, $filearea) {
 442         parent::__construct($browser, $context);
 443         $this->browser = $browser;
 444         $this->course = $course;
 445         $this->cm = $cm;
 446         $this->component = 'mod_data';
 447         $this->context = $context;
 448         $this->areas = $areas;
 449         $this->filearea = $filearea;
 450     }
 451
 452     /**
 453      * @return array with keys contextid, filearea, itemid, filepath and filename
 454      */
 455     public function get_params() {
 456         return array(
 457             'contextid' => $this->context->id,
 458             'component' => $this->component,
 459             'filearea' => $this->filearea,
 460             'itemid' => null,
 461             'filepath' => null,
 462             'filename' => null,
 463         );
 464     }
 465
 466     /**
 467      * Can new files or directories be added via the file browser
 468      *
 469      * @return bool
 470      */
 471     public function is_writable() {
 472         return false;
 473     }
 474
 475     /**
 476      * Should this node be considered as a folder in the file browser
 477      *
 478      * @return bool
 479      */
 480     public function is_directory() {
 481         return true;
 482     }
 483
 484     /**
 485      * Returns localised visible name of this node
 486      *
 487      * @return string
 488      */
 489     public function get_visible_name() {
 490         return $this->areas[$this->filearea];
 491     }
 492
 493     /**
 494      * Returns list of children nodes
 495      *
 496      * @return array of file_info instances
 497      */
 498     public function get_children() {
 499         return $this->get_filtered_children('*', false, true);
 500     }
 501
 502     /**
 503      * Help function to return files matching extensions or their count
 504      *
 505      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
 506      * @param bool|int $countonly if false returns the children, if an int returns just the
 507      *    count of children but stops counting when $countonly number of children is reached
 508      * @param bool $returnemptyfolders if true returns items that don't have matching files inside
 509      * @return array|int array of file_info instances or the count
 510      */
 511     private function get_filtered_children($extensions = '*', $countonly = false, $returnemptyfolders = false) {
 512         global $DB;
 513         $params = array('contextid' => $this->context->id,
 514             'component' => $this->component,
 515             'filearea' => $this->filearea);
 516         $sql = 'SELECT DISTINCT itemid
 517                     FROM {files}
 518                     WHERE contextid = :contextid
 519                     AND component = :component
 520                     AND filearea = :filearea';
 521         if (!$returnemptyfolders) {
 522             $sql .= ' AND filename <> :emptyfilename';
 523             $params['emptyfilename'] = '.';
 524         }
 525         list($sql2, $params2) = $this->build_search_files_sql($extensions);
 526         $sql .= ' '.$sql2;
 527         $params = array_merge($params, $params2);
 528         if ($countonly === false) {
 529             $sql .= ' ORDER BY itemid DESC';
 530         }
 531
 532         $rs = $DB->get_recordset_sql($sql, $params);
 533         $children = array();
 534         foreach ($rs as $record) {
 535             if ($child = $this->browser->get_file_info($this->context, 'mod_data', $this->filearea, $record->itemid)) {
 536                 $children[] = $child;
 537             }
 538             if ($countonly !== false && count($children) >= $countonly) {
 539                 break;
 540             }
 541         }
 542         $rs->close();
 543         if ($countonly !== false) {
 544             return count($children);
 545         }
 546         return $children;
 547     }
 548
 549     /**
 550      * Returns list of children which are either files matching the specified extensions
 551      * or folders that contain at least one such file.
 552      *
 553      * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
 554      * @return array of file_info instances
 555      */
 556     public function get_non_empty_children($extensions = '*') {
 557         return $this->get_filtered_children($extensions, false);
 558     }
 559
 560     /**
 561      * Returns the number of children which are either files matching the specified extensions
 562      * or folders containing at least one such file.
 563      *
 564      * @param string|array $extensions, for example '*' or array('.gif','.jpg')
 565      * @param int $limit stop counting after at least $limit non-empty children are found
 566      * @return int
 567      */
 568     public function count_non_empty_children($extensions = '*', $limit = 1) {
 569         return $this->get_filtered_children($extensions, $limit);
 570     }
 571
 572     /**
 573      * Returns parent file_info instance
 574      *
 575      * @return file_info or null for root
 576      */
 577     public function get_parent() {
 578         return $this->browser->get_file_info($this->context);
 579     }
 580 }