HistoryAction.php

Go to the documentation of this file.

<?php
use MediaWiki\Feed\AtomFeed;
use MediaWiki\Feed\FeedItem;
use MediaWiki\Feed\FeedUtils;
use MediaWiki\Feed\RSSFeed;
use MediaWiki\Html\Html;
use MediaWiki\HTMLForm\HTMLForm;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Pager\HistoryPager;
use MediaWiki\Request\WebRequest;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Utils\MWTimestamp;
use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\Rdbms\IResultWrapper;
 
class HistoryAction extends FormlessAction {
    private const DIR_PREV = 0;
    private const DIR_NEXT = 1;
 
    public $message;
 
    public function getName() {
        return 'history';
    }
 
    public function requiresWrite() {
        return false;
    }
 
    public function requiresUnblock() {
        return false;
    }
 
    protected function getPageTitle() {
        return $this->msg( 'history-title' )->plaintextParams( $this->getTitle()->getPrefixedText() );
    }
 
    protected function getDescription() {
        // Creation of a subtitle link pointing to [[Special:Log]]
        $linkRenderer = MediaWikiServices::getInstance()->getLinkRenderer();
        $subtitle = $linkRenderer->makeKnownLink(
            SpecialPage::getTitleFor( 'Log' ),
            $this->msg( 'viewpagelogs' )->text(),
            [],
            [ 'page' => $this->getTitle()->getPrefixedText() ]
        );
 
        $links = [];
        // Allow extensions to add more links
        $this->getHookRunner()->onHistoryPageToolLinks( $this->getContext(), $linkRenderer, $links );
        if ( $links ) {
            $subtitle .= ''
                . $this->msg( 'word-separator' )->escaped()
                . $this->msg( 'parentheses' )
                    ->rawParams( $this->getLanguage()->pipeList( $links ) )
                    ->escaped();
        }
        return Html::rawElement( 'div', [ 'class' => 'mw-history-subtitle' ], $subtitle );
    }
 
    private function preCacheMessages() {
        // Precache various messages
        if ( !isset( $this->message ) ) {
            $this->message = [];
            $msgs = [
                'cur', 'tooltip-cur', 'last', 'tooltip-last', 'pipe-separator',
                'changeslist-nocomment', 'updatedmarker',
            ];
            foreach ( $msgs as $msg ) {
                $this->message[$msg] = $this->msg( $msg )->escaped();
            }
        }
    }
 
    private function getTimestampFromRequest( WebRequest $request ) {
        // Backwards compatibility checks for URIs with only year and/or month.
        $year = $request->getInt( 'year' );
        $month = $request->getInt( 'month' );
        $day = null;
        if ( $year !== 0 || $month !== 0 ) {
            if ( $year === 0 ) {
                $year = MWTimestamp::getLocalInstance()->format( 'Y' );
            }
            if ( $month < 1 || $month > 12 ) {
                // month is invalid so treat as December (all months)
                $month = 12;
            }
            // month is valid so check day
            $day = cal_days_in_month( CAL_GREGORIAN, $month, $year );
 
            // Left pad the months and days
            $month = str_pad( (string)$month, 2, "0", STR_PAD_LEFT );
            $day = str_pad( (string)$day, 2, "0", STR_PAD_LEFT );
        }
 
        $before = $request->getVal( 'date-range-to' );
        if ( $before ) {
            $parts = explode( '-', $before );
            $year = $parts[0];
            // check date input is valid
            if ( count( $parts ) === 3 ) {
                $month = $parts[1];
                $day = $parts[2];
            }
        }
        return $year && $month && $day ? $year . '-' . $month . '-' . $day : '';
    }
 
    public function onView() {
        $out = $this->getOutput();
        $request = $this->getRequest();
        $config = $this->context->getConfig();
        $services = MediaWikiServices::getInstance();
 
        // Allow client-side HTTP caching of the history page.
        // But, always ignore this cache if the (logged-in) user has this page on their watchlist
        // and has one or more unseen revisions. Otherwise, we might be showing stale update markers.
        // The Last-Modified for the history page does not change when user's markers are cleared,
        // so going from "some unseen" to "all seen" would not clear the cache.
        // But, when all of the revisions are marked as seen, then only way for new unseen revision
        // markers to appear, is for the page to be edited, which updates page_touched/Last-Modified.
        $watchlistManager = $services->getWatchlistManager();
        $hasUnseenRevisionMarkers = $config->get( MainConfigNames::ShowUpdatedMarker ) &&
            $watchlistManager->getTitleNotificationTimestamp(
                $this->getUser(),
                $this->getTitle()
            );
        if (
            !$hasUnseenRevisionMarkers &&
            $out->checkLastModified( $this->getWikiPage()->getTouched() )
        ) {
            return null; // Client cache fresh and headers sent, nothing more to do.
        }
 
        $this->preCacheMessages();
 
        # Fill in the file cache if not set already
        if ( HTMLFileCache::useFileCache( $this->getContext() ) ) {
            $cache = new HTMLFileCache( $this->getTitle(), 'history' );
            if ( !$cache->isCacheGood( /* Assume up to date */ ) ) {
                ob_start( [ &$cache, 'saveToFileCache' ] );
            }
        }
 
        // Setup page variables.
        $out->setFeedAppendQuery( 'action=history' );
        $out->addModules( 'mediawiki.action.history' );
        $out->addModuleStyles( [
            'mediawiki.interface.helpers.styles',
            'mediawiki.action.history.styles',
            'mediawiki.special.changeslist',
        ] );
 
        // Handle atom/RSS feeds.
        $feedType = $request->getRawVal( 'feed' );
        if ( $feedType !== null ) {
            $this->feed( $feedType );
            return null;
        }
 
        $this->addHelpLink(
            'https://www.mediawiki.org/wiki/Special:MyLanguage/Help:History',
            true
        );
 
        $dbr = $services->getConnectionProvider()->getReplicaDatabase();
        // Fail nicely if article doesn't exist.
        if ( !$this->getWikiPage()->exists() ) {
            $send404Code = $config->get( MainConfigNames::Send404Code );
            if ( $send404Code ) {
                $out->setStatusCode( 404 );
            }
            $out->addWikiMsg( 'nohistory' );
 
            # show deletion/move log if there is an entry
            LogEventsList::showLogExtract(
                $out,
                [ 'delete', 'move', 'protect', 'merge' ],
                $this->getTitle(),
                '',
                [ 'lim' => 10,
                    'conds' => [ $dbr->expr( 'log_action', '!=', 'revision' ) ],
                    'showIfEmpty' => false,
                    'msgKey' => [ 'moveddeleted-notice' ]
                ]
            );
 
            return null;
        }
 
        $ts = $this->getTimestampFromRequest( $request );
        $tagFilter = $request->getVal( 'tagfilter' );
 
        if ( $request->getBool( 'deleted' ) ) {
            $conds = [ $dbr->expr( 'rev_deleted', '!=', 0 ) ];
        } else {
            $conds = [];
        }
 
        // Add the general form.
        $fields = [
            'action' => [
                'name' => 'action',
                'type' => 'hidden',
                'default' => 'history',
            ],
            'date-range-to' => [
                'type' => 'date',
                'default' => $ts,
                'label' => $this->msg( 'date-range-to' )->text(),
                'name' => 'date-range-to',
            ],
            'tagfilter' => [
                'label-message' => 'tag-filter',
                'type' => 'tagfilter',
                'id' => 'tagfilter',
                'name' => 'tagfilter',
                'value' => $tagFilter,
            ],
            'tagInvert' => [
                'type' => 'check',
                'name' => 'tagInvert',
                'label-message' => 'invert',
                'hide-if' => [ '===', 'tagfilter', '' ],
            ],
        ];
        if ( $this->getAuthority()->isAllowed( 'deletedhistory' ) ) {
            $fields['deleted'] = [
                'type' => 'check',
                'label' => $this->msg( 'history-show-deleted' )->text(),
                'default' => $request->getBool( 'deleted' ),
                'name' => 'deleted',
            ];
        }
 
        $out->enableOOUI();
        $htmlForm = HTMLForm::factory( 'ooui', $fields, $this->getContext() );
        $htmlForm
            ->setMethod( 'get' )
            ->setAction( wfScript() )
            ->setCollapsibleOptions( true )
            ->setId( 'mw-history-searchform' )
            ->setSubmitTextMsg( 'historyaction-submit' )
            ->setWrapperAttributes( [ 'id' => 'mw-history-search' ] )
            ->setWrapperLegendMsg( 'history-fieldset-title' )
            ->prepareForm();
 
        $out->addHTML( $htmlForm->getHTML( false ) );
 
        $this->getHookRunner()->onPageHistoryBeforeList(
            $this->getArticle(),
            $this->getContext()
        );
 
        // Create and output the list.
        $dateComponents = explode( '-', $ts );
        if ( count( $dateComponents ) > 1 ) {
            $y = (int)$dateComponents[0];
            $m = (int)$dateComponents[1];
            $d = (int)$dateComponents[2];
        } else {
            $y = 0;
            $m = 0;
            $d = 0;
        }
        $pager = new HistoryPager(
            $this,
            $y,
            $m,
            $d,
            $tagFilter,
            $request->getCheck( 'tagInvert' ),
            $conds,
            $services->getLinkBatchFactory(),
            $watchlistManager,
            $services->getCommentFormatter(),
            $services->getHookContainer(),
            $services->getChangeTagsStore()
        );
        $out->addHTML(
            $pager->getNavigationBar() .
            $pager->getBody() .
            $pager->getNavigationBar()
        );
        $out->getMetadata()->setPreventClickjacking( $pager->getPreventClickjacking() );
 
        return null;
    }
 
    private function fetchRevisions( $limit, $offset, $direction ) {
        // Fail if article doesn't exist.
        if ( !$this->getTitle()->exists() ) {
            return new FakeResultWrapper( [] );
        }
 
        $dbr = MediaWikiServices::getInstance()->getConnectionProvider()->getReplicaDatabase();
 
        if ( $direction === self::DIR_PREV ) {
            [ $dirs, $oper ] = [ "ASC", ">=" ];
        } else { /* $direction === self::DIR_NEXT */
            [ $dirs, $oper ] = [ "DESC", "<=" ];
        }
 
        $queryBuilder = MediaWikiServices::getInstance()->getRevisionStore()->newSelectQueryBuilder( $dbr )
            ->joinComment()
            ->where( [ 'rev_page' => $this->getWikiPage()->getId() ] )
            ->useIndex( [ 'revision' => 'rev_page_timestamp' ] )
            ->orderBy( [ 'rev_timestamp' ], $dirs )
            ->limit( $limit );
        if ( $offset ) {
            $queryBuilder->andWhere( $dbr->expr( 'rev_timestamp', $oper, $dbr->timestamp( $offset ) ) );
        }
 
        return $queryBuilder->caller( __METHOD__ )->fetchResultSet();
    }
 
    private function feed( $type ) {
        if ( !FeedUtils::checkFeedOutput( $type, $this->getOutput() ) ) {
            return;
        }
        $request = $this->getRequest();
 
        $feedClasses = $this->context->getConfig()->get( MainConfigNames::FeedClasses );
        $feed = new $feedClasses[$type](
            $this->getTitle()->getPrefixedText() . ' - ' .
            $this->msg( 'history-feed-title' )->inContentLanguage()->text(),
            $this->msg( 'history-feed-description' )->inContentLanguage()->text(),
            $this->getTitle()->getFullURL( 'action=history' )
        );
 
        // Get a limit on number of feed entries. Provide a sensible default
        // of 10 if none is defined (but limit to $wgFeedLimit max)
        $limit = $request->getInt( 'limit', 10 );
        $limit = min(
            max( $limit, 1 ),
            $this->context->getConfig()->get( MainConfigNames::FeedLimit )
        );
 
        $items = $this->fetchRevisions( $limit, 0, self::DIR_NEXT );
 
        // Preload comments
        $formattedComments = MediaWikiServices::getInstance()->getRowCommentFormatter()
            ->formatRows( $items, 'rev_comment' );
 
        // Generate feed elements enclosed between header and footer.
        $feed->outHeader();
        if ( $items->numRows() ) {
            foreach ( $items as $i => $row ) {
                $feed->outItem( $this->feedItem( $row, $formattedComments[$i] ) );
            }
        } else {
            $feed->outItem( $this->feedEmpty() );
        }
        $feed->outFooter();
    }
 
    private function feedEmpty() {
        return new FeedItem(
            $this->msg( 'nohistory' )->inContentLanguage()->text(),
            $this->msg( 'history-feed-empty' )->inContentLanguage()->parseAsBlock(),
            $this->getTitle()->getFullURL(),
            wfTimestamp( TS_MW ),
            '',
            $this->getTitle()->getTalkPage()->getFullURL()
        );
    }
 
    private function feedItem( $row, $formattedComment ) {
        $revisionStore = MediaWikiServices::getInstance()->getRevisionStore();
        $rev = $revisionStore->newRevisionFromRow( $row, 0, $this->getTitle() );
        $prevRev = $revisionStore->getPreviousRevision( $rev );
        $revComment = $rev->getComment() === null ? null : $rev->getComment()->text;
        $text = FeedUtils::formatDiffRow2(
            $this->getTitle(),
            $prevRev ? $prevRev->getId() : false,
            $rev->getId(),
            $rev->getTimestamp(),
            $formattedComment
        );
        $revUserText = $rev->getUser() ? $rev->getUser()->getName() : '';
        if ( $revComment == '' ) {
            $contLang = MediaWikiServices::getInstance()->getContentLanguage();
            $title = $this->msg( 'history-feed-item-nocomment',
                $revUserText,
                $contLang->timeanddate( $rev->getTimestamp() ),
                $contLang->date( $rev->getTimestamp() ),
                $contLang->time( $rev->getTimestamp() )
            )->inContentLanguage()->text();
        } else {
            $title = $revUserText .
                $this->msg( 'colon-separator' )->inContentLanguage()->text() .
                FeedItem::stripComment( $revComment );
        }
 
        return new FeedItem(
            $title,
            $text,
            $this->getTitle()->getFullURL( 'diff=' . $rev->getId() . '&oldid=prev' ),
            $rev->getTimestamp(),
            $revUserText,
            $this->getTitle()->getTalkPage()->getFullURL()
        );
    }
}