Backpack\CRUD\app\Library\CrudPanel\CrudFilter

Complexity

Total Complexity

65

Size/Duplication

Total Lines	609
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

39 Methods

Rating	Name	Duplication	Size	Complexity
A	remove()	0	3	1
A	after()	0	5	1
A	removeFilterAttribute()	0	7	1
A	label()	0	5	1
A	options()	0	3	1
A	makeFirst()	0	5	1
A	getViewWithNamespace()	0	3	1
A	makeLast()	0	6	1
A	isActive()	0	7	2
A	type()	0	6	1
A	wasApplied()	0	3	1
A	values()	0	5	3
A	apply()	0	25	5
A	forget()	0	13	3
A	getNamespacedViewWithFallbacks()	0	12	2
A	wasNotApplied()	0	3	1
A	before()	0	5	1
B	__construct()	0	29	6
A	name()	0	5	1
A	whenActive()	0	3	1
A	__call()	0	5	1
A	view()	0	6	1
A	applied()	0	5	1
A	else()	0	3	1
A	ifActive()	0	3	1
A	logic()	0	5	1
A	setAllOptionsValues()	0	3	1
A	ifNotActive()	0	3	1
B	applyDefaultLogic()	0	44	11
A	dd()	0	5	1
A	save()	0	11	2
A	whenInactive()	0	3	1
A	fallbackLogic()	0	5	1
A	viewNamespace()	0	5	1
A	ifInactive()	0	3	1
A	setOptionValue()	0	3	1
A	whenNotActive()	0	3	1
A	dump()	0	5	1
A	crud()	0	3	1

<?php

namespace Backpack\CRUD\app\Library\CrudPanel;

use Backpack\CRUD\app\Exceptions\BackpackProRequiredException;
use Backpack\CRUD\ViewNamespaces;
use Closure;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\Conditionable;
use Symfony\Component\HttpFoundation\ParameterBag;

class CrudFilter
{
    use Conditionable;

    public $name; // the name of the filtered variable (db column name)

    public $type = 'select2'; // the name of the filter view that will be loaded

    public $key; //camelCased version of filter name to use in internal ids, js functions and css classes.

    public $label;

    public $placeholder;

    public $values;

    public $options;

    public $logic;

    public $fallbackLogic;

    public $currentValue;

    public $view;

    public $viewNamespace = 'crud::filters';

    public $applied = false;

    public function __construct($options, $values, $logic, $fallbackLogic)
    {
        if (! backpack_pro()) {
            throw new BackpackProRequiredException('Filter');
        }
        // if filter exists
        if ($this->crud()->hasFilterWhere('name', $options['name'])) {
            $properties = get_object_vars($this->crud()->firstFilterWhere('name', $options['name']));

$this->crud()->firstFilterWhere('name', $options['name']) of type boolean is incompatible with the type object expected by parameter $object of get_object_vars().

            foreach ($properties as $property => $value) {
                $this->{$property} = $value;
            }
        } else {
            // it means we're creating the filter now,
            $this->name = $options['name'];
            $this->key = Str::camel($options['name']);
            $this->type = $options['type'] ?? $this->type;
            $this->label = $options['label'] ?? $this->crud()->makeLabel($this->name);
            $this->viewNamespace = $options['viewNamespace'] ?? $options['view_namespace'] ?? $this->viewNamespace;
            $this->view = $this->type;
            $this->placeholder = $options['placeholder'] ?? '';

            $this->values = is_callable($values) ? $values() : $values;
            $this->options = $options;
            $this->logic = $logic;
            $this->fallbackLogic = $fallbackLogic;
        }

        if ($this->crud()->getRequest()->has($this->name)) {
            $this->currentValue = $this->crud()->getRequest()->input($this->name);
        }
    }

    /**
     * Check if the field is currently active. This happens when there's a GET parameter
     * in the current request with the same name as the name of the field.
     *
     * @return bool
     */
    public function isActive()
    {
        if ($this->crud()->getRequest()->has($this->name)) {
            return true;
        }

        return false;
    }

    /**
     * Check if the filter has already had the apply method called on it.
     *
     * @return bool
     */
    public function wasApplied()
    {
        return $this->applied;
    }

    /**
     * Check if the filter has not had the apply method called on it yet.
     * This is the inverse of the wasApplied() method.
     *
     * @return bool
     */
    public function wasNotApplied()
    {
        return ! $this->applied;
    }

    /**
     * Run the filter logic, default logic and/or fallback logic so that from this point on
     * the CRUD query has its results filtered, according to the Request.
     *
     * @param  array  $input  The GET parameters for which the filter should be applied.
     * @return void
     */
    public function apply($input = null)
    {
        // mark the field as already applied
        $this->applied(true);

        if (is_array($input)) {
            $input = new ParameterBag($input);
        }

        $input = $input ?? new ParameterBag($this->crud()->getRequest()->all());

        if (! $input->has($this->name)) {
            // if fallback logic was supplied and is a closure
            if (is_callable($this->fallbackLogic)) {
                return ($this->fallbackLogic)();
            }

            return;
        }

        // if a closure was passed as "filterLogic"
        if (is_callable($this->logic)) {
            return ($this->logic)($input->get($this->name));
        } else {
            return $this->applyDefaultLogic($this->name, false);

false of type false is incompatible with the type string expected by parameter $operator of Backpack\CRUD\app\Library\CrudPanel\CrudFilter::applyDefaultLogic().

Are you sure the usage of $this->applyDefaultLogic($this->name, false) targeting Backpack\CRUD\app\Library\CrudPanel\CrudFilter::applyDefaultLogic() seems to always return null.

        }
    }

    /**
     * Get the full path of the filter view, including the view namespace.
     *
     * @return string
     */
    public function getViewWithNamespace()
    {
        return $this->viewNamespace.'.'.$this->view;
    }

    /**
     * Get an array of full paths to the filter view, including fallbacks
     * as configured in the backpack/config/crud.php file.
     *
     * @return array
     */
    public function getNamespacedViewWithFallbacks()
    {
        $type = $this->type;
        $namespaces = ViewNamespaces::getFor('filters');

        if ($this->viewNamespace != 'crud::filters') {
            $namespaces = array_merge([$this->viewNamespace], $namespaces);
        }

        return array_map(function ($item) use ($type) {
            return $item.'.'.$type;
        }, $namespaces);
    }

    // ---------------------
    // FLUENT SYNTAX METHODS
    // ---------------------

    /**
     * Create a CrudFilter object with the parameter as its name.
     *
     * @param  string  $name  Name of the column in the db, or model attribute.
     * @return CrudPanel
     */
    public static function name($name)
    {
        $filter = new static(compact('name'), null, null, null);

        return $filter->save();

The expression return $filter->save() returns the type Backpack\CRUD\app\Library\CrudPanel\CrudFilter which is incompatible with the documented return type Backpack\CRUD\app\Library\CrudPanel\CrudPanel.

    }

    /**
     * Remove the current filter from the current operation.
     *
     * @return void
     */
    public function remove()
    {
        $this->crud()->removeFilter($this->name);
    }

    /**
     * Remove an attribute from the current filter definition array.
     *
     * @param  string  $attribute  Name of the attribute being removed.
     * @return CrudFilter
     */
    public function forget($attribute)
    {
        if (property_exists($this, $attribute)) {
            $this->{$attribute} = false;
        }

        if (isset($this->options[$attribute])) {
            unset($this->options[$attribute]);
        }

        $this->crud()->replaceFilter($this->name, $this);

        return $this;
    }

    /**
     * Remove an attribute from one field's definition array.
     * (unused function).
     *
     * @param  string  $field  The name of the field.
     * @param  string  $attribute  The name of the attribute being removed.
     *
     * @codeCoverageIgnore
     *
     * @deprecated
     */
    public function removeFilterAttribute($filter, $attribute)

The parameter $filter is not used and could be removed.

    {
        $fields = $this->fields();

The method fields() does not exist on Backpack\CRUD\app\Library\CrudPanel\CrudFilter. Since you implemented __call, consider adding a @method annotation.

        unset($fields[$field][$attribute]);

The variable $field does not exist. Did you maybe mean $fields?

        $this->setOperationSetting('fields', $fields);

The method setOperationSetting() does not exist on Backpack\CRUD\app\Library\CrudPanel\CrudFilter. Since you implemented __call, consider adding a @method annotation.

    }

    /**
     * Move the current filter after another filter.
     *
     * @param  string  $destination  Name of the destination filter.
     * @return CrudFilter
     */
    public function after($destination)
    {
        $this->crud()->moveFilter($this->name, 'after', $destination);

        return $this;
    }

    /**
     * Move the current field before another field.
     *
     * @param  string  $destination  Name of the destination field.
     * @return CrudFilter
     */
    public function before($destination)
    {
        $this->crud()->moveFilter($this->name, 'before', $destination);

        return $this;
    }

    /**
     * Make the current field the first one in the fields list.
     *
     * @return CrudPanel
     */
    public function makeFirst()
    {
        $this->crud()->moveFilter($this->name, 'before', $this->crud()->filters()->first()->name);

        return $this;

The expression return $this returns the type Backpack\CRUD\app\Library\CrudPanel\CrudFilter which is incompatible with the documented return type Backpack\CRUD\app\Library\CrudPanel\CrudPanel.

    }

    /**
     * Make the current field the last one in the fields list.
     *
     * @return CrudPanel
     */
    public function makeLast()
    {
        $this->crud()->removeFilter($this->name);
        $this->crud()->addCrudFilter($this);

        return $this;

The expression return $this returns the type Backpack\CRUD\app\Library\CrudPanel\CrudFilter which is incompatible with the documented return type Backpack\CRUD\app\Library\CrudPanel\CrudPanel.

    }

    // -----------------------
    // FILTER-SPECIFIC SETTERS
    // -----------------------

    /**
     * Set the type of the filter.
     *
     * @param  string  $value  Name of blade view that shows the field.
     * @return CrudFilter
     */
    public function type($value)
    {
        $this->type = $value;
        $this->view = $value;

        return $this->save();
    }

    /**
     * Set the label of the filter - the element that the end-user can see and click
     * to activate the filter or an input that will activate the filter.
     *
     * @param  string  $value  A name for this filter that the end-user will understand.
     * @return CrudFilter
     */
    public function label($value)
    {
        $this->label = $value;

        return $this->save();
    }

    /**
     * Set the values for the current filter, for the filters who need values.
     * For example, the dropdown, select2 and select2 filters let the user select
     * pre-determined values to filter with. This is how to set those values that will be picked up.
     *
     * @param  array|string|function  $value  Key-value array with values for the user to pick from, or a function which also return a Key-value array.

The type Backpack\CRUD\app\Library\CrudPanel\function was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return CrudFilter
     */
    public function values($value)
    {
        $this->values = (! is_string($value) && is_callable($value)) ? $value() : $value;

        return $this->save();
    }

    /**
     * Set the values for the current filter, for the filters who need values. For example
     * the dropdown, select2 and select2 filters let the user select pre-determined
     * values to filter with.
     *
     * Alias of the values() method.
     *
     * @param  array|string|function  $value  Key-value array with values for the user to pick from, or a function which also return a Key-value array.
     * @return CrudFilter
     */
    public function options($value)
    {
        return $this->values($value);
    }

    /**
     * Set the blade view that will be used by the filter.
     * Should NOT include the namespace, that's defined separately using 'viewNamespace'.
     *
     * @param  string  $value  Path to the blade file, after the view namespace.
     * @return CrudFilter
     */
    public function view($value)
    {
        $this->view = $value;
        $this->options['view'] = $value;

        return $this->save();
    }

    /**
     * The path to the blade views directory where the filter file will be found. Ex: 'crud::filters'
     * Useful to load filters from a different package or directory.
     *
     * @param  string  $value  Blade path to the directory.
     * @return CrudFilter
     */
    public function viewNamespace($value)
    {
        $this->viewNamespace = $value;

        return $this->save();
    }

    /**
     * Define what happens when the filter is active, through a closure.
     *
     * @param  Closure  $value  Closure that will be called when Request has this name as GET parameter.
     * @return CrudFilter
     */
    public function logic($value)
    {
        $this->logic = $value;

        return $this->save();
    }

    /**
     * Define what happens when the filter is NOT active, through a closure.
     *
     * @param  Closure  $value  Closure that will be called when Request does NOT have this name as GET parameter.
     * @return CrudFilter
     */
    public function fallbackLogic($value)
    {
        $this->fallbackLogic = $value;

        return $this->save();
    }

    /**
     * Define if the filter has already been applied (logic or fallbackLogic called).
     *
     * @param  bool  $value  Whether the filter has been run.
     * @return CrudFilter
     */
    public function applied($value)
    {
        $this->applied = $value;

        return $this->save();
    }

    /**
     * Aliases of the logic() method.
     */
    public function whenActive($value)
    {
        return $this->logic($value);
    }

    public function ifActive($value)
    {
        return $this->logic($value);
    }

    /**
     * Alises of the fallbackLogic() method.
     */
    public function whenInactive($value)
    {
        return $this->fallbackLogic($value);
    }

    public function whenNotActive($value)
    {
        return $this->fallbackLogic($value);
    }

    public function ifInactive($value)
    {
        return $this->fallbackLogic($value);
    }

    public function ifNotActive($value)
    {
        return $this->fallbackLogic($value);
    }

    public function else($value)
    {
        return $this->fallbackLogic($value);
    }

    // ---------------
    // PRIVATE METHODS
    // ---------------

    private function crud()
    {
        return app()->make('crud');
    }

    /**
     * Set the value for a certain attribute on the CrudFilter object.
     *
     * @param  string  $attribute  Name of the attribute.
     * @param  string  $value  Value of that attribute.
     */
    private function setOptionValue($attribute, $value)
    {
        $this->options[$attribute] = $value;
    }

    /**
     * Replace all field options on the CrudFilter object
     * with the given array of attribute-value pairs.
     *
     * @param  array  $array  Array of options and their values.
     */
    private function setAllOptionsValues($array)

The method setAllOptionsValues() is not used, and could be removed.

    {
        $this->options = $array;
    }

    /**
     * Update the global CrudPanel object with the current field options.
     *
     * @return CrudFilter
     */
    private function save()
    {
        $key = $this->name;

        if ($this->crud()->hasFilterWhere('name', $key)) {
            $this->crud()->modifyFilter($key, (array) $this);
        } else {
            $this->crud()->addCrudFilter($this);
        }

        return $this;
    }

    /**
     * @param  string  $name
     * @param  string  $operator
     * @param  array  $input
     */
    private function applyDefaultLogic($name, $operator, $input = null)
    {
        $input = $input ?? $this->crud()->getRequest()->all();

        // if this filter is active (the URL has it as a GET parameter)
        switch ($operator) {
            // if no operator was passed, just use the equals operator
            case false:

It seems like you are loosely comparing $operator of type string to the boolean false. If you are specifically checking for an empty string, consider using the more explicit === '' instead.

                $this->crud()->addClause('where', $name, $input[$name]);
                break;

            case 'scope':
                $this->crud()->addClause($operator);
                break;

                // TODO:
                // whereBetween
                // whereNotBetween
                // whereIn
                // whereNotIn
                // whereNull
                // whereNotNull
                // whereDate
                // whereMonth
                // whereDay
                // whereYear
                // whereColumn
                // like

                // sql comparison operators
            case '=':
            case '<=>':
            case '<>':
            case '!=':
            case '>':
            case '>=':
            case '<':
            case '<=':
                $this->crud()->addClause('where', $name, $operator, $input[$name]);
                break;

            default:
                abort(500, 'Unknown filter operator.', ['developer-error-exception']);
                break;
        }
    }

    // -----------------
    // DEBUGGING METHODS
    // -----------------

    /**
     * Dump the current object to the screen,
     * so that the developer can see its contents.
     *
     * @codeCoverageIgnore
     *
     * @return CrudFilter
     */
    public function dump()
    {
        dump($this);

        return $this;
    }

    /**
     * Dump and die. Dumps the current object to the screen,
     * so that the developer can see its contents, then stops
     * the execution.
     *
     * @codeCoverageIgnore
     *
     * @return CrudFilter
     */
    public function dd()
    {
        dd($this);

        return $this;
    }

    // -------------
    // MAGIC METHODS
    // -------------

    /**
     * If a developer calls a method that doesn't exist, assume they want:
     * - $this->options['whatever'] to be set to that value;
     * - that filter be updated inside the global CrudPanel object;.
     *
     * Eg: type('number') will set the "type" attribute to "number"
     *
     * @param  string  $method  The method being called that doesn't exist.
     * @param  array  $parameters  The arguments when that method was called.
     * @return CrudFilter
     */
    public function __call($method, $parameters)
    {
        $this->setOptionValue($method, $parameters[0]);

        return $this->save();
    }
}