App\Shop\Roles\Repositories\RoleRepository

Complexity

Total Complexity

14

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	attachToPermission()	0	3	1
A	updateRole()	0	6	2
A	attachToPermissions()	0	3	1
A	syncPermissions()	0	3	1
A	findRoleById()	0	6	2
A	createRole()	0	8	2
A	listPermissions()	0	3	1
A	listRoles()	0	3	1
A	__construct()	0	4	1
A	deleteRoleById()	0	6	2

<?php
namespace App\Shop\Roles\Repositories;

use App\Shop\Base\BaseRepository;
use App\Shop\Permissions\Permission;
use App\Shop\Roles\Exceptions\CreateRoleErrorException;
use App\Shop\Roles\Exceptions\DeleteRoleErrorException;
use App\Shop\Roles\Exceptions\RoleNotFoundErrorException;
use App\Shop\Roles\Exceptions\UpdateRoleErrorException;
use App\Shop\Roles\Role;
use Illuminate\Database\QueryException;
use Illuminate\Support\Collection;

class RoleRepository extends BaseRepository implements RoleRepositoryInterface
{
    /**
     * @var Role
     */
    protected $model;
    /**
     * RoleRepository constructor.
     * @param Role $role
     */
    public function __construct(Role $role)
    {
        parent::__construct($role);
        $this->model = $role;
    }
    /**
     * List all Roles
     *
     * @param string $order
     * @param string $sort
     * @return Collection
     */
    public function listRoles(string $order = 'id', string $sort = 'desc') : Collection
    {
        return $this->all(['*'], $order, $sort);
    }
    /**
     * @param array $data
     * @return Role
     * @throws CreateRoleErrorException
     */
    public function createRole(array $data) : Role
    {
        try {
            $role = new Role($data);
            $role->save();
            return $role;
        } catch (QueryException $e) {
            throw new CreateRoleErrorException($e);
        }
    }

    /**
     * @param int $id
     *
     * @return Role
     * @throws RoleNotFoundErrorException
     */
    public function findRoleById(int $id) : Role
    {
        try {
            return $this->findOneOrFail($id);

The expression return $this->findOneOrFail($id) could return the type Illuminate\Database\Eloquent\Relations\MorphToMany which is incompatible with the type-hinted return App\Shop\Roles\Role. Consider adding an additional type-check to rule them out.

        } catch (QueryException $e) {
            throw new RoleNotFoundErrorException($e);
        }
    }

    /**
     * @param array $data
     * @param int $id
     *
     * @return bool
     * @throws UpdateRoleErrorException
     */
    public function updateRole(array $data, int $id) : bool
    {
        try {
            return $this->update($data, $id);
        } catch (QueryException $e) {
            throw new UpdateRoleErrorException($e);
        }
    }

    /**
     * @param int $id
     *
     * @return bool
     * @throws DeleteRoleErrorException
     */
    public function deleteRoleById(int $id) : bool
    {
        try {
            return $this->delete($id);
        } catch (QueryException $e) {
            throw new DeleteRoleErrorException($e);
        }
    }

    /**
     * @param Permission $permission
     */
    public function attachToPermission(Permission $permission)
    {
        $this->model->attachPermission($permission);
    }

    /**
     * @param Permission ...$permissions
     */
    public function attachToPermissions(... $permissions)
    {
        $this->model->attachPermissions($permissions);
    }

    /**
     * @param array $ids
     */
    public function syncPermissions(array $ids)
    {
        $this->model->syncPermissions($ids);
    }

    /**
     * @return Collection
     */
    public function listPermissions() : Collection
    {
        return $this->model->permissions()->get();
    }
}