Merge pull request #4 from ghonijee/hotfix/fixing-filter-relation

Fixing bug filter relation data
ghonijee · Nov 3, 2021 · ceac3b1 · ceac3b1
2 parents 396910e + f84237d
commit ceac3b1
Show file tree

Hide file tree

Showing 6 changed files with 133 additions and 30 deletions.
diff --git a/Models/TestModel.php b/Models/TestModel.php
@@ -37,6 +37,11 @@ public function comments()
         return $this->hasMany(TestComment::class, 'test_model_id');
     }
 
+    public function dataComments()
+    {
+        return $this->hasMany(TestComment::class, 'test_model_id');
+    }
+
     public function scopeActive(Builder $query)
     {
         $query->where('active', 1);

diff --git a/src/Builders/FilterQuery.php b/src/Builders/FilterQuery.php
@@ -5,6 +5,7 @@
 use GhoniJee\DxAdapter\Data\FilterData;
 use GhoniJee\DxAdapter\FilterClass\BuilderFilterData;
 use GhoniJee\DxAdapter\FilterClass\BuilderFilterQuery;
+use GhoniJee\DxAdapter\FilterClass\BuilderRelationFilterQuery;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Relations\Relation;
 use Illuminate\Support\Collection;
@@ -21,6 +22,7 @@ protected function parseFilter()
         $this->setArray();
 
         $this->buildFilterData();
+
         $this->query = $this->buildFilterQuery($this->query, $this->filter);
 
         return $this;
@@ -38,7 +40,7 @@ private function buildFilterData()
         $this->filter = BuilderFilterData::fromRequest($this->filter);
     }
 
-    private function buildFilterQuery(Builder $query, $collection)
+    private function buildFilterQuery(Builder &$query, $collection)
     {
         $collection->each(function ($item) use ($query) {
             if (is_string($item)) {
@@ -54,19 +56,7 @@ private function buildFilterQuery(Builder $query, $collection)
             }
 
             if ($this->isRelationFilter($query, $item)) {
-
-                [$relation,] = collect(explode('.', $item->field))
-                    ->pipe(function (Collection $parts) {
-                        return [
-                            $parts->except(count($parts) - 1)->implode('.'),
-                            $parts->last(),
-                        ];
-                    });
-
-                $this->query->whereHas($relation, function (Builder $relationQuery) use ($item) {
-                    $relationQuery = BuilderFilterQuery::fromDataType($relationQuery, $item, $this->conjungtion)->query();
-                });
-
+                $query = BuilderRelationFilterQuery::fromDataType($query, $item, $this->conjungtion)->query();
                 return true;
             }
 
@@ -78,16 +68,14 @@ private function buildFilterQuery(Builder $query, $collection)
 
     private function isRelationFilter(Builder $query, FilterData $item)
     {
-        if (!Str::contains($item->field, '.')) {
+        if (!$item->isRelation) {
             return false;
         }
 
-        $firstRelationship = explode('.', $item->field)[0];
-
-        if (!method_exists($query->getModel(), $firstRelationship)) {
+        if (!method_exists($query->getModel(), $item->relationMethod)) {
             return false;
         }
 
-        return is_a($query->getModel()->{$firstRelationship}(), Relation::class);
+        return is_a($query->getModel()->{$item->relationMethod}(), Relation::class);
     }
 }
diff --git a/src/Data/FilterData.php b/src/Data/FilterData.php
@@ -4,6 +4,8 @@
 
 use DateTime;
 use GhoniJee\DxAdapter\Enums\ValueDataType;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Str;
 
 class FilterData
 {
@@ -15,11 +17,14 @@ class FilterData
 
     public $type;
 
-    public $relation;
+    public $relationMethod;
+
+    public bool $isRelation = false;
 
     public function __construct($data)
     {
         list($this->field, $this->condition, $this->value) = $data;
+        $this->isRelationFilter();
         $this->setValueType();
     }
 
@@ -81,4 +86,18 @@ private function isNumeric()
         }
         return false;
     }
+
+    public function isRelationFilter()
+    {
+        if (Str::contains($this->field, '.')) {
+            $this->isRelation = true;
+            [$this->relationMethod, $this->field] = collect(explode('.', $this->field))
+                ->pipe(function (Collection $parts) {
+                    return [
+                        $parts->except(count($parts) - 1)->implode('.'),
+                        $parts->last(),
+                    ];
+                });
+        }
+    }
 }
diff --git a/src/FilterClass/BuilderFilterQuery.php b/src/FilterClass/BuilderFilterQuery.php
@@ -26,7 +26,7 @@ public function __construct($query, FilterData $filterData, $conjungtion)
         $this->conjungtion = $conjungtion;
     }
 
-    public static function fromDataType($query, FilterData $filterData, $conjungtion)
+    public static function fromDataType($query, FilterData $filterData, $conjungtion = null)
     {
         return new self($query, $filterData, $conjungtion);
     }

diff --git a/src/FilterClass/BuilderRelationFilterQuery.php b/src/FilterClass/BuilderRelationFilterQuery.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace GhoniJee\DxAdapter\FilterClass;
+
+use Exception;
+use GhoniJee\DxAdapter\Data\FilterData;
+use GhoniJee\DxAdapter\Enums\ValueDataType;
+use GhoniJee\DxAdapter\FilterClass\QueryClass\BooleanFilter;
+use GhoniJee\DxAdapter\FilterClass\QueryClass\DateFilter;
+use GhoniJee\DxAdapter\FilterClass\QueryClass\NullFilter;
+use GhoniJee\DxAdapter\FilterClass\QueryClass\NumericFilter;
+use GhoniJee\DxAdapter\FilterClass\QueryClass\StringFilter;
+
+class BuilderRelationFilterQuery
+{
+    protected $query;
+
+    protected FilterData $filterData;
+
+    protected $conjungtion;
+
+    public function __construct($query, FilterData $filterData, $conjungtion)
+    {
+        $this->query = $query;
+        $this->filterData = $filterData;
+        $this->conjungtion = $conjungtion;
+    }
+
+    public static function fromDataType($query, FilterData $filterData, $conjungtion = null)
+    {
+        return new self($query, $filterData, $conjungtion);
+    }
+
+    public function query()
+    {
+        switch ($this->conjungtion) {
+            case '!':
+                $this->query->whereDoesntHave($this->filterData->relationMethod, function ($relationQuery) {
+                    $relationQuery = BuilderFilterQuery::fromDataType($relationQuery, $this->filterData)->query();
+                });
+                break;
+            case 'or':
+                $this->query->orWhereHas($this->filterData->relationMethod, function ($relationQuery) {
+                    $relationQuery = BuilderFilterQuery::fromDataType($relationQuery, $this->filterData)->query();
+                });
+                break;
+            default:
+                $this->query->whereHas($this->filterData->relationMethod, function ($relationQuery) {
+                    $relationQuery = BuilderFilterQuery::fromDataType($relationQuery, $this->filterData)->query();
+                });
+                break;
+        }
+        return $this->query;
+    }
+}
diff --git a/tests/Feature/FilterTest.php b/tests/Feature/FilterTest.php
@@ -237,7 +237,7 @@
     $query = TestModel::query();
     $queryBuilder = DxAdapter::load($query, $this->request)->toSql();
     $expected = TestModel::whereHas('comments', function ($queryComment) {
-        $queryComment->where('comments.comment', 'like', 'ahmad');
+        $queryComment->where('comment', 'like', 'ahmad');
     })->where(function ($q) {
         $q->where('active', 0);
         $q->orWhere('active', 1);
@@ -247,18 +247,54 @@
 });
 
 
-test('can filter with string params', function () {
-    $filter = [['comments.comment', 'contains', 'test'], 'and', [['active', '=', 0], 'or', ['active', '=', 1]]];
+test('can filter multi relation data with conjungtion OR', function () {
+    $filter = [[['dataComments.comment', 'contains', 'test'], 'or', ['dataComments.comment', 'contains', 'est']], 'and', ['active', '=', 1]];
     $this->request->replace(['filter' => json_encode($filter)]);
 
     $query = TestModel::query();
     $queryBuilder = DxAdapter::load($query, $this->request)->toSql();
-    $expected = TestModel::whereHas('comments', function ($queryComment) {
-        $queryComment->where('comments.comment', 'like', 'ahmad');
-    })->where(function ($q) {
-        $q->where('active', 0);
-        $q->orWhere('active', 1);
-    })->toSql();
+
+    $expected = TestModel::where(function ($q) {
+        $q->whereHas('dataComments', function ($queryComment) {
+            $queryComment->where('comment', 'like', 'test');
+        })->orWhereHas('dataComments', function ($queryCommentNew) {
+            $queryCommentNew->where('comment', 'like', 'est');
+        });
+    })->where('active', 1)->toSql();
+
+    expect($queryBuilder)->toEqual($expected);
+});
+test('can filter multi relation data with conjungtion AND', function () {
+    $filter = [[['dataComments.comment', 'contains', 'test'], 'and', ['dataComments.comment', 'contains', 'est']], 'and', ['active', '=', 1]];
+    $this->request->replace(['filter' => json_encode($filter)]);
+
+    $query = TestModel::query();
+    $queryBuilder = DxAdapter::load($query, $this->request)->toSql();
+
+    $expected = TestModel::where(function ($q) {
+        $q->whereHas('dataComments', function ($queryComment) {
+            $queryComment->where('comment', 'like', 'test');
+        })->whereHas('dataComments', function ($queryCommentNew) {
+            $queryCommentNew->where('comment', 'like', 'est');
+        });
+    })->where('active', 1)->toSql();
+
+    expect($queryBuilder)->toEqual($expected);
+});
+test('can filter multi relation data with conjungtion NOT', function () {
+    $filter = [[['dataComments.comment', 'contains', 'test'], '!', ['dataComments.comment', 'contains', 'est']], 'and', ['active', '=', 1]];
+    $this->request->replace(['filter' => json_encode($filter)]);
+
+    $query = TestModel::query();
+    $queryBuilder = DxAdapter::load($query, $this->request)->toSql();
+
+    $expected = TestModel::where(function ($q) {
+        $q->whereHas('dataComments', function ($queryComment) {
+            $queryComment->where('comment', 'like', 'test');
+        })->whereDoesntHave('dataComments', function ($queryCommentNew) {
+            $queryCommentNew->where('comment', 'like', 'est');
+        });
+    })->where('active', 1)->toSql();
 
     expect($queryBuilder)->toEqual($expected);
 });