Exemple #1
0
 /**
  * Add headers represented by an array of header lines.
  *
  * @param string[] $headers Response headers as array of header lines.
  *
  * @return $this
  *
  * @throws \UnexpectedValueException For invalid header values.
  * @throws \InvalidArgumentException For invalid status code arguments.
  */
 public function setHeadersFromArray(array $headers)
 {
     $statusLine = trim(array_shift($headers));
     $parts = explode(' ', $statusLine, 3);
     if (count($parts) < 2 || substr(strtolower($parts[0]), 0, 5) !== 'http/') {
         throw new \UnexpectedValueException(sprintf('"%s" is not a valid HTTP status line', $statusLine));
     }
     $reasonPhrase = count($parts) > 2 ? $parts[2] : '';
     $this->response = $this->response->withStatus((int) $parts[1], $reasonPhrase)->withProtocolVersion(substr($parts[0], 5));
     foreach ($headers as $headerLine) {
         $headerLine = trim($headerLine);
         if ('' === $headerLine) {
             continue;
         }
         $parts = explode(':', $headerLine, 2);
         if (count($parts) !== 2) {
             throw new \UnexpectedValueException(sprintf('"%s" is not a valid HTTP header line', $headerLine));
         }
         $name = trim(urldecode($parts[0]));
         $value = trim(urldecode($parts[1]));
         if ($this->response->hasHeader($name)) {
             $this->response = $this->response->withAddedHeader($name, $value);
         } else {
             $this->response = $this->response->withHeader($name, $value);
         }
     }
     return $this;
 }
Exemple #2
0
 /**
  * Options
  *
  * Responding to OPTIONS requests and checks for implemented
  * methods that matches HTTP METHODS.
  *
  * @return array
  * @throws MethodNotAllowed
  */
 public function options()
 {
     if (!$this->response instanceof ResponseInterface) {
         throw new MethodNotAllowed();
     }
     // Get all implemented methods for this resources
     $methods = get_class_methods(get_class($this));
     // Get supported verbs
     $validMethods = $this->container['validHttpVerbs'];
     // Loop though class functions/methods
     foreach ($methods as $key => &$method) {
         $method = strtoupper($method);
         // If class function/method isn't a verb, then unset it
         if (!in_array($method, $validMethods)) {
             unset($methods[$key]);
         }
     }
     // Set accept header
     $this->response = $this->response->withAddedHeader('Allow', implode(', ', $methods));
     // Prepare output
     $output = [];
     $output['Content-Type'] = $this->container['contentTypes'];
     $output['Accept'] = $this->container['acceptTypes'];
     foreach ($methods as $verb) {
         $doc = $this->parseMethodDoc($verb);
         // Check if there is any output to show
         if (!empty($doc)) {
             $output['methods'][$verb] = $doc;
         }
     }
     // return output
     return $output;
 }
 /**
  * Proxy to PsrResponseInterface::withAddedHeader()
  *
  * {@inheritdoc}
  */
 public function withAddedHeader($header, $value)
 {
     if ($this->complete) {
         return $this;
     }
     $new = $this->psrResponse->withAddedHeader($header, $value);
     return new self($new);
 }
 /**
  * Add the set cookies to a response.
  *
  * @param ResponseInterface $response
  *
  * @return ResponseInterface
  */
 public function addToResponse(ResponseInterface $response) : ResponseInterface
 {
     $header = [];
     foreach ($this->cookies as $setCookie) {
         $header[] = $setCookie->toHeaderValue();
     }
     return $response->withAddedHeader('Set-Cookie', $header);
 }
 /**
  * Proxy to PsrResponseInterface::withAddedHeader()
  *
  * {@inheritdoc}
  * @throws RuntimeException if response is already completed
  */
 public function withAddedHeader($header, $value)
 {
     if ($this->complete) {
         throw $this->responseIsAlreadyCompleted(__METHOD__);
     }
     $new = $this->psrResponse->withAddedHeader($header, $value);
     return new self($new);
 }
Exemple #6
0
 /**
  * Create all headers for a regular request
  */
 protected function createRequestHeaders()
 {
     $headers = [];
     // Set Allowed origin header (either * or Origin from request)
     $headers = $this->createOriginHeader($headers);
     // Set support credentials header
     $headers = $this->createCredentialsHeader($headers);
     // Set exposed headers header
     $headers = $this->createExposedHeadersHeader($headers);
     // Add the headers to the response
     foreach ($headers as $name => $value) {
         $this->response = $this->response->withAddedHeader($name, (string) $value);
     }
 }
Exemple #7
0
 /**
  * Add header represented by a string.
  *
  * @param string $headerLine Response header as a string.
  *
  * @return $this
  *
  * @throws \InvalidArgumentException For invalid header names or values.
  */
 public function addHeader($headerLine)
 {
     $parts = explode(':', $headerLine, 2);
     if (count($parts) !== 2) {
         throw new \InvalidArgumentException(sprintf('"%s" is not a valid HTTP header line', $headerLine));
     }
     $name = trim(urldecode($parts[0]));
     $value = trim(urldecode($parts[1]));
     if ($this->response->hasHeader($name)) {
         $this->response = $this->response->withAddedHeader($name, $value);
     } else {
         $this->response = $this->response->withHeader($name, $value);
     }
     return $this;
 }
Exemple #8
0
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null)
 {
     $index = $this->storage->getIndex();
     return $response->withAddedHeader('X-Demeter-Index', $index);
 }
Exemple #9
0
 /**
  * {@inheritdoc}
  */
 public function withAddedHeader($name, $value)
 {
     return new HttpException($this->response->withAddedHeader($name, $value), $this->attributes);
 }
Exemple #10
0
 public function addToResponse(ResponseInterface $response) : ResponseInterface
 {
     return $response->withAddedHeader('Set-Cookie', $this->toHeaderValue());
 }
Exemple #11
0
 /**
  * Add session cookie Set-Cookie header to response.
  *
  * @param ResponseInterface $response
  *
  * @throws \InvalidArgumentException
  *
  * @return ResponseInterface
  */
 protected function respondWithSessionCookie(ResponseInterface $response)
 {
     if (session_status() !== PHP_SESSION_ACTIVE || !array_key_exists($this->sessionTimeoutKey, $_SESSION)) {
         $expireTime = time() - $this->sessionLifetime;
     } else {
         $expireTime = $_SESSION[$this->sessionTimeoutKey];
     }
     $cookieParams = [sprintf('expires=%s; max-age=%s', gmdate('D, d M Y H:i:s T', $expireTime), $this->sessionLifetime)];
     if (trim($this->getSessionSetting('cookie_path')) !== '') {
         $cookieParams[] = 'path=' . $this->getSessionSetting('cookie_path');
     }
     if (trim($this->getSessionSetting('cookie_domain')) !== '') {
         $cookieParams[] = 'domain=' . $this->getSessionSetting('cookie_domain');
     }
     if ((bool) $this->getSessionSetting('cookie_secure')) {
         $cookieParams[] = 'secure';
     }
     if ((bool) $this->getSessionSetting('cookie_httponly')) {
         $cookieParams[] = 'httponly';
     }
     return $response->withAddedHeader('Set-Cookie', sprintf('%s=%s; %s', urlencode($this->sessionName), urlencode(session_id()), implode('; ', $cookieParams)));
 }
Exemple #12
0
 public function apply(ResponseInterface $respose)
 {
     return $respose->withAddedHeader(self::HEADER_NAME, (string) $this);
 }
 /**
  * {@inheritdoc}
  */
 public function removeToken(Request $request, Response $response, TokenInterface $token)
 {
     return $response->withAddedHeader('Set-Cookie', $this->cookieHeader($request, null));
 }
 /**
  * {@inheritdoc}
  */
 public function mountToken(Request $request, Response $response, TokenInterface $token)
 {
     return $response->withAddedHeader($this->header, $token->getHash());
 }
Exemple #15
0
 /**
  * {@inheritDoc}
  */
 public function withAddedHeader($name, $value)
 {
     return new self($this->app, $this->decorated->withAddedHeader($name, $value));
 }
Exemple #16
0
 /**
  * Add no-cache cache headers to response.
  *
  * @param ResponseInterface $response
  *
  * @throws \InvalidArgumentException
  *
  * @return ResponseInterface
  */
 protected function respondWithNoCacheCache(ResponseInterface $response)
 {
     return $response->withAddedHeader('Expires', static::CACHE_EXPIRED)->withAddedHeader('Cache-Control', 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0')->withAddedHeader('Pragma', 'no-cache');
 }
 /**
  * Set tags on a response.
  *
  * @param ResponseInterface $response Original response
  * @param bool              $replace  Whether to replace the current tags
  *                                    on the response
  *
  * @return ResponseInterface Tagged response
  */
 public function tagResponse(ResponseInterface $response, $replace = false)
 {
     if ($replace) {
         return $response->withHeader($this->getTagsHeaderName(), $this->getTagsHeaderValue());
     }
     return $response->withAddedHeader($this->getTagsHeaderName(), $this->getTagsHeaderValue());
 }
Exemple #18
0
 /**
  * @inheritDoc
  */
 public function withAddedHeader($name, $value)
 {
     return new self($this->psrResponse->withAddedHeader($name, $value));
 }
Exemple #19
0
 /**
  * Set content type to response
  * 
  * @param string $type
  * 
  * @return static
  */
 protected function setContentType($type)
 {
     $this->response = $this->response->withAddedHeader('Content-Type', $type);
     return $this;
 }
Exemple #20
0
 /**
  * Sets/renews the site access cookie. Only call this if the user has
  * actually access to the website. This method does nothing if the website
  * has no site key set.
  * @param ResponseInterface $response The current response.
  * @return ResponseInterface The response with the Set-Cookie header.
  */
 private function withSiteAccessCookie(ResponseInterface $response)
 {
     $siteKey = $this->website->getConfig()->get(Config::OPTION_ACCESS_CODE);
     if (empty($siteKey)) {
         // The website doesn't use an access key
         return $response;
     }
     $now = new DateTimeImmutable();
     $expires = $now->add(new DateInterval('P60D'))->format('r');
     $siteUrl = $this->website->getText()->getUrlMain();
     $path = empty($siteUrl->getPath()) ? '/' : $siteUrl->getPath();
     $cookieInstructioh = "key={$siteKey}; expires={$expires}; path={$path}";
     return $response->withAddedHeader("Set-Cookie", $cookieInstructioh);
 }
Exemple #21
0
 public function withAddedHeader($name, $value)
 {
     $response = clone $this;
     $response->response = $this->response->withAddedHeader($name, $value);
     return $response;
 }
Exemple #22
0
 /**
  * Return an instance with the specified header appended with the given value.
  *
  * Existing values for the specified header will be maintained. The new
  * value(s) will be appended to the existing list. If the header did not
  * exist previously, it will be added.
  *
  * This method MUST be implemented in such a way as to retain the
  * immutability of the message, and MUST return an instance that has the
  * new header and/or value.
  *
  * @param string $name Case-insensitive header field name to add.
  * @param string|string[] $value Header value(s).
  * @return self
  * @throws \InvalidArgumentException for invalid header names or values.
  */
 function withAddedHeader($name, $value)
 {
     return $this->response->withAddedHeader($name, $value);
 }
 /**
  * Expire a cookie in the response.
  *
  * Do not worry about duplicated cookies, they will be deduped when the
  * response is rendered by "EncryptedCookieMiddleware".
  *
  * @param ResponseInterface $response
  * @param string $name
  *
  * @return ResponseInterface
  */
 public function expireCookie(ResponseInterface $response, $name)
 {
     $cookie = SetCookie::createExpired($name)->withMaxAge($this->configuration['maxAge'])->withPath($this->configuration['path'])->withDomain($this->configuration['domain'])->withSecure($this->configuration['secure'])->withHttpOnly($this->configuration['httpOnly']);
     return $response->withAddedHeader(static::RESPONSE_COOKIE_NAME, $cookie);
 }
 /**
  * Add the CSRF token to the response cookies.
  *
  * @param \Psr\Http\Message\ResponseInterface $response
  *
  * @return \Psr\Http\Message\ResponseInterface
  */
 protected function addCookieToResponse(ResponseInterface $response) : ResponseInterface
 {
     $config = $this->manager->getConfig();
     $setCookie = new Cookie('XSRF-TOKEN', $this->tokenService->generate(), $config->get('session::csrf.livetime', Chronos::now()->getTimestamp() + 60 * 120), $config->get('path'), $config->get('domain'), $config->get('secure', false), false, $config->get('session::csrf.samesite', false));
     return $response->withAddedHeader('Set-Cookie', (string) $setCookie);
 }
 /**
  * Mount session id or remove session cookie.
  *
  * @param ServerRequestInterface $request
  * @param ResponseInterface      $response
  * @param SessionStore           $store
  * @param array                  $cookies
  * @return ResponseInterface
  */
 protected function setCookie(ServerRequestInterface $request, ResponseInterface $response, SessionStore $store, array $cookies)
 {
     if ($store->isStarted()) {
         $store->commit();
     }
     if (!isset($cookies[self::COOKIE]) || $cookies[self::COOKIE] != $store->getID()) {
         if ($response instanceof ResponseInterface) {
             return $response->withAddedHeader('Set-Cookie', Cookie::create(self::COOKIE, $store->getID(), $store->config()['lifetime'], $request->getAttribute('basePath'), $request->getAttribute('cookieDomain'))->packHeader());
         }
     }
     return $response;
 }