includes/actions/HistoryAction.php

   1 <?php
   2 /**
   3  * Page history
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup Actions
  22  */
  23
  24 use MediaWiki\MediaWikiServices;
  25 use Wikimedia\Rdbms\IResultWrapper;
  26 use Wikimedia\Rdbms\FakeResultWrapper;
  27
  28 /**
  29  * This class handles printing the history page for an article. In order to
  30  * be efficient, it uses timestamps rather than offsets for paging, to avoid
  31  * costly LIMIT,offset queries.
  32  *
  33  * Construct it by passing in an Article, and call $h->history() to print the
  34  * history.
  35  *
  36  * @ingroup Actions
  37  */
  38 class HistoryAction extends FormlessAction {
  39         const DIR_PREV = 0;
  40         const DIR_NEXT = 1;
  41
  42         /** @var array Array of message keys and strings */
  43         public $message;
  44
  45         public function getName() {
  46                 return 'history';
  47         }
  48
  49         public function requiresWrite() {
  50                 return false;
  51         }
  52
  53         public function requiresUnblock() {
  54                 return false;
  55         }
  56
  57         protected function getPageTitle() {
  58                 return $this->msg( 'history-title', $this->getTitle()->getPrefixedText() )->text();
  59         }
  60
  61         protected function getDescription() {
  62                 // Creation of a subtitle link pointing to [[Special:Log]]
  63                 $linkRenderer = MediaWikiServices::getInstance()->getLinkRenderer();
  64                 $subtitle = $linkRenderer->makeKnownLink(
  65                         SpecialPage::getTitleFor( 'Log' ),
  66                         $this->msg( 'viewpagelogs' )->text(),
  67                         [],
  68                         [ 'page' => $this->getTitle()->getPrefixedText() ]
  69                 );
  70
  71                 $links = [];
  72                 // Allow extensions to add more links
  73                 Hooks::run( 'HistoryPageToolLinks', [ $this->getContext(), $linkRenderer, &$links ] );
  74                 if ( $links ) {
  75                         $subtitle .= ''
  76                                 . $this->msg( 'word-separator' )->escaped()
  77                                 . $this->msg( 'parentheses' )
  78                                         ->rawParams( $this->getLanguage()->pipeList( $links ) )
  79                                         ->escaped();
  80                 }
  81                 return Html::rawElement( 'div', [ 'class' => 'mw-history-subtitle' ], $subtitle );
  82         }
  83
  84         /**
  85          * @return WikiPage|Article|ImagePage|CategoryPage|Page The Article object we are working on.
  86          */
  87         public function getArticle() {
  88                 return $this->page;
  89         }
  90
  91         /**
  92          * As we use the same small set of messages in various methods and that
  93          * they are called often, we call them once and save them in $this->message
  94          */
  95         private function preCacheMessages() {
  96                 // Precache various messages
  97                 if ( !isset( $this->message ) ) {
  98                         $msgs = [ 'cur', 'last', 'pipe-separator' ];
  99                         foreach ( $msgs as $msg ) {
 100                                 $this->message[$msg] = $this->msg( $msg )->escaped();
 101                         }
 102                 }
 103         }
 104
 105         /**
 106          * @param WebRequest $request
 107          * @return string
 108          */
 109         private function getTimestampFromRequest( WebRequest $request ) {
 110                 // Backwards compatibility checks for URIs with only year and/or month.
 111                 $year = $request->getInt( 'year' );
 112                 $month = $request->getInt( 'month' );
 113                 $day = null;
 114                 if ( $year !== 0 || $month !== 0 ) {
 115                         if ( $year === 0 ) {
 116                                 $year = MWTimestamp::getLocalInstance()->format( 'Y' );
 117                         }
 118                         if ( $month < 1 || $month > 12 ) {
 119                                 // month is invalid so treat as December (all months)
 120                                 $month = 12;
 121                         }
 122                         // month is valid so check day
 123                         $day = cal_days_in_month( CAL_GREGORIAN, $month, $year );
 124
 125                         // Left pad the months and days
 126                         $month = str_pad( $month, 2, "0", STR_PAD_LEFT );
 127                         $day = str_pad( $day, 2, "0", STR_PAD_LEFT );
 128                 }
 129
 130                 $before = $request->getVal( 'date-range-to' );
 131                 if ( $before ) {
 132                         $parts = explode( '-', $before );
 133                         $year = $parts[0];
 134                         // check date input is valid
 135                         if ( count( $parts ) === 3 ) {
 136                                 $month = $parts[1];
 137                                 $day = $parts[2];
 138                         }
 139                 }
 140                 return $year && $month && $day ? $year . '-' . $month . '-' . $day : '';
 141         }
 142
 143         /**
 144          * Print the history page for an article.
 145          * @return string|null
 146          */
 147         function onView() {
 148                 $out = $this->getOutput();
 149                 $request = $this->getRequest();
 150
 151                 // Allow client-side HTTP caching of the history page.
 152                 // But, always ignore this cache if the (logged-in) user has this page on their watchlist
 153                 // and has one or more unseen revisions. Otherwise, we might be showing stale update markers.
 154                 // The Last-Modified for the history page does not change when user's markers are cleared,
 155                 // so going from "some unseen" to "all seen" would not clear the cache.
 156                 // But, when all of the revisions are marked as seen, then only way for new unseen revision
 157                 // markers to appear, is for the page to be edited, which updates page_touched/Last-Modified.
 158                 if (
 159                         !$this->hasUnseenRevisionMarkers() &&
 160                         $out->checkLastModified( $this->page->getTouched() )
 161                 ) {
 162                         return null; // Client cache fresh and headers sent, nothing more to do.
 163                 }
 164
 165                 $this->preCacheMessages();
 166                 $config = $this->context->getConfig();
 167
 168                 # Fill in the file cache if not set already
 169                 if ( HTMLFileCache::useFileCache( $this->getContext() ) ) {
 170                         $cache = new HTMLFileCache( $this->getTitle(), 'history' );
 171                         if ( !$cache->isCacheGood( /* Assume up to date */ ) ) {
 172                                 ob_start( [ &$cache, 'saveToFileCache' ] );
 173                         }
 174                 }
 175
 176                 // Setup page variables.
 177                 $out->setFeedAppendQuery( 'action=history' );
 178                 $out->addModules( 'mediawiki.action.history' );
 179                 $out->addModuleStyles( [
 180                         'mediawiki.interface.helpers.styles',
 181                         'mediawiki.action.history.styles',
 182                         'mediawiki.special.changeslist',
 183                 ] );
 184                 if ( $config->get( 'UseMediaWikiUIEverywhere' ) ) {
 185                         $out = $this->getOutput();
 186                         $out->addModuleStyles( [
 187                                 'mediawiki.ui.input',
 188                                 'mediawiki.ui.checkbox',
 189                         ] );
 190                 }
 191
 192                 // Handle atom/RSS feeds.
 193                 $feedType = $request->getRawVal( 'feed' );
 194                 if ( $feedType !== null ) {
 195                         $this->feed( $feedType );
 196                         return null;
 197                 }
 198
 199                 $this->addHelpLink(
 200                         'https://meta.wikimedia.org/wiki/Special:MyLanguage/Help:Page_history',
 201                         true
 202                 );
 203
 204                 // Fail nicely if article doesn't exist.
 205                 if ( !$this->page->exists() ) {
 206                         global $wgSend404Code;
 207                         if ( $wgSend404Code ) {
 208                                 $out->setStatusCode( 404 );
 209                         }
 210                         $out->addWikiMsg( 'nohistory' );
 211
 212                         $dbr = wfGetDB( DB_REPLICA );
 213
 214                         # show deletion/move log if there is an entry
 215                         LogEventsList::showLogExtract(
 216                                 $out,
 217                                 [ 'delete', 'move', 'protect' ],
 218                                 $this->getTitle(),
 219                                 '',
 220                                 [ 'lim' => 10,
 221                                         'conds' => [ 'log_action != ' . $dbr->addQuotes( 'revision' ) ],
 222                                         'showIfEmpty' => false,
 223                                         'msgKey' => [ 'moveddeleted-notice' ]
 224                                 ]
 225                         );
 226
 227                         return null;
 228                 }
 229
 230                 $ts = $this->getTimestampFromRequest( $request );
 231                 $tagFilter = $request->getVal( 'tagfilter' );
 232
 233                 /**
 234                  * Option to show only revisions that have been (partially) hidden via RevisionDelete
 235                  */
 236                 if ( $request->getBool( 'deleted' ) ) {
 237                         $conds = [ 'rev_deleted != 0' ];
 238                 } else {
 239                         $conds = [];
 240                 }
 241
 242                 // Add the general form.
 243                 $fields = [
 244                         [
 245                                 'name' => 'title',
 246                                 'type' => 'hidden',
 247                                 'default' => $this->getTitle()->getPrefixedDBkey(),
 248                         ],
 249                         [
 250                                 'name' => 'action',
 251                                 'type' => 'hidden',
 252                                 'default' => 'history',
 253                         ],
 254                         [
 255                                 'type' => 'date',
 256                                 'default' => $ts,
 257                                 'label' => $this->msg( 'date-range-to' )->text(),
 258                                 'name' => 'date-range-to',
 259                         ],
 260                         [
 261                                 'label-raw' => $this->msg( 'tag-filter' )->parse(),
 262                                 'type' => 'tagfilter',
 263                                 'id' => 'tagfilter',
 264                                 'name' => 'tagfilter',
 265                                 'value' => $tagFilter,
 266                         ]
 267                 ];
 268                 $permissionManager = MediaWikiServices::getInstance()->getPermissionManager();
 269                 if ( $permissionManager->userHasRight( $this->getUser(), 'deletedhistory' ) ) {
 270                         $fields[] = [
 271                                 'type' => 'check',
 272                                 'label' => $this->msg( 'history-show-deleted' )->text(),
 273                                 'default' => $request->getBool( 'deleted' ),
 274                                 'name' => 'deleted',
 275                         ];
 276                 }
 277
 278                 $out->enableOOUI();
 279                 $htmlForm = HTMLForm::factory( 'ooui', $fields, $this->getContext() );
 280                 $htmlForm
 281                         ->setMethod( 'get' )
 282                         ->setAction( wfScript() )
 283                         ->setCollapsibleOptions( true )
 284                         ->setId( 'mw-history-searchform' )
 285                         ->setSubmitText( $this->msg( 'historyaction-submit' )->text() )
 286                         ->setWrapperAttributes( [ 'id' => 'mw-history-search' ] )
 287                         ->setWrapperLegend( $this->msg( 'history-fieldset-title' )->text() );
 288                 $htmlForm->loadData();
 289
 290                 $out->addHTML( $htmlForm->getHTML( false ) );
 291
 292                 Hooks::run( 'PageHistoryBeforeList', [ &$this->page, $this->getContext() ] );
 293
 294                 // Create and output the list.
 295                 $dateComponents = explode( '-', $ts );
 296                 if ( count( $dateComponents ) > 1 ) {
 297                         $y = $dateComponents[0];
 298                         $m = $dateComponents[1];
 299                         $d = $dateComponents[2];
 300                 } else {
 301                         $y = '';
 302                         $m = '';
 303                         $d = '';
 304                 }
 305                 $pager = new HistoryPager( $this, $y, $m, $tagFilter, $conds, $d );
 306                 $out->addHTML(
 307                         $pager->getNavigationBar() .
 308                         $pager->getBody() .
 309                         $pager->getNavigationBar()
 310                 );
 311                 $out->preventClickjacking( $pager->getPreventClickjacking() );
 312
 313                 return null;
 314         }
 315
 316         /**
 317          * @return bool Page is watched by and has unseen revision for the user
 318          */
 319         private function hasUnseenRevisionMarkers() {
 320                 return (
 321                         $this->getContext()->getConfig()->get( 'ShowUpdatedMarker' ) &&
 322                         $this->getTitle()->getNotificationTimestamp( $this->getUser() )
 323                 );
 324         }
 325
 326         /**
 327          * Fetch an array of revisions, specified by a given limit, offset and
 328          * direction. This is now only used by the feeds. It was previously
 329          * used by the main UI but that's now handled by the pager.
 330          *
 331          * @param int $limit The limit number of revisions to get
 332          * @param int $offset
 333          * @param int $direction Either self::DIR_PREV or self::DIR_NEXT
 334          * @return IResultWrapper
 335          */
 336         function fetchRevisions( $limit, $offset, $direction ) {
 337                 // Fail if article doesn't exist.
 338                 if ( !$this->getTitle()->exists() ) {
 339                         return new FakeResultWrapper( [] );
 340                 }
 341
 342                 $dbr = wfGetDB( DB_REPLICA );
 343
 344                 if ( $direction === self::DIR_PREV ) {
 345                         list( $dirs, $oper ) = [ "ASC", ">=" ];
 346                 } else { /* $direction === self::DIR_NEXT */
 347                         list( $dirs, $oper ) = [ "DESC", "<=" ];
 348                 }
 349
 350                 if ( $offset ) {
 351                         $offsets = [ "rev_timestamp $oper " . $dbr->addQuotes( $dbr->timestamp( $offset ) ) ];
 352                 } else {
 353                         $offsets = [];
 354                 }
 355
 356                 $page_id = $this->page->getId();
 357
 358                 $revQuery = Revision::getQueryInfo();
 359                 return $dbr->select(
 360                         $revQuery['tables'],
 361                         $revQuery['fields'],
 362                         array_merge( [ 'rev_page' => $page_id ], $offsets ),
 363                         __METHOD__,
 364                         [
 365                                 'ORDER BY' => "rev_timestamp $dirs",
 366                                 'USE INDEX' => [ 'revision' => 'page_timestamp' ],
 367                                 'LIMIT' => $limit
 368                         ],
 369                         $revQuery['joins']
 370                 );
 371         }
 372
 373         /**
 374          * Output a subscription feed listing recent edits to this page.
 375          *
 376          * @param string $type Feed type
 377          */
 378         function feed( $type ) {
 379                 if ( !FeedUtils::checkFeedOutput( $type ) ) {
 380                         return;
 381                 }
 382                 $request = $this->getRequest();
 383
 384                 $feedClasses = $this->context->getConfig()->get( 'FeedClasses' );
 385                 /** @var RSSFeed|AtomFeed $feed */
 386                 $feed = new $feedClasses[$type](
 387                         $this->getTitle()->getPrefixedText() . ' - ' .
 388                         $this->msg( 'history-feed-title' )->inContentLanguage()->text(),
 389                         $this->msg( 'history-feed-description' )->inContentLanguage()->text(),
 390                         $this->getTitle()->getFullURL( 'action=history' )
 391                 );
 392
 393                 // Get a limit on number of feed entries. Provide a sane default
 394                 // of 10 if none is defined (but limit to $wgFeedLimit max)
 395                 $limit = $request->getInt( 'limit', 10 );
 396                 $limit = min(
 397                         max( $limit, 1 ),
 398                         $this->context->getConfig()->get( 'FeedLimit' )
 399                 );
 400
 401                 $items = $this->fetchRevisions( $limit, 0, self::DIR_NEXT );
 402
 403                 // Generate feed elements enclosed between header and footer.
 404                 $feed->outHeader();
 405                 if ( $items->numRows() ) {
 406                         foreach ( $items as $row ) {
 407                                 $feed->outItem( $this->feedItem( $row ) );
 408                         }
 409                 } else {
 410                         $feed->outItem( $this->feedEmpty() );
 411                 }
 412                 $feed->outFooter();
 413         }
 414
 415         function feedEmpty() {
 416                 return new FeedItem(
 417                         $this->msg( 'nohistory' )->inContentLanguage()->text(),
 418                         $this->msg( 'history-feed-empty' )->inContentLanguage()->parseAsBlock(),
 419                         $this->getTitle()->getFullURL(),
 420                         wfTimestamp( TS_MW ),
 421                         '',
 422                         $this->getTitle()->getTalkPage()->getFullURL()
 423                 );
 424         }
 425
 426         /**
 427          * Generate a FeedItem object from a given revision table row
 428          * Borrows Recent Changes' feed generation functions for formatting;
 429          * includes a diff to the previous revision (if any).
 430          *
 431          * @param stdClass|array $row Database row
 432          * @return FeedItem
 433          */
 434         function feedItem( $row ) {
 435                 $rev = new Revision( $row, 0, $this->getTitle() );
 436
 437                 $text = FeedUtils::formatDiffRow(
 438                         $this->getTitle(),
 439                         $this->getTitle()->getPreviousRevisionID( $rev->getId() ),
 440                         $rev->getId(),
 441                         $rev->getTimestamp(),
 442                         $rev->getComment()
 443                 );
 444                 if ( $rev->getComment() == '' ) {
 445                         $contLang = MediaWikiServices::getInstance()->getContentLanguage();
 446                         $title = $this->msg( 'history-feed-item-nocomment',
 447                                 $rev->getUserText(),
 448                                 $contLang->timeanddate( $rev->getTimestamp() ),
 449                                 $contLang->date( $rev->getTimestamp() ),
 450                                 $contLang->time( $rev->getTimestamp() )
 451                         )->inContentLanguage()->text();
 452                 } else {
 453                         $title = $rev->getUserText() .
 454                                 $this->msg( 'colon-separator' )->inContentLanguage()->text() .
 455                                 FeedItem::stripComment( $rev->getComment() );
 456                 }
 457
 458                 return new FeedItem(
 459                         $title,
 460                         $text,
 461                         $this->getTitle()->getFullURL( 'diff=' . $rev->getId() . '&oldid=prev' ),
 462                         $rev->getTimestamp(),
 463                         $rev->getUserText(),
 464                         $this->getTitle()->getTalkPage()->getFullURL()
 465                 );
 466         }
 467 }