lib/portfoliolib.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  * This file contains all global functions to do with manipulating portfolios
  20  * everything else that is logically namespaced by class is in its own file
  21  * in lib/portfolio/ directory.
  22  *
  23  * Major Contributors
  24  *     - Penny Leach <penny@catalyst.net.nz>
  25  *
  26  * @package    moodlecore
  27  * @subpackage portfolio
  28  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
  29  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  30  */
  31
  32 // require some of the sublibraries first.
  33 // this is not an exhaustive list, the others are pulled in as they're needed
  34 // so we don't have to always include everything unnecessarily for performance
  35
  36 // very lightweight list of constants. always needed and no further dependencies
  37 require_once($CFG->libdir . '/portfolio/constants.php');
  38 // a couple of exception deinitions. always needed and no further dependencies
  39 require_once($CFG->libdir . '/portfolio/exceptions.php');  // exception classes used by portfolio code
  40 // The base class for the caller classes. We always need this because we're either drawing a button,
  41 // in which case the button needs to know the calling class definition, which requires the base class,
  42 // or we're exporting, in which case we need the caller class anyway.
  43 require_once($CFG->libdir . '/portfolio/caller.php');
  44
  45 // the other dependencies are included on demand:
  46 // libdir/portfolio/formats.php  - the classes for the export formats
  47 // libdir/portfolio/forms.php    - all portfolio form classes (requires formslib)
  48 // libdir/portfolio/plugin.php   - the base class for the export plugins
  49 // libdir/portfolio/exporter.php - the exporter class
  50
  51
  52 /**
  53  * use this to add a portfolio button or icon or form to a page
  54  *
  55  * These class methods do not check permissions. the caller must check permissions first.
  56  * Later, during the export process, the caller class is instantiated and the check_permissions method is called
  57  * If you are exporting a single file, you should always call set_format_by_file($file)
  58  *
  59  * This class can be used like this:
  60  * <code>
  61  * $button = new portfolio_add_button();
  62  * $button->set_callback_options('name_of_caller_class', array('id' => 6), '/your/mod/lib.php');
  63  * $button->render(PORTFOLIO_ADD_FULL_FORM, get_string('addeverythingtoportfolio', 'yourmodule'));
  64  * </code>
  65  *
  66  * or like this:
  67  * <code>
  68  * $button = new portfolio_add_button(array('callbackclass' => 'name_of_caller_class', 'callbackargs' => array('id' => 6), 'callbackfile' => '/your/mod/lib.php'));
  69  * $somehtml .= $button->to_html(PORTFOLIO_ADD_TEXT_LINK);
  70  * </code>
  71  *
  72  * See {@link http://docs.moodle.org/en/Development:Adding_a_Portfolio_Button_to_a_page} for more information
  73  *
  74  * @package    moodlecore
  75  * @subpackage portfolio
  76  * @copyright 1999 onwards Martin Dougiamas  {@link http://moodle.com}
  77  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  78 */
  79 class portfolio_add_button {
  80
  81     private $callbackclass;
  82     private $callbackargs;
  83     private $callbackfile;
  84     private $formats;
  85     private $instances;
  86     private $file; // for single-file exports
  87     private $intendedmimetype; // for writing specific types of files
  88
  89     /**
  90     * constructor. either pass the options here or set them using the helper methods.
  91     * generally the code will be clearer if you use the helper methods.
  92     *
  93     * @param array $options keyed array of options:
  94     *                       key 'callbackclass': name of the caller class (eg forum_portfolio_caller')
  95     *                       key 'callbackargs': the array of callback arguments your caller class wants passed to it in the constructor
  96     *                       key 'callbackfile': the file containing the class definition of your caller class.
  97     *                       See set_callback_options for more information on these three.
  98     *                       key 'formats': an array of PORTFOLIO_FORMATS this caller will support
  99     *                       See set_formats or set_format_by_file for more information on this.
 100     */
 101     public function __construct($options=null) {
 102         global $SESSION, $CFG;
 103         $this->instances = portfolio_instances();
 104         if (empty($options)) {
 105             return true;
 106         }
 107         $constructoroptions = array('callbackclass', 'callbackargs', 'callbackfile', 'formats');
 108         foreach ((array)$options as $key => $value) {
 109             if (!in_array($key, $constructoroptions)) {
 110                 throw new portfolio_button_exception('invalidbuttonproperty', 'portfolio', $key);
 111             }
 112             $this->{$key} = $value;
 113         }
 114     }
 115
 116     /*
 117     * @param string $class   name of the class containing the callback functions
 118     *                        activity modules should ALWAYS use their name_portfolio_caller
 119     *                        other locations must use something unique
 120     * @param mixed $argarray this can be an array or hash of arguments to pass
 121     *                        back to the callback functions (passed by reference)
 122     *                        these MUST be primatives to be added as hidden form fields.
 123     *                        and the values get cleaned to PARAM_ALPHAEXT or PARAM_NUMBER or PARAM_PATH
 124     * @param string $file    this can be autodetected if it's in the same file as your caller,
 125     *                        but often, the caller is a script.php and the class in a lib.php
 126     *                        so you can pass it here if necessary.
 127     *                        this path should be relative (ie, not include) dirroot, eg '/mod/forum/lib.php'
 128     */
 129     public function set_callback_options($class, array $argarray, $file=null) {
 130         global $CFG;
 131         if (empty($file)) {
 132             $backtrace = debug_backtrace();
 133             if (!array_key_exists(0, $backtrace) || !array_key_exists('file', $backtrace[0]) || !is_readable($backtrace[0]['file'])) {
 134                 throw new portfolio_button_exception('nocallbackfile', 'portfolio');
 135             }
 136
 137             $file = substr($backtrace[0]['file'], strlen($CFG->dirroot));
 138         } else if (!is_readable($CFG->dirroot . $file)) {
 139             throw new portfolio_button_exception('nocallbackfile', 'portfolio', '', $file);
 140         }
 141         $this->callbackfile = $file;
 142         require_once($CFG->libdir . '/portfolio/caller.php'); // require the base class first
 143         require_once($CFG->dirroot . $file);
 144         if (!class_exists($class)) {
 145             throw new portfolio_button_exception('nocallbackclass', 'portfolio', '', $class);
 146         }
 147
 148         // this will throw exceptions
 149         // but should not actually do anything other than verify callbackargs
 150         $test = new $class($argarray);
 151         unset($test);
 152
 153         $this->callbackclass = $class;
 154         $this->callbackargs = $argarray;
 155     }
 156
 157     /*
 158     * sets the available export formats for this content
 159     * this function will also poll the static function in the caller class
 160     * and make sure we're not overriding a format that has nothing to do with mimetypes
 161     * eg if you pass IMAGE here but the caller can export LEAP2A it will keep LEAP2A as well.
 162     * see portfolio_most_specific_formats for more information
 163     *
 164     * @param array $formats if the calling code knows better than the static method on the calling class (base_supported_formats)
 165     *                       eg, if it's going to be a single file, or if you know it's HTML, you can pass it here instead
 166     *                       this is almost always the case so you should always use this.
 167     *                       {@see portfolio_format_from_mimetype} for how to get the appropriate formats to pass here for uploaded files.
 168     *                       or just call set_format_by_file instead
 169     */
 170     public function set_formats($formats=null) {
 171         if (is_string($formats)) {
 172             $formats = array($formats);
 173         }
 174         if (empty($formats)) {
 175             $formats = array();
 176         }
 177         if (empty($this->callbackclass)) {
 178             throw new portfolio_button_exception('noclassbeforeformats', 'portfolio');
 179         }
 180         $callerformats = call_user_func(array($this->callbackclass, 'base_supported_formats'));
 181         $this->formats = portfolio_most_specific_formats($formats, $callerformats);
 182     }
 183
 184     /**
 185      * reset formats to the default
 186      * which is usually what base_supported_formats returns
 187      */
 188     public function reset_formats() {
 189         $this->set_formats();
 190     }
 191
 192
 193     /**
 194      * if we already know we have exactly one file,
 195      * bypass set_formats and just pass the file
 196      * so we can detect the formats by mimetype.
 197      *
 198      * @param stored_file $file         file to set the format from
 199      * @param mixed       $extraformats any additional formats other than by mimetype
 200      *                                  eg leap2a etc
 201      */
 202     public function set_format_by_file(stored_file $file, $extraformats=null) {
 203         $this->file = $file;
 204         $fileformat = portfolio_format_from_mimetype($file->get_mimetype());
 205         if (is_string($extraformats)) {
 206             $extraformats = array($extraformats);
 207         } else if (!is_array($extraformats)) {
 208             $extraformats = array();
 209         }
 210         $this->set_formats(array_merge(array($fileformat), $extraformats));
 211     }
 212
 213     /**
 214      * correllary to set_format_by_file, but this is used when we don't yet have a stored_file
 215      * when we're writing out a new type of file (like csv or pdf)
 216      *
 217      * @param string $extn the file extension we intend to generate
 218      * @param mixed        $extraformats any additional formats other than by mimetype
 219      *                                  eg leap2a etc
 220      */
 221     public function set_format_by_intended_file($extn, $extraformats=null) {
 222         $mimetype = mimeinfo('type', 'something. ' . $extn);
 223         $fileformat = portfolio_format_from_mimetype($mimetype);
 224         $this->intendedmimetype = $fileformat;
 225         if (is_string($extraformats)) {
 226             $extraformats = array($extraformats);
 227         } else if (!is_array($extraformats)) {
 228             $extraformats = array();
 229         }
 230         $this->set_formats(array_merge(array($fileformat), $extraformats));
 231     }
 232
 233     /*
 234     * echo the form/button/icon/text link to the page
 235     *
 236     * @param int $format format to display the button or form or icon or link.
 237     *                    See constants PORTFOLIO_ADD_XXX for more info.
 238     *                    optional, defaults to PORTFOLI_ADD_FULL_FORM
 239     * @param str $addstr string to use for the button or icon alt text or link text.
 240     *                    this is whole string, not key.  optional, defaults to 'Add to portfolio';
 241     */
 242     public function render($format=null, $addstr=null) {
 243         echo $this->to_html($format, $addstr);
 244     }
 245
 246     /*
 247     * returns the form/button/icon/text link as html
 248     *
 249     * @param int $format format to display the button or form or icon or link.
 250     *                    See constants PORTFOLIO_ADD_XXX for more info.
 251     *                    optional, defaults to PORTFOLI_ADD_FULL_FORM
 252     * @param str $addstr string to use for the button or icon alt text or link text.
 253     *                    this is whole string, not key.  optional, defaults to 'Add to portfolio';
 254     */
 255     public function to_html($format=null, $addstr=null) {
 256         global $CFG, $COURSE, $OUTPUT, $USER;
 257         if (!$this->is_renderable()) {
 258             return;
 259         }
 260         if (empty($this->callbackclass) || empty($this->callbackfile)) {
 261             throw new portfolio_button_exception('mustsetcallbackoptions', 'portfolio');
 262         }
 263         if (empty($this->formats)) {
 264             // use the caller defaults
 265             $this->set_formats();
 266         }
 267         $url = new moodle_url('/portfolio/add.php');
 268         foreach ($this->callbackargs as $key => $value) {
 269             if (!empty($value) && !is_string($value) && !is_numeric($value)) {
 270                 $a->key = $key;
 271                 $a->value = print_r($value, true);
 272                 debugging(get_string('nonprimative', 'portfolio', $a));
 273                 return;
 274             }
 275             $url->param('ca_' . $key, $value);
 276         }
 277         $url->param('sesskey', sesskey());
 278         $url->param('callbackfile', $this->callbackfile);
 279         $url->param('callbackclass', $this->callbackclass);
 280         $url->param('course', (!empty($COURSE)) ? $COURSE->id : 0);
 281         $url->param('callerformats', implode(',', $this->formats));
 282         $mimetype = null;
 283         if ($this->file instanceof stored_file) {
 284             $mimetype = $this->file->get_mimetype();
 285         } else if ($this->intendedmimetype) {
 286             $mimetype = $this->intendedmimetype;
 287         }
 288         $selectoutput = '';
 289         if (count($this->instances) == 1) {
 290             $tmp = array_values($this->instances);
 291             $instance = $tmp[0];
 292
 293             $formats = portfolio_supported_formats_intersect($this->formats, $instance->supported_formats());
 294             if (count($formats) == 0) {
 295                 // bail. no common formats.
 296                 //debugging(get_string('nocommonformats', 'portfolio', (object)array('location' => $this->callbackclass, 'formats' => implode(',', $this->formats))));
 297                 return;
 298             }
 299             if ($error = portfolio_instance_sanity_check($instance)) {
 300                 // bail, plugin is misconfigured
 301                 //debugging(get_string('instancemisconfigured', 'portfolio', get_string($error[$instance->get('id')], 'portfolio_' . $instance->get('plugin'))));
 302                 return;
 303             }
 304             if (!$instance->allows_multiple_exports() && $already = portfolio_existing_exports($USER->id, $instance->get('plugin'))) {
 305                 //debugging(get_string('singleinstancenomultiallowed', 'portfolio'));
 306                 return;
 307             }
 308             if ($mimetype&& !$instance->file_mime_check($mimetype)) {
 309                 // bail, we have a specific file or mimetype and this plugin doesn't support it
 310                 //debugging(get_string('mimecheckfail', 'portfolio', (object)array('plugin' => $instance->get('plugin'), 'mimetype' => $mimetype)));
 311                 return;
 312             }
 313             $url->param('instance', $instance->get('id'));
 314         }
 315         else {
 316             if (!$selectoutput = portfolio_instance_select($this->instances, $this->formats, $this->callbackclass, $mimetype, 'instance', true)) {
 317                 return;
 318             }
 319         }
 320         // if we just want a url to redirect to, do it now
 321         if ($format == PORTFOLIO_ADD_FAKE_URL) {
 322             return $url->out(false);
 323         }
 324
 325         if (empty($addstr)) {
 326             $addstr = get_string('addtoportfolio', 'portfolio');
 327         }
 328         if (empty($format)) {
 329             $format = PORTFOLIO_ADD_FULL_FORM;
 330         }
 331
 332         $formoutput = '<form method="post" action="' . $CFG->wwwroot . '/portfolio/add.php" id="portfolio-add-button">' . "\n";
 333         $formoutput .= html_writer::input_hidden_params($url);
 334         $linkoutput = '<a href="' . $url->out();
 335
 336         switch ($format) {
 337             case PORTFOLIO_ADD_FULL_FORM:
 338                 $formoutput .= $selectoutput;
 339                 $formoutput .= "\n" . '<input type="submit" value="' . $addstr .'" />';
 340                 $formoutput .= "\n" . '</form>';
 341             break;
 342             case PORTFOLIO_ADD_ICON_FORM:
 343                 $formoutput .= $selectoutput;
 344                 $formoutput .= "\n" . '<input type="image" src="' . $OUTPUT->pix_url('t/portfolio') . '" alt=' . $addstr .'" />';
 345                 $formoutput .= "\n" . '</form>';
 346             break;
 347             case PORTFOLIO_ADD_ICON_LINK:
 348                 $linkoutput .= '"><img src="' . $OUTPUT->pix_url('t/portfolio') . '" alt=' . $addstr .'" /></a>';
 349             break;
 350             case PORTFOLIO_ADD_TEXT_LINK:
 351                 $linkoutput .= '">' . $addstr .'</a>';
 352             break;
 353             case PORTFOLIO_ADD_FAKE_URL:
 354                 return urldecode($linkoutput);
 355             default:
 356                 debugging(get_string('invalidaddformat', 'portfolio', $format));
 357         }
 358         $output = (in_array($format, array(PORTFOLIO_ADD_FULL_FORM, PORTFOLIO_ADD_ICON_FORM)) ? $formoutput : $linkoutput);
 359         return $output;
 360     }
 361
 362     /**
 363     * does some internal checks
 364     * these are not errors, just situations
 365     * where it's not appropriate to add the button
 366     */
 367     private function is_renderable() {
 368         global $CFG;
 369         if (empty($CFG->enableportfolios)) {
 370             return false;
 371         }
 372         if (defined('PORTFOLIO_INTERNAL')) {
 373             // something somewhere has detected a risk of this being called during inside the preparation
 374             // eg forum_print_attachments
 375             return false;
 376         }
 377         if (empty($this->instances) || count($this->instances) == 0) {
 378             return false;
 379         }
 380         return true;
 381     }
 382
 383     /**
 384      * Getter for $format property
 385      * @return array
 386      */
 387     public function get_formats() {
 388         return $this->formats;
 389     }
 390
 391     /**
 392      * Getter for $callbackargs property
 393      * @return array
 394      */
 395     public function get_callbackargs() {
 396         return $this->callbackargs;
 397     }
 398
 399     /**
 400      * Getter for $callbackfile property
 401      * @return array
 402      */
 403     public function get_callbackfile() {
 404         return $this->callbackfile;
 405     }
 406
 407     /**
 408      * Getter for $callbackclass property
 409      * @return array
 410      */
 411     public function get_callbackclass() {
 412         return $this->callbackclass;
 413     }
 414 }
 415
 416 /**
 417 * returns a drop menu with a list of available instances.
 418 *
 419 * @param array          $instances      array of portfolio plugin instance objects - the instances to put in the menu
 420 * @param array          $callerformats  array of PORTFOLIO_FORMAT_XXX constants - the formats the caller supports (this is used to filter plugins)
 421 * @param array          $callbackclass  the callback class name - used for debugging only for when there are no common formats
 422 * @param mimetype       $mimetype       if we already know we have exactly one file, or are going to write one, pass it here to do mime filtering.
 423 * @param string         $selectname     the name of the select element. Optional, defaults to instance.
 424 * @param boolean        $return         whether to print or return the output. Optional, defaults to print.
 425 * @param booealn        $returnarray    if returning, whether to return the HTML or the array of options. Optional, defaults to HTML.
 426 *
 427 * @return string the html, from <select> to </select> inclusive.
 428 */
 429 function portfolio_instance_select($instances, $callerformats, $callbackclass, $mimetype=null, $selectname='instance', $return=false, $returnarray=false) {
 430     global $CFG, $USER;
 431
 432     if (empty($CFG->enableportfolios)) {
 433         return;
 434     }
 435
 436     $insane = portfolio_instance_sanity_check();
 437     $pinsane = portfolio_plugin_sanity_check();
 438
 439     $count = 0;
 440     $selectoutput = "\n" . '<select name="' . $selectname . '">' . "\n";
 441     $existingexports = portfolio_existing_exports_by_plugin($USER->id);
 442     foreach ($instances as $instance) {
 443         $formats = portfolio_supported_formats_intersect($callerformats, $instance->supported_formats());
 444         if (count($formats) == 0) {
 445             // bail. no common formats.
 446             continue;
 447         }
 448         if (array_key_exists($instance->get('id'), $insane)) {
 449             // bail, plugin is misconfigured
 450             //debugging(get_string('instanceismisconfigured', 'portfolio', get_string($insane[$instance->get('id')], 'portfolio_' . $instance->get('plugin'))));
 451             continue;
 452         } else if (array_key_exists($instance->get('plugin'), $pinsane)) {
 453             // bail, plugin is misconfigured
 454             //debugging(get_string('pluginismisconfigured', 'portfolio', get_string($pinsane[$instance->get('plugin')], 'portfolio_' . $instance->get('plugin'))));
 455             continue;
 456         }
 457         if (!$instance->allows_multiple_exports() && in_array($instance->get('plugin'), $existingexports)) {
 458             // bail, already exporting something with this plugin and it doesn't support multiple exports
 459             continue;
 460         }
 461         if ($mimetype && !$instance->file_mime_check($mimetype)) {
 462             //debugging(get_string('mimecheckfail', 'portfolio', (object)array('plugin' => $instance->get('plugin'), 'mimetype' => $mimetype())));
 463             // bail, we have a specific file and this plugin doesn't support it
 464             continue;
 465         }
 466         $count++;
 467         $selectoutput .= "\n" . '<option value="' . $instance->get('id') . '">' . $instance->get('name') . '</option>' . "\n";
 468         $options[$instance->get('id')] = $instance->get('name');
 469     }
 470     if (empty($count)) {
 471         // bail. no common formats.
 472         //debugging(get_string('nocommonformats', 'portfolio', (object)array('location' => $callbackclass, 'formats' => implode(',', $callerformats))));
 473         return;
 474     }
 475     $selectoutput .= "\n" . "</select>\n";
 476     if (!empty($returnarray)) {
 477         return $options;
 478     }
 479     if (!empty($return)) {
 480         return $selectoutput;
 481     }
 482     echo $selectoutput;
 483 }
 484
 485 /**
 486 * return all portfolio instances
 487 *
 488 * @todo check capabilities here - see MDL-15768
 489 *
 490 * @param boolean visibleonly Don't include hidden instances. Defaults to true and will be overridden to true if the next parameter is true
 491 * @param boolean useronly    Check the visibility preferences and permissions of the logged in user. Defaults to true.
 492 *
 493 * @return array of portfolio instances (full objects, not just database records)
 494 */
 495 function portfolio_instances($visibleonly=true, $useronly=true) {
 496
 497     global $DB, $USER;
 498
 499     $values = array();
 500     $sql = 'SELECT * FROM {portfolio_instance}';
 501
 502     if ($visibleonly || $useronly) {
 503         $values[] = 1;
 504         $sql .= ' WHERE visible = ?';
 505     }
 506     if ($useronly) {
 507         $sql .= ' AND id NOT IN (
 508                 SELECT instance FROM {portfolio_instance_user}
 509                 WHERE userid = ? AND name = ? AND value = ?
 510             )';
 511         $values = array_merge($values, array($USER->id, 'visible', 0));
 512     }
 513     $sql .= ' ORDER BY name';
 514
 515     $instances = array();
 516     foreach ($DB->get_records_sql($sql, $values) as $instance) {
 517         $instances[$instance->id] = portfolio_instance($instance->id, $instance);
 518     }
 519     return $instances;
 520 }
 521
 522 /**
 523 * Supported formats currently in use.
 524 *
 525 * Canonical place for a list of all formats
 526 * that portfolio plugins and callers
 527 * can use for exporting content
 528 *
 529 * @return keyed array of all the available export formats (constant => classname)
 530 */
 531 function portfolio_supported_formats() {
 532     return array(
 533         PORTFOLIO_FORMAT_FILE         => 'portfolio_format_file',
 534         PORTFOLIO_FORMAT_IMAGE        => 'portfolio_format_image',
 535         PORTFOLIO_FORMAT_RICHHTML     => 'portfolio_format_richhtml',
 536         PORTFOLIO_FORMAT_PLAINHTML    => 'portfolio_format_plainhtml',
 537         PORTFOLIO_FORMAT_TEXT         => 'portfolio_format_text',
 538         PORTFOLIO_FORMAT_VIDEO        => 'portfolio_format_video',
 539         PORTFOLIO_FORMAT_PDF          => 'portfolio_format_pdf',
 540         PORTFOLIO_FORMAT_DOCUMENT     => 'portfolio_format_document',
 541         PORTFOLIO_FORMAT_SPREADSHEET  => 'portfolio_format_spreadsheet',
 542         PORTFOLIO_FORMAT_PRESENTATION => 'portfolio_format_presentation',
 543         /*PORTFOLIO_FORMAT_MBKP, */ // later
 544         PORTFOLIO_FORMAT_LEAP2A       => 'portfolio_format_leap2a',
 545         PORTFOLIO_FORMAT_RICH         => 'portfolio_format_rich',
 546     );
 547 }
 548
 549 /**
 550 * Deduce export format from file mimetype
 551 *
 552 * This function returns the revelant portfolio export format
 553 * which is used to determine which portfolio plugins can be used
 554 * for exporting this content
 555 * according to the given mime type
 556 * this only works when exporting exactly <b>one</b> file, or generating a new one
 557 * (like a pdf or csv export)
 558 *
 559 * @param string $mimetype (usually $file->get_mimetype())
 560 *
 561 * @return string the format constant (see PORTFOLIO_FORMAT_XXX constants)
 562 */
 563 function portfolio_format_from_mimetype($mimetype) {
 564     global $CFG;
 565     static $alreadymatched;
 566     if (empty($alreadymatched)) {
 567         $alreadymatched = array();
 568     }
 569     if (array_key_exists($mimetype, $alreadymatched)) {
 570         return $alreadymatched[$mimetype];
 571     }
 572     $allformats = portfolio_supported_formats();
 573     require_once($CFG->libdir . '/portfolio/formats.php');
 574     foreach ($allformats as $format => $classname) {
 575         $supportedmimetypes = call_user_func(array($classname, 'mimetypes'));
 576         if (!is_array($supportedmimetypes)) {
 577             debugging("one of the portfolio format classes, $classname, said it supported something funny for mimetypes, should have been array...");
 578             debugging(print_r($supportedmimetypes, true));
 579             continue;
 580         }
 581         if (in_array($mimetype, $supportedmimetypes)) {
 582             $alreadymatched[$mimetype] = $format;
 583             return $format;
 584         }
 585     }
 586     return PORTFOLIO_FORMAT_FILE; // base case for files...
 587 }
 588
 589 /**
 590 * Intersection of plugin formats and caller formats
 591 *
 592 * Walks both the caller formats and portfolio plugin formats
 593 * and looks for matches (walking the hierarchy as well)
 594 * and returns the intersection
 595 *
 596 * @param array $callerformats formats the caller supports
 597 * @param array $pluginformats formats the portfolio plugin supports
 598 */
 599 function portfolio_supported_formats_intersect($callerformats, $pluginformats) {
 600     global $CFG;
 601     $allformats = portfolio_supported_formats();
 602     $intersection = array();
 603     foreach ($callerformats as $cf) {
 604         if (!array_key_exists($cf, $allformats)) {
 605             if (!portfolio_format_is_abstract($cf)) {
 606                 debugging(get_string('invalidformat', 'portfolio', $cf));
 607             }
 608             continue;
 609         }
 610         require_once($CFG->libdir . '/portfolio/formats.php');
 611         $cfobj = new $allformats[$cf]();
 612         foreach ($pluginformats as $p => $pf) {
 613             if (!array_key_exists($pf, $allformats)) {
 614                 if (!portfolio_format_is_abstract($pf)) {
 615                     debugging(get_string('invalidformat', 'portfolio', $pf));
 616                 }
 617                 unset($pluginformats[$p]); // to avoid the same warning over and over
 618                 continue;
 619             }
 620             if ($cfobj instanceof $allformats[$pf]) {
 621                 $intersection[] = $cf;
 622             }
 623         }
 624     }
 625     return $intersection;
 626 }
 627
 628 /**
 629  * tiny helper to figure out whether a portfolio format is abstract
 630  *
 631  * @param string $format the format to test
 632  *
 633  * @retun bool
 634  */
 635 function portfolio_format_is_abstract($format) {
 636     if (class_exists($format)) {
 637         $class = $format;
 638     } else if (class_exists('portfolio_format_' . $format)) {
 639         $class = 'portfolio_format_' . $format;
 640     } else {
 641         $allformats = portfolio_supported_formats();
 642         if (array_key_exists($format, $allformats)) {
 643             $class = $allformats[$format];
 644         }
 645     }
 646     if (empty($class)) {
 647         return true; // it may as well be, we can't instantiate it :)
 648     }
 649     $rc = new ReflectionClass($class);
 650     return $rc->isAbstract();
 651 }
 652
 653 /**
 654 * return the combination of the two arrays of formats with duplicates in terms of specificity removed
 655 * and also removes conflicting formats
 656 * use case: a module is exporting a single file, so the general formats would be FILE and MBKP
 657 *           while the specific formats would be the specific subclass of FILE based on mime (say IMAGE)
 658 *           and this function would return IMAGE and MBKP
 659 *
 660 * @param array $specificformats array of more specific formats (eg based on mime detection)
 661 * @param array $generalformats  array of more general formats (usually more supported)
 662 *
 663 * @return array merged formats with dups removed
 664 */
 665 function portfolio_most_specific_formats($specificformats, $generalformats) {
 666     global $CFG;
 667     $allformats = portfolio_supported_formats();
 668     if (empty($specificformats)) {
 669         return $generalformats;
 670     } else if (empty($generalformats)) {
 671         return $specificformats;
 672     }
 673     $removedformats = array();
 674     foreach ($specificformats as $k => $f) {
 675         // look for something less specific and remove it, ie outside of the inheritance tree of the current formats.
 676         if (!array_key_exists($f, $allformats)) {
 677             if (!portfolio_format_is_abstract($f)) {
 678                 throw new portfolio_button_exception('invalidformat', 'portfolio', $f);
 679             }
 680         }
 681         if (in_array($f, $removedformats)) {
 682             // already been removed from the general list
 683             //debugging("skipping $f because it was already removed");
 684             unset($specificformats[$k]);
 685         }
 686         require_once($CFG->libdir . '/portfolio/formats.php');
 687         $fobj = new $allformats[$f];
 688         foreach ($generalformats as $key => $cf) {
 689             if (in_array($cf, $removedformats)) {
 690                 //debugging("skipping $cf because it was already removed");
 691                 continue;
 692             }
 693             $cfclass = $allformats[$cf];
 694             $cfobj = new $allformats[$cf];
 695             if ($fobj instanceof $cfclass && $cfclass != get_class($fobj)) {
 696                 //debugging("unsetting $key $cf because it's not specific enough ($f is better)");
 697                 unset($generalformats[$key]);
 698                 $removedformats[] = $cf;
 699                 continue;
 700             }
 701             // check for conflicts
 702             if ($fobj->conflicts($cf)) {
 703                 //debugging("unsetting $key $cf because it conflicts with $f");
 704                 unset($generalformats[$key]);
 705                 $removedformats[] = $cf;
 706                 continue;
 707             }
 708             if ($cfobj->conflicts($f)) {
 709                 //debugging("unsetting $key $cf because it reverse-conflicts with $f");
 710                 $removedformats[] = $cf;
 711                 unset($generalformats[$key]);
 712                 continue;
 713             }
 714         }
 715         //debugging('inside loop');
 716         //print_object($generalformats);
 717     }
 718
 719     //debugging('final formats');
 720     $finalformats =  array_unique(array_merge(array_values($specificformats), array_values($generalformats)));
 721     //print_object($finalformats);
 722     return $finalformats;
 723 }
 724
 725 /**
 726 * helper function to return a format object from the constant
 727 *
 728 * @param string $name the constant PORTFOLIO_FORMAT_XXX
 729 *
 730 * @return portfolio_format object
 731 */
 732 function portfolio_format_object($name) {
 733     global $CFG;
 734     require_once($CFG->libdir . '/portfolio/formats.php');
 735     $formats = portfolio_supported_formats();
 736     return new $formats[$name];
 737 }
 738
 739 /**
 740 * helper function to return an instance of a plugin (with config loaded)
 741 *
 742 * @param int   $instance id of instance
 743 * @param array $record   database row that corresponds to this instance
 744 *                        this is passed to avoid unnecessary lookups
 745 *                        Optional, and the record will be retrieved if null.
 746 *
 747 * @return subclass of portfolio_plugin_base
 748 */
 749 function portfolio_instance($instanceid, $record=null) {
 750     global $DB, $CFG;
 751
 752     if ($record) {
 753         $instance  = $record;
 754     } else {
 755         if (!$instance = $DB->get_record('portfolio_instance', array('id' => $instanceid))) {
 756             throw new portfolio_exception('invalidinstance', 'portfolio');
 757         }
 758     }
 759     require_once($CFG->libdir . '/portfolio/plugin.php');
 760     require_once($CFG->dirroot . '/portfolio/'. $instance->plugin . '/lib.php');
 761     $classname = 'portfolio_plugin_' . $instance->plugin;
 762     return new $classname($instanceid, $instance);
 763 }
 764
 765 /**
 766 * Helper function to call a static function on a portfolio plugin class
 767 *
 768 * This will figure out the classname and require the right file and call the function.
 769 * you can send a variable number of arguments to this function after the first two
 770 * and they will be passed on to the function you wish to call.
 771 *
 772 * @param string $plugin   name of plugin
 773 * @param string $function function to call
 774 */
 775 function portfolio_static_function($plugin, $function) {
 776     global $CFG;
 777
 778     $pname = null;
 779     if (is_object($plugin) || is_array($plugin)) {
 780         $plugin = (object)$plugin;
 781         $pname = $plugin->name;
 782     } else {
 783         $pname = $plugin;
 784     }
 785
 786     $args = func_get_args();
 787     if (count($args) <= 2) {
 788         $args = array();
 789     }
 790     else {
 791         array_shift($args);
 792         array_shift($args);
 793     }
 794
 795     require_once($CFG->libdir . '/portfolio/plugin.php');
 796     require_once($CFG->dirroot . '/portfolio/' . $plugin .  '/lib.php');
 797     return call_user_func_array(array('portfolio_plugin_' . $plugin, $function), $args);
 798 }
 799
 800 /**
 801 * helper function to check all the plugins for sanity and set any insane ones to invisible.
 802 *
 803 * @param array $plugins to check (if null, defaults to all)
 804 *               one string will work too for a single plugin.
 805 *
 806 * @return array array of insane instances (keys= id, values = reasons (keys for plugin lang)
 807 */
 808 function portfolio_plugin_sanity_check($plugins=null) {
 809     global $DB;
 810     if (is_string($plugins)) {
 811         $plugins = array($plugins);
 812     } else if (empty($plugins)) {
 813         $plugins = get_plugin_list('portfolio');
 814         $plugins = array_keys($plugins);
 815     }
 816
 817     $insane = array();
 818     foreach ($plugins as $plugin) {
 819         if ($result = portfolio_static_function($plugin, 'plugin_sanity_check')) {
 820             $insane[$plugin] = $result;
 821         }
 822     }
 823     if (empty($insane)) {
 824         return array();
 825     }
 826     list($where, $params) = $DB->get_in_or_equal(array_keys($insane));
 827     $where = ' plugin ' . $where;
 828     $DB->set_field_select('portfolio_instance', 'visible', 0, $where, $params);
 829     return $insane;
 830 }
 831
 832 /**
 833 * helper function to check all the instances for sanity and set any insane ones to invisible.
 834 *
 835 * @param array $instances to check (if null, defaults to all)
 836 *              one instance or id will work too
 837 *
 838 * @return array array of insane instances (keys= id, values = reasons (keys for plugin lang)
 839 */
 840 function portfolio_instance_sanity_check($instances=null) {
 841     global $DB;
 842     if (empty($instances)) {
 843         $instances = portfolio_instances(false);
 844     } else if (!is_array($instances)) {
 845         $instances = array($instances);
 846     }
 847
 848     $insane = array();
 849     foreach ($instances as $instance) {
 850         if (is_object($instance) && !($instance instanceof portfolio_plugin_base)) {
 851             $instance = portfolio_instance($instance->id, $instance);
 852         } else if (is_numeric($instance)) {
 853             $instance = portfolio_instance($instance);
 854         }
 855         if (!($instance instanceof portfolio_plugin_base)) {
 856             debugging('something weird passed to portfolio_instance_sanity_check, not subclass or id');
 857             continue;
 858         }
 859         if ($result = $instance->instance_sanity_check()) {
 860             $insane[$instance->get('id')] = $result;
 861         }
 862     }
 863     if (empty($insane)) {
 864         return array();
 865     }
 866     list ($where, $params) = $DB->get_in_or_equal(array_keys($insane));
 867     $where = ' id ' . $where;
 868     $DB->set_field_select('portfolio_instance', 'visible', 0, $where, $params);
 869     portfolio_insane_notify_admins($insane, true);
 870     return $insane;
 871 }
 872
 873 /**
 874 * helper function to display a table of plugins (or instances) and reasons for disabling
 875 *
 876 * @param array $insane array of insane plugins (key = plugin (or instance id), value = reason)
 877 * @param array $instances if reporting instances rather than whole plugins, pass the array (key = id, value = object) here
 878 *
 879 */
 880 function portfolio_report_insane($insane, $instances=false, $return=false) {
 881     global $OUTPUT;
 882     if (empty($insane)) {
 883         return;
 884     }
 885
 886     static $pluginstr;
 887     if (empty($pluginstr)) {
 888         $pluginstr = get_string('plugin', 'portfolio');
 889     }
 890     if ($instances) {
 891         $headerstr = get_string('someinstancesdisabled', 'portfolio');
 892     } else {
 893         $headerstr = get_string('somepluginsdisabled', 'portfolio');
 894     }
 895
 896     $output = $OUTPUT->notification($headerstr, 'notifyproblem');
 897     $table = new html_table();
 898     $table->head = array($pluginstr, '');
 899     $table->data = array();
 900     foreach ($insane as $plugin => $reason) {
 901         if ($instances) {
 902             $instance = $instances[$plugin];
 903             $plugin   = $instance->get('plugin');
 904             $name     = $instance->get('name');
 905         } else {
 906             $name = $plugin;
 907         }
 908         $table->data[] = array($name, get_string($reason, 'portfolio_' . $plugin));
 909     }
 910     $output .= html_writer::table($table);
 911     $output .= '<br /><br /><br />';
 912
 913     if ($return) {
 914         return $output;
 915     }
 916     echo $output;
 917 }
 918
 919
 920 /**
 921 * event handler for the portfolio_send event
 922 */
 923 function portfolio_handle_event($eventdata) {
 924     global $CFG;
 925
 926     require_once($CFG->libdir . '/portfolio/exporter.php');
 927     $exporter = portfolio_exporter::rewaken_object($eventdata);
 928     $exporter->process_stage_package();
 929     $exporter->process_stage_send();
 930     $exporter->save();
 931     $exporter->process_stage_cleanup();
 932     return true;
 933 }
 934
 935 /**
 936 * main portfolio cronjob
 937 * currently just cleans up expired transfer records.
 938 *
 939 * @todo add hooks in the plugins - either per instance or per plugin
 940 */
 941 function portfolio_cron() {
 942     global $DB, $CFG;
 943
 944     require_once($CFG->libdir . '/portfolio/exporter.php');
 945     if ($expired = $DB->get_records_select('portfolio_tempdata', 'expirytime < ?', array(time()), '', 'id')) {
 946         foreach ($expired as $d) {
 947             try {
 948                 $e = portfolio_exporter::rewaken_object($d->id);
 949                 $e->process_stage_cleanup(true);
 950             } catch (Exception $e) {
 951                 mtrade('Exception thrown in portfolio cron while cleaning up ' . $d->id . ': ' . $e->getMessage());
 952             }
 953         }
 954     }
 955 }
 956
 957 /**
 958  * helper function to rethrow a caught portfolio_exception as an export exception
 959  *
 960  * used because when a portfolio_export exception is thrown the export is cancelled
 961  *
 962  * throws portfolio_export_exceptiog
 963  *
 964  * @param portfolio_exporter $exporter  current exporter object
 965  * @param exception          $exception exception to rethrow
 966  *
 967  * @return void
 968  */
 969 function portfolio_export_rethrow_exception($exporter, $exception) {
 970     throw new portfolio_export_exception($exporter, $exception->errorcode, $exception->module, $exception->link, $exception->a);
 971 }
 972
 973 /**
 974 * try and determine expected_time for purely file based exports
 975 * or exports that might include large file attachments.
 976 *
 977  * @global object
 978 * @param mixed $totest - either an array of stored_file objects or a single stored_file object
 979 * @return constant PORTFOLIO_TIME_XXX
 980 */
 981 function portfolio_expected_time_file($totest) {
 982     global $CFG;
 983     if ($totest instanceof stored_file) {
 984         $totest = array($totest);
 985     }
 986     $size = 0;
 987     foreach ($totest as $file) {
 988         if (!($file instanceof stored_file)) {
 989             debugging('something weird passed to portfolio_expected_time_file - not stored_file object');
 990             debugging(print_r($file, true));
 991             continue;
 992         }
 993         $size += $file->get_filesize();
 994     }
 995
 996     $fileinfo = portfolio_filesize_info();
 997
 998     $moderate = $high = 0; // avoid warnings
 999
1000     foreach (array('moderate', 'high') as $setting) {
1001         $settingname = 'portfolio_' . $setting . '_filesize_threshold';
1002         if (empty($CFG->{$settingname}) || !array_key_exists($CFG->{$settingname}, $fileinfo['options'])) {
1003             debugging("weird or unset admin value for $settingname, using default instead");
1004             $$setting = $fileinfo[$setting];
1005         } else {
1006             $$setting = $CFG->{$settingname};
1007         }
1008     }
1009
1010     if ($size < $moderate) {
1011         return PORTFOLIO_TIME_LOW;
1012     } else if ($size < $high) {
1013         return PORTFOLIO_TIME_MODERATE;
1014     }
1015     return PORTFOLIO_TIME_HIGH;
1016 }
1017
1018
1019 /**
1020 * the default filesizes and threshold information for file based transfers
1021 * this shouldn't need to be used outside the admin pages and the portfolio code
1022 */
1023 function portfolio_filesize_info() {
1024     $filesizes = array();
1025     $sizelist = array(10240, 51200, 102400, 512000, 1048576, 2097152, 5242880, 10485760, 20971520, 52428800);
1026     foreach ($sizelist as $size) {
1027         $filesizes[$size] = display_size($size);
1028     }
1029     return array(
1030         'options' => $filesizes,
1031         'moderate' => 1048576,
1032         'high'     => 5242880,
1033     );
1034 }
1035
1036 /**
1037 * try and determine expected_time for purely database based exports
1038 * or exports that might include large parts of a database
1039 *
1040  * @global object
1041 * @param integer $recordcount - number of records trying to export
1042 * @return constant PORTFOLIO_TIME_XXX
1043 */
1044 function portfolio_expected_time_db($recordcount) {
1045     global $CFG;
1046
1047     if (empty($CFG->portfolio_moderate_dbsize_threshold)) {
1048         set_config('portfolio_moderate_dbsize_threshold', 10);
1049     }
1050     if (empty($CFG->portfolio_high_dbsize_threshold)) {
1051         set_config('portfolio_high_dbsize_threshold', 50);
1052     }
1053     if ($recordcount < $CFG->portfolio_moderate_dbsize_threshold) {
1054         return PORTFOLIO_TIME_LOW;
1055     } else if ($recordcount < $CFG->portfolio_high_dbsize_threshold) {
1056         return PORTFOLIO_TIME_MODERATE;
1057     }
1058     return PORTFOLIO_TIME_HIGH;
1059 }
1060
1061 /**
1062  * @global object
1063  */
1064 function portfolio_insane_notify_admins($insane, $instances=false) {
1065
1066     global $CFG;
1067
1068     if (defined('ADMIN_EDITING_PORTFOLIO')) {
1069         return true;
1070     }
1071
1072     $admins = get_admins();
1073
1074     if (empty($admins)) {
1075         return;
1076     }
1077     if ($instances) {
1078         $instances = portfolio_instances(false, false);
1079     }
1080
1081     $site = get_site();
1082
1083     $a = new StdClass;
1084     $a->sitename = $site->fullname;
1085     $a->fixurl   = "$CFG->wwwroot/$CFG->admin/settings.php?section=manageportfolios";
1086     $a->htmllist = portfolio_report_insane($insane, $instances, true);
1087     $a->textlist = '';
1088
1089     foreach ($insane as $k => $reason) {
1090         if ($instances) {
1091             $a->textlist = $instances[$k]->get('name') . ': ' . $reason . "\n";
1092         } else {
1093             $a->textlist = $k . ': ' . $reason . "\n";
1094         }
1095     }
1096
1097     $subject   = get_string('insanesubject', 'portfolio');
1098     $plainbody = get_string('insanebody', 'portfolio', $a);
1099     $htmlbody  = get_string('insanebodyhtml', 'portfolio', $a);
1100     $smallbody = get_string('insanebodysmall', 'portfolio', $a);
1101
1102     foreach ($admins as $admin) {
1103         $eventdata = new object();
1104         $eventdata->modulename = 'portfolio';
1105         $eventdata->component = 'portfolio';
1106         $eventdata->name = 'notices';
1107         $eventdata->userfrom = $admin;
1108         $eventdata->userto = $admin;
1109         $eventdata->subject = $subject;
1110         $eventdata->fullmessage = $plainbody;
1111         $eventdata->fullmessageformat = FORMAT_PLAIN;
1112         $eventdata->fullmessagehtml = $htmlbody;
1113         $eventdata->smallmessage = $smallbody;
1114         message_send($eventdata);
1115     }
1116 }
1117
1118 function portfolio_export_pagesetup($PAGE, $caller) {
1119     // for build navigation
1120     if (!$course = $caller->get('course')) {
1121         $course = $courseid;
1122     }
1123
1124     // set up the course so that build_navigation works nice
1125     $PAGE->set_course($course);
1126
1127     list($extranav, $cm) = $caller->get_navigation();
1128
1129     // and now we know the course for sure and maybe the cm, call require_login with it
1130     // todo this will have to change when we have things exporting content outside the course context (eg blogs)
1131     require_login($course, false, $cm);
1132
1133     foreach ($extranav as $navitem) {
1134         $PAGE->navbar->add($navitem['name']);
1135     }
1136     $PAGE->navbar->add(get_string('exporting', 'portfolio'));
1137 }
1138
1139 function portfolio_export_type_to_id($type, $userid) {
1140     global $DB;
1141     $sql = 'SELECT t.id FROM {portfolio_tempdata} t JOIN {portfolio_instance} i ON t.instance = i.id WHERE t.userid = ? AND i.plugin = ?';
1142     return $DB->get_field_sql($sql, array($userid, $type));
1143 }
1144
1145 /**
1146  * return a list of current exports for the given user
1147  * this will not go through and call rewaken_object, because it's heavy
1148  * it's really just used to figure out what exports are currently happening.
1149  * this is useful for plugins that don't support multiple exports per session
1150  *
1151  * @param int $userid  the user to check for
1152  * @param string $type (optional) the portfolio plugin to filter by
1153  *
1154  * @return array
1155  */
1156 function portfolio_existing_exports($userid, $type=null) {
1157     global $DB;
1158     $sql = 'SELECT t.*,t.instance,i.plugin,i.name FROM {portfolio_tempdata} t JOIN {portfolio_instance} i ON t.instance = i.id WHERE t.userid = ? ';
1159     $values = array($userid);
1160     if ($type) {
1161         $sql .= ' AND i.plugin = ?';
1162         $values[] = $type;
1163     }
1164     return $DB->get_records_sql($sql, $values);
1165 }
1166
1167 /**
1168  * Return an array of existing exports by type for a given user.
1169  * This is much more lightweight than {@see existing_exports} because it only returns the types, rather than the whole serialised data
1170  * so can be used for checking availability of multiple plugins at the same time.
1171  */
1172 function portfolio_existing_exports_by_plugin($userid) {
1173     global $DB;
1174     $sql = 'SELECT t.id,i.plugin FROM {portfolio_tempdata} t JOIN {portfolio_instance} i ON t.instance = i.id WHERE t.userid = ? ';
1175     $values = array($userid);
1176     return $DB->get_records_sql_menu($sql, $values);
1177 }
1178
1179
1180 /**
1181  * callback function from {@link portfolio_rewrite_pluginfile_urls}
1182  * looks through preg_replace matches and replaces content with whatever the active portfolio export format says
1183  */
1184 function portfolio_rewrite_pluginfile_url_callback($contextid,  $filearea, $itemid, $format, $options, $matches) {
1185     $matches = $matches[0]; // no internal matching
1186     $dom = new DomDocument();
1187     if (!$dom->loadXML($matches)) {
1188         return $matches;
1189     }
1190     $attributes = array();
1191     foreach ($dom->documentElement->attributes as $attr => $node) {
1192         $attributes[$attr] = $node->value;
1193     }
1194     // now figure out the file
1195     $fs = get_file_storage();
1196     $key = 'href';
1197     if (!array_key_exists('href', $attributes) && array_key_exists('src', $attributes)) {
1198         $key = 'src';
1199     }
1200     if (!array_key_exists($key, $attributes)) {
1201         debugging('Couldn\'t find an attribute to use that contains @@PLUGINFILE@@ in portfolio_rewrite_pluginfile');
1202         return $matches;
1203     }
1204     $filename = substr($attributes[$key], strpos($attributes[$key], '@@PLUGINFILE@@') + strlen('@@PLUGINFILE@@'));
1205     $filepath = '/';
1206     if (strpos($filename, '/') !== 0) {
1207         $bits = explode('/', $filename);
1208         $filename = array_pop($bits);
1209         $filepath = implode('/', $bits);
1210     }
1211     if (!$file = $fs->get_file($contextid, $filearea, $itemid, $filepath, $filename)) {
1212         debugging("Couldn\t find a file from the embedded path info context $contextid filearea $filearea itemid $itemid filepath $filepath name $filename");
1213         return $matches;
1214     }
1215     if (empty($options)) {
1216         $options = array();
1217     }
1218     $options['attributes'] = $attributes;
1219     return $format->file_output($file, $options);
1220 }
1221
1222
1223 /**
1224  * go through all the @@PLUGINFILE@@ matches in some text,
1225  * extract the file information and pass it back to the portfolio export format
1226  * to regenerate the html to output
1227  *
1228  * @param string           $text the text to search through
1229  * @param int              $contextid normal file_area arguments
1230  * @param string           $filearea  normal file_area arguments
1231  * @param int              $itemid    normal file_area arguments
1232  * @param portfolio_format $format    the portfolio export format
1233  * @param array            $options   extra options to pass through to the file_output function in the format (optional)
1234  *
1235  * @return string
1236  */
1237 function portfolio_rewrite_pluginfile_urls($text, $contextid, $filearea, $itemid, $format, $options=null) {
1238     $pattern = '/(<[^<]*?="@@PLUGINFILE@@\/[^>]*?(?:\/>|>.*?<\/[^>]*?>))/';
1239     $callback = partial('portfolio_rewrite_pluginfile_url_callback', $contextid, $filearea, $itemid, $format, $options);
1240     return preg_replace_callback($pattern, $callback, $text);
1241 }
1242 // this function has to go last, because the regexp screws up syntax highlighting in some editors
1243