ActionModuleBasedHandler.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Rest\Handler;
 
use ApiBase;
use ApiMain;
use ApiMessage;
use ApiUsageException;
use FauxRequest;
use IApiMessage;
use MediaWiki\Rest\Handler;
use MediaWiki\Rest\HttpException;
use MediaWiki\Rest\LocalizedHttpException;
use MediaWiki\Rest\Response;
use RequestContext;
use WebResponse;
use Wikimedia\Message\ListParam;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageValue;
use Wikimedia\Message\ParamType;
use Wikimedia\Message\ScalarParam;
 
abstract class ActionModuleBasedHandler extends Handler {
 
    private $apiMain = null;
 
    protected function getUser() {
        return $this->getApiMain()->getUser();
    }
 
    public function setApiMain( ApiMain $apiMain ) {
        $this->apiMain = $apiMain;
    }
 
    public function getApiMain() {
        if ( $this->apiMain ) {
            return $this->apiMain;
        }
 
        $context = RequestContext::getMain();
        $session = $context->getRequest()->getSession();
 
        // NOTE: This being a FauxRequest instance triggers special case behavior
        // in ApiMain, causing ApiMain::isInternalMode() to return true. Among other things,
        // this causes ApiMain to throw errors rather than encode them in the result data.
        $fauxRequest = new FauxRequest( [], true, $session );
        $fauxRequest->setSessionId( $session->getSessionId() );
 
        $fauxContext = new RequestContext();
        $fauxContext->setRequest( $fauxRequest );
        $fauxContext->setUser( $context->getUser() );
        $fauxContext->setLanguage( $context->getLanguage() );
 
        $this->apiMain = new ApiMain( $fauxContext, true );
        return $this->apiMain;
    }
 
    public function overrideActionModule( string $name, string $group, ApiBase $module ) {
        $this->getApiMain()->getModuleManager()->addModule(
            $name,
            $group,
            [
                'class' => get_class( $module ),
                'factory' => static function () use ( $module ) {
                    return $module;
                }
            ]
        );
    }
 
    public function execute() {
        $apiMain = $this->getApiMain();
 
        $params = $this->getActionModuleParameters();
        $request = $apiMain->getRequest();
 
        foreach ( $params as $key => $value ) {
            $request->setVal( $key, $value );
        }
 
        try {
            // NOTE: ApiMain detects this to be an internal call, so it will throw
            // ApiUsageException rather than putting error messages into the result.
            $apiMain->execute();
        } catch ( ApiUsageException $ex ) {
            // use a fake loop to throw the first error
            foreach ( $ex->getStatusValue()->getErrorsByType( 'error' ) as $error ) {
                $msg = ApiMessage::create( $error );
                $this->throwHttpExceptionForActionModuleError( $msg, $ex->getCode() ?: 400 );
            }
 
            // This should never happen, since ApiUsageExceptions should always
            // have errors in their Status object.
            throw new HttpException(
                'Unmapped action module error: ' . $ex->getMessage(),
                $ex->getCode()
            );
        }
 
        $actionModuleResult = $apiMain->getResult()->getResultData( null, [ 'Strip' => 'all' ] );
 
        // construct result
        $resultData = $this->mapActionModuleResult( $actionModuleResult );
 
        $response = $this->getResponseFactory()->createFromReturnValue( $resultData );
 
        $this->mapActionModuleResponse(
            $apiMain->getRequest()->response(),
            $actionModuleResult,
            $response
        );
 
        return $response;
    }
 
    abstract protected function getActionModuleParameters();
 
    abstract protected function mapActionModuleResult( array $data );
 
    protected function mapActionModuleResponse(
        WebResponse $actionModuleResponse,
        array $actionModuleResult,
        Response $response
    ) {
        // TODO: map status, headers, cookies, etc
    }
 
    protected function throwHttpExceptionForActionModuleError( IApiMessage $msg, $statusCode = 400 ) {
        // override to supply mappings
 
        throw new LocalizedHttpException(
            $this->makeMessageValue( $msg ),
            $statusCode,
            // Include the original error code in the response.
            // This makes it easier to track down the original cause of the error,
            // and allows more specific mappings to be added to
            // implementations of throwHttpExceptionForActionModuleError() provided by
            // subclasses
            [ 'actionModuleErrorCode' => $msg->getApiCode() ]
        );
    }
 
    protected function makeMessageValue( IApiMessage $msg ) {
        $params = [];
 
        // TODO: find a better home for the parameter mapping logic
        foreach ( $msg->getParams() as $p ) {
            $params[] = $this->makeMessageParam( $p );
        }
 
        return new MessageValue( $msg->getKey(), $params );
    }
 
    private function makeMessageParam( $param ) {
        if ( is_array( $param ) ) {
            foreach ( $param as $type => $value ) {
                if ( $type === 'list' ) {
                    $paramList = [];
 
                    foreach ( $value as $v ) {
                        $paramList[] = $this->makeMessageParam( $v );
                    }
 
                    return new ListParam( ParamType::TEXT, $paramList );
                } else {
                    return new ScalarParam( $type, $value );
                }
            }
        } else {
            return new ScalarParam( ParamType::TEXT, $param );
        }
    }
 
}