LaravelFlare\Flare\Traits\ModelAdmin\ModelQuerying

Complexity

Total Complexity

22

Size/Duplication

Total Lines	215
Duplicated Lines	9.3 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	6
Bugs	2	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	find()	0	6	1
A	items()	0	6	1
A	allItems()	10	10	2
A	onlyTrashedItems()	10	10	2
B	query()	0	24	6
A	totals()	0	12	2
A	orderBy()	0	10	3
A	sortBy()	0	12	3
A	getPerPage()	0	4	1
A	setPerPage()	0	4	1

<?php

namespace LaravelFlare\Flare\Traits\ModelAdmin;

trait ModelQuerying
{
    /**
     * Allows filtering of the query, for instance:.
     *
     *      $query_filter = [
     *                          'whereNotNull' => ['parent_id'],
     *                          'where' => ['name', 'John'],
     *                      ]
     *
     * Would result in an Eloquent query with the following scope:
     *     Model::whereNotNull('parent_id')->where('name', 'John')->get();
     * 
     * @var array
     */
    protected $query_filter = [];

    /**
     * The number of models to return for pagination.
     *
     * @var int
     */
    protected $perPage = 15;

    /**
     * Order By - Column/Attribute to OrderBy.
     *
     * Primary Key of Model by default
     * 
     * @var string
     */
    protected $orderBy;

    /**
     * Sort By - Either Desc or Asc.
     * 
     * @var string
     */
    protected $sortBy;

    /**
     * Finds an existing Model entry and sets it to the current model.
     * 
     * @param int $modelitem_id
     * 
     * @return
     */
    public function find($modelitem_id)
    {
        $this->model = $this->model->findOrFail($modelitem_id);

        return $this->model;
    }

    /**
     * Returns Model Items, either all() or paginated().
     *
     * Filtered by any defined query filters ($query_filter)
     * Ordered by Managed Model orderBy and sortBy methods
     * 
     * @return
     */
    public function items()
    {
        $model = $this->model;

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

    /**
     * Returns All Model Items, either all() or paginated().
     *
     * Filtered by any defined query filters ($query_filter)
     * Ordered by Managed Model orderBy and sortBy methods
     * 
     * @return
     */
    public function allItems()

This method seems to be duplicated in your project.

    {
        if (!$this->hasSoftDeleting()) {

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

            throw new \Exception('Model does not have Soft Deleting');
        }
        
        $model = $this->model->withTrashed();

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

    /**
     * Returns Model Items, either all() or paginated().
     *
     * Filtered by any defined query filters ($query_filter)
     * Ordered by Managed Model orderBy and sortBy methods
     * 
     * @return
     */
    public function onlyTrashedItems()

This method seems to be duplicated in your project.

    {
        if (!$this->hasSoftDeleting()) {

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

            throw new \Exception('Model does not have Soft Deleting');
        }
        
        $model = $this->model->onlyTrashed();

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

    /**
     * Performs the Model Query
     * 
     * @param  \Illuminate\Database\Eloquent\Model $model
     * 
     * @return \Illuminate\Database\Eloquent\Collection
     */
    private function query($model)
    {
        if (count($this->query_filter) > 0) {
            foreach ($this->query_filter as $filter => $parameters) {
                if (!is_array($parameters)) {
                    $parameters = [$parameters];
                }
                $model = call_user_func_array([$this->model, $filter], $parameters);
            }
        }

        if ($this->orderBy()) {
            $model = $model->orderBy(
                                $this->orderBy(),
                                $this->sortBy()
                            );
        }

        if ($this->perPage > 0) {
            return $model->paginate($this->perPage);
        }

        return $model->get();
    }

    /**
     * Return Totals of All, With Trashed and Only Trashed
     * 
     * @return array
     */
    public function totals()
    {
        if ($this->hasSoftDeleting()) {

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

            return [
                        'all' => $this->model->count(),
                        'with_trashed' => $this->model->withTrashed()->count(),
                        'only_trashed' => $this->model->onlyTrashed()->count(),
                    ];
        }

        return ['all' => $this->model->count()];
    }

    /**
     * Return Managed Model OrderBy.
     *
     * Primary key is default.
     *
     * @return string
     */
    public function orderBy()
    {
        if (\Request::input('order')) {
            return \Request::input('order');
        }

        if ($this->orderBy) {
            return $this->orderBy;
        }
    }

    /**
     * Return Managed Model SortBy (Asc or Desc).
     *
     * Descending is default.
     * 
     * @return string
     */
    public function sortBy()
    {
        if (\Request::input('sort')) {
            return \Request::input('sort');
        }

        if ($this->sortBy == 'asc') {
            return 'asc';
        }

        return 'desc';
    }

    /**
     * Get the number of models to return per page.
     *
     * @return int
     */
    public function getPerPage()
    {
        return $this->perPage;
    }

    /**
     * Set the number of models to return per page.
     *
     * @param int $perPage
     */
    public function setPerPage($perPage)
    {
        $this->perPage = $perPage;
    }
}