App\Response

Complexity

Total Complexity

41

Size/Duplication

Total Lines	276
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	setHeader()	0	4	1
A	setEmitJSONP()	0	5	1
A	setEmitType()	0	4	1
A	isJSON()	0	4	1
A	getError()	0	4	1
A	setError()	0	11	3
A	setException()	0	18	5
A	hasError()	0	4	1
A	updateResult()	0	4	1
A	getResult()	0	4	1
A	setResult()	0	4	1
C	emit()	0	40	14
A	emitJSON()	0	4	1
A	prepareResponse()	0	12	2
A	emitText()	0	16	4
A	emitRaw()	0	7	3

<?php
/**
 * Response class.
 *
 * @copyright YetiForce Sp. z o.o.
 * @license   YetiForce Public License 3.0 (licenses/LicenseEN.txt or yetiforce.com)
 * @author    Radosław Skrzypczak <r.skrzypczak@yetiforce.com>
 */

namespace App;

class Response
{
	/**
	 * Emit response wrapper as raw string.
	 */
	public static $EMIT_RAW = 0;

$EMIT_RAW does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

	/**
	 * Emit response wrapper as json string.
	 */
	public static $EMIT_JSON = 1;

$EMIT_JSON does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

	/**
	 * Emit response wrapper as html string.
	 */
	public static $EMIT_HTML = 2;

$EMIT_HTML does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

	/**
	 * Emit response wrapper as string/jsonstring.
	 */
	public static $EMIT_JSONTEXT = 3;

$EMIT_JSONTEXT does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

	/**
	 * Emit response wrapper as padded-json.
	 */
	public static $EMIT_JSONP = 4;

$EMIT_JSONP does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

	/**
	 * Error data.
	 */
	private $error;

	/**
	 * Result data.
	 */
	private $result;

	// Active emit type
	private $emitType = 1; // EMIT_JSON

	// JSONP padding
	private $emitJSONPFn = false; // for EMIT_JSONP

	// List of response headers
	private $headers = [];

	/**
	 * Set headers to send.
	 *
	 * @param mixed $header
	 */
	public function setHeader($header)
	{
		$this->headers[] = $header;
	}

	/**
	 * Set padding method name for JSONP emit type.
	 *
	 * @param mixed $fn
	 */
	public function setEmitJSONP($fn)
	{
		$this->setEmitType(self::$EMIT_JSONP);
		$this->emitJSONPFn = $fn;
	}

	/**
	 * Set emit type.
	 *
	 * @param mixed $type
	 */
	public function setEmitType($type)
	{
		$this->emitType = $type;
	}

	/**
	 * Is emit type configured to JSON?
	 */
	public function isJSON()
	{
		return $this->emitType == self::$EMIT_JSON;
	}

	/**
	 * Get the error data.
	 */
	public function getError()
	{
		return $this->error;
	}

	/**
	 * Set error data to send.
	 *
	 * @param mixed      $code

Consider making the type for parameter $code a bit more specific; maybe use integer.

	 * @param mixed|null $message
	 * @param mixed      $trace
	 *
	 * @return void
	 */
	public function setError($code = 500, $message = null, $trace = false): void
	{
		if (null === $message) {
			$message = $code;

Consider using a different name than the parameter $message. This often makes code more readable.

		}
		$error = ['code' => $code, 'message' => $message, 'trace' => $trace];
		$this->error = $error;
		if (is_numeric($code)) {
			http_response_code($code);
		}
	}

	/**
	 * Set exception error to send.
	 *
	 * @param Throwable $e

Should the type for parameter $e not be \Throwable?

	 *
	 * @return void
	 */
	public function setException(\Throwable $e): void
	{
		$reasonPhrase = \App\Language::translate('ERR_OCCURRED_ERROR');
		$message = $e->getMessage();
		$error = [
			'message' => $reasonPhrase,
			'code' => $e->getCode(),
		];
		if (\Conf\Config::$displayTrackingException) {
			$error['message'] = (Config::get('displayDetailsException') || 0 === strpos($message, 'ERR_')) ? $message : \App\Language::translate('ERR_OCCURRED_ERROR');
		}
		if (\Conf\Config::$displayTrackingException) {
			$error['trace'] = str_replace(ROOT_DIRECTORY . \DIRECTORY_SEPARATOR, '', $e->getTraceAsString());
		}
		$this->setHeader($_SERVER['SERVER_PROTOCOL'] . ' ' . $e->getCode() . ' ' . str_ireplace(["\r\n", "\r", "\n"], ' ', $reasonPhrase));
		$this->error = $error;
		http_response_code($e->getCode());
	}

	/**
	 * Check the presence of error data.
	 */
	public function hasError()
	{
		return null !== $this->error;
	}

	/**
	 * Update the result data.
	 *
	 * @param mixed $key
	 * @param mixed $value
	 */
	public function updateResult($key, $value)
	{
		$this->result[$key] = $value;
	}

	/**
	 * Get the result data.
	 */
	public function getResult()
	{
		return $this->result;
	}

	/**
	 * Set the result data.
	 *
	 * @param mixed $result
	 */
	public function setResult($result)
	{
		$this->result = $result;
	}

	/**
	 * Send response to client.
	 */
	public function emit()
	{
		$contentTypeSent = false;
		foreach ($this->headers as $header) {
			if (!$contentTypeSent && 0 === stripos($header, 'content-type')) {
				$contentTypeSent = true;
			}
			header($header);
		}

		// Set right charset (UTF-8) to avoid IE complaining about c00ce56e error
		if ($this->emitType == self::$EMIT_JSON) {
			if (!$contentTypeSent) {
				header('Content-type: text/json; charset=UTF-8');
			}
			$this->emitJSON();
		} elseif ($this->emitType == self::$EMIT_JSONTEXT) {
			if (!$contentTypeSent) {
				header('Content-type: text/json; charset=UTF-8');
			}
			$this->emitText();
		} elseif ($this->emitType == self::$EMIT_HTML) {
			if (!$contentTypeSent) {
				header('Content-type: text/html; charset=UTF-8');
			}
			$this->emitRaw();
		} elseif ($this->emitType == self::$EMIT_RAW) {
			if (!$contentTypeSent) {
				header('Content-type: text/plain; charset=UTF-8');
			}
			$this->emitRaw();
		} elseif ($this->emitType == self::$EMIT_JSONP) {
			if (!$contentTypeSent) {
				header('Content-type: application/javascript; charset=UTF-8');
			}
			echo $this->emitJSONPFn . '(';
			$this->emitJSON();
			echo ')';
		}
	}

	/**
	 * Emit response wrapper as JSONString.
	 */
	protected function emitJSON()
	{
		echo Json::encode($this->prepareResponse());
	}

	/**
	 * Prepare the response wrapper.
	 */
	protected function prepareResponse()
	{
		$response = [];
		if (null !== $this->error) {
			$response['success'] = false;
			$response['error'] = $this->error;
		} else {
			$response['success'] = true;
			$response['result'] = $this->result;
		}
		return $response;
	}

	/**
	 * Emit response wrapper as String/JSONString.
	 */
	protected function emitText()
	{
		if (null === $this->result) {
			if (\is_string($this->error)) {
				echo $this->error;
			} else {
				echo Json::encode($this->prepareResponse());
			}
		} else {
			if (\is_string($this->result)) {
				echo $this->result;
			} else {
				echo Json::encode($this->prepareResponse());
			}
		}
	}

	/**
	 * Emit response wrapper as String.
	 */
	protected function emitRaw()
	{
		if (null === $this->result) {
			echo (\is_string($this->error)) ? $this->error : var_export($this->error, true);
		}
		echo $this->result;
	}
}