Ps2alerts\Api\Controller\Endpoint\AbstractEndpointController

Complexity

Total Complexity

30

Size/Duplication

Total Lines	352
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes	11
Bugs	2	Features	4

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getStatusCode()	0	4	1
A	setStatusCode()	0	5	1
A	respond()	0	13	3
A	respondWithItem()	0	4	1
A	createItem()	0	7	1
A	respondWithCollection()	0	4	1
A	createCollection()	0	7	1
A	respondWithArray()	0	9	1
A	respondWithError()	0	18	2
A	errorEmpty()	0	5	1
A	errorForbidden()	0	5	1
A	errorInternalError()	0	5	1
A	errorNotFound()	0	5	1
A	errorUnauthorized()	0	5	1
A	errorWrongArgs()	0	5	1
A	getIncludesFromRequest()	0	8	2
D	getFiltersFromQueryString()	0	45	10

<?php

namespace Ps2alerts\Api\Controller\Endpoint;

use League\Fractal\Resource\Collection;
use League\Fractal\Resource\Item;
use Ps2alerts\Api\Contract\ConfigAwareInterface;
use Ps2alerts\Api\Contract\ConfigAwareTrait;
use Ps2alerts\Api\Contract\DatabaseAwareInterface;
use Ps2alerts\Api\Contract\DatabaseAwareTrait;
use Ps2alerts\Api\Exception\InvalidArgumentException;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

abstract class AbstractEndpointController implements
    ConfigAwareInterface,
    DatabaseAwareInterface
{
    use ConfigAwareTrait;
    use DatabaseAwareTrait;

    /**
     * Contains the repository used for interfacing with the database
     *
     * @var \Ps2alerts\Api\Repository\AbstractEndpointRepository
     */
    protected $repository;

    /**
     * Stores the status code
     *
     * @var integer
     */
    protected $statusCode = 200;

    /**
     * Holds Fractal
     *
     * @var \League\Fractal\Manager
     */
    protected $fractal;

    /**
     * Holds the transformer we're going to use
     *
     * @var mixed|\Leage\Fractal\TransformerAbstract
     */
    protected $transformer;

    const CODE_WRONG_ARGS     = 'API-MALFORMED-REQUEST';
    const CODE_NOT_FOUND      = 'API-NOT-FOUND';
    const CODE_INTERNAL_ERROR = 'API-DOH';
    const CODE_UNAUTHORIZED   = 'API-UNAUTHORIZED';
    const CODE_FORBIDDEN      = 'API-DENIED';
    const CODE_EMPTY          = 'API-EMPTY';

    /**
     * Getter for statusCode
     *
     * @return int
     */
    public function getStatusCode()
    {
        return $this->statusCode;
    }

    /**
     * Setter for statusCode
     *
     * @param int $statusCode Value to set
     *
     * @return self
     */
    public function setStatusCode($statusCode)
    {
        $this->statusCode = $statusCode;
        return $this;
    }

    /**
     * Master function to split out appropiate calls
     *
     * @param  string                                     $kind     The kind of data we wish to return
     * @param  array                                      $data     The data itself
     * @param  \League\Fractal\TransformerAbstract        $callback The transformer class to call
     * @param  \Symfony\Component\HttpFoundation\Request  $request  The request itself
     * @param  \Symfony\Component\HttpFoundation\Response $response The response object to eventually call
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function respond($kind, $data, $callback, Request $request, Response $response)
    {
        // Detect what embeds we need
        $this->getIncludesFromRequest($request);
        switch ($kind) {
            case 'item':
                return $this->respondWithItem($data, $callback, $response);
            case 'collection':
                return $this->respondWithCollection($data, $callback, $response);
            default:
                return $this->errorInternalError('No Response was defined. Please report this.');

'No Response was defined. Please report this.' is of type string, but the function expects a object<Symfony\Component\HttpFoundation\Response>.

        }
    }

    /**
     * Builds an item response in Fractal then hands off to the responder
     *
     * @param  array                                      $item     The item to transform
     * @param  \League\Fractal\TransformerAbstract        $transformer The Transformer to pass through to Fractal
     * @param  \Symfony\Component\HttpFoundation\Response $response The client's response
     *
     * @return array
     */
    protected function respondWithItem($item, $transformer, Response $response)
    {
        return $this->respondWithArray($response, $this->createItem($item, $transformer));
    }

    /**
     * Creates the item array and returns it hence it came.
     *
     * @param  array                               $item     The data to parse
     * @param  \League\Fractal\TransformerAbstract $transformer
     *
     * @return array
     */
    public function createItem($item, $transformer)
    {
        $resource = new Item($item, $transformer);
        $rootScope = $this->fractal->createData($resource);

        return $rootScope->toArray();
    }

    /**
     * Builds a collection of items from Fractal then hands off to the responder
     *
     * @param  array                                      $collection  The collection to transform
     * @param  \League\Fractal\TransformerAbstract        $transformer The Transformer to pass through to Fractal
     * @param  \Symfony\Component\HttpFoundation\Response $response    The client's response
     *
     * @return array
     */
    protected function respondWithCollection($collection, $transformer, Response $response)
    {
        return $this->respondWithArray($response, $this->createCollection($collection, $transformer));
    }

    /**
     * Creates a collection array and sends it back to hence it came.
     *
     * @param  array                               $collection
     * @param  \League\Fractal\TransformerAbstract $transformer
     *
     * @return array
     */
    public function createCollection($collection, $transformer)
    {
        $resource = new Collection($collection, $transformer);
        $rootScope = $this->fractal->createData($resource);

        return $rootScope->toArray();
    }

    /**
     * The final step where the formatted array is now sent back as a response in JSON form
     *
     * @param  \Symfony\Component\HttpFoundation\Response $response
     * @param  array                                      $array
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function respondWithArray(Response $response, array $array)
    {
        $response->setStatusCode($this->getStatusCode());
        $response->setContent(json_encode($array));
        $response->headers->set('Content-Type', 'application/json');

        // This is the end of the road. FIRE ZE RESPONSE!
        return $response;
    }

    /**
     * Responds gracefully with an error.
     *
     * @param  \Symfony\Component\HttpFoundation\Response $response
     * @param  string                                     $message   Response message to put in the error
     * @param  int                                        $errorCode Error code to set
     *
     * @return array
     */
    protected function respondWithError(Response $response, $message, $errorCode)
    {
        if ($this->statusCode === 200) {
            trigger_error(
                "This Error code 200 should never be sent. Please report this to the developer.",
                E_USER_WARNING
            );
        }

        // Pass to responder
        return $this->respondWithArray($response, [
            'error' => [
                'code'      => $errorCode,
                'http_code' => $this->statusCode,
                'message'   => $message,
            ]
        ]);
    }

    /**
     * Generates a response with a 404 HTTP error and a given message.
     *
     * @param  \Symfony\Component\HttpFoundation\Response $response
     * @param  string                                     $message
     *
     * @return void
     */
    public function errorEmpty(Response $response, $message = 'No data / Empty')
    {
        return $this->setStatusCode(404)
                    ->respondWithError($response, $message, self::CODE_EMPTY);
    }

    /**
     * Generates a Response with a 403 HTTP header and a given message.
     *
     * @param  \Symfony\Component\HttpFoundation\Response $response
     * @param  string                                     $message
     *
     * @return void
     */
    public function errorForbidden(Response $response, $message = 'Forbidden')
    {
        return $this->setStatusCode(403)
                    ->respondWithError($response, $message, self::CODE_FORBIDDEN);
    }

    /**
     * Generates a Response with a 500 HTTP header and a given message.
     *
     * @param  \Symfony\Component\HttpFoundation\Response $response
     * @param  string                                     $message
     *
     * @return void
     */
    public function errorInternalError(Response $response, $message = 'Internal Error')
    {
        return $this->setStatusCode(500)
                    ->respondWithError($response, $message, self::CODE_INTERNAL_ERROR);
    }

    /**
     * Generates a Response with a 404 HTTP header and a given message.
     *
     * @param  \Symfony\Component\HttpFoundation\Response $response
     * @param  string                                     $message
     *
     * @return void
     */
    public function errorNotFound(Response $response, $message = 'Resource Not Found')
    {
        return $this->setStatusCode(404)
                    ->respondWithError($response, $message, self::CODE_NOT_FOUND);
    }

    /**
     * Generates a Response with a 401 HTTP header and a given message.
     *
     * @param  \Symfony\Component\HttpFoundation\Response $response
     * @param  string                                     $message
     *
     * @return void
     */
    public function errorUnauthorized(Response $response, $message = 'Unauthorized')
    {
        return $this->setStatusCode(401)
                    ->respondWithError($response, $message, self::CODE_UNAUTHORIZED);
    }

    /**
     * Generates a Response with a 400 HTTP header and a given message.
     *
     * @param \Symfony\Component\HttpFoundation\Response $response
     * @param string                                     $message
     *
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function errorWrongArgs(Response $response, $message = 'Wrong Arguments')
    {
        return $this->setStatusCode(400)
                    ->respondWithError($response, $message, self::CODE_WRONG_ARGS);
    }

    /**
     * Reads any requested includes and adds them to the item / collection
     *
     * @param  Symfony\Component\HttpFoundation\Request $request
     *
     * @return void
     */
    public function getIncludesFromRequest(Request $request)
    {
        $queryString = $request->query->get('embed');

        if (! empty($queryString)) {
            $this->fractal->parseIncludes($request->query->get('embed'));
        }
    }

    /**
     * Gets the Server or Zone filters and runs a check to make sure the request validates. Also formats the list
     * correctly for inclusion in query strings.
     *
     * @param  string                                     $queryString
     * @param  string                                     $mode
     * @param  \Symfony\Component\HttpFoundation\Response $response
     *
     * @return string
     */
    public function getFiltersFromQueryString($queryString, $mode, $response)

The parameter $response is not used and could be removed.

    {
        $filters = $this->getConfigItem($mode);
        $numericals = ['servers', 'zones'];
        $strings = ['factions', 'brackets'];

        if (! empty($queryString)) {
            $check = explode(',', $queryString);

            // Run a check on the IDs provided to make sure they're valid and no naughty things are being passed
            foreach ($check as $id) {
                // If the query string should contain only numbers
                if (in_array($mode, $numericals)) {
                    if (! is_numeric($id)) {
                        throw new InvalidArgumentException("Non numerical ID detected. Only numerical IDs are accepted with this request.");
                    }
                }
                if (in_array($mode, $strings)) {
                    if (is_numeric($id)) {
                        throw new InvalidArgumentException("Numerical input detected. Only string inputs are accepted with this request.");
                    }
                }

                if (! in_array($id, $filters)) {
                    throw new InvalidArgumentException("Unrecognized {$mode}. Please check the IDs you sent.");
                }
            }

            // Format into strings comma seperated for SQL
            if (in_array($mode, $strings)) {
                $queryString = "'" . implode("','", $check) . "'";
            }

            return $queryString;
        }

        $return = implode(',', $filters);

        if (in_array($mode, $strings)) {
            $return = "'" . implode("','", $filters) . "'";
        }

        // If no string was provided, returns all data encoded as a comma seperated string
        return $return;
    }
}