RouteRegistrationService.php

Go to the documentation of this file.

<?php

namespace Elgg\Router;

use Elgg\EventsService;
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Router\Middleware\MaintenanceGatekeeper;
use Elgg\Router\Middleware\WalledGarden;
use Elgg\Traits\Loggable;

class RouteRegistrationService {

    use Loggable;

    public function __construct(
        protected EventsService $events,
        protected RouteCollection $routes,
        protected UrlGenerator $generator
    ) {
    }

    public function register(string $name, array $params = []): Route {

        $params = $this->events->triggerResults('route:config', $name, $params, $params);

        $path = elgg_extract('path', $params);
        $controller = elgg_extract('controller', $params);
        $file = elgg_extract('file', $params);
        $resource = elgg_extract('resource', $params);
        $handler = elgg_extract('handler', $params);
        $middleware = elgg_extract('middleware', $params, []);
        $walled = elgg_extract('walled', $params, true);
        $deprecated = elgg_extract('deprecated', $params, '');
        $required_plugins = elgg_extract('required_plugins', $params, []);
        $detect_page_owner = (bool) elgg_extract('detect_page_owner', $params, false);
        $priority = (int) elgg_extract('priority', $params);

        if (!$path || (!$controller && !$resource && !$handler && !$file)) {
            throw new InvalidArgumentException(
                __METHOD__ . ' requires "path" and one of controller parameters ("resource", "controller", "file" or "handler") to be set'
            );
        }

        $defaults = elgg_extract('defaults', $params, []);
        $requirements = elgg_extract('requirements', $params, []);
        $methods = elgg_extract('methods', $params, []);

        $patterns = [
            'guid' => '\d+',
            'group_guid' => '\d+',
            'container_guid' => '\d+',
            'owner_guid' => '\d+',
            'username' => '[\p{L}\p{M}\p{Nd}._-]+',
        ];

        $path = trim($path, '/');
        $segments = explode('/', $path);
        foreach ($segments as &$segment) {
            // look for segments that are defined as optional with added ?
            // e.g. /blog/owner/{username?}

            $matches = [];
            if (!preg_match('/\{(\w*)(\?)?\}/i', $segment, $matches)) {
                continue;
            }

            $wildcard = $matches[1];
            if (!isset($defaults[$wildcard]) && isset($matches[2])) {
                $defaults[$wildcard] = ''; // make it optional
            }

            if (!isset($requirements[$wildcard])) {
                if (array_key_exists($wildcard, $patterns)) {
                    $requirements[$wildcard] = $patterns[$wildcard];
                } else {
                    $requirements[$wildcard] = '.+?';
                }
            }

            $segment = '{' . $wildcard . '}';
        }

        $path = '/' . implode('/', $segments);

        if ($walled !== false) {
            $middleware[] = WalledGarden::class;
        }
        
        $middleware[] = MaintenanceGatekeeper::class;

        $defaults['_controller'] = $controller;
        $defaults['_file'] = $file;
        $defaults['_resource'] = $resource;
        $defaults['_handler'] = $handler;
        $defaults['_deprecated'] = $deprecated;
        $defaults['_middleware'] = $middleware;
        $defaults['_required_plugins'] = $required_plugins;
        $defaults['_detect_page_owner'] = $detect_page_owner;

        $options = array_merge((array) elgg_extract('options', $params, []), ['utf8' => true]);
        
        $route = new Route($path, $defaults, $requirements, $options, '', [], $methods);

        $this->routes->add($name, $route, $priority);

        return $route;
    }

    public function unregister(string $name): void {
        $this->routes->remove($name);
    }

    public function get(string $name): ?Route {
        return $this->routes->get($name);
    }

    public function all(): array {
        return $this->routes->all();
    }

    public function generateUrl(string $name, array $parameters = []): ?string {
        try {
            $route = $this->get($name);
            if ($route instanceof Route) {
                $deprecated = $route->getDefault('_deprecated');
                if (!empty($deprecated)) {
                    elgg_deprecated_notice("The route \"{$name}\" has been deprecated.", $deprecated);
                }
            }
            
            $url = $this->generator->generate($name, $parameters, UrlGenerator::ABSOLUTE_URL);

            // make sure the url is always normalized so it is also usable in CLI
            return elgg_normalize_url($url);
        } catch (\Exception $exception) {
            $this->getLogger()->notice($exception->getMessage());
        }
        
        return null;
    }

    public function resolveRouteParameters(string $name, ?\ElggEntity $entity = null, array $parameters = []) {
        $route = $this->routes->get($name);
        if (!$route) {
            return false;
        }

        $requirements = $route->getRequirements();
        $defaults = $route->getDefaults();
        $props = array_merge(array_keys($requirements), array_keys($defaults));

        foreach ($props as $prop) {
            if (str_starts_with($prop, '_')) {
                continue;
            }

            if (isset($parameters[$prop])) {
                continue;
            }

            if (!$entity) {
                $parameters[$prop] = '';
                continue;
            }

            switch ($prop) {
                case 'title':
                case 'name':
                    $parameters[$prop] = elgg_get_friendly_title($entity->getDisplayName());
                    break;

                default:
                    $parameters[$prop] = $entity->$prop;
                    break;
            }
        }

        return $parameters;
    }
}