Router.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
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\Middleware\MaintenanceGatekeeper;
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;
 
    public function __construct(
        protected EventsService $events,
        protected RouteCollection $routes,
        protected UrlMatcher $matcher,
        protected HandlersService $handlers,
        protected ResponseFactory $response
    ) {
    }
 
    public function route(HttpRequest $request): bool {
        $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): ResponseBuilder {
        $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']);
            
            unset($parameters['_detect_page_owner']);
            unset($parameters['_use_logged_in']);
 
            $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);
            }
            
            // force presence of MaintenanceGatekeeper
            array_unshift($middleware, MaintenanceGatekeeper::class);
            
            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) {
            $envelope = new \Elgg\Request(elgg(), $request);
            $result = $this->handlers->call(MaintenanceGatekeeper::class, $envelope, null);
            if ($result[1] instanceof ResponseBuilder) {
                return $result[1];
            }
            
            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);
    }
}