UserEditTracker.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\User;
 
use InvalidArgumentException;
use LogicException;
use MediaWiki\DAO\WikiAwareEntity;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\Deferred\UserEditCountUpdate;
use MediaWiki\JobQueue\JobQueueGroup;
use MediaWiki\WikiMap\WikiMap;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDBAccessObject;
use Wikimedia\Rdbms\SelectQueryBuilder;
use Wikimedia\Timestamp\ConvertibleTimestamp;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class UserEditTracker {
 
    private const FIRST_EDIT = 1;
    private const LATEST_EDIT = 2;
 
    private ActorNormalization $actorNormalization;
    private IConnectionProvider $dbProvider;
    private JobQueueGroup $jobQueueGroup;
 
    private $userEditCountCache = [];
 
    public function __construct(
        ActorNormalization $actorNormalization,
        IConnectionProvider $dbProvider,
        JobQueueGroup $jobQueueGroup
    ) {
        $this->actorNormalization = $actorNormalization;
        $this->dbProvider = $dbProvider;
        $this->jobQueueGroup = $jobQueueGroup;
    }
 
    public function getUserEditCount( UserIdentity $user ): ?int {
        if ( !$user->isRegistered() ) {
            return null;
        }
 
        $cacheKey = $this->getCacheKey( $user );
        if ( isset( $this->userEditCountCache[ $cacheKey ] ) ) {
            return $this->userEditCountCache[ $cacheKey ];
        }
 
        $wikiId = $user->getWikiId();
        $userId = $user->getId( $wikiId );
        $count = $this->dbProvider->getReplicaDatabase( $wikiId )->newSelectQueryBuilder()
            ->select( 'user_editcount' )
            ->from( 'user' )
            ->where( [ 'user_id' => $userId ] )
            ->caller( __METHOD__ )->fetchField();
 
        if ( $count === null ) {
            // it has not been initialized. do so.
            $count = $this->initializeUserEditCount( $user );
        }
 
        $this->userEditCountCache[ $cacheKey ] = $count;
        return $count;
    }
 
    public function preloadUserEditCountCache( array $users ): void {
        $userIds = [];
 
        foreach ( $users as $user ) {
            if (
                $user->isRegistered() &&
                $user->getWikiId() === UserIdentity::LOCAL
            ) {
                $userIds[] = $user->getId();
            }
        }
 
        $userIds = array_unique( $userIds );
 
        $dbr = $this->dbProvider->getReplicaDatabase();
 
        foreach ( array_chunk( $userIds, 500 ) as $batch ) {
            $rows = $dbr->newSelectQueryBuilder()
                ->select( [ 'user_id', 'user_editcount' ] )
                ->from( 'user' )
                ->where( [ 'user_id' => $batch ] )
                ->caller( __METHOD__ )
                ->fetchResultSet();
 
            foreach ( $rows as $row ) {
                if ( $row->user_editcount !== null ) {
                    $key = $this->getCacheKeyByUserId( (int)$row->user_id );
 
                    $this->userEditCountCache[$key] = (int)$row->user_editcount;
                }
            }
        }
    }
 
    public function initializeUserEditCount( UserIdentity $user ): int {
        if ( $user->getWikiId() !== UserIdentity::LOCAL ) {
            // Don't record edits on remote wikis
            throw new LogicException( __METHOD__ . ' only supports local users' );
        }
 
        $dbr = $this->dbProvider->getReplicaDatabase();
        $count = (int)$dbr->newSelectQueryBuilder()
            ->select( 'COUNT(*)' )
            ->from( 'revision' )
            ->where( [ 'rev_actor' => $this->actorNormalization->findActorId( $user, $dbr ) ] )
            ->caller( __METHOD__ )
            ->fetchField();
 
        // Defer updating the edit count via a job (T259719)
        $this->jobQueueGroup->push( new UserEditCountInitJob( [
            'userId' => $user->getId(),
            'editCount' => $count,
        ] ) );
 
        return $count;
    }
 
    public function incrementUserEditCount( UserIdentity $user ) {
        if ( !$user->isRegistered() ) {
            // Can't store editcount without user row (i.e. unregistered)
            return;
        }
 
        DeferredUpdates::addUpdate(
            new UserEditCountUpdate( $user, 1 ),
            DeferredUpdates::POSTSEND
        );
    }
 
    public function getFirstEditTimestamp( UserIdentity $user, int $flags = IDBAccessObject::READ_NORMAL ) {
        return $this->getUserEditTimestamp( $user, self::FIRST_EDIT, $flags );
    }
 
    public function getLatestEditTimestamp( UserIdentity $user, int $flags = IDBAccessObject::READ_NORMAL ) {
        return $this->getUserEditTimestamp( $user, self::LATEST_EDIT, $flags );
    }
 
    private function getUserEditTimestamp( UserIdentity $user, int $type, int $flags = IDBAccessObject::READ_NORMAL ) {
        if ( !$user->isRegistered() ) {
            return false;
        }
        if ( $flags & IDBAccessObject::READ_LATEST ) {
            $db = $this->dbProvider->getPrimaryDatabase( $user->getWikiId() );
        } else {
            $db = $this->dbProvider->getReplicaDatabase( $user->getWikiId() );
        }
 
        $sortOrder = ( $type === self::FIRST_EDIT ) ? SelectQueryBuilder::SORT_ASC : SelectQueryBuilder::SORT_DESC;
        $time = $db->newSelectQueryBuilder()
            ->select( 'rev_timestamp' )
            ->from( 'revision' )
            ->where( [ 'rev_actor' => $this->actorNormalization->findActorId( $user, $db ) ] )
            ->orderBy( 'rev_timestamp', $sortOrder )
            ->caller( __METHOD__ )
            ->fetchField();
 
        if ( !$time ) {
            return false; // no edits
        }
 
        return ConvertibleTimestamp::convert( TS::MW, $time );
    }
 
    public function clearUserEditCache( UserIdentity $user ) {
        if ( !$user->isRegistered() ) {
            return;
        }
 
        $cacheKey = $this->getCacheKey( $user );
        unset( $this->userEditCountCache[ $cacheKey ] );
    }
 
    public function setCachedUserEditCount( UserIdentity $user, int $editCount ) {
        if ( !$user->isRegistered() ) {
            throw new InvalidArgumentException( __METHOD__ . ' with an anonymous user' );
        }
 
        $cacheKey = $this->getCacheKey( $user );
        $this->userEditCountCache[ $cacheKey ] = $editCount;
    }
 
    private function getCacheKey( UserIdentity $user ): string {
        if ( !$user->isRegistered() ) {
            throw new InvalidArgumentException( 'Cannot prepare cache key for an anonymous user' );
        }
 
        $wikiId = $user->getWikiId();
 
        return $this->getCacheKeyByUserId( $user->getId( $wikiId ), $wikiId );
    }
 
    private function getCacheKeyByUserId(
        int $userId,
        string|bool $wikiId = WikiAwareEntity::LOCAL
    ): string {
        $isRemoteWiki = ( $wikiId !== UserIdentity::LOCAL ) && !WikiMap::isCurrentWikiId( $wikiId );
        if ( $isRemoteWiki ) {
            return $wikiId . ':u' . $userId;
        }
        return 'u' . $userId;
    }
}