ElasticSearchEngine::getSearchBody() - Code Metrics - Inspection of "Allow custom hits iterator" - matchish/laravel-scout-elasticsearch - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#85)

unknown

created 2020-02-09 10:45 UTC

ElasticSearchEngine::getSearchBody() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	3
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	7
ccs	0
cts	4
cp	0
crap	6
rs	10

<?php

namespace Matchish\ScoutElasticSearch\Engines;

use Elasticsearch\Common\Exceptions\ServerErrorResponseException;
use Illuminate\Database\Eloquent\Collection;
use Laravel\Scout\Builder as BaseBuilder;
use Laravel\Scout\Engines\Engine;
use Laravel\Scout\Searchable;
use Matchish\ScoutElasticSearch\ElasticSearch\HitsIteratorAggregate;
use Matchish\ScoutElasticSearch\ElasticSearch\Params\Bulk;
use Matchish\ScoutElasticSearch\ElasticSearch\Params\Indices\Refresh;
use Matchish\ScoutElasticSearch\ElasticSearch\Params\Search as SearchParams;
use Matchish\ScoutElasticSearch\ElasticSearch\SearchFactory;
use Matchish\ScoutElasticSearch\ElasticSearch\SearchResults;
use ONGR\ElasticsearchDSL\Query\MatchAllQuery;
use ONGR\ElasticsearchDSL\Search;

final class ElasticSearchEngine extends Engine
{
    /**
     * The ElasticSearch client.
     *
     * @var \Elasticsearch\Client
     */
    protected $elasticsearch;

    /** @var string */
    private $hitsIterator = null;

    private $builder = null;

    private $searchBody = null;


    private $options = [];

    /**
     * Create a new engine instance.
     *
     * @param \Elasticsearch\Client $elasticsearch
     * @return void
     */
    public function __construct(\Elasticsearch\Client $elasticsearch)
    {
        $this->elasticsearch = $elasticsearch;
    }

    /**
     * {@inheritdoc}
     */
    public function update($models)
    {
        $params = new Bulk();
        $params->index($models);
        $response = $this->elasticsearch->bulk($params->toArray());
        if (array_key_exists('errors', $response) && $response['errors']) {
            $error = new ServerErrorResponseException(json_encode($response, JSON_PRETTY_PRINT));
            throw new \Exception('Bulk update error', $error->getCode(), $error);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function delete($models)
    {
        $params = new Bulk();
        $params->delete($models);
        $this->elasticsearch->bulk($params->toArray());
    }

    /**
     * {@inheritdoc}
     */
    public function flush($model)
    {
        $indexName = $model->searchableAs();
        $exist = $this->elasticsearch->indices()->exists(['index' => $indexName]);
        if ($exist) {
            $body = (new Search())->addQuery(new MatchAllQuery())->toArray();
            $params = new SearchParams($indexName, $body);
            $this->elasticsearch->deleteByQuery($params->toArray());
            $this->elasticsearch->indices()->refresh((new Refresh($indexName))->toArray());
        }
    }

    /**
     * {@inheritdoc}
     */
    public function search(BaseBuilder $builder)
    {
        return $this->performSearch($builder, []);
    }

    /**
     * {@inheritdoc}
     */
    public function paginate(BaseBuilder $builder, $perPage, $page)
    {
        return $this->performSearch($builder, [
            'from' => ($page - 1) * $perPage,
            'size' => $perPage,
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function mapIds($results)
    {
        return collect($results['hits']['hits'])->pluck('_id');
    }

    /**
     * @param $value
     */
    public function useHitsIterator($value)
    {
        $this->hitsIterator = $value;
    }

    /**
     * {@inheritdoc}
     */
    public function map(BaseBuilder $builder, $results, $model)
    {
        if(is_null($this->hitsIterator)){

            $hits = app()->makeWith(HitsIteratorAggregate::class,
                ['results' => $results,
                    'callback' => $builder->queryCallback,
                ]);
        } else {
            $hits = app()->makeWith($this->hitsIterator,
                ['results' => $results,
                    'callback' => $builder->queryCallback,
                ]);
        }

        return new Collection($hits);
    }

    /**
     * {@inheritdoc}
     */
    public function getTotalCount($results)
    {
        return $results['hits']['total']['value'];
    }

    public function getSearchBody($options = [])
    {
        foreach($options as $key => $option){
            $this->options[$key] = $option;
        }

        return SearchFactory::create($this->builder, $this->options);
    }

    /**
     * @param BaseBuilder $builder
     * @param array $options
     * @return SearchResults|mixed
     */
    private function performSearch(BaseBuilder $builder, $options = [])
    {
        if ($builder->callback) {
            /** @var callable */
            $callback = $builder->callback;

            $this->builder = $builder;
            $this->options = $options;

            return call_user_func(
                $callback,
                $this->elasticsearch,
                $this
            );
        }

        $searchBody = SearchFactory::create($builder, $options);

        /** @var Searchable $model */
        $model = $builder->model;
        $indexName = $builder->index ?: $model->searchableAs();
        $params = new SearchParams($indexName, $searchBody->toArray());

        return $this->elasticsearch->search($params->toArray());
    }
}


1		<?php
2
3		namespace Matchish\ScoutElasticSearch\Engines;
4
5		use Elasticsearch\Common\Exceptions\ServerErrorResponseException;
6		use Illuminate\Database\Eloquent\Collection;
7		use Laravel\Scout\Builder as BaseBuilder;
8		use Laravel\Scout\Engines\Engine;
9		use Laravel\Scout\Searchable;
10		use Matchish\ScoutElasticSearch\ElasticSearch\HitsIteratorAggregate;
11		use Matchish\ScoutElasticSearch\ElasticSearch\Params\Bulk;
12		use Matchish\ScoutElasticSearch\ElasticSearch\Params\Indices\Refresh;
13		use Matchish\ScoutElasticSearch\ElasticSearch\Params\Search as SearchParams;
14		use Matchish\ScoutElasticSearch\ElasticSearch\SearchFactory;
15		use Matchish\ScoutElasticSearch\ElasticSearch\SearchResults;
16		use ONGR\ElasticsearchDSL\Query\MatchAllQuery;
17		use ONGR\ElasticsearchDSL\Search;
18
19		final class ElasticSearchEngine extends Engine
20		{
21		/**
22		* The ElasticSearch client.
23		*
24		* @var \Elasticsearch\Client
25		*/
26		protected $elasticsearch;
27
28		/** @var string */
29		private $hitsIterator = null;
30
31		private $builder = null;
32
33		private $searchBody = null;
		0 ignored issues – show introduced 2020-02-09 10:49 UTC by Report Bug Copy Issue Report The private property `$searchBody` is not used, and could be removed. Loading history...
34
35		private $options = [];
36
37		/**
38		* Create a new engine instance.
39		*
40		* @param \Elasticsearch\Client $elasticsearch
41		* @return void
42		*/
43	27	public function __construct(\Elasticsearch\Client $elasticsearch)
44		{
45	27	$this->elasticsearch = $elasticsearch;
46	27	}
47
48		/**
49		* {@inheritdoc}
50		*/
51	20	public function update($models)
52		{
53	20	$params = new Bulk();
54	20	$params->index($models);
55	20	$response = $this->elasticsearch->bulk($params->toArray());
56	20	if (array_key_exists('errors', $response) && $response['errors']) {
57	1	$error = new ServerErrorResponseException(json_encode($response, JSON_PRETTY_PRINT));
58	1	throw new \Exception('Bulk update error', $error->getCode(), $error);
59		}
60	19	}
61
62		/**
63		* {@inheritdoc}
64		*/
65	1	public function delete($models)
66		{
67	1	$params = new Bulk();
68	1	$params->delete($models);
69	1	$this->elasticsearch->bulk($params->toArray());
70	1	}
71
72		/**
73		* {@inheritdoc}
74		*/
75	2	public function flush($model)
76		{
77	2	$indexName = $model->searchableAs();
78	2	$exist = $this->elasticsearch->indices()->exists(['index' => $indexName]);
79	2	if ($exist) {
80	2	$body = (new Search())->addQuery(new MatchAllQuery())->toArray();
81	2	$params = new SearchParams($indexName, $body);
82	2	$this->elasticsearch->deleteByQuery($params->toArray());
83	2	$this->elasticsearch->indices()->refresh((new Refresh($indexName))->toArray());
84		}
85	2	}
86
87		/**
88		* {@inheritdoc}
89		*/
90	6	public function search(BaseBuilder $builder)
91		{
92	6	return $this->performSearch($builder, []);
93		}
94
95		/**
96		* {@inheritdoc}
97		*/
98	1	public function paginate(BaseBuilder $builder, $perPage, $page)
99		{
100	1	return $this->performSearch($builder, [
101	1	'from' => ($page - 1) * $perPage,
102	1	'size' => $perPage,
103		]);
104		}
105
106		/**
107		* {@inheritdoc}
108		*/
109	1	public function mapIds($results)
110		{
111	1	return collect($results['hits']['hits'])->pluck('_id');
112		}
113
114		/**
115		* @param $value
116		*/
117		public function useHitsIterator($value)
118		{
119		$this->hitsIterator = $value;
120		}
121
122		/**
123		* {@inheritdoc}
124		*/
125	7	public function map(BaseBuilder $builder, $results, $model)
126		{
127	7	if(is_null($this->hitsIterator)){
		0 ignored issues – show introduced 2020-02-08 13:02 UTC by Report Bug Copy Issue Report The condition `is_null($this->hitsIterator)` is always `false`. Loading history...
128	7	$hits = app()->makeWith(HitsIteratorAggregate::class,
129	7	['results' => $results,
130	7	'callback' => $builder->queryCallback,
131		]);
132		} else {
133		$hits = app()->makeWith($this->hitsIterator,
134		['results' => $results,
135		'callback' => $builder->queryCallback,
136		]);
137		}
138
139	7	return new Collection($hits);
140		}
141
142		/**
143		* {@inheritdoc}
144		*/
145	1	public function getTotalCount($results)
146		{
147	1	return $results['hits']['total']['value'];
148		}
149
150		public function getSearchBody($options = [])
151		{
152		foreach($options as $key => $option){
153		$this->options[$key] = $option;
154		}
155
156		return SearchFactory::create($this->builder, $this->options);
157		}
158
159		/**
160		* @param BaseBuilder $builder
161		* @param array $options
162		* @return SearchResults\|mixed
163		*/
164	7	private function performSearch(BaseBuilder $builder, $options = [])
165		{
166	7	if ($builder->callback) {
167		/** @var callable */
168	2	$callback = $builder->callback;
169
170	2	$this->builder = $builder;
171	2	$this->options = $options;
172
173	2	return call_user_func(
174	2	$callback,
175	2	$this->elasticsearch,
176	2	$this
177		);
178		}
179
180	5	$searchBody = SearchFactory::create($builder, $options);
181
182		/** @var Searchable $model */
183	5	$model = $builder->model;
184	5	$indexName = $builder->index ?: $model->searchableAs();
185	5	$params = new SearchParams($indexName, $searchBody->toArray());
186
187	5	return $this->elasticsearch->search($params->toArray());
188		}
189		}
190

matchish / laravel-scout-elasticsearch

Pull Request — master (#85)

ElasticSearchEngine::getSearchBody() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like