RelationshipsTable.php

Go to the documentation of this file.

<?php

namespace Elgg\Database;

use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Elgg\Database;
use Elgg\Database\Clauses\GroupByClause;
use Elgg\Database\Clauses\OrderByClause;
use Elgg\Database\Clauses\SelectClause;
use Elgg\EventsService;
use Elgg\Exceptions\DatabaseException;
use Elgg\Exceptions\LengthException;
use Elgg\Traits\TimeUsing;

class RelationshipsTable {

    use TimeUsing;
    
    const RELATIONSHIP_COLUMN_LENGTH = 255;
    
    protected Database $db;

    protected EntityTable $entities;

    protected MetadataTable $metadata;

    protected EventsService $events;

    public function __construct(Database $db, EntityTable $entities, MetadataTable $metadata, EventsService $events) {
        $this->db = $db;
        $this->entities = $entities;
        $this->metadata = $metadata;
        $this->events = $events;
    }

    public function get(int $id): ?\ElggRelationship {
        $select = Select::fromTable('entity_relationships');
        $select->select('*')
            ->where($select->compare('id', '=', $id, ELGG_VALUE_ID));
        
        return $this->db->getDataRow($select, [$this, 'rowToElggRelationship']) ?: null;
    }

    public function delete(int $id, bool $call_event = true): bool {
        $relationship = $this->get($id);
        if (!$relationship instanceof \ElggRelationship) {
            return false;
        }

        if ($call_event && !$this->events->trigger('delete', 'relationship', $relationship)) {
            return false;
        }

        $delete = Delete::fromTable('entity_relationships');
        $delete->where($delete->compare('id', '=', $id, ELGG_VALUE_ID));
        
        return (bool) $this->db->deleteData($delete);
    }

    public function add(int $guid_one, string $relationship, int $guid_two, bool $return_id = false): bool|int {
        if (strlen($relationship) > self::RELATIONSHIP_COLUMN_LENGTH) {
            throw new LengthException('Relationship name cannot be longer than ' . self::RELATIONSHIP_COLUMN_LENGTH);
        }

        // Check for duplicates
        // note: escape $relationship after this call, we don't want to double-escape
        if ($this->check($guid_one, $relationship, $guid_two)) {
            return false;
        }
        
        // Check if the related entities exist
        if (!$this->entities->exists($guid_one) || !$this->entities->exists($guid_two)) {
            // one or both of the guids doesn't exist
            return false;
        }
        
        $insert = Insert::intoTable('entity_relationships');
        $insert->values([
            'guid_one' => $insert->param($guid_one, ELGG_VALUE_GUID),
            'relationship' => $insert->param($relationship, ELGG_VALUE_STRING),
            'guid_two' => $insert->param($guid_two, ELGG_VALUE_GUID),
            'time_created' => $insert->param($this->getCurrentTime()->getTimestamp(), ELGG_VALUE_TIMESTAMP),
        ]);
        
        try {
            $id = $this->db->insertData($insert);
            if (!$id) {
                return false;
            }
        } catch (DatabaseException $e) {
            $prev = $e->getPrevious();
            if ($prev instanceof UniqueConstraintViolationException) {
                // duplicate key error see https://github.com/Elgg/Elgg/issues/9179
                return false;
            }
            
            throw $e;
        }

        $obj = $this->get($id);

        $result = $this->events->trigger('create', 'relationship', $obj);
        if (!$result) {
            $this->delete($id, false);
            return false;
        }

        return $return_id ? $obj->id : true;
    }

    public function check(int $guid_one, string $relationship, int $guid_two) {
        $select = Select::fromTable('entity_relationships');
        $select->select('*')
            ->where($select->compare('guid_one', '=', $guid_one, ELGG_VALUE_GUID))
            ->andWhere($select->compare('relationship', '=', $relationship, ELGG_VALUE_STRING))
            ->andWhere($select->compare('guid_two', '=', $guid_two, ELGG_VALUE_GUID))
            ->setMaxResults(1);
        
        $row = $this->db->getDataRow($select, [$this, 'rowToElggRelationship']);
        return $row instanceof \ElggRelationship ? $row : false;
    }

    public function remove(int $guid_one, string $relationship, int $guid_two): bool {
        $obj = $this->check($guid_one, $relationship, $guid_two);
        if (!$obj instanceof \ElggRelationship) {
            return false;
        }

        return $this->delete($obj->id);
    }

    public function removeAll(int $guid, string $relationship = '', bool $inverse_relationship = false, string $type = '', bool $trigger_events = true): bool {
        if ($trigger_events) {
            return $this->removeAllWithEvents($guid, $relationship, $inverse_relationship, $type);
        }
        
        return $this->removeAllWithoutEvents($guid, $relationship, $inverse_relationship, $type);
    }
    
    protected function removeAllWithoutEvents(int $guid, string $relationship = '', bool $inverse_relationship = false, string $type = ''): bool {
        $delete = Delete::fromTable('entity_relationships');
        
        if ($inverse_relationship) {
            $delete->where($delete->compare('guid_two', '=', $guid, ELGG_VALUE_GUID));
        } else {
            $delete->where($delete->compare('guid_one', '=', $guid, ELGG_VALUE_GUID));
        }
        
        if (!empty($relationship)) {
            $delete->andWhere($delete->compare('relationship', '=', $relationship, ELGG_VALUE_STRING));
        }
        
        if (!empty($type)) {
            $entity_sub = $delete->subquery('entities');
            $entity_sub->select('guid')
            ->where($delete->compare('type', '=', $type, ELGG_VALUE_STRING));
            
            if (!$inverse_relationship) {
                $delete->andWhere($delete->compare('guid_two', 'in', $entity_sub->getSQL()));
            } else {
                $delete->andWhere($delete->compare('guid_one', 'in', $entity_sub->getSQL()));
            }
        }
        
        $this->db->deleteData($delete);
        
        return true;
    }
    
    protected function removeAllWithEvents(int $guid, string $relationship = '', bool $inverse_relationship = false, string $type = ''): bool {
        $select = Select::fromTable('entity_relationships');
        $select->select('*');
        
        if ($inverse_relationship) {
            $select->where($select->compare('guid_two', '=', $guid, ELGG_VALUE_GUID));
        } else {
            $select->where($select->compare('guid_one', '=', $guid, ELGG_VALUE_GUID));
        }
        
        if (!empty($relationship)) {
            $select->andWhere($select->compare('relationship', '=', $relationship, ELGG_VALUE_STRING));
        }
        
        if (!empty($type)) {
            $entity_sub = $select->subquery('entities');
            $entity_sub->select('guid')
            ->where($select->compare('type', '=', $type, ELGG_VALUE_STRING));
            
            if (!$inverse_relationship) {
                $select->andWhere($select->compare('guid_two', 'in', $entity_sub->getSQL()));
            } else {
                $select->andWhere($select->compare('guid_one', 'in', $entity_sub->getSQL()));
            }
        }
        
        $remove_ids = [];
        
        $relationships = $this->db->getData($select, [$this, 'rowToElggRelationship']);
        
        /* @var $rel \ElggRelationship */
        foreach ($relationships as $rel) {
            if (!$this->events->trigger('delete', 'relationship', $rel)) {
                continue;
            }
            
            $remove_ids[] = $rel->id;
        }
        
        // to prevent MySQL query length issues
        $chunks = array_chunk($remove_ids, 250);
        foreach ($chunks as $chunk) {
            if (empty($chunk)) {
                continue;
            }
            
            $delete = Delete::fromTable('entity_relationships');
            $delete->where($delete->compare('id', 'in', $chunk));
            
            $this->db->deleteData($delete);
        }
        
        return true;
    }

    public function getEntitiesFromCount(array $options = []) {
        $options['selects'][] = new SelectClause('COUNT(e.guid) AS total');
        $options['group_by'][] = new GroupByClause('r.guid_two');
        $options['order_by'][] = new OrderByClause('total', 'desc');

        return Entities::find($options);
    }

    public function rowToElggRelationship(\stdClass $row): \ElggRelationship {
        return new \ElggRelationship($row);
    }
}