UserEditTracker.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\User;
 
use ActorMigration;
use DeferredUpdates;
use InvalidArgumentException;
use JobQueueGroup;
use UserEditCountInitJob;
use UserEditCountUpdate;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Timestamp\ConvertibleTimestamp;
 
class UserEditTracker {
 
    private const FIRST_EDIT = 1;
    private const LATEST_EDIT = 2;
 
    private $actorMigration;
 
    private $loadBalancer;
 
    private $jobQueueGroup;
 
    private $userEditCountCache = [];
 
    public function __construct(
        ActorMigration $actorMigration,
        ILoadBalancer $loadBalancer,
        JobQueueGroup $jobQueueGroup
    ) {
        $this->actorMigration = $actorMigration;
        $this->loadBalancer = $loadBalancer;
        $this->jobQueueGroup = $jobQueueGroup;
    }
 
    public function getUserEditCount( UserIdentity $user ): ?int {
        if ( !$user->isRegistered() ) {
            return null;
        }
 
        $userId = $user->getId();
        $cacheKey = 'u' . (string)$userId;
 
        if ( isset( $this->userEditCountCache[ $cacheKey ] ) ) {
            return $this->userEditCountCache[ $cacheKey ];
        }
 
        $dbr = $this->loadBalancer->getConnectionRef( DB_REPLICA );
        $count = $dbr->selectField(
            'user',
            'user_editcount',
            [ 'user_id' => $userId ],
            __METHOD__
        );
 
        if ( $count === null ) {
            // it has not been initialized. do so.
            $count = $this->initializeUserEditCount( $user );
        }
 
        $this->userEditCountCache[ $cacheKey ] = $count;
        return $count;
    }
 
    public function initializeUserEditCount( UserIdentity $user ): int {
        $dbr = $this->loadBalancer->getConnectionRef( DB_REPLICA );
        $actorWhere = $this->actorMigration->getWhere( $dbr, 'rev_user', $user );
 
        $count = (int)$dbr->selectField(
            [ 'revision' ] + $actorWhere['tables'],
            'COUNT(*)',
            [ $actorWhere['conds'] ],
            __METHOD__,
            [],
            $actorWhere['joins']
        );
 
        // 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() ) {
            // Anonymous users don't have edit counts
            return;
        }
 
        DeferredUpdates::addUpdate(
            new UserEditCountUpdate( $user, 1 ),
            DeferredUpdates::POSTSEND
        );
    }
 
    public function getFirstEditTimestamp( UserIdentity $user ) {
        return $this->getUserEditTimestamp( $user, self::FIRST_EDIT );
    }
 
    public function getLatestEditTimestamp( UserIdentity $user ) {
        return $this->getUserEditTimestamp( $user, self::LATEST_EDIT );
    }
 
    private function getUserEditTimestamp( UserIdentity $user, int $type ) {
        if ( !$user->isRegistered() ) {
            return false;
        }
 
        $dbr = $this->loadBalancer->getConnectionRef( DB_REPLICA );
        $actorWhere = $this->actorMigration->getWhere( $dbr, 'rev_user', $user );
 
        $sortOrder = ( $type === self::FIRST_EDIT ) ? 'ASC' : 'DESC';
        $time = $dbr->selectField(
            [ 'revision' ] + $actorWhere['tables'],
            'rev_timestamp',
            [ $actorWhere['conds'] ],
            __METHOD__,
            [ 'ORDER BY' => "rev_timestamp $sortOrder" ],
            $actorWhere['joins']
        );
 
        if ( !$time ) {
            return false; // no edits
        }
 
        return ConvertibleTimestamp::convert( TS_MW, $time );
    }
 
    public function clearUserEditCache( UserIdentity $user ) {
        if ( !$user->isRegistered() ) {
            return;
        }
 
        $userId = $user->getId();
        $cacheKey = 'u' . (string)$userId;
 
        unset( $this->userEditCountCache[ $cacheKey ] );
    }
 
    public function setCachedUserEditCount( UserIdentity $user, int $editCount ) {
        if ( !$user->isRegistered() ) {
            throw new InvalidArgumentException( __METHOD__ . ' with an anonymous user' );
        }
 
        $userId = $user->getId();
        $cacheKey = 'u' . (string)$userId;
 
        $this->userEditCountCache[ $cacheKey ] = $editCount;
    }
 
}