Daikon\Boot\Middleware\Action\DaikonRequest

Complexity

Total Complexity

41

Size/Duplication

Total Lines	245
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

41 Methods

Rating	Name	Duplication	Size	Complexity
A	getUri()	0	3	1
A	unwrap()	0	3	1
A	getStatusCode()	0	3	1
A	getHeader()	0	3	1
A	withCookieParams()	0	3	1
A	withUri()	0	3	1
A	withStatusCode()	0	3	1
A	withAttribute()	0	3	1
A	getAttribute()	0	3	1
A	getResponder()	0	3	1
A	withRequestTarget()	0	3	1
A	getAttributes()	0	3	1
A	getMethod()	0	3	1
A	withHeader()	0	3	1
A	getBody()	0	3	1
A	getProtocolVersion()	0	3	1
A	withMethod()	0	3	1
A	withoutAttribute()	0	3	1
A	withParsedBody()	0	3	1
A	getErrors()	0	3	1
A	getQueryParams()	0	3	1
A	withPayload()	0	3	1
A	withResponder()	0	3	1
A	__construct()	0	3	1
A	withUploadedFiles()	0	3	1
A	getPayload()	0	3	1
A	getHeaders()	0	3	1
A	withProtocolVersion()	0	3	1
A	getParsedBody()	0	3	1
A	getUploadedFiles()	0	3	1
A	withBody()	0	3	1
A	hasHeader()	0	3	1
A	getHeaderLine()	0	3	1
A	wrap()	0	3	1
A	withErrors()	0	3	1
A	withoutHeader()	0	3	1
A	withAddedHeader()	0	3	1
A	getRequestTarget()	0	3	1
A	getCookieParams()	0	3	1
A	withQueryParams()	0	3	1
A	getServerParams()	0	3	1

<?php declare(strict_types=1);
/**
 * This file is part of the daikon-cqrs/boot project.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Daikon\Boot\Middleware\Action;

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UriInterface;

class DaikonRequest implements ServerRequestInterface
{
    public const ERRORS = '_errors';
    public const PAYLOAD = '_payload';
    public const STATUS_CODE = '_status_code';
    public const RESPONDER = '_responder';

    protected ServerRequestInterface $serverRequest;

    private function __construct(ServerRequestInterface $serverRequest)
    {
        $this->serverRequest = $serverRequest;
    }

    /** @return static */
    public static function wrap(ServerRequestInterface $serverRequest): self
    {
        return new self($serverRequest);
    }

    public function unwrap(): ServerRequestInterface
    {
        return $this->serverRequest;
    }

    /**
     * @param mixed $errors
     * @return static
     */
    public function withErrors($errors): self
    {
        return static::wrap($this->serverRequest->withAttribute(self::ERRORS, $errors));
    }

    /**
     * @param mixed $default
     * @return mixed
     */
    public function getErrors($default = null)
    {
        return $this->serverRequest->getAttribute(self::ERRORS, $default);
    }

    /**
     * @param mixed $payload
     * @return static
     */
    public function withPayload($payload): self
    {
        return static::wrap($this->serverRequest->withAttribute(self::PAYLOAD, $payload));
    }

    /**
     * @param mixed $default
     * @return mixed
     */
    public function getPayload($default = null)
    {
        return $this->serverRequest->getAttribute(self::PAYLOAD, $default);
    }

    /**
     * @param mixed $responder
     * @return static
     */
    public function withResponder($responder): self
    {
        return static::wrap($this->serverRequest->withAttribute(self::RESPONDER, $responder));
    }

    /**
     * @param mixed $default
     * @return mixed
     */
    public function getResponder($default = null)
    {
        return $this->serverRequest->getAttribute(self::RESPONDER, $default);
    }

    /**
     * @param mixed $statusCode
     * @return static
     */
    public function withStatusCode($statusCode): self
    {
        return static::wrap($this->serverRequest->withAttribute(self::STATUS_CODE, $statusCode));
    }

    /**
     * @param mixed $default
     * @return mixed
     */
    public function getStatusCode($default = null)
    {
        return $this->getAttribute(self::STATUS_CODE, $default);
    }

    public function getServerParams()
    {
        return $this->serverRequest->getServerParams();
    }

    public function getCookieParams()
    {
        return $this->serverRequest->getCookieParams();
    }

    public function withCookieParams(array $cookies)
    {
        return static::wrap($this->serverRequest->withCookieParams($cookies));
    }

    public function getQueryParams()
    {
        return $this->serverRequest->getQueryParams();
    }

    public function withQueryParams(array $query)
    {
        return static::wrap($this->serverRequest->withQueryParams($query));
    }

    public function getUploadedFiles()
    {
        return $this->serverRequest->getUploadedFiles();
    }

    public function withUploadedFiles(array $uploadedFiles)
    {
        return static::wrap($this->serverRequest->withUploadedFiles($uploadedFiles));
    }

    public function getParsedBody()
    {
        return $this->serverRequest->getParsedBody();
    }

    public function withParsedBody($data)
    {
        return static::wrap($this->serverRequest->withParsedBody($data));
    }

    public function getAttributes()
    {
        return $this->serverRequest->getAttributes();
    }

    public function getAttribute($name, $default = null)
    {
        return $this->serverRequest->getAttribute($name, $default);
    }

    public function withAttribute($name, $value)
    {
        return static::wrap($this->serverRequest->withAttribute($name, $value));
    }

    public function withoutAttribute($name)
    {
        return static::wrap($this->serverRequest->withoutAttribute($name));
    }

    public function getRequestTarget()
    {
        return $this->serverRequest->getRequestTarget();
    }

    public function withRequestTarget($requestTarget)
    {
        return static::wrap($this->serverRequest->withRequestTarget($requestTarget));
    }

    public function getMethod()
    {
        return $this->serverRequest->getMethod();
    }

    public function withMethod($method)
    {
        return static::wrap($this->serverRequest->withMethod($method));
    }

    public function getUri()
    {
        return $this->serverRequest->getUri();
    }

    public function withUri(UriInterface $uri, $preserveHost = false)
    {
        return static::wrap($this->serverRequest->withUri($uri, $preserveHost));
    }

    public function getProtocolVersion()
    {
        return $this->serverRequest->getProtocolVersion();
    }

    public function withProtocolVersion($version)
    {
        return static::wrap($this->serverRequest->withProtocolVersion($version));
    }

    public function getHeaders()
    {
        return $this->serverRequest->getHeaders();
    }

    public function hasHeader($name)
    {
        return $this->serverRequest->hasHeader($name);
    }

    public function getHeader($name)
    {
        return $this->serverRequest->getHeader($name);
    }

    public function getHeaderLine($name)
    {
        return $this->serverRequest->getHeaderLine($name);
    }

    public function withHeader($name, $value)
    {
        return static::wrap($this->serverRequest->withHeader($name, $value));
    }

    public function withAddedHeader($name, $value)
    {
        return static::wrap($this->serverRequest->withAddedHeader($name, $value));
    }

    public function withoutHeader($name)
    {
        return static::wrap($this->serverRequest->withoutHeader($name));
    }

    public function getBody()
    {
        return $this->serverRequest->getBody();
    }

    public function withBody(StreamInterface $body)
    {
        return static::wrap($this->serverRequest->withBody($body));
    }
}