Huntie\JsonApi\Http\Controllers\JsonApiController

Complexity

Total Complexity

36

Size/Duplication

Total Lines	310
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	17

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	indexAction()	0	20	4
A	storeAction()	0	10	2
A	showAction()	0	8	1
A	updateAction()	0	12	2
A	destroyAction()	0	7	1
A	updateToOneRelationshipAction()	0	13	1
B	updateToManyRelationshipAction()	0	29	6
A	findModelInstance()	0	12	3
A	getRequestParameters()	0	15	4
A	getRequestQuerySet()	0	17	3
B	validateIncludableRelations()	0	12	5
A	showRelationshipAction()	0	6	1

<?php

namespace Huntie\JsonApi\Http\Controllers;

use Validator;
use Huntie\JsonApi\Contracts\Model\IncludesRelatedResources;
use Huntie\JsonApi\Exceptions\HttpException;
use Huntie\JsonApi\Exceptions\InvalidRelationPathException;
use Huntie\JsonApi\Http\JsonApiResponse;
use Huntie\JsonApi\Http\Concerns\QueriesResources;
use Huntie\JsonApi\Http\Concerns\UpdatesModelRelations;
use Huntie\JsonApi\Serializers\CollectionSerializer;
use Huntie\JsonApi\Serializers\RelationshipSerializer;
use Huntie\JsonApi\Serializers\ResourceSerializer;
use Huntie\JsonApi\Support\JsonApiErrors;
use Illuminate\Database\QueryException;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Routing\Controller;
use Illuminate\Validation\ValidationException;

abstract class JsonApiController extends Controller
{
    use JsonApiErrors;
    use QueriesResources;
    use UpdatesModelRelations;
    use AuthorizesRequests;
    use ValidatesRequests;

    /**
     * The Eloquent Model for the resource.
     *
     * @var Model|string
     */
    protected $model;

    /**
     * Create a new JsonApiController instance.
     */
    public function __construct()
    {
        if (is_string($this->model)) {
            if (!is_subclass_of($this->model, Model::class)) {
                $this->model = str_finish(config('jsonapi.model_namespace', app()->getNamespace()), '\\')
                    . preg_replace('/Controller$/', '', class_basename($this));
            }

            $this->model = new $this->model;
        }
    }

    /**
     * Return a listing of the resource.
     *
     * @param Request                                    $request
     * @param \Illuminate\Database\Eloquent\Builder|null $query   Custom resource query
     *
     * @return JsonApiResponse
     */
    public function indexAction(Request $request, $query = null)
    {
        $records = $query ?: $this->model->newQuery();
        $params = $this->getRequestParameters($request);
        $this->validateIncludableRelations($params['include']);

        $records = $this->sortQuery($records, $params['sort']);
        $records = $this->filterQuery($records, $params['filter']);

        try {
            $pageSize = min($this->model->getPerPage(), $request->input('page.size'));
            $pageNumber = $request->input('page.number') ?: 1;

            $records = $records->paginate($pageSize, null, 'page', $pageNumber);

null is of type null, but the function expects a array.

        } catch (QueryException $e) {
            return $this->error(Response::HTTP_BAD_REQUEST, 'Invalid query parameters');
        }

        return new JsonApiResponse(new CollectionSerializer($records, $params['fields'], $params['include']));
    }

    /**
     * Store a new record.
     *
     * @param Request $request
     *
     * @return JsonApiResponse
     */
    public function storeAction(Request $request)
    {
        $record = $this->model->create((array) $request->input('data.attributes'));

        if ($relationships = $request->input('data.relationships')) {
            $this->updateResourceRelationships($record, (array) $relationships);
        }

        return new JsonApiResponse(new ResourceSerializer($record), Response::HTTP_CREATED);
    }

    /**
     * Return a specified record.
     *
     * @param Request     $request
     * @param Model|mixed $record
     *
     * @return JsonApiResponse
     */
    public function showAction(Request $request, $record)
    {
        $record = $this->findModelInstance($record);
        $params = $this->getRequestParameters($request);
        $this->validateIncludableRelations($params['include']);

        return new JsonApiResponse(new ResourceSerializer($record, $params['fields'], $params['include']));
    }

    /**
     * Update a specified record.
     *
     * @param Request     $request
     * @param Model|mixed $record
     *
     * @return JsonApiResponse
     */
    public function updateAction(Request $request, $record)
    {
        $record = $this->findModelInstance($record);
        $record->fill((array) $request->input('data.attributes'));
        $record->save();

        if ($relationships = $request->input('data.relationships')) {
            $this->updateRecordRelationships($record, (array) $relationships);

The method updateRecordRelationships does not exist on object<Huntie\JsonApi\Http\Controllers\JsonApiController>? Since you implemented __call, maybe consider adding a @method annotation.

        }

        return new JsonApiResponse(new ResourceSerializer($record));
    }

    /**
     * Destroy a specified record.
     *
     * @param Request     $request
     * @param Model|mixed $record
     *
     * @return JsonApiResponse
     */
    public function destroyAction(Request $request, $record)

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

    {
        $record = $this->findModelInstance($record);
        $record->delete();

        return new JsonApiResponse(null, Response::HTTP_NO_CONTENT);
    }

    /**
     * Return a specified record relationship.
     *
     * @param Request     $request
     * @param Model|mixed $record
     * @param string      $relation
     *
     * @return JsonApiResponse
     */
    public function showRelationshipAction(Request $request, $record, $relation)

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

    {
        $record = $this->findModelInstance($record);

        return new JsonApiResponse(new RelationshipSerializer($record, $relation));
    }

    /**
     * Update a named many-to-one relationship association on a specified record.
     * http://jsonapi.org/format/#crud-updating-to-one-relationships
     *
     * @param Request     $request
     * @param Model|mixed $record
     * @param string      $relation
     *
     * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     *
     * @return JsonApiResponse
     */
    public function updateToOneRelationshipAction(Request $request, $record, $relation)
    {
        abort_unless($this->isFillableRelation($relation), Response::HTTP_NOT_FOUND);

        $record = $this->findModelInstance($record);
        $relation = $this->getModelRelationships()[$relation];

The method getModelRelationships does not exist on object<Huntie\JsonApi\Http\Controllers\JsonApiController>? Since you implemented __call, maybe consider adding a @method annotation.

        $data = (array) $request->input('data');

        $record->{$relation->getForeignKey()} = $data['id'];
        $record->save();

        return new JsonApiResponse(new RelationshipSerializer($record, $relation));
    }

    /**
     * Update named many-to-many relationship entries on a specified record.
     * http://jsonapi.org/format/#crud-updating-to-many-relationships
     *
     * @param Request     $request
     * @param Model|mixed $record
     * @param string      $relation
     *
     * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     *
     * @return JsonApiResponse
     */
    public function updateToManyRelationshipAction(Request $request, $record, $relation)
    {
        abort_unless($this->isFillableRelation($relation), Response::HTTP_NOT_FOUND);

        $record = $this->findModelInstance($record);
        $relationships = (array) $request->input('data');
        $items = [];

        foreach ($relationships as $item) {
            if (isset($item['attributes'])) {
                $items[$item['id']] = $item['attributes'];
            } else {
                $items[] = $item['id'];
            }
        }

        switch ($request->method()) {
            case 'PATCH':
                $record->{$relation}()->sync($items);
                break;
            case 'POST':
                $record->{$relation}()->sync($items, false);
                break;
            case 'DELETE':
                $record->{$relation}()->detach(array_keys($items));
        }

        return new JsonApiResponse(new RelationshipSerializer($record, $relation));
    }

    /**
     * Return existing instance of the resource or find by primary key.
     *
     * @param Model|mixed $record
     *
     * @throws ModelNotFoundException
     *
     * @return Model
     */
    protected function findModelInstance($record)
    {
        if ($record instanceof Model) {
            if (is_null($record->getKey())) {
                throw new ModelNotFoundException();
            }

            return $record;
        }

        return $this->model->findOrFail($record);
    }

    /**
     * Return any JSON API resource parameters from a request.
     *
     * @param Request $request
     *
     * @return array
     */
    protected function getRequestParameters($request)
    {
        $enableIncluded = config('jsonapi.enable_included_resources');

        if ($request->has('include') && is_bool($enableIncluded) && !$enableIncluded) {
            throw new HttpException('Inclusion of related resources is not supported');
        }

        return [
            'fields' => $this->getRequestQuerySet($request, 'fields', '/^([A-Za-z]+.?)+[A-Za-z]+$/'),
            'include' => $this->getRequestQuerySet($request, 'include', '/^([A-Za-z]+.?)+[A-Za-z]+$/'),
            'sort' => $this->getRequestQuerySet($request, 'sort', '/[A-Za-z_]+/'),
            'filter' => (array) $request->input('filter'),
        ];
    }

    /**
     * Return any comma separated values in a request query field as an array.
     *
     * @param Request     $request
     * @param string      $key
     * @param string|null $validate Regular expression to test for each item
     *
     * @throws \Illuminate\Validation\ValidationException
     *
     * @return array
     */
    protected function getRequestQuerySet($request, $key, $validate = null)
    {
        $values = preg_split('/,/', $request->input($key), null, PREG_SPLIT_NO_EMPTY);

        $validator = Validator::make(['param' => $values], [
            'param.*' => 'required' . ($validate ? '|regex:' . $validate : ''),
        ]);

        if ($validator->fails()) {
            throw new ValidationException($validator, $this->error(
                Response::HTTP_BAD_REQUEST,
                sprintf('Invalid values for "%s" parameter', $key))
            );
        }

        return $values;
    }

    /**
     * Validate the requested included relationships against those that are
     * allowed on the requested resource type.
     *
     * @param array|null $relations
     *
     * @throws InvalidRelationPathException
     */
    protected function validateIncludableRelations($relations)
    {
        if (is_null($relations)) {
            return;
        }

        foreach ($relations as $relation) {
            if (!$this->model instanceof IncludesRelatedResources || !in_array($relation, $this->model->getIncludableRelations())) {

This line exceeds maximum limit of 120 characters; contains 132 characters

                throw new InvalidRelationPathException($relation);
            }
        }
    }
}