Yaro\Jarboe\Table\Filters\SelectFilter

Complexity

Total Complexity

33

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	1	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	applyRelationValues()	0	8	1
A	getSelectedGroupedOptions()	0	22	6
A	isSelectField()	0	3	1
A	getSelectedOptions()	0	8	1
A	getOptions()	0	8	2
A	multiple()	0	5	1
A	isNullable()	0	7	2
A	render()	0	12	4
A	options()	0	5	1
A	isMultiple()	0	7	2
A	nullable()	0	5	1
B	apply()	0	41	11

<?php

namespace Yaro\Jarboe\Table\Filters;

class SelectFilter extends AbstractFilter
{
    const NO_INPUT_APPLIED = '__jarboe-no-search-input-applied';

    private $multiple = false;
    private $options = null;
    private $nullable = false;

    public function render()
    {
        $value = $this->value();
        $values = [];
        if (!is_null($value) && $value !== self::NO_INPUT_APPLIED) {
            $values = is_array($value) ? $value : [$value];
        }

        return view('jarboe::crud.filters.select', [
            'filter' => $this,
            'values' => $values,
            'desearch' => self::NO_INPUT_APPLIED,
        ]);
    }

    public function multiple(bool $multiple = true)
    {
        $this->multiple = $multiple;

        return $this;
    }

    public function nullable(bool $nullable = true)
    {
        $this->nullable = $nullable;

        return $this;
    }

    public function isNullable(): bool
    {
        if (is_null($this->nullable)) {

The condition is_null($this->nullable) is always false.

            return $this->field()->isNullable();
        }

        return $this->nullable;
    }

    public function isMultiple(): bool
    {
        if (is_null($this->multiple)) {

The condition is_null($this->multiple) is always false.

            return $this->field()->isMultiple();
        }

        return $this->multiple;
    }

    public function options(array $options)
    {
        $this->options = $options;

        return $this;
    }

    public function getOptions()
    {
        $options = $this->options;
        if (is_null($options)) {
            $options = $this->field()->getOptions();
        }

        return $options;
    }

    public function getSelectedOptions(array $values, int $index = 0): array
    {
        $total = 0;
        $options = $this->field()->getOptions(null, null, null, $total, $index, function ($query, $related) use ($values) {
            $query->whereIn($related->getTable() .'.'. $related->getKeyName(), $values);
        });

        return $options;
    }

    public function getSelectedGroupedOptions(): array
    {
        $value = $this->value();
        $values = is_array($value) ? $value : [$value];
        $values = array_filter($values);

        $options = [];
        foreach ($this->field()->getRelations() as $index => $relation) {
            $groupValues = [];
            foreach ($values as $value) {
                list($groupHash, $groupValue) = explode('~~~', $value);
                if ($groupHash == crc32($relation['group'])) {
                    $groupValues[] = $groupValue;
                }
            }

            if ($groupValues) {
                $options[$relation['group']] = $this->getSelectedOptions($groupValues, $index);
            }
        }

        return array_filter($options);
    }

    public function isSelectField(): bool
    {
        return method_exists($this->field(), 'isSelect2Type');
    }

    public function apply($query)
    {
        $value = $this->value();
        if (is_null($value) || $value == self::NO_INPUT_APPLIED) {
            return;
        }

        if ($this->field()->isRelationField()) {
            $values = is_array($value) ? $value : [$value];
            $model = $this->field()->getModel();
            $model = new $model;

            foreach ($this->field()->getRelations() as $index => $relation) {
                $groupValues = $values;
                if ($this->field()->isGroupedRelation()) {
                    $groupValues = [];
                    foreach ($values as $value) {
                        list($groupHash, $groupValue) = explode('~~~', $value);
                        if ($groupHash == crc32($relation['group'])) {
                            $groupValues[] = $groupValue;
                        }
                    }
                }

                if ($groupValues) {
                    $this->applyRelationValues($model, $query, $groupValues, $index);
                }
            }

            return;
        }

        if ($this->field()->isMultiple()) {
            $query->whereIn($this->field()->name(), $value);
            return;
        }

        $query->where(
            $this->field()->name(),
            $this->sign,
            $value
        );
    }

    private function applyRelationValues($model, $query, $values, int $index = 0)
    {
        $relationQuery = $model->{$this->field()->getRelationMethod($index)}()->getRelated();
        $relationClass = get_class($relationQuery);
        $relationClass = new $relationClass;

        $query->whereHas($this->field()->getRelationMethod($index), function ($query) use ($values, $relationClass, $relationQuery) {
            $query->whereIn($relationQuery->getTable() .'.'. $relationClass->getKeyName(), $values);
        });
    }
}