ApiDelete.php

Go to the documentation of this file.

<?php
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserOptionsLookup;
use MediaWiki\Watchlist\WatchlistManager;
 
class ApiDelete extends ApiBase {
 
    use ApiWatchlistTrait;
 
    private $repoGroup;
 
    public function __construct(
        ApiMain $mainModule,
        $moduleName,
        RepoGroup $repoGroup,
        WatchlistManager $watchlistManager,
        UserOptionsLookup $userOptionsLookup
    ) {
        parent::__construct( $mainModule, $moduleName );
        $this->repoGroup = $repoGroup;
 
        // Variables needed in ApiWatchlistTrait trait
        $this->watchlistExpiryEnabled = $this->getConfig()->get( 'WatchlistExpiry' );
        $this->watchlistMaxDuration = $this->getConfig()->get( 'WatchlistExpiryMaxDuration' );
        $this->watchlistManager = $watchlistManager;
        $this->userOptionsLookup = $userOptionsLookup;
    }
 
    public function execute() {
        $this->useTransactionalTimeLimit();
 
        $params = $this->extractRequestParams();
 
        $pageObj = $this->getTitleOrPageId( $params, 'fromdbmaster' );
        $titleObj = $pageObj->getTitle();
        $this->getErrorFormatter()->setContextTitle( $titleObj );
        if ( !$pageObj->exists() &&
            // @phan-suppress-next-line PhanUndeclaredMethod
            !( $titleObj->getNamespace() === NS_FILE && self::canDeleteFile( $pageObj->getFile() ) )
        ) {
            $this->dieWithError( 'apierror-missingtitle' );
        }
 
        $reason = $params['reason'];
        $user = $this->getUser();
 
        // Check that the user is allowed to carry out the deletion
        $this->checkTitleUserPermissions( $titleObj, 'delete' );
 
        // If change tagging was requested, check that the user is allowed to tag,
        // and the tags are valid
        if ( $params['tags'] ) {
            $tagStatus = ChangeTags::canAddTagsAccompanyingChange( $params['tags'], $this->getAuthority() );
            if ( !$tagStatus->isOK() ) {
                $this->dieStatus( $tagStatus );
            }
        }
 
        if ( $titleObj->getNamespace() === NS_FILE ) {
            $status = $this->deleteFile(
                $pageObj,
                $user,
                $params['oldimage'],
                $reason,
                false,
                $params['tags']
            );
        } else {
            $status = self::delete( $pageObj, $user, $reason, $params['tags'] );
        }
 
        if ( !$status->isOK() ) {
            $this->dieStatus( $status );
        }
        $this->addMessagesFromStatus( $status, [ 'warning' ], [ 'delete-scheduled' ] );
 
        // Deprecated parameters
        if ( $params['watch'] ) {
            $watch = 'watch';
        } elseif ( $params['unwatch'] ) {
            $watch = 'unwatch';
        } else {
            $watch = $params['watchlist'];
        }
 
        $watchlistExpiry = $this->getExpiryFromParams( $params );
        $this->setWatch( $watch, $titleObj, $user, 'watchdeletion', $watchlistExpiry );
 
        $r = [
            'title' => $titleObj->getPrefixedText(),
            'reason' => $reason,
        ];
 
        if ( $status->hasMessage( 'delete-scheduled' ) ) {
            $r['scheduled'] = true;
        }
        if ( $status->value !== null ) {
            // Scheduled deletions don't currently have a log entry available at this point
            $r['logid'] = $status->value;
        }
        $this->getResult()->addValue( null, $this->getModuleName(), $r );
    }
 
    private static function delete( WikiPage $page, UserIdentity $deleter, &$reason = null, $tags = [] ) {
        $title = $page->getTitle();
 
        // Auto-generate a summary, if necessary
        if ( $reason === null ) {
            // Need to pass a throwaway variable because generateReason expects
            // a reference
            $hasHistory = false;
            $reason = $page->getAutoDeleteReason( $hasHistory );
            if ( $reason === false ) {
                // Should be reachable only if the page has no revisions
                return Status::newFatal( 'cannotdelete', $title->getPrefixedText() ); // @codeCoverageIgnore
            }
        }
 
        $error = '';
 
        // Luckily, WikiPage provides a reusable delete function that does the hard work for us
        return $page->doDeleteArticleReal(
            $reason,
            $deleter,
            false, // don't suppress
            null, // unused
            $error,
            null, // unused
            $tags
        );
    }
 
    protected static function canDeleteFile( File $file ) {
        return $file->exists() && $file->isLocal() && !$file->getRedirected();
    }
 
    private function deleteFile( WikiPage $page, UserIdentity $deleter, $oldimage,
        &$reason = null, $suppress = false, $tags = []
    ) {
        $title = $page->getTitle();
 
        // @phan-suppress-next-line PhanUndeclaredMethod There's no right typehint for it
        $file = $page->getFile();
        if ( !self::canDeleteFile( $file ) ) {
            return self::delete( $page, $deleter, $reason, $tags );
        }
 
        if ( $oldimage ) {
            if ( !FileDeleteForm::isValidOldSpec( $oldimage ) ) {
                return Status::newFatal( 'invalidoldimage' );
            }
            $oldfile = $this->repoGroup->getLocalRepo()->newFromArchiveName( $title, $oldimage );
            if ( !$oldfile->exists() || !$oldfile->isLocal() || $oldfile->getRedirected() ) {
                return Status::newFatal( 'nodeleteablefile' );
            }
        }
 
        if ( $reason === null ) { // Log and RC don't like null reasons
            $reason = '';
        }
 
        return FileDeleteForm::doDelete( $title, $file, $oldimage, $reason, $suppress, $deleter, $tags );
    }
 
    public function mustBePosted() {
        return true;
    }
 
    public function isWriteMode() {
        return true;
    }
 
    public function getAllowedParams() {
        $params = [
            'title' => null,
            'pageid' => [
                ApiBase::PARAM_TYPE => 'integer'
            ],
            'reason' => null,
            'tags' => [
                ApiBase::PARAM_TYPE => 'tags',
                ApiBase::PARAM_ISMULTI => true,
            ],
            'watch' => [
                ApiBase::PARAM_DFLT => false,
                ApiBase::PARAM_DEPRECATED => true,
            ],
        ];
 
        // Params appear in the docs in the order they are defined,
        // which is why this is here and not at the bottom.
        $params += $this->getWatchlistParams();
 
        return $params + [
            'unwatch' => [
                ApiBase::PARAM_DFLT => false,
                ApiBase::PARAM_DEPRECATED => true,
            ],
            'oldimage' => null,
        ];
    }
 
    public function needsToken() {
        return 'csrf';
    }
 
    protected function getExamplesMessages() {
        return [
            'action=delete&title=Main%20Page&token=123ABC'
                => 'apihelp-delete-example-simple',
            'action=delete&title=Main%20Page&token=123ABC&reason=Preparing%20for%20move'
                => 'apihelp-delete-example-reason',
        ];
    }
 
    public function getHelpUrls() {
        return 'https://www.mediawiki.org/wiki/Special:MyLanguage/API:Delete';
    }
}