includes/WatchlistEditor.php

   1 <?php
   2
   3 /**
   4  * Provides the UI through which users can perform editing
   5  * operations on their watchlist
   6  *
   7  * @ingroup Watchlist
   8  * @author Rob Church <robchur@gmail.com>
   9  */
  10 class WatchlistEditor {
  11
  12         /**
  13          * Editing modes
  14          */
  15         const EDIT_CLEAR = 1;
  16         const EDIT_RAW = 2;
  17         const EDIT_NORMAL = 3;
  18
  19         /**
  20          * Main execution point
  21          *
  22          * @param User $user
  23          * @param OutputPage $output
  24          * @param WebRequest $request
  25          * @param int $mode
  26          */
  27         public function execute( $user, $output, $request, $mode ) {
  28                 global $wgUser;
  29                 if( wfReadOnly() ) {
  30                         $output->readOnlyPage();
  31                         return;
  32                 }
  33                 switch( $mode ) {
  34                         case self::EDIT_CLEAR:
  35                                 // The "Clear" link scared people too much.
  36                                 // Pass on to the raw editor, from which it's very easy to clear.
  37                         case self::EDIT_RAW:
  38                                 $output->setPageTitle( wfMsg( 'watchlistedit-raw-title' ) );
  39                                 if( $request->wasPosted() && $this->checkToken( $request, $wgUser ) ) {
  40                                         $wanted = $this->extractTitles( $request->getText( 'titles' ) );
  41                                         $current = $this->getWatchlist( $user );
  42                                         if( count( $wanted ) > 0 ) {
  43                                                 $toWatch = array_diff( $wanted, $current );
  44                                                 $toUnwatch = array_diff( $current, $wanted );
  45                                                 $this->watchTitles( $toWatch, $user );
  46                                                 $this->unwatchTitles( $toUnwatch, $user );
  47                                                 $user->invalidateCache();
  48                                                 if( count( $toWatch ) > 0 || count( $toUnwatch ) > 0 )
  49                                                         $output->addHtml( wfMsgExt( 'watchlistedit-raw-done', 'parse' ) );
  50                                                 if( ( $count = count( $toWatch ) ) > 0 ) {
  51                                                         $output->addHtml( wfMsgExt( 'watchlistedit-raw-added', 'parse', $count ) );
  52                                                         $this->showTitles( $toWatch, $output, $wgUser->getSkin() );
  53                                                 }
  54                                                 if( ( $count = count( $toUnwatch ) ) > 0 ) {
  55                                                         $output->addHtml( wfMsgExt( 'watchlistedit-raw-removed', 'parse', $count ) );
  56                                                         $this->showTitles( $toUnwatch, $output, $wgUser->getSkin() );
  57                                                 }
  58                                         } else {
  59                                                 $this->clearWatchlist( $user );
  60                                                 $user->invalidateCache();
  61                                                 $output->addHtml( wfMsgExt( 'watchlistedit-raw-removed', 'parse', count( $current ) ) );
  62                                                 $this->showTitles( $current, $output, $wgUser->getSkin() );
  63                                         }
  64                                 }
  65                                 $this->showRawForm( $output, $user );
  66                                 break;
  67                         case self::EDIT_NORMAL:
  68                                 $output->setPageTitle( wfMsg( 'watchlistedit-normal-title' ) );
  69                                 if( $request->wasPosted() && $this->checkToken( $request, $wgUser ) ) {
  70                                         $titles = $this->extractTitles( $request->getArray( 'titles' ) );
  71                                         $this->unwatchTitles( $titles, $user );
  72                                         $user->invalidateCache();
  73                                         $output->addHtml( wfMsgExt( 'watchlistedit-normal-done', 'parse',
  74                                                 $GLOBALS['wgLang']->formatNum( count( $titles ) ) ) );
  75                                         $this->showTitles( $titles, $output, $wgUser->getSkin() );
  76                                 }
  77                                 $this->showNormalForm( $output, $user );
  78                 }
  79         }
  80
  81         /**
  82          * Check the edit token from a form submission
  83          *
  84          * @param WebRequest $request
  85          * @param User $user
  86          * @return bool
  87          */
  88         private function checkToken( $request, $user ) {
  89                 return $user->matchEditToken( $request->getVal( 'token' ), 'watchlistedit' );
  90         }
  91
  92         /**
  93          * Extract a list of titles from a blob of text, returning
  94          * (prefixed) strings; unwatchable titles are ignored
  95          *
  96          * @param mixed $list
  97          * @return array
  98          */
  99         private function extractTitles( $list ) {
 100                 $titles = array();
 101                 if( !is_array( $list ) ) {
 102                         $list = explode( "\n", trim( $list ) );
 103                         if( !is_array( $list ) )
 104                                 return array();
 105                 }
 106                 foreach( $list as $text ) {
 107                         $text = trim( $text );
 108                         if( strlen( $text ) > 0 ) {
 109                                 $title = Title::newFromText( $text );
 110                                 if( $title instanceof Title && $title->isWatchable() )
 111                                         $titles[] = $title->getPrefixedText();
 112                         }
 113                 }
 114                 return array_unique( $titles );
 115         }
 116
 117         /**
 118          * Print out a list of linked titles
 119          *
 120          * $titles can be an array of strings or Title objects; the former
 121          * is preferred, since Titles are very memory-heavy
 122          *
 123          * @param array $titles An array of strings, or Title objects
 124          * @param OutputPage $output
 125          * @param Skin $skin
 126          */
 127         private function showTitles( $titles, $output, $skin ) {
 128                 $talk = wfMsgHtml( 'talkpagelinktext' );
 129                 // Do a batch existence check
 130                 $batch = new LinkBatch();
 131                 foreach( $titles as $title ) {
 132                         if( !$title instanceof Title )
 133                                 $title = Title::newFromText( $title );
 134                         if( $title instanceof Title ) {
 135                                 $batch->addObj( $title );
 136                                 $batch->addObj( $title->getTalkPage() );
 137                         }
 138                 }
 139                 $batch->execute();
 140                 // Print out the list
 141                 $output->addHtml( "<ul>\n" );
 142                 foreach( $titles as $title ) {
 143                         if( !$title instanceof Title )
 144                                 $title = Title::newFromText( $title );
 145                         if( $title instanceof Title ) {
 146                                 $output->addHtml( "<li>" . $skin->makeLinkObj( $title )
 147                                 . ' (' . $skin->makeLinkObj( $title->getTalkPage(), $talk ) . ")</li>\n" );
 148                         }
 149                 }
 150                 $output->addHtml( "</ul>\n" );
 151         }
 152
 153         /**
 154          * Count the number of titles on a user's watchlist, excluding talk pages
 155          *
 156          * @param User $user
 157          * @return int
 158          */
 159         private function countWatchlist( $user ) {
 160                 $dbr = wfGetDB( DB_MASTER );
 161                 $res = $dbr->select( 'watchlist', 'COUNT(*) AS count', array( 'wl_user' => $user->getId() ), __METHOD__ );
 162                 $row = $dbr->fetchObject( $res );
 163                 return ceil( $row->count / 2 ); // Paranoia
 164         }
 165
 166         /**
 167          * Prepare a list of titles on a user's watchlist (excluding talk pages)
 168          * and return an array of (prefixed) strings
 169          *
 170          * @param User $user
 171          * @return array
 172          */
 173         private function getWatchlist( $user ) {
 174                 $list = array();
 175                 $dbr = wfGetDB( DB_MASTER );
 176                 $res = $dbr->select(
 177                         'watchlist',
 178                         '*',
 179                         array(
 180                                 'wl_user' => $user->getId(),
 181                         ),
 182                         __METHOD__
 183                 );
 184                 if( $res->numRows() > 0 ) {
 185                         while( $row = $res->fetchObject() ) {
 186                                 $title = Title::makeTitleSafe( $row->wl_namespace, $row->wl_title );
 187                                 if( $title instanceof Title && !$title->isTalkPage() )
 188                                         $list[] = $title->getPrefixedText();
 189                         }
 190                         $res->free();
 191                 }
 192                 return $list;
 193         }
 194
 195         /**
 196          * Get a list of titles on a user's watchlist, excluding talk pages,
 197          * and return as a two-dimensional array with namespace, title and
 198          * redirect status
 199          *
 200          * @param User $user
 201          * @return array
 202          */
 203         private function getWatchlistInfo( $user ) {
 204                 $titles = array();
 205                 $dbr = wfGetDB( DB_MASTER );
 206                 $uid = intval( $user->getId() );
 207                 list( $watchlist, $page ) = $dbr->tableNamesN( 'watchlist', 'page' );
 208                 $sql = "SELECT wl_namespace, wl_title, page_id, page_len, page_is_redirect
 209                         FROM {$watchlist} LEFT JOIN {$page} ON ( wl_namespace = page_namespace
 210                         AND wl_title = page_title ) WHERE wl_user = {$uid}";
 211                 $res = $dbr->query( $sql, __METHOD__ );
 212                 if( $res && $dbr->numRows( $res ) > 0 ) {
 213                         $cache = LinkCache::singleton();
 214                         while( $row = $dbr->fetchObject( $res ) ) {
 215                                 $title = Title::makeTitleSafe( $row->wl_namespace, $row->wl_title );
 216                                 if( $title instanceof Title ) {
 217                                         // Update the link cache while we're at it
 218                                         if( $row->page_id ) {
 219                                                 $cache->addGoodLinkObj( $row->page_id, $title, $row->page_len, $row->page_is_redirect );
 220                                         } else {
 221                                                 $cache->addBadLinkObj( $title );
 222                                         }
 223                                         // Ignore non-talk
 224                                         if( !$title->isTalkPage() )
 225                                                 $titles[$row->wl_namespace][$row->wl_title] = $row->page_is_redirect;
 226                                 }
 227                         }
 228                 }
 229                 return $titles;
 230         }
 231
 232         /**
 233          * Show a message indicating the number of items on the user's watchlist,
 234          * and return this count for additional checking
 235          *
 236          * @param OutputPage $output
 237          * @param User $user
 238          * @return int
 239          */
 240         private function showItemCount( $output, $user ) {
 241                 if( ( $count = $this->countWatchlist( $user ) ) > 0 ) {
 242                         $output->addHtml( wfMsgExt( 'watchlistedit-numitems', 'parse',
 243                                 $GLOBALS['wgLang']->formatNum( $count ) ) );
 244                 } else {
 245                         $output->addHtml( wfMsgExt( 'watchlistedit-noitems', 'parse' ) );
 246                 }
 247                 return $count;
 248         }
 249
 250         /**
 251          * Remove all titles from a user's watchlist
 252          *
 253          * @param User $user
 254          */
 255         private function clearWatchlist( $user ) {
 256                 $dbw = wfGetDB( DB_MASTER );
 257                 $dbw->delete( 'watchlist', array( 'wl_user' => $user->getId() ), __METHOD__ );
 258         }
 259
 260         /**
 261          * Add a list of titles to a user's watchlist
 262          *
 263          * $titles can be an array of strings or Title objects; the former
 264          * is preferred, since Titles are very memory-heavy
 265          *
 266          * @param array $titles An array of strings, or Title objects
 267          * @param User $user
 268          */
 269         private function watchTitles( $titles, $user ) {
 270                 $dbw = wfGetDB( DB_MASTER );
 271                 $rows = array();
 272                 foreach( $titles as $title ) {
 273                         if( !$title instanceof Title )
 274                                 $title = Title::newFromText( $title );
 275                         if( $title instanceof Title ) {
 276                                 $rows[] = array(
 277                                         'wl_user' => $user->getId(),
 278                                         'wl_namespace' => ( $title->getNamespace() & ~1 ),
 279                                         'wl_title' => $title->getDBkey(),
 280                                         'wl_notificationtimestamp' => null,
 281                                 );
 282                                 $rows[] = array(
 283                                         'wl_user' => $user->getId(),
 284                                         'wl_namespace' => ( $title->getNamespace() | 1 ),
 285                                         'wl_title' => $title->getDBkey(),
 286                                         'wl_notificationtimestamp' => null,
 287                                 );
 288                         }
 289                 }
 290                 $dbw->insert( 'watchlist', $rows, __METHOD__, 'IGNORE' );
 291         }
 292
 293         /**
 294          * Remove a list of titles from a user's watchlist
 295          *
 296          * $titles can be an array of strings or Title objects; the former
 297          * is preferred, since Titles are very memory-heavy
 298          *
 299          * @param array $titles An array of strings, or Title objects
 300          * @param User $user
 301          */
 302         private function unwatchTitles( $titles, $user ) {
 303                 $dbw = wfGetDB( DB_MASTER );
 304                 foreach( $titles as $title ) {
 305                         if( !$title instanceof Title )
 306                                 $title = Title::newFromText( $title );
 307                         if( $title instanceof Title ) {
 308                                 $dbw->delete(
 309                                         'watchlist',
 310                                         array(
 311                                                 'wl_user' => $user->getId(),
 312                                                 'wl_namespace' => ( $title->getNamespace() & ~1 ),
 313                                                 'wl_title' => $title->getDBkey(),
 314                                         ),
 315                                         __METHOD__
 316                                 );
 317                                 $dbw->delete(
 318                                         'watchlist',
 319                                         array(
 320                                                 'wl_user' => $user->getId(),
 321                                                 'wl_namespace' => ( $title->getNamespace() | 1 ),
 322                                                 'wl_title' => $title->getDBkey(),
 323                                         ),
 324                                         __METHOD__
 325                                 );
 326                         }
 327                 }
 328         }
 329
 330         /**
 331          * Show the standard watchlist editing form
 332          *
 333          * @param OutputPage $output
 334          * @param User $user
 335          */
 336         private function showNormalForm( $output, $user ) {
 337                 global $wgUser;
 338                 if( ( $count = $this->showItemCount( $output, $user ) ) > 0 ) {
 339                         $self = SpecialPage::getTitleFor( 'Watchlist' );
 340                         $form  = Xml::openElement( 'form', array( 'method' => 'post',
 341                                 'action' => $self->getLocalUrl( 'action=edit' ) ) );
 342                         $form .= Xml::hidden( 'token', $wgUser->editToken( 'watchlistedit' ) );
 343                         $form .= '<fieldset><legend>' . wfMsgHtml( 'watchlistedit-normal-legend' ) . '</legend>';
 344                         $form .= wfMsgExt( 'watchlistedit-normal-explain', 'parse' );
 345                         foreach( $this->getWatchlistInfo( $user ) as $namespace => $pages ) {
 346                                 $form .= '<h2>' . $this->getNamespaceHeading( $namespace ) . '</h2>';
 347                                 $form .= '<ul>';
 348                                 foreach( $pages as $dbkey => $redirect ) {
 349                                         $title = Title::makeTitleSafe( $namespace, $dbkey );
 350                                         $form .= $this->buildRemoveLine( $title, $redirect, $wgUser->getSkin() );
 351                                 }
 352                                 $form .= '</ul>';
 353                         }
 354                         $form .= '<p>' . Xml::submitButton( wfMsg( 'watchlistedit-normal-submit' ) ) . '</p>';
 355                         $form .= '</fieldset></form>';
 356                         $output->addHtml( $form );
 357                 }
 358         }
 359
 360         /**
 361          * Get the correct "heading" for a namespace
 362          *
 363          * @param int $namespace
 364          * @return string
 365          */
 366         private function getNamespaceHeading( $namespace ) {
 367                 return $namespace == NS_MAIN
 368                         ? wfMsgHtml( 'blanknamespace' )
 369                         : htmlspecialchars( $GLOBALS['wgContLang']->getFormattedNsText( $namespace ) );
 370         }
 371
 372         /**
 373          * Build a single list item containing a check box selecting a title
 374          * and a link to that title, with various additional bits
 375          *
 376          * @param Title $title
 377          * @param bool $redirect
 378          * @param Skin $skin
 379          * @return string
 380          */
 381         private function buildRemoveLine( $title, $redirect, $skin ) {
 382                 $link = $skin->makeLinkObj( $title );
 383                 if( $redirect )
 384                         $link = '<span class="watchlistredir">' . $link . '</span>';
 385                 $tools[] = $skin->makeLinkObj( $title->getTalkPage(), wfMsgHtml( 'talkpagelinktext' ) );
 386                 if( $title->exists() ) {
 387                         $tools[] = $skin->makeKnownLinkObj( $title, wfMsgHtml( 'history_short' ), 'action=history' );
 388                 }
 389                 if( $title->getNamespace() == NS_USER && !$title->isSubpage() ) {
 390                         $tools[] = $skin->makeKnownLinkObj( SpecialPage::getTitleFor( 'Contributions', $title->getText() ), wfMsgHtml( 'contributions' ) );
 391                 }
 392                 return '<li>'
 393                         . Xml::check( 'titles[]', false, array( 'value' => $title->getPrefixedText() ) )
 394                         . $link . ' (' . implode( ' | ', $tools ) . ')' . '</li>';
 395                 }
 396
 397         /**
 398          * Show a form for editing the watchlist in "raw" mode
 399          *
 400          * @param OutputPage $output
 401          * @param User $user
 402          */
 403         public function showRawForm( $output, $user ) {
 404                 global $wgUser;
 405                 $this->showItemCount( $output, $user );
 406                 $self = SpecialPage::getTitleFor( 'Watchlist' );
 407                 $form  = Xml::openElement( 'form', array( 'method' => 'post',
 408                         'action' => $self->getLocalUrl( 'action=raw' ) ) );
 409                 $form .= Xml::hidden( 'token', $wgUser->editToken( 'watchlistedit' ) );
 410                 $form .= '<fieldset><legend>' . wfMsgHtml( 'watchlistedit-raw-legend' ) . '</legend>';
 411                 $form .= wfMsgExt( 'watchlistedit-raw-explain', 'parse' );
 412                 $form .= Xml::label( wfMsg( 'watchlistedit-raw-titles' ), 'titles' );
 413                 $form .= "<br />\n";
 414                 $form .= Xml::openElement( 'textarea', array( 'id' => 'titles', 'name' => 'titles',
 415                         'rows' => $wgUser->getIntOption( 'rows' ), 'cols' => $wgUser->getIntOption( 'cols' ) ) );
 416                 $titles = $this->getWatchlist( $user );
 417                 foreach( $titles as $title )
 418                         $form .= htmlspecialchars( $title ) . "\n";
 419                 $form .= '</textarea>';
 420                 $form .= '<p>' . Xml::submitButton( wfMsg( 'watchlistedit-raw-submit' ) ) . '</p>';
 421                 $form .= '</fieldset></form>';
 422                 $output->addHtml( $form );
 423         }
 424
 425         /**
 426          * Determine whether we are editing the watchlist, and if so, what
 427          * kind of editing operation
 428          *
 429          * @param WebRequest $request
 430          * @param mixed $par
 431          * @return int
 432          */
 433         public static function getMode( $request, $par ) {
 434                 $mode = strtolower( $request->getVal( 'action', $par ) );
 435                 switch( $mode ) {
 436                         case 'clear':
 437                                 return self::EDIT_CLEAR;
 438                         case 'raw':
 439                                 return self::EDIT_RAW;
 440                         case 'edit':
 441                                 return self::EDIT_NORMAL;
 442                         default:
 443                                 return false;
 444                 }
 445         }
 446
 447         /**
 448          * Build a set of links for convenient navigation
 449          * between watchlist viewing and editing modes
 450          *
 451          * @param Skin $skin Skin to use
 452          * @return string
 453          */
 454         public static function buildTools( $skin ) {
 455                 $tools = array();
 456                 $modes = array( 'view' => false, 'edit' => 'edit', 'raw' => 'raw' );
 457                 foreach( $modes as $mode => $subpage ) {
 458                         $tools[] = $skin->makeKnownLinkObj( SpecialPage::getTitleFor( 'Watchlist', $subpage ), wfMsgHtml( "watchlisttools-{$mode}" ) );
 459                 }
 460                 return implode( ' | ', $tools );
 461         }
 462 }