EntityTable.php

Go to the documentation of this file.

<?php

namespace Elgg\Database;

use ClassException;
use DatabaseException;
use Elgg\Cache\EntityCache;
use Elgg\Cache\MetadataCache;
use Elgg\Config;
use Elgg\Database;
use Elgg\Database\Clauses\EntityWhereClause;
use Elgg\Database\EntityTable\UserFetchFailureException;
use Elgg\EntityPreloader;
use Elgg\EventsService;
use Elgg\I18n\Translator;
use Elgg\Logger;
use ElggBatch;
use ElggEntity;
use ElggGroup;
use ElggObject;
use ElggSession;
use ElggSite;
use ElggUser;
use InvalidParameterException;
use Psr\Log\LoggerInterface;
use stdClass;
use Elgg\Cache\PrivateSettingsCache;

class EntityTable {

    use \Elgg\TimeUsing;

    protected $config;

    protected $db;

    protected $table;

    protected $entity_classes;

    protected $entity_cache;

    protected $entity_preloader;

    protected $metadata_cache;

    protected $private_settings_cache;

    protected $events;

    protected $session;

    protected $translator;

    protected $logger;

    public function __construct(
        Config $config,
        Database $db,
        EntityCache $entity_cache,
        MetadataCache $metadata_cache,
        PrivateSettingsCache $private_settings_cache,
        EventsService $events,
        ElggSession $session,
        Translator $translator,
        LoggerInterface $logger
    ) {
        $this->config = $config;
        $this->db = $db;
        $this->table = $this->db->prefix . 'entities';
        $this->entity_cache = $entity_cache;
        $this->metadata_cache = $metadata_cache;
        $this->private_settings_cache = $private_settings_cache;
        $this->events = $events;
        $this->session = $session;
        $this->translator = $translator;
        $this->logger = $logger;
    }

    public function setEntityClass($type, $subtype, $class = '') {
        if (!in_array($type, Config::getEntityTypes())) {
            throw new InvalidParameterException("$type is not a valid entity type");
        }

        $this->entity_classes[$type][$subtype] = $class;
    }

    public function getEntityClass($type, $subtype) {
        if (isset($this->entity_classes[$type][$subtype])) {
            return $this->entity_classes[$type][$subtype];
        }

        return '';
    }

    public function getRow($guid, $user_guid = null) {

        if (!$guid) {
            return false;
        }

        $where = new EntityWhereClause();
        $where->guids = (int) $guid;
        $where->viewer_guid = $user_guid;

        $select = Select::fromTable('entities', 'e');
        $select->select('e.*');
        $select->addClause($where);

        return $this->db->getDataRow($select);
    }

    public function insertRow(stdClass $row, array $attributes = []) {

        $sql = "
            INSERT INTO {$this->db->prefix}entities
            (type, subtype, owner_guid, container_guid, access_id, time_created, time_updated, last_action)
            VALUES
            (:type, :subtype, :owner_guid, :container_guid, :access_id, :time_created, :time_updated, :last_action)
        ";

        return $this->db->insertData($sql, [
            ':type' => $row->type,
            ':subtype' => $row->subtype,
            ':owner_guid' => $row->owner_guid,
            ':container_guid' => $row->container_guid,
            ':access_id' => $row->access_id,
            ':time_created' => $row->time_created,
            ':time_updated' => $row->time_updated,
            ':last_action' => $row->last_action,
        ]);
    }

    public function updateRow($guid, stdClass $row) {
        $sql = "
            UPDATE {$this->db->prefix}entities
            SET owner_guid = :owner_guid,
                access_id = :access_id,
                container_guid = :container_guid,
                time_created = :time_created,
                time_updated = :time_updated
            WHERE guid = :guid
        ";

        $params = [
            ':owner_guid' => $row->owner_guid,
            ':access_id' => $row->access_id,
            ':container_guid' => $row->container_guid,
            ':time_created' => $row->time_created,
            ':time_updated' => $row->time_updated,
            ':guid' => $guid,
        ];

        return $this->db->updateData($sql, false, $params);
    }

    public function rowToElggStar(stdClass $row) {
        if (!isset($row->guid) || !isset($row->subtype)) {
            return false;
        }

        $class_name = $this->getEntityClass($row->type, $row->subtype);
        if ($class_name && !class_exists($class_name)) {
            $this->logger->error("Class '$class_name' was not found, missing plugin?");
            $class_name = '';
        }

        if (!$class_name) {
            $map = [
                'object' => ElggObject::class,
                'user' => ElggUser::class,
                'group' => ElggGroup::class,
                'site' => ElggSite::class,
            ];

            if (isset($map[$row->type])) {
                $class_name = $map[$row->type];
            } else {
                throw new InvalidParameterException("Entity type {$row->type} is not supported.");
            }
        }

        $entity = new $class_name($row);
        if (!$entity instanceof ElggEntity) {
            throw new ClassException("$class_name must extend " . ElggEntity::class);
        }

        return $entity;
    }

    public function getFromCache($guid) {
        $entity = $this->entity_cache->load($guid);
        if ($entity) {
            return $entity;
        }

        $cache = _elgg_services()->dataCache->entities;
        $entity = $cache->load($guid);
        if (!$entity instanceof ElggEntity) {
            return false;
        }

        // Validate accessibility if from cache
        if (!elgg_get_ignore_access() && !has_access_to_entity($entity)) {
            return false;
        }

        $entity->cache(false);

        return $entity;
    }

    public function invalidateCache($guid) {
        $ia = $this->session->setIgnoreAccess(true);
        $ha = $this->session->getDisabledEntityVisibility();
        $this->session->setDisabledEntityVisibility(true);
        $entity = $this->get($guid);
        if ($entity) {
            $entity->invalidateCache();
        }
        $this->session->setDisabledEntityVisibility($ha);
        $this->session->setIgnoreAccess($ia);
    }

    public function get($guid, $type = null, $subtype = null) {
        // We could also use: if (!(int) $guid) { return false },
        // but that evaluates to a false positive for $guid = true.
        // This is a bit slower, but more thorough.
        if (!is_numeric($guid) || $guid === 0 || $guid === '0') {
            return false;
        }

        $guid = (int) $guid;

        $entity = $this->getFromCache($guid);
        if ($entity && elgg_instanceof($entity, $type, $subtype)) {
            return $entity;
        }

        $row = $this->getRow($guid);
        if (!$row) {
            return false;
        }

        if ($type && $row->type != $type) {
            return false;
        }

        if ($subtype && $row->subtype !== $subtype) {
            return false;
        }

        $entity = $row;

        if ($entity instanceof \stdClass) {
            $entity = $this->rowToElggStar($entity);
        }

        $entity->cache();

        return $entity;
    }

    public function exists($guid) {

        // need to ignore access and show hidden entities to check existence
        $ia = $this->session->setIgnoreAccess(true);
        $show_hidden = $this->session->setDisabledEntityVisibility(true);

        $result = $this->getRow($guid);

        $this->session->setIgnoreAccess($ia);
        $this->session->setDisabledEntityVisibility($show_hidden);

        return !empty($result);
    }

    public function enable($guid, $recursive = true) {

        // Override access only visible entities
        $old_access_status = $this->session->getDisabledEntityVisibility();
        $this->session->setDisabledEntityVisibility(true);

        $result = false;
        $entity = get_entity($guid);
        if ($entity) {
            $result = $entity->enable($recursive);
        }

        $this->session->setDisabledEntityVisibility($old_access_status);

        return $result;
    }

    public function fetch(QueryBuilder $query, array $options = []) {
        $results = $this->db->getData($query, $options['callback']);

        if (empty($results)) {
            return [];
        }

        $preload = array_filter($results, function ($e) {
            return $e instanceof ElggEntity;
        });
        /* @var $preload ElggEntity[] */

        $this->metadata_cache->populateFromEntities($preload);
        
        if (elgg_extract('preload_private_settings', $options, false)) {
            $this->private_settings_cache->populateFromEntities($preload);
        }
        
        $props_to_preload = [];
        if (elgg_extract('preload_owners', $options, false)) {
            $props_to_preload[] = 'owner_guid';
        }
        if (elgg_extract('preload_containers', $options, false)) {
            $props_to_preload[] = 'container_guid';
        }

        if ($props_to_preload) {
            _elgg_services()->entityPreloader->preload($preload, $props_to_preload);
        }

        return $results;
    }

    public function updateLastAction(ElggEntity $entity, $posted = null) {

        if ($posted === null) {
            $posted = $this->getCurrentTime()->getTimestamp();
        }

        $query = "
            UPDATE {$this->db->prefix}entities
            SET last_action = :last_action
            WHERE guid = :guid
        ";

        $params = [
            ':last_action' => (int) $posted,
            ':guid' => (int) $entity->guid,
        ];

        $this->db->updateData($query, true, $params);

        return (int) $posted;
    }

    public function getUserForPermissionsCheck($guid = 0) {
        if (!$guid) {
            return $this->session->getLoggedInUser();
        }

        // need to ignore access and show hidden entities for potential hidden/disabled users
        $ia = $this->session->setIgnoreAccess(true);
        $show_hidden = $this->session->setDisabledEntityVisibility(true);

        $user = $this->get($guid, 'user');
        if ($user) {
            $this->metadata_cache->populateFromEntities([$user->guid]);
        }

        $this->session->setIgnoreAccess($ia);
        $this->session->setDisabledEntityVisibility($show_hidden);

        if (!$user) {
            // requested to check access for a specific user_guid, but there is no user entity, so the caller
            // should cancel the check and return false
            $message = $this->translator->translate('UserFetchFailureException', [$guid]);
            // $this->logger->warn($message);

            throw new UserFetchFailureException($message);
        }

        return $user;
    }

    public function disableEntities(ElggEntity $entity) {
        if (!$entity->canEdit()) {
            return false;
        }

        if (!$this->events->trigger('disable', $entity->type, $entity)) {
            return false;
        }

        $qb = Update::table('entities');
        $qb->set('enabled', $qb->param('no', ELGG_VALUE_STRING))
            ->where($qb->compare('owner_guid', '=', $entity->guid, ELGG_VALUE_INTEGER))
            ->orWhere($qb->compare('container_guid', '=', $entity->guid, ELGG_VALUE_INTEGER));

        $this->db->updateData($qb, true);

        $entity->invalidateCache();

        return true;
    }

    public function delete(\ElggEntity $entity, $recursive = true) {
        $guid = $entity->guid;
        if (!$guid) {
            return false;
        }

        if (!_elgg_services()->events->triggerBefore('delete', $entity->type, $entity)) {
            return false;
        }

        // now trigger an event to let others know this entity is about to be deleted
        // so they can prevent it or take their own actions
        if (!_elgg_services()->events->triggerDeprecated('delete', $entity->type, $entity)) {
            return false;
        }

        if ($entity instanceof ElggUser) {
            // ban to prevent using the site during delete
            $entity->ban();
        }

        if ($recursive) {
            $this->deleteRelatedEntities($entity);
        }

        $this->deleteEntityProperties($entity);

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

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

        _elgg_services()->events->triggerAfter('delete', $entity->type, $entity);

        return true;
    }

    protected function deleteRelatedEntities(ElggEntity $entity) {
        // Temporarily overriding access controls
        $entity_disable_override = $this->session->getDisabledEntityVisibility();
        $this->session->setDisabledEntityVisibility(true);
        $ia = $this->session->setIgnoreAccess(true);

        $options = [
            'wheres' => function (QueryBuilder $qb, $main_alias) use ($entity) {
                $ors = $qb->merge([
                    $qb->compare("{$main_alias}.owner_guid", '=', $entity->guid, ELGG_VALUE_GUID),
                    $qb->compare("{$main_alias}.container_guid", '=', $entity->guid, ELGG_VALUE_GUID),
                ], 'OR');

                return $qb->merge([
                    $ors,
                    $qb->compare("{$main_alias}.guid", 'neq', $entity->guid, ELGG_VALUE_GUID),
                ]);
            },
            'limit' => false,
        ];

        $batch = new ElggBatch('elgg_get_entities', $options);
        $batch->setIncrementOffset(false);

        /* @var $e \ElggEntity */
        foreach ($batch as $e) {
            $this->delete($e, true);
        }

        $this->session->setDisabledEntityVisibility($entity_disable_override);
        $this->session->setIgnoreAccess($ia);
    }

    protected function deleteEntityProperties(ElggEntity $entity) {
        elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES, function() use ($entity) {
            $entity->removeAllRelatedRiverItems();
            $entity->removeAllPrivateSettings();
            $entity->deleteOwnedAccessCollections();
            $entity->deleteAccessCollectionMemberships();
            $entity->deleteRelationships();
            $entity->deleteOwnedAnnotations();
            $entity->deleteAnnotations();
            $entity->deleteMetadata();
        });
        
        $dir = new \Elgg\EntityDirLocator($entity->guid);
        $file_path = _elgg_config()->dataroot . $dir;
        delete_directory($file_path);

    }
}