Request::getHttpCode() - Code Metrics - suricate-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Request::getHttpCode() A
last analyzed 2019-08-10 15:27 UTC

↳ Parent: Request

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php

declare(strict_types=1);

namespace Suricate;

/**
 * @SuppressWarnings("StaticAccess")
 */
class Request
{
    const HTTP_METHOD_GET = 'GET';
    const HTTP_METHOD_POST = 'POST';
    const HTTP_METHOD_PUT = 'PUT';
    const HTTP_METHOD_DELETE = 'DELETE';
    const HTTP_METHOD_HEAD = 'HEAD';
    const HTTP_METHOD_OPTIONS = 'OPTIONS';

    private $method = self::HTTP_METHOD_GET;
    private $methods = [
        self::HTTP_METHOD_GET => 'GET',
        self::HTTP_METHOD_POST => 'POST',
        self::HTTP_METHOD_PUT => 'PUT',
        self::HTTP_METHOD_DELETE => 'DELETE',
        self::HTTP_METHOD_HEAD => 'HEAD',
        self::HTTP_METHOD_OPTIONS => 'OPTIONS'
    ];

    private $httpCodeString = [
        100 => 'Continue',
        101 => 'Switching Protocols',
        102 => 'Processing',
        200 => 'OK',
        201 => 'Created',
        202 => 'Accepted',
        203 => 'Non-Authoritative Information',
        204 => 'No Content',
        205 => 'Reset Content',
        206 => 'Partial Content',
        207 => 'Multi-Status',
        208 => 'Already Reported',
        226 => 'IM Used',
        250 => 'Low on Storage Space',
        300 => 'Multiple Choices',
        301 => 'Moved Permanently',
        302 => 'Found',
        303 => 'See Other',
        304 => 'Not Modified',
        305 => 'Use Proxy',
        306 => '306 Switch Proxy',
        307 => 'Temporary Redirect',
        308 => 'Permanent Redirect',
        400 => 'Bad Request',
        401 => 'Unauthorized',
        402 => 'Payment Required',
        403 => 'Forbidden',
        404 => 'Not Found',
        405 => 'Method Not Allowed',
        406 => 'Not Acceptable',
        407 => 'Proxy Authentication Required',
        408 => 'Request Timeout',
        409 => 'Conflict',
        410 => 'Gone',
        411 => 'Length Required',
        412 => 'Precondition Failed',
        413 => 'Request Entity Too Large',
        414 => 'Request-URI Too Long',
        415 => 'Unsupported Media Type',
        416 => 'Requested Range Not Satisfiable',
        417 => 'Expectation Failed',
        422 => 'Unprocessable Entity',
        423 => 'Locked',
        424 => 'Failed Dependency',
        425 => 'Unordered Collection',
        426 => 'Upgrade Required',
        428 => 'Precondition Required',
        429 => 'Too Many Requests',
        431 => 'Request Header Fields Too Large',
        444 => 'No Response',
        449 => 'Retry With',
        450 => 'Blocked by Windows Parental Controls',
        494 => 'Request Header Too Large',
        495 => 'Cert Error',
        496 => 'No Cert',
        497 => 'HTTP to HTTPS',
        499 => 'Client Closed Request',
        500 => 'Internal Server Error',
        501 => 'Not Implemented',
        502 => 'Bad Gateway',
        503 => 'Service Unavailable',
        504 => 'Gateway Timeout',
        505 => 'HTTP Version Not Supported',
        506 => 'Variant Also Negotiates',
        507 => 'Insufficient Storage',
        508 => 'Loop Detected',
        509 => 'Bandwidth Limit Exceeded',
        510 => 'Not Extended',
        511 => 'Network Authentication Required'
    ];

    private $httpCode;
    private $headers = [];
    private $requestUri = '';
    private $url;
    private $body;
    private $path;
    private $query;

    public function __construct()
    {
        $this->headers = [];
        $this->httpCode = 200;
    }

    public function parse()
    {
        if (isset($_SERVER['REQUEST_URI'])) {
            $this->setRequestUri($_SERVER['REQUEST_URI']);
            $parseResult = parse_url($_SERVER['REQUEST_URI']);
            $this->path = dataGet($parseResult, 'path');
            $this->query = dataGet($parseResult, 'query');
        }

        if (isset($_SERVER['REQUEST_METHOD'])) {
            $this->setMethod($_SERVER['REQUEST_METHOD']);
        }
        if (isset($_POST['_method'])) {
            $this->setMethod($_POST['_method']);
        }
    }

    public function setMethod($method)
    {
        if (!isset($this->methods[$method])) {
            throw new \InvalidArgumentException(
                'Invalid HTTP Method ' . $method
            );
        }

        $this->method = $method;

        return $this;
    }

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

    public function setUrl($url)
    {
        $this->url = $url;

        return $this;
    }
    public function getUrl()
    {
        return $this->url;
    }

    public function setRequestUri($uri)
    {
        $this->requestUri = $uri;

        return $this;
    }

    public function getRequestUri()
    {
        return $this->requestUri;
    }

    public function getPath()
    {
        return $this->path;
    }

    public function getQuery()
    {
        return $this->query;
    }

    public static function getPostParam($variable, $defaultValue = null)
    {
        if (array_key_exists($variable, $_POST)) {
            return $_POST[$variable];
        }
        return $defaultValue;
    }

    public static function getParam($variable, $defaultValue = null)
    {
        if (array_key_exists($variable, $_GET)) {
            return $_GET[$variable];
        }
        if (array_key_exists($variable, $_POST)) {
            return $_POST[$variable];
        }

        return $defaultValue;
    }

    public static function hasParam($variable)
    {
        return array_key_exists($variable, $_GET) ||
            array_key_exists($variable, $_POST);
    }

    /**
     * Set request headers
     *
     * @param array $headers Headers to set key => $value
     * @return Request
     */
    public function setHeaders(array $headers): Request
    {
        $this->headers = $headers;

        return $this;
    }

    /**
     * Add specific header
     *
     * @param string $header header name
     * @param string $value  header value
     * @return Request
     */
    public function addHeader($header, $value): Request
    {
        $this->headers[$header] = $value;

        return $this;
    }

    /**
     * Get request headers
     *
     * @return array
     */
    public function getHeaders(): array
    {
        return $this->headers;
    }

    public function setContentType(
        string $contentType,
        $encoding = null
    ): Request {
        if ($encoding !== null) {
            $contentType .= '; charset=' . $encoding;
        }
        $this->addHeader('Content-type', $contentType);

        return $this;
    }

    public function setBody(string $body): Request
    {
        $this->body = $body;

        return $this;
    }

    public function getBody(): string
    {
        return $this->body;
    }

    public function write()
    {
        if (!headers_sent()) {
            if (substr(php_sapi_name(), 0, 3) == 'cgi') {
                $headerString = 'Status: ' . $this->getStringForHttpCode();
            } else {
                $headerString = 'HTTP/1.1 ' . $this->getStringForHttpCode();
            }

            header($headerString);

            // Send headers
            foreach ($this->headers as $headerName => $headerValue) {
                header($headerName . ':' . $headerValue);
            }
        }

        /**
         TODO HANDLE HTTP RESPONSE CODE
         */
        if ($this->httpCode !== null) {
        }

        // Send body
        echo $this->body;
    }

    //
    // HTTP Code
    //

    public function setHttpCode($code): Request
    {
        $this->httpCode = $code;

        return $this;
    }

    public function getHttpCode()
    {
        return $this->httpCode;
    }

    /**
     * Flash message
     *
     * @param string $type message type
     * @param array|string $data data to be flashed
     */
    public function flash(string $type, $data)
    {
        Flash::writeMessage($type, $data);

        return $this;
    }

    public function flashData($name, $value)
    {
        Flash::writeData($name, $value);

        return $this;
    }

    public function redirect($url, $httpCode = 302)
    {
        $this->setHttpCode($httpCode);
        $this->addHeader('Location', $url);

        $this->write();
        die();

    }

    public function redirectWithSuccess($url, $message)
    {
        $this->flash('success', $message)->redirect($url);
    }

    public function redirectWithInfo($url, $message)
    {
        $this->flash('info', $message)->redirect($url);
    }

    public function redirectWithError($url, $message)
    {
        $this->flash('error', $message)->redirect($url);
    }

    public function redirectWithData($url, $key, $value)
    {
        $this->flashData($key, $value)->redirect($url);
    }

    /**
     * Check if request has a 200 OK Code
     *
     * @return boolean
     */
    public function isOK(): bool
    {
        return $this->httpCode == 200;
    }

    /**
     * Check if request has a 3XX HTTP code
     *
     * @return boolean
     */
    public function isRedirect(): bool
    {
        return $this->httpCode >= 300 && $this->httpCode < 400;
    }

    /**
     * Check is request has a 4XX HTTP code
     *
     * @return boolean
     */
    public function isClientError(): bool
    {
        return $this->httpCode >= 400 && $this->httpCode < 500;
    }

    /**
     * Check if request has a 5XX HTTP code
     *
     * @return boolean
     */
    public function isServerError(): bool
    {
        return $this->httpCode >= 500 && $this->httpCode < 600;
    }

    private function getStringForHttpCode()
    {
        if (isset($this->httpCodeString[$this->httpCode])) {
            return $this->httpCode .
                ' ' .
                $this->httpCodeString[$this->httpCode];
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Suricate;
6
7		/**
8		* @SuppressWarnings("StaticAccess")
9		*/
10		class Request
11		{
12		const HTTP_METHOD_GET = 'GET';
13		const HTTP_METHOD_POST = 'POST';
14		const HTTP_METHOD_PUT = 'PUT';
15		const HTTP_METHOD_DELETE = 'DELETE';
16		const HTTP_METHOD_HEAD = 'HEAD';
17		const HTTP_METHOD_OPTIONS = 'OPTIONS';
18
19		private $method = self::HTTP_METHOD_GET;
20		private $methods = [
21		self::HTTP_METHOD_GET => 'GET',
22		self::HTTP_METHOD_POST => 'POST',
23		self::HTTP_METHOD_PUT => 'PUT',
24		self::HTTP_METHOD_DELETE => 'DELETE',
25		self::HTTP_METHOD_HEAD => 'HEAD',
26		self::HTTP_METHOD_OPTIONS => 'OPTIONS'
27		];
28
29		private $httpCodeString = [
30		100 => 'Continue',
31		101 => 'Switching Protocols',
32		102 => 'Processing',
33		200 => 'OK',
34		201 => 'Created',
35		202 => 'Accepted',
36		203 => 'Non-Authoritative Information',
37		204 => 'No Content',
38		205 => 'Reset Content',
39		206 => 'Partial Content',
40		207 => 'Multi-Status',
41		208 => 'Already Reported',
42		226 => 'IM Used',
43		250 => 'Low on Storage Space',
44		300 => 'Multiple Choices',
45		301 => 'Moved Permanently',
46		302 => 'Found',
47		303 => 'See Other',
48		304 => 'Not Modified',
49		305 => 'Use Proxy',
50		306 => '306 Switch Proxy',
51		307 => 'Temporary Redirect',
52		308 => 'Permanent Redirect',
53		400 => 'Bad Request',
54		401 => 'Unauthorized',
55		402 => 'Payment Required',
56		403 => 'Forbidden',
57		404 => 'Not Found',
58		405 => 'Method Not Allowed',
59		406 => 'Not Acceptable',
60		407 => 'Proxy Authentication Required',
61		408 => 'Request Timeout',
62		409 => 'Conflict',
63		410 => 'Gone',
64		411 => 'Length Required',
65		412 => 'Precondition Failed',
66		413 => 'Request Entity Too Large',
67		414 => 'Request-URI Too Long',
68		415 => 'Unsupported Media Type',
69		416 => 'Requested Range Not Satisfiable',
70		417 => 'Expectation Failed',
71		422 => 'Unprocessable Entity',
72		423 => 'Locked',
73		424 => 'Failed Dependency',
74		425 => 'Unordered Collection',
75		426 => 'Upgrade Required',
76		428 => 'Precondition Required',
77		429 => 'Too Many Requests',
78		431 => 'Request Header Fields Too Large',
79		444 => 'No Response',
80		449 => 'Retry With',
81		450 => 'Blocked by Windows Parental Controls',
82		494 => 'Request Header Too Large',
83		495 => 'Cert Error',
84		496 => 'No Cert',
85		497 => 'HTTP to HTTPS',
86		499 => 'Client Closed Request',
87		500 => 'Internal Server Error',
88		501 => 'Not Implemented',
89		502 => 'Bad Gateway',
90		503 => 'Service Unavailable',
91		504 => 'Gateway Timeout',
92		505 => 'HTTP Version Not Supported',
93		506 => 'Variant Also Negotiates',
94		507 => 'Insufficient Storage',
95		508 => 'Loop Detected',
96		509 => 'Bandwidth Limit Exceeded',
97		510 => 'Not Extended',
98		511 => 'Network Authentication Required'
99		];
100
101		private $httpCode;
102		private $headers = [];
103		private $requestUri = '';
104		private $url;
105		private $body;
106		private $path;
107		private $query;
108
109	18	public function __construct()
110		{
111	18	$this->headers = [];
112	18	$this->httpCode = 200;
113	18	}
114
115	9	public function parse()
116		{
117	9	if (isset($_SERVER['REQUEST_URI'])) {
118	5	$this->setRequestUri($_SERVER['REQUEST_URI']);
119	5	$parseResult = parse_url($_SERVER['REQUEST_URI']);
120	5	$this->path = dataGet($parseResult, 'path');
121	5	$this->query = dataGet($parseResult, 'query');
122		}
123
124	9	if (isset($_SERVER['REQUEST_METHOD'])) {
125	1	$this->setMethod($_SERVER['REQUEST_METHOD']);
126		}
127	9	if (isset($_POST['_method'])) {
128	5	$this->setMethod($_POST['_method']);
129		}
130	9	}
131
132	7	public function setMethod($method)
133		{
134	7	if (!isset($this->methods[$method])) {
135	1	throw new \InvalidArgumentException(
136	1	'Invalid HTTP Method ' . $method
137		);
138		}
139
140	7	$this->method = $method;
141
142	7	return $this;
143		}
144
145	3	public function getMethod()
146		{
147	3	return $this->method;
148		}
149
150	2	public function setUrl($url)
151		{
152	2	$this->url = $url;
153
154	2	return $this;
155		}
156	2	public function getUrl()
157		{
158	2	return $this->url;
159		}
160
161	10	public function setRequestUri($uri)
162		{
163	10	$this->requestUri = $uri;
164
165	10	return $this;
166		}
167
168	11	public function getRequestUri()
169		{
170	11	return $this->requestUri;
171		}
172
173	1	public function getPath()
174		{
175	1	return $this->path;
176		}
177
178	1	public function getQuery()
179		{
180	1	return $this->query;
181		}
182
183	1	public static function getPostParam($variable, $defaultValue = null)
184		{
185	1	if (array_key_exists($variable, $_POST)) {
186	1	return $_POST[$variable];
187		}
188	1	return $defaultValue;
189		}
190
191	1	public static function getParam($variable, $defaultValue = null)
192		{
193	1	if (array_key_exists($variable, $_GET)) {
194	1	return $_GET[$variable];
195		}
196	1	if (array_key_exists($variable, $_POST)) {
197	1	return $_POST[$variable];
198		}
199
200	1	return $defaultValue;
201		}
202
203	1	public static function hasParam($variable)
204		{
205	1	return array_key_exists($variable, $_GET) \|\|
206	1	array_key_exists($variable, $_POST);
207		}
208
209		/**
210		* Set request headers
211		*
212		* @param array $headers Headers to set key => $value
213		* @return Request
214		*/
215	1	public function setHeaders(array $headers): Request
216		{
217	1	$this->headers = $headers;
218
219	1	return $this;
220		}
221
222		/**
223		* Add specific header
224		*
225		* @param string $header header name
226		* @param string $value header value
227		* @return Request
228		*/
229	1	public function addHeader($header, $value): Request
230		{
231	1	$this->headers[$header] = $value;
232
233	1	return $this;
234		}
235
236		/**
237		* Get request headers
238		*
239		* @return array
240		*/
241	1	public function getHeaders(): array
242		{
243	1	return $this->headers;
244		}
245
246	1	public function setContentType(
247		string $contentType,
248		$encoding = null
249		): Request {
250	1	if ($encoding !== null) {
251	1	$contentType .= '; charset=' . $encoding;
252		}
253	1	$this->addHeader('Content-type', $contentType);
254
255	1	return $this;
256		}
257
258	1	public function setBody(string $body): Request
259		{
260	1	$this->body = $body;
261
262	1	return $this;
263		}
264
265	1	public function getBody(): string
266		{
267	1	return $this->body;
268		}
269
270		public function write()
271		{
272		if (!headers_sent()) {
273		if (substr(php_sapi_name(), 0, 3) == 'cgi') {
274		$headerString = 'Status: ' . $this->getStringForHttpCode();
275		} else {
276		$headerString = 'HTTP/1.1 ' . $this->getStringForHttpCode();
277		}
278
279		header($headerString);
280
281		// Send headers
282		foreach ($this->headers as $headerName => $headerValue) {
283		header($headerName . ':' . $headerValue);
284		}
285		}
286
287		/**
288		TODO HANDLE HTTP RESPONSE CODE
289		*/
290		if ($this->httpCode !== null) {
291		}
292
293		// Send body
294		echo $this->body;
295		}
296
297		//
298		// HTTP Code
299		//
300
301	1	public function setHttpCode($code): Request
302		{
303	1	$this->httpCode = $code;
304
305	1	return $this;
306		}
307
308	1	public function getHttpCode()
309		{
310	1	return $this->httpCode;
311		}
312
313		/**
314		* Flash message
315		*
316		* @param string $type message type
317		* @param array\|string $data data to be flashed
318		*/
319		public function flash(string $type, $data)
320		{
321		Flash::writeMessage($type, $data);
322
323		return $this;
324		}
325
326		public function flashData($name, $value)
327		{
328		Flash::writeData($name, $value);
329
330		return $this;
331		}
332
333		public function redirect($url, $httpCode = 302)
334		{
335		$this->setHttpCode($httpCode);
336		$this->addHeader('Location', $url);
337
338		$this->write();
339		die();
		0 ignored issues – show Best Practice introduced 2019-01-13 22:04 UTC by Report Bug Copy Issue Report Using `exit` here is not recommended. In general, usage of exit should be done with care and only when running in a scripting context like a CLI script. Loading history...
340		}
341
342		public function redirectWithSuccess($url, $message)
343		{
344		$this->flash('success', $message)->redirect($url);
345		}
346
347		public function redirectWithInfo($url, $message)
348		{
349		$this->flash('info', $message)->redirect($url);
350		}
351
352		public function redirectWithError($url, $message)
353		{
354		$this->flash('error', $message)->redirect($url);
355		}
356
357		public function redirectWithData($url, $key, $value)
358		{
359		$this->flashData($key, $value)->redirect($url);
360		}
361
362		/**
363		* Check if request has a 200 OK Code
364		*
365		* @return boolean
366		*/
367	1	public function isOK(): bool
368		{
369	1	return $this->httpCode == 200;
370		}
371
372		/**
373		* Check if request has a 3XX HTTP code
374		*
375		* @return boolean
376		*/
377	1	public function isRedirect(): bool
378		{
379	1	return $this->httpCode >= 300 && $this->httpCode < 400;
380		}
381
382		/**
383		* Check is request has a 4XX HTTP code
384		*
385		* @return boolean
386		*/
387	1	public function isClientError(): bool
388		{
389	1	return $this->httpCode >= 400 && $this->httpCode < 500;
390		}
391
392		/**
393		* Check if request has a 5XX HTTP code
394		*
395		* @return boolean
396		*/
397	1	public function isServerError(): bool
398		{
399	1	return $this->httpCode >= 500 && $this->httpCode < 600;
400		}
401
402	1	private function getStringForHttpCode()
403		{
404	1	if (isset($this->httpCodeString[$this->httpCode])) {
405	1	return $this->httpCode .
406	1	' ' .
407	1	$this->httpCodeString[$this->httpCode];
408		}
409	1	}
410		}
411

suricate-php / framework

Request::getHttpCode() A last analyzed 2019-08-10 15:27 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Request::getHttpCode() A
last analyzed 2019-08-10 15:27 UTC