ApiDelete.php

Go to the documentation of this file.

<?php
use MediaWiki\Page\DeletePage;
use MediaWiki\Page\DeletePageFactory;
use MediaWiki\User\UserOptionsLookup;
use MediaWiki\Watchlist\WatchlistManager;
 
class ApiDelete extends ApiBase {
 
    use ApiWatchlistTrait;
 
    private $repoGroup;
 
    private $deletePageFactory;
 
    public function __construct(
        ApiMain $mainModule,
        $moduleName,
        RepoGroup $repoGroup,
        WatchlistManager $watchlistManager,
        UserOptionsLookup $userOptionsLookup,
        DeletePageFactory $deletePageFactory
    ) {
        parent::__construct( $mainModule, $moduleName );
        $this->repoGroup = $repoGroup;
        $this->deletePageFactory = $deletePageFactory;
 
        // 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();
 
        $tags = $params['tags'] ?: [];
 
        if ( $titleObj->getNamespace() === NS_FILE ) {
            $status = $this->deleteFile(
                $pageObj,
                $params['oldimage'],
                $reason,
                false,
                $tags
            );
            // TODO What kind of non-fatal errors should we expect here?
            $wasScheduled = $status->isOK() && $status->getValue() === false;
        } else {
            $status = $this->delete( $pageObj, $reason, $tags );
            $wasScheduled = $status->isGood() && $status->getValue() === false;
        }
 
        if ( !$status->isOK() ) {
            $this->dieStatus( $status );
        }
 
        if ( $wasScheduled ) {
            $this->addWarning( [ 'delete-scheduled', $titleObj->getPrefixedText() ] );
        }
 
        // 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 ( $wasScheduled ) {
            $r['scheduled'] = true;
        } else {
            // 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 function delete( WikiPage $page, &$reason = null, array $tags = [] ): StatusValue {
        $title = $page->getTitle();
 
        // Auto-generate a summary, if necessary
        if ( $reason === null ) {
            $reason = $page->getAutoDeleteReason();
            if ( $reason === false ) {
                // Should be reachable only if the page has no revisions
                return Status::newFatal( 'cannotdelete', $title->getPrefixedText() ); // @codeCoverageIgnore
            }
        }
 
        $deletePage = $this->deletePageFactory->newDeletePage( $page, $this->getAuthority() );
        $deletionStatus = $deletePage->setTags( $tags )->deleteIfAllowed( $reason );
        $deletionStatus->value = $deletePage->deletionsWereScheduled()[DeletePage::PAGE_BASE]
            ? false
            : $deletePage->getSuccessfulDeletionsIDs()[DeletePage::PAGE_BASE];
        return $deletionStatus;
    }
 
    protected static function canDeleteFile( File $file ) {
        return $file->exists() && $file->isLocal() && !$file->getRedirected();
    }
 
    private function deleteFile( WikiPage $page, $oldimage,
        &$reason = null, bool $suppress = false, array $tags = []
    ) {
        $title = $page->getTitle();
 
        // @phan-suppress-next-line PhanUndeclaredMethod There's no right typehint for it
        $file = $page->getFile();
        if ( !self::canDeleteFile( $file ) ) {
            return $this->delete( $page, $reason, $tags );
        }
 
        // Check that the user is allowed to carry out the deletion
        $this->checkTitleUserPermissions( $page->getTitle(), 'delete' );
        if ( $tags ) {
            // If change tagging was requested, check that the user is allowed to tag,
            // and the tags are valid
            $tagStatus = ChangeTags::canAddTagsAccompanyingChange( $tags, $this->getAuthority() );
            if ( !$tagStatus->isOK() ) {
                $this->dieStatus( $tagStatus );
            }
        }
 
        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, $this->getUser(), $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';
    }
}