Elgg\Database\MetadataTable

Complexity

Total Complexity

47

Size/Duplication

Total Lines	422
Duplicated Lines	0 %

Test Coverage

Coverage

84.38%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	registerTagName()	0	6	2
A	unregisterTagName()	0	9	2
A	__construct()	0	8	1
A	getTagNames()	0	2	1
A	getAll()	0	6	1
B	getIdsByName()	0	25	5
B	update()	0	31	6
B	getTags()	0	35	2
B	delete()	0	19	5
C	create()	0	74	15
A	get()	0	14	2
B	deleteAll()	0	28	5

<?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 popular tags and their frequencies
	 *
	 * Accepts all options supported by {@link elgg_get_entities()}
	 *
	 * Returns an array of objects that include "tag" and "total" properties
	 *
	 * @todo   When updating this function for 3.0, I have noticed that docs explicitly mention
	 *       that tags must be registered, but it was not really checked anywhere in code
	 *       So, either update the docs or decide what the behavior should be
	 *
	 * @param array $options Options
	 *
	 * @return    object[]|false
	 * @throws \DatabaseException
	 * @option int      $threshold Minimum number of tag occurrences
	 * @option string[] $tag_names Names of registered tag names to include in search
	 *
	 */
	public function getTags(array $options = []) {
		$defaults = [
			'threshold' => 1,
			'tag_names' => [],
		];

		$options = array_merge($defaults, $options);

		$singulars = ['tag_name'];
		$options = LegacyQueryOptionsAdapter::normalizePluralOptions($options, $singulars);

		$tag_names = elgg_extract('tag_names', $options);
		if (empty($tag_names)) {
			$tag_names = elgg_get_registered_tag_metadata_names();
		}

		$threshold = elgg_extract('threshold', $options, 1, false);

		unset($options['tag_names']);
		unset($options['threshold']);

		$qb = \Elgg\Database\Select::fromTable('metadata', 'md');
		$qb->select('md.value AS tag')
			->addSelect('COUNT(md.id) AS total')
			->where($qb->compare('md.name', 'IN', $tag_names, ELGG_VALUE_STRING))
			->andWhere($qb->compare('md.value', '!=', '', ELGG_VALUE_STRING))
			->groupBy('md.value')
			->having($qb->compare('total', '>=', $threshold, ELGG_VALUE_INTEGER))
			->orderBy('total', 'desc');

		$options = new \Elgg\Database\QueryOptions($options);
		$alias = $qb->joinEntitiesTable('md', 'entity_guid', 'inner', 'e');
		$qb->addClause(\Elgg\Database\Clauses\EntityWhereClause::factory($options), $alias);

		return _elgg_services()->db->getData($qb);
	}

	/**
	 * 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
	 * @throws \DatabaseException
	 */
	public function get($id) {
		$qb = Select::fromTable('metadata');
		$qb->select('*');

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

It seems like $id of type integer is incompatible with the declared type integer[] of property $ids.

		$qb->addClause($where);

		$row = $this->db->getDataRow($qb);
		if ($row) {

The expression $row of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			return new ElggMetadata($row);
		}

		return false;
	}

	/**
	 * Deletes metadata using its ID
	 *
	 * @param ElggMetadata $metadata Metadata
	 *
	 * @return bool
	 * @throws \DatabaseException
	 */
	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 !== false;
	}

	/**
	 * 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
	 * @throws \DatabaseException
	 */
	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) {

The expression $id of type null|integer is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== null instead.

				$metadata->id = $id;

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

		if (!$this->events->triggerBefore('create', 'metadata', $metadata)) {

$metadata of type ElggMetadata is incompatible with the type string expected by parameter $object of Elgg\EventsService::triggerBefore().

			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);

$metadata of type ElggMetadata is incompatible with the type string expected by parameter $object of Elgg\EventsService::triggerAfter().

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

			return false;
		}
	}

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

		if (!$this->events->triggerBefore('update', 'metadata', $metadata)) {

$metadata of type ElggMetadata is incompatible with the type string expected by parameter $object of Elgg\EventsService::triggerBefore().

			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);

$metadata of type ElggMetadata is incompatible with the type string expected by parameter $object of Elgg\EventsService::triggerAfter().

		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 = LegacyQueryOptionsAdapter::normalizeMetastringOptions($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;
	}
}