Longman\Platfourm\Repository\Eloquent\BaseRepository

Complexity

Total Complexity

102

Size/Duplication

Total Lines	850
Duplicated Lines	7.29 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

0%

Importance

Changes

0

43 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	boot()	0	3	1
A	resetModel()	0	4	1
	model()	0	1	?
A	presenter()	0	3	1
A	setPresenter()	0	6	1
A	makeModel()	0	10	2
B	makePresenter()	0	14	5
A	scopeQuery()	0	6	1
A	count()	0	15	2
A	all()	0	15	2
A	findAll()	0	5	1
A	first()	0	9	1
C	findBy()	0	47	10
A	parseColumns()	0	8	2
C	setWheres()	0	59	17
C	paginate()	0	28	7
B	parseSortByString()	0	18	5
A	simplePaginate()	0	10	2
A	find()	0	9	1
A	findOrNew()	0	14	2
A	findByField()	9	9	1
A	findBySlug()	0	9	1
A	findWhere()	0	19	3
A	findWhereIn()	8	8	1
A	findWhereNotIn()	8	8	1
A	newInstance()	0	8	1
A	create()	0	10	1
A	update()	18	18	1
A	delete()	19	19	1
A	restore()	0	22	2
A	with()	0	6	1
A	withTrashed()	0	6	1
A	hidden()	0	6	1
A	visible()	0	6	1
A	pushCriteria()	0	6	1
A	getCriteria()	0	4	1
A	getByCriteria()	0	8	1
A	skipCriteria()	0	6	1
A	applyScope()	0	10	3
B	applyCriteria()	0	19	5
A	skipPresenter()	0	6	1
C	parserResult()	0	24	7

<?php
/*
 * This file is part of the Laravel Platfourm package.
 *
 * (c) Avtandil Kikabidze aka LONGMAN <akalongman@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Longman\Platfourm\Repository\Eloquent;

use Closure;
use Exception;
use Illuminate\Container\Container as Application;
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Collection;
use Longman\Platfourm\Contracts\Repository\Criteria;
use Longman\Platfourm\Contracts\Repository\Presentable;
use Longman\Platfourm\Contracts\Repository\Presenter;
use Longman\Platfourm\Contracts\Repository\Repository;
use Longman\Platfourm\Contracts\Repository\RepositoryCriteria;
use Longman\Platfourm\Repository\Events\RepositoryEntityCreated;
use Longman\Platfourm\Repository\Events\RepositoryEntityDeleted;
use Longman\Platfourm\Repository\Events\RepositoryEntityRestored;
use Longman\Platfourm\Repository\Events\RepositoryEntityUpdated;
use Longman\Platfourm\Repository\Exceptions\RepositoryException;

/**
 * Class BaseRepository.
 */
abstract class BaseRepository implements Repository, RepositoryCriteria
{
    /**
     * @var Application
     */
    protected $app;

    /**
     * @var Model
     */
    protected $model;

    /**
     * @var Presenter
     */
    protected $presenter;

    /**
     * Validation Rules.
     *
     * @var array
     */
    protected $rules = null;

    /**
     * Collection of Criteria.
     *
     * @var Collection
     */
    protected $criteria;

    /**
     * @var bool
     */
    protected $skipCriteria = false;

    /**
     * @var bool
     */
    protected $skipPresenter = false;

    /**
     * @var \Closure
     */
    protected $scopeQuery = null;

    protected $availableSortDirections = ['asc', 'desc'];

    /**
     * @param Application $app
     */
    public function __construct(Application $app)
    {
        $this->app      = $app;
        $this->criteria = new Collection();
        $this->makeModel();
        $this->makePresenter();
        $this->boot();
    }

    public function boot()
    {
    }

    /**
     * @throws RepositoryException
     */
    public function resetModel()
    {
        $this->makeModel();
    }

    /**
     * Specify Model class name.
     *
     * @return string
     */
    abstract public function model();

    /**
     * Specify Presenter class name.
     *
     * @return string
     */
    public function presenter()
    {
    }

    /**
     * Set Presenter.
     *
     * @param  $presenter
     * @return $this
     */
    public function setPresenter($presenter)
    {
        $this->makePresenter($presenter);

        return $this;
    }

    /**
     * @throws RepositoryException
     * @return Model
     */
    public function makeModel()
    {
        $model = $this->app->make($this->model());

        if (!$model instanceof Model) {
            throw new RepositoryException("Class {$this->model()} must be an instance of Illuminate\\Database\\Eloquent\\Model");
        }

        return $this->model = $model;
    }

    /**
     * @param  null $presenter
     * @throws RepositoryException
     * @return Presenter
     */
    public function makePresenter($presenter = null)
    {
        $presenter = !is_null($presenter) ? $presenter : $this->presenter();

        if (!is_null($presenter)) {
            $this->presenter = is_string($presenter) ? $this->app->make($presenter) : $presenter;

            if (!$this->presenter instanceof Presenter) {
                throw new RepositoryException("Class {$presenter} must be an instance of Longman\Platfourm\\Contracts\\Repository\\Presenter");
            }

            return $this->presenter;
        }
    }

    /**
     * Query Scope.
     *
     * @param  \Closure $scope
     * @return $this
     */
    public function scopeQuery(\Closure $scope)
    {
        $this->scopeQuery = $scope;

        return $this;
    }

    /**
     * Retrieve count of records.
     *
     * @param  array $columns

There is no parameter named $columns. Was it maybe removed?

     * @return mixed
     */
    public function count()
    {
        $this->applyCriteria();
        $this->applyScope();

        if ($this->model instanceof EloquentBuilder) {
            $results = $this->model->count();
        } else {
            $results = $this->model->count();
        }

        $this->resetModel();

        return $results;
    }

    /**
     * Retrieve all data of repository.
     *
     * @param  array $columns
     * @return mixed
     */
    public function all($columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();

        if ($this->model instanceof EloquentBuilder) {
            $results = $this->model->get($columns);
        } else {
            $results = $this->model->all($columns);
        }

        $this->resetModel();

        return $this->parserResult($results);
    }

    public function findAll($columns = ['*'])
    {

        return $this->all($columns);
    }

    /**
     * Retrieve first data of repository.
     *
     * @param  array $columns
     * @return mixed
     */
    public function first($columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();
        $results = $this->model->first($columns);
        $this->resetModel();

        return $this->parserResult($results);
    }

    /**
     * Get entities
     *
     * @param string     $columns
     * @param array|null $options
     * @param null       $limit
     * @param null       $page
     * @param null       $sortBy
     * @return mixed
     */
    public function findBy($columns = '*', array $options = null, $limit = null, $page = null, $sortBy = null)
    {
        $this->applyCriteria();
        $this->applyScope();

        $model = $this->model;

        if (!is_array($columns)) {
            $columns = $this->parseColumns($columns);
        }

        if (!is_null($options)) {
            $model = $this->setWheres($model, $options);
        }

        if (is_string($sortBy)) {
            $sortBy = $this->parseSortByString($sortBy);
        }

        if (!empty($sortBy)) {
            if ($this->model instanceof EloquentBuilder) {
                $sortableFields = $this->model->getModel()->getSortableFields();
            } else {
                $sortableFields = $this->model->getSortableFields();
            }
            foreach ($sortBy as $field => $direction) {
                if (!in_array($field, $sortableFields)) {
                    continue;
                }
                if (!in_array($direction, $this->availableSortDirections)) {
                    $direction = 'asc';
                }
                $model = $model->orderBy($field, $direction);
            }
        }

        if (is_null($limit)) {
            $data    = $model->get($columns);
            $total   = $data->count();
            $results = new LengthAwarePaginator($data, $total, 1, 1, []);
        } else {
            $results = $model->paginate($limit, $columns, 'page', $page);
        }
        $this->resetModel();

        return $this->parserResult($results);
    }

    protected function parseColumns($columns)
    {
        if ($columns == '*') {
            return ['*'];
        }

        return explode(',', $columns);
    }

    protected function setWheres($model, array $options = null)
    {

        foreach ($options as $k => $v) {

The expression $options of type null|array is not guaranteed to be traversable. How about adding an additional type check?

            if ($v instanceof Closure) {
                $model = $model->where($v);
                continue;
            }

            $boolean = 'and';

            $ex = explode(':', $k);

            if (empty($ex[1])) {
                $operator = '=';
                $field    = trim($ex[0]);
            } else {
                $operator = trim($ex[0]);
                $field    = trim($ex[1]);
            }

            switch ($operator) {
                case 'in':
                    $model = $model->whereIn($field, $v, $boolean);
                    break;

                case 'not_in':
                    $model = $model->whereNotIn($field, $v, $boolean);
                    break;

                case '=':
                case '<':
                case '>':
                case '<=':
                case '>=':
                case '<>':
                case '!=':
                    $model = $model->where($field, $operator, $v, $boolean);
                    break;

                case 'not':
                    $model = $model->where($field, '!=', $v, $boolean);
                    break;

                case 'like':
                    $model = $model->where($field, 'like', $v, $boolean);
                    break;

                case 'not_like':
                    $model = $model->where($field, 'not like', $v, $boolean);
                    break;

                case 'between':
                    $model = $model->where($field, 'between', $v, $boolean);
                    break;
            }
        }
        return $model;
    }

    /**
     * Retrieve all data of repository, paginated.
     *
     * @param  null  $limit
     * @param  array $columns
     * @return mixed
     */
    public function paginate($columns = ['*'], $limit = null, $page = null, $sortBy = [])
    {
        $this->applyCriteria();
        $this->applyScope();
        $limit = is_null($limit) ? config('database.pagination.limit', 15) : $limit;

        if (is_string($sortBy)) {
            $sortBy = $this->parseSortByString($sortBy);
        }

        if (!empty($sortBy)) {
            $sortableFields = $model->getSortableFields();

The variable $model does not exist. Did you forget to declare it?

            foreach ($sortBy as $field => $direction) {
                if (!in_array($field, $sortableFields)) {
                    continue;
                }
                if (!in_array($sortDir, $this->availableSortDirections)) {

The variable $sortDir does not seem to be defined for all execution paths leading up to this point.

                    $sortDir = 'asc';
                }
                $this->model = $this->model->orderBy($sortField, $sortDir);

The variable $sortField does not exist. Did you forget to declare it?

            }
        }

        $results = $this->model->paginate($limit, $columns, 'page', $page);
        $this->resetModel();

        return $this->parserResult($results);
    }

    protected function parseSortByString($sortBy)
    {
        $sortBy = explode(',', $sortBy);
        $return = [];
        foreach ($sortBy as $sortItem) {
            $sortEx = explode(':', $sortItem);
            if (empty($sortEx[0])) {
                continue;
            }
            $sortField = trim($sortEx[0]);
            $sortDir   = isset($sortEx[1]) ? trim($sortEx[1]) : 'asc';
            if (!in_array($sortDir, $this->availableSortDirections)) {
                $sortDir = 'asc';
            }
            $return[$sortField] = $sortDir;
        }
        return $return;
    }

    /**
     * Retrieve all data of repository, simple paginated.
     *
     * @param  null  $limit
     * @param  array $columns
     * @return mixed
     */
    public function simplePaginate($limit = null, $columns = ['*'], $pageName = 'page', $page = null)
    {
        $this->applyCriteria();
        $this->applyScope();
        $limit   = is_null($limit) ? config('repository.pagination.limit', 15) : $limit;
        $results = $this->model->simplePaginate($limit, $columns, 'page', $page);
        $this->resetModel();

        return $this->parserResult($results);
    }

    /**
     * Find data by id.
     *
     * @param        $id
     * @param  array $columns
     * @return mixed
     */
    public function find($id, $columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();
        $model = $this->model->findOrFail($id, $columns);
        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Find data by id or return new if not exists.
     *
     * @param        $id
     * @param  array $columns
     * @return mixed
     */
    public function findOrNew($id, $columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();
        try {
            $model = $this->model->findOrFail($id, $columns);
        } catch (Exception $e) {
            $model = $this->model->newInstance([]);
        }

        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Find data by field and value.
     *
     * @param        $field
     * @param        $value
     * @param  array $columns
     * @return mixed
     */
    public function findByField($field, $value = null, $columns = ['*'])

This method seems to be duplicated in your project.

    {
        $this->applyCriteria();
        $this->applyScope();
        $model = $this->model->where($field, '=', $value)->get($columns);
        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Find data by slug.
     *
     * @param        $value
     * @param  array $columns
     * @return mixed
     */
    public function findBySlug($value = null, $columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();
        $model = $this->model->whereSlug($value)->first($columns);
        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Find data by multiple fields.
     *
     * @param  array $where
     * @param  array $columns
     * @return mixed
     */
    public function findWhere(array $where, $columns = ['*'])
    {
        $this->applyCriteria();
        $this->applyScope();

        foreach ($where as $field => $value) {
            if (is_array($value)) {
                list($field, $condition, $val) = $value;
                $this->model = $this->model->where($field, $condition, $val);
            } else {
                $this->model = $this->model->where($field, '=', $value);
            }
        }

        $model = $this->model->get($columns);
        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Find data by multiple values in one field.
     *
     * @param        $field
     * @param  array $values
     * @param  array $columns
     * @return mixed
     */
    public function findWhereIn($field, array $values, $columns = ['*'])

This method seems to be duplicated in your project.

    {
        $this->applyCriteria();
        $model = $this->model->whereIn($field, $values)->get($columns);
        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Find data by excluding multiple values in one field.
     *
     * @param        $field
     * @param  array $values
     * @param  array $columns
     * @return mixed
     */
    public function findWhereNotIn($field, array $values, $columns = ['*'])

This method seems to be duplicated in your project.

    {
        $this->applyCriteria();
        $model = $this->model->whereNotIn($field, $values)->get($columns);
        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Create a new instance in repository.
     *
     * @param  array $attributes
     * @return mixed
     */
    public function newInstance(array $attributes)
    {
        $model = $this->model->newInstance($attributes);

        $this->resetModel();

        return $this->parserResult($model);
    }

    /**
     * Save a new entity in repository.
     *
     * @param  array $attributes
     * @return mixed
     */
    public function create(array $attributes)
    {
        $model = $this->model->newInstance($attributes);
        $model->save();
        $this->resetModel();

        event(new RepositoryEntityCreated($this, $model));

        return $this->parserResult($model);
    }

    /**
     * Update a entity in repository by id.
     *
     * @param  array $attributes
     * @param        $id
     * @return mixed
     */
    public function update($id, array $attributes)

This method seems to be duplicated in your project.

    {
        $this->applyScope();
        $_skipPresenter = $this->skipPresenter;

        $this->skipPresenter(true);

        $model = $this->model->findOrFail($id);
        $model->fill($attributes);
        $model->save();

        $this->skipPresenter($_skipPresenter);
        $this->resetModel();

        event(new RepositoryEntityUpdated($this, $model));

        return $this->parserResult($model);
    }

    /**
     * Delete a entity in repository by id.
     *
     * @param  $id
     * @return int
     */
    public function delete($id)

This method seems to be duplicated in your project.

    {
        $this->applyScope();

        $_skipPresenter = $this->skipPresenter;
        $this->skipPresenter(true);

        $model         = $this->find($id);
        $originalModel = clone $model;

        $this->skipPresenter($_skipPresenter);
        $this->resetModel();

        $deleted = $model->delete();

$deleted is not used, you could remove the assignment.

        event(new RepositoryEntityDeleted($this, $originalModel));

        return $this->parserResult($model);
    }

    /**
     * Delete a entity in repository by id.
     *
     * @param  $id
     * @return int
     */
    public function restore($id)
    {
        $this->applyScope();
        $_skipPresenter = $this->skipPresenter;

        $this->skipPresenter(true);

        $model = $this->model->withTrashed()->findOrFail($id);

        if (!$model->trashed()) {
            return $model;
        }

        $restored = $model->restore();

$restored is not used, you could remove the assignment.

        $this->skipPresenter($_skipPresenter);
        $this->resetModel();

        event(new RepositoryEntityRestored($this, $model));

        return $this->parserResult($model);
    }

    /**
     * Load relations.
     *
     * @param  array|string $relations
     * @return $this
     */
    public function with($relations)
    {
        $this->model = $this->model->with($relations);

It seems like $this->model->with($relations) can also be of type object<Illuminate\Database\Eloquent\Builder>. However, the property $model is declared as type object<Illuminate\Database\Eloquent\Model>. Maybe add an additional type check?

        return $this;
    }

    /**
     * With trashed.
     *
     * @return $this
     */
    public function withTrashed()
    {
        $this->model = $this->model->withTrashed();

        return $this;
    }

    /**
     * Set hidden fields.
     *
     * @param  array $fields
     * @return $this
     */
    public function hidden(array $fields)
    {
        $this->model->setHidden($fields);

        return $this;
    }

    /**
     * Set visible fields.
     *
     * @param  array $fields
     * @return $this
     */
    public function visible(array $fields)
    {
        $this->model->setVisible($fields);

        return $this;
    }

    /**
     * Push Criteria for filter the query.
     *
     * @param  Criteria $criteria
     * @return $this
     */
    public function pushCriteria(Criteria $criteria)
    {
        $this->criteria->push($criteria);

        return $this;
    }

    /**
     * Get Collection of Criteria.
     *
     * @return Collection
     */
    public function getCriteria()
    {
        return $this->criteria;
    }

    /**
     * Find data by Criteria.
     *
     * @param  Criteria $criteria
     * @return mixed
     */
    public function getByCriteria(Criteria $criteria)
    {
        $this->model = $criteria->apply($this->model, $this);
        $results     = $this->model->get();
        $this->resetModel();

        return $this->parserResult($results);
    }

    /**
     * Skip Criteria.
     *
     * @param  bool $status
     * @return $this
     */
    public function skipCriteria($status = true)
    {
        $this->skipCriteria = $status;

        return $this;
    }

    /**
     * Apply scope in current Query.
     *
     * @return $this
     */
    protected function applyScope()
    {

        if (isset($this->scopeQuery) && is_callable($this->scopeQuery)) {
            $callback    = $this->scopeQuery;
            $this->model = $callback($this->model);
        }

        return $this;
    }

    /**
     * Apply criteria in current Query.
     *
     * @return $this
     */
    protected function applyCriteria()
    {

        if ($this->skipCriteria === true) {
            return $this;
        }

        $criteria = $this->getCriteria();

        if ($criteria) {
            foreach ($criteria as $c) {
                if ($c instanceof Criteria) {
                    $this->model = $c->apply($this->model, $this);
                }
            }
        }

        return $this;
    }

    /**
     * Skip Presenter Wrapper.
     *
     * @param  bool $status
     * @return $this
     */
    public function skipPresenter($status = true)
    {
        $this->skipPresenter = $status;

        return $this;
    }

    /**
     * Wrapper result data.
     *
     * @param  mixed $result
     * @return mixed
     */
    public function parserResult($result)
    {

        if ($this->presenter instanceof Presenter) {
            if ($result instanceof Collection || $result instanceof LengthAwarePaginator) {
                $result->each(function ($model) {

The method each does only exist in Illuminate\Support\Collection, but not in Illuminate\Pagination\LengthAwarePaginator.

                    if ($model instanceof Presentable) {
                        $model->setPresenter($this->presenter);
                    }

                    return $model;
                });
            } elseif ($result instanceof Presentable) {
                $result = $result->setPresenter($this->presenter);
            }

            if (!$this->skipPresenter) {
                return $this->presenter->present($result);
            }
        }

        return $result;
    }
}