Router.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\Database\Plugins;
use Elgg\Exceptions\Http\BadRequestException;
use Elgg\Exceptions\Http\PageNotFoundException;
use Elgg\Exceptions\RuntimeException;
use Elgg\Http\Request as HttpRequest;
use Elgg\Http\ResponseBuilder;
use Elgg\Http\ResponseFactory;
use Elgg\Router\RouteCollection;
use Elgg\Router\UrlMatcher;
use Elgg\Traits\Debug\Profilable;
use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;

class Router {

    use Profilable;

    protected $events;

    protected $routes;

    protected $matcher;

    protected $handlers;

    protected $response;

    protected $plugins;

    public function __construct(
        EventsService $events,
        RouteCollection $routes,
        UrlMatcher $matcher,
        HandlersService $handlers,
        ResponseFactory $response,
        Plugins $plugins
    ) {
        $this->events = $events;
        $this->routes = $routes;
        $this->matcher = $matcher;
        $this->handlers = $handlers;
        $this->response = $response;
        $this->plugins = $plugins;
    }

    public function route(HttpRequest $request) {
        $this->beginTimer(['build page']);

        $request->validate();

        $response = $this->getResponse($request);

        if ($this->response->getSentResponse()) {
            return true;
        }

        $this->response->respond($response);
        
        return headers_sent();
    }

    public function getResponse(HttpRequest $request) {
        $response = $this->prepareResponse($request);
        
        if (!$response instanceof ResponseBuilder) {
            throw new PageNotFoundException();
        }

        if ($request->getFirstUrlSegment() == 'action') {
            if ($response->getForwardURL() === null) {
                $response->setForwardURL(REFERRER);
            }
        }

        return $response;
    }

    protected function prepareResponse(HttpRequest $request) {

        $segments = $request->getUrlSegments();
        $path = '/' . implode('/', $segments);

        try {
            $parameters = $this->matcher->match($path);

            $resource = (string) elgg_extract('_resource', $parameters);
            unset($parameters['_resource']);

            $handler = elgg_extract('_handler', $parameters);
            unset($parameters['_handler']);

            $controller = elgg_extract('_controller', $parameters);
            unset($parameters['_controller']);

            $file = elgg_extract('_file', $parameters);
            unset($parameters['_file']);

            $deprecated = elgg_extract('_deprecated', $parameters, '');
            unset($parameters['_deprecated']);
            
            $middleware = elgg_extract('_middleware', $parameters, []);
            unset($parameters['_middleware']);

            $required_plugins = (array) elgg_extract('_required_plugins', $parameters, []);
            unset($parameters['_required_plugins']);
            
            unset($parameters['_detect_page_owner']);
            
            foreach ($required_plugins as $plugin_id) {
                if (!$this->plugins->isActive($plugin_id)) {
                    throw new PageNotFoundException();
                }
            }

            $route = $this->routes->get($parameters['_route']);
            $route->setMatchedParameters($parameters);
            $request->setRoute($route);

            $envelope = new \Elgg\Request(elgg(), $request);
            $parameters['request'] = $envelope;

            if (!empty($deprecated)) {
                elgg_deprecated_notice("The route \"{$route->getName()}\" has been deprecated.", $deprecated);
            }
            
            foreach ($middleware as $callable) {
                $result = $this->handlers->call($callable, $envelope, null);
                if ($result[1] instanceof ResponseBuilder) {
                    return $result[1];
                }
            }

            if ($handler) {
                return $this->getResponseFromHandler($handler, $envelope);
            } elseif ($controller) {
                $result = $this->handlers->call($controller, $envelope, null);
                if ($result[1] instanceof ResponseBuilder) {
                    return $result[1];
                }
            } elseif ($file) {
                return $this->getResponseFromFile($file, $envelope);
            }
            
            $output = elgg_view_resource($resource, $parameters);
            return elgg_ok_response($output);
        } catch (ResourceNotFoundException $ex) {
            throw new PageNotFoundException();
        } catch (MethodNotAllowedException $ex) {
            throw new BadRequestException();
        }
    }

    protected function getResponseFromHandler($handler, \Elgg\Request $request) {
        if (!is_callable($handler)) {
            return null;
        }

        $path = trim($request->getPath(), '/');
        $segments = explode('/', $path);
        $identifier = array_shift($segments) ?: '';

        ob_start();
        try {
            $response = call_user_func($handler, $segments, $identifier, $request);
        } catch (\Exception $ex) {
            ob_end_clean();
            throw $ex;
        }

        $output = ob_get_clean();

        if ($response instanceof ResponseBuilder) {
            return $response;
        } else if ($response === false) {
            return null;
        }

        return elgg_ok_response($output);
    }

    protected function getResponseFromFile(string $file, \Elgg\Request $request) {
        if (!is_file($file)) {
            throw new PageNotFoundException(elgg_echo('actionnotfound', [$request->getPath()]), ELGG_HTTP_NOT_IMPLEMENTED);
        }

        ob_start();

        try {
            $response = include $file;
        } catch (\Exception $ex) {
            ob_get_clean();
            throw $ex;
        }

        $output = ob_get_clean();

        if ($response instanceof ResponseBuilder) {
            return $response;
        }

        return elgg_ok_response($output);
    }

    public function allowRewrite(HttpRequest $request) {
        $segments = $request->getUrlSegments();
        if (!empty($segments)) {
            $identifier = array_shift($segments);
        } else {
            $identifier = '';
        }

        $old = [
            'identifier' => $identifier,
            'segments' => $segments,
        ];
        $new = $this->events->triggerResults('route:rewrite', $identifier, $old, $old);
        if ($new === $old) {
            return $request;
        }

        if (!isset($new['identifier']) ||
            !isset($new['segments']) ||
            !is_string($new['identifier']) ||
            !is_array($new['segments'])
        ) {
            throw new RuntimeException('rewrite_path handler returned invalid route data.');
        }

        // rewrite request
        $segments = $new['segments'];
        array_unshift($segments, $new['identifier']);

        return $request->setUrlSegments($segments);
    }
}