示例#1
0
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
 {
     if ($request->getUri()->getScheme() != 'https' && $request->getUri()->getHost() != 'localhost') {
         throw new SecurityException('HTTPS not used');
     }
     return $next($request, $response);
 }
 /**
  * Invocation
  *
  * Register routes container and request attributes
  *
  * @param ServerRequestInterface $request Request
  * @param ResponseInterface $response Response
  * @param TornadoHttp $next Next Middleware - TornadoHttp container
  * @return ResponseInterface
  * @throws HttpMethodNotAllowedException
  * @throws HttpNotFoundException
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, TornadoHttp $next)
 {
     /** @var \FastRoute\Dispatcher\GroupCountBased $dispatcher */
     $dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $routeCollector) {
         foreach ($this->routes as $key => $route) {
             $routeCollector->addRoute($route['methods'], $route['path'], $key);
         }
     });
     $method = $request->getMethod();
     $uri = rawurldecode(parse_url($request->getUri(), \PHP_URL_PATH));
     $route = $dispatcher->dispatch($method, $uri);
     $handler = null;
     $vars = null;
     switch ($route[0]) {
         case Dispatcher::NOT_FOUND:
             throw new HttpNotFoundException('Inexistent route for the url ' . $request->getUri());
         case Dispatcher::METHOD_NOT_ALLOWED:
             throw new HttpMethodNotAllowedException('Method not allowed');
         case Dispatcher::FOUND:
             $handler = $route[1];
             $vars = $route[2];
             break;
     }
     $request = $request->withAttribute(Router::REGISTER_KEY, $handler);
     foreach ($vars as $name => $value) {
         $request = $request->withAttribute($name, $value);
     }
     return $next($request, $response);
 }
示例#3
0
 /**
  * @param Request $request
  * @param Response $response
  * @return Response
  */
 function dispatch(Request $request, Response $response)
 {
     $path = preg_replace('{/{2,}}', '/', $request->getUri()->getPath());
     $path = $request->getUri()->getQuery();
     // TODO:TEST:DEBUG
     $path = trim($path, '/');
     $path = urldecode($path);
     // TODO: debug temporaire
     foreach ($this->collection as $route) {
         // Pattern
         if (!preg_match('{^' . $route->getPattern() . '$}i', $path, $attributes)) {
             continue;
         }
         // Options
         foreach ($route->getOptions() as $key => $value) {
             switch ($key) {
                 case 'method':
                     if (!in_array($request->getMethod(), explode('|', $value))) {
                         continue 3;
                     }
             }
         }
         // Attributes
         foreach (array_filter($attributes, 'is_string', ARRAY_FILTER_USE_KEY) as $ak => $av) {
             $request = $request->withAttribute($ak, $av);
         }
         //return call_user_func($this->callable, $request, ...array_filter($attributes, 'is_int', ARRAY_FILTER_USE_KEY)); // TODO: delete key 0
         return $this->runner($request, $response, ...$route->getCallables());
     }
     // Error 404
     return $response;
 }
示例#4
0
 protected function getRoute($indexKey, ServerRequestInterface $request)
 {
     $validRoutes = [];
     foreach ($this->routesIndex[$indexKey] as $route) {
         $scheme = $route->getScheme();
         if (!empty($scheme) && $request->getUri()->getScheme() !== $scheme) {
             continue;
         }
         $host = $route->getHost();
         if (!empty($host) && $request->getUri()->getHost() !== $host) {
             continue;
         }
         foreach ($route->getGroup()->getConditions() as $condition) {
             if (!$condition->verify($request)) {
                 continue 2;
             }
         }
         foreach ($route->getConditions() as $condition) {
             if (!$condition->verify($request)) {
                 continue 2;
             }
         }
         $validRoutes[] = $route;
     }
     if (empty($validRoutes)) {
         throw new RouteConditionFailedException();
     } else {
         if (count($validRoutes) > 1) {
             throw new ManyRoutesFoundException();
         }
     }
     return reset($validRoutes);
 }
示例#5
0
 /**
  * {@inheritdoc}
  */
 public function get(array $fileInfo, array $data = []) : string
 {
     $engine = $this->getLoader();
     if ($this->request !== null) {
         // Set uri extensions
         $engine->loadExtension(new URI($this->request->getUri()->getPath()));
     }
     // Set asset extensions
     $engine->loadExtension(new Asset($this->config['engine']['plates']['asset'] ?? null));
     // Get all extensions
     if (!empty($this->availableExtensions)) {
         foreach ($this->availableExtensions as $extension) {
             $engine->loadExtension(is_object($extension) ? $extension : new $extension());
         }
     }
     if (!$engine->exists($fileInfo['name'])) {
         throw new Exception('Template "' . $fileInfo['name'] . '" dont exist!');
     }
     // Creat a new template
     $template = new Template($engine, $fileInfo['name']);
     // We'll evaluate the contents of the view inside a try/catch block so we can
     // flush out any stray output that might get out before an error occurs or
     // an exception is thrown. This prevents any partial views from leaking.
     ob_start();
     try {
         return $template->render($data);
     } catch (Throwable $exception) {
         $this->handleViewException($exception);
     }
 }
 public function addLanguage(ServerRequestInterface $request, $language)
 {
     $path = $request->getUri()->getPath();
     if ($language !== $this->environment->getDefaultLanguage()) {
         $path = '/' . $language . ($path === '/' ? '' : $path);
     }
     return $request->withUri($request->getUri()->withPath($path));
 }
 /**
  * Invocation
  *
  * @param ServerRequestInterface $request Request
  * @param ResponseInterface $response Response
  * @param callable $next Next Middleware
  * @return ResponseInterface
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
 {
     if ($this->basePath !== '/') {
         $uri = $request->getUri();
         $path = '/' . preg_replace('/^' . str_replace('/', '\\/', $this->basePath) . '/', '', $request->getUri()->getPath());
         $request = $request->withUri($uri->withPath($path));
     }
     return $next($request, $response);
 }
 /**
  * Convert a PSR-7 ServerRequest to a Zend\Http server-side request.
  *
  * @param ServerRequestInterface $psr7Request
  * @param bool $shallow Whether or not to convert without body/file
  *     parameters; defaults to false, meaning a fully populated request
  *     is returned.
  * @return Zend\Request
  */
 public static function toZend(ServerRequestInterface $psr7Request, $shallow = false)
 {
     if ($shallow) {
         return new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), [], [], $psr7Request->getServerParams());
     }
     $zendRequest = new Zend\Request($psr7Request->getMethod(), $psr7Request->getUri(), $psr7Request->getHeaders(), $psr7Request->getCookieParams(), $psr7Request->getQueryParams(), $psr7Request->getParsedBody() ?: [], self::convertUploadedFiles($psr7Request->getUploadedFiles()), $psr7Request->getServerParams());
     $zendRequest->setContent($psr7Request->getBody());
     return $zendRequest;
 }
示例#9
0
 /**
  * Invoke middleware
  * 
  * @param ServerRequestInterface $request  request
  * @param ResponseInterface      $response response
  * @param callable               $next     callable
  * 
  * @return object ResponseInterface
  */
 public function __invoke(Request $request, Response $response, callable $next = null)
 {
     $err = null;
     if ($request->isSecure() == false) {
         $path = $request->getUri()->getPath();
         $host = $request->getUri()->getHost();
         return $response->redirect('https://' . $host . $path);
     }
     return $next($request, $response, $err);
 }
示例#10
0
 /**
  * Schedule new cookie. Cookie will be send while dispatching request.
  *
  * Domain, path, and secure values can be left in null state, in this case cookie manager will
  * populate them automatically.
  *
  * @link http://php.net/manual/en/function.setcookie.php
  * @param string $name     The name of the cookie.
  * @param string $value    The value of the cookie. This value is stored on the clients
  *                         computer; do not store sensitive information.
  * @param int    $lifetime Cookie lifetime. This value specified in seconds and declares period
  *                         of time in which cookie will expire relatively to current time()
  *                         value.
  * @param string $path     The path on the server in which the cookie will be available on.
  *                         If set to '/', the cookie will be available within the entire
  *                         domain.
  *                         If set to '/foo/', the cookie will only be available within the
  *                         /foo/
  *                         directory and all sub-directories such as /foo/bar/ of domain. The
  *                         default value is the current directory that the cookie is being set
  *                         in.
  * @param string $domain   The domain that the cookie is available. To make the cookie
  *                         available
  *                         on all subdomains of example.com then you'd set it to
  *                         '.example.com'.
  *                         The . is not required but makes it compatible with more browsers.
  *                         Setting it to www.example.com will make the cookie only available in
  *                         the www subdomain. Refer to tail matching in the spec for details.
  * @param bool   $secure   Indicates that the cookie should only be transmitted over a secure
  *                         HTTPS connection from the client. When set to true, the cookie will
  *                         only be set if a secure connection exists. On the server-side, it's
  *                         on the programmer to send this kind of cookie only on secure
  *                         connection (e.g. with respect to $_SERVER["HTTPS"]).
  * @param bool   $httpOnly When true the cookie will be made accessible only through the HTTP
  *                         protocol. This means that the cookie won't be accessible by
  *                         scripting
  *                         languages, such as JavaScript. This setting can effectively help to
  *                         reduce identity theft through XSS attacks (although it is not
  *                         supported by all browsers).
  * @return $this
  */
 public function set($name, $value = null, $lifetime = null, $path = null, $domain = null, $secure = null, $httpOnly = true)
 {
     if (is_null($domain)) {
         $domain = $this->httpConfig->cookiesDomain($this->request->getUri());
     }
     if (is_null($secure)) {
         $secure = $this->request->getMethod() == 'https';
     }
     return $this->schedule(new Cookie($name, $value, $lifetime, $path, $domain, $secure, $httpOnly));
 }
示例#11
0
 /**
  * @inheritDoc
  */
 public function getRoutes() : array
 {
     $routes = [];
     foreach ($this->routes->getRoutes() as $route) {
         if ((!$route->getHost() || $route->getHost() === $this->request->getUri()->getHost()) && (!$route->getScheme() || $route->getScheme() === $this->request->getUri()->getScheme())) {
             $routes[] = $route;
         }
     }
     return $routes;
 }
示例#12
0
 /**
  * Guesses the base URI of the application.
  *
  * @param  Psr\Http\Message\ServerRequestInterface $request
  * @return Psr\Http\Message\ServerRequestInterface
  */
 public static function guess(\Psr\Http\Message\ServerRequestInterface $request)
 {
     $server = $request->getServerParams();
     $basename = basename($server['SCRIPT_FILENAME']);
     $position = strpos($server['SCRIPT_NAME'], $basename) - 1;
     $rootUri = substr($server['SCRIPT_NAME'], 0, $position);
     $oldPath = $request->getUri()->getPath();
     $newPath = str_replace($rootUri, '', $oldPath);
     $uri = $request->getUri()->withPath($newPath);
     return $request->withUri($uri);
 }
示例#13
0
 /**
  * @return bool
  */
 public function resolves()
 {
     if (preg_match($this->compileRegex(), $this->request->getUri()->getPath(), $parameters) > 0) {
         $params = [];
         foreach ($parameters as $key => $value) {
             if (!is_int($key)) {
                 $params[$key] = $value;
             }
         }
         return $params;
     }
     return false;
 }
示例#14
0
 /**
  * @throws \WoohooLabs\Harmony\Exception\MethodNotAllowed
  * @throws \WoohooLabs\Harmony\Exception\RouteNotFound
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) : ResponseInterface
 {
     $route = $this->fastRoute->dispatch($request->getMethod(), $request->getUri()->getPath());
     if ($route[0] === Dispatcher::NOT_FOUND) {
         throw new RouteNotFound($request->getUri()->getPath());
     }
     if ($route[0] === Dispatcher::METHOD_NOT_ALLOWED) {
         throw new MethodNotAllowed($request->getMethod());
     }
     foreach ($route[2] as $name => $value) {
         $request = $request->withAttribute($name, $value);
     }
     $request = $request->withAttribute($this->actionAttributeName, $route[1]);
     return $next($request, $response);
 }
示例#15
0
 public function match(ServerRequestInterface $request)
 {
     if (!$this->startsWith($request->getUri()->getPath(), $this->routePath)) {
         return false;
     }
     $templateFile = trim(substr($request->getUri()->getPath(), strlen($this->routePath)), '/');
     if (!$templateFile) {
         $templateFile = 'index';
     }
     $template = $this->templateDir . $templateFile . $this->templateExtension;
     if (!is_file($template)) {
         throw new NoMatchingRouteException('No matching route for request "' . $request->getUri()->getPath() . '"');
     }
     return new RouteData($this->name, array_merge(['template' => $templateFile, '_view' => ['text/html' => $template]], $this->values), $this->handler);
 }
示例#16
0
 /**
  * Handles any backend request
  *
  * @param ServerRequestInterface $request
  * @return NULL|ResponseInterface
  */
 public function handleRequest(ServerRequestInterface $request)
 {
     // enable dispatching via Request/Response logic only for typo3/index.php
     // This fallback will be removed in TYPO3 CMS 8, as only index.php will be allowed
     $path = substr($request->getUri()->getPath(), strlen(GeneralUtility::getIndpEnv('TYPO3_SITE_PATH')));
     $routingEnabled = $path === TYPO3_mainDir . 'index.php' || $path === TYPO3_mainDir;
     $proceedIfNoUserIsLoggedIn = false;
     if ($routingEnabled) {
         $pathToRoute = (string) $request->getQueryParams()['route'];
         // Allow the login page to be displayed if routing is not used and on index.php
         if (empty($pathToRoute)) {
             $pathToRoute = '/login';
         }
         $request = $request->withAttribute('routePath', $pathToRoute);
         // Evaluate the constant for skipping the BE user check for the bootstrap
         // should be handled differently in the future by checking the Bootstrap directly
         if ($pathToRoute === '/login') {
             $proceedIfNoUserIsLoggedIn = true;
         }
     }
     $this->boot($proceedIfNoUserIsLoggedIn);
     // Check if the router has the available route and dispatch.
     if ($routingEnabled) {
         return $this->dispatch($request);
     }
     // No route found, so the system proceeds in called entrypoint as fallback.
     return null;
 }
 /**
  * Execute the middleware.
  *
  * @param ServerRequestInterface $request
  * @param ResponseInterface      $response
  * @param callable               $next
  *
  * @return ResponseInterface
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
 {
     $language = null;
     //Use path
     if ($this->usePath) {
         $uri = $request->getUri();
         $path = ltrim($this->getPath($uri->getPath()), '/');
         $dirs = explode('/', $path, 2);
         $first = array_shift($dirs);
         if (!empty($first) && in_array($first, $this->languages, true)) {
             $language = $first;
             //remove the language in the path
             $request = $request->withUri($uri->withPath('/' . array_shift($dirs)));
         }
     }
     //Use http headers
     if ($language === null) {
         $language = $this->negotiateHeader($request->getHeaderLine('Accept-Language'), new Negotiator(), $this->languages);
         if (empty($language)) {
             $language = isset($this->languages[0]) ? $this->languages[0] : null;
         }
         //Redirect to a path with the language
         if ($this->redirectStatus && $this->usePath) {
             $path = Utils\Helpers::joinPath($this->basePath, $language, $this->getPath($uri->getPath()));
             return self::getRedirectResponse($this->redirectStatus, $uri->withPath($path), $response);
         }
     }
     $request = Middleware::setAttribute($request, self::KEY, $language);
     if ($language !== null) {
         $response = $response->withHeader('Content-Language', $language);
     }
     return $next($request, $response);
 }
示例#18
0
 /**
  *
  */
 public function nav($root)
 {
     if (!isset($this->navigation[$root]) || !is_array($this->navigation[$root])) {
         return [];
     }
     $navigation = $this->navigation[$root];
     $aclFilter = function ($page) {
         if (!$this->acl) {
             return true;
         }
         $path = parse_url($page['href'], PHP_URL_PATH);
         if (isset($page['external'])) {
             return true;
         }
         $resource = 'route' . $path;
         return $this->acl->isAllowed($this->currentRole, $resource, 'get');
     };
     $prepare = function ($page) use(&$prepare, &$aclFilter) {
         if (isset($page['route'])) {
             $routeData = isset($page['route_data']) ? $page['route_data'] : [];
             $query = isset($page['query']) ? $page['query'] : [];
             $page['href'] = $this->router->pathFor($page['route'], $routeData, $query);
         }
         $path = parse_url($page['href'], PHP_URL_PATH);
         $page['active'] = $path !== '/' && 0 === strpos($this->request->getUri()->getPath(), $path);
         if (isset($page['pages']) && is_array($page['pages'])) {
             $page['pages'] = array_filter(array_map($prepare, $page['pages']), $aclFilter);
         }
         return $page;
     };
     return array_filter(array_map($prepare, $navigation), $aclFilter);
 }
 /**
  * {@inheritdoc}
  */
 public function canHandleRequest(ServerRequestInterface $request)
 {
     if (static::$uriPattern === null || (string) static::$uriPattern === '') {
         return false;
     }
     return (bool) preg_match(static::$uriPattern, $request->getUri()->getPath());
 }
示例#20
0
 /**
  * @param ServerRequestInterface $request
  * @param ResponseInterface $response
  * @param callable $next
  * @return ResponseInterface
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
 {
     $routeInfo = $this->dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath());
     switch ($routeInfo[0]) {
         case Dispatcher::NOT_FOUND:
             $response = $response->withStatus(404);
             break;
         case Dispatcher::METHOD_NOT_ALLOWED:
             $response = $response->withStatus(405);
             break;
         case Dispatcher::FOUND:
             $callable = $routeInfo[1];
             $args = $routeInfo[2];
             if (isset($this->container)) {
                 $response = $this->container->call($callable, ['request' => $request, 'response' => $response, 'arguments' => $args]);
             } else {
                 if (is_callable($callable)) {
                     call_user_func($callable, $request, $response, $args);
                 } else {
                     $callable = new $callable();
                     call_user_func($callable, $request, $response, $args);
                 }
             }
             break;
         default:
             return $response->withStatus(500);
     }
     $response = $next($request, $response);
     return $response;
 }
示例#21
0
 /**
  * Slim middleware entry point
  *
  * @param  \Psr\Http\Message\ServerRequestInterface $request  PSR7 request
  * @param  \Psr\Http\Message\ResponseInterface      $response PSR7 response
  * @param  callable                                 $next     Next middleware
  * @return \Psr\Http\Message\ResponseInterface
  */
 public function __invoke($request, $response, $next)
 {
     $this->request = $request;
     $this->response = $response;
     $this->dispatch($request->getMethod(), $request->getUri());
     return $next($this->request, $this->response);
 }
示例#22
0
 /**
  * Apply the asset middleware.
  *
  * @param \Psr\Http\Message\ServerRequestInterface $request The request.
  * @param \Psr\Http\Message\ResponseInterface $response The response.
  * @param callable $next The callable to invoke the next middleware layer.
  * @return \Psr\Http\Message\ResponseInterface A response.
  */
 public function __invoke($request, $response, $next)
 {
     $path = $request->getUri()->getPath();
     if (strpos($path, $this->urlPrefix) !== 0) {
         // Not an asset request.
         return $next($request, $response);
     }
     $factory = new Factory($this->config);
     $assets = $factory->assetCollection();
     $targetName = substr($path, strlen($this->urlPrefix));
     if (!$assets->contains($targetName)) {
         // Unknown build.
         return $next($request, $response);
     }
     try {
         $build = $assets->get($targetName);
         $compiler = $factory->cachedCompiler($this->outputDir);
         $contents = $compiler->generate($build);
     } catch (Exception $e) {
         // Could not build the asset.
         $response->getBody()->write($e->getMessage());
         return $response->withStatus(400)->withHeader('Content-Type', 'text/plain');
     }
     return $this->respond($response, $contents, $build->ext());
 }
 /**
  * @param ServerRequestInterface $request
  *
  * @return RoutingResponse
  */
 public function route(ServerRequestInterface $request) : RoutingResponse
 {
     if ($request->getUri() == '/') {
         return new RoutingResponse(200, ControllerMock::class, 'stringAction');
     } else {
         if ($request->getUri() == '/notfound') {
             return new RoutingResponse(200, ControllerMock::class, 'throwNotFoundAction');
         } else {
             if ($request->getUri() == '/exception') {
                 return new RoutingResponse(200, ControllerMock::class, 'exceptionAction');
             } else {
                 return $this->getNotFoundRoute();
             }
         }
     }
 }
 /**
  * @param Request $request
  * @param Response $response
  * @param callable $next
  * @return \Psr\Http\Message\MessageInterface|HtmlResponse
  * @throws Exception
  */
 public function __invoke(Request $request, Response $response, callable $next)
 {
     //$form = new LoginForm('Login', []);
     //$form->get('submit')->setValue('Login');
     if ($request->getMethod() == 'POST') {
         $auth = new AuthenticationService();
         $query = $request->getParsedBody();
         $authAdapter = new AuthAdapter($query['login'], $query['password'], $this->authConfig);
         $result = $auth->authenticate($authAdapter);
         if (!$result->isValid()) {
             //$response->getBody()->write("Not valid authentication\n");
             //return $response->withStatus(403)->withHeader("Content-type", 'text/html');
             throw new Exception("Not valid authentication\n", 403);
         } else {
             if ($request->getUri()->getPath() === '/auth') {
                 $render = $this->template->render('app::homepage');
                 $query = $request->getParsedBody();
                 $query['view']['render'] = $render;
                 $query['view']['code'] = 200;
                 $request = $request->withParsedBody($query);
             }
             return $next($request, $response);
         }
     } else {
         $render = $this->template->render('app::login', ['error' => null]);
         $query = $request->getParsedBody();
         $query['view']['render'] = $render;
         $query['view']['code'] = 200;
         $request = $request->withParsedBody($query);
         return $next($request, $response);
     }
 }
示例#25
0
 /**
  * @param Request $request
  * @return Executable
  */
 public function routeRequest(Request $request)
 {
     $path = $request->getUri()->getPath();
     $routeInfo = $this->dispatcher->dispatch($request->getMethod(), $path);
     $dispatcherResult = $routeInfo[0];
     if ($dispatcherResult === \FastRoute\Dispatcher::FOUND) {
         $handler = $routeInfo[1];
         $vars = $routeInfo[2];
         $injectionParams = InjectionParams::fromParams($vars);
         $injectionParams->share(new \Tier\JigBridge\RouteInfo($vars));
         $executable = new Executable($handler, $injectionParams, null);
         $executable->setTierNumber(TierHTTPApp::TIER_GENERATE_BODY);
         return $executable;
     } else {
         if ($dispatcherResult === \FastRoute\Dispatcher::METHOD_NOT_ALLOWED) {
             //TODO - need to embed allowedMethods....theoretically.
             $executable = new Executable([$this, 'serve405ErrorPage']);
             $executable->setTierNumber(TierHTTPApp::TIER_GENERATE_BODY);
             return $executable;
         }
     }
     $executable = new Executable([$this, 'serve404ErrorPage']);
     $executable->setTierNumber(TierHTTPApp::TIER_GENERATE_BODY);
     return $executable;
 }
 /**
  * {@inheritdoc}
  */
 public function route(ServerRequestInterface $request) : RoutingResponse
 {
     $httpMethod = $request->getMethod();
     $uri = $request->getUri()->getPath();
     $routeInfo = $this->dispatcher->dispatch($httpMethod, $uri);
     return $this->processDispatcherResult($routeInfo);
 }
 public function match(ServerRequestInterface $request)
 {
     //Convert URL params into regex patterns, construct a regex for this route, init params
     $patternAsRegex = preg_replace_callback('#:([\\w]+)\\+?#', array($this, 'matchesCallback'), str_replace(')', ')?', (string) $this->path));
     if (substr($this->path, -1) === '/') {
         $patternAsRegex .= '?';
     }
     $regex = '#^' . $patternAsRegex . '$#';
     //Cache URL params' names and values if this route matches the current HTTP request
     if (!preg_match($regex, $request->getUri()->getPath(), $paramValues)) {
         return false;
     }
     $params = [];
     if ($this->paramNames) {
         foreach ($this->paramNames as $name) {
             if (isset($paramValues[$name])) {
                 if (isset($this->paramNamesPath[$name])) {
                     $params[$name] = explode('/', urldecode($paramValues[$name]));
                 } else {
                     $params[$name] = urldecode($paramValues[$name]);
                 }
             }
         }
     }
     return $params;
 }
 /**
  * @param Request $request
  * @return \Psr\Http\Message\ResponseInterface|RedirectResponse
  */
 public function handle(Request $request)
 {
     $redirectUri = (string) $request->getAttribute('originalUri', $request->getUri())->withQuery('');
     $server = new Twitter(['identifier' => $this->settings->get('flarum-auth-twitter.api_key'), 'secret' => $this->settings->get('flarum-auth-twitter.api_secret'), 'callback_uri' => $redirectUri]);
     $session = $request->getAttribute('session');
     $queryParams = $request->getQueryParams();
     $oAuthToken = array_get($queryParams, 'oauth_token');
     $oAuthVerifier = array_get($queryParams, 'oauth_verifier');
     if (!$oAuthToken || !$oAuthVerifier) {
         $temporaryCredentials = $server->getTemporaryCredentials();
         $session->set('temporary_credentials', serialize($temporaryCredentials));
         $session->save();
         // Second part of OAuth 1.0 authentication is to redirect the
         // resource owner to the login screen on the server.
         $server->authorize($temporaryCredentials);
         exit;
     }
     // Retrieve the temporary credentials we saved before
     $temporaryCredentials = unserialize($session->get('temporary_credentials'));
     // We will now retrieve token credentials from the server
     $tokenCredentials = $server->getTokenCredentials($temporaryCredentials, $oAuthToken, $oAuthVerifier);
     $user = $server->getUserDetails($tokenCredentials);
     $identification = ['twitter_id' => $user->uid];
     $suggestions = ['username' => $user->nickname, 'avatarUrl' => str_replace('_normal', '', $user->imageUrl)];
     return $this->authResponse->make($request, $identification, $suggestions);
 }
示例#29
0
 /**
  * Generates a cache key based on a unique request.
  *
  * @todo determine parts required for unique request
  * @param ServerRequestInterface $request
  * @return string
  */
 private function generateKey(ServerRequestInterface $request)
 {
     $params = $request->getQueryParams();
     ksort($params);
     $parts = [$request->getMethod(), $request->getUri()->getPath(), serialize($params)];
     return sha1(implode(':', $parts));
 }
示例#30
0
 public function match(ServerRequestInterface $request)
 {
     if ($request->getUri()->getPath() !== $this->path) {
         return false;
     }
     return new RouteData($this->name, $this->values, $this->handler);
 }