Ir a la última revisión | Autoría | Comparar con el anterior | Ultima modificación | Ver Log |
<?php// This file is part of Moodle - http://moodle.org///// Moodle is free software: you can redistribute it and/or modify// it under the terms of the GNU General Public License as published by// the Free Software Foundation, either version 3 of the License, or// (at your option) any later version.//// Moodle is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.//// You should have received a copy of the GNU General Public License// along with Moodle. If not, see <http://www.gnu.org/licenses/>./*** This file contains all global functions to do with manipulating portfolios.** Everything else that is logically namespaced by class is in its own file* in lib/portfolio/ directory.** Major Contributors* - Penny Leach <penny@catalyst.net.nz>** @package core_portfolio* @category portfolio* @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later*/defined('MOODLE_INTERNAL') || die();// require some of the sublibraries first.// this is not an exhaustive list, the others are pulled in as they're needed// so we don't have to always include everything unnecessarily for performance// very lightweight list of constants. always needed and no further dependenciesrequire_once($CFG->libdir . '/portfolio/constants.php');// a couple of exception deinitions. always needed and no further dependenciesrequire_once($CFG->libdir . '/portfolio/exceptions.php'); // exception classes used by portfolio code// The base class for the caller classes. We always need this because we're either drawing a button,// in which case the button needs to know the calling class definition, which requires the base class,// or we're exporting, in which case we need the caller class anyway.require_once($CFG->libdir . '/portfolio/caller.php');// the other dependencies are included on demand:// libdir/portfolio/formats.php - the classes for the export formats// libdir/portfolio/forms.php - all portfolio form classes (requires formslib)// libdir/portfolio/plugin.php - the base class for the export plugins// libdir/portfolio/exporter.php - the exporter class/*** Use this to add a portfolio button or icon or form to a page.** These class methods do not check permissions. the caller must check permissions first.* Later, during the export process, the caller class is instantiated and the check_permissions method is called* If you are exporting a single file, you should always call set_format_by_file($file)* This class can be used like this:* <code>* $button = new portfolio_add_button();* $button->set_callback_options('name_of_caller_class', array('id' => 6), 'yourcomponent'); eg. mod_forum* $button->render(PORTFOLIO_ADD_FULL_FORM, get_string('addeverythingtoportfolio', 'yourcomponent'));* </code>* or like this:* <code>* $button = new portfolio_add_button(array('callbackclass' => 'name_of_caller_class', 'callbackargs' => array('id' => 6), 'callbackcomponent' => 'yourcomponent')); eg. mod_forum* $somehtml .= $button->to_html(PORTFOLIO_ADD_TEXT_LINK);* </code>** @package core_portfolio* @category portfolio* @copyright 1999 onwards Martin Dougiamas {@link http://moodle.com}* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later*/class portfolio_add_button {/** @var string the name of the callback functions */private $callbackclass;/** @var array can be an array of arguments to pass back to the callback functions (passed by reference)*/private $callbackargs;/** @var string caller file */private $callbackcomponent;/** @var array array of more specific formats (eg based on mime detection) */private $formats;/** @var array array of portfolio instances */private $instances;/** @var stored_file for single-file exports */private $file;/** @var string for writing specific types of files*/private $intendedmimetype;/*** Constructor. Either pass the options here or set them using the helper methods.* Generally the code will be clearer if you use the helper methods.** @param array $options keyed array of options:* key 'callbackclass': name of the caller class (eg forum_portfolio_caller')* key 'callbackargs': the array of callback arguments your caller class wants passed to it in the constructor* key 'callbackcomponent': the file containing the class definition of your caller class.* See set_callback_options for more information on these three.* key 'formats': an array of PORTFOLIO_FORMATS this caller will support* See set_formats or set_format_by_file for more information on this.*/public function __construct($options=null) {global $SESSION, $CFG;if (empty($CFG->enableportfolios)) {debugging('Building portfolio add button while portfolios is disabled. This code can be optimised.', DEBUG_DEVELOPER);}$cache = cache::make('core', 'portfolio_add_button_portfolio_instances');$instances = $cache->get('instances');if ($instances === false) {$instances = portfolio_instances();$cache->set('instances', $instances);}$this->instances = $instances;if (empty($options)) {return true;}$constructoroptions = array('callbackclass', 'callbackargs', 'callbackcomponent');foreach ((array)$options as $key => $value) {if (!in_array($key, $constructoroptions)) {throw new portfolio_button_exception('invalidbuttonproperty', 'portfolio', $key);}}$this->set_callback_options($options['callbackclass'], $options['callbackargs'], $options['callbackcomponent']);}/*** Function to set the callback options** @param string $class Name of the class containing the callback functions* activity components should ALWAYS use their name_portfolio_caller* other locations must use something unique* @param array $argarray This can be an array or hash of arguments to pass* back to the callback functions (passed by reference)* these MUST be primatives to be added as hidden form fields.* and the values get cleaned to PARAM_ALPHAEXT or PARAM_FLOAT or PARAM_PATH* @param string $component This is the name of the component in Moodle, eg 'mod_forum'*/public function set_callback_options($class, array $argarray, $component) {global $CFG;// Require the base class first before any other files.require_once($CFG->libdir . '/portfolio/caller.php');// Include any potential callback files and check for errors.portfolio_include_callback_file($component, $class);// This will throw exceptions but should not actually do anything other than verify callbackargs.$test = new $class($argarray);unset($test);$this->callbackcomponent = $component;$this->callbackclass = $class;$this->callbackargs = $argarray;}/*** Sets the available export formats for this content.* This function will also poll the static function in the caller class* and make sure we're not overriding a format that has nothing to do with mimetypes.* Eg: if you pass IMAGE here but the caller can export LEAP2A it will keep LEAP2A as well.* @see portfolio_most_specific_formats for more information* @see portfolio_format_from_mimetype** @param array $formats if the calling code knows better than the static method on the calling class (base_supported_formats).* Eg: if it's going to be a single file, or if you know it's HTML, you can pass it here instead.* This is almost always the case so it should be use all the times* portfolio_format_from_mimetype for how to get the appropriate formats to pass here for uploaded files.* or just call set_format_by_file instead*/public function set_formats($formats=null) {if (is_string($formats)) {$formats = array($formats);}if (empty($formats)) {$formats = array();}if (empty($this->callbackclass)) {throw new portfolio_button_exception('noclassbeforeformats', 'portfolio');}$callerformats = call_user_func(array($this->callbackclass, 'base_supported_formats'));$this->formats = portfolio_most_specific_formats($formats, $callerformats);}/*** Reset formats to the default,* which is usually what base_supported_formats returns*/public function reset_formats() {$this->set_formats();}/*** If we already know we have exactly one file,* bypass set_formats and just pass the file* so we can detect the formats by mimetype.** @param stored_file $file file to set the format from* @param array $extraformats any additional formats other than by mimetype* eg leap2a etc*/public function set_format_by_file(stored_file $file, $extraformats=null) {$this->file = $file;$fileformat = portfolio_format_from_mimetype($file->get_mimetype());if (is_string($extraformats)) {$extraformats = array($extraformats);} else if (!is_array($extraformats)) {$extraformats = array();}$this->set_formats(array_merge(array($fileformat), $extraformats));}/*** Correllary this is use to set_format_by_file, but it is also used when there is no stored_file and* when we're writing out a new type of file (like csv or pdf)** @param string $extn the file extension we intend to generate* @param array $extraformats any additional formats other than by mimetype* eg leap2a etc*/public function set_format_by_intended_file($extn, $extraformats=null) {$mimetype = mimeinfo('type', 'something. ' . $extn);$fileformat = portfolio_format_from_mimetype($mimetype);$this->intendedmimetype = $fileformat;if (is_string($extraformats)) {$extraformats = array($extraformats);} else if (!is_array($extraformats)) {$extraformats = array();}$this->set_formats(array_merge(array($fileformat), $extraformats));}/*** Echo the form/button/icon/text link to the page** @param int $format format to display the button or form or icon or link.* See constants PORTFOLIO_ADD_XXX for more info.* optional, defaults to PORTFOLIO_ADD_FULL_FORM* @param string $addstr string to use for the button or icon alt text or link text.* this is whole string, not key. optional, defaults to 'Export to portfolio';*/public function render($format=null, $addstr=null) {echo $this->to_html($format, $addstr);}/*** Returns the form/button/icon/text link as html** @param int $format format to display the button or form or icon or link.* See constants PORTFOLIO_ADD_XXX for more info.* Optional, defaults to PORTFOLIO_ADD_FULL_FORM* @param string $addstr string to use for the button or icon alt text or link text.* This is whole string, not key. optional, defaults to 'Add to portfolio';* @return void|string|moodle_url*/public function to_html($format=null, $addstr=null) {global $CFG, $COURSE, $OUTPUT, $USER;if (!$this->is_renderable()) {return;}if (empty($this->callbackclass) || empty($this->callbackcomponent)) {throw new portfolio_button_exception('mustsetcallbackoptions', 'portfolio');}if (empty($this->formats)) {// use the caller defaults$this->set_formats();}$url = new moodle_url('/portfolio/add.php');foreach ($this->callbackargs as $key => $value) {if (!empty($value) && !is_string($value) && !is_numeric($value)) {$a = new stdClass();$a->key = $key;$a->value = print_r($value, true);debugging(get_string('nonprimative', 'portfolio', $a));return;}$url->param('ca_' . $key, $value);}$url->param('sesskey', sesskey());$url->param('callbackcomponent', $this->callbackcomponent);$url->param('callbackclass', $this->callbackclass);$url->param('course', (!empty($COURSE)) ? $COURSE->id : 0);$url->param('callerformats', implode(',', $this->formats));$mimetype = null;if ($this->file instanceof stored_file) {$mimetype = $this->file->get_mimetype();} else if ($this->intendedmimetype) {$mimetype = $this->intendedmimetype;}$selectoutput = '';if (count($this->instances) == 1) {$tmp = array_values($this->instances);$instance = $tmp[0];$formats = portfolio_supported_formats_intersect($this->formats, $instance->supported_formats());if (count($formats) == 0) {// bail. no common formats.//debugging(get_string('nocommonformats', 'portfolio', (object)array('location' => $this->callbackclass, 'formats' => implode(',', $this->formats))));return;}if ($error = portfolio_instance_sanity_check($instance)) {// bail, plugin is misconfigured//debugging(get_string('instancemisconfigured', 'portfolio', get_string($error[$instance->get('id')], 'portfolio_' . $instance->get('plugin'))));return;}if (!$instance->allows_multiple_exports() && $already = portfolio_existing_exports($USER->id, $instance->get('plugin'))) {//debugging(get_string('singleinstancenomultiallowed', 'portfolio'));return;}if ($mimetype&& !$instance->file_mime_check($mimetype)) {// bail, we have a specific file or mimetype and this plugin doesn't support it//debugging(get_string('mimecheckfail', 'portfolio', (object)array('plugin' => $instance->get('plugin'), 'mimetype' => $mimetype)));return;}$url->param('instance', $instance->get('id'));}else {if (!$selectoutput = portfolio_instance_select($this->instances, $this->formats, $this->callbackclass, $mimetype, 'instance', true)) {return;}}// If we just want a moodle_url to redirect to, do it now.if ($format == PORTFOLIO_ADD_MOODLE_URL) {return $url;}// if we just want a url to redirect to, do it nowif ($format == PORTFOLIO_ADD_FAKE_URL) {return $url->out(false);}if (empty($addstr)) {$addstr = get_string('addtoportfolio', 'portfolio');}if (empty($format)) {$format = PORTFOLIO_ADD_FULL_FORM;}$formoutput = '<form method="post" action="' . $CFG->wwwroot . '/portfolio/add.php" id="portfolio-add-button">' . "\n";$formoutput .= html_writer::input_hidden_params($url);$linkoutput = '';switch ($format) {case PORTFOLIO_ADD_FULL_FORM:$formoutput .= $selectoutput;$formoutput .= "\n" . '<input type="submit" class="btn btn-secondary" value="' . $addstr .'" />';$formoutput .= "\n" . '</form>';break;case PORTFOLIO_ADD_ICON_FORM:$formoutput .= $selectoutput;$formoutput .= "\n" . '<button class="portfolio-add-icon">' . $OUTPUT->pix_icon('t/portfolioadd', $addstr) . '</button>';$formoutput .= "\n" . '</form>';break;case PORTFOLIO_ADD_ICON_LINK:$linkoutput = $OUTPUT->action_icon($url, new pix_icon('t/portfolioadd', $addstr, '',array('class' => 'portfolio-add-icon smallicon')));break;case PORTFOLIO_ADD_TEXT_LINK:$linkoutput = html_writer::link($url, $addstr, array('class' => 'portfolio-add-link','title' => $addstr));break;default:debugging(get_string('invalidaddformat', 'portfolio', $format));}$output = (in_array($format, array(PORTFOLIO_ADD_FULL_FORM, PORTFOLIO_ADD_ICON_FORM)) ? $formoutput : $linkoutput);return $output;}/*** Perform some internal checks.* These are not errors, just situations* where it's not appropriate to add the button** @return bool*/private function is_renderable() {global $CFG;if (empty($CFG->enableportfolios)) {return false;}if (defined('PORTFOLIO_INTERNAL')) {// something somewhere has detected a risk of this being called during inside the preparation// eg forum_print_attachmentsreturn false;}if (empty($this->instances) || count($this->instances) == 0) {return false;}return true;}/*** Getter for $format property** @return array*/public function get_formats() {return $this->formats;}/*** Getter for $callbackargs property** @return array*/public function get_callbackargs() {return $this->callbackargs;}/*** Getter for $callbackcomponent property** @return string*/public function get_callbackcomponent() {return $this->callbackcomponent;}/*** Getter for $callbackclass property** @return string*/public function get_callbackclass() {return $this->callbackclass;}}/*** Returns a drop menu with a list of available instances.** @param array $instances array of portfolio plugin instance objects - the instances to put in the menu* @param array $callerformats array of PORTFOLIO_FORMAT_XXX constants - the formats the caller supports (this is used to filter plugins)* @param string $callbackclass the callback class name - used for debugging only for when there are no common formats* @param string $mimetype if we already know we have exactly one file, or are going to write one, pass it here to do mime filtering.* @param string $selectname the name of the select element. Optional, defaults to instance.* @param bool $return whether to print or return the output. Optional, defaults to print.* @param bool $returnarray if returning, whether to return the HTML or the array of options. Optional, defaults to HTML.* @return void|array|string the html, from <select> to </select> inclusive.*/function portfolio_instance_select($instances, $callerformats, $callbackclass, $mimetype=null, $selectname='instance', $return=false, $returnarray=false) {global $CFG, $USER;if (empty($CFG->enableportfolios)) {return;}$insane = portfolio_instance_sanity_check();$pinsane = portfolio_plugin_sanity_check();$count = 0;$selectoutput = "\n" . '<label class="accesshide" for="instanceid">' . get_string('plugin', 'portfolio') . '</label>';$selectoutput .= "\n" . '<select id="instanceid" name="' . $selectname . '" class="custom-select">' . "\n";$existingexports = portfolio_existing_exports_by_plugin($USER->id);foreach ($instances as $instance) {$formats = portfolio_supported_formats_intersect($callerformats, $instance->supported_formats());if (count($formats) == 0) {// bail. no common formats.continue;}if (array_key_exists($instance->get('id'), $insane)) {// bail, plugin is misconfigured//debugging(get_string('instanceismisconfigured', 'portfolio', get_string($insane[$instance->get('id')], 'portfolio_' . $instance->get('plugin'))));continue;} else if (array_key_exists($instance->get('plugin'), $pinsane)) {// bail, plugin is misconfigured//debugging(get_string('pluginismisconfigured', 'portfolio', get_string($pinsane[$instance->get('plugin')], 'portfolio_' . $instance->get('plugin'))));continue;}if (!$instance->allows_multiple_exports() && in_array($instance->get('plugin'), $existingexports)) {// bail, already exporting something with this plugin and it doesn't support multiple exportscontinue;}if ($mimetype && !$instance->file_mime_check($mimetype)) {//debugging(get_string('mimecheckfail', 'portfolio', (object)array('plugin' => $instance->get('plugin'), 'mimetype' => $mimetype())));// bail, we have a specific file and this plugin doesn't support itcontinue;}$count++;$selectoutput .= "\n" . '<option value="' . $instance->get('id') . '">' . $instance->get('name') . '</option>' . "\n";$options[$instance->get('id')] = $instance->get('name');}if (empty($count)) {// bail. no common formats.//debugging(get_string('nocommonformats', 'portfolio', (object)array('location' => $callbackclass, 'formats' => implode(',', $callerformats))));return;}$selectoutput .= "\n" . "</select>\n";if (!empty($returnarray)) {return $options;}if (!empty($return)) {return $selectoutput;}echo $selectoutput;}/*** Return all portfolio instances** @todo MDL-15768 - check capabilities here* @param bool $visibleonly Don't include hidden instances. Defaults to true and will be overridden to true if the next parameter is true* @param bool $useronly Check the visibility preferences and permissions of the logged in user. Defaults to true.* @return array of portfolio instances (full objects, not just database records)*/function portfolio_instances($visibleonly=true, $useronly=true) {global $DB, $USER;$values = array();$sql = 'SELECT * FROM {portfolio_instance}';if ($visibleonly || $useronly) {$values[] = 1;$sql .= ' WHERE visible = ?';}if ($useronly) {$sql .= ' AND id NOT IN (SELECT instance FROM {portfolio_instance_user}WHERE userid = ? AND name = ? AND ' . $DB->sql_compare_text('value') . ' = ?)';$values = array_merge($values, array($USER->id, 'visible', 0));}$sql .= ' ORDER BY name';$instances = array();foreach ($DB->get_records_sql($sql, $values) as $instance) {$instances[$instance->id] = portfolio_instance($instance->id, $instance);}return $instances;}/*** Return whether there are visible instances in portfolio.** @return bool true when there are some visible instances.*/function portfolio_has_visible_instances() {global $DB;return $DB->record_exists('portfolio_instance', array('visible' => 1));}/*** Supported formats currently in use.* Canonical place for a list of all formats* that portfolio plugins and callers* can use for exporting content** @return array keyed array of all the available export formats (constant => classname)*/function portfolio_supported_formats() {return array(PORTFOLIO_FORMAT_FILE => 'portfolio_format_file',PORTFOLIO_FORMAT_IMAGE => 'portfolio_format_image',PORTFOLIO_FORMAT_RICHHTML => 'portfolio_format_richhtml',PORTFOLIO_FORMAT_PLAINHTML => 'portfolio_format_plainhtml',PORTFOLIO_FORMAT_TEXT => 'portfolio_format_text',PORTFOLIO_FORMAT_VIDEO => 'portfolio_format_video',PORTFOLIO_FORMAT_PDF => 'portfolio_format_pdf',PORTFOLIO_FORMAT_DOCUMENT => 'portfolio_format_document',PORTFOLIO_FORMAT_SPREADSHEET => 'portfolio_format_spreadsheet',PORTFOLIO_FORMAT_PRESENTATION => 'portfolio_format_presentation',/*PORTFOLIO_FORMAT_MBKP, */ // laterPORTFOLIO_FORMAT_LEAP2A => 'portfolio_format_leap2a',PORTFOLIO_FORMAT_RICH => 'portfolio_format_rich',);}/*** Deduce export format from file mimetype* This function returns the revelant portfolio export format* which is used to determine which portfolio plugins can be used* for exporting this content* according to the given mime type* this only works when exporting exactly <b>one</b> file, or generating a new one* (like a pdf or csv export)** @param string $mimetype (usually $file->get_mimetype())* @return string the format constant (see PORTFOLIO_FORMAT_XXX constants)*/function portfolio_format_from_mimetype($mimetype) {global $CFG;static $alreadymatched;if (empty($alreadymatched)) {$alreadymatched = array();}if (array_key_exists($mimetype, $alreadymatched)) {return $alreadymatched[$mimetype];}$allformats = portfolio_supported_formats();require_once($CFG->libdir . '/portfolio/formats.php');foreach ($allformats as $format => $classname) {$supportedmimetypes = call_user_func(array($classname, 'mimetypes'));if (!is_array($supportedmimetypes)) {debugging("one of the portfolio format classes, $classname, said it supported something funny for mimetypes, should have been array...");debugging(print_r($supportedmimetypes, true));continue;}if (in_array($mimetype, $supportedmimetypes)) {$alreadymatched[$mimetype] = $format;return $format;}}return PORTFOLIO_FORMAT_FILE; // base case for files...}/*** Intersection of plugin formats and caller formats.* Walks both the caller formats and portfolio plugin formats* and looks for matches (walking the hierarchy as well)* and returns the intersection** @param array $callerformats formats the caller supports* @param array $pluginformats formats the portfolio plugin supports* @return array*/function portfolio_supported_formats_intersect($callerformats, $pluginformats) {global $CFG;$allformats = portfolio_supported_formats();$intersection = array();foreach ($callerformats as $cf) {if (!array_key_exists($cf, $allformats)) {if (!portfolio_format_is_abstract($cf)) {debugging(get_string('invalidformat', 'portfolio', $cf));}continue;}require_once($CFG->libdir . '/portfolio/formats.php');$cfobj = new $allformats[$cf]();foreach ($pluginformats as $p => $pf) {if (!array_key_exists($pf, $allformats)) {if (!portfolio_format_is_abstract($pf)) {debugging(get_string('invalidformat', 'portfolio', $pf));}unset($pluginformats[$p]); // to avoid the same warning over and overcontinue;}if ($cfobj instanceof $allformats[$pf]) {$intersection[] = $cf;}}}return $intersection;}/*** Tiny helper to figure out whether a portfolio format is abstract** @param string $format the format to test* @return bool*/function portfolio_format_is_abstract($format) {if (class_exists($format)) {$class = $format;} else if (class_exists('portfolio_format_' . $format)) {$class = 'portfolio_format_' . $format;} else {$allformats = portfolio_supported_formats();if (array_key_exists($format, $allformats)) {$class = $allformats[$format];}}if (empty($class)) {return true; // it may as well be, we can't instantiate it :)}$rc = new ReflectionClass($class);return $rc->isAbstract();}/*** Return the combination of the two arrays of formats with duplicates in terms of specificity removed* and also removes conflicting formats.* Use case: a module is exporting a single file, so the general formats would be FILE and MBKP* while the specific formats would be the specific subclass of FILE based on mime (say IMAGE)* and this function would return IMAGE and MBKP** @param array $specificformats array of more specific formats (eg based on mime detection)* @param array $generalformats array of more general formats (usually more supported)* @return array merged formats with dups removed*/function portfolio_most_specific_formats($specificformats, $generalformats) {global $CFG;$allformats = portfolio_supported_formats();if (empty($specificformats)) {return $generalformats;} else if (empty($generalformats)) {return $specificformats;}$removedformats = array();foreach ($specificformats as $k => $f) {// look for something less specific and remove it, ie outside of the inheritance tree of the current formats.if (!array_key_exists($f, $allformats)) {if (!portfolio_format_is_abstract($f)) {throw new portfolio_button_exception('invalidformat', 'portfolio', $f);}}if (in_array($f, $removedformats)) {// already been removed from the general list//debugging("skipping $f because it was already removed");unset($specificformats[$k]);}require_once($CFG->libdir . '/portfolio/formats.php');$fobj = new $allformats[$f];foreach ($generalformats as $key => $cf) {if (in_array($cf, $removedformats)) {//debugging("skipping $cf because it was already removed");continue;}$cfclass = $allformats[$cf];$cfobj = new $allformats[$cf];if ($fobj instanceof $cfclass && $cfclass != get_class($fobj)) {//debugging("unsetting $key $cf because it's not specific enough ($f is better)");unset($generalformats[$key]);$removedformats[] = $cf;continue;}// check for conflictsif ($fobj->conflicts($cf)) {//debugging("unsetting $key $cf because it conflicts with $f");unset($generalformats[$key]);$removedformats[] = $cf;continue;}if ($cfobj->conflicts($f)) {//debugging("unsetting $key $cf because it reverse-conflicts with $f");$removedformats[] = $cf;unset($generalformats[$key]);continue;}}//debugging('inside loop');//print_object($generalformats);}//debugging('final formats');$finalformats = array_unique(array_merge(array_values($specificformats), array_values($generalformats)));//print_object($finalformats);return $finalformats;}/*** Helper function to return a format object from the constant** @param string $name the constant PORTFOLIO_FORMAT_XXX* @return portfolio_format*/function portfolio_format_object($name) {global $CFG;require_once($CFG->libdir . '/portfolio/formats.php');$formats = portfolio_supported_formats();return new $formats[$name];}/*** Helper function to return an instance of a plugin (with config loaded)** @param int $instanceid id of instance* @param object $record database row that corresponds to this instance* this is passed to avoid unnecessary lookups* Optional, and the record will be retrieved if null.* @return object of portfolio_plugin_XXX*/function portfolio_instance($instanceid, $record=null) {global $DB, $CFG;if ($record) {$instance = $record;} else {if (!$instance = $DB->get_record('portfolio_instance', array('id' => $instanceid))) {throw new portfolio_exception('invalidinstance', 'portfolio');}}require_once($CFG->libdir . '/portfolio/plugin.php');require_once($CFG->dirroot . '/portfolio/'. $instance->plugin . '/lib.php');$classname = 'portfolio_plugin_' . $instance->plugin;return new $classname($instanceid, $instance);}/*** Helper function to call a static function on a portfolio plugin class.* This will figure out the classname and require the right file and call the function.* You can send a variable number of arguments to this function after the first two* and they will be passed on to the function you wish to call.** @param string $plugin name of plugin* @param string $function function to call* @return mixed*/function portfolio_static_function($plugin, $function) {global $CFG;$pname = null;if (is_object($plugin) || is_array($plugin)) {$plugin = (object)$plugin;$pname = $plugin->name;} else {$pname = $plugin;}$args = func_get_args();if (count($args) <= 2) {$args = array();}else {array_shift($args);array_shift($args);}require_once($CFG->libdir . '/portfolio/plugin.php');require_once($CFG->dirroot . '/portfolio/' . $plugin . '/lib.php');return call_user_func_array(array('portfolio_plugin_' . $plugin, $function), $args);}/*** Helper function to check all the plugins for sanity and set any insane ones to invisible.** @param array $plugins array of supported plugin types* @return array array of insane instances (keys= id, values = reasons (keys for plugin lang)*/function portfolio_plugin_sanity_check($plugins=null) {global $DB;if (is_string($plugins)) {$plugins = array($plugins);} else if (empty($plugins)) {$plugins = core_component::get_plugin_list('portfolio');$plugins = array_keys($plugins);}$insane = array();foreach ($plugins as $plugin) {if ($result = portfolio_static_function($plugin, 'plugin_sanity_check')) {$insane[$plugin] = $result;}}if (empty($insane)) {return array();}list($where, $params) = $DB->get_in_or_equal(array_keys($insane));$where = ' plugin ' . $where;$DB->set_field_select('portfolio_instance', 'visible', 0, $where, $params);return $insane;}/*** Helper function to check all the instances for sanity and set any insane ones to invisible.** @param array $instances array of plugin instances* @return array array of insane instances (keys= id, values = reasons (keys for plugin lang)*/function portfolio_instance_sanity_check($instances=null) {global $DB;if (empty($instances)) {$instances = portfolio_instances(false);} else if (!is_array($instances)) {$instances = array($instances);}$insane = array();foreach ($instances as $instance) {if (is_object($instance) && !($instance instanceof portfolio_plugin_base)) {$instance = portfolio_instance($instance->id, $instance);} else if (is_numeric($instance)) {$instance = portfolio_instance($instance);}if (!($instance instanceof portfolio_plugin_base)) {debugging('something weird passed to portfolio_instance_sanity_check, not subclass or id');continue;}if ($result = $instance->instance_sanity_check()) {$insane[$instance->get('id')] = $result;}}if (empty($insane)) {return array();}list ($where, $params) = $DB->get_in_or_equal(array_keys($insane));$where = ' id ' . $where;$DB->set_field_select('portfolio_instance', 'visible', 0, $where, $params);portfolio_insane_notify_admins($insane, true);return $insane;}/*** Helper function to display a table of plugins (or instances) and reasons for disabling** @param array $insane array of portfolio plugin* @param array $instances if reporting instances rather than whole plugins, pass the array (key = id, value = object) here* @param bool $return option to deliver the report in html format or print it out directly to the page.* @return void|string of portfolio report in html table format*/function portfolio_report_insane($insane, $instances=false, $return=false) {global $OUTPUT;if (empty($insane)) {return;}static $pluginstr;if (empty($pluginstr)) {$pluginstr = get_string('plugin', 'portfolio');}if ($instances) {$headerstr = get_string('someinstancesdisabled', 'portfolio');} else {$headerstr = get_string('somepluginsdisabled', 'portfolio');}$output = $OUTPUT->notification($headerstr, 'notifyproblem');$table = new html_table();$table->head = array($pluginstr, '');$table->data = array();foreach ($insane as $plugin => $reason) {if ($instances) {$instance = $instances[$plugin];$plugin = $instance->get('plugin');$name = $instance->get('name');} else {$name = $plugin;}$table->data[] = array($name, get_string($reason, 'portfolio_' . $plugin));}$output .= html_writer::table($table);$output .= '<br /><br /><br />';if ($return) {return $output;}echo $output;}/*** Helper function to rethrow a caught portfolio_exception as an export exception.* Used because when a portfolio_export exception is thrown the export is cancelled* throws portfolio_export_exceptiog** @param portfolio_exporter $exporter current exporter object* @param object $exception exception to rethrow*/function portfolio_export_rethrow_exception($exporter, $exception) {throw new portfolio_export_exception($exporter, $exception->errorcode, $exception->module, $exception->link, $exception->a);}/*** Try and determine expected_time for purely file based exports* or exports that might include large file attachments.** @param stored_file|array $totest - either an array of stored_file objects or a single stored_file object* @return string PORTFOLIO_TIME_XXX*/function portfolio_expected_time_file($totest) {global $CFG;if ($totest instanceof stored_file) {$totest = array($totest);}$size = 0;foreach ($totest as $file) {if (!($file instanceof stored_file)) {debugging('something weird passed to portfolio_expected_time_file - not stored_file object');debugging(print_r($file, true));continue;}$size += $file->get_filesize();}$fileinfo = portfolio_filesize_info();$moderate = $high = 0; // avoid warningsforeach (array('moderate', 'high') as $setting) {$settingname = 'portfolio_' . $setting . '_filesize_threshold';if (empty($CFG->{$settingname}) || !array_key_exists($CFG->{$settingname}, $fileinfo['options'])) {debugging("weird or unset admin value for $settingname, using default instead");$$setting = $fileinfo[$setting];} else {$$setting = $CFG->{$settingname};}}if ($size < $moderate) {return PORTFOLIO_TIME_LOW;} else if ($size < $high) {return PORTFOLIO_TIME_MODERATE;}return PORTFOLIO_TIME_HIGH;}/*** The default filesizes and threshold information for file based transfers.* This shouldn't need to be used outside the admin pages and the portfolio code** @return array*/function portfolio_filesize_info() {$filesizes = array();$sizelist = array(10240, 51200, 102400, 512000, 1048576, 2097152, 5242880, 10485760, 20971520, 52428800);foreach ($sizelist as $size) {$filesizes[$size] = display_size($size, 0);}return array('options' => $filesizes,'moderate' => 1048576,'high' => 5242880,);}/*** Try and determine expected_time for purely database based exports* or exports that might include large parts of a database.** @param int $recordcount number of records trying to export* @return string PORTFOLIO_TIME_XXX*/function portfolio_expected_time_db($recordcount) {global $CFG;if (empty($CFG->portfolio_moderate_db_threshold)) {set_config('portfolio_moderate_db_threshold', 20);}if (empty($CFG->portfolio_high_db_threshold)) {set_config('portfolio_high_db_threshold', 50);}if ($recordcount < $CFG->portfolio_moderate_db_threshold) {return PORTFOLIO_TIME_LOW;} else if ($recordcount < $CFG->portfolio_high_db_threshold) {return PORTFOLIO_TIME_MODERATE;}return PORTFOLIO_TIME_HIGH;}/*** Function to send portfolio report to admins** @param array $insane array of insane plugins* @param bool $instances (optional) if reporting instances rather than whole plugins*/function portfolio_insane_notify_admins($insane, $instances=false) {global $CFG;if (defined('ADMIN_EDITING_PORTFOLIO')) {return true;}$admins = get_admins();if (empty($admins)) {return;}if ($instances) {$instances = portfolio_instances(false, false);}$site = get_site();$a = new StdClass;$a->sitename = format_string($site->fullname, true, array('context' => context_course::instance(SITEID)));$a->fixurl = "$CFG->wwwroot/$CFG->admin/settings.php?section=manageportfolios";$a->htmllist = portfolio_report_insane($insane, $instances, true);$a->textlist = '';foreach ($insane as $k => $reason) {if ($instances) {$a->textlist = $instances[$k]->get('name') . ': ' . $reason . "\n";} else {$a->textlist = $k . ': ' . $reason . "\n";}}$subject = get_string('insanesubject', 'portfolio');$plainbody = get_string('insanebody', 'portfolio', $a);$htmlbody = get_string('insanebodyhtml', 'portfolio', $a);$smallbody = get_string('insanebodysmall', 'portfolio', $a);foreach ($admins as $admin) {$eventdata = new \core\message\message();$eventdata->courseid = SITEID;$eventdata->modulename = 'portfolio';$eventdata->component = 'portfolio';$eventdata->name = 'notices';$eventdata->userfrom = get_admin();$eventdata->userto = $admin;$eventdata->subject = $subject;$eventdata->fullmessage = $plainbody;$eventdata->fullmessageformat = FORMAT_PLAIN;$eventdata->fullmessagehtml = $htmlbody;$eventdata->smallmessage = $smallbody;message_send($eventdata);}}/*** Setup page export** @param moodle_page $PAGE global variable from page object* @param portfolio_caller_base $caller plugin type caller*/function portfolio_export_pagesetup($PAGE, $caller) {// set up the context so that build_navigation works nice$caller->set_context($PAGE);list($extranav, $cm) = $caller->get_navigation();// and now we know the course for sure and maybe the cm, call require_login with itrequire_login($PAGE->course, false, $cm);$PAGE->activityheader->set_attrs(['description' => '','hidecompletion' => true]);foreach ($extranav as $navitem) {$PAGE->navbar->add($navitem['name']);}$PAGE->navbar->add(get_string('exporting', 'portfolio'));}/*** Get export type id** @param string $type plugin type* @param int $userid the user to check for* @return mixed|bool*/function portfolio_export_type_to_id($type, $userid) {global $DB;$sql = 'SELECT t.id FROM {portfolio_tempdata} t JOIN {portfolio_instance} i ON t.instance = i.id WHERE t.userid = ? AND i.plugin = ?';return $DB->get_field_sql($sql, array($userid, $type));}/*** Return a list of current exports for the given user.* This will not go through and call rewaken_object, because it's heavy.* It's really just used to figure out what exports are currently happening.* This is useful for plugins that don't support multiple exports per session** @param int $userid the user to check for* @param string $type (optional) the portfolio plugin to filter by* @return array*/function portfolio_existing_exports($userid, $type=null) {global $DB;$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 = ? ';$values = array($userid);if ($type) {$sql .= ' AND i.plugin = ?';$values[] = $type;}return $DB->get_records_sql($sql, $values);}/*** Return an array of existing exports by type for a given user.* This is much more lightweight than existing_exports because it only returns the types, rather than the whole serialised data* so can be used for checking availability of multiple plugins at the same time.* @see existing_exports** @param int $userid the user to check for* @return array*/function portfolio_existing_exports_by_plugin($userid) {global $DB;$sql = 'SELECT t.id,i.plugin FROM {portfolio_tempdata} t JOIN {portfolio_instance} i ON t.instance = i.id WHERE t.userid = ? ';$values = array($userid);return $DB->get_records_sql_menu($sql, $values);}/*** Return default common options for {@link format_text()} when preparing a content to be exported.* It is important not to apply filters and not to clean the HTML in format_text()** @return stdClass*/function portfolio_format_text_options() {$options = new stdClass();$options->para = false;$options->newlines = true;$options->filter = false;$options->noclean = true;$options->overflowdiv = false;return $options;}/*** callback function from {@link portfolio_rewrite_pluginfile_urls}* looks through preg_replace matches and replaces content with whatever the active portfolio export format says** @param int $contextid module context id* @param string $component module name (eg:mod_assign)* @param string $filearea normal file_area arguments* @param int $itemid component item id* @param portfolio_format $format exporter format type* @param array $options extra options to pass through to the file_output function in the format (optional)* @param array $matches internal matching* @return object|array|string*/function portfolio_rewrite_pluginfile_url_callback($contextid, $component, $filearea, $itemid, $format, $options, $matches) {$matches = $matches[0]; // No internal matching.// Loads the HTML.$dom = new DomDocument();if (!$dom->loadHTML($matches)) {return $matches;}// Navigates to the node.$xpath = new DOMXPath($dom);$nodes = $xpath->query('/html/body/child::*');if (empty($nodes) || count($nodes) > 1) {// Unexpected sequence, none or too many nodes.return $matches;}$dom = $nodes->item(0);$attributes = array();foreach ($dom->attributes as $attr => $node) {$attributes[$attr] = $node->value;}// now figure out the file$fs = get_file_storage();$key = 'href';if (!array_key_exists('href', $attributes) && array_key_exists('src', $attributes)) {$key = 'src';}if (!array_key_exists($key, $attributes)) {debugging('Couldn\'t find an attribute to use that contains @@PLUGINFILE@@ in portfolio_rewrite_pluginfile');return $matches;}$filename = substr($attributes[$key], strpos($attributes[$key], '@@PLUGINFILE@@') + strlen('@@PLUGINFILE@@'));$filepath = '/';if (strpos($filename, '/') !== 0) {$bits = explode('/', $filename);$filename = array_pop($bits);$filepath = implode('/', $bits);}if (!$file = $fs->get_file($contextid, $component, $filearea, $itemid, $filepath, urldecode($filename))) {debugging("Couldn't find a file from the embedded path info context $contextid component $component filearea $filearea itemid $itemid filepath $filepath name $filename");return $matches;}if (empty($options)) {$options = array();}$options['attributes'] = $attributes;return $format->file_output($file, $options);}/*** Function to require any potential callback files, throwing exceptions* if an issue occurs.** @param string $component This is the name of the component in Moodle, eg 'mod_forum'* @param string $class Name of the class containing the callback functions* activity components should ALWAYS use their name_portfolio_caller* other locations must use something unique*/function portfolio_include_callback_file($component, $class = null) {global $CFG;require_once($CFG->libdir . '/adminlib.php');// It's possible that they are passing a file path rather than passing a component.// We want to try and convert this to a component name, eg. mod_forum.$pos = strrpos($component, '/');if ($pos !== false) {// Get rid of the first slash (if it exists).$component = ltrim($component, '/');// Get a list of valid plugin types.$plugintypes = core_component::get_plugin_types();// Assume it is not valid for now.$isvalid = false;// Go through the plugin types.foreach ($plugintypes as $type => $path) {// Getting the path relative to the dirroot.$path = preg_replace('|^' . preg_quote($CFG->dirroot, '|') . '/|', '', $path);if (strrpos($component, $path) === 0) {// Found the plugin type.$isvalid = true;$plugintype = $type;$pluginpath = $path;}}// Throw exception if not a valid component.if (!$isvalid) {throw new coding_exception('Somehow a non-valid plugin path was passed, could be a hackz0r attempt, exiting.');}// Remove the file name.$component = trim(substr($component, 0, $pos), '/');// Replace the path with the type.$component = str_replace($pluginpath, $plugintype, $component);// Ok, replace '/' with '_'.$component = str_replace('/', '_', $component);// Place a debug message saying the third parameter should be changed.debugging('The third parameter sent to the function set_callback_options should be the component name, not a file path, please update this.', DEBUG_DEVELOPER);}// Check that it is a valid component.if (!get_component_version($component)) {throw new portfolio_button_exception('nocallbackcomponent', 'portfolio', '', $component);}// Obtain the component's location.if (!$componentloc = core_component::get_component_directory($component)) {throw new portfolio_button_exception('nocallbackcomponent', 'portfolio', '', $component);}// Check if the component contains the necessary file for the portfolio plugin.// These are locallib.php, portfoliolib.php and portfolio_callback.php.$filefound = false;if (file_exists($componentloc . '/locallib.php')) {$filefound = true;require_once($componentloc . '/locallib.php');}if (file_exists($componentloc . '/portfoliolib.php')) {$filefound = true;debugging('Please standardise your plugin by renaming your portfolio callback file to locallib.php, or if that file already exists moving the portfolio functionality there.', DEBUG_DEVELOPER);require_once($componentloc . '/portfoliolib.php');}if (file_exists($componentloc . '/portfolio_callback.php')) {$filefound = true;debugging('Please standardise your plugin by renaming your portfolio callback file to locallib.php, or if that file already exists moving the portfolio functionality there.', DEBUG_DEVELOPER);require_once($componentloc . '/portfolio_callback.php');}// Ensure that we found a file we can use, if not throw an exception.if (!$filefound) {throw new portfolio_button_exception('nocallbackfile', 'portfolio', '', $component);}if (!is_null($class)) {// If class is specified, check it exists and extends portfolio_caller_base.if (!class_exists($class) || !is_subclass_of($class, 'portfolio_caller_base')) {throw new portfolio_button_exception('nocallbackclass', 'portfolio', '', $class);}}}/*** Go through all the @@PLUGINFILE@@ matches in some text,* extract the file information and pass it back to the portfolio export format* to regenerate the html to output** @param string $text the text to search through* @param int $contextid normal file_area arguments* @param string $component module name* @param string $filearea normal file_area arguments* @param int $itemid normal file_area arguments* @param portfolio_format $format the portfolio export format* @param array $options additional options to be included in the plugin file url (optional)* @return mixed*/function portfolio_rewrite_pluginfile_urls($text, $contextid, $component, $filearea, $itemid, $format, $options=null) {$patterns = array('(<(a|A)[^<]*?href="@@PLUGINFILE@@/[^>]*?>.*?</(a|A)>)','(<(img|IMG)\s[^<]*?src="@@PLUGINFILE@@/[^>]*?/?>)',);$pattern = '~' . implode('|', $patterns) . '~';$callback = partial('portfolio_rewrite_pluginfile_url_callback', $contextid, $component, $filearea, $itemid, $format, $options);return preg_replace_callback($pattern, $callback, $text);}// this function has to go last, because the regexp screws up syntax highlighting in some editors