raspisms/descartes/Router.php

341 lines
12 KiB
PHP
Executable File

<?php
namespace descartes;
/**
* Cette classe gère l'appel des ressources
*/
class Router
{
/**
* Generate an url for a page of the app
* @param string $controller : Name of controller we want url for
* @param string $method : Name of method we want url for
* @param array $params : Parameters we want to transmit to controller method
* @param array $get_params : Get parameters we want to add to url
* @return string : the generated url
*/
public static function url (string $controller, string $method, array $params = [], array $get_params = []) : string
{
$url = HTTP_PWD;
if (!array_key_exists($controller, ROUTES))
{
throw new \descartes\exceptions\DescartesExceptionRouterUrlGenerationError('Try to generate url for controller ' . $controller . ' that did not exist.');
}
if (!array_key_exists($method, ROUTES[$controller]))
{
throw new \descartes\exceptions\DescartesExceptionRouterUrlGenerationError('Try to generate url for method ' . $controller . '::' . $method . ' that did not exist.');
}
$get_params = http_build_query($get_params);
$routes = ROUTES[$controller][$method];
if (!is_array($routes))
{
$routes = [$routes];
}
foreach ($routes as $route)
{
foreach ($params as $name => $value)
{
$find_flag = mb_strpos($route, '{' . $name . '}');
if ($find_flag === false)
{
continue 2;
}
$route = str_replace('{' . $name . '}', $value, $route);
}
$remain_flag = mb_strpos($route, '{');
if ($remain_flag)
{
continue;
}
return $url . $route . ($get_params ? '?' . $get_params : '');
}
throw new \descartes\exceptions\DescartesExceptionRouterUrlGenerationError('Cannot find any route for ' . $controller . '::' . $method . ' with parameters ' . print_r($params, true));
}
/**
* Clean url to remove anything before app root, and ancre, and parameters
* @param string $url : url to clean
* @return string : cleaned url
*/
protected static function clean_url (string $url)
{
$to_remove = parse_url(HTTP_PWD, PHP_URL_PATH);
$url = mb_strcut($url, mb_strlen($to_remove));
$url = parse_url($url, PHP_URL_PATH);
return $url;
}
/**
* Find controller and method to call for an url
* @param array $routes : Routes of the app
* @param string $url : url to find route for
* @return array|bool : An array, ['controller' => name of controller to call, 'method' => name of method to call, 'route' => 'route matching the url', 'route_regex' => 'the regex to extract data from url'], false on error
*/
protected static function map_url (array $routes, string $url)
{
foreach ($routes as $controller => $controller_routes)
{
foreach ($controller_routes as $method => $method_routes)
{
if (!is_array($method_routes))
{
$method_routes = [$method_routes];
}
foreach ($method_routes as $route)
{
$route_regex = preg_replace('#\\\{(.+)\\\}#iU', '([^/]+)', preg_quote($route, '#'));
$route_regex = preg_replace('#/$#', '/?', $route_regex);
$match = preg_match('#^' . $route_regex . '$#U', $url);
if (!$match)
{
continue;
}
return [
'controller' => $controller,
'method' => $method,
'route' => $route,
'route_regex' => $route_regex,
];
}
}
}
return false;
}
/**
* Get data from url and map it with route flags
* @param string $url : A clean url to extract data from (see clean_url)
* @param string $route : Route we must extract flag from
* @param string $route_regex : Regex to extract data from url
* @return array : An array with flagname and values, flag => value
*/
protected static function map_params_from_url (string $url, string $route, string $route_regex)
{
$flags = [];
preg_match_all('#\\\{(.+)\\\}#iU', preg_quote($route, '#'), $flags);
$flags = $flags[1];
$values = [];
if (!preg_match('#^' . $route_regex . '$#U', $url, $values))
{
return false;
}
unset($values[0]);
$values = array_map('rawurldecode', $values);
//On retourne les valeurs associées aux flags
return array_combine($flags, $values);
}
/**
* Compute a controller name to return is real path with namespace
* @param string $controller : The controller name
* @return string|bool : False if controller does not exist, controller name with namespace else
*/
protected static function compute_controller (string $controller)
{
$controller = str_replace('/', '\\', PWD_CONTROLLER . '/publics/') . $controller;
$controller = mb_strcut($controller, mb_strlen(PWD));
if (!class_exists($controller))
{
return false;
}
return $controller;
}
/**
* Compute a method to find his real name and check its available
* @param string $controller : Full namespace of controller to call
* @param string $method : The method to call
* @return string | bool : False if method unavaible, its realname else
*/
protected static function compute_method (string $controller, string $method)
{
if (is_subclass_of($controller, 'descartes\ApiController'))
{
//On va choisir le type à employer
$http_method = $_SERVER['REQUEST_METHOD'];
switch (mb_convert_case($http_method, MB_CASE_LOWER))
{
case 'delete' :
$prefix_method = 'delete_';
break;
case 'patch' :
$prefix_method = 'patch_';
break;
case 'post' :
$prefix_method = 'post_';
break;
case 'put' :
$prefix_method = 'put_';
break;
default :
$prefix_method = 'get_';
}
//If we dont match prefix with request method, return error
if (mb_substr($method, 0, mb_strlen($prefix_method)) != $prefix_method)
{
return false;
}
}
if (!method_exists($controller, $method))
{
return false;
}
if (!is_callable($controller, $method))
{
return false;
}
return $method;
}
/**
* Type, order and check params we must pass to method
* @param string $controller : Full namespace of controller
* @param string $method : Name of method
* @param array $params : Parameters to compute, format name => value
* @return array : Array ['success' => false, 'message' => error message] on error, and ['success' => true, 'method_arguments' => array of method arguments key=>val] on success
*/
protected static function compute_params (string $controller, string $method, array $params) : array
{
$reflection = new \ReflectionMethod($controller, $method);
$method_arguments = [];
foreach ($reflection->getParameters() as $parameter)
{
if (!array_key_exists($parameter->getName(), $params) && !$parameter->isDefaultValueAvailable())
{
return ['success' => false, 'message' => 'Try to call ' . $controller . '::' . $method . ' but ' . $parameter->getName() . ' is missing.'];
}
if ($parameter->isDefaultValueAvailable())
{
$method_arguments[$parameter->getName()] = $parameter->getDefaultValue();
}
if (!array_key_exists($parameter->getName(), $params))
{
continue;
}
$type = $parameter->getType();
$type = $type ?? false;
if ($type)
{
switch ($type)
{
case 'bool' :
$params[$parameter->getName()] = (bool) $params[$parameter->getName()];
break;
case 'int' :
$params[$parameter->getName()] = (int) $params[$parameter->getName()];
break;
case 'float' :
$params[$parameter->getName()] = (float) $params[$parameter->getName()];
break;
case 'string' :
$params[$parameter->getName()] = (string) $params[$parameter->getName()];
break;
default :
return ['success' => false, 'message' => 'Method ' . $controller . '::' . $method . ' use an invalid type for param ' . $parameter->getName() . '. Only bool, int float and string are supported.'];
break;
}
}
$method_arguments[$parameter->getName()] = $params[$parameter->getName()];
}
return ['success' => true, 'method_arguments' => $method_arguments];
}
/**
* Throw a 404 exception
*/
public static function error_404 () : void
{
throw new \descartes\exceptions\DescartesException404();
}
/**
* Route a query
* @param array $routes : Routes of app
* @param string $url : Url call
* @param mixed $args : Args we want to pass to Controller constructor
*/
public static function route (array $routes, string $url, ...$args) : void
{
$url = static::clean_url($url);
$computed_url = static::map_url($routes, $url);
if (!$computed_url)
{
static::error_404();
}
$params = static::map_params_from_url($url, $computed_url['route'], $computed_url['route_regex']);
$controller = static::compute_controller($computed_url['controller']);
if (!$controller)
{
throw new \descartes\exceptions\DescartesExceptionRouterInvocationError('Try to call controller ' . $computed_url['controller'] . ' that did not exists.');
}
$method = static::compute_method($controller, $computed_url['method']);
if (!$method)
{
throw new \descartes\exceptions\DescartesExceptionRouterInvocationError('Try to call the method ' . $computed_url['method'] . ' that did not exists from controller ' . $controller . '.');
}
$compute_params_result = static::compute_params($controller, $method, $params);
if (!$compute_params_result['success'])
{
throw new \descartes\exceptions\DescartesExceptionRouterInvocationError($compute_params_result['message']);
}
$method_arguments = $compute_params_result['method_arguments'];
$controller = new $controller(...$args);
call_user_func_array([$controller, $method], $method_arguments);
}
}