RelationshipsTable.php

Go to the documentation of this file.

<?php
namespace Elgg\Database;

use Elgg\Database;
use Elgg\EventsService;
use Doctrine\DBAL\Exception\UniqueConstraintViolationException;

class RelationshipsTable {

    use \Elgg\TimeUsing;
    
    protected $db;

    protected $entities;

    protected $metadata;

    protected $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($id) {
        $row = $this->getRow($id);
        if (!$row) {
            return false;
        }

        return new \ElggRelationship($row);
    }

    public function getRow($id) {
        $sql = "SELECT * FROM {$this->db->prefix}entity_relationships WHERE id = :id";
        $params = [
            ':id' => (int) $id,
        ];
        return $this->db->getDataRow($sql, null, $params);
    }

    public function delete($id, $call_event = true) {
        $id = (int)$id;

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

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

        $sql = "DELETE FROM {$this->db->prefix}entity_relationships WHERE id = :id";
        $params = [
            ':id' => $id,
        ];
        return $this->db->deleteData($sql, $params);
    }

    public function add($guid_one, $relationship, $guid_two, $return_id = false) {
        if (strlen($relationship) > \ElggRelationship::RELATIONSHIP_LIMIT) {
            $msg = "relationship name cannot be longer than " . \ElggRelationship::RELATIONSHIP_LIMIT;
            throw new \InvalidArgumentException($msg);
        }

        // 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;
        }
        
        $sql = "
            INSERT INTO {$this->db->prefix}entity_relationships
                   (guid_one, relationship, guid_two, time_created)
            VALUES (:guid1, :relationship, :guid2, :time)
        ";
        $params = [
            ':guid1' => (int)$guid_one,
            ':guid2' => (int)$guid_two,
            ':relationship' => $relationship,
            ':time' => $this->getCurrentTime()->getTimestamp(),
        ];

        try {
            $id = $this->db->insertData($sql, $params);
            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($guid_one, $relationship, $guid_two) {
        $query = "
            SELECT * FROM {$this->db->prefix}entity_relationships
            WHERE guid_one = :guid1
              AND relationship = :relationship
              AND guid_two = :guid2
            LIMIT 1
        ";
        $params = [
            ':guid1' => (int)$guid_one,
            ':guid2' => (int)$guid_two,
            ':relationship' => $relationship,
        ];
        $row = $this->rowToElggRelationship($this->db->getDataRow($query, null, $params));
        if ($row) {
            return $row;
        }

        return false;
    }

    public function remove($guid_one, $relationship, $guid_two) {
        $obj = $this->check($guid_one, $relationship, $guid_two);
        if (!$obj) {
            return false;
        }

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

    public function removeAll($guid, $relationship = "", $inverse_relationship = false, $type = '') {
        $guid = (int) $guid;
        $params = [];

        if (!empty($relationship)) {
            $where = "AND er.relationship = :relationship";
            $params[':relationship'] = $relationship;
        } else {
            $where = "";
        }

        if (!empty($type)) {
            if (!$inverse_relationship) {
                $join = "JOIN {$this->db->prefix}entities e ON e.guid = er.guid_two";
            } else {
                $join = "JOIN {$this->db->prefix}entities e ON e.guid = er.guid_one";
                $where .= " AND ";
            }
            $where .= " AND e.type = :type";
            $params[':type'] = $type;
        } else {
            $join = "";
        }

        $guid_col = $inverse_relationship ? "guid_two" : "guid_one";

        $this->db->deleteData("
            DELETE er FROM {$this->db->prefix}entity_relationships AS er
            $join
            WHERE $guid_col = $guid
            $where
        ", $params);

        return true;
    }

    public function getAll($guid, $inverse_relationship = false) {
        $params[':guid'] = (int)$guid;

        $where = ($inverse_relationship ? "guid_two = :guid" : "guid_one = :guid");

        $query = "SELECT * from {$this->db->prefix}entity_relationships WHERE {$where}";

        return $this->db->getData($query, [$this, 'rowToElggRelationship'], $params);
    }

    public function getEntities($options) {
        $defaults = array(
            'relationship' => null,
            'relationship_guid' => null,
            'inverse_relationship' => false,
            'relationship_join_on' => 'guid',

            'relationship_created_time_lower' => ELGG_ENTITIES_ANY_VALUE,
            'relationship_created_time_upper' => ELGG_ENTITIES_ANY_VALUE,
        );

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

        $join_column = "e.{$options['relationship_join_on']}";

        $clauses = $this->getEntityRelationshipWhereSql($join_column, $options['relationship'],
            $options['relationship_guid'], $options['inverse_relationship']);

        if ($clauses) {
            // merge wheres to pass to get_entities()
            if (isset($options['wheres']) && !is_array($options['wheres'])) {
                $options['wheres'] = array($options['wheres']);
            } elseif (!isset($options['wheres'])) {
                $options['wheres'] = array();
            }

            $options['wheres'] = array_merge($options['wheres'], $clauses['wheres']);

            // limit based on time created
            $time_wheres = $this->entities->getEntityTimeWhereSql('r',
                    $options['relationship_created_time_upper'],
                    $options['relationship_created_time_lower']);
            if ($time_wheres) {
                $options['wheres'] = array_merge($options['wheres'], array($time_wheres));
            }
            // merge joins to pass to get_entities()
            if (isset($options['joins']) && !is_array($options['joins'])) {
                $options['joins'] = array($options['joins']);
            } elseif (!isset($options['joins'])) {
                $options['joins'] = array();
            }

            $options['joins'] = array_merge($options['joins'], $clauses['joins']);

            if (isset($options['selects']) && !is_array($options['selects'])) {
                $options['selects'] = array($options['selects']);
            } elseif (!isset($options['selects'])) {
                $options['selects'] = array();
            }

            $select = array('r.id');

            $options['selects'] = array_merge($options['selects'], $select);

            if (!isset($options['group_by'])) {
                $options['group_by'] = $clauses['group_by'];
            }
        }

        return $this->metadata->getEntities($options);
    }

    public function getEntityRelationshipWhereSql($column, $relationship = null,
            $relationship_guid = null, $inverse_relationship = false) {

        if ($relationship == null && $relationship_guid == null) {
            return '';
        }

        $wheres = array();
        $joins = array();
        $group_by = '';

        if ($inverse_relationship) {
            $joins[] = "JOIN {$this->db->prefix}entity_relationships r on r.guid_one = $column";
        } else {
            $joins[] = "JOIN {$this->db->prefix}entity_relationships r on r.guid_two = $column";
        }

        if ($relationship) {
            $wheres[] = "r.relationship = '" . $this->db->sanitizeString($relationship) . "'";
        }

        if ($relationship_guid) {
            if ($inverse_relationship) {
                $wheres[] = "r.guid_two = '$relationship_guid'";
            } else {
                $wheres[] = "r.guid_one = '$relationship_guid'";
            }
        } else {
            // See #5775. Queries that do not include a relationship_guid must be grouped by entity table alias,
            // otherwise the result set is not unique
            $group_by = $column;
        }

        if ($where_str = implode(' AND ', $wheres)) {

            return array('wheres' => array("($where_str)"), 'joins' => $joins, 'group_by' => $group_by);
        }

        return '';
    }

    public function getEntitiesFromCount(array $options = array()) {
        $options['selects'][] = "COUNT(e.guid) as total";
        $options['group_by'] = 'r.guid_two';
        $options['order_by'] = 'total desc';
        return $this->getEntities($options);
    }

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

        return false;
    }
}