SelectFilter::options() - Code Metrics - Cherry-Pie/Jarboe - Measure and Improve Code Quality continuously with Scrutinizer

SelectFilter::options() A
last analyzed 2024-09-13 11:39 UTC

↳ Parent: SelectFilter

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	5
rs	10
ccs	0
cts	4
cp	0
crap	2

<?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)) {

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

        return $this->nullable;
    }

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

            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);
        });
    }
}


1			<?php
2
3			namespace Yaro\Jarboe\Table\Filters;
4
5			class SelectFilter extends AbstractFilter
6			{
7			const NO_INPUT_APPLIED = '__jarboe-no-search-input-applied';
8
9			private $multiple = false;
10			private $options = null;
11			private $nullable = false;
12
13			public function render()
14			{
15			$value = $this->value();
16			$values = [];
17			if (!is_null($value) && $value !== self::NO_INPUT_APPLIED) {
18			$values = is_array($value) ? $value : [$value];
19			}
20
21			return view('jarboe::crud.filters.select', [
22			'filter' => $this,
23			'values' => $values,
24			'desearch' => self::NO_INPUT_APPLIED,
25			]);
26			}
27
28			public function multiple(bool $multiple = true)
29			{
30			$this->multiple = $multiple;
31
32			return $this;
33			}
34
35			public function nullable(bool $nullable = true)
36			{
37			$this->nullable = $nullable;
38
39			return $this;
40			}
41
42			public function isNullable(): bool
43			{
44			if (is_null($this->nullable)) {
			0 ignored issues – show introduced 2021-09-12 19:22 UTC by Report Bug Copy Issue Report The condition `is_null($this->nullable)` is always `false`. Loading history...
45			return $this->field()->isNullable();
46			}
47
48			return $this->nullable;
49			}
50
51			public function isMultiple(): bool
52			{
53			if (is_null($this->multiple)) {
			0 ignored issues – show introduced 2021-09-12 19:22 UTC by Report Bug Copy Issue Report The condition `is_null($this->multiple)` is always `false`. Loading history...
54			return $this->field()->isMultiple();
55			}
56
57			return $this->multiple;
58			}
59
60			public function options(array $options)
61			{
62			$this->options = $options;
63
64			return $this;
65			}
66
67			public function getOptions()
68			{
69			$options = $this->options;
70			if (is_null($options)) {
71			$options = $this->field()->getOptions();
72			}
73
74			return $options;
75			}
76
77			public function getSelectedOptions(array $values, int $index = 0): array
78			{
79			$total = 0;
80			$options = $this->field()->getOptions(null, null, null, $total, $index, function ($query, $related) use ($values) {
81			$query->whereIn($related->getTable() .'.'. $related->getKeyName(), $values);
82			});
83
84			return $options;
85			}
86
87			public function getSelectedGroupedOptions(): array
88			{
89			$value = $this->value();
90			$values = is_array($value) ? $value : [$value];
91			$values = array_filter($values);
92
93			$options = [];
94			foreach ($this->field()->getRelations() as $index => $relation) {
95			$groupValues = [];
96			foreach ($values as $value) {
97			list($groupHash, $groupValue) = explode('~~~', $value);
98			if ($groupHash == crc32($relation['group'])) {
99			$groupValues[] = $groupValue;
100			}
101			}
102
103			if ($groupValues) {
104			$options[$relation['group']] = $this->getSelectedOptions($groupValues, $index);
105			}
106			}
107
108			return array_filter($options);
109			}
110
111			public function isSelectField(): bool
112			{
113			return method_exists($this->field(), 'isSelect2Type');
114			}
115
116			public function apply($query)
117			{
118			$value = $this->value();
119			if (is_null($value) \|\| $value == self::NO_INPUT_APPLIED) {
120			return;
121			}
122
123			if ($this->field()->isRelationField()) {
124			$values = is_array($value) ? $value : [$value];
125			$model = $this->field()->getModel();
126			$model = new $model;
127
128			foreach ($this->field()->getRelations() as $index => $relation) {
129			$groupValues = $values;
130			if ($this->field()->isGroupedRelation()) {
131			$groupValues = [];
132			foreach ($values as $value) {
133			list($groupHash, $groupValue) = explode('~~~', $value);
134			if ($groupHash == crc32($relation['group'])) {
135			$groupValues[] = $groupValue;
136			}
137			}
138			}
139
140			if ($groupValues) {
141			$this->applyRelationValues($model, $query, $groupValues, $index);
142			}
143			}
144
145			return;
146			}
147
148			if ($this->field()->isMultiple()) {
149			$query->whereIn($this->field()->name(), $value);
150			return;
151			}
152
153			$query->where(
154			$this->field()->name(),
155			$this->sign,
156			$value
157			);
158			}
159
160			private function applyRelationValues($model, $query, $values, int $index = 0)
161			{
162			$relationQuery = $model->{$this->field()->getRelationMethod($index)}()->getRelated();
163			$relationClass = get_class($relationQuery);
164			$relationClass = new $relationClass;
165
166			$query->whereHas($this->field()->getRelationMethod($index), function ($query) use ($values, $relationClass, $relationQuery) {
167			$query->whereIn($relationQuery->getTable() .'.'. $relationClass->getKeyName(), $values);
168			});
169			}
170			}
171

Cherry-Pie / Jarboe

SelectFilter::options() A last analyzed 2024-09-13 11:39 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

SelectFilter::options() A
last analyzed 2024-09-13 11:39 UTC