Action.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
 
abstract class Action implements MessageLocalizer {
 
    protected $page;
 
    protected $context;
 
    protected $fields;
 
    final private static function getClass( $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( $action, Page $page, IContextSource $context = null ) {
        $classOrCallable = self::getClass( $action, $page->getActionOverrides() );
 
        if ( is_string( $classOrCallable ) ) {
            if ( !class_exists( $classOrCallable ) ) {
                return false;
            }
            return new $classOrCallable( $page, $context );
        }
 
        if ( is_callable( $classOrCallable ) ) {
            return $classOrCallable( $page, $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, $context->getWikiPage(), $context );
        if ( $action instanceof Action ) {
            return $action->getName();
        }
 
        return 'nosuchaction';
    }
 
    final public static function exists( $name ) {
        return self::getClass( $name, [] ) !== null;
    }
 
    final public function getContext() {
        if ( $this->context instanceof IContextSource ) {
            return $this->context;
        } elseif ( $this->page instanceof Article ) {
            // NOTE: $this->page can be a WikiPage, which does not have a context.
            wfDebug( __METHOD__ . ": no context known, falling back to Article's context.\n" );
            return $this->page->getContext();
        }
 
        wfWarn( __METHOD__ . ': no context known, falling back to RequestContext::getMain().' );
        return RequestContext::getMain();
    }
 
    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 getTitle() {
        return $this->page->getTitle();
    }
 
    final public function msg( $key, ...$params ) {
        return $this->getContext()->msg( $key, ...$params );
    }
 
    public function __construct( Page $page, IContextSource $context = null ) {
        if ( $context === null ) {
            wfWarn( __METHOD__ . ' called without providing a Context object.' );
            // NOTE: We could try to initialize $context using $page->getContext(),
            //      if $page is an Article. That however seems to not work seamlessly.
        }
 
        $this->page = $page;
        $this->context = $context;
    }
 
    abstract public function getName();
 
    public function getRestriction() {
        return null;
    }
 
    protected function checkCanExecute( User $user ) {
        $right = $this->getRestriction();
        if ( $right !== null ) {
            $errors = $this->getTitle()->getUserPermissionsErrors( $right, $user );
            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 );
            }
 
            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;
    }
}