WatchedItemStore.php

Go to the documentation of this file.

<?php
 
use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Revision\RevisionLookup;
use MediaWiki\User\UserIdentity;
use Wikimedia\Assert\Assert;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ILBFactory;
use Wikimedia\Rdbms\LoadBalancer;
use Wikimedia\ScopedCallback;
 
class WatchedItemStore implements WatchedItemStoreInterface, StatsdAwareInterface {
 
    private $lbFactory;
 
    private $loadBalancer;
 
    private $queueGroup;
 
    private $stash;
 
    private $readOnlyMode;
 
    private $cache;
 
    private $latestUpdateCache;
 
    private $cacheIndex = [];
 
    private $deferredUpdatesAddCallableUpdateCallback;
 
    private $updateRowsPerQuery;
 
    private $nsInfo;
 
    private $revisionLookup;
 
    private $stats;
 
    public function __construct(
        ILBFactory $lbFactory,
        JobQueueGroup $queueGroup,
        BagOStuff $stash,
        HashBagOStuff $cache,
        ReadOnlyMode $readOnlyMode,
        $updateRowsPerQuery,
        NamespaceInfo $nsInfo,
        RevisionLookup $revisionLookup
    ) {
        $this->lbFactory = $lbFactory;
        $this->loadBalancer = $lbFactory->getMainLB();
        $this->queueGroup = $queueGroup;
        $this->stash = $stash;
        $this->cache = $cache;
        $this->readOnlyMode = $readOnlyMode;
        $this->stats = new NullStatsdDataFactory();
        $this->deferredUpdatesAddCallableUpdateCallback =
            [ DeferredUpdates::class, 'addCallableUpdate' ];
        $this->updateRowsPerQuery = $updateRowsPerQuery;
        $this->nsInfo = $nsInfo;
        $this->revisionLookup = $revisionLookup;
 
        $this->latestUpdateCache = new HashBagOStuff( [ 'maxKeys' => 3 ] );
    }
 
    public function setStatsdDataFactory( StatsdDataFactoryInterface $stats ) {
        $this->stats = $stats;
    }
 
    public function overrideDeferredUpdatesAddCallableUpdateCallback( callable $callback ) {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new MWException(
                'Cannot override DeferredUpdates::addCallableUpdate callback in operation.'
            );
        }
        $previousValue = $this->deferredUpdatesAddCallableUpdateCallback;
        $this->deferredUpdatesAddCallableUpdateCallback = $callback;
        return new ScopedCallback( function () use ( $previousValue ) {
            $this->deferredUpdatesAddCallableUpdateCallback = $previousValue;
        } );
    }
 
    private function getCacheKey( UserIdentity $user, LinkTarget $target ) {
        return $this->cache->makeKey(
            (string)$target->getNamespace(),
            $target->getDBkey(),
            (string)$user->getId()
        );
    }
 
    private function cache( WatchedItem $item ) {
        $user = $item->getUserIdentity();
        $target = $item->getLinkTarget();
        $key = $this->getCacheKey( $user, $target );
        $this->cache->set( $key, $item );
        $this->cacheIndex[$target->getNamespace()][$target->getDBkey()][$user->getId()] = $key;
        $this->stats->increment( 'WatchedItemStore.cache' );
    }
 
    private function uncache( UserIdentity $user, LinkTarget $target ) {
        $this->cache->delete( $this->getCacheKey( $user, $target ) );
        unset( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()][$user->getId()] );
        $this->stats->increment( 'WatchedItemStore.uncache' );
    }
 
    private function uncacheLinkTarget( LinkTarget $target ) {
        $this->stats->increment( 'WatchedItemStore.uncacheLinkTarget' );
        if ( !isset( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()] ) ) {
            return;
        }
        foreach ( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()] as $key ) {
            $this->stats->increment( 'WatchedItemStore.uncacheLinkTarget.items' );
            $this->cache->delete( $key );
        }
    }
 
    private function uncacheUser( UserIdentity $user ) {
        $this->stats->increment( 'WatchedItemStore.uncacheUser' );
        foreach ( $this->cacheIndex as $ns => $dbKeyArray ) {
            foreach ( $dbKeyArray as $dbKey => $userArray ) {
                if ( isset( $userArray[$user->getId()] ) ) {
                    $this->stats->increment( 'WatchedItemStore.uncacheUser.items' );
                    $this->cache->delete( $userArray[$user->getId()] );
                }
            }
        }
 
        $pageSeenKey = $this->getPageSeenTimestampsKey( $user );
        $this->latestUpdateCache->delete( $pageSeenKey );
        $this->stash->delete( $pageSeenKey );
    }
 
    private function getCached( UserIdentity $user, LinkTarget $target ) {
        return $this->cache->get( $this->getCacheKey( $user, $target ) );
    }
 
    private function dbCond( UserIdentity $user, LinkTarget $target ) {
        return [
            'wl_user' => $user->getId(),
            'wl_namespace' => $target->getNamespace(),
            'wl_title' => $target->getDBkey(),
        ];
    }
 
    private function getConnectionRef( $dbIndex ) {
        return $this->loadBalancer->getConnectionRef( $dbIndex, [ 'watchlist' ] );
    }
 
    public function clearUserWatchedItems( UserIdentity $user ) {
        if ( $this->countWatchedItems( $user ) > $this->updateRowsPerQuery ) {
            return false;
        }
 
        $dbw = $this->loadBalancer->getConnectionRef( DB_MASTER );
        $dbw->delete(
            'watchlist',
            [ 'wl_user' => $user->getId() ],
            __METHOD__
        );
        $this->uncacheAllItemsForUser( $user );
 
        return true;
    }
 
    private function uncacheAllItemsForUser( UserIdentity $user ) {
        $userId = $user->getId();
        foreach ( $this->cacheIndex as $ns => $dbKeyIndex ) {
            foreach ( $dbKeyIndex as $dbKey => $userIndex ) {
                if ( array_key_exists( $userId, $userIndex ) ) {
                    $this->cache->delete( $userIndex[$userId] );
                    unset( $this->cacheIndex[$ns][$dbKey][$userId] );
                }
            }
        }
 
        // Cleanup empty cache keys
        foreach ( $this->cacheIndex as $ns => $dbKeyIndex ) {
            foreach ( $dbKeyIndex as $dbKey => $userIndex ) {
                if ( empty( $this->cacheIndex[$ns][$dbKey] ) ) {
                    unset( $this->cacheIndex[$ns][$dbKey] );
                }
            }
            if ( empty( $this->cacheIndex[$ns] ) ) {
                unset( $this->cacheIndex[$ns] );
            }
        }
    }
 
    public function clearUserWatchedItemsUsingJobQueue( UserIdentity $user ) {
        $job = ClearUserWatchlistJob::newForUser( $user, $this->getMaxId() );
        $this->queueGroup->push( $job );
    }
 
    public function getMaxId() {
        $dbr = $this->getConnectionRef( DB_REPLICA );
        return (int)$dbr->selectField(
            'watchlist',
            'MAX(wl_id)',
            '',
            __METHOD__
        );
    }
 
    public function countWatchedItems( UserIdentity $user ) {
        $dbr = $this->getConnectionRef( DB_REPLICA );
        $return = (int)$dbr->selectField(
            'watchlist',
            'COUNT(*)',
            [
                'wl_user' => $user->getId()
            ],
            __METHOD__
        );
 
        return $return;
    }
 
    public function countWatchers( LinkTarget $target ) {
        $dbr = $this->getConnectionRef( DB_REPLICA );
        $return = (int)$dbr->selectField(
            'watchlist',
            'COUNT(*)',
            [
                'wl_namespace' => $target->getNamespace(),
                'wl_title' => $target->getDBkey(),
            ],
            __METHOD__
        );
 
        return $return;
    }
 
    public function countVisitingWatchers( LinkTarget $target, $threshold ) {
        $dbr = $this->getConnectionRef( DB_REPLICA );
        $visitingWatchers = (int)$dbr->selectField(
            'watchlist',
            'COUNT(*)',
            [
                'wl_namespace' => $target->getNamespace(),
                'wl_title' => $target->getDBkey(),
                'wl_notificationtimestamp >= ' .
                $dbr->addQuotes( $dbr->timestamp( $threshold ) ) .
                ' OR wl_notificationtimestamp IS NULL'
            ],
            __METHOD__
        );
 
        return $visitingWatchers;
    }
 
    public function removeWatchBatchForUser( UserIdentity $user, array $titles ) {
        if ( $this->readOnlyMode->isReadOnly() ) {
            return false;
        }
        if ( !$user->isRegistered() ) {
            return false;
        }
        if ( !$titles ) {
            return true;
        }
 
        $rows = $this->getTitleDbKeysGroupedByNamespace( $titles );
        $this->uncacheTitlesForUser( $user, $titles );
 
        $dbw = $this->getConnectionRef( DB_MASTER );
        $ticket = count( $titles ) > $this->updateRowsPerQuery ?
            $this->lbFactory->getEmptyTransactionTicket( __METHOD__ ) : null;
        $affectedRows = 0;
 
        // Batch delete items per namespace.
        foreach ( $rows as $namespace => $namespaceTitles ) {
            $rowBatches = array_chunk( $namespaceTitles, $this->updateRowsPerQuery );
            foreach ( $rowBatches as $toDelete ) {
                $dbw->delete( 'watchlist', [
                    'wl_user' => $user->getId(),
                    'wl_namespace' => $namespace,
                    'wl_title' => $toDelete
                ], __METHOD__ );
                $affectedRows += $dbw->affectedRows();
                if ( $ticket ) {
                    $this->lbFactory->commitAndWaitForReplication( __METHOD__, $ticket );
                }
            }
        }
 
        return (bool)$affectedRows;
    }
 
    public function countWatchersMultiple( array $targets, array $options = [] ) {
        $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
 
        $dbr = $this->getConnectionRef( DB_REPLICA );
 
        if ( array_key_exists( 'minimumWatchers', $options ) ) {
            $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$options['minimumWatchers'];
        }
 
        $lb = new LinkBatch( $targets );
        $res = $dbr->select(
            'watchlist',
            [ 'wl_title', 'wl_namespace', 'watchers' => 'COUNT(*)' ],
            [ $lb->constructSet( 'wl', $dbr ) ],
            __METHOD__,
            $dbOptions
        );
 
        $watchCounts = [];
        foreach ( $targets as $linkTarget ) {
            $watchCounts[$linkTarget->getNamespace()][$linkTarget->getDBkey()] = 0;
        }
 
        foreach ( $res as $row ) {
            $watchCounts[$row->wl_namespace][$row->wl_title] = (int)$row->watchers;
        }
 
        return $watchCounts;
    }
 
    public function countVisitingWatchersMultiple(
        array $targetsWithVisitThresholds,
        $minimumWatchers = null
    ) {
        if ( $targetsWithVisitThresholds === [] ) {
            // No titles requested => no results returned
            return [];
        }
 
        $dbr = $this->getConnectionRef( DB_REPLICA );
 
        $conds = $this->getVisitingWatchersCondition( $dbr, $targetsWithVisitThresholds );
 
        $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
        if ( $minimumWatchers !== null ) {
            $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$minimumWatchers;
        }
        $res = $dbr->select(
            'watchlist',
            [ 'wl_namespace', 'wl_title', 'watchers' => 'COUNT(*)' ],
            $conds,
            __METHOD__,
            $dbOptions
        );
 
        $watcherCounts = [];
        foreach ( $targetsWithVisitThresholds as list( $target ) ) {
            /* @var LinkTarget $target */
            $watcherCounts[$target->getNamespace()][$target->getDBkey()] = 0;
        }
 
        foreach ( $res as $row ) {
            $watcherCounts[$row->wl_namespace][$row->wl_title] = (int)$row->watchers;
        }
 
        return $watcherCounts;
    }
 
    private function getVisitingWatchersCondition(
        IDatabase $db,
        array $targetsWithVisitThresholds
    ) {
        $missingTargets = [];
        $namespaceConds = [];
        foreach ( $targetsWithVisitThresholds as list( $target, $threshold ) ) {
            if ( $threshold === null ) {
                $missingTargets[] = $target;
                continue;
            }
            /* @var LinkTarget $target */
            $namespaceConds[$target->getNamespace()][] = $db->makeList( [
                'wl_title = ' . $db->addQuotes( $target->getDBkey() ),
                $db->makeList( [
                    'wl_notificationtimestamp >= ' . $db->addQuotes( $db->timestamp( $threshold ) ),
                    'wl_notificationtimestamp IS NULL'
                ], LIST_OR )
            ], LIST_AND );
        }
 
        $conds = [];
        foreach ( $namespaceConds as $namespace => $pageConds ) {
            $conds[] = $db->makeList( [
                'wl_namespace = ' . $namespace,
                '(' . $db->makeList( $pageConds, LIST_OR ) . ')'
            ], LIST_AND );
        }
 
        if ( $missingTargets ) {
            $lb = new LinkBatch( $missingTargets );
            $conds[] = $lb->constructSet( 'wl', $db );
        }
 
        return $db->makeList( $conds, LIST_OR );
    }
 
    public function getWatchedItem( UserIdentity $user, LinkTarget $target ) {
        if ( !$user->isRegistered() ) {
            return false;
        }
 
        $cached = $this->getCached( $user, $target );
        if ( $cached ) {
            $this->stats->increment( 'WatchedItemStore.getWatchedItem.cached' );
            return $cached;
        }
        $this->stats->increment( 'WatchedItemStore.getWatchedItem.load' );
        return $this->loadWatchedItem( $user, $target );
    }
 
    public function loadWatchedItem( UserIdentity $user, LinkTarget $target ) {
        // Only registered user can have a watchlist
        if ( !$user->isRegistered() ) {
            return false;
        }
 
        $dbr = $this->getConnectionRef( DB_REPLICA );
 
        $row = $dbr->selectRow(
            'watchlist',
            'wl_notificationtimestamp',
            $this->dbCond( $user, $target ),
            __METHOD__
        );
 
        if ( !$row ) {
            return false;
        }
 
        $item = new WatchedItem(
            $user,
            $target,
            $this->getLatestNotificationTimestamp( $row->wl_notificationtimestamp, $user, $target )
        );
        $this->cache( $item );
 
        return $item;
    }
 
    public function getWatchedItemsForUser( UserIdentity $user, array $options = [] ) {
        $options += [ 'forWrite' => false ];
 
        $dbOptions = [];
        if ( array_key_exists( 'sort', $options ) ) {
            Assert::parameter(
                ( in_array( $options['sort'], [ self::SORT_ASC, self::SORT_DESC ] ) ),
                '$options[\'sort\']',
                'must be SORT_ASC or SORT_DESC'
            );
            $dbOptions['ORDER BY'] = [
                "wl_namespace {$options['sort']}",
                "wl_title {$options['sort']}"
            ];
        }
        $db = $this->getConnectionRef( $options['forWrite'] ? DB_MASTER : DB_REPLICA );
 
        $res = $db->select(
            'watchlist',
            [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
            [ 'wl_user' => $user->getId() ],
            __METHOD__,
            $dbOptions
        );
 
        $watchedItems = [];
        foreach ( $res as $row ) {
            $target = new TitleValue( (int)$row->wl_namespace, $row->wl_title );
            // @todo: Should we add these to the process cache?
            $watchedItems[] = new WatchedItem(
                $user,
                $target,
                $this->getLatestNotificationTimestamp(
                    $row->wl_notificationtimestamp, $user, $target )
            );
        }
 
        return $watchedItems;
    }
 
    public function isWatched( UserIdentity $user, LinkTarget $target ) {
        return (bool)$this->getWatchedItem( $user, $target );
    }
 
    public function getNotificationTimestampsBatch( UserIdentity $user, array $targets ) {
        $timestamps = [];
        foreach ( $targets as $target ) {
            $timestamps[$target->getNamespace()][$target->getDBkey()] = false;
        }
 
        if ( !$user->isRegistered() ) {
            return $timestamps;
        }
 
        $targetsToLoad = [];
        foreach ( $targets as $target ) {
            $cachedItem = $this->getCached( $user, $target );
            if ( $cachedItem ) {
                $timestamps[$target->getNamespace()][$target->getDBkey()] =
                    $cachedItem->getNotificationTimestamp();
            } else {
                $targetsToLoad[] = $target;
            }
        }
 
        if ( !$targetsToLoad ) {
            return $timestamps;
        }
 
        $dbr = $this->getConnectionRef( DB_REPLICA );
 
        $lb = new LinkBatch( $targetsToLoad );
        $res = $dbr->select(
            'watchlist',
            [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
            [
                $lb->constructSet( 'wl', $dbr ),
                'wl_user' => $user->getId(),
            ],
            __METHOD__
        );
 
        foreach ( $res as $row ) {
            $target = new TitleValue( (int)$row->wl_namespace, $row->wl_title );
            $timestamps[$row->wl_namespace][$row->wl_title] =
                $this->getLatestNotificationTimestamp(
                    $row->wl_notificationtimestamp, $user, $target );
        }
 
        return $timestamps;
    }
 
    public function addWatch( UserIdentity $user, LinkTarget $target ) {
        $this->addWatchBatchForUser( $user, [ $target ] );
    }
 
    public function addWatchBatchForUser( UserIdentity $user, array $targets ) {
        if ( $this->readOnlyMode->isReadOnly() ) {
            return false;
        }
        // Only registered user can have a watchlist
        if ( !$user->isRegistered() ) {
            return false;
        }
 
        if ( !$targets ) {
            return true;
        }
 
        $rows = [];
        $items = [];
        foreach ( $targets as $target ) {
            $rows[] = [
                'wl_user' => $user->getId(),
                'wl_namespace' => $target->getNamespace(),
                'wl_title' => $target->getDBkey(),
                'wl_notificationtimestamp' => null,
            ];
            $items[] = new WatchedItem(
                $user,
                $target,
                null
            );
            $this->uncache( $user, $target );
        }
 
        $dbw = $this->getConnectionRef( DB_MASTER );
        $ticket = count( $targets ) > $this->updateRowsPerQuery ?
            $this->lbFactory->getEmptyTransactionTicket( __METHOD__ ) : null;
        $affectedRows = 0;
        $rowBatches = array_chunk( $rows, $this->updateRowsPerQuery );
        foreach ( $rowBatches as $toInsert ) {
            // Use INSERT IGNORE to avoid overwriting the notification timestamp
            // if there's already an entry for this page
            $dbw->insert( 'watchlist', $toInsert, __METHOD__, [ 'IGNORE' ] );
            $affectedRows += $dbw->affectedRows();
            if ( $ticket ) {
                $this->lbFactory->commitAndWaitForReplication( __METHOD__, $ticket );
            }
        }
        // Update process cache to ensure skin doesn't claim that the current
        // page is unwatched in the response of action=watch itself (T28292).
        // This would otherwise be re-queried from a replica by isWatched().
        foreach ( $items as $item ) {
            $this->cache( $item );
        }
 
        return (bool)$affectedRows;
    }
 
    public function removeWatch( UserIdentity $user, LinkTarget $target ) {
        return $this->removeWatchBatchForUser( $user, [ $target ] );
    }
 
    public function setNotificationTimestampsForUser(
        UserIdentity $user, $timestamp, array $targets = []
    ) {
        // Only registered user can have a watchlist
        if ( !$user->isRegistered() || $this->readOnlyMode->isReadOnly() ) {
            return false;
        }
 
        if ( !$targets ) {
            // Backwards compatibility
            $this->resetAllNotificationTimestampsForUser( $user, $timestamp );
            return true;
        }
 
        $rows = $this->getTitleDbKeysGroupedByNamespace( $targets );
 
        $dbw = $this->getConnectionRef( DB_MASTER );
        if ( $timestamp !== null ) {
            $timestamp = $dbw->timestamp( $timestamp );
        }
        $ticket = $this->lbFactory->getEmptyTransactionTicket( __METHOD__ );
        $affectedSinceWait = 0;
 
        // Batch update items per namespace
        foreach ( $rows as $namespace => $namespaceTitles ) {
            $rowBatches = array_chunk( $namespaceTitles, $this->updateRowsPerQuery );
            foreach ( $rowBatches as $toUpdate ) {
                $dbw->update(
                    'watchlist',
                    [ 'wl_notificationtimestamp' => $timestamp ],
                    [
                        'wl_user' => $user->getId(),
                        'wl_namespace' => $namespace,
                        'wl_title' => $toUpdate
                    ]
                );
                $affectedSinceWait += $dbw->affectedRows();
                // Wait for replication every time we've touched updateRowsPerQuery rows
                if ( $affectedSinceWait >= $this->updateRowsPerQuery ) {
                    $this->lbFactory->commitAndWaitForReplication( __METHOD__, $ticket );
                    $affectedSinceWait = 0;
                }
            }
        }
 
        $this->uncacheUser( $user );
 
        return true;
    }
 
    public function getLatestNotificationTimestamp(
        $timestamp, UserIdentity $user, LinkTarget $target
    ) {
        $timestamp = wfTimestampOrNull( TS_MW, $timestamp );
        if ( $timestamp === null ) {
            return null; // no notification
        }
 
        $seenTimestamps = $this->getPageSeenTimestamps( $user );
        if (
            $seenTimestamps &&
            $seenTimestamps->get( $this->getPageSeenKey( $target ) ) >= $timestamp
        ) {
            // If a reset job did not yet run, then the "seen" timestamp will be higher
            return null;
        }
 
        return $timestamp;
    }
 
    public function resetAllNotificationTimestampsForUser( UserIdentity $user, $timestamp = null ) {
        // Only registered user can have a watchlist
        if ( !$user->isRegistered() ) {
            return;
        }
 
        // If the page is watched by the user (or may be watched), update the timestamp
        $job = new ClearWatchlistNotificationsJob( [
            'userId'  => $user->getId(), 'timestamp' => $timestamp, 'casTime' => time()
        ] );
 
        // Try to run this post-send
        // Calls DeferredUpdates::addCallableUpdate in normal operation
        call_user_func(
            $this->deferredUpdatesAddCallableUpdateCallback,
            function () use ( $job ) {
                $job->run();
            }
        );
    }
 
    public function updateNotificationTimestamp(
        UserIdentity $editor, LinkTarget $target, $timestamp
    ) {
        $dbw = $this->getConnectionRef( DB_MASTER );
        $uids = $dbw->selectFieldValues(
            'watchlist',
            'wl_user',
            [
                'wl_user != ' . intval( $editor->getId() ),
                'wl_namespace' => $target->getNamespace(),
                'wl_title' => $target->getDBkey(),
                'wl_notificationtimestamp IS NULL',
            ],
            __METHOD__
        );
 
        $watchers = array_map( 'intval', $uids );
        if ( $watchers ) {
            // Update wl_notificationtimestamp for all watching users except the editor
            $fname = __METHOD__;
            DeferredUpdates::addCallableUpdate(
                function () use ( $timestamp, $watchers, $target, $fname ) {
                    $dbw = $this->getConnectionRef( DB_MASTER );
                    $ticket = $this->lbFactory->getEmptyTransactionTicket( $fname );
 
                    $watchersChunks = array_chunk( $watchers, $this->updateRowsPerQuery );
                    foreach ( $watchersChunks as $watchersChunk ) {
                        $dbw->update( 'watchlist',
                            [ /* SET */
                                'wl_notificationtimestamp' => $dbw->timestamp( $timestamp )
                            ], [ /* WHERE - TODO Use wl_id T130067 */
                                'wl_user' => $watchersChunk,
                                'wl_namespace' => $target->getNamespace(),
                                'wl_title' => $target->getDBkey(),
                            ], $fname
                        );
                        if ( count( $watchersChunks ) > 1 ) {
                            $this->lbFactory->commitAndWaitForReplication(
                                $fname, $ticket, [ 'domain' => $dbw->getDomainID() ]
                            );
                        }
                    }
                    $this->uncacheLinkTarget( $target );
                },
                DeferredUpdates::POSTSEND,
                $dbw
            );
        }
 
        return $watchers;
    }
 
    public function resetNotificationTimestamp(
        UserIdentity $user, LinkTarget $title, $force = '', $oldid = 0
    ) {
        $time = time();
 
        // Only registered user can have a watchlist
        if ( $this->readOnlyMode->isReadOnly() || !$user->isRegistered() ) {
            return false;
        }
 
        // Hook expects User and Title, not UserIdentity and LinkTarget
        $userObj = User::newFromId( $user->getId() );
        $titleObj = Title::castFromLinkTarget( $title );
        if ( !Hooks::run( 'BeforeResetNotificationTimestamp',
            [ &$userObj, &$titleObj, $force, &$oldid ] )
        ) {
            return false;
        }
        if ( !$userObj->equals( $user ) ) {
            $user = $userObj;
        }
        if ( !$titleObj->equals( $title ) ) {
            $title = $titleObj;
        }
 
        $item = null;
        if ( $force != 'force' ) {
            $item = $this->loadWatchedItem( $user, $title );
            if ( !$item || $item->getNotificationTimestamp() === null ) {
                return false;
            }
        }
 
        // Get the timestamp (TS_MW) of this revision to track the latest one seen
        $id = $oldid;
        $seenTime = null;
        if ( !$id ) {
            $latestRev = $this->revisionLookup->getRevisionByTitle( $title );
            if ( $latestRev ) {
                $id = $latestRev->getId();
                // Save a DB query
                $seenTime = $latestRev->getTimestamp();
            }
        }
        if ( $seenTime === null ) {
            $seenTime = $this->revisionLookup->getTimestampFromId( $id );
        }
 
        // Mark the item as read immediately in lightweight storage
        $this->stash->merge(
            $this->getPageSeenTimestampsKey( $user ),
            function ( $cache, $key, $current ) use ( $title, $seenTime ) {
                $value = $current ?: new MapCacheLRU( 300 );
                $subKey = $this->getPageSeenKey( $title );
 
                if ( $seenTime > $value->get( $subKey ) ) {
                    // Revision is newer than the last one seen
                    $value->set( $subKey, $seenTime );
                    $this->latestUpdateCache->set( $key, $value, BagOStuff::TTL_PROC_LONG );
                } elseif ( $seenTime === false ) {
                    // Revision does not exist
                    $value->set( $subKey, wfTimestamp( TS_MW ) );
                    $this->latestUpdateCache->set( $key, $value, BagOStuff::TTL_PROC_LONG );
                } else {
                    return false; // nothing to update
                }
 
                return $value;
            },
            BagOStuff::TTL_HOUR
        );
 
        // If the page is watched by the user (or may be watched), update the timestamp
        $job = new ActivityUpdateJob(
            $title,
            [
                'type'      => 'updateWatchlistNotification',
                'userid'    => $user->getId(),
                'notifTime' => $this->getNotificationTimestamp( $user, $title, $item, $force, $oldid ),
                'curTime'   => $time
            ]
        );
        // Try to enqueue this post-send
        $this->queueGroup->lazyPush( $job );
 
        $this->uncache( $user, $title );
 
        return true;
    }
 
    private function getPageSeenTimestamps( UserIdentity $user ) {
        $key = $this->getPageSeenTimestampsKey( $user );
 
        return $this->latestUpdateCache->getWithSetCallback(
            $key,
            BagOStuff::TTL_PROC_LONG,
            function () use ( $key ) {
                return $this->stash->get( $key ) ?: null;
            }
        );
    }
 
    private function getPageSeenTimestampsKey( UserIdentity $user ) {
        return $this->stash->makeGlobalKey(
            'watchlist-recent-updates',
            $this->lbFactory->getLocalDomainID(),
            $user->getId()
        );
    }
 
    private function getPageSeenKey( LinkTarget $target ) {
        return "{$target->getNamespace()}:{$target->getDBkey()}";
    }
 
    private function getNotificationTimestamp(
        UserIdentity $user, LinkTarget $title, $item, $force, $oldid
    ) {
        if ( !$oldid ) {
            // No oldid given, assuming latest revision; clear the timestamp.
            return null;
        }
 
        $oldRev = $this->revisionLookup->getRevisionById( $oldid );
        if ( !$oldRev ) {
            // Oldid given but does not exist (probably deleted)
            return false;
        }
 
        $nextRev = $this->revisionLookup->getNextRevision( $oldRev );
        if ( !$nextRev ) {
            // Oldid given and is the latest revision for this title; clear the timestamp.
            return null;
        }
 
        if ( $item === null ) {
            $item = $this->loadWatchedItem( $user, $title );
        }
 
        if ( !$item ) {
            // This can only happen if $force is enabled.
            return null;
        }
 
        // Oldid given and isn't the latest; update the timestamp.
        // This will result in no further notification emails being sent!
        $notificationTimestamp = $this->revisionLookup->getTimestampFromId( $oldid );
        // @FIXME: this should use getTimestamp() for consistency with updates on new edits
        // $notificationTimestamp = $nextRev->getTimestamp(); // first unseen revision timestamp
 
        // We need to go one second to the future because of various strict comparisons
        // throughout the codebase
        $ts = new MWTimestamp( $notificationTimestamp );
        $ts->timestamp->add( new DateInterval( 'PT1S' ) );
        $notificationTimestamp = $ts->getTimestamp( TS_MW );
 
        if ( $notificationTimestamp < $item->getNotificationTimestamp() ) {
            if ( $force != 'force' ) {
                return false;
            } else {
                // This is a little silly…
                return $item->getNotificationTimestamp();
            }
        }
 
        return $notificationTimestamp;
    }
 
    public function countUnreadNotifications( UserIdentity $user, $unreadLimit = null ) {
        $dbr = $this->getConnectionRef( DB_REPLICA );
 
        $queryOptions = [];
        if ( $unreadLimit !== null ) {
            $unreadLimit = (int)$unreadLimit;
            $queryOptions['LIMIT'] = $unreadLimit;
        }
 
        $conds = [
            'wl_user' => $user->getId(),
            'wl_notificationtimestamp IS NOT NULL'
        ];
 
        $rowCount = $dbr->selectRowCount( 'watchlist', '1', $conds, __METHOD__, $queryOptions );
 
        if ( $unreadLimit === null ) {
            return $rowCount;
        }
 
        if ( $rowCount >= $unreadLimit ) {
            return true;
        }
 
        return $rowCount;
    }
 
    public function duplicateAllAssociatedEntries( LinkTarget $oldTarget, LinkTarget $newTarget ) {
        // Duplicate first the subject page, then the talk page
        $this->duplicateEntry(
            $this->nsInfo->getSubjectPage( $oldTarget ),
            $this->nsInfo->getSubjectPage( $newTarget )
        );
        $this->duplicateEntry(
            $this->nsInfo->getTalkPage( $oldTarget ),
            $this->nsInfo->getTalkPage( $newTarget )
        );
    }
 
    public function duplicateEntry( LinkTarget $oldTarget, LinkTarget $newTarget ) {
        $dbw = $this->getConnectionRef( DB_MASTER );
 
        $result = $dbw->select(
            'watchlist',
            [ 'wl_user', 'wl_notificationtimestamp' ],
            [
                'wl_namespace' => $oldTarget->getNamespace(),
                'wl_title' => $oldTarget->getDBkey(),
            ],
            __METHOD__,
            [ 'FOR UPDATE' ]
        );
 
        $newNamespace = $newTarget->getNamespace();
        $newDBkey = $newTarget->getDBkey();
 
        # Construct array to replace into the watchlist
        $values = [];
        foreach ( $result as $row ) {
            $values[] = [
                'wl_user' => $row->wl_user,
                'wl_namespace' => $newNamespace,
                'wl_title' => $newDBkey,
                'wl_notificationtimestamp' => $row->wl_notificationtimestamp,
            ];
        }
 
        if ( !empty( $values ) ) {
            # Perform replace
            # Note that multi-row replace is very efficient for MySQL but may be inefficient for
            # some other DBMSes, mostly due to poor simulation by us
            $dbw->replace(
                'watchlist',
                [ [ 'wl_user', 'wl_namespace', 'wl_title' ] ],
                $values,
                __METHOD__
            );
        }
    }
 
    private function getTitleDbKeysGroupedByNamespace( array $titles ) {
        $rows = [];
        foreach ( $titles as $title ) {
            // Group titles by namespace.
            $rows[ $title->getNamespace() ][] = $title->getDBkey();
        }
        return $rows;
    }
 
    private function uncacheTitlesForUser( UserIdentity $user, array $titles ) {
        foreach ( $titles as $title ) {
            $this->uncache( $user, $title );
        }
    }
 
}