EntityTable.php

Go to the documentation of this file.

<?php

namespace Elgg\Database;

use Elgg\Cache\EntityCache;
use Elgg\Cache\MetadataCache;
use Elgg\Config;
use Elgg\Database;
use Elgg\Database\Clauses\EntityWhereClause;
use Elgg\EntityPreloader;
use Elgg\EventsService;
use Elgg\Exceptions\ClassException;
use Elgg\Exceptions\Database\UserFetchFailureException;
use Elgg\Exceptions\DomainException;
use Elgg\I18n\Translator;
use Elgg\SessionManagerService;
use Elgg\Traits\Loggable;
use Elgg\Traits\TimeUsing;

class EntityTable {

    use Loggable;
    use TimeUsing;

    const TABLE_NAME = 'entities';

    protected Config $config;

    protected Database $db;

    protected EntityCache $entity_cache;

    protected EntityPreloader $entity_preloader;

    protected MetadataCache $metadata_cache;

    protected EventsService $events;

    protected SessionManagerService $session_manager;

    protected Translator $translator;

    protected array $deleted_guids = [];
    
    protected array $entity_classes = [];

    public function __construct(
        Config $config,
        Database $db,
        EntityCache $entity_cache,
        MetadataCache $metadata_cache,
        EventsService $events,
        SessionManagerService $session_manager,
        Translator $translator
    ) {
        $this->config = $config;
        $this->db = $db;
        $this->entity_cache = $entity_cache;
        $this->metadata_cache = $metadata_cache;
        $this->events = $events;
        $this->session_manager = $session_manager;
        $this->translator = $translator;
    }

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

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

    public function getEntityClass(string $type, string $subtype): string {
        return $this->entity_classes[$type][$subtype] ?? '';
    }

    public function getRow(int $guid, int $user_guid = null): ?\stdClass {
        if ($guid < 0) {
            return null;
        }

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

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

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

    public function insertRow(\stdClass $row, array $attributes = []): int {
        $insert = Insert::intoTable(self::TABLE_NAME);
        $insert->values([
            'type' => $insert->param($row->type, ELGG_VALUE_STRING),
            'subtype' => $insert->param($row->subtype, ELGG_VALUE_STRING),
            'owner_guid' => $insert->param($row->owner_guid, ELGG_VALUE_GUID),
            'container_guid' => $insert->param($row->container_guid, ELGG_VALUE_GUID),
            'access_id' => $insert->param($row->access_id, ELGG_VALUE_ID),
            'time_created' => $insert->param($row->time_created, ELGG_VALUE_TIMESTAMP),
            'time_updated' => $insert->param($row->time_updated, ELGG_VALUE_TIMESTAMP),
            'last_action' => $insert->param($row->last_action, ELGG_VALUE_TIMESTAMP),
        ]);

        return $this->db->insertData($insert);
    }

    public function updateRow(int $guid, \stdClass $row): bool {
        $update = Update::table(self::TABLE_NAME);
        $update->set('owner_guid', $update->param($row->owner_guid, ELGG_VALUE_GUID))
            ->set('container_guid', $update->param($row->container_guid, ELGG_VALUE_GUID))
            ->set('access_id', $update->param($row->access_id, ELGG_VALUE_ID))
            ->set('time_created', $update->param($row->time_created, ELGG_VALUE_TIMESTAMP))
            ->set('time_updated', $update->param($row->time_updated, ELGG_VALUE_TIMESTAMP))
            ->where($update->compare('guid', '=', $guid, ELGG_VALUE_GUID));

        return $this->db->updateData($update);
    }

    public function rowToElggStar(\stdClass $row): ?\ElggEntity {
        if (!isset($row->guid) || !isset($row->subtype)) {
            return null;
        }

        $class_name = $this->getEntityClass($row->type, $row->subtype);
        if ($class_name && !class_exists($class_name)) {
            $this->getLogger()->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 DomainException("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(int $guid): ?\ElggEntity {
        $entity = $this->entity_cache->load($guid);
        if ($entity) {
            return $entity;
        }

        $entity = _elgg_services()->sessionCache->entities->load($guid);
        if (!$entity instanceof \ElggEntity) {
            return null;
        }

        // Validate accessibility if from cache
        if (!elgg_get_ignore_access() && !$entity->hasAccess()) {
            return null;
        }

        $entity->cache(false);

        return $entity;
    }

    public function invalidateCache(int $guid): void {
        elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES, function() use ($guid) {
            $entity = $this->get($guid);
            if ($entity instanceof \ElggEntity) {
                $entity->invalidateCache();
            }
        });
    }

    public function get(int $guid, string $type = null, string $subtype = null): ?\ElggEntity {
        $entity = $this->getFromCache($guid);
        if ($entity instanceof \ElggEntity &&
            (!isset($type) || $entity->type === $type) &&
            (!isset($subtype) || $entity->subtype === $subtype)
        ) {
            return $entity;
        }

        $row = $this->getRow($guid);
        if (empty($row)) {
            return null;
        }

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

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

        $entity = $row;

        if ($entity instanceof \stdClass) {
            // Need to check for \stdClass because the unit test mocker returns \ElggEntity classes
            $entity = $this->rowToElggStar($entity);
        }

        $entity->cache();

        return $entity;
    }

    public function exists(int $guid): bool {
        return elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES, function() use ($guid) {
            // need to ignore access and show hidden entities to check existence
            return !empty($this->getRow($guid));
        });
    }

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

        /* @var $preload \ElggEntity[] */
        $preload = array_filter($results, function ($e) {
            return $e instanceof \ElggEntity;
        });
        
        $this->metadata_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 (!empty($props_to_preload)) {
            _elgg_services()->entityPreloader->preload($preload, $props_to_preload);
        }

        return $results;
    }

    public function updateLastAction(\ElggEntity $entity, int $posted = null): int {
        if ($posted === null) {
            $posted = $this->getCurrentTime()->getTimestamp();
        }

        $update = Update::table(self::TABLE_NAME);
        $update->set('last_action', $update->param($posted, ELGG_VALUE_TIMESTAMP))
            ->where($update->compare('guid', '=', $entity->guid, ELGG_VALUE_GUID));

        $this->db->updateData($update);

        return (int) $posted;
    }

    public function getUserForPermissionsCheck(int $guid = null): ?\ElggUser {
        if (empty($guid) || $guid === $this->session_manager->getLoggedInUserGuid()) {
            return $this->session_manager->getLoggedInUser();
        }

        $user = elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES, function() use ($guid) {
            // need to ignore access and show hidden entities for potential hidden/disabled users
            return $this->get($guid, 'user');
        });

        if (!$user instanceof \ElggUser) {
            // 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]);

            throw new UserFetchFailureException($message);
        }

        return $user;
    }

    public function enable(\ElggEntity $entity): bool {
        $qb = Update::table(self::TABLE_NAME);
        $qb->set('enabled', $qb->param('yes', ELGG_VALUE_STRING))
            ->where($qb->compare('guid', '=', $entity->guid, ELGG_VALUE_GUID));

        return $this->db->updateData($qb);
    }

    public function disable(\ElggEntity $entity): bool {
        $qb = Update::table(self::TABLE_NAME);
        $qb->set('enabled', $qb->param('no', ELGG_VALUE_STRING))
            ->where($qb->compare('guid', '=', $entity->guid, ELGG_VALUE_GUID));
        
        return $this->db->updateData($qb);
    }

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

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

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

        // we're going to delete this entity, log the guid to prevent deadloops
        $this->deleted_guids[] = $entity->guid;
        
        if ($recursive) {
            $this->deleteRelatedEntities($entity);
        }

        $this->deleteEntityProperties($entity);

        $qb = Delete::fromTable(self::TABLE_NAME);
        $qb->where($qb->compare('guid', '=', $guid, ELGG_VALUE_GUID));

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

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

        return true;
    }

    protected function deleteRelatedEntities(\ElggEntity $entity): void {
        // Temporarily overriding access controls
        elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES, function() use ($entity) {
            /* @var $batch \ElggBatch */
            $batch = elgg_get_entities([
                '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' => true,
                'batch_inc_offset' => false,
            ]);
            
            /* @var $e \ElggEntity */
            foreach ($batch as $e) {
                if (in_array($e->guid, $this->deleted_guids)) {
                    // prevent deadloops, doing this here in case of large deletes which could cause query length issues
                    $batch->reportFailure();
                    continue;
                }
                
                if (!$this->delete($e, true)) {
                    $batch->reportFailure();
                }
            }
        });
    }

    protected function deleteEntityProperties(\ElggEntity $entity): void {
        // Temporarily overriding access controls and disable system_log to save performance
        elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES | ELGG_DISABLE_SYSTEM_LOG, function() use ($entity) {
            $entity->removeAllRelatedRiverItems();
            $entity->deleteOwnedAccessCollections();
            $entity->deleteAccessCollectionMemberships();
            // remove relationships without events
            // can't use DI provided service because of circular reference
            _elgg_services()->relationshipsTable->removeAll($entity->guid, '', false, '', false);
            _elgg_services()->relationshipsTable->removeAll($entity->guid, '', true, '', false);
            $entity->deleteOwnedAnnotations();
            $entity->deleteAnnotations();
            $entity->deleteMetadata();
            _elgg_services()->delayedEmailQueueTable->deleteAllRecipientRows($entity->guid);
        });
        
        $dir = new \Elgg\EntityDirLocator($entity->guid);
        $file_path = _elgg_services()->config->dataroot . $dir;
        elgg_delete_directory($file_path);
    }
}