Feed.php

Go to the documentation of this file.

<?php
class FeedItem {
    public $title;
 
    public $description;
 
    public $url;
 
    public $date;
 
    public $author;
 
    public $uniqueId;
 
    public $comments;
 
    public $rssIsPermalink = false;
 
    function __construct( $title, $description, $url, $date = '', $author = '', $comments = '' ) {
        $this->title = $title;
        $this->description = $description;
        $this->url = $url;
        $this->uniqueId = $url;
        $this->date = $date;
        $this->author = $author;
        $this->comments = $comments;
    }
 
    public function xmlEncode( $string ) {
        $string = str_replace( "\r\n", "\n", $string );
        $string = preg_replace( '/[\x00-\x08\x0b\x0c\x0e-\x1f]/', '', $string );
        return htmlspecialchars( $string );
    }
 
    public function getUniqueID() {
        $id = $this->getUniqueIdUnescaped();
        if ( $id ) {
            return $this->xmlEncode( $id );
        }
    }
 
    public function getUniqueIdUnescaped() {
        if ( $this->uniqueId ) {
            return wfExpandUrl( $this->uniqueId, PROTO_CURRENT );
        }
    }
 
    public function setUniqueId( $uniqueId, $rssIsPermalink = false ) {
        $this->uniqueId = $uniqueId;
        $this->rssIsPermalink = $rssIsPermalink;
    }
 
    public function getTitle() {
        return $this->xmlEncode( $this->title );
    }
 
    public function getUrl() {
        return $this->xmlEncode( $this->url );
    }
 
    public function getUrlUnescaped() {
        return $this->url;
    }
 
    public function getDescription() {
        return $this->xmlEncode( $this->description );
    }
 
    public function getDescriptionUnescaped() {
        return $this->description;
    }
 
    public function getLanguage() {
        global $wgLanguageCode;
        return LanguageCode::bcp47( $wgLanguageCode );
    }
 
    public function getDate() {
        return $this->date;
    }
 
    public function getAuthor() {
        return $this->xmlEncode( $this->author );
    }
 
    public function getAuthorUnescaped() {
        return $this->author;
    }
 
    public function getComments() {
        return $this->xmlEncode( $this->comments );
    }
 
    public function getCommentsUnescaped() {
        return $this->comments;
    }
 
    public static function stripComment( $text ) {
        return preg_replace( '/\[\[([^]]*\|)?([^]]+)\]\]/', '\2', $text );
    }
}
 
abstract class ChannelFeed extends FeedItem {
 
    protected $templateParser;
 
    function __construct( $title, $description, $url, $date = '', $author = '', $comments = '' ) {
        parent::__construct( $title, $description, $url, $date, $author, $comments );
        $this->templateParser = new TemplateParser();
    }
 
    abstract public function outHeader();
 
    abstract public function outItem( $item );
 
    abstract public function outFooter();
 
    public function httpHeaders() {
        global $wgOut, $wgVaryOnXFP;
 
        # We take over from $wgOut, excepting its cache header info
        $wgOut->disable();
        $mimetype = $this->contentType();
        header( "Content-type: $mimetype; charset=UTF-8" );
 
        // Set a sane filename
        $exts = MediaWiki\MediaWikiServices::getInstance()->getMimeAnalyzer()
            ->getExtensionsForType( $mimetype );
        $ext = $exts ? strtok( $exts, ' ' ) : 'xml';
        header( "Content-Disposition: inline; filename=\"feed.{$ext}\"" );
 
        if ( $wgVaryOnXFP ) {
            $wgOut->addVaryHeader( 'X-Forwarded-Proto' );
        }
        $wgOut->sendCacheControl();
    }
 
    private function contentType() {
        global $wgRequest;
 
        $ctype = $wgRequest->getVal( 'ctype', 'application/xml' );
        $allowedctypes = [
            'application/xml',
            'text/xml',
            'application/rss+xml',
            'application/atom+xml'
        ];
 
        return ( in_array( $ctype, $allowedctypes ) ? $ctype : 'application/xml' );
    }
 
    protected function outXmlHeader() {
        $this->httpHeaders();
        echo '<?xml version="1.0"?>' . "\n";
    }
}
 
class RSSFeed extends ChannelFeed {
 
    function formatTime( $ts ) {
        if ( $ts ) {
            return gmdate( 'D, d M Y H:i:s \G\M\T', wfTimestamp( TS_UNIX, $ts ) );
        }
    }
 
    function outHeader() {
        global $wgVersion;
 
        $this->outXmlHeader();
        // Manually escaping rather than letting Mustache do it because Mustache
        // uses htmlentities, which does not work with XML
        $templateParams = [
            'title' => $this->getTitle(),
            'url' => $this->xmlEncode( wfExpandUrl( $this->getUrlUnescaped(), PROTO_CURRENT ) ),
            'description' => $this->getDescription(),
            'language' => $this->xmlEncode( $this->getLanguage() ),
            'version' => $this->xmlEncode( $wgVersion ),
            'timestamp' => $this->xmlEncode( $this->formatTime( wfTimestampNow() ) )
        ];
        print $this->templateParser->processTemplate( 'RSSHeader', $templateParams );
    }
 
    function outItem( $item ) {
        // Manually escaping rather than letting Mustache do it because Mustache
        // uses htmlentities, which does not work with XML
        $templateParams = [
            "title" => $item->getTitle(),
            "url" => $this->xmlEncode( wfExpandUrl( $item->getUrlUnescaped(), PROTO_CURRENT ) ),
            "permalink" => $item->rssIsPermalink,
            "uniqueID" => $item->getUniqueID(),
            "description" => $item->getDescription(),
            "date" => $this->xmlEncode( $this->formatTime( $item->getDate() ) ),
            "author" => $item->getAuthor()
        ];
        $comments = $item->getCommentsUnescaped();
        if ( $comments ) {
            $commentsEscaped = $this->xmlEncode( wfExpandUrl( $comments, PROTO_CURRENT ) );
            $templateParams["comments"] = $commentsEscaped;
        }
        print $this->templateParser->processTemplate( 'RSSItem', $templateParams );
    }
 
    function outFooter() {
        print "</channel></rss>";
    }
}
 
class AtomFeed extends ChannelFeed {
    function formatTime( $timestamp ) {
        if ( $timestamp ) {
            // need to use RFC 822 time format at least for rss2.0
            return gmdate( 'Y-m-d\TH:i:s', wfTimestamp( TS_UNIX, $timestamp ) );
        }
    }
 
    function outHeader() {
        global $wgVersion;
        $this->outXmlHeader();
        // Manually escaping rather than letting Mustache do it because Mustache
        // uses htmlentities, which does not work with XML
        $templateParams = [
            'language' => $this->xmlEncode( $this->getLanguage() ),
            'feedID' => $this->getFeedId(),
            'title' => $this->getTitle(),
            'url' => $this->xmlEncode( wfExpandUrl( $this->getUrlUnescaped(), PROTO_CURRENT ) ),
            'selfUrl' => $this->getSelfUrl(),
            'timestamp' => $this->xmlEncode( $this->formatTime( wfTimestampNow() ) ),
            'description' => $this->getDescription(),
            'version' => $this->xmlEncode( $wgVersion ),
        ];
        print $this->templateParser->processTemplate( 'AtomHeader', $templateParams );
    }
 
    private function getFeedId() {
        return $this->getSelfUrl();
    }
 
    private function getSelfUrl() {
        global $wgRequest;
        return htmlspecialchars( $wgRequest->getFullRequestURL() );
    }
 
    function outItem( $item ) {
        global $wgMimeType;
        // Manually escaping rather than letting Mustache do it because Mustache
        // uses htmlentities, which does not work with XML
        $templateParams = [
            "uniqueID" => $item->getUniqueID(),
            "title" => $item->getTitle(),
            "mimeType" => $this->xmlEncode( $wgMimeType ),
            "url" => $this->xmlEncode( wfExpandUrl( $item->getUrlUnescaped(), PROTO_CURRENT ) ),
            "date" => $this->xmlEncode( $this->formatTime( $item->getDate() ) ),
            "description" => $item->getDescription(),
            "author" => $item->getAuthor()
        ];
        print $this->templateParser->processTemplate( 'AtomItem', $templateParams );
    }
 
    function outFooter() {
        print "</feed>";
    }
}