mirror of
https://github.com/moodle/moodle.git
synced 2025-01-17 13:38:32 +01:00
fcfe8ceef1
Due to missing `AND k.script = 'rss'` condition, the query did not make use of the existing script-value compound index defined for the table. So it had to perform the full sequential scan for all rows when searching for the token. This had serious performance issues on sites with many users, especially in case on non-existing token / key.
536 lines
18 KiB
PHP
536 lines
18 KiB
PHP
<?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 the common stuff to be used in RSS System
|
|
*
|
|
* @package core_rss
|
|
* @category rss
|
|
* @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();
|
|
|
|
/**
|
|
* Build the URL for the RSS feed and add it as a header
|
|
*
|
|
* @param stdClass $context The context under which the URL should be created
|
|
* @param string $componentname The name of the component for which the RSS feed exists
|
|
* @param stdClass $componentinstance The instance of the component
|
|
* @param string $title Name for the link to be added to the page header
|
|
*/
|
|
function rss_add_http_header($context, $componentname, $componentinstance, $title) {
|
|
global $PAGE, $USER;
|
|
|
|
$componentid = null;
|
|
if (is_object($componentinstance)) {
|
|
$componentid = $componentinstance->id;
|
|
} else {
|
|
$componentid = $componentinstance;
|
|
}
|
|
|
|
$rsspath = rss_get_url($context->id, $USER->id, $componentname, $componentid);
|
|
$PAGE->add_alternate_version($title, $rsspath, 'application/rss+xml');
|
|
}
|
|
|
|
/**
|
|
* Print the link for the RSS feed with the correct RSS icon
|
|
*
|
|
* @param stdClass $contextid The id of the context under which the URL should be created
|
|
* @param int $userid The source of the RSS feed (site/course/group/user)
|
|
* @param string $componentname The name of the component for which the feed exists
|
|
* @param string $id The name by which to call the RSS File
|
|
* @param string $tooltiptext The tooltip to be displayed with the link
|
|
* @return string HTML output for the RSS link
|
|
*/
|
|
function rss_get_link($contextid, $userid, $componentname, $id, $tooltiptext='') {
|
|
global $OUTPUT;
|
|
|
|
static $rsspath = '';
|
|
|
|
$rsspath = rss_get_url($contextid, $userid, $componentname, $id);
|
|
|
|
return '<a href="'. $rsspath .'">' . $OUTPUT->pix_icon('i/rss', $tooltiptext) . '</a>';
|
|
}
|
|
|
|
/**
|
|
* This function returns the URL for the RSS XML file.
|
|
*
|
|
* @param int $contextid the course id
|
|
* @param int $userid the current user id
|
|
* @param string $componentname the name of the current component. For example "forum"
|
|
* @param string $additionalargs For modules, module instance id
|
|
* @return string the url of the RSS feed
|
|
*/
|
|
function rss_get_url($contextid, $userid, $componentname, $additionalargs) {
|
|
global $CFG;
|
|
if (empty($userid)) {
|
|
$userid = guest_user()->id;
|
|
}
|
|
$usertoken = rss_get_token($userid);
|
|
$url = '/rss/file.php';
|
|
return moodle_url::make_file_url($url, '/'.$contextid.'/'.$usertoken.'/'.$componentname.'/'.$additionalargs.'/rss.xml');
|
|
}
|
|
|
|
/**
|
|
* Print the link for the RSS feed with the correct RSS icon (Theme based)
|
|
*
|
|
* @param stdClass $contextid The id of the context under which the URL should be created
|
|
* @param int $userid The source of the RSS feed (site/course/group/user)
|
|
* @param string $componentname The name of the component for which the feed exists
|
|
* @param string $id The name by which to call the RSS File
|
|
* @param string $tooltiptext The tooltip to be displayed with the link
|
|
*/
|
|
function rss_print_link($contextid, $userid, $componentname, $id, $tooltiptext='') {
|
|
print rss_get_link($contextid, $userid, $componentname, $id, $tooltiptext);
|
|
|
|
}
|
|
|
|
/**
|
|
* Given an object, deletes all RSS files associated with it.
|
|
*
|
|
* @param string $componentname the name of the module ie 'forum'. Used to construct the cache path.
|
|
* @param stdClass $instance An object with an id member variable ie $forum, $glossary.
|
|
*/
|
|
function rss_delete_file($componentname, $instance) {
|
|
global $CFG;
|
|
|
|
$dirpath = "$CFG->cachedir/rss/$componentname";
|
|
if (is_dir($dirpath)) {
|
|
if (!$dh = opendir($dirpath)) {
|
|
error_log("Directory permission error. RSS directory store for component '{$componentname}' exists but cannot be opened.", DEBUG_DEVELOPER);
|
|
return;
|
|
}
|
|
while (false !== ($filename = readdir($dh))) {
|
|
if ($filename!='.' && $filename!='..') {
|
|
if (preg_match("/{$instance->id}_/", $filename)) {
|
|
unlink("$dirpath/$filename");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Are RSS feeds enabled for the supplied module instance?
|
|
*
|
|
* @param string $modname The name of the module to be checked
|
|
* @param stdClass $instance An instance of an activity module ie $forum, $glossary.
|
|
* @param bool $hasrsstype Should there be a rsstype member variable?
|
|
* @param bool $hasrssarticles Should there be a rssarticles member variable?
|
|
* @return bool whether or not RSS is enabled for the module
|
|
*/
|
|
function rss_enabled_for_mod($modname, $instance=null, $hasrsstype=true, $hasrssarticles=true) {
|
|
if ($hasrsstype) {
|
|
if (empty($instance->rsstype) || $instance->rsstype==0) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//have they set the RSS feed to return 0 results?
|
|
if ($hasrssarticles) {
|
|
if (empty($instance->rssarticles) || $instance->rssarticles==0) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!empty($instance) && !instance_is_visible($modname,$instance)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This function saves to file the rss feed specified in the parameters
|
|
*
|
|
* @param string $componentname the module name ie forum. Used to create a cache directory.
|
|
* @param string $filename the name of the file to be created ie "rss.xml"
|
|
* @param string $contents the data to be written to the file
|
|
* @param bool $expandfilename whether or not the fullname of the RSS file should be used
|
|
* @return bool whether the save was successful or not
|
|
*/
|
|
function rss_save_file($componentname, $filename, $contents, $expandfilename=true) {
|
|
global $CFG;
|
|
|
|
$status = true;
|
|
|
|
if (! $basedir = make_cache_directory ('rss/'. $componentname)) {
|
|
//Cannot be created, so error
|
|
$status = false;
|
|
}
|
|
|
|
if ($status) {
|
|
$fullfilename = $filename;
|
|
if ($expandfilename) {
|
|
$fullfilename = rss_get_file_full_name($componentname, $filename);
|
|
}
|
|
|
|
$rss_file = fopen($fullfilename, "w");
|
|
if ($rss_file) {
|
|
$status = fwrite ($rss_file, $contents);
|
|
fclose($rss_file);
|
|
} else {
|
|
$status = false;
|
|
}
|
|
}
|
|
return $status;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the location and file name of a cached RSS feed
|
|
*
|
|
* @param string $componentname the name of the component the RSS feed is being created for
|
|
* @param string $filename the name of the RSS FEED
|
|
* @return string The full name and path of the RSS file
|
|
*/
|
|
function rss_get_file_full_name($componentname, $filename) {
|
|
global $CFG;
|
|
return "$CFG->cachedir/rss/$componentname/$filename.xml";
|
|
}
|
|
|
|
/**
|
|
* Construct the file name of the RSS File
|
|
*
|
|
* @param stdClass $instance the instance of the source of the RSS feed
|
|
* @param string $sql the SQL used to produce the RSS feed
|
|
* @param array $params the parameters used in the SQL query
|
|
* @return string the name of the RSS file
|
|
*/
|
|
function rss_get_file_name($instance, $sql, $params = array()) {
|
|
if ($params) {
|
|
// If a parameters array is passed, then we want to
|
|
// serialize it and then concatenate it with the sql.
|
|
// The reason for this is to generate a unique filename
|
|
// for queries using the same sql but different parameters.
|
|
asort($params);
|
|
$serializearray = serialize($params);
|
|
return $instance->id.'_'.md5($sql . $serializearray);
|
|
} else {
|
|
return $instance->id.'_'.md5($sql);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function return all the common headers for every rss feed in the site
|
|
*
|
|
* @param string $title the title for the RSS Feed
|
|
* @param string $link the link for the origin of the RSS feed
|
|
* @param string $description the description of the contents of the RSS feed
|
|
* @return bool|string the standard header for the RSS feed
|
|
*/
|
|
function rss_standard_header($title = NULL, $link = NULL, $description = NULL) {
|
|
global $CFG, $USER, $OUTPUT;
|
|
|
|
$status = true;
|
|
$result = "";
|
|
|
|
$site = get_site();
|
|
|
|
if ($status) {
|
|
|
|
//Calculate title, link and description
|
|
if (empty($title)) {
|
|
$title = format_string($site->fullname);
|
|
}
|
|
if (empty($link)) {
|
|
$link = $CFG->wwwroot;
|
|
}
|
|
if (empty($description)) {
|
|
$description = $site->summary;
|
|
}
|
|
|
|
//xml headers
|
|
$result .= "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
|
|
$result .= "<rss version=\"2.0\">\n";
|
|
|
|
//open the channel
|
|
$result .= rss_start_tag('channel', 1, true);
|
|
|
|
//write channel info
|
|
$result .= rss_full_tag('title', 2, false, strip_tags($title));
|
|
$result .= rss_full_tag('link', 2, false, $link);
|
|
$result .= rss_full_tag('description', 2, false, $description);
|
|
$result .= rss_full_tag('generator', 2, false, 'Moodle');
|
|
if (!empty($USER->lang)) {
|
|
$result .= rss_full_tag('language', 2, false, substr($USER->lang,0,2));
|
|
}
|
|
$today = getdate();
|
|
$result .= rss_full_tag('copyright', 2, false, '(c) '. $today['year'] .' '. format_string($site->fullname));
|
|
/*
|
|
if (!empty($USER->email)) {
|
|
$result .= rss_full_tag('managingEditor', 2, false, fullname($USER));
|
|
$result .= rss_full_tag('webMaster', 2, false, fullname($USER));
|
|
}
|
|
*/
|
|
|
|
//write image info
|
|
$rsspix = $OUTPUT->image_url('i/rsssitelogo');
|
|
|
|
//write the info
|
|
$result .= rss_start_tag('image', 2, true);
|
|
$result .= rss_full_tag('url', 3, false, $rsspix);
|
|
$result .= rss_full_tag('title', 3, false, 'moodle');
|
|
$result .= rss_full_tag('link', 3, false, $CFG->wwwroot);
|
|
$result .= rss_full_tag('width', 3, false, '140');
|
|
$result .= rss_full_tag('height', 3, false, '35');
|
|
$result .= rss_end_tag('image', 2, true);
|
|
}
|
|
|
|
if (!$status) {
|
|
return false;
|
|
} else {
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Generates the rss XML code for every item passed in the array
|
|
*
|
|
* item->title: The title of the item
|
|
* item->author: The author of the item. Optional !!
|
|
* item->pubdate: The pubdate of the item
|
|
* item->link: The link url of the item
|
|
* item->description: The content of the item
|
|
*
|
|
* @param array $items an array of item objects
|
|
* @return bool|string the rss XML code for every item passed in the array
|
|
*/
|
|
function rss_add_items($items) {
|
|
global $CFG;
|
|
|
|
$result = '';
|
|
|
|
if (!empty($items)) {
|
|
foreach ($items as $item) {
|
|
$result .= rss_start_tag('item',2,true);
|
|
//Include the category if exists (some rss readers will use it to group items)
|
|
if (isset($item->category)) {
|
|
$result .= rss_full_tag('category',3,false,$item->category);
|
|
}
|
|
if (isset($item->tags)) {
|
|
$attributes = array();
|
|
if (isset($item->tagscheme)) {
|
|
$attributes['domain'] = s($item->tagscheme);
|
|
}
|
|
foreach ($item->tags as $tag) {
|
|
$result .= rss_full_tag('category', 3, false, $tag, $attributes);
|
|
}
|
|
}
|
|
$result .= rss_full_tag('title',3,false,strip_tags($item->title));
|
|
$result .= rss_full_tag('link',3,false,$item->link);
|
|
$result .= rss_add_enclosures($item);
|
|
$result .= rss_full_tag('pubDate',3,false,gmdate('D, d M Y H:i:s',$item->pubdate).' GMT'); # MDL-12563
|
|
//Include the author if exists
|
|
if (isset($item->author) && !empty($item->author)) {
|
|
//$result .= rss_full_tag('author',3,false,$item->author);
|
|
//We put it in the description instead because it's more important
|
|
//for moodle than most other feeds, and most rss software seems to ignore
|
|
//the author field ...
|
|
$item->description = get_string('byname','',$item->author).'. <p>'.$item->description.'</p>';
|
|
}
|
|
$result .= rss_full_tag('description',3,false,$item->description);
|
|
$result .= rss_full_tag('guid',3,false,$item->link,array('isPermaLink' => 'true'));
|
|
$result .= rss_end_tag('item',2,true);
|
|
|
|
}
|
|
} else {
|
|
$result = false;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* This function return all the common footers for every rss feed in the site.
|
|
*
|
|
* @return string
|
|
*/
|
|
function rss_standard_footer() {
|
|
$status = true;
|
|
$result = '';
|
|
|
|
$result .= rss_end_tag('channel', 1, true);
|
|
$result .= '</rss>';
|
|
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* This function return an error xml file (string) to be sent when a rss is required (file.php) and something goes wrong
|
|
*
|
|
* @param string $errortype Type of error to send, default is rsserror
|
|
* @return stdClass returns a XML Feed with an error message in it
|
|
*/
|
|
function rss_geterrorxmlfile($errortype = 'rsserror') {
|
|
global $CFG;
|
|
|
|
$return = '';
|
|
|
|
//XML Header
|
|
$return = rss_standard_header();
|
|
|
|
//XML item
|
|
if ($return) {
|
|
$item = new stdClass();
|
|
$item->title = "RSS Error";
|
|
$item->link = $CFG->wwwroot;
|
|
$item->pubdate = time();
|
|
$item->description = get_string($errortype);
|
|
$return .= rss_add_items(array($item));
|
|
}
|
|
|
|
//XML Footer
|
|
if ($return) {
|
|
$return .= rss_standard_footer();
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Get the ID of the user from a given RSS Token
|
|
*
|
|
* @param string $token the RSS token you would like to use to find the user id
|
|
* @return int The user id
|
|
*/
|
|
function rss_get_userid_from_token($token) {
|
|
global $DB;
|
|
|
|
$sql = "SELECT u.id
|
|
FROM {user} u
|
|
JOIN {user_private_key} k ON u.id = k.userid
|
|
WHERE u.deleted = 0
|
|
AND u.confirmed = 1
|
|
AND u.suspended = 0
|
|
AND k.script = 'rss'
|
|
AND k.value = ?";
|
|
|
|
return $DB->get_field_sql($sql, array($token), IGNORE_MISSING);
|
|
}
|
|
|
|
/**
|
|
* Get the RSS Token from a given user id
|
|
*
|
|
* @param int $userid The user id
|
|
* @return string the RSS token for the user
|
|
*/
|
|
function rss_get_token($userid) {
|
|
return get_user_key('rss', $userid);
|
|
}
|
|
|
|
/**
|
|
* Removes the token for the given user from the DB
|
|
* @param int $userid The user id for the token you wish to delete
|
|
*/
|
|
function rss_delete_token($userid) {
|
|
delete_user_key('rss', $userid);
|
|
}
|
|
|
|
/**
|
|
* Return the xml start tag
|
|
*
|
|
* @param string $tag the xml tag name
|
|
* @param int $level the indentation level
|
|
* @param bool $endline whether or not to start new tags on a new line
|
|
* @param array $attributes the attributes of the xml tag
|
|
* @return string the xml start tag
|
|
*/
|
|
function rss_start_tag($tag,$level=0,$endline=false,$attributes=null) {
|
|
if ($endline) {
|
|
$endchar = "\n";
|
|
} else {
|
|
$endchar = "";
|
|
}
|
|
$attrstring = '';
|
|
if (!empty($attributes) && is_array($attributes)) {
|
|
foreach ($attributes as $key => $value) {
|
|
$attrstring .= " ".$key."=\"".$value."\"";
|
|
}
|
|
}
|
|
return str_repeat(" ",$level*2)."<".$tag.$attrstring.">".$endchar;
|
|
}
|
|
|
|
/**
|
|
* Return the xml end tag
|
|
* @param string $tag the xml tag name
|
|
* @param int $level the indentation level
|
|
* @param bool $endline whether or not to start new tags on a new line
|
|
* @return string the xml end tag
|
|
*/
|
|
function rss_end_tag($tag,$level=0,$endline=true) {
|
|
if ($endline) {
|
|
$endchar = "\n";
|
|
} else {
|
|
$endchar = "";
|
|
}
|
|
return str_repeat(" ",$level*2)."</".$tag.">".$endchar;
|
|
}
|
|
|
|
/**
|
|
* Return the while xml element, including content
|
|
*
|
|
* @param string $tag the xml tag name
|
|
* @param int $level the indentation level
|
|
* @param bool $endline whether or not to start new tags on a new line
|
|
* @param string $content the text to go inside the tag
|
|
* @param array $attributes the attributes of the xml tag
|
|
* @return string the whole xml element
|
|
*/
|
|
function rss_full_tag($tag, $level, $endline, $content, $attributes = null) {
|
|
$st = rss_start_tag($tag,$level,$endline,$attributes);
|
|
$co="";
|
|
$co = preg_replace("/\r\n|\r/", "\n", htmlspecialchars($content, ENT_COMPAT));
|
|
$et = rss_end_tag($tag,0,true);
|
|
|
|
return $st.$co.$et;
|
|
}
|
|
|
|
/**
|
|
* Adds RSS Media Enclosures for "podcasting" by including attachments that
|
|
* are specified in the item->attachments field.
|
|
*
|
|
* @param stdClass $item representing an RSS item
|
|
* @return string RSS enclosure tags
|
|
*/
|
|
function rss_add_enclosures($item){
|
|
global $CFG;
|
|
|
|
$returnstring = '';
|
|
|
|
// list of media file extensions and their respective mime types
|
|
include_once($CFG->libdir.'/filelib.php');
|
|
$mediafiletypes = get_mimetypes_array();
|
|
|
|
// take into account attachments (e.g. from forum) - with these, we are able to know the file size
|
|
if (isset($item->attachments) && is_array($item->attachments)) {
|
|
foreach ($item->attachments as $attachment){
|
|
$extension = strtolower(substr($attachment->url, strrpos($attachment->url, '.')+1));
|
|
if (isset($mediafiletypes[$extension]['type'])) {
|
|
$type = $mediafiletypes[$extension]['type'];
|
|
} else {
|
|
$type = 'document/unknown';
|
|
}
|
|
$returnstring .= "\n<enclosure url=\"$attachment->url\" length=\"$attachment->length\" type=\"$type\" />\n";
|
|
}
|
|
}
|
|
|
|
return $returnstring;
|
|
}
|