Huntie\JsonApi\Http\Controllers\JsonApiController

Complexity

Total Complexity

25

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	indexAction()	0	19	4
A	storeAction()	0	10	2
A	showAction()	0	7	1
A	updateAction()	0	12	2
A	destroyAction()	0	7	1
A	showRelationshipAction()	0	6	1
A	updateRelationshipAction()	0	15	4
A	findModelInstance()	0	12	3
A	validateIncludableRelations()	0	8	4

<?php

namespace Huntie\JsonApi\Http\Controllers;

use Validator;
use Huntie\JsonApi\Contracts\Model\IncludesRelatedResources;
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\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 \Huntie\JsonApi\Http\Requests\JsonApiRequest $request
     * @param \Illuminate\Database\Eloquent\Builder|null   $query   Custom resource query
     *
     * @return JsonApiResponse
     */
    public function indexAction($request, $query = null)
    {
        $records = $query ?: $this->model->newQuery();
        $this->validateIncludableRelations($request->inputSet('include'));

        $records = $this->sortQuery($records, $request->inputSet('sort'));
        $records = $this->filterQuery($records, (array) $request->input('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, $request->inputSet('fields'), $request->inputSet('include')));

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

    }

    /**
     * Store a new record.
     *
     * @param \Huntie\JsonApi\Http\Requests\JsonApiRequest $request
     *
     * @return JsonApiResponse
     */
    public function storeAction($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 \Huntie\JsonApi\Http\Requests\JsonApiRequest $request
     * @param Model|mixed                                  $record
     *
     * @return JsonApiResponse
     */
    public function showAction($request, $record)
    {
        $record = $this->findModelInstance($record);
        $this->validateIncludableRelations($request->inputSet('include'));

        return new JsonApiResponse(new ResourceSerializer($record, $request->inputSet('fields'), $request->inputSet('include')));

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

    }

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

        if ($request->has('data.relationships')) {
            $this->updateRecordRelationships($record, (array) $request->input('data.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 \Huntie\JsonApi\Http\Requests\JsonApiRequest $request
     * @param Model|mixed                                  $record
     *
     * @return JsonApiResponse
     */
    public function destroyAction($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 \Huntie\JsonApi\Http\Requests\JsonApiRequest $request
     * @param Model|mixed                                  $record
     * @param string                                       $relation
     *
     * @return JsonApiResponse
     */
    public function showRelationshipAction($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 relationship on a specified record.
     *
     * http://jsonapi.org/format/#crud-updating-relationships
     *
     * @param \Huntie\JsonApi\Http\Requests\JsonApiRequest $request
     * @param Model|mixed                                  $record
     * @param string                                       $relation
     *
     * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     *
     * @return JsonApiResponse
     */
    public function updateRelationshipAction($request, $record, $relation)
    {
        $record = $this->findModelInstance($record);
        $relationType = $this->getRelationType($relation);

        abort_unless(is_string($relationType) && $this->isFillableRelation($relation), Response::HTTP_NOT_FOUND);

        if ($relationType === 'To-One') {
            $this->updateToOneResourceRelationship($record, $relation, $request->input('data'));

It seems like $request->input('data') targeting Illuminate\Http\Concerns\InteractsWithInput::input() can also be of type string; however, Huntie\JsonApi\Http\Concerns\UpdatesModelRelations::updateToOneResourceRelationship() does only seem to accept array, maybe add an additional type check?

        } else if ($relationType === 'To-Many') {
            $this->updateToManyResourceRelationship($record, $relation, $request->input('data'), $request->method());

It seems like $request->input('data') targeting Illuminate\Http\Concerns\InteractsWithInput::input() can also be of type string; however, Huntie\JsonApi\Http\Concerns\UpdatesModelRelations::updateToManyResourceRelationship() does only seem to accept array, maybe add an additional type check?

        }

        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);
    }

    /**
     * Validate the requested included relationships against those that are
     * allowed on the requested resource type.
     *
     * @param array $relations
     *
     * @throws InvalidRelationPathException
     */
    protected function validateIncludableRelations(array $relations)
    {
        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);
            }
        }
    }
}