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\router;

use core\exception\invalid_parameter_exception;

use core\exception\response_aware_exception;

use core\router;

use core\router\response\exception_response;

use core\router\response\invalid_parameter_response;

use core\router\schema\response\response_type;

use Psr\Container\ContainerInterface;

use Psr\Http\Message\ResponseInterface;

use Psr\Http\Message\ServerRequestInterface;

/**

 * Controller Invoker for the Moodle Router.

 *

 * This class handles invocation of the route callable, and the conversion of the response into an appropriate format.

 *

 * @package    core

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

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

 */

class response_handler {

    /**

     * Create a new response handler.

     *

     * @param ContainerInterface $container

     */

    public function __construct(

        /** @var ContainerInterface */

        private readonly ContainerInterface $container,

    ) {

    }

    /**

     * Invoke a route callable.

     *

     * Note: Much of this is copied from the parent class, but we need to handle the response differently.

     *

     * @param ResponseInterface|response_type $response The response object.

     * @return ResponseInterface The response from the callable.

     */

    public function standardise_response(

        ResponseInterface | response_type $response,

    ): ResponseInterface {

        if ($response instanceof ResponseInterface) {

            // An object implementing ResponseInterface is returned, so we can just return it.

            return $response;

        }

        $responsefactory = $this->container->get(router::class)->get_response_factory();

        // This must be a response\response_type.

        return $response->get_response($responsefactory);

    }

    /**

     * Get the response from an exception.

     *

     * @param ServerRequestInterface $request

     * @param \Exception $exception

     *

     * @return ResponseInterface

     */

    public function get_response_from_exception(

        ServerRequestInterface $request,

        \Exception $exception,

    ): ResponseInterface {

        $response = match (true) {

            // Newer exceptions may be response-aware, so we can use the response class they specify.

            (is_a($exception, response_aware_exception::class)) => $exception->get_response_classname()::get_response(

                $request,

                $exception,

            ),

            // Some legacy expressions are here for the moment.

            is_a($exception, invalid_parameter_exception::class) => invalid_parameter_response::get_response(

                $request,

                $exception,

            ),

            // Otherwise use the default.

            default => exception_response::get_response($request, $exception),

        };

        return $this->standardise_response($response);

    }

}