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;
    
    public const RELATIONSHIP_COLUMN_LENGTH = 255;
    
    public const TABLE_NAME = 'entity_relationships';
    
    public const DEFAULT_JOIN_ALIAS = 'r';
 
    public function __construct(
        protected Database $db,
        protected EntityTable $entities,
        protected MetadataTable $metadata,
        protected EventsService $events
    ) {
    }
 
    public function get(int $id): ?\ElggRelationship {
        $select = Select::fromTable(self::TABLE_NAME);
        $select->select('*')
            ->where($select->compare('id', '=', $id, ELGG_VALUE_ID));
        
        return $this->db->getDataRow($select, [$this, 'rowToElggRelationship']) ?: null;
    }
 
    public function delete(int $id): bool {
        $relationship = $this->get($id);
        if (!$relationship instanceof \ElggRelationship) {
            return false;
        }
 
        return $this->events->triggerSequence('delete', 'relationship', $relationship, function() use ($id) {
            $delete = Delete::fromTable(self::TABLE_NAME);
            $delete->where($delete->compare('id', '=', $id, ELGG_VALUE_ID));
            
            return (bool) $this->db->deleteData($delete);
        });
    }
 
    public function add(\ElggRelationship $relationship, bool $return_id = false): bool|int {
        if (strlen($relationship->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($relationship->guid_one, $relationship->relationship, $relationship->guid_two)) {
            return false;
        }
        
        // Check if the related entities exist
        if (!$this->entities->exists($relationship->guid_one) || !$this->entities->exists($relationship->guid_two)) {
            // one or both of the guids doesn't exist
            return false;
        }
        
        $id = 0;
        
        $result = $this->events->triggerSequence('create', 'relationship', $relationship, function (\ElggRelationship $relationship) use (&$id) {
            $insert = Insert::intoTable(self::TABLE_NAME);
            $insert->values([
                'guid_one' => $insert->param($relationship->guid_one, ELGG_VALUE_GUID),
                'relationship' => $insert->param($relationship->relationship, ELGG_VALUE_STRING),
                'guid_two' => $insert->param($relationship->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;
                }
                
                $relationship->time_created = $this->getCurrentTime()->getTimestamp();
                $relationship->id = $id;
            } 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;
            }
            
            return true;
        });
        
        if (!$result) {
            return false;
        }
        
        return $return_id ? $id : true;
    }
 
    public function check(int $guid_one, string $relationship, int $guid_two) {
        $select = Select::fromTable(self::TABLE_NAME);
        $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(self::TABLE_NAME);
        
        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(EntityTable::TABLE_NAME);
            $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(self::TABLE_NAME);
        $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(EntityTable::TABLE_NAME);
            $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->triggerBefore('delete', 'relationship', $rel)) {
                continue;
            }
            
            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(self::TABLE_NAME);
            $delete->where($delete->compare('id', 'in', $chunk));
            
            $this->db->deleteData($delete);
        }
        
        /* @var $rel \ElggRelationship */
        foreach ($relationships as $rel) {
            if (!in_array($rel->id, $remove_ids)) {
                continue;
            }
            
            $this->events->triggerAfter('delete', 'relationship', $rel);
        }
        
        return true;
    }
 
    public function getEntitiesFromCount(array $options = []) {
        $options['selects'][] = new SelectClause('COUNT(' . EntityTable::DEFAULT_JOIN_ALIAS . '.guid) AS total');
        $options['group_by'][] = new GroupByClause(self::DEFAULT_JOIN_ALIAS . '.guid_two');
        $options['order_by'][] = new OrderByClause('total', 'desc');
 
        return Entities::find($options);
    }
 
    public function rowToElggRelationship(\stdClass $row): \ElggRelationship {
        return new \ElggRelationship($row);
    }
}