Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace core;

use core\router\middleware\cors_middleware;

use core\router\middleware\error_handling_middleware;

use core\router\middleware\moodle_api_authentication_middleware;

use core\router\middleware\moodle_authentication_middleware;

use core\router\middleware\moodle_bootstrap_middleware;

use core\router\middleware\moodle_route_attribute_middleware;

use core\router\middleware\uri_normalisation_middleware;

use core\router\middleware\validation_middleware;

use core\router\request_validator_interface;

use core\router\response_handler;

use core\router\response_validator_interface;

use core\router\route_loader_interface;

use Psr\Http\Message\ResponseFactoryInterface;

use Psr\Http\Message\ResponseInterface;

use Psr\Http\Message\ServerRequestInterface;

use Slim\App;

use Slim\Exception\HttpForbiddenException;

use Slim\Exception\HttpNotFoundException;

use Slim\Interfaces\RouteGroupInterface;

use Slim\Middleware\ErrorMiddleware;

/**

 * Moodle Router.

 *

 * This class represents the Moodle Router, which handles all aspects of Routing in Moodle.

 *

 * It should not normally be accessed or used outside of its own unit tests, the route_testcase, and the `r.php` handler.

 *

 * @package    core

 * @copyright  Andrew Lyons <andrew@nicols.co.uk>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class router {

    /** @var string The base path to use for all requests */

    public readonly string $basepath;

    /** @var App The SlimPHP App */

    protected readonly App $app;

    /**

     * Create a new Router.

     *

     * @param response_handler $responsehandler

     * @param route_loader_interface $routeloader

     * @param request_validator_interface $requestvalidator

     * @param response_validator_interface $responsevalidator

     * @param null|string $basepath

     */

    public function __construct(

        /** @var response_handler */

        protected response_handler $responsehandler,

        /** @var route_loader_interface The router loader to use */

        protected readonly route_loader_interface $routeloader,

        /** @var request_validator_interface */

        protected request_validator_interface $requestvalidator,

        /** @var response_validator_interface */

        protected response_validator_interface $responsevalidator,

        ?string $basepath = null,

    ) {

        if ($basepath === null) {

            $basepath = $this->guess_basepath();

        }

        $this->basepath = $basepath;

    }

    /**

     * Guess the basepath for the Router.

     *

     * @return string

     */

    protected function guess_basepath(): string {

        global $CFG;

        // Moodle is not guaranteed to exist at the domain root.

        // Strip out the current script.

        $scriptroot = parse_url($CFG->wwwroot, PHP_URL_PATH) ?? '';

        $scriptfile = str_replace(

            realpath($CFG->dirroot),

            '',

            realpath($_SERVER['SCRIPT_FILENAME']),

        );

        // Replace occurrences of backslashes with forward slashes, especially on Windows.

        $scriptfile = str_replace('\\', '/', $scriptfile);

        // The server is not configured to rewrite unknown requests to automatically use the router.

        $userphp = false;

        if ($_SERVER && array_key_exists('REQUEST_URI', $_SERVER)) {

            if (str_starts_with($_SERVER['REQUEST_URI'], "{$scriptroot}/r.php")) {

                $userphp = true;

            }

        }

        if ($CFG->routerconfigured !== true || $userphp) {

            $scriptroot .= '/r.php';

        }

        return $scriptroot;

    }

    /**

     * Get the configured SlimPHP Application.

     *

     * @return App

     */

    public function get_app(): App {

        if (!isset($this->app)) {

            $this->create_app($this->basepath);

        }

        return $this->app;

    }

    /**

     * Get the Response Factory for the Router.

     *

     * @return ResponseFactoryInterface

     */

    public function get_response_factory(): ResponseFactoryInterface {

        return $this->get_app()->getResponseFactory();

    }

    /**

     * Create the configured SlimPHP Application.

     *

     * @param string $basepath The base path of the Moodle instance

     */

    protected function create_app(

        string $basepath = '',

    ): void {

        // Create an App using the DI Bridge.

        $this->app = router\bridge::create();

        // Add Middleware to the App.

        // Note: App Middleware is called before any Group or Route middleware.

        $this->add_middleware();

        $this->configure_caching();

        $this->configure_routes();

        // Configure the basepath for Moodle.

        $this->app->setBasePath($basepath);

    }

    /**

     * Add Middleware to the App.

     */

    protected function add_middleware(): void {

        // Middleware is added like an onion.

        // For a Response, the outer-most middleware is executed first, and the inner-most middleware is executed last.

        // For a Request, the inner-most middleware is executed first, and the outer-most middleware is executed last.

        // Add the body parsing middleware from Slim.

        // See https://www.slimframework.com/docs/v4/middleware/body-parsing.html for further information.

        $this->app->addBodyParsingMiddleware();

        // Add Middleware to Bootstrap Moodle from a request.

        $this->app->add(di::get(moodle_bootstrap_middleware::class));

        // Add the Moodle route attribute to the request.

        // This must be processed after the Routing Middleware has been processed on the request.

        $this->app->add(di::get(moodle_route_attribute_middleware::class));

        // Add the Routing Middleware as one of the outer-most middleware.

        // This allows the Route to be accessed before it is handled.

        // See https://www.slimframework.com/docs/v4/cookbook/retrieving-current-route.html for further information.

        $this->app->addRoutingMiddleware();

        // Add request normalisation middleware to standardise the URI.

        // This must be done before the Routing Middleware to ensure that the route is matched correctly.

        $this->app->add(di::get(uri_normalisation_middleware::class));

        // Add the Error Handling Middleware to the App.

        $this->add_error_handler_middleware();

    }

    /**

     * Add the Error Handling Middleware to the RouteGroup.

     */

    protected function add_error_handler_middleware(): void {

        // Add the Error Handling Middleware and configure it to show Moodle Errors for HTML pages.

        $errormiddleware = new ErrorMiddleware(

            $this->app->getCallableResolver(),

            $this->app->getResponseFactory(),

            displayErrorDetails: true,

            logErrors: true,

            logErrorDetails: true,

        );

        // Set a custom error handler for the HttpNotFoundException and HttpForbiddenException.

        // We route these to a custom error handler to ensure that the error is displayed with a feedback form.

        $errormiddleware->setErrorHandler(

            [

                HttpNotFoundException::class,

                HttpForbiddenException::class,

            ],

            new router\error_handler($this->app),

        );

        $errormiddleware->getDefaultErrorHandler()->registerErrorRenderer('text/html', router\error_renderer::class);

        $this->app->add($errormiddleware);

    }

    /**

     * Configure the API routes.

     */

    protected function configure_routes(): void {

        $routegroups = $this->routeloader->configure_routes($this->app);

        foreach ($routegroups as $name => $collection) {

            match ($name) {

                route_loader_interface::ROUTE_GROUP_API => $this->configure_api_route($collection),

                route_loader_interface::ROUTE_GROUP_PAGE => $this->configure_standard_route($collection),

                route_loader_interface::ROUTE_GROUP_SHIM => $this->configure_shim_route($collection),

                default => null,

            };

        }

    }

    /**

     * Configure the API Route Middleware.

     *

     * @param RouteGroupInterface $group

     */

    protected function configure_api_route(RouteGroupInterface $group): void {

        $group

            ->add(di::get(error_handling_middleware::class))

            // Add a Middleware to set the CORS headers for all REST Responses.

            ->add(di::get(cors_middleware::class))

            ->add(di::get(moodle_api_authentication_middleware::class))

            ->add(di::get(validation_middleware::class));

    }

    /**

     * Configure the Standard page Route Middleware.

     *

     * @param RouteGroupInterface $group

     */

    protected function configure_standard_route(RouteGroupInterface $group): void {

        $group

            ->add(di::get(moodle_authentication_middleware::class))

            ->add(di::get(validation_middleware::class));

    }

    /**

     * Configure the Shim Route Middleware.

     *

     * @param RouteGroupInterface $group

     */

    protected function configure_shim_route(RouteGroupInterface $group): void {

        $group

            // Note: In the future we may wish to add a shim middleware to notify users of updated bookmarks.

            ->add(di::get(validation_middleware::class));

    }

    /**

     * Configure caching for the routes.

     */

    protected function configure_caching(): void {

        global $CFG;

        // Note: Slim uses a file cache and is not compatible with MUC.

        $this->app->getRouteCollector()->setCacheFile(

            sprintf(

                "%s/routes.%s.cache",

                $CFG->cachedir,

                sha1($this->basepath),

            ),

        );

    }

    /**

     * Handle the specified Request.

     *

     * @param ServerRequestInterface $request

     * @return ResponseInterface

     */

    public function handle_request(

        ServerRequestInterface $request,

    ): ResponseInterface {

        return $this->get_app()->handle($request);

    }

    /**

     * Serve the current request using global variables.

     *

     * @codeCoverageIgnore

     */

    public function serve(): void {

        $this->get_app()->run();

    }

}