Koch\Filters\Filter

Complexity

Total Complexity

9

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	apply()	0	14	2
A	filters()	0	4	1
A	callFilterMethod()	0	4	1
A	getTableName()	0	4	1
A	resolve()	0	18	3

<?php

namespace Koch\Filters;

use Illuminate\Http\Request;
use Koch\Filters\Behavior\Orderable;
use Koch\Filters\Behavior\Searchable;
use Illuminate\Database\Eloquent\Builder;
use Koch\Filters\Contracts\Filter as FilterContract;

abstract class Filter implements FilterContract
{
    use Searchable, Orderable;

    /**
     * Already loaded relations.
     *
     * @var array
     */
    protected $loaded = [];

    /**
     * Default searchable columns.
     *
     * @var array
     */
    protected $searchable = ['name'];

    /**
     * Default orderable columns.
     *
     * @var array
     */
    protected $orderable = ['name' => 'name'];

    /**
     * Request data.
     *
     * @var \Illuminate\Http\Request
     */
    protected $request;

    /**
     * Builder instance.
     *
     * @var \Illuminate\Database\Eloquent\Builder
     */
    protected $builder;

    /**
     * Class constructor.
     *
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct(Request $request)

You have injected the Request via parameter $request. This is generally not recommended as there might be multiple instances during a request cycle (f.e. when using sub-requests). Instead, it is recommended to inject the RequestStack and retrieve the current request each time you need it via getCurrentRequest().

    {
        $this->request = $request;
    }

    /**
     * Applies all available filters.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $builder
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function apply(Builder $builder)
    {
        $this->builder = $builder;

        // We need to select all columns from the original
        // table, since many joins can mess up the selected fields
        $this->builder->select("{$this->getTableName()}.*");

        foreach ($this->filters() as $name => $value) {
            $this->callFilterMethod($name, $value);
        }

        return $this->builder;
    }

    /**
     * Returns all filters from the request.
     *
     * @return array
     */
    public function filters()
    {
        return $this->request->all();
    }

    /**
     * Helper function to call each filter method.
     *
     * @param  string  $name
     * @param  string  $value
     */
    protected function callFilterMethod($name, $value)
    {
        call_user_func_array([$this, $name], array_filter([$value]));
    }

    /**
     * Returns the associated table name.
     *
     * @return string
     */
    protected function getTableName()
    {
        return $this->builder->getModel()->getTable();
    }

    /**
     * Recursively build up the query.
     *
     * @param  string  $column
     * @param  string  $key
     * @param  string  $last
     * @param  callable  $callback
     * @return void
     */
    protected function resolve($column, $key, $last, callable $callback)
    {
        if (! strpos($column, '.')) {
            return $callback("{$last}.{$column}", $key);
        }

        $scope = strstr($column, '.', true);
        $singular = str_singular($scope);
        $next = substr(strstr($column, '.'), 1);

        if (! in_array($scope, $this->loaded)) {
            $this->loaded[] = $scope;

            $this->builder->join($scope, "{$last}.{$singular}_id", "{$scope}.id");
        }

        return $this->resolve($next, $key, $scope, $callback);
    }
}