CategoryMembershipChange.php

Go to the documentation of this file.

<?php
namespace MediaWiki\RecentChanges;
 
use LogicException;
use MediaWiki\Cache\BacklinkCache;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
use Wikimedia\Rdbms\IDBAccessObject;
 
class CategoryMembershipChange {
 
    private const CATEGORY_ADDITION = 1;
    private const CATEGORY_REMOVAL = -1;
 
    private $timestamp;
 
    private $pageTitle;
 
    private RevisionRecord $revision;
 
    private $forImport;
 
    private $numTemplateLinks = 0;
 
    private $newForCategorizationCallback = null;
 
    private $backlinkCache;
 
    public function __construct(
        Title $pageTitle, BacklinkCache $backlinkCache, RevisionRecord $revision, bool $forImport
    ) {
        $this->pageTitle = $pageTitle;
        $this->revision = $revision;
 
        // Use the current timestamp for creating the RC entry when dealing with imported revisions,
        // since their timestamp may be significantly older than the current time.
        // This ensures the resulting RC entry won't be immediately reaped by probabilistic RC purging if
        // the imported revision is older than $wgRCMaxAge (T377392).
        $this->timestamp = $forImport ? wfTimestampNow() : $revision->getTimestamp();
        $this->newForCategorizationCallback = [ RecentChange::class, 'newForCategorization' ];
        $this->backlinkCache = $backlinkCache;
        $this->forImport = $forImport;
    }
 
    public function overrideNewForCategorizationCallback( callable $callback ) {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new LogicException( 'Cannot override newForCategorization callback in operation.' );
        }
        $this->newForCategorizationCallback = $callback;
    }
 
    public function checkTemplateLinks() {
        $this->numTemplateLinks = $this->backlinkCache->getNumLinks( 'templatelinks' );
    }
 
    public function triggerCategoryAddedNotification( PageIdentity $categoryPage ) {
        $this->createRecentChangesEntry( $categoryPage, self::CATEGORY_ADDITION );
    }
 
    public function triggerCategoryRemovedNotification( PageIdentity $categoryPage ) {
        $this->createRecentChangesEntry( $categoryPage, self::CATEGORY_REMOVAL );
    }
 
    private function createRecentChangesEntry( PageIdentity $categoryPage, $type ) {
        $this->notifyCategorization(
            $this->timestamp,
            $categoryPage,
            $this->getUser(),
            $this->getChangeMessageText(
                $type,
                $this->pageTitle->getPrefixedText(),
                $this->numTemplateLinks
            ),
            $this->pageTitle,
            $this->getPreviousRevisionTimestamp(),
            $this->revision,
            $this->forImport,
            $type === self::CATEGORY_ADDITION
        );
    }
 
    private function notifyCategorization(
        $timestamp,
        PageIdentity $categoryPage,
        ?UserIdentity $user,
        $comment,
        PageIdentity $page,
        $lastTimestamp,
        RevisionRecord $revision,
        bool $forImport,
        $added
    ) {
        $deleted = $revision->getVisibility() & RevisionRecord::SUPPRESSED_USER;
        $newRevId = $revision->getId();
 
        $bot = 1;
        $lastRevId = 0;
        $ip = '';
 
        $revisionStore = MediaWikiServices::getInstance()->getRevisionStore();
        $correspondingRc = $revisionStore->getRecentChange( $revision ) ??
            $revisionStore->getRecentChange( $revision, IDBAccessObject::READ_LATEST );
        if ( $correspondingRc !== null ) {
            $bot = $correspondingRc->getAttribute( 'rc_bot' ) ?: 0;
            $ip = $correspondingRc->getAttribute( 'rc_ip' ) ?: '';
            $lastRevId = $correspondingRc->getAttribute( 'rc_last_oldid' ) ?: 0;
        }
 
        $rc = ( $this->newForCategorizationCallback )(
            $timestamp,
            $categoryPage,
            $user,
            $comment,
            $page,
            $lastRevId,
            $newRevId,
            $lastTimestamp,
            $bot,
            $ip,
            $deleted,
            $added,
            $forImport
        );
        $rc->save();
    }
 
    private function getUser(): ?UserIdentity {
        return $this->revision->getUser( RevisionRecord::RAW );
    }
 
    private function getChangeMessageText( $type, $prefixedText, $numTemplateLinks ) {
        $array = [
            self::CATEGORY_ADDITION => 'recentchanges-page-added-to-category',
            self::CATEGORY_REMOVAL => 'recentchanges-page-removed-from-category',
        ];
 
        $msgKey = $array[$type];
 
        if ( intval( $numTemplateLinks ) > 0 ) {
            $msgKey .= '-bundled';
        }
 
        return wfMessage( $msgKey, $prefixedText )->inContentLanguage()->text();
    }
 
    private function getPreviousRevisionTimestamp() {
        $rl = MediaWikiServices::getInstance()->getRevisionLookup();
        $latestRev = $rl->getRevisionByTitle( $this->pageTitle );
        if ( $latestRev ) {
            $previousRev = $rl->getPreviousRevision( $latestRev );
            if ( $previousRev ) {
                return $previousRev->getTimestamp();
            }
        }
        return null;
    }
 
}
 
class_alias( CategoryMembershipChange::class, 'CategoryMembershipChange' );