Bakery\Eloquent\Concerns\Authorizable

Complexity

Total Complexity

16

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	authorizedToAdd()	0	5	1
A	authorize()	0	4	2
A	authorizeToAdd()	0	5	1
A	authorizeToDetach()	0	5	1
A	authorizedToCreate()	0	3	1
A	authorizeToAttach()	0	5	1
A	authorizedToUpdate()	0	3	1
A	authorizedToDelete()	0	3	1
A	authorizeToDelete()	0	3	1
A	authorizeToCreate()	0	4	2
A	authorizedToAttach()	0	5	1
A	authorizeToUpdate()	0	3	1
A	authorized()	0	5	1
A	authorizedToDetach()	0	5	1

<?php

namespace Bakery\Eloquent\Concerns;

use Illuminate\Support\Str;
use Illuminate\Support\Facades\Gate;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Auth\Access\AuthorizationException;

trait Authorizable
{
    /**
     * Determine if the current user can create a new model or throw an exception.
     *
     * @return void
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function authorizeToCreate(): void
    {
        if (! static::authorizedToCreate()) {

The method Bakery\Eloquent\Concerns\Authorizable::authorizedToCreate() is not static, but was called statically.

            throw new AuthorizationException("Not allowed to perform create on {$this->getModelClass()}");

It seems like getModelClass() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }
    }

    /**
     * Determine if the current user can create a new model.
     *
     * @return bool
     */
    public function authorizedToCreate(): bool
    {
        return $this->authorized('create');
    }

    /**
     * Determine if the current user can update the model or throw an exception.
     *
     * @return void
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function authorizeToUpdate(): void
    {
        $this->authorize('update');
    }

    /**
     * Determine if the current user can update the model.
     *
     * @return bool
     */
    public function authorizedToUpdate(): bool
    {
        return $this->authorized('update');
    }

    /**
     * Determine if the current user can delete the model or throw an exception.
     *
     * @return void
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function authorizeToDelete(): void
    {
        $this->authorize('delete');
    }

    /**
     * Determine if the current user can delete the model.
     *
     * @return bool
     */
    public function authorizedToDelete(): bool
    {
        return $this->authorized('delete');
    }

    /**
     * Determine if the current user can add the given model to the model or throw an exception.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function authorizeToAdd(Model $model): void
    {
        $method = 'add'.Str::singular(class_basename($model));

        $this->authorize($method, [$model]);
    }

    /**
     * Determine if the current user can add the given model to the model.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     * @return bool
     */
    public function authorizedToAdd(Model $model): bool
    {
        $method = 'add'.Str::singular(class_basename($model));

        return $this->authorized($method, [$model]);
    }

    /**
     * Determine if the current user can attach the given model to the model.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     * @param array|null $pivot
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function authorizeToAttach(Model $model, array $pivot = null): void
    {
        $method = 'attach'.Str::singular(class_basename($model));

        $this->authorize($method, [$model, $pivot]);
    }

    /**
     * Determine if the current user can attach the given model to the model.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     * @param array|null $pivot
     * @return bool
     */
    public function authorizedToAttach(Model $model, array $pivot = null): bool
    {
        $method = 'attach'.Str::singular(class_basename($model));

        return $this->authorized($method, [$model, $pivot]);
    }

    /**
     * Determine if the current user can detach the given model from the model.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function authorizeToDetach(Model $model): void
    {
        $method = 'detach'.Str::singular(class_basename($model));

        $this->authorize($method, [$model]);
    }

    /**
     * Determine if the current user can detach the given model from the model.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     * @return bool
     */
    public function authorizedToDetach(Model $model): bool
    {
        $method = 'detach'.Str::singular(class_basename($model));

        return $this->authorized($method, [$model]);
    }

    /**
     * Determine if the current user has a given ability or throw an exception.
     *
     * @param string $ability
     * @param array|null $arguments
     * @return void
     *
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function authorize(string $ability, $arguments = []): void
    {
        if (! $this->authorized($ability, $arguments)) {

It seems like $arguments can also be of type null; however, parameter $arguments of Bakery\Eloquent\Concerns\Authorizable::authorized() does only seem to accept array, maybe add an additional type check?

            throw new AuthorizationException("Not allowed to perform {$ability} on {$this->getModelClass()}");
        }
    }

    /**
     * Determine if the current user has a given ability.
     *
     * @param string $ability
     * @param array $arguments
     * @return bool
     */
    public function authorized(string $ability, array $arguments = []): bool
    {
        $arguments = array_merge([$this->instance ?? $this->getModelClass()], $arguments);

        return Gate::check($ability, $arguments);
    }
}