RouteRegistrationService.php

Go to the documentation of this file.

<?php

namespace Elgg\Router;

use Elgg\Loggable;
use Elgg\Logger;
use Elgg\PluginHooksService;
use Elgg\Router\Middleware\WalledGarden;
use ElggEntity;
use Exception;
use InvalidParameterException;
use Psr\Log\LoggerInterface;

class RouteRegistrationService {

    use Loggable;

    protected $hooks;

    protected $routes;

    protected $generator;

    public function __construct(
        PluginHooksService $hooks,
        LoggerInterface $logger,
        RouteCollection $routes,
        UrlGenerator $generator
    ) {
        $this->hooks = $hooks;
        $this->logger = $logger;
        $this->routes = $routes;
        $this->generator = $generator;
    }

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

        $params = $this->hooks->trigger('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, []);
        $protected = elgg_extract('walled', $params, true);

        if (!$path || (!$controller && !$resource && !$handler && !$file)) {
            throw new InvalidParameterException(
                __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{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?}

            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 ($protected !== false) {
            $middleware[] = WalledGarden::class;
        }

        $defaults['_controller'] = $controller;
        $defaults['_file'] = $file;
        $defaults['_resource'] = $resource;
        $defaults['_handler'] = $handler;
        $defaults['_middleware'] = $middleware;

        $route = new Route($path, $defaults, $requirements, [
            'utf8' => true,
        ], '', [], $methods);

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

        return $route;
    }

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

    public function get($name) {
        return $this->routes->get($name);
    }

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

    public function generateUrl($name, array $parameters = []) {
        try {
            $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->logger->notice($exception->getMessage());
        }
        
        return false;
    }

    public function resolveRouteParameters($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 (substr($prop, 0, 1) === '_') {
                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;
    }

    public function registerPageHandler($identifier, $function) {
        if (!is_callable($function, true)) {
            return false;
        }

        $this->register($identifier, [
            'path' => "/$identifier/{segments}",
            'handler' => $function,
            'defaults' => [
                'segments' => '',
            ],
            'requirements' => [
                'segments' => '.+',
            ],
        ]);

        return true;
    }

    public function unregisterPageHandler($identifier) {
        $this->unregister($identifier);
    }

}