Merge pull request #1 from suenert/extend-map-function

PR: adds constrain macro to use eloquent for retrieving records. Fixes pagination when simple where() statements are used.

Author: michaelklopf

README.md

@@ -129,6 +129,61 @@ After that you can search your models with:
 
 `Post::search('Bugs Bunny')->get();`
 
+## Constrains
+
+Additionally to `where()` statements as conditions, you're able to use Eloquent queries to constrain your search. This allows you to take relationships into account.
+
+If you make use of this, the search command has to be called after all queries have been defined in your controller.
+
+The `where()` statements you already know can be applied everywhere.
+
+```php
+namespace App\Http\Controllers;
+
+use App\Post;
+
+class PostController extends Controller
+{
+    /**
+     * Display a listing of the resource.
+     *
+     * @return \Illuminate\Http\Response
+     */
+    public function index(Request $request)
+    {
+        $post = new Post;
+
+        // filter out posts to which the given topic is assigned
+        if($request->topic) {
+            $post = $post->whereNotIn('id', function($query){
+                $query->select('assigned_to')->from('comments')->where('topic','=', request()->input('topic'));
+            });
+        }
+
+        // only posts from people that are no moderators
+        $post = $post->byRole('moderator','!=');
+
+        // when user is not admin filter out internal posts
+        if(!auth()->user()->hasRole('admin'))
+        {
+            $post= $post->where('internal_post', false);
+        }
+
+        if ($request->searchTerm) {
+            $constraints = $post; // not necessary but for better readability
+            $post = Department::search($request->searchTerm)->constrain($constraints);
+        }
+
+        $post->where('deleted', false);
+
+        $paginator = $department->paginate(10);
+        $posts = $paginator->getCollection();
+
+        // return posts
+    }
+}
+```
+
 ## Sponsors
 
 Become a sponsor and get your logo on our README on Github with a link to your site. [[Become a sponsor](https://opencollective.com/tntsearch#sponsor)]

src/Engines/TNTSearchEngine.php

@@ -112,16 +112,54 @@ public function paginate(Builder $builder, $perPage, $page)
             $results['hits'] = $builder->limit;
         }
 
-        $chunks = array_chunk($results['ids'], $perPage);
+        $searchResults = $results['ids'];
 
-        if (!empty($chunks)) {
-            if (array_key_exists($page - 1, $chunks)) {
-                $results['ids'] = $chunks[$page - 1];
-            } else {
-                $results['ids'] = end($chunks);
-            }
+        $qualifiedKeyName = $builder->model->getQualifiedKeyName();  // tableName.id
+        $subQualifiedKeyName = 'sub.' . $builder->model->getKeyName(); // sub.id
+    
+        $sub = $this->getBuilder($builder->model)->whereIn(
+            $qualifiedKeyName, $searchResults
+        ); // sub query for left join
+
+        /*
+         * The search index results ($results['ids']) need to be compared against our query
+         * that contains the constraints.
+         * 
+         * To get the correct results and counts for the pagination, we remove those ids
+         * from the search index results that were found by the search but are not part of
+         * the query ($sub) that is constrained.
+         * 
+         * This is achieved with self joining the constrained query as subquery and selecting
+         * the ids which are not matching to anything (i.e., is null).
+         * 
+         * The constraints usually remove only a small amount of results, which is why the non
+         * matching results are looked up and removed, instead of returning a collection with
+         * all the valid results.
+         */
+        $discardIds = $builder->model->newQuery()
+            ->select($qualifiedKeyName)
+            ->leftJoinSub($sub->getQuery(), 'sub', $subQualifiedKeyName, '=', $qualifiedKeyName)
+            ->whereIn($qualifiedKeyName, $searchResults)
+            ->whereNull($subQualifiedKeyName)
+            ->pluck($builder->model->getKeyName());
+
+        // returns values of $results['ids'] that are not part of $discardIds
+        $filtered = collect($results['ids'])->diff($discardIds);
+
+        $results['hits'] = $filtered->count();
+
+        $chunks = array_chunk($filtered->toArray(), $perPage);
+        
+        if (empty($chunks)) {
+            return $results;
         }
 
+        if (array_key_exists($page - 1, $chunks)) {
+            $results['ids'] = $chunks[$page - 1];
+        } else {
+            $results['ids'] = end($chunks);
+        }
+        
         return $results;
     }
 
@@ -184,19 +222,43 @@ public function map($results, $model)
             return Collection::make();
         }
 
-        $keys   = collect($results['ids'])->values()->all();
-        $fieldsWheres = array_keys($this->builder->wheres);
-        $models = $model->whereIn(
+        $keys = collect($results['ids'])->values()->all();
+
+        $builder = $this->getBuilder($model);
+
+        $models = $builder->whereIn(
             $model->getQualifiedKeyName(), $keys
         )->get()->keyBy($model->getKeyName());
 
         return collect($results['ids'])->map(function ($hit) use ($models) {
-            return $models->has($hit) ? $models[$hit] : null;
-        })->filter(function ($model) use ($fieldsWheres) {
-            return !is_null($model) && array_reduce($fieldsWheres, function ($carry, $item) use($model) {
-                    return $carry && $model[$item] == $this->builder->wheres[$item];
-                }, true);
-        });
+            if (isset($models[$hit])) {
+                return $models[$hit];
+            }
+        })->filter()->values();
+    }
+
+    /**
+     * Return query builder either from given constraints, or as
+     * new query. Add where statements to builder when given.
+     *
+     * @param \Illuminate\Database\Eloquent\Model $model
+     *
+     * @return Builder
+     */
+    public function getBuilder($model)
+    {
+        // get query as given constraint or create a new query
+        $builder = $this->builder->constraints ?? $model->newQuery();
+
+        // iterate over given where clauses
+        return collect($this->builder->wheres)->map(function ($value, $key) {
+            // for reduce function combine key and value into array
+            return [$key, $value];
+        })->reduce(function ($builder, $where) {
+            // separate key, value again
+            list($key, $value) = $where;
+            return $builder->where($key, $value);
+        }, $builder);
     }
 
     /**

src/TNTSearchScoutServiceProvider.php

@@ -2,6 +2,7 @@
 
 use TeamTNT\TNTSearch\TNTSearch;
 use Laravel\Scout\EngineManager;
+use Laravel\Scout\Builder;
 use Illuminate\Support\ServiceProvider;
 use TeamTNT\Scout\Console\ImportCommand;
 use TeamTNT\Scout\Engines\TNTSearchEngine;
@@ -35,6 +36,11 @@ public function boot()
                 ImportCommand::class,
             ]);
         }
+
+        Builder::macro('constrain', function($constraints) {
+            $this->constraints = $constraints;
+            return $this;
+        });
     }
 
     protected function setFuzziness($tnt)