ElasticConnection::search() - Code Metrics - Inspection of "Fixing body query due elasticsearch 5 compatibilit..." - andsalves/doctrine-elastic - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a4e5c9...2c0076 )

by Anderson

created 2017-06-06 20:28 UTC

ElasticConnection::search() C

↳ Parent: ElasticConnection

Complexity

Conditions	12
Paths	9

Size

Total Lines	49
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	49
rs	5.1474
c	0
b	0
f	0
cc	12
eloc	28
nc	9
nop	5

How to fix Complexity

<?php

namespace DoctrineElastic\Connection;

use DoctrineElastic\Exception\ConnectionException;
use DoctrineElastic\Exception\ElasticOperationException;
use DoctrineElastic\Helper\MappingHelper;
use DoctrineElastic\Http\CurlRequest;
use DoctrineElastic\Traiting\ErrorGetterTrait;

/**
 * Default elastic connection class for general operations
 * Notice that the original elastic result of most of operations can be get by $return param
 *
 * @author Andsalves <[email protected]>
 */
class ElasticConnection implements ElasticConnectionInterface {

    use ErrorGetterTrait;

    /** Override default elastic limit size query */
    const DEFAULT_MAX_RESULTS = 10000;

    /** @var CurlRequest */
    protected $curlRequest;

    /** @var float */
    protected $esVersion;

    public function __construct(array $hosts) {
        $this->curlRequest = new CurlRequest();
        $baseHost = reset($hosts);

        if (empty($baseHost) || !is_string($baseHost) || !preg_match('/http/', $baseHost)) {
            throw new ConnectionException("Elasticsearch host is invalid. ");
        }

        $this->curlRequest->setBaseUrl($baseHost);
    }

    /**
     * @param string $index
     * @param array|null $mappings
     * @param array|null $settings
     * @param array|null $aliases
     * @param array|null $return
     * @return bool
     */
    public function createIndex(
        $index, array $mappings = null, array $settings = null, array $aliases = null, array &$return = null
    ) {
        if ($this->indexExists($index)) {
            throw new \InvalidArgumentException(sprintf("'%s' index already exists", $index));
        }

        $params = [];

        if (is_array($mappings) && !empty($mappings)) {
            $params['mappings'] = MappingHelper::patchMappings($mappings, floor($this->getElasticsearchVersion()));
        }

        if (is_array($settings) && !empty($settings)) {
            $params['settings'] = $settings;
        }

        if (is_array($aliases) && !empty($aliases)) {
            $params['aliases'] = $aliases;
        }

        $response = $this->curlRequest->request($index, $params, 'PUT');
        $return = $response['content'];

        if (isset($return['acknowledged']) && $return['acknowledged']) {
            return $return['acknowledged'];
        }

        $this->setErrorFromElasticReturn($return);

        return false;
    }

    /**
     * @param string $index
     * @param array|null $return
     * @return bool
     * @throws ElasticOperationException
     */
    public function deleteIndex($index, array &$return = null) {
        if (is_string($index) && !strstr('_all', $index) && !strstr('*', $index)) {
            $response = $this->curlRequest->request("$index?refresh=true", [], 'DELETE');
            $return = $response['content'];

            if ($response['status'] == 404) {
                throw new ElasticOperationException("Index '$index' doesn't exist so cannot be deleted. ");
            }

            if (isset($return['acknowledged'])) {
                return $return['acknowledged'];
            }
        } else {
            throw new ElasticOperationException('Index name is invalid for deletion. ');
        }

        $this->setErrorFromElasticReturn($return);

        return false;
    }

    /**
     * @param string $index
     * @param string $type
     * @param array $mappings
     * @param array|null $return
     * @return bool
     * @throws ElasticOperationException
     */
    public function createType($index, $type, array $mappings = [], array &$return = null) {
        if (!$this->indexExists($index)) {
            throw new \InvalidArgumentException(sprintf("%s' index does not exists", $index));
        }

        if ($this->typeExists($index, $type)) {
            throw new \InvalidArgumentException(sprintf("Type 's%' already exists on index %s", $type, $index));
        }

        $mappings = MappingHelper::patchMappings($mappings, floor($this->getElasticsearchVersion()));

        $url = "$index/_mapping/$type";
        $response = $this->curlRequest->request($url, $mappings, 'PUT');

        $this->throwExceptionFromResponse($response, "Error creating type '$type' in '$index' index");

        $return = $response['content'];

        if (isset($return['acknowledged'])) {
            return $return['acknowledged'];
        }

        $this->setErrorFromElasticReturn($return);

        return false;
    }

    /**
     * @param string $index
     * @param string $type
     * @param array $body
     * @param array $queryParams
     * @param array|null $return
     * @return bool
     */
    public function insert($index, $type, array $body, array $queryParams = [], array &$return = null) {
        $url = "$index/$type";
        if (isset($body['_id'])) {
            $url .= '/' . $body['_id'];
            unset($body['_id']);
        }

        $url = "$url?" . http_build_query(array_merge(['refresh' => "true"], $queryParams));

        $response = $this->curlRequest->request($url, $body, 'POST');

        $this->throwExceptionFromResponse($response);
        $return = $response['content'];

        if (isset($return['created'])) {
            return $return['created'];
        }

        $this->setErrorFromElasticReturn($return);

        return false;
    }

    /**
     * @param string $index
     * @param string $type
     * @param string $_id
     * @param array $body
     * @param array $queryParams
     * @param array|null $return
     *
     * @return bool
     */
    public function update($index, $type, $_id, array $body = [], array $queryParams = [], array &$return = null) {
        if (!$this->indexExists($index)) {
            return false;
        }

        if (array_key_exists('doc', $body)) {
            $params = $body;
        } else {
            $params = ['doc' => $body];
        }

        $url = "$index/$type/$_id/_update?" . http_build_query(array_merge(['refresh' => 'true'], $queryParams));
        $response = $this->curlRequest->request($url, $params, 'POST');
        $this->throwExceptionFromResponse($response);

        $return = $response['content'];

        if (isset($return['_id'])) {
            return true;
        }

        $this->setErrorFromElasticReturn($return);

        return false;
    }

    /**
     * @param string $index
     * @param string $type
     * @param string $_id
     * @param array $queryParams
     * @param array|null $return
     * @return bool
     */
    public function delete($index, $type, $_id, array $queryParams = [], array &$return = null) {
        if (!$this->indexExists($index)) {
            return false;
        }

        $url = "$index/$type/$_id?" . http_build_query(array_merge(['refresh' => 'true'], $queryParams));
        $response = $this->curlRequest->request($url, [], 'DELETE');
        $this->throwExceptionFromResponse($response);
        $return = $response['content'];

        if (isset($return['found']) && !$return['found']) {
            error_log("Doc with _id '$_id' was not found for delete. Index: '$index', Type: '$type' ");
        }

        if (isset($return['_id'])) {
            return true;
        }

        $this->setErrorFromElasticReturn($return);

        return false;
    }

    public function updateWhere($index, $type, array $where, array &$return = null) {
        // TODO
    }

    public function deleteWhere($index, $type, array $where, array &$return = null) {
        // TODO
    }

    /**
     *
     * @param string $index
     * @param string $type
     * @param string $_id
     * @param array $queryParams
     * @param array|null $return
     * @return array|null
     */
    public function get($index, $type, $_id, array $queryParams = [], array &$return = null) {
        if (!$this->indexExists($index)) {
            return null;
        }

        $url = "$index/$type/$_id";
        $response = $this->curlRequest->request($url, [], 'GET');
        $return = $response['content'];

        if ($response['status'] == 404) {
            return null;
        }

        if (isset($return['found']) && boolval($return['found'])) {
            return $return;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        return null;
    }

    /**
     * Returns the [hits][hits] array from query
     *
     * @param string $index
     * @param string $type
     * @param array $body
     * @param array $queryParams
     * @param array|null $return
     * @return array
     */
    public function search($index, $type, array $body = [], array $queryParams = [], array &$return = null) {
        if (!$this->indexExists($index)) {
            return [];
        }

        $this->unsetEmpties($body);

        if (isset($body['query']) && empty($body['query'])) {
            unset($body['query']);
        }

        $url = "$index/$type/_search";

        $cleanQuery = function ($queryPart, callable $recusiveFn) {
            if (!is_array($queryPart)) {
                return $queryPart;
            }

            foreach ($queryPart as $key => $item) {
                if ($key == 'query' && isset($queryPart['query']['bool'])) {
                    $queryPart['bool'] = $recusiveFn($queryPart['query']['bool'], $recusiveFn);
                    unset($queryPart['query']['bool']);
                }

                if (isset($item['query']['bool'])) {
                    $queryPart[$key]['bool'] = $recusiveFn($item['query']['bool'], $recusiveFn);
                    unset($queryPart[$key]['query']);
                } else if (is_array($item)) {
                    $queryPart[$key] = $recusiveFn($item, $recusiveFn);
                }
            }

            return $queryPart;
        };

        foreach ($body['query']['bool'] as $key => $item) {
            $body['query']['bool'][$key] = $cleanQuery($item, $cleanQuery);
        }

        $response = $this->curlRequest->request($url, $body, 'POST');
        $this->throwExceptionFromResponse($response);
        $return = $response['content'];

        if (isset($return['hits']['hits'])) {
            return $return['hits']['hits'];
        }

        return [];
    }

    private function unsetEmpties(array &$array, array &$parent = null) {
        if (!is_array($array)) {
            return null;
        }

        for ($count = 2; $count > 0; $count--) {
            foreach ($array as $key => $item) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                if (is_array($item) && empty($item)) {
                    unset($array[$key]);

                    if (is_array($parent)) {
                        $this->unsetEmpties($parent);
                    }
                } else if (is_array($item)) {
                    $this->unsetEmpties($array[$key], $array);
                }
            }
        }
    }

    /**
     * @param string $index
     * @return bool
     */
    public function indexExists($index) {
        $response = $this->curlRequest->request($index, [], 'HEAD');

        return $response['status'] === 200;
    }

    /**
     * @param string $index
     * @param string $type
     * @return bool
     */
    public function typeExists($index, $type) {
        $response = $this->curlRequest->request("$index/$type", [], 'HEAD');

        return $response['status'] === 200;
    }

    private function throwExceptionFromResponse($response, $appendPrefix = '') {
        if (isset($response['content']['error']['reason'])) {
            if (!empty($appendPrefix)) {
                $appendPrefix .= ': ';
            }

            throw new ElasticOperationException($appendPrefix . $response['content']['error']['reason']);
        }
    }

    public function hasConnection() {
        $response = $this->curlRequest->request('', [], 'HEAD');

        return $response['status'] == 200;
    }

    private function setErrorFromElasticReturn($return) {
        if (isset($return['error']['root_cause'][0]['reason'])) {
            $this->setError($return['error']['root_cause'][0]['reason']);
        } else if (isset($return['error']['reason'])) {
            $this->setError($return['error']['reason']);
        }
    }

    public function getElasticsearchVersion() {
        if (is_null($this->esVersion)) {
            $response = $this->curlRequest->request('', [], 'GET');

            if (isset($response['content']['version']['number'])) {
                $this->esVersion = floatval($response['content']['version']['number']);
            } else {
                throw new ConnectionException('Unable to fetch elasticsearch version. ');
            }
        }

        return $this->esVersion;
    }
}


GitHub Access Token became invalid

Push — master ( a4e5c9...2c0076 )

ElasticConnection::search() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

1			<?php
2
3			namespace DoctrineElastic\Connection;
4
5			use DoctrineElastic\Exception\ConnectionException;
6			use DoctrineElastic\Exception\ElasticOperationException;
7			use DoctrineElastic\Helper\MappingHelper;
8			use DoctrineElastic\Http\CurlRequest;
9			use DoctrineElastic\Traiting\ErrorGetterTrait;
10
11			/**
12			* Default elastic connection class for general operations
13			* Notice that the original elastic result of most of operations can be get by $return param
14			*
15			* @author Andsalves <[email protected]>
16			*/
17			class ElasticConnection implements ElasticConnectionInterface {
18
19			use ErrorGetterTrait;
20
21			/** Override default elastic limit size query */
22			const DEFAULT_MAX_RESULTS = 10000;
23
24			/** @var CurlRequest */
25			protected $curlRequest;
26
27			/** @var float */
28			protected $esVersion;
29
30			public function __construct(array $hosts) {
31			$this->curlRequest = new CurlRequest();
32			$baseHost = reset($hosts);
33
34			if (empty($baseHost) \|\| !is_string($baseHost) \|\| !preg_match('/http/', $baseHost)) {
35			throw new ConnectionException("Elasticsearch host is invalid. ");
36			}
37
38			$this->curlRequest->setBaseUrl($baseHost);
39			}
40
41			/**
42			* @param string $index
43			* @param array\|null $mappings
44			* @param array\|null $settings
45			* @param array\|null $aliases
46			* @param array\|null $return
47			* @return bool
48			*/
49			public function createIndex(
50			$index, array $mappings = null, array $settings = null, array $aliases = null, array &$return = null
51			) {
52			if ($this->indexExists($index)) {
53			throw new \InvalidArgumentException(sprintf("'%s' index already exists", $index));
54			}
55
56			$params = [];
57
58			if (is_array($mappings) && !empty($mappings)) {
59			$params['mappings'] = MappingHelper::patchMappings($mappings, floor($this->getElasticsearchVersion()));
60			}
61
62			if (is_array($settings) && !empty($settings)) {
63			$params['settings'] = $settings;
64			}
65
66			if (is_array($aliases) && !empty($aliases)) {
67			$params['aliases'] = $aliases;
68			}
69
70			$response = $this->curlRequest->request($index, $params, 'PUT');
71			$return = $response['content'];
72
73			if (isset($return['acknowledged']) && $return['acknowledged']) {
74			return $return['acknowledged'];
75			}
76
77			$this->setErrorFromElasticReturn($return);
78
79			return false;
80			}
81
82			/**
83			* @param string $index
84			* @param array\|null $return
85			* @return bool
86			* @throws ElasticOperationException
87			*/
88			public function deleteIndex($index, array &$return = null) {
89			if (is_string($index) && !strstr('_all', $index) && !strstr('*', $index)) {
90			$response = $this->curlRequest->request("$index?refresh=true", [], 'DELETE');
91			$return = $response['content'];
92
93			if ($response['status'] == 404) {
94			throw new ElasticOperationException("Index '$index' doesn't exist so cannot be deleted. ");
95			}
96
97			if (isset($return['acknowledged'])) {
98			return $return['acknowledged'];
99			}
100			} else {
101			throw new ElasticOperationException('Index name is invalid for deletion. ');
102			}
103
104			$this->setErrorFromElasticReturn($return);
105
106			return false;
107			}
108
109			/**
110			* @param string $index
111			* @param string $type
112			* @param array $mappings
113			* @param array\|null $return
114			* @return bool
115			* @throws ElasticOperationException
116			*/
117			public function createType($index, $type, array $mappings = [], array &$return = null) {
118			if (!$this->indexExists($index)) {
119			throw new \InvalidArgumentException(sprintf("%s' index does not exists", $index));
120			}
121
122			if ($this->typeExists($index, $type)) {
123			throw new \InvalidArgumentException(sprintf("Type 's%' already exists on index %s", $type, $index));
124			}
125
126			$mappings = MappingHelper::patchMappings($mappings, floor($this->getElasticsearchVersion()));
127
128			$url = "$index/_mapping/$type";
129			$response = $this->curlRequest->request($url, $mappings, 'PUT');
130
131			$this->throwExceptionFromResponse($response, "Error creating type '$type' in '$index' index");
132
133			$return = $response['content'];
134
135			if (isset($return['acknowledged'])) {
136			return $return['acknowledged'];
137			}
138
139			$this->setErrorFromElasticReturn($return);
140
141			return false;
142			}
143
144			/**
145			* @param string $index
146			* @param string $type
147			* @param array $body
148			* @param array $queryParams
149			* @param array\|null $return
150			* @return bool
151			*/
152			public function insert($index, $type, array $body, array $queryParams = [], array &$return = null) {
153			$url = "$index/$type";
154			if (isset($body['_id'])) {
155			$url .= '/' . $body['_id'];
156			unset($body['_id']);
157			}
158
159			$url = "$url?" . http_build_query(array_merge(['refresh' => "true"], $queryParams));
160
161			$response = $this->curlRequest->request($url, $body, 'POST');
162
163			$this->throwExceptionFromResponse($response);
164			$return = $response['content'];
165
166			if (isset($return['created'])) {
167			return $return['created'];
168			}
169
170			$this->setErrorFromElasticReturn($return);
171
172			return false;
173			}
174
175			/**
176			* @param string $index
177			* @param string $type
178			* @param string $_id
179			* @param array $body
180			* @param array $queryParams
181			* @param array\|null $return
182			*
183			* @return bool
184			*/
185			public function update($index, $type, $_id, array $body = [], array $queryParams = [], array &$return = null) {
186			if (!$this->indexExists($index)) {
187			return false;
188			}
189
190			if (array_key_exists('doc', $body)) {
191			$params = $body;
192			} else {
193			$params = ['doc' => $body];
194			}
195
196			$url = "$index/$type/$_id/_update?" . http_build_query(array_merge(['refresh' => 'true'], $queryParams));
197			$response = $this->curlRequest->request($url, $params, 'POST');
198			$this->throwExceptionFromResponse($response);
199
200			$return = $response['content'];
201
202			if (isset($return['_id'])) {
203			return true;
204			}
205
206			$this->setErrorFromElasticReturn($return);
207
208			return false;
209			}
210
211			/**
212			* @param string $index
213			* @param string $type
214			* @param string $_id
215			* @param array $queryParams
216			* @param array\|null $return
217			* @return bool
218			*/
219			public function delete($index, $type, $_id, array $queryParams = [], array &$return = null) {
220			if (!$this->indexExists($index)) {
221			return false;
222			}
223
224			$url = "$index/$type/$_id?" . http_build_query(array_merge(['refresh' => 'true'], $queryParams));
225			$response = $this->curlRequest->request($url, [], 'DELETE');
226			$this->throwExceptionFromResponse($response);
227			$return = $response['content'];
228
229			if (isset($return['found']) && !$return['found']) {
230			error_log("Doc with _id '$_id' was not found for delete. Index: '$index', Type: '$type' ");
231			}
232
233			if (isset($return['_id'])) {
234			return true;
235			}
236
237			$this->setErrorFromElasticReturn($return);
238
239			return false;
240			}
241
242			public function updateWhere($index, $type, array $where, array &$return = null) {
243			// TODO
244			}
245
246			public function deleteWhere($index, $type, array $where, array &$return = null) {
247			// TODO
248			}
249
250			/**
251			*
252			* @param string $index
253			* @param string $type
254			* @param string $_id
255			* @param array $queryParams
256			* @param array\|null $return
257			* @return array\|null
258			*/
259			public function get($index, $type, $_id, array $queryParams = [], array &$return = null) {
260			if (!$this->indexExists($index)) {
261			return null;
262			}
263
264			$url = "$index/$type/$_id";
265			$response = $this->curlRequest->request($url, [], 'GET');
266			$return = $response['content'];
267
268			if ($response['status'] == 404) {
269			return null;
270			}
271
272			if (isset($return['found']) && boolval($return['found'])) {
273			return $return;
			0 ignored issues – show Bug Best Practice introduced 2017-05-29 00:12 UTC by Report Bug Copy Issue Report The return type of `return $return;` (`object\|integer\|double\|string\|array\|boolean`) is incompatible with the return type declared by the interface `DoctrineElastic\Connecti...onnectionInterface::get` of type `array\|null`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
274			}
275
276			return null;
277			}
278
279			/**
280			* Returns the [hits][hits] array from query
281			*
282			* @param string $index
283			* @param string $type
284			* @param array $body
285			* @param array $queryParams
286			* @param array\|null $return
287			* @return array
288			*/
289			public function search($index, $type, array $body = [], array $queryParams = [], array &$return = null) {
290			if (!$this->indexExists($index)) {
291			return [];
292			}
293
294			$this->unsetEmpties($body);
295
296			if (isset($body['query']) && empty($body['query'])) {
297			unset($body['query']);
298			}
299
300			$url = "$index/$type/_search";
301
302			$cleanQuery = function ($queryPart, callable $recusiveFn) {
303			if (!is_array($queryPart)) {
304			return $queryPart;
305			}
306
307			foreach ($queryPart as $key => $item) {
308			if ($key == 'query' && isset($queryPart['query']['bool'])) {
309			$queryPart['bool'] = $recusiveFn($queryPart['query']['bool'], $recusiveFn);
310			unset($queryPart['query']['bool']);
311			}
312
313			if (isset($item['query']['bool'])) {
314			$queryPart[$key]['bool'] = $recusiveFn($item['query']['bool'], $recusiveFn);
315			unset($queryPart[$key]['query']);
316			} else if (is_array($item)) {
317			$queryPart[$key] = $recusiveFn($item, $recusiveFn);
318			}
319			}
320
321			return $queryPart;
322			};
323
324			foreach ($body['query']['bool'] as $key => $item) {
325			$body['query']['bool'][$key] = $cleanQuery($item, $cleanQuery);
326			}
327
328			$response = $this->curlRequest->request($url, $body, 'POST');
329			$this->throwExceptionFromResponse($response);
330			$return = $response['content'];
331
332			if (isset($return['hits']['hits'])) {
333			return $return['hits']['hits'];
334			}
335
336			return [];
337			}
338
339			private function unsetEmpties(array &$array, array &$parent = null) {
340			if (!is_array($array)) {
341			return null;
342			}
343
344			for ($count = 2; $count > 0; $count--) {
345			foreach ($array as $key => $item) {
			0 ignored issues – show Bug introduced 2017-04-20 19:27 UTC by Report Bug Copy Issue Report The expression `$array` of type `null\|array` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
346			if (is_array($item) && empty($item)) {
347			unset($array[$key]);
348
349			if (is_array($parent)) {
350			$this->unsetEmpties($parent);
351			}
352			} else if (is_array($item)) {
353			$this->unsetEmpties($array[$key], $array);
354			}
355			}
356			}
357			}
358
359			/**
360			* @param string $index
361			* @return bool
362			*/
363			public function indexExists($index) {
364			$response = $this->curlRequest->request($index, [], 'HEAD');
365
366			return $response['status'] === 200;
367			}
368
369			/**
370			* @param string $index
371			* @param string $type
372			* @return bool
373			*/
374			public function typeExists($index, $type) {
375			$response = $this->curlRequest->request("$index/$type", [], 'HEAD');
376
377			return $response['status'] === 200;
378			}
379
380			private function throwExceptionFromResponse($response, $appendPrefix = '') {
381			if (isset($response['content']['error']['reason'])) {
382			if (!empty($appendPrefix)) {
383			$appendPrefix .= ': ';
384			}
385
386			throw new ElasticOperationException($appendPrefix . $response['content']['error']['reason']);
387			}
388			}
389
390			public function hasConnection() {
391			$response = $this->curlRequest->request('', [], 'HEAD');
392
393			return $response['status'] == 200;
394			}
395
396			private function setErrorFromElasticReturn($return) {
397			if (isset($return['error']['root_cause'][0]['reason'])) {
398			$this->setError($return['error']['root_cause'][0]['reason']);
399			} else if (isset($return['error']['reason'])) {
400			$this->setError($return['error']['reason']);
401			}
402			}
403
404			public function getElasticsearchVersion() {
405			if (is_null($this->esVersion)) {
406			$response = $this->curlRequest->request('', [], 'GET');
407
408			if (isset($response['content']['version']['number'])) {
409			$this->esVersion = floatval($response['content']['version']['number']);
410			} else {
411			throw new ConnectionException('Unable to fetch elasticsearch version. ');
412			}
413			}
414
415			return $this->esVersion;
416			}
417			}
418

andsalves / doctrine-elastic

GitHub Access Token became invalid

Push — master ( a4e5c9...2c0076 )

ElasticConnection::search() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like