Completed
Pull Request — master (#451)
by
unknown
01:32
created

AllowedFilter::setFilterArrayValueDelimiter()   A

Complexity

Conditions 2
Paths 2

Size

Total Lines 6

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
dl 0
loc 6
rs 10
c 0
b 0
f 0
cc 2
nc 2
nop 1
1
<?php
2
3
namespace Spatie\QueryBuilder;
4
5
use Illuminate\Support\Collection;
6
use Spatie\QueryBuilder\Filters\Filter;
7
use Spatie\QueryBuilder\Filters\FiltersCallback;
8
use Spatie\QueryBuilder\Filters\FiltersExact;
9
use Spatie\QueryBuilder\Filters\FiltersPartial;
10
use Spatie\QueryBuilder\Filters\FiltersScope;
11
use Spatie\QueryBuilder\Filters\FiltersTrashed;
12
13
class AllowedFilter
14
{
15
    /** @var \Spatie\QueryBuilder\Filters\Filter */
16
    protected $filterClass;
17
18
    /** @var string */
19
    protected $name;
20
21
    /** @var string */
22
    protected $internalName;
23
24
    /** @var \Illuminate\Support\Collection */
25
    protected $ignored;
26
27
    /** @var mixed */
28
    protected $default;
29
30
    public function __construct(string $name, Filter $filterClass, ?string $internalName = null)
31
    {
32
        $this->name = $name;
33
34
        $this->filterClass = $filterClass;
35
36
        $this->ignored = Collection::make();
37
38
        $this->internalName = $internalName ?? $name;
39
    }
40
41
    public function filter(QueryBuilder $query, $value)
42
    {
43
        $valueToFilter = $this->resolveValueForFiltering($value);
44
45
        if (is_null($valueToFilter)) {
46
            return;
47
        }
48
49
        ($this->filterClass)($query, $valueToFilter, $this->internalName);
50
    }
51
52
    public static function setFilterArrayValueDelimiter(string $delimiter): void
53
    {
54
        if (isset($delimiter)) {
55
            QueryBuilderRequest::setFilterArrayValueDelimiter($delimiter);
56
        }
57
    }
58
59
    public static function exact(string $name, ?string $internalName = null, bool $addRelationConstraint = true, string $arrayValueDelimiter = null): self
60
    {
61
        static::setFilterArrayValueDelimiter($arrayValueDelimiter);
62
        return new static($name, new FiltersExact($addRelationConstraint), $internalName);
63
    }
64
65
    public static function partial(string $name, $internalName = null, bool $addRelationConstraint = true, string $arrayValueDelimiter = null): self
66
    {
67
        static::setFilterArrayValueDelimiter($arrayValueDelimiter);
68
        return new static($name, new FiltersPartial($addRelationConstraint), $internalName);
69
    }
70
71
    public static function scope(string $name, $internalName = null, string $arrayValueDelimiter = null): self
72
    {
73
        static::setFilterArrayValueDelimiter($arrayValueDelimiter);
74
        return new static($name, new FiltersScope(), $internalName);
75
    }
76
77
    public static function callback(string $name, $callback, $internalName = null, string $arrayValueDelimiter = null): self
78
    {
79
        static::setFilterArrayValueDelimiter($arrayValueDelimiter);
80
        return new static($name, new FiltersCallback($callback), $internalName);
81
    }
82
83
    public static function trashed(string $name = 'trashed', $internalName = null): self
84
    {
85
        return new static($name, new FiltersTrashed(), $internalName);
86
    }
87
88
    public static function custom(string $name, Filter $filterClass, $internalName = null, string $arrayValueDelimiter = null): self
89
    {
90
        static::setFilterArrayValueDelimiter($arrayValueDelimiter);
91
        return new static($name, $filterClass, $internalName);
92
    }
93
94
    public function getName(): string
95
    {
96
        return $this->name;
97
    }
98
99
    public function isForFilter(string $filterName): bool
100
    {
101
        return $this->name === $filterName;
102
    }
103
104
    public function ignore(...$values): self
105
    {
106
        $this->ignored = $this->ignored
107
            ->merge($values)
108
            ->flatten();
109
110
        return $this;
111
    }
112
113
    public function getIgnored(): array
114
    {
115
        return $this->ignored->toArray();
116
    }
117
118
    public function getInternalName(): string
119
    {
120
        return $this->internalName;
121
    }
122
123
    public function default($value): self
124
    {
125
        $this->default = $value;
126
127
        return $this;
128
    }
129
130
    public function getDefault()
131
    {
132
        return $this->default;
133
    }
134
135
    public function hasDefault(): bool
136
    {
137
        return isset($this->default);
138
    }
139
140
    protected function resolveValueForFiltering($value)
141
    {
142
        if (is_array($value)) {
143
            $remainingProperties = array_diff($value, $this->ignored->toArray());
144
145
            return !empty($remainingProperties) ? $remainingProperties : null;
146
        }
147
148
        return !$this->ignored->contains($value) ? $value : null;
149
    }
150
}
151