api-utils/src/Utils/Controller/LuRoute.php

<?php

namespace Luticate\Utils\Controller;

use FastRoute\Dispatcher;
use Luticate\Utils\Business\LuBusinessException;
use Luticate\Utils\Business\LuMethodDocParser;
use Luticate\Utils\Dbo\LuDboConstraintException;
use Luticate\Utils\Dbo\LuDboDeserializeException;
use FastRoute\DataGenerator\GroupCountBased as DataGeneratorGroupCountBased;
use FastRoute\Dispatcher\GroupCountBased as DispatcherGroupCountBased;
use FastRoute\RouteCollector;
use FastRoute\RouteParser\Std;
use Luticate\Utils\Dbo\LuRouteDbo;
use Luticate\Utils\Middleware\LuAbstractMiddleware;

class LuRoute {

    const REG_UINT = "[0-9]+";
    const REG_INT = "\\-?" . self::REG_UINT;
    const REG_BOOL = "true|false";

    /**
     * @var DispatcherGroupCountBased
     */
    private $_dispatcher = null;

    /**
     * @var string[]
     */
    private $middleware = array('Luticate\Utils\ParametersMiddleware');

    /**
     * @var LuRouteDbo[]
     */
    private $routes = array();

    public function __construct()
    {
    }

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

    /**
     * @param $middleware string
     */
    public function addMiddleware($middleware)
    {
        $this->middleware[] = $middleware;
    }
    
    public function setup()
    {
        $routeCollector = new RouteCollector(new Std(), new DataGeneratorGroupCountBased());
        $router = $this;

        foreach ($this->getRoutes() as $route) {
            $routeCollector->addRoute($route->getMethod(), $route->getUrl(), function($parameters) use($route, $router)
            {
                return $router->execute($route, $parameters);
            });
        }

        $this->_dispatcher = new DispatcherGroupCountBased($routeCollector->getData());
    }

    public function execute(LuRouteDbo $route, $parameters)
    {
        $middlewares = [];
        foreach ($route->getMiddlewares() as $middlewareName) {
            /**
             * @var $middleware LuAbstractMiddleware
             */
            $middleware = new $middlewareName();
            $parameters = $middleware->onBefore($route, $parameters);
            $middlewares[] = $middleware;
        }

        $reflect = new \ReflectionMethod($route->getControllerClass(), $route->getControllerMethod());
        $params = $reflect->getParameters();
        $doc = new LuMethodDocParser($reflect->getDocComment());
        $doc->parse();

        $args = array();
        foreach ($params as $param) {

            try {
                if ($param->isOptional()) {
                    $value = null;
                    if (array_key_exists($param->getName(), $parameters)) {
                        $value = $this->getParam($param, $parameters[$param->getName()]);
                    }
                    else {
                        $value = $param->getDefaultValue();
                    }
                    $args[$param->getName()] = $value;
                }
                else {
                    if (array_key_exists($param->getName(), $parameters)) {
                        $args[$param->getName()] = $this->getParam($param, $parameters[$param->getName()]);
                        
                        if (is_null($args[$param->getName()]) && 
                            array_key_exists($param->getName(), $doc->getParams()) &&
                            $doc->getParams()[$param->getName()]->isNotNull()) {
                            throw new LuBusinessException("Parameter '" . $param->getName() . "' can not be null", 400);
                        }
                    }
                    else {
                        throw new LuBusinessException("Missing parameter '" . $param->getName() . "'", 400);
                    }
                }
                
                if (array_key_exists($param->getName(), $doc->getParams())) {
                    foreach ($doc->getParams()[$param->getName()]->getConstraints() as $constraint) {
                        call_user_func_array([$args[$param->getName()], $constraint->getMethod()],
                            $constraint->getArguments());
                    }
                }
            }
            catch (LuDboConstraintException $e)
            {
                $paramName = $param->getName();
                throw new LuBusinessException("Invalid value for '${paramName}': " . $e->getMessage(), 400, $e);
            }
            catch (LuDboDeserializeException $e)
            {
                $paramName = $param->getName();
                throw new LuBusinessException("Failed to deserialize '${paramName}': " . $e->getMessage(), 400, $e);
            }
        }

        $controller = $route->getControllerClass();
        $controllerInstance = new $controller();
        $result = call_user_func_array(array($controllerInstance, $route->getControllerMethod()), $args);

        foreach ($middlewares as $middleware) {
            $result = $middleware->onAfter($route, $parameters, $result);
        }

        return $result;
    }

    public function dispatch(string $httpMethod, string $url, $parameters)
    {
        $routeInfo = $this->_dispatcher->dispatch($httpMethod, $url);

        if ($routeInfo[0] == Dispatcher::NOT_FOUND) {
            throw new LuBusinessException("Route not found", 404);
        }
        else if ($routeInfo[0] == Dispatcher::METHOD_NOT_ALLOWED) {
            throw new LuBusinessException("Method not allowed", 405);
        }
        else {
            $handler = $routeInfo[1];
            $urlVars = $routeInfo[2];
            $parameters = array_merge($parameters, $urlVars);
            return $handler($parameters);
        }
    }
    
    private function getClassName(\ReflectionParameter $param) {
        preg_match('/\[\s\<\w+?>\s([\w]+)/s', $param->__toString(), $matches);
        return isset($matches[1]) ? $matches[1] : null;
    }

    private function getParam(\ReflectionParameter $param, $value)
    {
        $typedValue = null;
        $className = $this->getClassName($param);
        if (is_null($className)) {
            $typedValue = $value;
        }
        else {
            $class = $param->getClass();
            try
            {
                $json = json_decode($value, true);
                if (is_null($json)) {
                    $json = $value . "";
                }
                $typedValue = call_user_func_array(array($class->getName(), "jsonDeserialize"), array($json));
            }
            catch (LuDboDeserializeException $e)
            {
                throw $e;
            }
            catch (\Exception $e)
            {
                throw new LuBusinessException("Unable to parse JSON value for '" . $param->getName() . "'", 400, $e);
            }
        }
        return $typedValue;
    }

    public function addRoute(string $httpMethod, string $url, string $controller, string $method, $permissions = array(), $middlewares = array())
    {
        if (!is_array($permissions)) {
            $permissions = array($permissions);
        }
        if (!is_array($middlewares)) {
            $middlewares = array($middlewares);
        }

        if (strpos($controller, "\\") === false) {
            $controller = "App\\Controller\\" . $controller . "Controller";
        }

        $route = new LuRouteDbo();
        $route->setUrl($url);
        $route->setControllerClass($controller);
        $route->setControllerMethod($method);
        $route->setMiddlewares($middlewares);
        $route->setPermissions($permissions);
        $route->setMethod($httpMethod);
        $this->routes[] = $route;
    }
    
    public function get(string $url, string $controller, string $method, $permissions = array(), $middleware = array())
    {
        $this->addRoute("GET", $url, $controller, $method, $permissions, $middleware);
    }

    public function post(string $url, string $controller, string $method, $permissions = array(), $middleware = array())
    {
        $this->addRoute("POST", $url, $controller, $method, $permissions, $middleware);
    }

    public function put(string $url, string $controller, string $method, $permissions = array(), $middleware = array())
    {
        $this->addRoute("PUT", $url, $controller, $method, $permissions, $middleware);
    }

    public function delete(string $url, string $controller, string $method, $permissions = array(), $middleware = array())
    {
        $this->addRoute("DELETE", $url, $controller, $method, $permissions, $middleware);
    }
}