Add operator filter (<, =, >, ...) (#940)

* [FEAT] add filter by operators * [TEST] add test cases for filter by operator * [FEAT] add dynamic operator to filer by operators * [TEST] test dynamic operator filter
spatie · Sep 27, 2024 · 09d9162 · 09d9162
1 parent 34f35ce
commit 09d9162
Show file tree

Hide file tree

Showing 6 changed files with 224 additions and 0 deletions.
diff --git a/src/AllowedFilter.php b/src/AllowedFilter.php
@@ -3,11 +3,13 @@
 namespace Spatie\QueryBuilder;
 
 use Illuminate\Support\Collection;
+use Spatie\QueryBuilder\Enums\FilterOperator;
 use Spatie\QueryBuilder\Filters\Filter;
 use Spatie\QueryBuilder\Filters\FiltersBeginsWithStrict;
 use Spatie\QueryBuilder\Filters\FiltersCallback;
 use Spatie\QueryBuilder\Filters\FiltersEndsWithStrict;
 use Spatie\QueryBuilder\Filters\FiltersExact;
+use Spatie\QueryBuilder\Filters\FiltersOperator;
 use Spatie\QueryBuilder\Filters\FiltersPartial;
 use Spatie\QueryBuilder\Filters\FiltersScope;
 use Spatie\QueryBuilder\Filters\FiltersTrashed;
@@ -106,6 +108,13 @@ public static function custom(string $name, Filter $filterClass, $internalName =
         return new static($name, $filterClass, $internalName);
     }
 
+    public static function operator(string $name, FilterOperator $filterOperator, string $boolean = 'and', ?string $internalName = null, bool $addRelationConstraint = true, string $arrayValueDelimiter = null): self
+    {
+        static::setFilterArrayValueDelimiter($arrayValueDelimiter);
+
+        return new static($name, new FiltersOperator($addRelationConstraint, $filterOperator, $boolean), $internalName, $filterOperator);
+    }
+
     public function getFilterClass(): Filter
     {
         return $this->filterClass;

diff --git a/src/Enums/FilterOperator.php b/src/Enums/FilterOperator.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Spatie\QueryBuilder\Enums;
+
+enum FilterOperator: string
+{
+    case DYNAMIC = '';
+    case EQUAL = '=';
+    case LESS_THAN = '<';
+    case GREATER_THAN = '>';
+    case LESS_THAN_OR_EQUAL = '<=';
+    case GREATER_THAN_OR_EQUAL = '>=';
+    case NOT_EQUAL = '<>';
+
+    public function isDynamic()
+    {
+        return self::DYNAMIC === $this;
+    }
+}
diff --git a/src/Filters/FiltersOperator.php b/src/Filters/FiltersOperator.php
@@ -0,0 +1,68 @@
+<?php
+
+namespace Spatie\QueryBuilder\Filters;
+
+use Illuminate\Database\Eloquent\Builder;
+use Spatie\QueryBuilder\Enums\FilterOperator;
+
+/**
+ * @template TModelClass of \Illuminate\Database\Eloquent\Model
+ * @template-implements \Spatie\QueryBuilder\Filters\Filter<TModelClass>
+ */
+class FiltersOperator extends FiltersExact implements Filter
+{
+    public function __construct(protected bool $addRelationConstraint, protected FilterOperator $filterOperator, protected string $boolean)
+    {
+    }
+
+    /** {@inheritdoc} */
+    public function __invoke(Builder $query, $value, string $property)
+    {
+        $filterOperator = $this->filterOperator;
+
+        if ($this->addRelationConstraint) {
+            if ($this->isRelationProperty($query, $property)) {
+                $this->withRelationConstraint($query, $value, $property);
+
+                return;
+            }
+        }
+
+        if (is_array($value)) {
+            $query->where(function ($query) use ($value, $property) {
+                foreach($value as $item) {
+                    $this->__invoke($query, $item, $property);
+                }
+            });
+
+            return;
+        }
+        else if ($this->filterOperator->isDynamic()) {
+            $filterOperator = $this->getDynamicFilterOperator($value, $this);
+            $this->removeDynamicFilterOperatorFromValue($value, $filterOperator);
+        }
+
+        $query->where($query->qualifyColumn($property), $filterOperator->value, $value, $this->boolean);
+    }
+
+    protected function getDynamicFilterOperator(string $value): FilterOperator
+    {
+        $filterOperator = FilterOperator::EQUAL;
+
+        // match filter operators and assign the filter operator.
+        foreach(FilterOperator::cases() as $filterOperatorCase) {
+            if (str_starts_with($value, $filterOperatorCase->value) && ! $filterOperatorCase->isDynamic()) {
+                $filterOperator = $filterOperatorCase;
+            }
+        }
+
+        return $filterOperator;
+    }
+
+    protected function removeDynamicFilterOperatorFromValue(string &$value, FilterOperator $filterOperator)
+    {
+        if (str_contains($value, $filterOperator->value)) {
+            $value = substr_replace($value, '', 0, strlen($filterOperator->value));
+        }
+    }
+}
diff --git a/tests/FilterTest.php b/tests/FilterTest.php
@@ -9,6 +9,7 @@
 use function PHPUnit\Framework\assertObjectHasProperty;
 
 use Spatie\QueryBuilder\AllowedFilter;
+use Spatie\QueryBuilder\Enums\FilterOperator;
 use Spatie\QueryBuilder\Exceptions\InvalidFilterQuery;
 use Spatie\QueryBuilder\Filters\Filter as CustomFilter;
 use Spatie\QueryBuilder\Filters\Filter as FilterInterface;
@@ -657,3 +658,116 @@ public function __invoke(Builder $query, $value, string $property): Builder
         ->get();
     expect($models->count())->toEqual(0);
 });
+
+it('can filter name with equal operator filter', function () {
+    TestModel::create(['name' => 'John Doe']);
+
+    $results = createQueryFromFilterRequest([
+            'name' => 'John Doe',
+        ])
+        ->allowedFilters(AllowedFilter::operator('name', FilterOperator::EQUAL))
+        ->get();
+
+    expect($results)->toHaveCount(1);
+});
+
+it('can filter name with not equal operator filter', function () {
+    TestModel::create(['name' => 'John Doe']);
+
+    $results = createQueryFromFilterRequest([
+            'name' => 'John Doe',
+        ])
+        ->allowedFilters(AllowedFilter::operator('name', FilterOperator::NOT_EQUAL))
+        ->get();
+
+    expect($results)->toHaveCount(5);
+});
+
+it('can filter salary with greater than operator filter', function () {
+    TestModel::create(['salary' => 5000]);
+
+    $results = createQueryFromFilterRequest([
+            'salary' => 3000,
+        ])
+        ->allowedFilters(AllowedFilter::operator('salary', FilterOperator::GREATER_THAN))
+        ->get();
+
+    expect($results)->toHaveCount(1);
+});
+
+it('can filter salary with less than operator filter', function () {
+    TestModel::create(['salary' => 5000]);
+
+    $results = createQueryFromFilterRequest([
+            'salary' => 7000,
+        ])
+        ->allowedFilters(AllowedFilter::operator('salary', FilterOperator::LESS_THAN))
+        ->get();
+
+    expect($results)->toHaveCount(1);
+});
+
+it('can filter salary with greater than or equal operator filter', function () {
+    TestModel::create(['salary' => 5000]);
+
+    $results = createQueryFromFilterRequest([
+            'salary' => 3000,
+        ])
+        ->allowedFilters(AllowedFilter::operator('salary', FilterOperator::GREATER_THAN_OR_EQUAL))
+        ->get();
+
+    expect($results)->toHaveCount(1);
+});
+
+it('can filter salary with less than or equal operator filter', function () {
+    TestModel::create(['salary' => 5000]);
+
+    $results = createQueryFromFilterRequest([
+            'salary' => 7000,
+        ])
+        ->allowedFilters(AllowedFilter::operator('salary', FilterOperator::LESS_THAN_OR_EQUAL))
+        ->get();
+
+    expect($results)->toHaveCount(1);
+});
+
+it('can filter array of names with equal operator filter', function () {
+    TestModel::create(['name' => 'John Doe']);
+    TestModel::create(['name' => 'Max Doe']);
+
+    $results = createQueryFromFilterRequest([
+            'name' => 'John Doe,Max Doe',
+        ])
+        ->allowedFilters(AllowedFilter::operator('name', FilterOperator::EQUAL, 'or'))
+        ->get();
+
+    expect($results)->toHaveCount(2);
+});
+
+it('can filter salary with dynamic operator filter', function () {
+    TestModel::create(['salary' => 5000]);
+    TestModel::create(['salary' => 2000]);
+
+    $results = createQueryFromFilterRequest([
+            'salary' => '>2000',
+        ])
+        ->allowedFilters(AllowedFilter::operator('salary', FilterOperator::DYNAMIC))
+        ->get();
+
+    expect($results)->toHaveCount(1);
+});
+
+it('can filter salary with dynamic array operator filter', function () {
+    TestModel::create(['salary' => 1000]);
+    TestModel::create(['salary' => 2000]);
+    TestModel::create(['salary' => 3000]);
+    TestModel::create(['salary' => 4000]);
+
+    $results = createQueryFromFilterRequest([
+            'salary' => '>1000,<4000',
+        ])
+        ->allowedFilters(AllowedFilter::operator('salary', FilterOperator::DYNAMIC))
+        ->get();
+
+    expect($results)->toHaveCount(2);
+});
diff --git a/tests/RelationFilterTest.php b/tests/RelationFilterTest.php
@@ -1,6 +1,7 @@
 <?php
 
 use Spatie\QueryBuilder\AllowedFilter;
+use Spatie\QueryBuilder\Enums\FilterOperator;
 use Spatie\QueryBuilder\Tests\TestClasses\Models\TestModel;
 
 beforeEach(function () {
@@ -115,3 +116,15 @@
 
     expect($sql)->toContain('LOWER(`relatedModels`.`name`) LIKE ?');
 });
+
+it('can disable operator filtering based on related model properties', function () {
+    $addRelationConstraint = false;
+
+    $sql = createQueryFromFilterRequest([
+            'relatedModels.name' => $this->models->first()->name,
+        ])
+        ->allowedFilters(AllowedFilter::operator('relatedModels.name', FilterOperator::EQUAL, 'and', null, $addRelationConstraint))
+        ->toSql();
+
+    expect($sql)->toContain('`relatedModels`.`name` = ?');
+});
diff --git a/tests/TestCase.php b/tests/TestCase.php
@@ -37,6 +37,7 @@ protected function setUpDatabase(Application $app)
             $table->increments('id');
             $table->timestamps();
             $table->string('name')->nullable();
+            $table->double('salary')->nullable();
             $table->boolean('is_visible')->default(true);
         });