Issues in SearchService.php - All Issues - Inspection of "Merge pull request #11567 from mrclay/11563_routes" - Elgg/Elgg - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c0a3a7...3b84a4 )

by Jeroen

created 2018-01-08 10:08 UTC

engine/classes/Elgg/Search/SearchService.php (1 issue)

Showing only issues like (Show All)

return values of null are not assigned.

Bug Minor

Ismayil Khayredinov 1

<?php

namespace Elgg\Search;

use Doctrine\DBAL\Query\Expression\CompositeExpression;
use Elgg\Config;
use Elgg\Database;
use Elgg\Database\Clauses\AnnotationWhereClause;
use Elgg\Database\Clauses\AttributeWhereClause;
use Elgg\Database\Clauses\MetadataWhereClause;
use Elgg\Database\Clauses\PrivateSettingWhereClause;
use Elgg\Database\QueryBuilder;
use Elgg\PluginHooksService;
use ElggBatch;
use ElggEntity;
use InvalidParameterException;

/**
 * WARNING: API IN FLUX. DO NOT USE DIRECTLY.
 *
 * Use elgg_search() instead.
 *
 * @todo   Implement type/subtype normalization into types => subtypes pairs and add logic to search for multiple
 *         subtypes
 *
 * @access private
 * @since  3.0
 */
class SearchService {

	/**
	 * @var Config
	 */
	private $config;

	/**
	 * @var PluginHooksService
	 */
	private $hooks;

	/**
	 * @var Database
	 */
	private $db;

	/**
	 * Constructor
	 *
	 * @param \Elgg\Config             $config Config
	 * @param \Elgg\PluginHooksService $hooks  Hook registration service
	 * @param Database                 $db     Database
	 */
	public function __construct(Config $config, PluginHooksService $hooks, Database $db) {
		$this->config = $config;
		$this->hooks = $hooks;
		$this->db = $db;
	}

	/**
	 * Returns search results as an array of entities, as a batch, or a count,
	 * depending on parameters given.
	 *
	 * @param array $options Search parameters
	 *                       Accepts all options supported by {@link elgg_get_entities()}
	 *
	 * @option string $query         Search query
	 * @option string $type          Entity type. Required if no search type is set
	 * @option string $search_type   Custom search type. Required if no type is set
	 * @option array  $fields        An array of fields to search in
	 * @option string $sort          An array containing 'property', 'property_type', 'direction' and 'signed'
	 * @option bool   $partial_match Allow partial matches, e.g. find 'elgg' when search for 'el'
	 * @option bool   $tokenize      Break down search query into tokens,
	 *                               e.g. find 'elgg has been released' when searching for 'elgg released'
	 *
	 * @return ElggBatch|ElggEntity[]|int|false
	 * @throws InvalidParameterException
	 *
	 * @see    elgg_get_entities()
	 */
	public function search(array $options = []) {
		$options = $this->prepareSearchOptions($options);

		$query_parts = elgg_extract('query_parts', $options);
		$fields = elgg_extract('fields', $options);

		if (empty($query_parts) || empty(array_filter($fields))) {
			return false;
		}

		$entity_type = elgg_extract('type', $options, 'all', false);
		$entity_subtype = elgg_extract('subtype', $options);
		$search_type = elgg_extract('search_type', $options, 'entities');

		if ($entity_type !== 'all' && !in_array($entity_type, Config::getEntityTypes())) {
			throw new InvalidParameterException("'$entity_type' is not a valid entity type");
		}

		$options = $this->hooks->trigger('search:options', $entity_type, $options, $options);
		if ($entity_subtype) {
			$options = $this->hooks->trigger('search:options', "$entity_type:$entity_subtype", $options, $options);
		}

		$options = $this->hooks->trigger('search:options', $search_type, $options, $options);

		if ($this->hooks->hasHandler('search:results', $search_type)) {
			$results = $this->hooks->trigger('search:results', $search_type, $options);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
			if (isset($results)) {
				// allow hooks to conditionally replace the result set
				return $results;
			}
		}

		return elgg_get_entities($options);
	}

	/**
	 * Normalize options
	 *
	 * @param array $options Options
	 *
	 * @return array
	 */
	public function normalizeOptions(array $options = []) {
		$search_type = elgg_extract('search_type', $options, 'entities', false);
		$options['search_type'] = $search_type;

		$options = $this->hooks->trigger('search:params', $search_type, $options, $options);

		$options = $this->normalizeQuery($options);
		$options = $this->normalizeSearchFields($options);

		return $options;
	}

	/**
	 * Prepare ege* options
	 *
	 * @param array $options Entity search params
	 *
	 * @return array
	 */
	public function prepareSearchOptions(array $options = []) {
		$options = $this->normalizeOptions($options);

		$fields = elgg_extract('fields', $options);
		$query_parts = elgg_extract('query_parts', $options);
		$partial = elgg_extract('partial_match', $options, true);

		$options['wheres']['search'] = function (QueryBuilder $qb, $alias) use ($fields, $query_parts, $partial) {
			return $this->buildSearchWhereQuery($qb, $alias, $fields, $query_parts, $partial);
		};

		$options = $this->prepareSortOptions($options);

		return $options;
	}

	/**
	 * Normalize query parts
	 *
	 * @param array $options Options
	 *
	 * @return array
	 */
	public function normalizeQuery(array $options = []) {

		$query = elgg_extract('query', $options);
		$query = filter_var($query, FILTER_SANITIZE_STRING);
		$query = trim($query);

		$words = preg_split('/\s+/', $query);
		$words = array_map(function ($e) {
			return trim($e);
		}, $words);

		$query = implode(' ', $words);

		$options['query'] = $query;

		$tokenize = elgg_extract('tokenize', $options, true);
		if ($tokenize) {
			$parts = $words;
		} else {
			$parts = [$query];
		}

		$options['query_parts'] = array_unique(array_filter($parts));

		return $options;
	}

	/**
	 * Normalizes an array of search fields
	 *
	 * @param array $options Search parameters
	 *
	 * @return array
	 */
	public function normalizeSearchFields(array $options = []) {

		$fields = [
			'attributes' => [],
			'metadata' => [],
			'annotations' => [],
			'private_settings' => [],
		];

		$property_types = array_keys($fields);

		$entity_type = elgg_extract('type', $options);
		$entity_subtype = elgg_extract('subtype', $options);
		$search_type = elgg_extract('search_type', $options, 'entities');

		if ($entity_type) {
			$fields = $this->hooks->trigger('search:fields', $entity_type, $options, $fields);
		}

		if ($entity_subtype) {
			$fields = $this->hooks->trigger('search:fields', "$entity_type:$entity_subtype", $options, $fields);
		}

		if ($search_type) {
			$fields = $this->hooks->trigger('search:fields', $search_type, $options, $fields);
		}

		foreach ($property_types as $property_type) {
			if (empty($fields[$property_type])) {
				$fields[$property_type] = [];
			}
		}

		if (empty($options['fields'])) {
			$options['fields'] = $fields;
		} else {
			// only allow known fields
			foreach ($fields as $property_type => $property_type_fields) {
				if (empty($options['fields'][$property_type])) {
					$options['fields'][$property_type] = [];
					continue;
				}

				$allowed = array_intersect($property_type_fields, (array) $options['fields'][$property_type]);
				$options['fields'][$property_type] = array_values(array_unique($allowed));
			}
		}

		return $options;
	}

	/**
	 * Normalizes sort options
	 *
	 * @param array $options Search parameters
	 *
	 * @return array
	 */
	public function prepareSortOptions(array $options = []) {

		$sort = elgg_extract('sort', $options);
		if (is_string($sort)) {
			$sort = [
				'property' => $sort,
				'direction' => elgg_extract('order', $options)
			];
		}

		if (!isset($sort['property'])) {
			$sort = [
				'property' => 'time_created',
				'property_type' => 'attribute',
				'direction' => 'desc',
			];
		}

		$clause = new Database\Clauses\EntitySortByClause();
		$clause->property = elgg_extract('property', $sort);
		$clause->property_type = elgg_extract('property_type', $sort);
		$clause->direction = elgg_extract('direction', $sort, 'asc');
		$clause->signed = elgg_extract('signed', $sort, false);

		$options['order_by'] = [$clause];

		return $options;
	}

	/**
	 * Builds search clause
	 *
	 * @param QueryBuilder $qb            Query builder
	 * @param string       $alias         Entity table alias
	 * @param array        $fields        Fields to match against
	 * @param array        $query_parts   Search query
	 * @param bool         $partial_match Allow partial matches
	 *
	 * @return CompositeExpression
	 * @throws InvalidParameterException
	 */
	public function buildSearchWhereQuery(QueryBuilder $qb, $alias, $fields, $query_parts, $partial_match = true) {

		$attributes = elgg_extract('attributes', $fields, [], false);
		$metadata = elgg_extract('metadata', $fields, [], false);
		$annotations = elgg_extract('annotations', $fields, [], false);
		$private_settings = elgg_extract('private_settings', $fields, [], false);

		$ors = [];

		$populate_where = function ($where, $part) use ($partial_match) {
			$where->values = $partial_match ? "%{$part}%" : $part;
			$where->comparison = 'LIKE';
			$where->value_type = ELGG_VALUE_STRING;
			$where->case_sensitive = false;
		};

		if (!empty($attributes)) {
			foreach ($attributes as $attribute) {
				$attribute_ands = [];
				foreach ($query_parts as $part) {
					$where = new AttributeWhereClause();
					$where->names = $attribute;
					$populate_where($where, $part);
					$attribute_ands[] = $where->prepare($qb, $alias);
				}
				$ors[] = $qb->merge($attribute_ands, 'AND');
			}
		}

		if (!empty($metadata)) {
			$metadata_ands = [];
			$md_alias = $qb->joinMetadataTable($alias, 'guid', $metadata, 'left');
			foreach ($query_parts as $part) {
				$where = new MetadataWhereClause();
				$populate_where($where, $part);
				$metadata_ands[] = $where->prepare($qb, $md_alias);
			}
			$ors[] = $qb->merge($metadata_ands, 'AND');
		}

		if (!empty($annotations)) {
			$annotations_ands = [];
			$an_alias = $qb->joinAnnotationTable($alias, 'guid', $annotations, 'left');
			foreach ($query_parts as $part) {
				$where = new AnnotationWhereClause();
				$populate_where($where, $part);
				$annotations_ands[] = $where->prepare($qb, $an_alias);
			}
			$ors[] = $qb->merge($annotations_ands, 'AND');
		}

		if (!empty($private_settings)) {
			$private_settings_ands = [];
			$ps_alias = $qb->joinPrivateSettingsTable($alias, 'guid', $private_settings, 'left');
			foreach ($query_parts as $part) {
				$where = new PrivateSettingWhereClause();
				$populate_where($where, $part);
				$private_settings_ands[] = $where->prepare($qb, $ps_alias);
			}
			$ors[] = $qb->merge($private_settings_ands, 'AND');
		}

		return $qb->merge($ors, 'OR');
	}

}


1		<?php
2
3		namespace Elgg\Search;
4
5		use Doctrine\DBAL\Query\Expression\CompositeExpression;
6		use Elgg\Config;
7		use Elgg\Database;
8		use Elgg\Database\Clauses\AnnotationWhereClause;
9		use Elgg\Database\Clauses\AttributeWhereClause;
10		use Elgg\Database\Clauses\MetadataWhereClause;
11		use Elgg\Database\Clauses\PrivateSettingWhereClause;
12		use Elgg\Database\QueryBuilder;
13		use Elgg\PluginHooksService;
14		use ElggBatch;
15		use ElggEntity;
16		use InvalidParameterException;
17
18		/**
19		* WARNING: API IN FLUX. DO NOT USE DIRECTLY.
20		*
21		* Use elgg_search() instead.
22		*
23		* @todo Implement type/subtype normalization into types => subtypes pairs and add logic to search for multiple
24		* subtypes
25		*
26		* @access private
27		* @since 3.0
28		*/
29		class SearchService {
30
31		/**
32		* @var Config
33		*/
34		private $config;
35
36		/**
37		* @var PluginHooksService
38		*/
39		private $hooks;
40
41		/**
42		* @var Database
43		*/
44		private $db;
45
46		/**
47		* Constructor
48		*
49		* @param \Elgg\Config $config Config
50		* @param \Elgg\PluginHooksService $hooks Hook registration service
51		* @param Database $db Database
52		*/
53	35	public function __construct(Config $config, PluginHooksService $hooks, Database $db) {
54	35	$this->config = $config;
55	35	$this->hooks = $hooks;
56	35	$this->db = $db;
57	35	}
58
59		/**
60		* Returns search results as an array of entities, as a batch, or a count,
61		* depending on parameters given.
62		*
63		* @param array $options Search parameters
64		* Accepts all options supported by {@link elgg_get_entities()}
65		*
66		* @option string $query Search query
67		* @option string $type Entity type. Required if no search type is set
68		* @option string $search_type Custom search type. Required if no type is set
69		* @option array $fields An array of fields to search in
70		* @option string $sort An array containing 'property', 'property_type', 'direction' and 'signed'
71		* @option bool $partial_match Allow partial matches, e.g. find 'elgg' when search for 'el'
72		* @option bool $tokenize Break down search query into tokens,
73		* e.g. find 'elgg has been released' when searching for 'elgg released'
74		*
75		* @return ElggBatch\|ElggEntity[]\|int\|false
76		* @throws InvalidParameterException
77		*
78		* @see elgg_get_entities()
79		*/
80	197	public function search(array $options = []) {
81	197	$options = $this->prepareSearchOptions($options);
82
83	197	$query_parts = elgg_extract('query_parts', $options);
84	197	$fields = elgg_extract('fields', $options);
85
86	197	if (empty($query_parts) \|\| empty(array_filter($fields))) {
87	5	return false;
88		}
89
90	192	$entity_type = elgg_extract('type', $options, 'all', false);
91	192	$entity_subtype = elgg_extract('subtype', $options);
92	192	$search_type = elgg_extract('search_type', $options, 'entities');
93
94	192	if ($entity_type !== 'all' && !in_array($entity_type, Config::getEntityTypes())) {
95		throw new InvalidParameterException("'$entity_type' is not a valid entity type");
96		}
97
98	192	$options = $this->hooks->trigger('search:options', $entity_type, $options, $options);
99	192	if ($entity_subtype) {
100	12	$options = $this->hooks->trigger('search:options', "$entity_type:$entity_subtype", $options, $options);
101		}
102
103	192	$options = $this->hooks->trigger('search:options', $search_type, $options, $options);
104
105	192	if ($this->hooks->hasHandler('search:results', $search_type)) {
106	1	$results = $this->hooks->trigger('search:results', $search_type, $options);
		0 ignored issues – show Bug introduced 2017-12-07 20:57 UTC by Report Bug Copy Issue Report Show Similar Issues like this Are you sure the assignment to `$results` is correct as `$this->hooks->trigger('s...$search_type, $options)` targeting `Elgg\PluginHooksService::trigger()` seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
107	1	if (isset($results)) {
108		// allow hooks to conditionally replace the result set
109	1	return $results;
110		}
111		}
112
113	191	return elgg_get_entities($options);
114		}
115
116		/**
117		* Normalize options
118		*
119		* @param array $options Options
120		*
121		* @return array
122		*/
123	213	public function normalizeOptions(array $options = []) {
124	213	$search_type = elgg_extract('search_type', $options, 'entities', false);
125	213	$options['search_type'] = $search_type;
126
127	213	$options = $this->hooks->trigger('search:params', $search_type, $options, $options);
128
129	213	$options = $this->normalizeQuery($options);
130	213	$options = $this->normalizeSearchFields($options);
131
132	213	return $options;
133		}
134
135		/**
136		* Prepare ege* options
137		*
138		* @param array $options Entity search params
139		*
140		* @return array
141		*/
142	200	public function prepareSearchOptions(array $options = []) {
143	200	$options = $this->normalizeOptions($options);
144
145	200	$fields = elgg_extract('fields', $options);
146	200	$query_parts = elgg_extract('query_parts', $options);
147	200	$partial = elgg_extract('partial_match', $options, true);
148
149	191	$options['wheres']['search'] = function (QueryBuilder $qb, $alias) use ($fields, $query_parts, $partial) {
150	191	return $this->buildSearchWhereQuery($qb, $alias, $fields, $query_parts, $partial);
151		};
152
153	200	$options = $this->prepareSortOptions($options);
154
155	200	return $options;
156		}
157
158		/**
159		* Normalize query parts
160		*
161		* @param array $options Options
162		*
163		* @return array
164		*/
165	213	public function normalizeQuery(array $options = []) {
166
167	213	$query = elgg_extract('query', $options);
168	213	$query = filter_var($query, FILTER_SANITIZE_STRING);
169	213	$query = trim($query);
170
171	213	$words = preg_split('/\s+/', $query);
172	213	$words = array_map(function ($e) {
173	213	return trim($e);
174	213	}, $words);
175
176	213	$query = implode(' ', $words);
177
178	213	$options['query'] = $query;
179
180	213	$tokenize = elgg_extract('tokenize', $options, true);
181	213	if ($tokenize) {
182	118	$parts = $words;
183		} else {
184	95	$parts = [$query];
185		}
186
187	213	$options['query_parts'] = array_unique(array_filter($parts));
188
189	213	return $options;
190		}
191
192		/**
193		* Normalizes an array of search fields
194		*
195		* @param array $options Search parameters
196		*
197		* @return array
198		*/
199	213	public function normalizeSearchFields(array $options = []) {
200
201		$fields = [
202	213	'attributes' => [],
203		'metadata' => [],
204		'annotations' => [],
205		'private_settings' => [],
206		];
207
208	213	$property_types = array_keys($fields);
209
210	213	$entity_type = elgg_extract('type', $options);
211	213	$entity_subtype = elgg_extract('subtype', $options);
212	213	$search_type = elgg_extract('search_type', $options, 'entities');
213
214	213	if ($entity_type) {
215	21	$fields = $this->hooks->trigger('search:fields', $entity_type, $options, $fields);
216		}
217
218	213	if ($entity_subtype) {
219	16	$fields = $this->hooks->trigger('search:fields', "$entity_type:$entity_subtype", $options, $fields);
220		}
221
222	213	if ($search_type) {
223	213	$fields = $this->hooks->trigger('search:fields', $search_type, $options, $fields);
224		}
225
226	213	foreach ($property_types as $property_type) {
227	213	if (empty($fields[$property_type])) {
228	213	$fields[$property_type] = [];
229		}
230		}
231
232	213	if (empty($options['fields'])) {
233	21	$options['fields'] = $fields;
234		} else {
235		// only allow known fields
236	192	foreach ($fields as $property_type => $property_type_fields) {
237	192	if (empty($options['fields'][$property_type])) {
238	191	$options['fields'][$property_type] = [];
239	191	continue;
240		}
241
242	192	$allowed = array_intersect($property_type_fields, (array) $options['fields'][$property_type]);
243	192	$options['fields'][$property_type] = array_values(array_unique($allowed));
244		}
245		}
246
247	213	return $options;
248		}
249
250		/**
251		* Normalizes sort options
252		*
253		* @param array $options Search parameters
254		*
255		* @return array
256		*/
257	200	public function prepareSortOptions(array $options = []) {
258
259	200	$sort = elgg_extract('sort', $options);
260	200	if (is_string($sort)) {
261		$sort = [
262	2	'property' => $sort,
263	2	'direction' => elgg_extract('order', $options)
264		];
265		}
266
267	200	if (!isset($sort['property'])) {
268		$sort = [
269	197	'property' => 'time_created',
270		'property_type' => 'attribute',
271		'direction' => 'desc',
272		];
273		}
274
275	200	$clause = new Database\Clauses\EntitySortByClause();
276	200	$clause->property = elgg_extract('property', $sort);
277	200	$clause->property_type = elgg_extract('property_type', $sort);
278	200	$clause->direction = elgg_extract('direction', $sort, 'asc');
279	200	$clause->signed = elgg_extract('signed', $sort, false);
280
281	200	$options['order_by'] = [$clause];
282
283	200	return $options;
284		}
285
286		/**
287		* Builds search clause
288		*
289		* @param QueryBuilder $qb Query builder
290		* @param string $alias Entity table alias
291		* @param array $fields Fields to match against
292		* @param array $query_parts Search query
293		* @param bool $partial_match Allow partial matches
294		*
295		* @return CompositeExpression
296		* @throws InvalidParameterException
297		*/
298	191	public function buildSearchWhereQuery(QueryBuilder $qb, $alias, $fields, $query_parts, $partial_match = true) {
299
300	191	$attributes = elgg_extract('attributes', $fields, [], false);
301	191	$metadata = elgg_extract('metadata', $fields, [], false);
302	191	$annotations = elgg_extract('annotations', $fields, [], false);
303	191	$private_settings = elgg_extract('private_settings', $fields, [], false);
304
305	191	$ors = [];
306
307	191	$populate_where = function ($where, $part) use ($partial_match) {
308	191	$where->values = $partial_match ? "%{$part}%" : $part;
309	191	$where->comparison = 'LIKE';
310	191	$where->value_type = ELGG_VALUE_STRING;
311	191	$where->case_sensitive = false;
312	191	};
313
314		if (!empty($attributes)) {
315		foreach ($attributes as $attribute) {
316		$attribute_ands = [];
317		foreach ($query_parts as $part) {
318		$where = new AttributeWhereClause();
319		$where->names = $attribute;
320		$populate_where($where, $part);
321		$attribute_ands[] = $where->prepare($qb, $alias);
322		}
323		$ors[] = $qb->merge($attribute_ands, 'AND');
324		}
325		}
326
327		if (!empty($metadata)) {
328		$metadata_ands = [];
329		$md_alias = $qb->joinMetadataTable($alias, 'guid', $metadata, 'left');
330		foreach ($query_parts as $part) {
331		$where = new MetadataWhereClause();
332		$populate_where($where, $part);
333		$metadata_ands[] = $where->prepare($qb, $md_alias);
334		}
335		$ors[] = $qb->merge($metadata_ands, 'AND');
336		}
337
338		if (!empty($annotations)) {
339		$annotations_ands = [];
340		$an_alias = $qb->joinAnnotationTable($alias, 'guid', $annotations, 'left');
341		foreach ($query_parts as $part) {
342		$where = new AnnotationWhereClause();
343		$populate_where($where, $part);
344		$annotations_ands[] = $where->prepare($qb, $an_alias);
345		}
346		$ors[] = $qb->merge($annotations_ands, 'AND');
347		}
348
349		if (!empty($private_settings)) {
350		$private_settings_ands = [];
351		$ps_alias = $qb->joinPrivateSettingsTable($alias, 'guid', $private_settings, 'left');
352		foreach ($query_parts as $part) {
353		$where = new PrivateSettingWhereClause();
354		$populate_where($where, $part);
355		$private_settings_ands[] = $where->prepare($qb, $ps_alias);
356		}
357		$ors[] = $qb->merge($private_settings_ands, 'AND');
358		}
359
360		return $qb->merge($ors, 'OR');
361		}
362
363		}
364

Elgg / Elgg

Push — master ( c0a3a7...3b84a4 )

engine/classes/Elgg/Search/SearchService.php (1 issue)

Showing only issues like (Show All)

Introduced By

Duplication Side-by-Side

Filter issues like