Action.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\MediaWikiServices;
 
abstract class Action implements MessageLocalizer {
 
    protected $page;
 
    private $article;
 
    protected $context;
 
    protected $fields;
 
    private static function getClass(
        string $action,
        array $overrides
    ) {
        global $wgActions;
        $action = strtolower( $action );
 
        if ( !isset( $wgActions[$action] ) ) {
            return null;
        }
 
        if ( $wgActions[$action] === false ) {
            return false;
        } elseif ( $wgActions[$action] === true && isset( $overrides[$action] ) ) {
            return $overrides[$action];
        } elseif ( $wgActions[$action] === true ) {
            return ucfirst( $action ) . 'Action';
        } else {
            return $wgActions[$action];
        }
    }
 
    final public static function factory(
        ?string $action,
        Page $article,
        IContextSource $context = null
    ) {
        if ( !is_string( $action ) ) {
            wfDeprecated( __METHOD__ . ' with null $action', '1.35' );
            return null;
        }
        if ( !$article instanceof Article ) {
            wfDeprecated(
                __METHOD__ . ' with ' . get_class( $article ),
                '1.35'
            );
        }
        $classOrCallable = self::getClass( $action, $article->getActionOverrides() );
        if ( is_string( $classOrCallable ) ) {
            if ( !class_exists( $classOrCallable ) ) {
                return false;
            }
            return new $classOrCallable( $article, $context );
        }
 
        if ( is_callable( $classOrCallable ) ) {
            return $classOrCallable( $article, $context );
        }
 
        return $classOrCallable;
    }
 
    final public static function getActionName( IContextSource $context ) {
        global $wgActions;
 
        $request = $context->getRequest();
        $actionName = $request->getVal( 'action', 'view' );
 
        // Check for disabled actions
        if ( isset( $wgActions[$actionName] ) && $wgActions[$actionName] === false ) {
            $actionName = 'nosuchaction';
        }
 
        // Workaround for T22966: inability of IE to provide an action dependent
        // on which submit button is clicked.
        if ( $actionName === 'historysubmit' ) {
            if ( $request->getBool( 'revisiondelete' ) ) {
                $actionName = 'revisiondelete';
            } elseif ( $request->getBool( 'editchangetags' ) ) {
                $actionName = 'editchangetags';
            } else {
                $actionName = 'view';
            }
        } elseif ( $actionName === 'editredlink' ) {
            $actionName = 'edit';
        }
 
        // Trying to get a WikiPage for NS_SPECIAL etc. will result
        // in WikiPage::factory throwing "Invalid or virtual namespace -1 given."
        // For SpecialPages et al, default to action=view.
        if ( !$context->canUseWikiPage() ) {
            return 'view';
        }
 
        $action = self::factory(
            $actionName,
            Article::newFromWikiPage( $context->getWikiPage(), $context ),
            $context
        );
 
        if ( $action instanceof Action ) {
            return $action->getName();
        }
 
        return 'nosuchaction';
    }
 
    final public static function exists( string $name ) : bool {
        return self::getClass( $name, [] ) !== null;
    }
 
    final public function getContext() {
        if ( $this->context instanceof IContextSource ) {
            return $this->context;
        }
        wfDebug( __METHOD__ . ": no context known, falling back to Article's context." );
        return $this->getArticle()->getContext();
    }
 
    final public function getRequest() {
        return $this->getContext()->getRequest();
    }
 
    final public function getOutput() {
        return $this->getContext()->getOutput();
    }
 
    final public function getUser() {
        return $this->getContext()->getUser();
    }
 
    final public function getSkin() {
        return $this->getContext()->getSkin();
    }
 
    final public function getLanguage() {
        return $this->getContext()->getLanguage();
    }
 
    final public function getWikiPage() : WikiPage {
        return $this->getArticle()->getPage();
    }
 
    public function getArticle() {
        return $this->article;
    }
 
    final public function getTitle() {
        return $this->getWikiPage()->getTitle();
    }
 
    final public function msg( $key, ...$params ) {
        return $this->getContext()->msg( $key, ...$params );
    }
 
    protected function getHookContainer() {
        return MediaWikiServices::getInstance()->getHookContainer();
    }
 
    protected function getHookRunner() {
        return new HookRunner( $this->getHookContainer() );
    }
 
    public function __construct(
        Page $page,
        IContextSource $context = null
    ) {
        if ( $context === null ) {
            wfWarn( __METHOD__ . ' called without providing a Context object.' );
        }
 
        $this->page = $page;// @todo remove b/c
        $this->article = self::convertPageToArticle( $page, $context, __METHOD__ );
        $this->context = $context;
    }
 
    private static function convertPageToArticle(
        Page $page,
        ?IContextSource $context,
        string $method
    ) : Article {
        if ( $page instanceof Article ) {
            return $page;
        }
 
        if ( !$page instanceof WikiPage ) {
            throw new LogicException(
                $method . ' called with unknown Page: ' . get_class( $page )
            );
        }
 
        wfDeprecated(
            $method . ' with: ' . get_class( $page ),
            '1.35'
        );
 
        return Article::newFromWikiPage(
            $page,
            $context ?? RequestContext::getMain()
        );
    }
 
    abstract public function getName();
 
    public function getRestriction() {
        return null;
    }
 
    public function needsReadRights() {
        return true;
    }
 
    protected function checkCanExecute( User $user ) {
        $right = $this->getRestriction();
        if ( $right !== null ) {
            $errors = MediaWikiServices::getInstance()->getPermissionManager()
                ->getPermissionErrors( $right, $user, $this->getTitle() );
            if ( count( $errors ) ) {
                throw new PermissionsError( $right, $errors );
            }
        }
 
        // If the action requires an unblock, explicitly check the user's block.
        if ( $this->requiresUnblock() && $user->isBlockedFrom( $this->getTitle() ) ) {
            $block = $user->getBlock();
            if ( $block ) {
                throw new UserBlockedError(
                    $block,
                    $user,
                    $this->getLanguage(),
                    $this->getRequest()->getIP()
                );
            }
 
            throw new PermissionsError( $this->getName(), [ 'badaccess-group0' ] );
        }
 
        // This should be checked at the end so that the user won't think the
        // error is only temporary when he also don't have the rights to execute
        // this action
        if ( $this->requiresWrite() && wfReadOnly() ) {
            throw new ReadOnlyError();
        }
    }
 
    public function requiresWrite() {
        return true;
    }
 
    public function requiresUnblock() {
        return true;
    }
 
    protected function setHeaders() {
        $out = $this->getOutput();
        $out->setRobotPolicy( 'noindex,nofollow' );
        $out->setPageTitle( $this->getPageTitle() );
        $out->setSubtitle( $this->getDescription() );
        $out->setArticleRelated( true );
    }
 
    protected function getPageTitle() {
        return $this->getTitle()->getPrefixedText();
    }
 
    protected function getDescription() {
        return $this->msg( strtolower( $this->getName() ) )->escaped();
    }
 
    public function addHelpLink( $to, $overrideBaseUrl = false ) {
        $msg = wfMessage( MediaWikiServices::getInstance()->getContentLanguage()->lc(
            self::getActionName( $this->getContext() )
            ) . '-helppage' );
 
        if ( !$msg->isDisabled() ) {
            $helpUrl = Skin::makeUrl( $msg->plain() );
            $this->getOutput()->addHelpLink( $helpUrl, true );
        } else {
            $this->getOutput()->addHelpLink( $to, $overrideBaseUrl );
        }
    }
 
    abstract public function show();
 
    protected function useTransactionalTimeLimit() {
        if ( $this->getRequest()->wasPosted() ) {
            wfTransactionalTimeLimit();
        }
    }
 
    public function doesWrites() {
        return false;
    }
}