/** * @param Request $request * @param Response $response * @param callable $next * @return Response */ public function __invoke(Request $request, Response $response, callable $next) { $dispatcher = new Dispatcher($this->collector->getData()); $result = $dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath()); $code = $result[0]; if ($code != Dispatcher::FOUND) { return $next($request, $response); } /** @var Route $route */ $route = $result[1]; $params = $result[2]; $request = $request->withAttribute('params', $params); foreach ($params as $key => $value) { $request[$key] = $value; } // Custom middleware handler. // We have to iterate through middleware as it was added so that they retain the proper ordering. // We have to check if the middleware is a route and if it was the route matched during dispatching. // If so, we can call the route handler, otherwise, we need to skip over it. $middleware = $this->middleware; $callable = function ($request, $response) use(&$callable, &$middleware, $route, $next) { /** @var callable $layer */ $layer = array_shift($middleware); if ($layer instanceof Route) { if ($layer !== $route) { return $callable($request, $response, $next); } $layer = $this->resolver->resolve($route->getHandler()); return $layer($request, $response); } return $layer($request, $response, $callable); }; return $callable($request, $response); }
/** * URL からディスパッチ対象を取得する * * @param string $http_method * @param string $url * @return array */ public function dispatch($http_method, $url) { if ($this->dispatcher === null) { throw new \RuntimeException('Route dispatcher is not initialized'); } $this->dispatched_http_method = $http_method; $this->dispatched_url = $url; $this->route_info = $this->dispatcher->dispatch($http_method, $url); return $this->route_info; }
/** * @internal * @param Request $request * @param Response $response * @param callable $next * @return Response */ public function dispatchHandler(Request $request, Response $response, callable $next) { $dispatcher = new Dispatcher($this->collector->getData()); $result = $dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath()); $code = $result[0]; $handler = isset($result[1]) ? $result[1] : null; $params = isset($result[2]) ? $result[2] : []; if ($code != Dispatcher::FOUND) { return $next ? $next($request, $response) : $response; } foreach ($params as $key => $value) { $request[$key] = $value; } return $this->paramHandler($request, $response, $next, $handler, $params); }
/** * Visszaadja a paraméterben megadott adatok alapján, a megfelelő handler-t és az ahhoz tartozó esetleges * paramétereket. * * Ha nem talál egyezést abban az esetben HttpNotFoundException hibát dob. * * * @param $method * @param $uri * @return array * @throws HttpNotFoundException */ public function findRoute($method, $uri) { // Strip query string (?foo=bar) and decode URI if (false !== ($pos = strpos($uri, '?'))) { $uri = substr($uri, 0, $pos); } $uri = rawurldecode($uri); $routeInfo = $this->dispatcher->dispatch($method, $uri); switch ($routeInfo[0]) { case RouterInterface::NOT_FOUND: throw new HttpNotFoundException(); case RouterInterface::METHOD_NOT_ALLOWED: throw new HttpNotFoundException(); case RouterInterface::FOUND: $params = $routeInfo[2]; //Ha van locale, akkor azt beállítjuk és töröljük a paraméter listából if (isset($params["locale"])) { Application::Translator()->setLocale($params["locale"]); unset($params["locale"]); } foreach ($this->routes as $route) { if ($route["handler"] == $routeInfo[1]) { $this->actualRoute = $route; break; } } return ["handler" => $routeInfo[1], "params" => $params]; default: return []; } }
public function it_should_throw_exception_when_unknown_routing_status(ServerRequestInterface $request, UriInterface $uri, ResponseInterface $response, GroupCountBased $dispatcher) { $request->getMethod()->willReturn('GET'); $request->getUri()->willReturn($uri); $uri->getPath()->willReturn('/'); $dispatcher->dispatch('GET', '/')->willReturn([99999]); $this->shouldThrow(InternalErrorHttpException::class)->during('__invoke', [$request, $response, function ($request, $response) { return $response; }]); }
public function match($uri, $method) { $routeInfo = array(); $dispatcher = new FastRoute\Dispatcher\GroupCountBased($this->fastRoute->getData()); $fastRouteInfo = $dispatcher->dispatch($method, $uri); switch ($fastRouteInfo[0]) { case FastRoute\Dispatcher::NOT_FOUND: $routeInfo[0] = self::NOT_FOUND; break; case FastRoute\Dispatcher::METHOD_NOT_ALLOWED: $routeInfo[0] = self::METHOD_NOT_ALLOWED; break; case FastRoute\Dispatcher::FOUND: $routeInfo[0] = self::FOUND; $routeInfo[1] = $fastRouteInfo[1]; $routeInfo[2] = $fastRouteInfo[2]; break; } return $routeInfo; }
/** * Dispatch router * * @param string $requestUri * @param string $requestMethod * @param callable $callable * @return $this * @throws MethodNotAllowed * @throws NotFound */ public function dispatch(string $requestUri, string $requestMethod, callable $callable) { $this->registerRoutes(); $routeInfo = $this->dispatcher->dispatch($requestMethod, $requestUri); switch ($routeInfo[0]) { case FastRoute\Dispatcher::NOT_FOUND: throw new NotFound('Unable to match request for route ' . $requestUri . ' and method: ' . $requestMethod); break; case FastRoute\Dispatcher::METHOD_NOT_ALLOWED: $allowedMethods = $routeInfo[1]; throw new MethodNotAllowed($requestMethod . ' is not allowed for route', 0, null, $allowedMethods); break; case FastRoute\Dispatcher::FOUND: $handler = $routeInfo[1]; $vars = $routeInfo[2]; call_user_func_array($callable, [$handler, $vars]); break; } return $this; }
/** * @param ServerRequestInterface $request * @param ResponseInterface $response * @param callable $next * @return ResponseInterface * @throws NotFoundHttpException * @throws MethodNotAllowedHttpException * @throws InternalErrorHttpException */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) { /** * dispatch before route */ $this->event->dispatch(VinnigeEvents::BEFORE_ROUTE, new BeforeRouteEvent($request)); $info = $this->dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath()); switch ($info[0]) { case Dispatcher::NOT_FOUND: throw new NotFoundHttpException('not found'); break; case Dispatcher::METHOD_NOT_ALLOWED: throw new MethodNotAllowedHttpException([$info[0][1]], 'method not allowed'); break; case Dispatcher::FOUND: $request = $request->withAttribute('param', $info[2]); /** * dispatch before dispatch event */ $this->event->dispatch(VinnigeEvents::BEFORE_DISPATCH_ROUTE, new BeforeDispatchRouteEvent($request, $info[1])); if (is_callable($info[1])) { $response = $info[1]($request, $response); } else { $controller = $this->app[$info[1]]; if (!$controller instanceof ClassBasedRoutingHandlerInterface) { throw new InternalErrorHttpException(sprintf('class %s must implement %s', $info[1], ClassBasedRoutingHandlerInterface::class)); } /** * resolve middleware from container and invoke it */ $response = $controller($request, $response); } return $next($request, $response, $next); break; default: throw new InternalErrorHttpException('routing error'); } }
/** * Match and dispatch a route matching the given http method and uri * * @param string $method * @param string $uri * @return \Symfony\Component\HttpFoundation\Response */ public function dispatch($method, $uri) { $match = parent::dispatch($method, $uri); if ($match[0] === FastRoute::NOT_FOUND) { return $this->handleNotFound(); } if ($match[0] === FastRoute::METHOD_NOT_ALLOWED) { $allowed = (array) $match[1]; return $this->handleNotAllowed($allowed); } $handler = isset($this->routes[$match[1]]['callback']) ? $this->routes[$match[1]]['callback'] : $match[1]; $strategy = $this->routes[$match[1]]['strategy']; $vars = (array) $match[2]; return $this->handleFound($handler, $strategy, $vars); }
public function find($httpMethod, $uri, ServerRequestInterface $request) { list($this->staticRouteMap, $this->variableRouteData) = $this->getCollector()->getData(); $result = parent::dispatch($httpMethod, $uri); switch ($result[0]) { case self::NOT_FOUND: throw new RouteNotFoundException(); case self::METHOD_NOT_ALLOWED: throw new MethodNotAllowedException((array) $result[1]); } $route = $this->getRoute($result[1], $request); foreach ((array) $result[2] as $name => $value) { $route->setAttribute($name, $value); } return $route; }
/** * Match and dispatch a route matching the given http method and uri * * @param string $method * @param string $uri * @return \Orno\Http\ResponseInterface */ public function dispatch($method, $uri) { $match = parent::dispatch($method, $uri); switch ($match[0]) { case FastRoute\Dispatcher::NOT_FOUND: $response = $this->handleNotFound(); break; case FastRoute\Dispatcher::METHOD_NOT_ALLOWED: $allowed = (array) $match[1]; $response = $this->handleNotAllowed($allowed); break; case FastRoute\Dispatcher::FOUND: default: $handler = isset($this->routes[$match[1]]['callback']) ? $this->routes[$match[1]]['callback'] : $match[1]; $strategy = $this->routes[$match[1]]['strategy']; $vars = (array) $match[2]; $response = $this->handleFound($handler, $strategy, $vars); break; } return $response; }
/** * @param $method * @param $uri * @return array * @throws HttpNotFoundException */ public function findRoute($method, $uri) { $routes = $this->getRoutes(); //Hozzá kell még adni a nyelvi url-t, ha van. $translator = Application::Translator(); if ($translator != null) { $langRoute = $translator->getCookieSetUrl(); if ($langRoute != null) { $routes["langSetRoute"] = ["method" => $langRoute["method"], "url" => $langRoute["url"], "handler" => $langRoute["handler"]]; } } $this->dispatcher = simpleDispatcher(function (RouteCollector $r) use($routes) { foreach ($routes as $route) { $r->addRoute($route["method"], $route["url"], $route["handler"]); } }); // Strip query string (?foo=bar) and decode URI if (false !== ($pos = strpos($uri, '?'))) { $uri = substr($uri, 0, $pos); } $uri = rawurldecode($uri); $routeInfo = $this->dispatcher->dispatch($method, $uri); switch ($routeInfo[0]) { case RouterInterface::NOT_FOUND: throw new HttpNotFoundException(); case RouterInterface::METHOD_NOT_ALLOWED: throw new HttpNotFoundException(); case RouterInterface::FOUND: foreach ($routes as $route) { if ($route["handler"] == $routeInfo[1]) { $this->actualRoute = $route; break; } } return ["handler" => $routeInfo[1], "params" => $routeInfo[2]]; default: return []; } }
public function checkGroupUrl($path) { if ($this->cacheRouteData === false) { if (!file_exists($this->authRouteFile)) { return false; } $this->cacheRouteData = (require $this->authRouteFile); } $dispatcher = new GroupCountBased($this->cacheRouteData); $route = $dispatcher->dispatch('GET', $path); switch ($route[0]) { case \FastRoute\Dispatcher::NOT_FOUND: return false; case \FastRoute\Dispatcher::METHOD_NOT_ALLOWED: return false; case \FastRoute\Dispatcher::FOUND: return call_user_func_array($route[1], $route[2]); default: return false; } }
/** * Wrapper for using resolve() instead of dispatch(). * * @param string $httpMethod The HTTP Method to route * @param string $uri The URI to route * * @author Benjamin Carl <*****@*****.**> * @return array The result as array? * @access public */ public function resolve($httpMethod, $uri) { return parent::dispatch($httpMethod, $uri); }
/** * Parses the user request against the provided HTTP method verb and URI. * * Returns array (from FastRoute\Dispatcher) with one of the following formats: * * [FastRoute\Dispatcher::NOT_FOUND] * [FastRoute\Dispatcher::METHOD_NOT_ALLOWED, ['GET', 'OTHER_ALLOWED_METHODS']] * [FastRoute\Dispatcher::FOUND, $handler, ['varName' => 'value', ...]] * * @param string $method * @param string $uri * @return array */ public function parseRequest($method, $uri) { $this->buildRules(); $data = $this->routeCollector->getData(); $dispatcher = new Dispatcher($data); $routeInfo = $dispatcher->dispatch($method, $uri); if ($routeInfo[0] == Dispatcher::FOUND) { $routeInfo[2] = array_merge($this->rules[$routeInfo[1]]->getDefault(), $routeInfo[2]); } return $routeInfo; }
public function dispatch($method, $uri) { $routes = $this->container->get('config')['http']['routes']; $uri = rtrim($uri, '/'); if ($uri === '') { $uri .= '/'; } $matchedRoute = parent::dispatch($method, $uri); $hasMatchedRoute = false; $anonymous = false; if ($matchedRoute[0] === Dispatcher::NOT_FOUND) { return $this->handleRouteNotFound(); } if ($matchedRoute) { foreach ($routes as $key => $route) { if ($matchedRoute[0] === Dispatcher::METHOD_NOT_ALLOWED && $route['path'] === $this->request->getPathInfo()) { if (isset($route['strategy'])) { switch ($route['strategy']) { case Route::STRATEGY_RESTFUL: $this->setStrategy(new RestfulStrategy()); break; case Route::STRATEGY_REQUEST_RESPONSE: default: $this->setStrategy(new RequestResponseStrategy()); } } else { $this->setStrategy(new RequestResponseStrategy()); } } elseif ($matchedRoute[0] === Dispatcher::FOUND && $route['path'] === $this->request->getPathInfo() && $route['method'] === $this->request->getMethod() && $route['target'] === $matchedRoute[1]) { if (isset($route['anonymous'])) { $anonymous = $route['anonymous']; } if (isset($route['strategy'])) { switch ($route['strategy']) { case Route::STRATEGY_RESTFUL: $this->setStrategy(new RestfulStrategy()); break; case Route::STRATEGY_REQUEST_RESPONSE: default: $this->setStrategy(new RequestResponseStrategy()); } } else { $this->setStrategy(new RequestResponseStrategy()); } break; } } } if ($matchedRoute[0] === Dispatcher::METHOD_NOT_ALLOWED) { return $this->handleMethodNotAllowed(); } $handler = isset($this->routes[$matchedRoute[1]]['callback']) ? $this->routes[$matchedRoute[1]]['callback'] : $matchedRoute[1]; $vars = (array) $matchedRoute[2]; if (!$anonymous) { $this->auth->authenticate(Auth::METHOD_TOKEN); if (!$this->auth->hasAuthenticatedUser()) { return $this->handleUnauthenticated(); } elseif (!$this->auth->isAuthenticatedUserAuthorized($handler)) { return $this->handleUnauthorized(); } } return $this->handleResponse($handler, $this->getStrategy(), $vars); }
/** * Dispatch router for HTTP request * * @param ServerRequestInterface $request The current HTTP request object * * @return array * * @link https://github.com/nikic/FastRoute/blob/master/src/Dispatcher.php */ public function dispatch(ServerRequestInterface $request) { $this->finalize(); $dispatcher = new GroupCountBasedDispatcher($this->getData()); $uri = '/' . ltrim($request->getUri()->getPath(), '/'); return $dispatcher->dispatch($request->getMethod(), $uri); }