CakeDC\Api\Service\Renderer\JSendRenderer

Complexity

Total Complexity

18

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

84.31%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	accept()	0	6	3
A	response()	0	18	2
A	error()	0	12	2
A	_format()	0	11	3
A	_success()	0	4	1
A	_fail()	0	4	1
A	_error()	0	13	2
A	_mapStatus()	0	9	4

<?php
/**
 * Copyright 2016 - 2018, Cake Development Corporation (http://cakedc.com)
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright 2016 - 2018, Cake Development Corporation (http://cakedc.com)
 * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
 */

namespace CakeDC\Api\Service\Renderer;

use CakeDC\Api\Exception\ValidationException;
use CakeDC\Api\Service\Action\Result;
use Cake\Core\Configure;
use Cake\Utility\Hash;
use Exception;
use stdClass;

/**
 * Class JSendRenderer
 * JSend content negotiation Renderer.
 *
 * @package CakeDC\Api\Service\Renderer
 */
class JSendRenderer extends BaseRenderer
{

    /**
     * Success status.
     */
    const STATUS_SUCCESS = 'success';

    /**
     * Fail status.
     */
    const STATUS_FAIL = 'fail';

    /**
     * Error status.
     */
    const STATUS_ERROR = 'error';

    /**
     * Response status.
     */
    public $status = self::STATUS_SUCCESS;

    /**
     * HTTP error code.
     */
    public $errorCode = 200;

    /**
     * Confirms if the specified content type is acceptable for the response.
     *
     * @return bool
     */
    public function accept()
    {
        $request = $this->_service->getRequest();

        return ($request->accepts('application/json') || $request->accepts('text/json') || $request->accepts('text/javascript'));
    }

    /**
     * Builds the HTTP response.
     *
     * @param Result $result The result object returned by the Service.
     * @return bool
     */
    public function response(Result $result = null)
    {
        $response = $this->_service->getResponse();

        $data = $result->getData();

It seems like $result is not always an object, but can also be of type null. Maybe add an additional type check?

        $payload = $result->getPayload();
        $return = [
            'data' => $data
        ];
        if (is_array($payload)) {
            $return = Hash::merge($return, $payload);
        }
        $this->_mapStatus($result);

It seems like $result defined by parameter $result on line 73 can be null; however, CakeDC\Api\Service\Renderer\JSendRenderer::_mapStatus() does not accept null, maybe add an additional type check?

        $this->_service->setResponse($response->withStringBody($this->_format($this->status, $return))->withStatus($result->getCode())->withType('application/json'));

        return true;
    }

    /**
     * Processes an exception thrown while processing the request.
     *
     * @param Exception $exception The exception object.
     * @return void
     */
    public function error(Exception $exception)
    {
        $response = $this->_service->getResponse();
        if ($exception instanceof ValidationException) {
            $data = $exception->getValidationErrors();
        } else {
            $data = null;
        }
        $message = $this->_buildMessage($exception);
        $trace = $this->_stackTrace($exception);
        $this->_service->setResponse($response->withStringBody($this->_error($message, $exception->getCode(), $data, $trace))->withStatus((int)$this->errorCode)->withType('application/json'));
    }

    /**
     * Formats a response to JSend specification.
     *
     * @param string $status The status of the response.
     * @param array $response The response properties.
     * @return string
     */
    protected function _format($status, $response = [])
    {
        $object = new stdClass();
        $object->status = $status;
        foreach ($response as $param => $value) {
            $object->{$param} = $value;
        }
        $format = Configure::read('debug') ? JSON_PRETTY_PRINT : 0;

        return json_encode($object, $format);
    }

    /**
     * Creates a successful response.
     *
     * @param array $data The response data object.
     * @return string
     */
    protected function _success($data = null)
    {
        return $this->_format(self::STATUS_SUCCESS, ['data' => $data]);
    }

    /**
     * Creates a failure response.
     *
     * @param array $data The response data object.
     * @return string
     */
    protected function _fail($data = null)
    {
        return $this->_format(self::STATUS_FAIL, ['data' => $data]);
    }

    /**
     * Creates an error response.
     *
     * @param string $message The error message.
     * @param int $code The error code.
     * @param array $data The response data object.
     * @param array $trace The exception trace
     * @return string
     */
    protected function _error($message = 'Unknown error', $code = 0, $data = null, $trace = null)
    {
        $response = [
            'message' => $message,
            'code' => $code,
            'data' => $data
        ];
        if (Configure::read('debug') > 0) {
            $response['trace'] = $trace;
        }

        return $this->_format(self::STATUS_ERROR, $response);
    }

    /**
     * Update status based on result code
     *
     * @param Result $result A result object instance.
     * @return void
     */
    protected function _mapStatus(Result $result)
    {
        $code = (int)$result->getCode();
        if ($code == 0 || $code >= 200 && $code <= 399) {
            $this->status = self::STATUS_SUCCESS;
        } else {
            $this->status = self::STATUS_ERROR;
        }
    }
}