/**
* {@inheritdoc}
*/
public function getData()
{
$headers = [];
foreach ($this->request->getHeaders() as $name => $values) {
$headers[$name] = implode(', ', $values);
}
$data = ['SERVER' => $this->request->getServerParams(), 'QUERY' => $this->request->getQueryParams(), 'COOKIES' => $this->request->getCookieParams(), 'HEADERS' => $headers, 'ATTRIBUTES' => $this->request->getAttributes()];
return $data;
}
/**
* 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;
}
public function getHeaders()
{
if (!isset($this->headers)) {
$this->headers = array();
foreach ($this->request->getHeaders() as $header => $values) {
$this->headers[strtolower($header)] = end($values);
}
}
return $this->headers;
}
/**
* {@inheritdoc}
*/
public function createRequest(ServerRequestInterface $psrRequest)
{
$parsedBody = $psrRequest->getParsedBody();
$parsedBody = is_array($parsedBody) ? $parsedBody : array();
$request = new Request($psrRequest->getQueryParams(), $parsedBody, $psrRequest->getAttributes(), $psrRequest->getCookieParams(), $this->getFiles($psrRequest->getUploadedFiles()), $psrRequest->getServerParams(), $psrRequest->getBody()->__toString());
$request->headers->replace($psrRequest->getHeaders());
return $request;
}
/**
* Converts a PSR-7 request into an OAuth2 request.
*
* @param ServerRequestInterface $psrRequest
* @return Request
*/
public static function convertRequestFromPsr7(ServerRequestInterface $psrRequest)
{
$headers = [];
foreach ($psrRequest->getHeaders() as $header => $value) {
$headers[$header] = implode(';', $value);
}
return new Request($psrRequest->getQueryParams(), is_array($psrRequest->getParsedBody()) ? $psrRequest->getParsedBody() : [], $psrRequest->getAttributes(), $psrRequest->getCookieParams(), self::getFiles($psrRequest->getUploadedFiles()), $psrRequest->getServerParams(), $psrRequest->getBody()->__toString(), $headers);
}
/**
* Headers
* @return \PHPixie\HTTP\Data\Headers
*/
public function headers()
{
if ($this->headers === null) {
$data = $this->serverRequest->getHeaders();
$this->headers = $this->builder->headers($data);
}
return $this->headers;
}
public static function createRequest(PsrServerRequestInterface $psrRequest)
{
$request = new Request(new Uri($psrRequest->getUri()), $psrRequest->getMethod(), $psrRequest->getHeaders(), $psrRequest->getBody());
$attributes = $psrRequest->getAttributes();
foreach ($attributes as $name => $value) {
$request->setAttribute($name, $value);
}
return $request;
}
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null)
{
$tokenHeader = $request->getHeader('X-Auth-Token');
if (count($tokenHeader) > 0) {
$tokenHeaderValue = $tokenHeader[0];
} else {
$tokenHeaderValue = null;
}
$data = array('requestMethod' => $request->getMethod(), 'requestUri' => $request->getRequestTarget(), 'queryParams' => $request->getQueryParams(), 'formParams' => $request->getParsedBody(), 'rawBody' => (string) $request->getBody(), 'headers' => $request->getHeaders(), 'X-Auth-Token' => $tokenHeaderValue);
return new JsonResponse($data);
}
/**
* @param \Psr\Http\Message\ServerRequestInterface $request
* @return string
*/
protected function prettifyRequest(ServerRequestInterface $request)
{
$contents = "{$request->getMethod()} : {$request->getUri()->__toString()}\n";
$contents .= "HEADERS\n";
foreach ($request->getHeaders() as $name => $value) {
$contents .= " {$name} : {$request->getHeaderLine($name)}\n";
}
if ($body = $request->getBody()) {
$contents .= "BODY\n";
$contents .= "\"{$body->__toString()}\"\n";
}
return $contents;
}
/**
* Construct action request.
*
* @param \Psr\Http\Message\ServerRequestInterface $request Request to wrap.
*/
public function __construct(\Psr\Http\Message\ServerRequestInterface $request)
{
parent::__construct($request->getBody());
foreach ($request->getHeaders() as $name => $value) {
$this->setHeader($name, $value);
}
$this->protocolVersion = $request->getProtocolVersion();
$this->method = $request->getMethod();
$this->requestTarget = $request->getRequestTarget();
$this->uri = $request->getUri();
$this->attributes = $request->getAttributes();
$this->cookies = $request->getCookieParams();
$this->data = $request->getParsedBody();
$this->query = $request->getQueryParams();
$this->server = $request->getServerParams();
$this->files = $request->getUploadedFiles();
if (isset($this->server['SCRIPT_NAME'])) {
$this->attributes['basePath'] = dirname($this->server['SCRIPT_NAME']);
$this->attributes['scriptName'] = basename($this->server['SCRIPT_NAME']);
} else {
$this->attributes['basePath'] = '/';
$this->attributes['scriptName'] = 'index.php';
}
if (!isset($this->attributes['path'])) {
$this->attributes['path'] = self::findPath($this);
}
if (!isset($this->attributes['rewrite'])) {
$this->attributes['rewrite'] = false;
}
if (!isset($this->attributes['accepts'])) {
$this->attributes['accepts'] = [];
if (isset($this->server['HTTP_ACCEPT'])) {
$contentTypes = explode(',', $this->server['HTTP_ACCEPT']);
foreach ($contentTypes as $contentType) {
$contentType = explode(';', $contentType);
$this->attributes['accepts'][] = trim(strtolower($contentType[0]));
}
}
}
if (!isset($this->attributes['encodings'])) {
$this->attributes['encodings'] = [];
if (isset($this->server['HTTP_ACCEPT_ENCODING'])) {
$acceptEncodings = explode(',', $this->server['HTTP_ACCEPT_ENCODING']);
foreach ($acceptEncodings as $encoding) {
$this->attributes['encodings'][] = trim(strtolower($encoding));
}
}
}
}
/**
* @param ServerRequestInterface $request
*/
public function send(ServerRequestInterface $request)
{
$this->currentUri = $request->getUri();
$this->setBase($this->currentUri);
if (empty($this->currentUri->getHost())) {
$this->currentUri = new Uri($this->getBase() . $this->currentUri);
}
$curl = curl_init();
$options = [CURLOPT_URL => (string) $this->currentUri, CURLOPT_FOLLOWLOCATION => true, CURLOPT_RETURNTRANSFER => true, CURLOPT_CUSTOMREQUEST => $request->getMethod(), CURLOPT_USERAGENT => Loader::USER_AGENT, CURLOPT_HEADER => true, CURLOPT_HTTPHEADER => $this->getConvertedHeaders($request->getHeaders())];
if ($request->getBody()->getSize()) {
$options[CURLOPT_POSTFIELDS] = (string) $request->getBody();
}
curl_setopt_array($curl, $options);
$response = curl_exec($curl);
$this->currentUri = new Uri(curl_getinfo($curl, CURLINFO_EFFECTIVE_URL));
return \GuzzleHttp\Psr7\parse_response($response);
}
/**
* {@inheritdoc}
*/
public function createRequest(ServerRequestInterface $psrRequest)
{
$server = array();
$uri = $psrRequest->getUri();
if ($uri instanceof UriInterface) {
$server['SERVER_NAME'] = $uri->getHost();
$server['SERVER_PORT'] = $uri->getPort();
$server['REQUEST_URI'] = $uri->getPath();
$server['QUERY_STRING'] = $uri->getQuery();
}
$server['REQUEST_METHOD'] = $psrRequest->getMethod();
$server = array_replace($server, $psrRequest->getServerParams());
$parsedBody = $psrRequest->getParsedBody();
$parsedBody = is_array($parsedBody) ? $parsedBody : array();
$request = new Request($psrRequest->getQueryParams(), $parsedBody, $psrRequest->getAttributes(), $psrRequest->getCookieParams(), $this->getFiles($psrRequest->getUploadedFiles()), $server, $psrRequest->getBody()->__toString());
$request->headers->replace($psrRequest->getHeaders());
return $request;
}
public function responseRaidsAdd(Request $request, Response $response)
{
$aRequest = $request->getParsedBody();
$aHeader = $request->getHeaders();
// @todo: validation of input params
$sUserName = $aHeader['HTTP_X_AUTH_USER'];
$sToken = $aHeader['HTTP_X_AUTH_TOKEN'];
if (!$this->oUser->checkUserToken($sToken)) {
return $response->withStatus(401);
}
/**
* @var Raid
*/
$oRaid = new Raid();
$bSuccess = $oRaid->generateUuid()->setTitle($aRequest['title'])->setStart($aRequest['raidDate'], $aRequest['startTime'])->setEnd($aRequest['raidDate'], $aRequest['endTime'])->setMaxAttendees($aRequest['maxAttendees'])->save();
$aResponse = [self::RESPONSE_SUCCESS => $bSuccess, 'uuid' => $oRaid->getUuid()];
$response->getBody()->write(json_encode($aResponse));
return $response;
}
/**
* Render an exception into an HTTP or JSON response.
*
* @param Request $request
* @param Response $response
* @param \Exception $exception
* @return mixed
*/
public function render(Request $request, Response $response, \Exception $exception)
{
$statusCode = method_exists($exception, 'getStatusCode') ? $exception->getStatusCode() : 400;
$response->withStatus($statusCode);
$debug = $this->settings['displayErrorDetails'] == 'true' ? true : false;
$title = $debug ? 'The application could not run because of the following error:' : 'A website error has occurred. Sorry for the temporary inconvenience.';
$header = $request->getHeaders();
$message = $exception->getMessage();
$json = isset($header['HTTP_CONTENT_TYPE'][0]) && $header['HTTP_CONTENT_TYPE'][0] == 'application/json';
// Check content-type is application/json
if ($json) {
// Define content-type to json
$response->withHeader('Content-Type', 'application/json');
$error = ['status' => 'error', 'error' => $title, 'statusCode' => $statusCode];
// Check debug
if ($debug) {
$error['details'] = ['message' => $message, 'file' => $exception->getFile(), 'line' => $exception->getLine(), 'code' => $exception->getCode()];
}
$view = $this->json->render($response, $error, $statusCode);
} else {
// Define content-type to html
$response->withHeader('Content-Type', 'text/html');
$message = sprintf('<span>%s</span>', htmlentities($message));
$error = ['type' => get_class($exception), 'message' => $message];
// Check debug
if ($debug) {
$trace = $exception->getTraceAsString();
$trace = sprintf('<pre>%s</pre>', htmlentities($trace));
$error['file'] = $exception->getFile();
$error['line'] = $exception->getLine();
$error['code'] = $exception->getCode();
$error['trace'] = $trace;
}
$error['debug'] = $debug;
$error['title'] = $title;
$view = $this->view->render($response, 'error/error.twig', $error);
}
// Send error to log
$this->log->addError($exception->getMessage());
return $view;
}
/**
* {@inheritdoc}
*/
public function getHeaders()
{
return $this->wrapped->getHeaders();
}
public function getReleasedAttributes(Request $request) : array
{
$cas_auth_prefix = 'AUTH_ATTR_';
$allcasattributes = \array_filter($request->getHeaders(), function ($key) use($cas_auth_prefix) {
return \substr(\strtoupper($key), 0, \strlen($cas_auth_prefix)) === $cas_auth_prefix;
}, ARRAY_FILTER_USE_KEY);
$matchingreleasedattributes = \array_filter(\array_flip(self::getReleasedAttributeNames()), function ($key) use($cas_auth_prefix, $allcasattributes) {
return \in_array(\strtoupper($key), \array_map(function ($v) use($cas_auth_prefix) {
return \strtoupper(\substr($v, \strlen($cas_auth_prefix)));
}, \array_keys($allcasattributes)));
}, ARRAY_FILTER_USE_KEY);
$remainingattributes = [];
\array_walk($matchingreleasedattributes, function (&$val, $key, $allcasattributes) use($cas_auth_prefix) {
// Find the matching key in $allcasattributes
\reset($allcasattributes);
while (list($akey, $aval) = \each($allcasattributes)) {
if (\strtoupper(\substr($akey, \strlen($cas_auth_prefix))) == \strtoupper($key)) {
$val = $aval;
\end($allcasattributes);
}
}
});
\reset($allcasattributes);
while (list($akey, $aval) = \each($allcasattributes)) {
// $akey not in $matchingreleasedattributes
if (!\in_array(\strtoupper(\substr($akey, \strlen($cas_auth_prefix))), \array_map('strtoupper', \array_keys($matchingreleasedattributes)))) {
$remainingattributes[\strtolower(\substr($akey, \strlen($cas_auth_prefix)))] = $aval;
}
}
return \array_merge($matchingreleasedattributes, $request->hasHeader('AUTH_PRINCIPAL') ? ['username' => $request->getHeaderLine('AUTH_PRINCIPAL')] : [], $remainingattributes);
}
/**
* {@inheritDoc}
*/
public function getHeaders()
{
return $this->psrRequest->getHeaders();
}
/**
* Returns the available HTTP verbs and the resource URLs
*
* @param ContainerInterface $container Dependency injection container
* @param ServerRequestInterface $request Request object
* @param ResponseInterface $response Response object
* @param array $args Associative list of route parameters
* @return ResponseInterface $response Modified response object with generated output
*/
public static function optionsAction(ContainerInterface $container, ServerRequestInterface $request, ResponseInterface $response, array $args)
{
$status = 500;
$header = $request->getHeaders();
$client = self::createClient($container, $request, $response, $args);
$result = $client->options((string) $request->getBody(), $header, $status);
return self::withResponse($response, $result, $status, $header);
}
/**
* @param ServerRequestInterface $r
* @param $title
*/
private function logRequest($r, $title, $forceShow = false)
{
/** @var ServerRequestInterface $current */
$current = $this->currentRequestMutator->get();
$showAll = !$this->currentRequestMutator->get() || $forceShow;
$icon = $showAll ? '' : '<sup>*</sup>';
if ($showAll || $r->getHeaders() != $current->getHeaders()) {
$out['Headers' . $icon] = map($r->getHeaders(), function ($v) {
return implode('<br>', $v);
});
}
if ($showAll || $r->getAttributes() != $current->getAttributes()) {
$out['Attributes' . $icon] = $r->getAttributes();
}
if ($showAll || $r->getRequestTarget() != $current->getRequestTarget()) {
$out['Request target' . $icon] = $r->getRequestTarget();
}
if ($showAll || $r->getBody()->getSize() != self::$currentRequestSize) {
$out['Size' . $icon] = $r->getBody()->getSize();
}
$this->routingLogger->write("<div class='indent'>")->simpleTable($out, $title)->write('</div>');
}
/**
* Returns a new instance of \OAuth2\Request based on the given \Slim\Http\Request
*
* @param ServerRequestInterface $request The psr-7 request.
*
* @return OAuth2\Request
*/
public static final function toOAuth2(ServerRequestInterface $request)
{
return new OAuth2\Request((array) $request->getQueryParams(), (array) $request->getParsedBody(), $request->getAttributes(), $request->getCookieParams(), self::convertUploadedFiles($request->getUploadedFiles()), $request->getServerParams(), (string) $request->getBody(), self::cleanupHeaders($request->getHeaders()));
}
private function isAuthenticated(ServerRequestInterface $serverRequestInterface)
{
if ($this->secured !== null && $this->securityProvider !== null) {
$token = $this->securityProvider->getTokenFromHeaders($serverRequestInterface->getHeaders());
if (!$this->securityProvider->validateToken($token)) {
return false;
}
if ($this->secured->value !== null) {
$rolesAllowed = explode(",", $this->secured->value);
$found = false;
$roles = $this->securityProvider->getRoles($token);
foreach ($rolesAllowed as $roleAllowed) {
foreach ($roles as $role) {
if ($roleAllowed === $role) {
$found = true;
}
}
}
if (!$found) {
return false;
}
}
}
return true;
}
