includes/WatchedItemStore.php

   1 <?php
   2
   3 use Wikimedia\Rdbms\IDatabase;
   4 use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
   5 use MediaWiki\Linker\LinkTarget;
   6 use MediaWiki\MediaWikiServices;
   7 use Wikimedia\Assert\Assert;
   8 use Wikimedia\ScopedCallback;
   9 use Wikimedia\Rdbms\LoadBalancer;
  10 use Wikimedia\Rdbms\DBUnexpectedError;
  11
  12 /**
  13  * Storage layer class for WatchedItems.
  14  * Database interaction.
  15  *
  16  * Uses database because this uses User::isAnon
  17  *
  18  * @group Database
  19  *
  20  * @author Addshore
  21  * @since 1.27
  22  */
  23 class WatchedItemStore implements StatsdAwareInterface {
  24
  25         const SORT_DESC = 'DESC';
  26         const SORT_ASC = 'ASC';
  27
  28         /**
  29          * @var LoadBalancer
  30          */
  31         private $loadBalancer;
  32
  33         /**
  34          * @var ReadOnlyMode
  35          */
  36         private $readOnlyMode;
  37
  38         /**
  39          * @var HashBagOStuff
  40          */
  41         private $cache;
  42
  43         /**
  44          * @var array[] Looks like $cacheIndex[Namespace ID][Target DB Key][User Id] => 'key'
  45          * The index is needed so that on mass changes all relevant items can be un-cached.
  46          * For example: Clearing a users watchlist of all items or updating notification timestamps
  47          *              for all users watching a single target.
  48          */
  49         private $cacheIndex = [];
  50
  51         /**
  52          * @var callable|null
  53          */
  54         private $deferredUpdatesAddCallableUpdateCallback;
  55
  56         /**
  57          * @var callable|null
  58          */
  59         private $revisionGetTimestampFromIdCallback;
  60
  61         /**
  62          * @var StatsdDataFactoryInterface
  63          */
  64         private $stats;
  65
  66         /**
  67          * @param LoadBalancer $loadBalancer
  68          * @param HashBagOStuff $cache
  69          * @param ReadOnlyMode $readOnlyMode
  70          */
  71         public function __construct(
  72                 LoadBalancer $loadBalancer,
  73                 HashBagOStuff $cache,
  74                 ReadOnlyMode $readOnlyMode
  75         ) {
  76                 $this->loadBalancer = $loadBalancer;
  77                 $this->cache = $cache;
  78                 $this->readOnlyMode = $readOnlyMode;
  79                 $this->stats = new NullStatsdDataFactory();
  80                 $this->deferredUpdatesAddCallableUpdateCallback = [ 'DeferredUpdates', 'addCallableUpdate' ];
  81                 $this->revisionGetTimestampFromIdCallback = [ 'Revision', 'getTimestampFromId' ];
  82         }
  83
  84         public function setStatsdDataFactory( StatsdDataFactoryInterface $stats ) {
  85                 $this->stats = $stats;
  86         }
  87
  88         /**
  89          * Overrides the DeferredUpdates::addCallableUpdate callback
  90          * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
  91          *
  92          * @param callable $callback
  93          *
  94          * @see DeferredUpdates::addCallableUpdate for callback signiture
  95          *
  96          * @return ScopedCallback to reset the overridden value
  97          * @throws MWException
  98          */
  99         public function overrideDeferredUpdatesAddCallableUpdateCallback( callable $callback ) {
 100                 if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
 101                         throw new MWException(
 102                                 'Cannot override DeferredUpdates::addCallableUpdate callback in operation.'
 103                         );
 104                 }
 105                 $previousValue = $this->deferredUpdatesAddCallableUpdateCallback;
 106                 $this->deferredUpdatesAddCallableUpdateCallback = $callback;
 107                 return new ScopedCallback( function () use ( $previousValue ) {
 108                         $this->deferredUpdatesAddCallableUpdateCallback = $previousValue;
 109                 } );
 110         }
 111
 112         /**
 113          * Overrides the Revision::getTimestampFromId callback
 114          * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
 115          *
 116          * @param callable $callback
 117          * @see Revision::getTimestampFromId for callback signiture
 118          *
 119          * @return ScopedCallback to reset the overridden value
 120          * @throws MWException
 121          */
 122         public function overrideRevisionGetTimestampFromIdCallback( callable $callback ) {
 123                 if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
 124                         throw new MWException(
 125                                 'Cannot override Revision::getTimestampFromId callback in operation.'
 126                         );
 127                 }
 128                 $previousValue = $this->revisionGetTimestampFromIdCallback;
 129                 $this->revisionGetTimestampFromIdCallback = $callback;
 130                 return new ScopedCallback( function () use ( $previousValue ) {
 131                         $this->revisionGetTimestampFromIdCallback = $previousValue;
 132                 } );
 133         }
 134
 135         private function getCacheKey( User $user, LinkTarget $target ) {
 136                 return $this->cache->makeKey(
 137                         (string)$target->getNamespace(),
 138                         $target->getDBkey(),
 139                         (string)$user->getId()
 140                 );
 141         }
 142
 143         private function cache( WatchedItem $item ) {
 144                 $user = $item->getUser();
 145                 $target = $item->getLinkTarget();
 146                 $key = $this->getCacheKey( $user, $target );
 147                 $this->cache->set( $key, $item );
 148                 $this->cacheIndex[$target->getNamespace()][$target->getDBkey()][$user->getId()] = $key;
 149                 $this->stats->increment( 'WatchedItemStore.cache' );
 150         }
 151
 152         private function uncache( User $user, LinkTarget $target ) {
 153                 $this->cache->delete( $this->getCacheKey( $user, $target ) );
 154                 unset( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()][$user->getId()] );
 155                 $this->stats->increment( 'WatchedItemStore.uncache' );
 156         }
 157
 158         private function uncacheLinkTarget( LinkTarget $target ) {
 159                 $this->stats->increment( 'WatchedItemStore.uncacheLinkTarget' );
 160                 if ( !isset( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()] ) ) {
 161                         return;
 162                 }
 163                 foreach ( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()] as $key ) {
 164                         $this->stats->increment( 'WatchedItemStore.uncacheLinkTarget.items' );
 165                         $this->cache->delete( $key );
 166                 }
 167         }
 168
 169         private function uncacheUser( User $user ) {
 170                 $this->stats->increment( 'WatchedItemStore.uncacheUser' );
 171                 foreach ( $this->cacheIndex as $ns => $dbKeyArray ) {
 172                         foreach ( $dbKeyArray as $dbKey => $userArray ) {
 173                                 if ( isset( $userArray[$user->getId()] ) ) {
 174                                         $this->stats->increment( 'WatchedItemStore.uncacheUser.items' );
 175                                         $this->cache->delete( $userArray[$user->getId()] );
 176                                 }
 177                         }
 178                 }
 179         }
 180
 181         /**
 182          * @param User $user
 183          * @param LinkTarget $target
 184          *
 185          * @return WatchedItem|false
 186          */
 187         private function getCached( User $user, LinkTarget $target ) {
 188                 return $this->cache->get( $this->getCacheKey( $user, $target ) );
 189         }
 190
 191         /**
 192          * Return an array of conditions to select or update the appropriate database
 193          * row.
 194          *
 195          * @param User $user
 196          * @param LinkTarget $target
 197          *
 198          * @return array
 199          */
 200         private function dbCond( User $user, LinkTarget $target ) {
 201                 return [
 202                         'wl_user' => $user->getId(),
 203                         'wl_namespace' => $target->getNamespace(),
 204                         'wl_title' => $target->getDBkey(),
 205                 ];
 206         }
 207
 208         /**
 209          * @param int $dbIndex DB_MASTER or DB_REPLICA
 210          *
 211          * @return IDatabase
 212          * @throws MWException
 213          */
 214         private function getConnectionRef( $dbIndex ) {
 215                 return $this->loadBalancer->getConnectionRef( $dbIndex, [ 'watchlist' ] );
 216         }
 217
 218         /**
 219          * Count the number of individual items that are watched by the user.
 220          * If a subject and corresponding talk page are watched this will return 2.
 221          *
 222          * @param User $user
 223          *
 224          * @return int
 225          */
 226         public function countWatchedItems( User $user ) {
 227                 $dbr = $this->getConnectionRef( DB_REPLICA );
 228                 $return = (int)$dbr->selectField(
 229                         'watchlist',
 230                         'COUNT(*)',
 231                         [
 232                                 'wl_user' => $user->getId()
 233                         ],
 234                         __METHOD__
 235                 );
 236
 237                 return $return;
 238         }
 239
 240         /**
 241          * @param LinkTarget $target
 242          *
 243          * @return int
 244          */
 245         public function countWatchers( LinkTarget $target ) {
 246                 $dbr = $this->getConnectionRef( DB_REPLICA );
 247                 $return = (int)$dbr->selectField(
 248                         'watchlist',
 249                         'COUNT(*)',
 250                         [
 251                                 'wl_namespace' => $target->getNamespace(),
 252                                 'wl_title' => $target->getDBkey(),
 253                         ],
 254                         __METHOD__
 255                 );
 256
 257                 return $return;
 258         }
 259
 260         /**
 261          * Number of page watchers who also visited a "recent" edit
 262          *
 263          * @param LinkTarget $target
 264          * @param mixed $threshold timestamp accepted by wfTimestamp
 265          *
 266          * @return int
 267          * @throws DBUnexpectedError
 268          * @throws MWException
 269          */
 270         public function countVisitingWatchers( LinkTarget $target, $threshold ) {
 271                 $dbr = $this->getConnectionRef( DB_REPLICA );
 272                 $visitingWatchers = (int)$dbr->selectField(
 273                         'watchlist',
 274                         'COUNT(*)',
 275                         [
 276                                 'wl_namespace' => $target->getNamespace(),
 277                                 'wl_title' => $target->getDBkey(),
 278                                 'wl_notificationtimestamp >= ' .
 279                                 $dbr->addQuotes( $dbr->timestamp( $threshold ) ) .
 280                                 ' OR wl_notificationtimestamp IS NULL'
 281                         ],
 282                         __METHOD__
 283                 );
 284
 285                 return $visitingWatchers;
 286         }
 287
 288         /**
 289          * @param LinkTarget[] $targets
 290          * @param array $options Allowed keys:
 291          *        'minimumWatchers' => int
 292          *
 293          * @return array multi dimensional like $return[$namespaceId][$titleString] = int $watchers
 294          *         All targets will be present in the result. 0 either means no watchers or the number
 295          *         of watchers was below the minimumWatchers option if passed.
 296          */
 297         public function countWatchersMultiple( array $targets, array $options = [] ) {
 298                 $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
 299
 300                 $dbr = $this->getConnectionRef( DB_REPLICA );
 301
 302                 if ( array_key_exists( 'minimumWatchers', $options ) ) {
 303                         $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$options['minimumWatchers'];
 304                 }
 305
 306                 $lb = new LinkBatch( $targets );
 307                 $res = $dbr->select(
 308                         'watchlist',
 309                         [ 'wl_title', 'wl_namespace', 'watchers' => 'COUNT(*)' ],
 310                         [ $lb->constructSet( 'wl', $dbr ) ],
 311                         __METHOD__,
 312                         $dbOptions
 313                 );
 314
 315                 $watchCounts = [];
 316                 foreach ( $targets as $linkTarget ) {
 317                         $watchCounts[$linkTarget->getNamespace()][$linkTarget->getDBkey()] = 0;
 318                 }
 319
 320                 foreach ( $res as $row ) {
 321                         $watchCounts[$row->wl_namespace][$row->wl_title] = (int)$row->watchers;
 322                 }
 323
 324                 return $watchCounts;
 325         }
 326
 327         /**
 328          * Number of watchers of each page who have visited recent edits to that page
 329          *
 330          * @param array $targetsWithVisitThresholds array of pairs (LinkTarget $target, mixed $threshold),
 331          *        $threshold is:
 332          *        - a timestamp of the recent edit if $target exists (format accepted by wfTimestamp)
 333          *        - null if $target doesn't exist
 334          * @param int|null $minimumWatchers
 335          * @return array multi-dimensional like $return[$namespaceId][$titleString] = $watchers,
 336          *         where $watchers is an int:
 337          *         - if the page exists, number of users watching who have visited the page recently
 338          *         - if the page doesn't exist, number of users that have the page on their watchlist
 339          *         - 0 means there are no visiting watchers or their number is below the minimumWatchers
 340          *         option (if passed).
 341          */
 342         public function countVisitingWatchersMultiple(
 343                 array $targetsWithVisitThresholds,
 344                 $minimumWatchers = null
 345         ) {
 346                 $dbr = $this->getConnectionRef( DB_REPLICA );
 347
 348                 $conds = $this->getVisitingWatchersCondition( $dbr, $targetsWithVisitThresholds );
 349
 350                 $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
 351                 if ( $minimumWatchers !== null ) {
 352                         $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$minimumWatchers;
 353                 }
 354                 $res = $dbr->select(
 355                         'watchlist',
 356                         [ 'wl_namespace', 'wl_title', 'watchers' => 'COUNT(*)' ],
 357                         $conds,
 358                         __METHOD__,
 359                         $dbOptions
 360                 );
 361
 362                 $watcherCounts = [];
 363                 foreach ( $targetsWithVisitThresholds as list( $target ) ) {
 364                         /* @var LinkTarget $target */
 365                         $watcherCounts[$target->getNamespace()][$target->getDBkey()] = 0;
 366                 }
 367
 368                 foreach ( $res as $row ) {
 369                         $watcherCounts[$row->wl_namespace][$row->wl_title] = (int)$row->watchers;
 370                 }
 371
 372                 return $watcherCounts;
 373         }
 374
 375         /**
 376          * Generates condition for the query used in a batch count visiting watchers.
 377          *
 378          * @param IDatabase $db
 379          * @param array $targetsWithVisitThresholds array of pairs (LinkTarget, last visit threshold)
 380          * @return string
 381          */
 382         private function getVisitingWatchersCondition(
 383                 IDatabase $db,
 384                 array $targetsWithVisitThresholds
 385         ) {
 386                 $missingTargets = [];
 387                 $namespaceConds = [];
 388                 foreach ( $targetsWithVisitThresholds as list( $target, $threshold ) ) {
 389                         if ( $threshold === null ) {
 390                                 $missingTargets[] = $target;
 391                                 continue;
 392                         }
 393                         /* @var LinkTarget $target */
 394                         $namespaceConds[$target->getNamespace()][] = $db->makeList( [
 395                                 'wl_title = ' . $db->addQuotes( $target->getDBkey() ),
 396                                 $db->makeList( [
 397                                         'wl_notificationtimestamp >= ' . $db->addQuotes( $db->timestamp( $threshold ) ),
 398                                         'wl_notificationtimestamp IS NULL'
 399                                 ], LIST_OR )
 400                         ], LIST_AND );
 401                 }
 402
 403                 $conds = [];
 404                 foreach ( $namespaceConds as $namespace => $pageConds ) {
 405                         $conds[] = $db->makeList( [
 406                                 'wl_namespace = ' . $namespace,
 407                                 '(' . $db->makeList( $pageConds, LIST_OR ) . ')'
 408                         ], LIST_AND );
 409                 }
 410
 411                 if ( $missingTargets ) {
 412                         $lb = new LinkBatch( $missingTargets );
 413                         $conds[] = $lb->constructSet( 'wl', $db );
 414                 }
 415
 416                 return $db->makeList( $conds, LIST_OR );
 417         }
 418
 419         /**
 420          * Get an item (may be cached)
 421          *
 422          * @param User $user
 423          * @param LinkTarget $target
 424          *
 425          * @return WatchedItem|false
 426          */
 427         public function getWatchedItem( User $user, LinkTarget $target ) {
 428                 if ( $user->isAnon() ) {
 429                         return false;
 430                 }
 431
 432                 $cached = $this->getCached( $user, $target );
 433                 if ( $cached ) {
 434                         $this->stats->increment( 'WatchedItemStore.getWatchedItem.cached' );
 435                         return $cached;
 436                 }
 437                 $this->stats->increment( 'WatchedItemStore.getWatchedItem.load' );
 438                 return $this->loadWatchedItem( $user, $target );
 439         }
 440
 441         /**
 442          * Loads an item from the db
 443          *
 444          * @param User $user
 445          * @param LinkTarget $target
 446          *
 447          * @return WatchedItem|false
 448          */
 449         public function loadWatchedItem( User $user, LinkTarget $target ) {
 450                 // Only loggedin user can have a watchlist
 451                 if ( $user->isAnon() ) {
 452                         return false;
 453                 }
 454
 455                 $dbr = $this->getConnectionRef( DB_REPLICA );
 456                 $row = $dbr->selectRow(
 457                         'watchlist',
 458                         'wl_notificationtimestamp',
 459                         $this->dbCond( $user, $target ),
 460                         __METHOD__
 461                 );
 462
 463                 if ( !$row ) {
 464                         return false;
 465                 }
 466
 467                 $item = new WatchedItem(
 468                         $user,
 469                         $target,
 470                         wfTimestampOrNull( TS_MW, $row->wl_notificationtimestamp )
 471                 );
 472                 $this->cache( $item );
 473
 474                 return $item;
 475         }
 476
 477         /**
 478          * @param User $user
 479          * @param array $options Allowed keys:
 480          *        'forWrite' => bool defaults to false
 481          *        'sort' => string optional sorting by namespace ID and title
 482          *                     one of the self::SORT_* constants
 483          *
 484          * @return WatchedItem[]
 485          */
 486         public function getWatchedItemsForUser( User $user, array $options = [] ) {
 487                 $options += [ 'forWrite' => false ];
 488
 489                 $dbOptions = [];
 490                 if ( array_key_exists( 'sort', $options ) ) {
 491                         Assert::parameter(
 492                                 ( in_array( $options['sort'], [ self::SORT_ASC, self::SORT_DESC ] ) ),
 493                                 '$options[\'sort\']',
 494                                 'must be SORT_ASC or SORT_DESC'
 495                         );
 496                         $dbOptions['ORDER BY'] = [
 497                                 "wl_namespace {$options['sort']}",
 498                                 "wl_title {$options['sort']}"
 499                         ];
 500                 }
 501                 $db = $this->getConnectionRef( $options['forWrite'] ? DB_MASTER : DB_REPLICA );
 502
 503                 $res = $db->select(
 504                         'watchlist',
 505                         [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
 506                         [ 'wl_user' => $user->getId() ],
 507                         __METHOD__,
 508                         $dbOptions
 509                 );
 510
 511                 $watchedItems = [];
 512                 foreach ( $res as $row ) {
 513                         // @todo: Should we add these to the process cache?
 514                         $watchedItems[] = new WatchedItem(
 515                                 $user,
 516                                 new TitleValue( (int)$row->wl_namespace, $row->wl_title ),
 517                                 $row->wl_notificationtimestamp
 518                         );
 519                 }
 520
 521                 return $watchedItems;
 522         }
 523
 524         /**
 525          * Must be called separately for Subject & Talk namespaces
 526          *
 527          * @param User $user
 528          * @param LinkTarget $target
 529          *
 530          * @return bool
 531          */
 532         public function isWatched( User $user, LinkTarget $target ) {
 533                 return (bool)$this->getWatchedItem( $user, $target );
 534         }
 535
 536         /**
 537          * @param User $user
 538          * @param LinkTarget[] $targets
 539          *
 540          * @return array multi-dimensional like $return[$namespaceId][$titleString] = $timestamp,
 541          *         where $timestamp is:
 542          *         - string|null value of wl_notificationtimestamp,
 543          *         - false if $target is not watched by $user.
 544          */
 545         public function getNotificationTimestampsBatch( User $user, array $targets ) {
 546                 $timestamps = [];
 547                 foreach ( $targets as $target ) {
 548                         $timestamps[$target->getNamespace()][$target->getDBkey()] = false;
 549                 }
 550
 551                 if ( $user->isAnon() ) {
 552                         return $timestamps;
 553                 }
 554
 555                 $targetsToLoad = [];
 556                 foreach ( $targets as $target ) {
 557                         $cachedItem = $this->getCached( $user, $target );
 558                         if ( $cachedItem ) {
 559                                 $timestamps[$target->getNamespace()][$target->getDBkey()] =
 560                                         $cachedItem->getNotificationTimestamp();
 561                         } else {
 562                                 $targetsToLoad[] = $target;
 563                         }
 564                 }
 565
 566                 if ( !$targetsToLoad ) {
 567                         return $timestamps;
 568                 }
 569
 570                 $dbr = $this->getConnectionRef( DB_REPLICA );
 571
 572                 $lb = new LinkBatch( $targetsToLoad );
 573                 $res = $dbr->select(
 574                         'watchlist',
 575                         [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
 576                         [
 577                                 $lb->constructSet( 'wl', $dbr ),
 578                                 'wl_user' => $user->getId(),
 579                         ],
 580                         __METHOD__
 581                 );
 582
 583                 foreach ( $res as $row ) {
 584                         $timestamps[$row->wl_namespace][$row->wl_title] =
 585                                 wfTimestampOrNull( TS_MW, $row->wl_notificationtimestamp );
 586                 }
 587
 588                 return $timestamps;
 589         }
 590
 591         /**
 592          * Must be called separately for Subject & Talk namespaces
 593          *
 594          * @param User $user
 595          * @param LinkTarget $target
 596          */
 597         public function addWatch( User $user, LinkTarget $target ) {
 598                 $this->addWatchBatchForUser( $user, [ $target ] );
 599         }
 600
 601         /**
 602          * @param User $user
 603          * @param LinkTarget[] $targets
 604          *
 605          * @return bool success
 606          */
 607         public function addWatchBatchForUser( User $user, array $targets ) {
 608                 if ( $this->readOnlyMode->isReadOnly() ) {
 609                         return false;
 610                 }
 611                 // Only loggedin user can have a watchlist
 612                 if ( $user->isAnon() ) {
 613                         return false;
 614                 }
 615
 616                 if ( !$targets ) {
 617                         return true;
 618                 }
 619
 620                 $rows = [];
 621                 $items = [];
 622                 foreach ( $targets as $target ) {
 623                         $rows[] = [
 624                                 'wl_user' => $user->getId(),
 625                                 'wl_namespace' => $target->getNamespace(),
 626                                 'wl_title' => $target->getDBkey(),
 627                                 'wl_notificationtimestamp' => null,
 628                         ];
 629                         $items[] = new WatchedItem(
 630                                 $user,
 631                                 $target,
 632                                 null
 633                         );
 634                         $this->uncache( $user, $target );
 635                 }
 636
 637                 $dbw = $this->getConnectionRef( DB_MASTER );
 638                 foreach ( array_chunk( $rows, 100 ) as $toInsert ) {
 639                         // Use INSERT IGNORE to avoid overwriting the notification timestamp
 640                         // if there's already an entry for this page
 641                         $dbw->insert( 'watchlist', $toInsert, __METHOD__, 'IGNORE' );
 642                 }
 643                 // Update process cache to ensure skin doesn't claim that the current
 644                 // page is unwatched in the response of action=watch itself (T28292).
 645                 // This would otherwise be re-queried from a slave by isWatched().
 646                 foreach ( $items as $item ) {
 647                         $this->cache( $item );
 648                 }
 649
 650                 return true;
 651         }
 652
 653         /**
 654          * Removes the an entry for the User watching the LinkTarget
 655          * Must be called separately for Subject & Talk namespaces
 656          *
 657          * @param User $user
 658          * @param LinkTarget $target
 659          *
 660          * @return bool success
 661          * @throws DBUnexpectedError
 662          * @throws MWException
 663          */
 664         public function removeWatch( User $user, LinkTarget $target ) {
 665                 // Only logged in user can have a watchlist
 666                 if ( $this->readOnlyMode->isReadOnly() || $user->isAnon() ) {
 667                         return false;
 668                 }
 669
 670                 $this->uncache( $user, $target );
 671
 672                 $dbw = $this->getConnectionRef( DB_MASTER );
 673                 $dbw->delete( 'watchlist',
 674                         [
 675                                 'wl_user' => $user->getId(),
 676                                 'wl_namespace' => $target->getNamespace(),
 677                                 'wl_title' => $target->getDBkey(),
 678                         ], __METHOD__
 679                 );
 680                 $success = (bool)$dbw->affectedRows();
 681
 682                 return $success;
 683         }
 684
 685         /**
 686          * @param User $user The user to set the timestamp for
 687          * @param string|null $timestamp Set the update timestamp to this value
 688          * @param LinkTarget[] $targets List of targets to update. Default to all targets
 689          *
 690          * @return bool success
 691          */
 692         public function setNotificationTimestampsForUser( User $user, $timestamp, array $targets = [] ) {
 693                 // Only loggedin user can have a watchlist
 694                 if ( $user->isAnon() ) {
 695                         return false;
 696                 }
 697
 698                 $dbw = $this->getConnectionRef( DB_MASTER );
 699
 700                 $conds = [ 'wl_user' => $user->getId() ];
 701                 if ( $targets ) {
 702                         $batch = new LinkBatch( $targets );
 703                         $conds[] = $batch->constructSet( 'wl', $dbw );
 704                 }
 705
 706                 if ( $timestamp !== null ) {
 707                         $timestamp = $dbw->timestamp( $timestamp );
 708                 }
 709
 710                 $success = $dbw->update(
 711                         'watchlist',
 712                         [ 'wl_notificationtimestamp' => $timestamp ],
 713                         $conds,
 714                         __METHOD__
 715                 );
 716
 717                 $this->uncacheUser( $user );
 718
 719                 return $success;
 720         }
 721
 722         /**
 723          * @param User $editor The editor that triggered the update. Their notification
 724          *  timestamp will not be updated(they have already seen it)
 725          * @param LinkTarget $target The target to update timestamps for
 726          * @param string $timestamp Set the update timestamp to this value
 727          *
 728          * @return int[] Array of user IDs the timestamp has been updated for
 729          */
 730         public function updateNotificationTimestamp( User $editor, LinkTarget $target, $timestamp ) {
 731                 $dbw = $this->getConnectionRef( DB_MASTER );
 732                 $uids = $dbw->selectFieldValues(
 733                         'watchlist',
 734                         'wl_user',
 735                         [
 736                                 'wl_user != ' . intval( $editor->getId() ),
 737                                 'wl_namespace' => $target->getNamespace(),
 738                                 'wl_title' => $target->getDBkey(),
 739                                 'wl_notificationtimestamp IS NULL',
 740                         ],
 741                         __METHOD__
 742                 );
 743
 744                 $watchers = array_map( 'intval', $uids );
 745                 if ( $watchers ) {
 746                         // Update wl_notificationtimestamp for all watching users except the editor
 747                         $fname = __METHOD__;
 748                         DeferredUpdates::addCallableUpdate(
 749                                 function () use ( $timestamp, $watchers, $target, $fname ) {
 750                                         global $wgUpdateRowsPerQuery;
 751
 752                                         $dbw = $this->getConnectionRef( DB_MASTER );
 753                                         $factory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
 754                                         $ticket = $factory->getEmptyTransactionTicket( __METHOD__ );
 755
 756                                         $watchersChunks = array_chunk( $watchers, $wgUpdateRowsPerQuery );
 757                                         foreach ( $watchersChunks as $watchersChunk ) {
 758                                                 $dbw->update( 'watchlist',
 759                                                         [ /* SET */
 760                                                                 'wl_notificationtimestamp' => $dbw->timestamp( $timestamp )
 761                                                         ], [ /* WHERE - TODO Use wl_id T130067 */
 762                                                                 'wl_user' => $watchersChunk,
 763                                                                 'wl_namespace' => $target->getNamespace(),
 764                                                                 'wl_title' => $target->getDBkey(),
 765                                                         ], $fname
 766                                                 );
 767                                                 if ( count( $watchersChunks ) > 1 ) {
 768                                                         $factory->commitAndWaitForReplication(
 769                                                                 __METHOD__, $ticket, [ 'wiki' => $dbw->getWikiID() ]
 770                                                         );
 771                                                 }
 772                                         }
 773                                         $this->uncacheLinkTarget( $target );
 774                                 },
 775                                 DeferredUpdates::POSTSEND,
 776                                 $dbw
 777                         );
 778                 }
 779
 780                 return $watchers;
 781         }
 782
 783         /**
 784          * Reset the notification timestamp of this entry
 785          *
 786          * @param User $user
 787          * @param Title $title
 788          * @param string $force Whether to force the write query to be executed even if the
 789          *    page is not watched or the notification timestamp is already NULL.
 790          *    'force' in order to force
 791          * @param int $oldid The revision id being viewed. If not given or 0, latest revision is assumed.
 792          *
 793          * @return bool success
 794          */
 795         public function resetNotificationTimestamp( User $user, Title $title, $force = '', $oldid = 0 ) {
 796                 // Only loggedin user can have a watchlist
 797                 if ( $this->readOnlyMode->isReadOnly() || $user->isAnon() ) {
 798                         return false;
 799                 }
 800
 801                 $item = null;
 802                 if ( $force != 'force' ) {
 803                         $item = $this->loadWatchedItem( $user, $title );
 804                         if ( !$item || $item->getNotificationTimestamp() === null ) {
 805                                 return false;
 806                         }
 807                 }
 808
 809                 // If the page is watched by the user (or may be watched), update the timestamp
 810                 $job = new ActivityUpdateJob(
 811                         $title,
 812                         [
 813                                 'type'      => 'updateWatchlistNotification',
 814                                 'userid'    => $user->getId(),
 815                                 'notifTime' => $this->getNotificationTimestamp( $user, $title, $item, $force, $oldid ),
 816                                 'curTime'   => time()
 817                         ]
 818                 );
 819
 820                 // Try to run this post-send
 821                 // Calls DeferredUpdates::addCallableUpdate in normal operation
 822                 call_user_func(
 823                         $this->deferredUpdatesAddCallableUpdateCallback,
 824                         function () use ( $job ) {
 825                                 $job->run();
 826                         }
 827                 );
 828
 829                 $this->uncache( $user, $title );
 830
 831                 return true;
 832         }
 833
 834         private function getNotificationTimestamp( User $user, Title $title, $item, $force, $oldid ) {
 835                 if ( !$oldid ) {
 836                         // No oldid given, assuming latest revision; clear the timestamp.
 837                         return null;
 838                 }
 839
 840                 if ( !$title->getNextRevisionID( $oldid ) ) {
 841                         // Oldid given and is the latest revision for this title; clear the timestamp.
 842                         return null;
 843                 }
 844
 845                 if ( $item === null ) {
 846                         $item = $this->loadWatchedItem( $user, $title );
 847                 }
 848
 849                 if ( !$item ) {
 850                         // This can only happen if $force is enabled.
 851                         return null;
 852                 }
 853
 854                 // Oldid given and isn't the latest; update the timestamp.
 855                 // This will result in no further notification emails being sent!
 856                 // Calls Revision::getTimestampFromId in normal operation
 857                 $notificationTimestamp = call_user_func(
 858                         $this->revisionGetTimestampFromIdCallback,
 859                         $title,
 860                         $oldid
 861                 );
 862
 863                 // We need to go one second to the future because of various strict comparisons
 864                 // throughout the codebase
 865                 $ts = new MWTimestamp( $notificationTimestamp );
 866                 $ts->timestamp->add( new DateInterval( 'PT1S' ) );
 867                 $notificationTimestamp = $ts->getTimestamp( TS_MW );
 868
 869                 if ( $notificationTimestamp < $item->getNotificationTimestamp() ) {
 870                         if ( $force != 'force' ) {
 871                                 return false;
 872                         } else {
 873                                 // This is a little silly…
 874                                 return $item->getNotificationTimestamp();
 875                         }
 876                 }
 877
 878                 return $notificationTimestamp;
 879         }
 880
 881         /**
 882          * @param User $user
 883          * @param int $unreadLimit
 884          *
 885          * @return int|bool The number of unread notifications
 886          *                  true if greater than or equal to $unreadLimit
 887          */
 888         public function countUnreadNotifications( User $user, $unreadLimit = null ) {
 889                 $queryOptions = [];
 890                 if ( $unreadLimit !== null ) {
 891                         $unreadLimit = (int)$unreadLimit;
 892                         $queryOptions['LIMIT'] = $unreadLimit;
 893                 }
 894
 895                 $dbr = $this->getConnectionRef( DB_REPLICA );
 896                 $rowCount = $dbr->selectRowCount(
 897                         'watchlist',
 898                         '1',
 899                         [
 900                                 'wl_user' => $user->getId(),
 901                                 'wl_notificationtimestamp IS NOT NULL',
 902                         ],
 903                         __METHOD__,
 904                         $queryOptions
 905                 );
 906
 907                 if ( !isset( $unreadLimit ) ) {
 908                         return $rowCount;
 909                 }
 910
 911                 if ( $rowCount >= $unreadLimit ) {
 912                         return true;
 913                 }
 914
 915                 return $rowCount;
 916         }
 917
 918         /**
 919          * Check if the given title already is watched by the user, and if so
 920          * add a watch for the new title.
 921          *
 922          * To be used for page renames and such.
 923          *
 924          * @param LinkTarget $oldTarget
 925          * @param LinkTarget $newTarget
 926          */
 927         public function duplicateAllAssociatedEntries( LinkTarget $oldTarget, LinkTarget $newTarget ) {
 928                 $oldTarget = Title::newFromLinkTarget( $oldTarget );
 929                 $newTarget = Title::newFromLinkTarget( $newTarget );
 930
 931                 $this->duplicateEntry( $oldTarget->getSubjectPage(), $newTarget->getSubjectPage() );
 932                 $this->duplicateEntry( $oldTarget->getTalkPage(), $newTarget->getTalkPage() );
 933         }
 934
 935         /**
 936          * Check if the given title already is watched by the user, and if so
 937          * add a watch for the new title.
 938          *
 939          * To be used for page renames and such.
 940          * This must be called separately for Subject and Talk pages
 941          *
 942          * @param LinkTarget $oldTarget
 943          * @param LinkTarget $newTarget
 944          */
 945         public function duplicateEntry( LinkTarget $oldTarget, LinkTarget $newTarget ) {
 946                 $dbw = $this->getConnectionRef( DB_MASTER );
 947
 948                 $result = $dbw->select(
 949                         'watchlist',
 950                         [ 'wl_user', 'wl_notificationtimestamp' ],
 951                         [
 952                                 'wl_namespace' => $oldTarget->getNamespace(),
 953                                 'wl_title' => $oldTarget->getDBkey(),
 954                         ],
 955                         __METHOD__,
 956                         [ 'FOR UPDATE' ]
 957                 );
 958
 959                 $newNamespace = $newTarget->getNamespace();
 960                 $newDBkey = $newTarget->getDBkey();
 961
 962                 # Construct array to replace into the watchlist
 963                 $values = [];
 964                 foreach ( $result as $row ) {
 965                         $values[] = [
 966                                 'wl_user' => $row->wl_user,
 967                                 'wl_namespace' => $newNamespace,
 968                                 'wl_title' => $newDBkey,
 969                                 'wl_notificationtimestamp' => $row->wl_notificationtimestamp,
 970                         ];
 971                 }
 972
 973                 if ( !empty( $values ) ) {
 974                         # Perform replace
 975                         # Note that multi-row replace is very efficient for MySQL but may be inefficient for
 976                         # some other DBMSes, mostly due to poor simulation by us
 977                         $dbw->replace(
 978                                 'watchlist',
 979                                 [ [ 'wl_user', 'wl_namespace', 'wl_title' ] ],
 980                                 $values,
 981                                 __METHOD__
 982                         );
 983                 }
 984         }
 985
 986 }