Issues in MetadataTable.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/Database/MetadataTable.php (1 issue)

Labels

Severity

Minor 1

Ismayil Khayredinov 1

<?php

namespace Elgg\Database;

use Elgg\Cache\MetadataCache;
use Elgg\Database;
use Elgg\Database\Clauses\MetadataWhereClause;
use Elgg\EventsService as Events;
use Elgg\TimeUsing;
use ElggMetadata;
use ElggEntity;

/**
 * This class interfaces with the database to perform CRUD operations on metadata
 *
 * WARNING: API IN FLUX. DO NOT USE DIRECTLY.
 *
 * @access private
 */
class MetadataTable {

	use TimeUsing;

	/**
	 * @var MetadataCache
	 */
	protected $metadata_cache;

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

	/**
	 * @var Events
	 */
	protected $events;

	/**
	 * @var string[]
	 */
	protected $tag_names = [];

	const MYSQL_TEXT_BYTE_LIMIT = 65535;

	/**
	 * Constructor
	 *
	 * @param MetadataCache $metadata_cache A cache for this table
	 * @param Database      $db             The Elgg database
	 * @param Events        $events         The events registry
	 */
	public function __construct(
		MetadataCache $metadata_cache,
		Database $db,
		Events $events
	) {
		$this->metadata_cache = $metadata_cache;
		$this->db = $db;
		$this->events = $events;
	}

	/**
	 * Registers a metadata name as containing tags for an entity.
	 *
	 * @param string $name Tag name
	 *
	 * @return bool
	 */
	public function registerTagName($name) {
		if (!in_array($name, $this->tag_names)) {
			$this->tag_names[] = $name;
		}

		return true;
	}

	/**
	 * Unregisters a metadata tag name
	 *
	 * @param string $name Tag name
	 *
	 * @return bool
	 */
	public function unregisterTagName($name) {
		$index = array_search($name, $this->tag_names);
		if ($index >= 0) {
			unset($this->tag_names[$index]);

			return true;
		}

		return false;
	}

	/**
	 * Returns an array of valid metadata names for tags.
	 *
	 * @return string[]
	 */
	public function getTagNames() {
		return $this->tag_names;
	}

	/**
	 * Get a specific metadata object by its id
	 *
	 * @see MetadataTable::getAll()
	 *
	 * @param int $id The id of the metadata object being retrieved.
	 *
	 * @return ElggMetadata|false  false if not found
	 */
	public function get($id) {
		$qb = Select::fromTable('metadata');
		$qb->select('*');

		$where = new MetadataWhereClause();
		$where->ids = $id;

		$qb->addClause($where);

		$row = $this->db->getDataRow($qb);
		if ($row) {
			return new ElggMetadata($row);
		}

		return false;
	}

	/**
	 * Deletes metadata using its ID
	 *
	 * @param ElggMetadata $metadata Metadata
	 *
	 * @return bool
	 */
	public function delete(ElggMetadata $metadata) {
		if (!$metadata->id || !$metadata->canEdit()) {
			return false;
		}

		if (!elgg_trigger_event('delete', 'metadata', $metadata)) {
			return false;
		}

		$qb = Delete::fromTable('metadata');
		$qb->where($qb->compare('id', '=', $metadata->id, ELGG_VALUE_INTEGER));

		$deleted = $this->db->deleteData($qb);

		if ($deleted) {
			$this->metadata_cache->clear($metadata->entity_guid);
		}

		return $deleted;
	}

	/**
	 * Create a new metadata object, or update an existing one (if multiple is allowed)
	 *
	 * Metadata can be an array by setting allow_multiple to true, but it is an
	 * indexed array with no control over the indexing
	 *
	 * @param ElggMetadata $metadata       Metadata
	 * @param bool         $allow_multiple Allow multiple values for one key. Default is false
	 *
	 * @return int|false id of metadata or false if failure
	 */
	public function create(ElggMetadata $metadata, $allow_multiple = false) {
		if (!isset($metadata->value) || !isset($metadata->entity_guid)) {
			elgg_log("Metadata must have a value and entity guid", 'ERROR');
			return false;
		}

		if (!is_scalar($metadata->value)) {
			elgg_log("To set multiple metadata values use ElggEntity::setMetadata", 'ERROR');
			return false;
		}

		if ($metadata->id) {
			if ($this->update($metadata)) {
				return $metadata->id;
			}
		}

		if (strlen($metadata->value) > self::MYSQL_TEXT_BYTE_LIMIT) {
			elgg_log("Metadata '$metadata->name' is above the MySQL TEXT size limit and may be truncated.", 'WARNING');
		}

		if (!$allow_multiple) {
			$id = $this->getIdsByName($metadata->entity_guid, $metadata->name);

			if (is_array($id)) {
				throw new \LogicException("Multiple '{$metadata->name}' metadata values exist for entity [guid: {$metadata->entity_guid}]. Use ElggEntity::setMetadata()");
			}

			if ($id) {
				$metadata->id = $id;

				if ($this->update($metadata)) {
					return $metadata->id;
				}
			}
		}

		if (!$this->events->triggerBefore('create', 'metadata', $metadata)) {
			return false;
		}

		$time_created = $this->getCurrentTime()->getTimestamp();

		$qb = Insert::intoTable('metadata');
		$qb->values([
			'name' => $qb->param($metadata->name, ELGG_VALUE_STRING),
			'entity_guid' => $qb->param($metadata->entity_guid, ELGG_VALUE_INTEGER),
			'value' => $qb->param($metadata->value, $metadata->value_type === 'integer' ? ELGG_VALUE_INTEGER : ELGG_VALUE_STRING),
			'value_type' => $qb->param($metadata->value_type, ELGG_VALUE_STRING),
			'time_created' => $qb->param($time_created, ELGG_VALUE_INTEGER),
		]);

		$id = $this->db->insertData($qb);

		if ($id === false) {
			return false;
		}

		$metadata->id = (int) $id;
		$metadata->time_created = $time_created;

		if ($this->events->trigger('create', 'metadata', $metadata)) {
			$this->metadata_cache->clear($metadata->entity_guid);

			$this->events->triggerAfter('create', 'metadata', $metadata);

			return $id;
		} else {
			$this->delete($metadata);

			return false;
		}
	}

	/**
	 * Update a specific piece of metadata
	 *
	 * @param ElggMetadata $metadata Updated metadata
	 *
	 * @return bool
	 */
	public function update(ElggMetadata $metadata) {
		if (!$metadata->canEdit()) {
			return false;
		}

		if (!$this->events->triggerBefore('update', 'metadata', $metadata)) {
			return false;
		}

		if (strlen($metadata->value) > self::MYSQL_TEXT_BYTE_LIMIT) {
			elgg_log("Metadata '$metadata->name' is above the MySQL TEXT size limit and may be truncated.", 'WARNING');
		}

		$qb = Update::table('metadata');
		$qb->set('name', $qb->param($metadata->name, ELGG_VALUE_STRING))
			->set('value', $qb->param($metadata->value, $metadata->value_type === 'integer' ? ELGG_VALUE_INTEGER : ELGG_VALUE_STRING))
			->set('value_type', $qb->param($metadata->value_type, ELGG_VALUE_STRING))
			->where($qb->compare('id', '=', $metadata->id, ELGG_VALUE_INTEGER));

		$result = $this->db->updateData($qb);

		if ($result === false) {
			return false;
		}

		$this->metadata_cache->clear($metadata->entity_guid);

		$this->events->trigger('update', 'metadata', $metadata);
		$this->events->triggerAfter('update', 'metadata', $metadata);

		return true;
	}

	/**
	 * Returns metadata
	 *
	 * Accepts all {@link elgg_get_entities()} options for entity restraints.
	 *
	 * @see     elgg_get_entities()
	 *
	 * @param array $options Options
	 *
	 * @return ElggMetadata[]|mixed
	 */
	public function getAll(array $options = []) {

		$options['metastring_type'] = 'metadata';
		$options = _elgg_normalize_metastrings_options($options);

		return Metadata::find($options);
	}

	/**
	 * Deletes metadata based on $options.
	 *
	 * @warning Unlike elgg_get_metadata() this will not accept an empty options array!
	 *          This requires at least one constraint:
	 *          metadata_name(s), metadata_value(s), or guid(s) must be set.
	 *
	 * @see     elgg_get_metadata()
	 * @see     elgg_get_entities()
	 *
	 * @param array $options Options
	 *
	 * @return bool|null true on success, false on failure, null if no metadata to delete.
	 */
	public function deleteAll(array $options) {
		if (!_elgg_is_valid_options_for_batch_operation($options, 'metadata')) {
			return false;
		}

		// This moved last in case an object's constructor sets metadata. Currently the batch
		// delete process has to create the entity to delete its metadata. See #5214
		$this->metadata_cache->invalidateByOptions($options);

		$options['batch'] = true;
		$options['batch_size'] = 50;
		$options['batch_inc_offset'] = false;

		$metadata = Metadata::find($options);
		$count = $metadata->count();

		if (!$count) {
			return;
		}

		$success = 0;
		foreach ($metadata as $md) {
			if ($md->delete()) {
				$success++;
			}
		}

		return $success == $count;
	}

	/**
	 * Returns ID(s) of metadata with a particular name attached to an entity
	 *
	 * @param int    $entity_guid Entity guid
	 * @param string $name        Metadata name
	 *
	 * @return int[]|int|null
	 */
	public function getIdsByName($entity_guid, $name) {
		if ($this->metadata_cache->isLoaded($entity_guid)) {
			$ids = $this->metadata_cache->getSingleId($entity_guid, $name);
		} else {
			$qb = Select::fromTable('metadata');
			$qb->select('id')
				->where($qb->compare('entity_guid', '=', $entity_guid, ELGG_VALUE_INTEGER))
				->andWhere($qb->compare('name', '=', $name, ELGG_VALUE_STRING));

			$callback = function (\stdClass $row) {
				return (int) $row->id;
			};

			$ids = $this->db->getData($qb, $callback);
		}

		if (empty($ids)) {
			return null;
		}

		if (is_array($ids) && count($ids) === 1) {
			return array_shift($ids);
		}

		return $ids;
	}
}


1		<?php
2
3		namespace Elgg\Database;
4
5		use Elgg\Cache\MetadataCache;
6		use Elgg\Database;
7		use Elgg\Database\Clauses\MetadataWhereClause;
8		use Elgg\EventsService as Events;
9		use Elgg\TimeUsing;
10		use ElggMetadata;
11		use ElggEntity;
12
13		/**
14		* This class interfaces with the database to perform CRUD operations on metadata
15		*
16		* WARNING: API IN FLUX. DO NOT USE DIRECTLY.
17		*
18		* @access private
19		*/
20		class MetadataTable {
21
22		use TimeUsing;
23
24		/**
25		* @var MetadataCache
26		*/
27		protected $metadata_cache;
28
29		/**
30		* @var Database
31		*/
32		protected $db;
33
34		/**
35		* @var Events
36		*/
37		protected $events;
38
39		/**
40		* @var string[]
41		*/
42		protected $tag_names = [];
43
44		const MYSQL_TEXT_BYTE_LIMIT = 65535;
45
46		/**
47		* Constructor
48		*
49		* @param MetadataCache $metadata_cache A cache for this table
50		* @param Database $db The Elgg database
51		* @param Events $events The events registry
52		*/
53	4417	public function __construct(
54		MetadataCache $metadata_cache,
55		Database $db,
56		Events $events
57		) {
58	4417	$this->metadata_cache = $metadata_cache;
59	4417	$this->db = $db;
60	4417	$this->events = $events;
61	4417	}
62
63		/**
64		* Registers a metadata name as containing tags for an entity.
65		*
66		* @param string $name Tag name
67		*
68		* @return bool
69		*/
70	32	public function registerTagName($name) {
71	32	if (!in_array($name, $this->tag_names)) {
72	19	$this->tag_names[] = $name;
73		}
74
75	32	return true;
76		}
77
78		/**
79		* Unregisters a metadata tag name
80		*
81		* @param string $name Tag name
82		*
83		* @return bool
84		*/
85	1	public function unregisterTagName($name) {
86	1	$index = array_search($name, $this->tag_names);
87	1	if ($index >= 0) {
88	1	unset($this->tag_names[$index]);
89
90	1	return true;
91		}
92
93		return false;
94		}
95
96		/**
97		* Returns an array of valid metadata names for tags.
98		*
99		* @return string[]
100		*/
101	3	public function getTagNames() {
102	3	return $this->tag_names;
103		}
104
105		/**
106		* Get a specific metadata object by its id
107		*
108		* @see MetadataTable::getAll()
109		*
110		* @param int $id The id of the metadata object being retrieved.
111		*
112		* @return ElggMetadata\|false false if not found
113		*/
114	9	public function get($id) {
115	9	$qb = Select::fromTable('metadata');
116	9	$qb->select('*');
117
118	9	$where = new MetadataWhereClause();
119	9	$where->ids = $id;
		1 ignored issue – show Documentation Bug introduced 2017-11-22 15:01 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `$id` of type `integer` is incompatible with the declared type `integer[]` of property `$ids`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
120	9	$qb->addClause($where);
121
122	9	$row = $this->db->getDataRow($qb);
123	9	if ($row) {
124	9	return new ElggMetadata($row);
125		}
126
127		return false;
128		}
129
130		/**
131		* Deletes metadata using its ID
132		*
133		* @param ElggMetadata $metadata Metadata
134		*
135		* @return bool
136		*/
137	199	public function delete(ElggMetadata $metadata) {
138	199	if (!$metadata->id \|\| !$metadata->canEdit()) {
139		return false;
140		}
141
142	199	if (!elgg_trigger_event('delete', 'metadata', $metadata)) {
143		return false;
144		}
145
146	199	$qb = Delete::fromTable('metadata');
147	199	$qb->where($qb->compare('id', '=', $metadata->id, ELGG_VALUE_INTEGER));
148
149	199	$deleted = $this->db->deleteData($qb);
150
151	199	if ($deleted) {
152	199	$this->metadata_cache->clear($metadata->entity_guid);
153		}
154
155	199	return $deleted;
156		}
157
158		/**
159		* Create a new metadata object, or update an existing one (if multiple is allowed)
160		*
161		* Metadata can be an array by setting allow_multiple to true, but it is an
162		* indexed array with no control over the indexing
163		*
164		* @param ElggMetadata $metadata Metadata
165		* @param bool $allow_multiple Allow multiple values for one key. Default is false
166		*
167		* @return int\|false id of metadata or false if failure
168		*/
169	1028	public function create(ElggMetadata $metadata, $allow_multiple = false) {
170	1028	if (!isset($metadata->value) \|\| !isset($metadata->entity_guid)) {
171		elgg_log("Metadata must have a value and entity guid", 'ERROR');
172		return false;
173		}
174
175	1028	if (!is_scalar($metadata->value)) {
176		elgg_log("To set multiple metadata values use ElggEntity::setMetadata", 'ERROR');
177		return false;
178		}
179
180	1028	if ($metadata->id) {
181		if ($this->update($metadata)) {
182		return $metadata->id;
183		}
184		}
185
186	1028	if (strlen($metadata->value) > self::MYSQL_TEXT_BYTE_LIMIT) {
187		elgg_log("Metadata '$metadata->name' is above the MySQL TEXT size limit and may be truncated.", 'WARNING');
188		}
189
190	1028	if (!$allow_multiple) {
191	1027	$id = $this->getIdsByName($metadata->entity_guid, $metadata->name);
192
193	1027	if (is_array($id)) {
194		throw new \LogicException("Multiple '{$metadata->name}' metadata values exist for entity [guid: {$metadata->entity_guid}]. Use ElggEntity::setMetadata()");
195		}
196
197	1027	if ($id) {
198	198	$metadata->id = $id;
199
200	198	if ($this->update($metadata)) {
201	198	return $metadata->id;
202		}
203		}
204		}
205
206	1028	if (!$this->events->triggerBefore('create', 'metadata', $metadata)) {
207		return false;
208		}
209
210	1028	$time_created = $this->getCurrentTime()->getTimestamp();
211
212	1028	$qb = Insert::intoTable('metadata');
213	1028	$qb->values([
214	1028	'name' => $qb->param($metadata->name, ELGG_VALUE_STRING),
215	1028	'entity_guid' => $qb->param($metadata->entity_guid, ELGG_VALUE_INTEGER),
216	1028	'value' => $qb->param($metadata->value, $metadata->value_type === 'integer' ? ELGG_VALUE_INTEGER : ELGG_VALUE_STRING),
217	1028	'value_type' => $qb->param($metadata->value_type, ELGG_VALUE_STRING),
218	1028	'time_created' => $qb->param($time_created, ELGG_VALUE_INTEGER),
219		]);
220
221	1028	$id = $this->db->insertData($qb);
222
223	1028	if ($id === false) {
224		return false;
225		}
226
227	1028	$metadata->id = (int) $id;
228	1028	$metadata->time_created = $time_created;
229
230	1028	if ($this->events->trigger('create', 'metadata', $metadata)) {
231	1028	$this->metadata_cache->clear($metadata->entity_guid);
232
233	1028	$this->events->triggerAfter('create', 'metadata', $metadata);
234
235	1028	return $id;
236		} else {
237		$this->delete($metadata);
238
239		return false;
240		}
241		}
242
243		/**
244		* Update a specific piece of metadata
245		*
246		* @param ElggMetadata $metadata Updated metadata
247		*
248		* @return bool
249		*/
250	198	public function update(ElggMetadata $metadata) {
251	198	if (!$metadata->canEdit()) {
252	1	return false;
253		}
254
255	198	if (!$this->events->triggerBefore('update', 'metadata', $metadata)) {
256		return false;
257		}
258
259	198	if (strlen($metadata->value) > self::MYSQL_TEXT_BYTE_LIMIT) {
260		elgg_log("Metadata '$metadata->name' is above the MySQL TEXT size limit and may be truncated.", 'WARNING');
261		}
262
263	198	$qb = Update::table('metadata');
264	198	$qb->set('name', $qb->param($metadata->name, ELGG_VALUE_STRING))
265	198	->set('value', $qb->param($metadata->value, $metadata->value_type === 'integer' ? ELGG_VALUE_INTEGER : ELGG_VALUE_STRING))
266	198	->set('value_type', $qb->param($metadata->value_type, ELGG_VALUE_STRING))
267	198	->where($qb->compare('id', '=', $metadata->id, ELGG_VALUE_INTEGER));
268
269	198	$result = $this->db->updateData($qb);
270
271	198	if ($result === false) {
272		return false;
273		}
274
275	198	$this->metadata_cache->clear($metadata->entity_guid);
276
277	198	$this->events->trigger('update', 'metadata', $metadata);
278	198	$this->events->triggerAfter('update', 'metadata', $metadata);
279
280	198	return true;
281		}
282
283		/**
284		* Returns metadata
285		*
286		* Accepts all {@link elgg_get_entities()} options for entity restraints.
287		*
288		* @see elgg_get_entities()
289		*
290		* @param array $options Options
291		*
292		* @return ElggMetadata[]\|mixed
293		*/
294	590	public function getAll(array $options = []) {
295
296	590	$options['metastring_type'] = 'metadata';
297	590	$options = _elgg_normalize_metastrings_options($options);
298
299	590	return Metadata::find($options);
300		}
301
302		/**
303		* Deletes metadata based on $options.
304		*
305		* @warning Unlike elgg_get_metadata() this will not accept an empty options array!
306		* This requires at least one constraint:
307		* metadata_name(s), metadata_value(s), or guid(s) must be set.
308		*
309		* @see elgg_get_metadata()
310		* @see elgg_get_entities()
311		*
312		* @param array $options Options
313		*
314		* @return bool\|null true on success, false on failure, null if no metadata to delete.
315		*/
316	271	public function deleteAll(array $options) {
317	271	if (!_elgg_is_valid_options_for_batch_operation($options, 'metadata')) {
318		return false;
319		}
320
321		// This moved last in case an object's constructor sets metadata. Currently the batch
322		// delete process has to create the entity to delete its metadata. See #5214
323	271	$this->metadata_cache->invalidateByOptions($options);
324
325	271	$options['batch'] = true;
326	271	$options['batch_size'] = 50;
327	271	$options['batch_inc_offset'] = false;
328
329	271	$metadata = Metadata::find($options);
330	271	$count = $metadata->count();
331
332	271	if (!$count) {
333	91	return;
334		}
335
336	199	$success = 0;
337	199	foreach ($metadata as $md) {
338	199	if ($md->delete()) {
339	199	$success++;
340		}
341		}
342
343	199	return $success == $count;
344		}
345
346		/**
347		* Returns ID(s) of metadata with a particular name attached to an entity
348		*
349		* @param int $entity_guid Entity guid
350		* @param string $name Metadata name
351		*
352		* @return int[]\|int\|null
353		*/
354	1027	public function getIdsByName($entity_guid, $name) {
355	1027	if ($this->metadata_cache->isLoaded($entity_guid)) {
356	666	$ids = $this->metadata_cache->getSingleId($entity_guid, $name);
357		} else {
358	1027	$qb = Select::fromTable('metadata');
359	1027	$qb->select('id')
360	1027	->where($qb->compare('entity_guid', '=', $entity_guid, ELGG_VALUE_INTEGER))
361	1027	->andWhere($qb->compare('name', '=', $name, ELGG_VALUE_STRING));
362
363	1027	$callback = function (\stdClass $row) {
364	1	return (int) $row->id;
365	1027	};
366
367		$ids = $this->db->getData($qb, $callback);
368		}
369
370		if (empty($ids)) {
371		return null;
372		}
373
374		if (is_array($ids) && count($ids) === 1) {
375		return array_shift($ids);
376		}
377
378		return $ids;
379		}
380		}
381

Elgg / Elgg

Push — master ( c0a3a7...3b84a4 )

engine/classes/Elgg/Database/MetadataTable.php (1 issue)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like