TeamTNT\Scout\Engines\TNTSearchEngine

Complexity

Total Complexity

17

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	15
Bugs	5	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	delete()	0	10	1
A	search()	0	4	1
A	paginate()	0	13	2
A	__construct()	0	4	1
A	update()	0	18	2
A	performSearch()	0	9	3
A	filters()	0	6	1
A	map()	0	14	2
A	initIndex()	0	14	2
A	getIndexName()	0	8	2

<?php

namespace TeamTNT\Scout\Engines;

use Illuminate\Database\Eloquent\Collection;
use Laravel\Scout\Builder;
use Laravel\Scout\Engines\Engine;
use TeamTNT\TNTSearch\TNTSearch;

class TNTSearchEngine extends Engine
{
    /**
     * Create a new engine instance.
     *
     * @param TNTSearch $tnt
     */
    public function __construct(TNTSearch $tnt)
    {
        $this->tnt = $tnt;

The property tnt does not exist. Did you maybe forget to declare it?

    }

    /**
     * Update the given model in the index.
     *
     * @param Collection $models
     *
     * @return void
     */
    public function update($models)
    {
        $this->initIndex($models->first());

        $models->each(function ($model) {
            $searchableFields = $model->toSearchableArray();

            $this->tnt->selectIndex("{$this->getIndexName($model)}.index");
            $index = $this->tnt->getIndex();
            $index->setPrimaryKey($model->getKeyName());

            if ($model->getKey()) {
                $index->update($model->getKey(), $searchableFields);
            } else {
                $index->insert($searchableFields);
            }
        });
    }

    /**
     * Remove the given model from the index.
     *
     * @param Collection $models
     *
     * @return void
     */
    public function delete($models)
    {
        $this->initIndex($models->first());
        $models->each(function ($model) {
            $this->tnt->selectIndex("{$this->getIndexName($model)}.index");
            $index = $this->tnt->getIndex();
            $index->setPrimaryKey($model->getKeyName());
            $index->delete($model->id);
        });
    }

    /**
     * Perform the given search on the engine.
     *
     * @param Builder $builder
     *
     * @return mixed
     */
    public function search(Builder $builder)
    {
        return $this->performSearch($builder);
    }

    /**
     * Perform the given search on the engine.
     *
     * @param Builder $builder
     * @param int     $perPage
     * @param int     $page
     *
     * @return mixed
     */
    public function paginate(Builder $builder, $perPage, $page)
    {
        $builder->limit = 500;
        $results = $this->performSearch($builder);
        $chunks = array_chunk($results['ids'], $perPage);
        if (array_key_exists($page - 1, $chunks)) {
            $results['ids'] = $chunks[$page - 1];
        } else {
            $results['ids'] = end($chunks);
        }

        return $results;
    }

    /**
     * Perform the given search on the engine.
     *
     * @param Builder $builder
     * @param array   $options
     *
     * @return mixed
     */
    protected function performSearch(Builder $builder, array $options = [])

The parameter $options is not used and could be removed.

    {
        $model = $builder->model;
        $index = $builder->index ?: $this->getIndexName($model);
        $limit = $builder->limit ?: 10;
        $this->tnt->selectIndex("{$index}.index");

        return $this->tnt->search($builder->query, $limit);
    }

    /**
     * Get the filter array for the query.
     *
     * @param Builder $builder
     *
     * @return array
     */
    protected function filters(Builder $builder)
    {
        return collect($builder->wheres)->map(function ($value, $key) {
            return $key.'='.$value;
        })->values()->all();
    }

    /**
     * Map the given results to instances of the given model.
     *
     * @param mixed                               $results
     * @param \Illuminate\Database\Eloquent\Model $model
     *
     * @return Collection
     */
    public function map($results, $model)
    {
        if (count($results['ids']) === 0) {
            return Collection::make();
        }
        $keys = collect($results['ids']);
        $models = $model->whereIn(
            $model->getKeyName(), $keys
        )->get()->keyBy($model->getKeyName());

        return collect($results['ids'])->map(function ($hit) use ($models) {
            return $models[$hit];
        });
    }

    public function initIndex($model)
    {
        $indexName = $this->getIndexName($model);

        if (!file_exists($this->tnt->config['storage']."/{$indexName}.index")) {
            $indexer = $this->tnt->createIndex("$indexName.index");
            $indexer->setDatabaseHandle($model->getConnection()->getPdo());
            $indexer->disableOutput = true;
            $indexer->setPrimaryKey($model->getKeyName());
            $fields = implode(', ', array_keys($model->toSearchableArray()));
            $indexer->query("SELECT {$model->getKeyName()}, $fields FROM $indexName WHERE {$model->getKeyName()} = {$model->getKey()}");
            $indexer->run();
        }
    }

    /**
     * @param $model
     * @return mixed
     */
    private function getIndexName($model)
    {
        if (property_exists($model, 'searchable_index')) {
            return $model->searchable_index;
        }

        return $model->searchableAs();
    }
}