ApiFeedWatchlist.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Api;
 
use Exception;
use MediaWiki\Feed\ChannelFeed;
use MediaWiki\Feed\FeedItem;
use MediaWiki\MainConfigNames;
use MediaWiki\Parser\ParserFactory;
use MediaWiki\Request\FauxRequest;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Title\Title;
use Wikimedia\ParamValidator\ParamValidator;
use Wikimedia\ParamValidator\TypeDef\IntegerDef;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class ApiFeedWatchlist extends ApiBase {
 
    private $watchlistModule = null;
    private $linkToSections = false;
 
    public function __construct(
        ApiMain $main,
        string $action,
        private readonly ParserFactory $parserFactory,
    ) {
        parent::__construct( $main, $action );
    }
 
    public function getCustomPrinter() {
        return new ApiFormatFeedWrapper( $this->getMain() );
    }
 
    public function execute() {
        $config = $this->getConfig();
        $feedClasses = $config->get( MainConfigNames::FeedClasses );
        '@phan-var array<string,class-string<ChannelFeed>> $feedClasses';
        $params = [];
        $feedItems = [];
        try {
            $params = $this->extractRequestParams();
 
            if ( !$config->get( MainConfigNames::Feed ) ) {
                $this->dieWithError( 'feed-unavailable' );
            }
 
            if ( !isset( $feedClasses[$params['feedformat']] ) ) {
                $this->dieWithError( 'feed-invalid' );
            }
 
            // limit to the number of hours going from now back
            $endTime = wfTimestamp( TS::MW, time() - (int)$params['hours'] * 60 * 60 );
 
            // Prepare parameters for nested request
            $fauxReqArr = [
                'action' => 'query',
                'meta' => 'siteinfo',
                'siprop' => 'general',
                'list' => 'watchlist',
                'wlprop' => 'title|user|comment|timestamp|ids|loginfo',
                'wldir' => 'older', // reverse order - from newest to oldest
                'wlend' => $endTime, // stop at this time
                'wllimit' => min( 50, $config->get( MainConfigNames::FeedLimit ) )
            ];
 
            if ( $params['wlowner'] !== null ) {
                $fauxReqArr['wlowner'] = $params['wlowner'];
            }
            if ( $params['wltoken'] !== null ) {
                $fauxReqArr['wltoken'] = $params['wltoken'];
            }
            if ( $params['wlexcludeuser'] !== null ) {
                $fauxReqArr['wlexcludeuser'] = $params['wlexcludeuser'];
            }
            if ( $params['wlshow'] !== null ) {
                $fauxReqArr['wlshow'] = ParamValidator::implodeMultiValue( $params['wlshow'] );
            }
            if ( $params['wltype'] !== null ) {
                $fauxReqArr['wltype'] = ParamValidator::implodeMultiValue( $params['wltype'] );
            }
 
            // Support linking directly to sections when possible
            // (possible only if section name is present in comment)
            if ( $params['linktosections'] ) {
                $this->linkToSections = true;
            }
 
            // Check for 'allrev' parameter, and if found, show all revisions to each page on wl.
            if ( $params['allrev'] ) {
                $fauxReqArr['wlallrev'] = '';
            }
 
            $fauxReq = new FauxRequest( $fauxReqArr );
 
            $module = new ApiMain( $fauxReq );
            $module->execute();
 
            $data = $module->getResult()->getResultData( [ 'query', 'watchlist' ] );
            foreach ( (array)$data as $key => $info ) {
                if ( ApiResult::isMetadataKey( $key ) ) {
                    continue;
                }
                $feedItem = $this->createFeedItem( $info );
                if ( $feedItem ) {
                    $feedItems[] = $feedItem;
                }
            }
 
            $msg = $this->msg( 'watchlist' )->inContentLanguage()->text();
 
            $feedTitle = $config->get( MainConfigNames::Sitename )
                . " - $msg "
                . $this->msg( 'brackets', $config->get( MainConfigNames::LanguageCode ) )->inContentLanguage()->text();
            $feedUrl = SpecialPage::getTitleFor( 'Watchlist' )->getFullURL();
 
            $feed = new $feedClasses[$params['feedformat']] (
                $feedTitle,
                htmlspecialchars( $msg ),
                $feedUrl
            );
 
            ApiFormatFeedWrapper::setResult( $this->getResult(), $feed, $feedItems );
        } catch ( Exception $e ) {
            // Error results should not be cached
            $this->getMain()->setCacheMaxAge( 0 );
 
            $feedTitle = $config->get( MainConfigNames::Sitename )
                . ' - Error - '
                . $this->msg( 'watchlist' )->inContentLanguage()->text()
                . ' '
                . $this->msg( 'brackets', $config->get( MainConfigNames::LanguageCode ) )->inContentLanguage()->text();
            $feedUrl = SpecialPage::getTitleFor( 'Watchlist' )->getFullURL();
 
            $feedFormat = $params['feedformat'] ?? 'rss';
            $msg = $this->msg( 'watchlist' )->inContentLanguage()->escaped();
            $feed = new $feedClasses[$feedFormat]( $feedTitle, $msg, $feedUrl );
 
            if ( $e instanceof ApiUsageException ) {
                foreach ( $e->getStatusValue()->getMessages() as $msg ) {
                    // @phan-suppress-next-line PhanUndeclaredMethod
                    $msg = ApiMessage::create( $msg )
                        ->inLanguage( $this->getLanguage() );
                    $errorTitle = $this->msg( 'api-feed-error-title', $msg->getApiCode() )->text();
                    $errorText = $msg->text();
                    $feedItems[] = new FeedItem( $errorTitle, $errorText, '', '', '' );
                }
            } else {
                // Something is seriously wrong
                $errorCode = 'internal_api_error';
                $errorTitle = $this->msg( 'api-feed-error-title', $errorCode )->text();
                $errorText = $e->getMessage();
                $feedItems[] = new FeedItem( $errorTitle, $errorText, '', '', '' );
            }
 
            ApiFormatFeedWrapper::setResult( $this->getResult(), $feed, $feedItems );
        }
    }
 
    private function createFeedItem( $info ) {
        if ( !isset( $info['title'] ) ) {
            // Probably a revdeled log entry, skip it.
            return null;
        }
 
        $titleStr = $info['title'];
        $title = Title::newFromText( $titleStr );
        $curidParam = [];
        if ( !$title || $title->isExternal() ) {
            // Probably a formerly-valid title that's now conflicting with an
            // interwiki prefix or the like.
            if ( isset( $info['pageid'] ) ) {
                $title = Title::newFromID( $info['pageid'] );
                $curidParam = [ 'curid' => $info['pageid'] ];
            }
            if ( !$title || $title->isExternal() ) {
                return null;
            }
        }
        if ( isset( $info['revid'] ) ) {
            if ( $info['revid'] === 0 && isset( $info['logid'] ) ) {
                $logTitle = Title::makeTitle( NS_SPECIAL, 'Log' );
                $titleUrl = $logTitle->getFullURL( [ 'logid' => $info['logid'] ] );
            } else {
                $titleUrl = $title->getFullURL( [ 'diff' => $info['revid'] ] );
            }
        } else {
            $titleUrl = $title->getFullURL( $curidParam );
        }
        $comment = $info['comment'] ?? null;
 
        // Create an anchor to section.
        // The anchor won't work for sections that have dupes on page
        // as there's no way to strip that info from ApiWatchlist (apparently?).
        // RegExp in the line below is equal to MediaWiki\CommentFormatter\CommentParser::doSectionLinks().
        if ( $this->linkToSections && $comment !== null &&
            preg_match( '!(.*)/\*\s*(.*?)\s*\*/(.*)!', $comment, $matches )
        ) {
            $titleUrl .= $this->parserFactory->getMainInstance()->guessSectionNameFromWikiText( $matches[ 2 ] );
        }
 
        $timestamp = $info['timestamp'];
 
        if ( isset( $info['user'] ) ) {
            $user = $info['user'];
            $completeText = "$comment ($user)";
        } else {
            $user = '';
            $completeText = (string)$comment;
        }
 
        return new FeedItem( $titleStr, $completeText, $titleUrl, $timestamp, $user );
    }
 
    private function getWatchlistModule() {
        $this->watchlistModule ??= $this->getMain()->getModuleManager()->getModule( 'query' )
            ->getModuleManager()->getModule( 'watchlist' );
 
        return $this->watchlistModule;
    }
 
    public function getAllowedParams( $flags = 0 ) {
        $feedFormatNames = array_keys( $this->getConfig()->get( MainConfigNames::FeedClasses ) );
        $ret = [
            'feedformat' => [
                ParamValidator::PARAM_DEFAULT => 'rss',
                ParamValidator::PARAM_TYPE => $feedFormatNames
            ],
            'hours' => [
                ParamValidator::PARAM_DEFAULT => 24,
                ParamValidator::PARAM_TYPE => 'integer',
                IntegerDef::PARAM_MIN => 1,
                IntegerDef::PARAM_MAX => 72,
            ],
            'linktosections' => false,
        ];
 
        $copyParams = [
            'allrev' => 'allrev',
            'owner' => 'wlowner',
            'token' => 'wltoken',
            'show' => 'wlshow',
            'type' => 'wltype',
            'excludeuser' => 'wlexcludeuser',
        ];
        // @phan-suppress-next-line PhanParamTooMany
        $wlparams = $this->getWatchlistModule()->getAllowedParams( $flags );
        foreach ( $copyParams as $from => $to ) {
            $p = $wlparams[$from];
            if ( !is_array( $p ) ) {
                $p = [ ParamValidator::PARAM_DEFAULT => $p ];
            }
            if ( !isset( $p[ApiBase::PARAM_HELP_MSG] ) ) {
                $p[ApiBase::PARAM_HELP_MSG] = "apihelp-query+watchlist-param-$from";
            }
            if ( isset( $p[ParamValidator::PARAM_TYPE] ) && is_array( $p[ParamValidator::PARAM_TYPE] ) &&
                isset( $p[ApiBase::PARAM_HELP_MSG_PER_VALUE] )
            ) {
                foreach ( $p[ParamValidator::PARAM_TYPE] as $v ) {
                    if ( !isset( $p[ApiBase::PARAM_HELP_MSG_PER_VALUE][$v] ) ) {
                        $p[ApiBase::PARAM_HELP_MSG_PER_VALUE][$v] = "apihelp-query+watchlist-paramvalue-$from-$v";
                    }
                }
            }
            $ret[$to] = $p;
        }
 
        return $ret;
    }
 
    protected function getExamplesMessages() {
        return [
            'action=feedwatchlist'
                => 'apihelp-feedwatchlist-example-default',
            'action=feedwatchlist&allrev=&hours=6'
                => 'apihelp-feedwatchlist-example-all6hrs',
        ];
    }
 
    public function getHelpUrls() {
        return 'https://www.mediawiki.org/wiki/Special:MyLanguage/API:Watchlist_feed';
    }
}
 
class_alias( ApiFeedWatchlist::class, 'ApiFeedWatchlist' );