RevisionDeleter.php

Go to the documentation of this file.

<?php
namespace MediaWiki\RevisionDelete;
 
use InvalidArgumentException;
use MediaWiki\Context\IContextSource;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Title\Title;
 
class RevisionDeleter {
    private const ALLOWED_TYPES = [
        'revision' => [
            'class' => RevDelRevisionList::class,
            'services' => [
                'DBLoadBalancerFactory',
                'HookContainer',
                'HtmlCacheUpdater',
                'RevisionStore',
                'DomainEventDispatcher'
            ],
        ],
        'archive' => [
            'class' => RevDelArchiveList::class,
            'services' => [
                'DBLoadBalancerFactory',
                'HookContainer',
                'HtmlCacheUpdater',
                'RevisionStore',
                'DomainEventDispatcher'
            ],
        ],
        'oldimage' => [
            'class' => RevDelFileList::class,
            'services' => [
                'DBLoadBalancerFactory',
                'HtmlCacheUpdater',
                'RepoGroup',
            ],
        ],
        'filearchive' => [
            'class' => RevDelArchivedFileList::class,
            'services' => [
                'DBLoadBalancerFactory',
                'HtmlCacheUpdater',
                'RepoGroup',
            ],
        ],
        'logging' => [
            'class' => RevDelLogList::class,
            'services' => [
                'DBLoadBalancerFactory',
                'CommentStore',
                'LogFormatterFactory',
            ],
        ],
    ];
 
    private const DEPRECATED_TYPE_MAP = [
        'oldid' => 'revision',
        'artimestamp' => 'archive',
        'oldimage' => 'oldimage',
        'fileid' => 'filearchive',
        'logid' => 'logging',
    ];
 
    public static function getTypes() {
        return array_keys( self::ALLOWED_TYPES );
    }
 
    public static function getCanonicalTypeName( $typeName ) {
        if ( isset( self::DEPRECATED_TYPE_MAP[$typeName] ) ) {
            $typeName = self::DEPRECATED_TYPE_MAP[$typeName];
        }
        return isset( self::ALLOWED_TYPES[$typeName] ) ? $typeName : null;
    }
 
    public static function createList( $typeName, IContextSource $context, PageIdentity $page, array $ids ) {
        $typeName = self::getCanonicalTypeName( $typeName );
        if ( !$typeName ) {
            throw new InvalidArgumentException( __METHOD__ . ": Unknown RevDel type '$typeName'" );
        }
        $spec = self::ALLOWED_TYPES[$typeName];
        $objectFactory = MediaWikiServices::getInstance()->getObjectFactory();
 
        // ObjectFactory::createObject accepts an array, not just a callable (phan bug)
        // @phan-suppress-next-line PhanTypeInvalidCallableArrayKey
        return $objectFactory->createObject(
            $spec,
            [
                'extraArgs' => [ $context, $page, $ids ],
                'assertClass' => RevDelList::class,
            ]
        );
    }
 
    protected static function checkItem( $desc, $field, $diff, $new, &$arr ) {
        if ( $diff & $field ) {
            $arr[( $new & $field ) ? 0 : 1][] = $desc;
        }
    }
 
    public static function getChanges( $n, $o ) {
        $diff = $n ^ $o;
        $ret = [ 0 => [], 1 => [], 2 => [] ];
        // Build bitfield changes in language
        self::checkItem( 'revdelete-content',
            RevisionRecord::DELETED_TEXT, $diff, $n, $ret );
        self::checkItem( 'revdelete-summary',
            RevisionRecord::DELETED_COMMENT, $diff, $n, $ret );
        self::checkItem( 'revdelete-uname',
            RevisionRecord::DELETED_USER, $diff, $n, $ret );
        // Restriction application to sysops
        if ( $diff & RevisionRecord::DELETED_RESTRICTED ) {
            if ( $n & RevisionRecord::DELETED_RESTRICTED ) {
                $ret[2][] = 'revdelete-restricted';
            } else {
                $ret[2][] = 'revdelete-unrestricted';
            }
        }
        return $ret;
    }
 
    public static function getRelationType( $typeName ) {
        $typeName = self::getCanonicalTypeName( $typeName );
        if ( !$typeName ) {
            return null;
        }
        $class = self::ALLOWED_TYPES[$typeName]['class'];
        return $class::getRelationType();
    }
 
    public static function getRestriction( $typeName ) {
        $typeName = self::getCanonicalTypeName( $typeName );
        if ( !$typeName ) {
            return null;
        }
        $class = self::ALLOWED_TYPES[$typeName]['class'];
        return $class::getRestriction();
    }
 
    public static function getRevdelConstant( $typeName ) {
        $typeName = self::getCanonicalTypeName( $typeName );
        if ( !$typeName ) {
            return null;
        }
        $class = self::ALLOWED_TYPES[$typeName]['class'];
        return $class::getRevdelConstant();
    }
 
    public static function suggestTarget( $typeName, $target, array $ids ) {
        $typeName = self::getCanonicalTypeName( $typeName );
        if ( !$typeName ) {
            return $target;
        }
        $class = self::ALLOWED_TYPES[$typeName]['class'];
        return $class::suggestTarget(
            $target,
            $ids
        );
    }
 
    public static function extractBitfield( array $bitPars, $oldfield ) {
        // Build the actual new rev_deleted bitfield
        $newBits = $oldfield;
        foreach ( $bitPars as $const => $val ) {
            // $const is the XXX_DELETED const
 
            if ( $val == 1 ) {
                $newBits |= $const; // set the bit
            } elseif ( $val == 0 ) {
                $newBits &= ~$const; // unset the bit
            }
        }
        return $newBits;
    }
}
 
class_alias( RevisionDeleter::class, 'RevisionDeleter' );