Borobudur\Http\Request

Complexity

Total Complexity

70

Size/Duplication

Total Lines	556
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	13

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	21	2
B	create()	0	62	7
A	createFromServer()	0	14	4
A	normalizeQueryString()	0	12	2
B	computePairValue()	0	28	5
B	fixCreateServerRequest()	0	21	5
A	fixServerComponent()	0	15	4
A	fixSchema()	0	12	4
B	fixQueryString()	0	22	6
A	get()	0	12	3
A	has()	0	12	3
A	all()	0	4	1
A	getQueryString()	0	6	2
A	getCharsets()	0	8	2
A	getEncodings()	0	8	2
A	getLanguages()	0	8	2
A	getETags()	0	15	3
A	getClientIps()	0	20	3
A	getClientIp()	0	6	2
A	isNoCache()	0	14	4
A	__toString()	0	12	1
A	getAcceptedHeaderValues()	0	15	3

<?php
/*
 * This file is part of the Borobudur-Http package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Http;

use Borobudur\Http\Header\Accept\AbstractAcceptHeader;
use Borobudur\Http\Header\CacheControlHeader;
use Borobudur\Http\Session;
use Borobudur\Http\Session\Storage\SaveHandler\NativeSessionSaveHandler;
use SessionHandlerInterface;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     7/19/15
 */
class Request extends AbstractRequest
{
    /**
     * @const string
     */
    const HTTP_METHOD_GET = 'GET';
    const HTTP_METHOD_POST = 'POST';
    const HTTP_METHOD_PATCH = 'PATCH';
    const HTTP_METHOD_PUT = 'PUT';
    const HTTP_METHOD_DELETE = 'DELETE';
    const HTTP_METHOD_OPTIONS = 'OPTIONS';
    const HTTP_METHOD_HEAD = 'HEAD';
    const HTTP_METHOD_CONNECT = 'CONNECT';
    const HTTP_METHOD_TRACE = 'TRACE';
    const HTTP_METHOD_PURGE = 'PURGE';

    /**
     * HTTP request method (GET is default).
     *
     * @var string
     */
    protected $method = Request::HTTP_METHOD_GET;

    /**
     * @var array
     */
    private $charsets;

    /**
     * @var array
     */
    private $encodings;

    /**
     * @var array
     */
    private $languages;

    /**
     * @var array
     */
    private $eTags;

    /**
     * Constructor.
     *
     * @param array                        $server
     * @param array                        $query
     * @param array                        $request
     * @param array                        $cookies
     * @param array                        $files
     * @param SessionHandlerInterface|null $sessionHandler
     * @param string|null                  $content
     */
    public function __construct(
        array $server = array(),
        array $query = array(),
        array $request = array(),
        array $cookies = array(),
        array $files = array(),
        SessionHandlerInterface $sessionHandler = null,
        $content = null
    ) {
        $this->server = new ServerBag($server);
        $this->query = new ParameterBag($query);
        $this->request = new ParameterBag($request);
        $this->cookies = new ParameterBag($cookies);
        $this->headers = HeaderBag::fromServer($this->server->getHeaders());
        $this->schemaHost = new SchemaHost($this->server);
        $this->uri = new Uri($this->server);
        $this->url = new Url($this->uri, $this->schemaHost, $this->getQueryString());
        $this->files = new UploadFileBag($files);
        $this->session = new Session($sessionHandler ?: new NativeSessionSaveHandler());
        $this->content = $content;
    }

    /**
     * Factory create Request.
     *
     * @param string $uri
     * @param string $method
     * @param array  $parameters
     * @param array  $cookies
     * @param array  $server
     * @param array  $files
     * @param string $content
     *
     * @return $this
     */
    public static function create(
        $uri,
        $method = Request::HTTP_METHOD_GET,
        array $parameters = array(),
        array $cookies = array(),
        array $server = array(),
        array $files = array(),
        $content = null
    ) {
        $server = array_replace(array(
            'SERVER_PROTOCOL'      => 'HTTP/1.1',
            'SERVER_NAME'          => 'localhost',
            'SERVER_PORT'          => 80,
            'REQUEST_URI'          => '/',
            'SCRIPT_NAME'          => '',
            'SCRIPT_FILENAME'      => '',
            'HTTP_HOST'            => 'localhost',
            'HTTP_ACCEPT'          => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'HTTP_ACCEPT_LANGUAGE' => 'en-US,en;q=0.8',
            'HTTP_ACCEPT_CHARSET'  => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
            'HTTP_USER_AGENT'      => 'Borobudur/0.X',
            'REQUEST_TIME'         => time(),
        ), $server);

        $server['PATH_INFO'] = '';
        $server['REQUEST_METHOD'] = strtoupper($method);

        $components = array_merge(array('path' => '/'), parse_url($uri));
        self::fixServerComponent($server, $components);

        switch ($server['REQUEST_METHOD']) {
            case Request::HTTP_METHOD_POST:
                // break intentionally omitted
            case Request::HTTP_METHOD_PUT:
                // break intentionally omitted
            case Request::HTTP_METHOD_DELETE:
                if (!isset($server['CONTENT_TYPE'])) {
                    $server['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';
                }
            // break intentionally omitted
            case Request::HTTP_METHOD_PATCH:
                // $parameters as $_POST parameters.
                // disable $_GET parameters.
                $request = $parameters;
                $query = array();
                break;
            default:
                // $parameters as $_GET parameters.
                // disabled $_POST parameters.
                $request = array();
                $query = $parameters;
        }

        $queryString = '';
        if (isset($components['query'])) {
            $queryString = $components['query'];
        }

        $query = self::fixQueryString($server, $query, $queryString, $components['path']);

        return new static($server, $query, $request, $cookies, $files, null, $content);
    }

    /**
     * Factory create Request from $_SERVER variables.
     *
     * @return Request
     */
    public static function createFromServer()
    {
        $server = $_SERVER;
        if ('cli-server' === php_sapi_name()) {
            if (array_key_exists('HTTP_CONTENT_LENGTH', $_SERVER)) {
                $server['CONTENT_LENGTH'] = $_SERVER['HTTP_CONTENT_LENGTH'];
            }
            if (array_key_exists('HTTP_CONTENT_TYPE', $_SERVER)) {
                $server['CONTENT_TYPE'] = $_SERVER['HTTP_CONTENT_TYPE'];
            }
        }

        return self::fixCreateServerRequest($server);
    }

    /**
     * Normalize query string.
     *
     * @param string $queryString
     *
     * @return string
     */
    public static function normalizeQueryString($queryString)
    {
        $queryString = trim((string) $queryString);
        if (empty($queryString)) {
            return '';
        }

        list($parts, $order) = self::computePairValue($queryString);
        array_multisort($order, SORT_ASC, $parts);

        return implode('&', $parts);
    }

    /**
     * Pair value.
     *
     * @param string $queryString
     *
     * @return array
     */
    private static function computePairValue($queryString)
    {
        $parts = array();
        $order = array();

        foreach (explode('&', $queryString) as $param) {
            $param = trim($param);
            if (true === empty($param) || '=' === $param[0]) {
                continue;
            }

            $keyValuePair = explode('=', $param, 2);
            $order[] = urldecode($keyValuePair[0]);

            if (isset($keyValuePair[1])) {
                $parts[] = sprintf(
                    '%s=%s',
                    rawurlencode(urldecode($keyValuePair[0])),
                    rawurlencode(urldecode($keyValuePair[1]))
                );
                continue;
            }

            $parts[] = rawurlencode(urldecode($keyValuePair[0]));
        }

        return array($parts, $order);
    }

    /**
     * Create fixed server request
     *
     * @param array $server
     *
     * @return $this
     */
    private static function fixCreateServerRequest(array &$server)
    {
        $request = new self($server, $_GET, $_POST, $_COOKIE, $_FILES);

        // parse parameter from body content from method PUT, DELETE and PATCH.
        if ($request->getHeaderBag()->has('Content-Type')
            && 0 === strpos(
                $request->getHeaderBag()->first('Content-Type')->getFieldValue(),
                'application/x-www-form-urlencoded'
            )
            && in_array(
                strtoupper($request->getServerBag()->get('REQUEST_METHOD', Request::HTTP_METHOD_GET)),
                array(Request::HTTP_METHOD_PUT, Request::HTTP_METHOD_DELETE, Request::HTTP_METHOD_PATCH)
            )
        ) {
            parse_str($request->getContent(), $data);
            $request->request = new ParameterBag($data ?: array());
        }

        return $request;
    }

    /**
     * Fixing server component.
     *
     * @param array $server
     * @param array $components
     */
    private static function fixServerComponent(array &$server, array $components)
    {
        if (isset($components['host'])) {
            $server['SERVER_NAME'] = $server['HTTP_HOST'] = $components['host'];
        }

        if (isset($components['scheme'])) {
            self::fixSchema($server, $components['scheme']);
        }

        if (isset($components['port'])) {
            $server['SERVER_PORT'] = $components['port'];
            $server['HTTP_HOST'] = sprintf('%s:%s', $server['HTTP_HOST'], $server['SERVER_PORT']);
        }
    }

    /**
     * Fix schema.
     *
     * @param array  $server
     * @param string $schema
     */
    private static function fixSchema(array &$server, $schema)
    {
        if ($schema) {
            if ('http' === $schema) {
                unset($server['HTTPS']);
                $server['SERVER_PORT'] = 80;
            } elseif ('https' === $schema) {
                $server['HTTPS'] = 'on';
                $server['SERVER_PORT'] = 443;
            }
        }
    }

    /**
     * Fix server query string
     *
     * @param array $server
     * @param array $query
     *
     * @return array
     */
    private static function fixQueryString(array &$server, array $query, $queryString, $path)
    {
        $str = '';
        if ($queryString) {
            parse_str(html_entity_decode($queryString), $queryParts);

            if (!empty($query)) {
                $query = array_merge($query, $queryParts);
            } else {
                $query = $queryParts ?: array();
            }
        }

        if (!empty($query)) {
            $str = http_build_query($query, '', '&');
        }

        $server['REQUEST_URI'] = $path . (!empty($str) ? sprintf('?%s', $str) : '');
        $server['QUERY_STRING'] = $str;

        return $query;
    }

    /**
     * Get parameter value or return default value if not exist.
     *
     * Order of precedence: GET, POST
     *
     * @param string $key
     * @param mixed  $default
     *
     * @return mixed
     */
    public function get($key, $default = null)
    {
        if ($this->query->has($key)) {
            return $this->query->get($key, $default);
        }

        if ($this->request->has($key)) {
            return $this->request->get($key, $default);
        }

        return $default;
    }

    /**
     * Check if parameter defined by key.
     *
     * @param string $key
     *
     * @return bool
     */
    public function has($key)
    {
        if ($this->query->has($key)) {
            return true;
        }

        if ($this->request->has($key)) {
            return true;
        }

        return false;
    }

    /**
     * Get all parameters.
     *
     * @return array
     */
    public function all()
    {
        return array_merge($this->request->all(), $this->query->all());
    }

    /**
     * Get query string.
     *
     * @return string|null
     */
    public function getQueryString()
    {
        $queryString = static::normalizeQueryString($this->server->get('QUERY_STRING'));

        return false === empty($queryString) ? $queryString : null;
    }

    /**
     * Get list of charsets that accepted by client browser.
     *
     * @return array
     */
    public function getCharsets()
    {
        if (null === $this->charsets) {
            $this->charsets = $this->getAcceptedHeaderValues('Accept-Charset');
        }

        return $this->charsets;
    }

    /**
     * Get list of encodings that accepted by client browser.
     *
     * @return array
     */
    public function getEncodings()
    {
        if (null === $this->encodings) {
            $this->encodings = $this->getAcceptedHeaderValues('Accept-Encoding');
        }

        return $this->encodings;
    }

    /**
     * Get list of languages that accepted by client browser.
     *
     * @return array
     */
    public function getLanguages()
    {
        if (null === $this->languages) {
            $this->languages = $this->getAcceptedHeaderValues('Accept-Language');
        }

        return $this->languages;
    }

    /**
     * Get ETags.
     *
     * @return array
     */
    public function getETags()
    {
        if (null === $this->eTags) {
            $eTags = array();
            if ($this->headers->has('ETag')) {
                $header = $this->headers->first('ETag');
                $eTags = array_map('trim', explode(',', $header->getFieldValue()));
                $eTags = array_filter($eTags);
            }

            $this->eTags = $eTags;
        }

        return $this->eTags;
    }

    /**
     * Get client ip addresses.
     *
     * @return array
     */
    public function getClientIps()
    {
        $ips = array();
        foreach (
            array(
                'HTTP_CLIENT_IP',
                'HTTP_X_FORWARDED_FOR',
                'HTTP_X_FORWARDED',
                'HTTP_FORWARDED_FOR',
                'HTTP_FORWARDED',
                'REMOTE_ADDR',
            ) as $ip
        ) {
            if ($this->server->has($ip)) {
                $ips[] = $this->server->get($ip);
            }
        }

        return array_reverse($ips);
    }

    /**
     * Get client ip address.
     *
     * @return string
     */
    public function getClientIp()
    {
        $ips = $this->getClientIps();

        return count($ips) ? $ips[0] : null;
    }

    /**
     * Check request is no cache.
     *
     * @return bool
     */
    public function isNoCache()
    {
        if ($this->headers->has('Cache-Control')) {
            /**
             * @var CacheControlHeader $cacheControlHeader
             */
            $cacheControlHeader = $this->headers->first('Cache-Control');
            if ($cacheControlHeader->isNoCache()) {
                return true;
            }
        }

        return $this->headers->has('Pragma') && 'no-cache' === $this->headers->first('Pragma')->getFieldValue();
    }

    /**
     * Cast Request to string representation.
     *
     * @return string
     */
    public function __toString()
    {
        return
            sprintf(
                '%s %s %s' . "\r\n",
                $this->getMethod(),
                $this->uri->getRequestUri(),
                $this->server->get('SERVER_PROTOCOL')
            ) .
            $this->headers . "\r\n" .
            $this->getContent();
    }

    /**
     * Get accept header values by header name.
     *
     * @param string $headerName
     *
     * @return array
     */
    private function getAcceptedHeaderValues($headerName)
    {
        $values = array();
        if ($this->headers->has($headerName)) {
            /**
             * @var AbstractAcceptHeader $header
             */
            $header = $this->headers->first($headerName);
            foreach ($header->all() as $item) {
                $values[] = $item->getValue();
            }
        }

        return $values;
    }
}