ResponseModel::isEmptyResponse() - Code Metrics - Inspection of "- Minor updates" - MediaMonks/symfony-rest-api-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ec8ea2...b05dbd )

by Robert

created 2016-03-09 12:44 UTC

ResponseModel::isEmptyResponse() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace MediaMonks\RestApiBundle\Model;

use MediaMonks\RestApiBundle\Exception\AbstractValidationException;
use MediaMonks\RestApiBundle\Exception\ExceptionInterface;
use MediaMonks\RestApiBundle\Response\Error;
use MediaMonks\RestApiBundle\Response\PaginatedResponseInterface;
use MediaMonks\RestApiBundle\Util\StringUtil;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\HttpException;

class ResponseModel
{
    const EXCEPTION_GENERAL = 'Exception';
    const EXCEPTION_HTTP = 'HttpException';

    /**
     * @var int
     */
    protected $statusCode = Response::HTTP_OK;

    /**
     * @var bool
     */
    protected $returnStatusCode = false;

    /**
     * @var mixed
     */
    protected $data;

    /**
     * @var Response
     */
    protected $response;

    /**
     * @var \Exception
     */
    protected $exception;

    /**
     * @var PaginatedResponseInterface
     */
    protected $pagination;

    /**
     * @return int
     */
    public function getStatusCode()
    {
        if (isset($this->response)) {
            return $this->response->getStatusCode();
        }
        if (isset($this->exception)) {
            return $this->getExceptionStatusCode();
        }
        if ($this->isEmpty()) {
            return Response::HTTP_NO_CONTENT;
        }

        return $this->statusCode;
    }

    /**
     * @return int
     */
    protected function getExceptionStatusCode()
    {
        if ($this->exception instanceof HttpException) {
            return $this->exception->getStatusCode();
        } elseif ($this->exception instanceof AbstractValidationException) {
            return Response::HTTP_BAD_REQUEST;
        } elseif ($this->isValidHttpStatusCode($this->exception->getCode())) {
            return $this->exception->getCode();
        }
        return Response::HTTP_INTERNAL_SERVER_ERROR;
    }

    /**
     * @param int $code
     * @return bool
     */
    protected function isValidHttpStatusCode($code)
    {
        return array_key_exists($code, Response::$statusTexts) && $code >= Response::HTTP_BAD_REQUEST;
    }

    /**
     * @param int $statusCode
     * @return $this
     */
    public function setStatusCode($statusCode)
    {
        $this->statusCode = $statusCode;

        return $this;
    }

    /**
     * @return bool
     */
    public function getReturnStatusCode()
    {
        return $this->returnStatusCode;
    }

    /**
     * @param bool $returnStatusCode
     * @return $this
     */
    public function setReturnStatusCode($returnStatusCode)
    {
        $this->returnStatusCode = $returnStatusCode;

        return $this;
    }

    /**
     * @return mixed
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * @param mixed $data
     * @return $this
     */
    public function setData($data)
    {
        $this->data = $data;

        return $this;
    }

    /**
     * @return \Exception
     */
    public function getException()
    {
        return $this->exception;
    }

    /**
     * @param \Exception $exception
     * @return $this
     */
    public function setException(\Exception $exception)
    {
        $this->exception = $exception;

        return $this;
    }

    /**
     * @return array
     */
    public function getPagination()
    {
        return $this->pagination;
    }

    /**
     * @param PaginatedResponseInterface $pagination
     * @return $this
     */
    public function setPagination(PaginatedResponseInterface $pagination)
    {
        $this->pagination = $pagination;
        $this->setData($pagination->getData());

        return $this;
    }

    /**
     * @return Response
     */
    public function getResponse()
    {
        return $this->response;
    }

    /**
     * @param Response $response
     * @return ResponseModel
     */
    public function setResponse(Response $response)
    {
        $this->response = $response;
        $this->setStatusCode($response->getStatusCode());
        $this->setData($response->getContent());

        return $this;
    }

    /**
     * @return array
     */
    public function toArray()
    {
        $return = [];
        if ($this->getReturnStatusCode()) {
            $return['statusCode'] = $this->getStatusCode();
        }
        if (isset($this->exception)) {
            $return['error'] = $this->exceptionToArray();
        } elseif (isset($this->response) && $this->response instanceof RedirectResponse) {
            $return['location'] = $this->response->headers->get('Location');
        } else {
            $return += $this->dataToArray();
        }
        return $return;
    }

    /**
     * @return array
     */
    protected function dataToArray()
    {
        $return = [];
        if (isset($this->data)) {
            $return['data'] = $this->data;
            if (isset($this->pagination)) {
                $return['pagination'] = $this->pagination->toArray();
            }
        }
        return $return;
    }

    /**
     * @return array
     */
    protected function exceptionToArray()
    {
        if ($this->exception instanceof ExceptionInterface) {
            return $this->exception->toArray();
        } elseif ($this->exception instanceof HttpException) {
            return $this->httpExceptionToArray();
        }

        return $this->generalExceptionToArray();
    }

    /**
     * @return array
     */
    protected function httpExceptionToArray()
    {
        return [
            'code'    => $this->getExceptionErrorCode(Error::CODE_HTTP, self::EXCEPTION_HTTP),
            'message' => $this->exception->getMessage()
        ];
    }

    /**
     * @return array
     */
    protected function generalExceptionToArray()
    {
        return [
            'code'    => trim($this->getExceptionErrorCode(Error::CODE_GENERAL, self::EXCEPTION_GENERAL), '.'),
            'message' => $this->exception->getMessage()
        ];
    }

    /**
     * @param string $errorCode
     * @param string $trim
     * @return string
     */
    protected function getExceptionErrorCode($errorCode, $trim = null)
    {
        return sprintf($errorCode, StringUtil::classToSnakeCase($this->exception, $trim));
    }

    /**
     * @return bool
     */
    public function isEmpty()
    {
        return (
            !isset($this->exception)
            && is_null($this->data)
            && !isset($this->pagination)
            && $this->isEmptyResponse()
        );
    }

    /**
     * @return bool
     */
    protected function isEmptyResponse()
    {
        return !isset($this->response) || $this->response->isEmpty();
    }

    // @codeCoverageIgnoreStart
    /**
     * This is called when an exception is thrown during the response transformation
     *
     * @return string
     */
    public function __toString()
    {
        $data                  = $this->toArray();
        $data['error']['code'] = Error::CODE_REST_API_BUNDLE;

        return json_encode($data);
    }
    // @codeCoverageIgnoreEnd
}


1		<?php
2
3		namespace MediaMonks\RestApiBundle\Model;
4
5		use MediaMonks\RestApiBundle\Exception\AbstractValidationException;
6		use MediaMonks\RestApiBundle\Exception\ExceptionInterface;
7		use MediaMonks\RestApiBundle\Response\Error;
8		use MediaMonks\RestApiBundle\Response\PaginatedResponseInterface;
9		use MediaMonks\RestApiBundle\Util\StringUtil;
10		use Symfony\Component\HttpFoundation\RedirectResponse;
11		use Symfony\Component\HttpFoundation\Response;
12		use Symfony\Component\HttpKernel\Exception\HttpException;
13
14		class ResponseModel
15		{
16		const EXCEPTION_GENERAL = 'Exception';
17		const EXCEPTION_HTTP = 'HttpException';
18
19		/**
20		* @var int
21		*/
22		protected $statusCode = Response::HTTP_OK;
23
24		/**
25		* @var bool
26		*/
27		protected $returnStatusCode = false;
28
29		/**
30		* @var mixed
31		*/
32		protected $data;
33
34		/**
35		* @var Response
36		*/
37		protected $response;
38
39		/**
40		* @var \Exception
41		*/
42		protected $exception;
43
44		/**
45		* @var PaginatedResponseInterface
46		*/
47		protected $pagination;
48
49		/**
50		* @return int
51		*/
52	32	public function getStatusCode()
53		{
54	32	if (isset($this->response)) {
55	6	return $this->response->getStatusCode();
56		}
57	26	if (isset($this->exception)) {
58	13	return $this->getExceptionStatusCode();
59		}
60	13	if ($this->isEmpty()) {
61	2	return Response::HTTP_NO_CONTENT;
62		}
63
64	11	return $this->statusCode;
65		}
66
67		/**
68		* @return int
69		*/
70	13	protected function getExceptionStatusCode()
71		{
72	13	if ($this->exception instanceof HttpException) {
73	4	return $this->exception->getStatusCode();
74	9	} elseif ($this->exception instanceof AbstractValidationException) {
75	4	return Response::HTTP_BAD_REQUEST;
76	5	} elseif ($this->isValidHttpStatusCode($this->exception->getCode())) {
77	2	return $this->exception->getCode();
78		}
79	3	return Response::HTTP_INTERNAL_SERVER_ERROR;
80		}
81
82		/**
83		* @param int $code
84		* @return bool
85		*/
86	5	protected function isValidHttpStatusCode($code)
87		{
88	5	return array_key_exists($code, Response::$statusTexts) && $code >= Response::HTTP_BAD_REQUEST;
89		}
90
91		/**
92		* @param int $statusCode
93		* @return $this
94		*/
95	9	public function setStatusCode($statusCode)
96		{
97	9	$this->statusCode = $statusCode;
98
99	9	return $this;
100		}
101
102		/**
103		* @return bool
104		*/
105	26	public function getReturnStatusCode()
106		{
107	26	return $this->returnStatusCode;
108		}
109
110		/**
111		* @param bool $returnStatusCode
112		* @return $this
113		*/
114	2	public function setReturnStatusCode($returnStatusCode)
115		{
116	2	$this->returnStatusCode = $returnStatusCode;
117
118	2	return $this;
119		}
120
121		/**
122		* @return mixed
123		*/
124	10	public function getData()
125		{
126	10	return $this->data;
127		}
128
129		/**
130		* @param mixed $data
131		* @return $this
132		*/
133	24	public function setData($data)
134		{
135	24	$this->data = $data;
136
137	24	return $this;
138		}
139
140		/**
141		* @return \Exception
142		*/
143	11	public function getException()
144		{
145	11	return $this->exception;
146		}
147
148		/**
149		* @param \Exception $exception
150		* @return $this
151		*/
152	15	public function setException(\Exception $exception)
153		{
154	15	$this->exception = $exception;
155
156	15	return $this;
157		}
158
159		/**
160		* @return array
161		*/
162	11	public function getPagination()
163		{
164	11	return $this->pagination;
165		}
166
167		/**
168		* @param PaginatedResponseInterface $pagination
169		* @return $this
170		*/
171	4	public function setPagination(PaginatedResponseInterface $pagination)
172		{
173	4	$this->pagination = $pagination;
174	4	$this->setData($pagination->getData());
175
176	4	return $this;
177		}
178
179		/**
180		* @return Response
181		*/
182	11	public function getResponse()
183		{
184	11	return $this->response;
185		}
186
187		/**
188		* @param Response $response
189		* @return ResponseModel
190		*/
191	7	public function setResponse(Response $response)
192		{
193	7	$this->response = $response;
194	7	$this->setStatusCode($response->getStatusCode());
195	7	$this->setData($response->getContent());
196
197	7	return $this;
198		}
199
200		/**
201		* @return array
202		*/
203	25	public function toArray()
204		{
205	25	$return = [];
206	25	if ($this->getReturnStatusCode()) {
207	1	$return['statusCode'] = $this->getStatusCode();
208	1	}
209	25	if (isset($this->exception)) {
210	12	$return['error'] = $this->exceptionToArray();
211	25	} elseif (isset($this->response) && $this->response instanceof RedirectResponse) {
212	2	$return['location'] = $this->response->headers->get('Location');
213	2	} else {
214	11	$return += $this->dataToArray();
215		}
216	25	return $return;
217		}
218
219		/**
220		* @return array
221		*/
222	11	protected function dataToArray()
223		{
224	11	$return = [];
225	11	if (isset($this->data)) {
226	10	$return['data'] = $this->data;
227	10	if (isset($this->pagination)) {
228	3	$return['pagination'] = $this->pagination->toArray();
229	3	}
230	10	}
231	11	return $return;
232		}
233
234		/**
235		* @return array
236		*/
237	12	protected function exceptionToArray()
238		{
239	12	if ($this->exception instanceof ExceptionInterface) {
240	4	return $this->exception->toArray();
241	8	} elseif ($this->exception instanceof HttpException) {
242	4	return $this->httpExceptionToArray();
243		}
244
245	4	return $this->generalExceptionToArray();
246		}
247
248		/**
249		* @return array
250		*/
251	4	protected function httpExceptionToArray()
252		{
253		return [
254	4	'code' => $this->getExceptionErrorCode(Error::CODE_HTTP, self::EXCEPTION_HTTP),
255	4	'message' => $this->exception->getMessage()
256	4	];
257		}
258
259		/**
260		* @return array
261		*/
262	4	protected function generalExceptionToArray()
263		{
264		return [
265	4	'code' => trim($this->getExceptionErrorCode(Error::CODE_GENERAL, self::EXCEPTION_GENERAL), '.'),
266	4	'message' => $this->exception->getMessage()
267	4	];
268		}
269
270		/**
271		* @param string $errorCode
272		* @param string $trim
273		* @return string
274		*/
275	8	protected function getExceptionErrorCode($errorCode, $trim = null)
276		{
277	8	return sprintf($errorCode, StringUtil::classToSnakeCase($this->exception, $trim));
278		}
279
280		/**
281		* @return bool
282		*/
283	19	public function isEmpty()
284		{
285		return (
286	19	!isset($this->exception)
287	19	&& is_null($this->data)
288	19	&& !isset($this->pagination)
289	19	&& $this->isEmptyResponse()
290	19	);
291		}
292
293		/**
294		* @return bool
295		*/
296	2	protected function isEmptyResponse()
297		{
298	2	return !isset($this->response) \|\| $this->response->isEmpty();
299		}
300
301		// @codeCoverageIgnoreStart
302		/**
303		* This is called when an exception is thrown during the response transformation
304		*
305		* @return string
306		*/
307		public function __toString()
308		{
309		$data = $this->toArray();
310		$data['error']['code'] = Error::CODE_REST_API_BUNDLE;
311
312		return json_encode($data);
313		}
314		// @codeCoverageIgnoreEnd
315		}
316

MediaMonks / symfony-rest-api-bundle

Push — master ( ec8ea2...b05dbd )

ResponseModel::isEmptyResponse() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like