AccessCollections.php

Go to the documentation of this file.

<?php

namespace Elgg\Database;

use Elgg\Config;
use Elgg\Database;
use Elgg\Database\EntityTable\UserFetchFailureException;
use Elgg\I18n\Translator;
use Elgg\PluginHooksService;
use Elgg\UserCapabilities;
use ElggCache;
use ElggEntity;
use ElggSession;
use ElggUser;

class AccessCollections {

    protected $config;

    protected $db;

    protected $access_cache;

    protected $hooks;

    protected $session;

    protected $entities;

    protected $capabilities;

    protected $translator;

    protected $table;

    protected $membership_table;

    protected $init_complete = false;

    public function __construct(
        Config $config,
        Database $db,
        EntityTable $entities,
        UserCapabilities $capabilities,
        ElggCache $cache,
        PluginHooksService $hooks,
        ElggSession $session,
        Translator $translator) {
        $this->config = $config;
        $this->db = $db;
        $this->entities = $entities;
        $this->capabilities = $capabilities;
        $this->access_cache = $cache;
        $this->hooks = $hooks;
        $this->session = $session;
        $this->translator = $translator;

        $this->table = "{$this->db->prefix}access_collections";
        $this->membership_table = "{$this->db->prefix}access_collection_membership";
    }

    public function markInitComplete() {
        $this->init_complete = true;
    }

    public function getAccessList($user_guid = 0, $flush = false) {
        $access_array = $this->getAccessArray($user_guid, $flush);
        $access_ids = implode(',', $access_array);
        $list = "($access_ids)";

        // for BC, populate the cache
        $hash = $user_guid . 'get_access_list';
        $this->access_cache->add($hash, $list);

        return $list;
    }

    public function getAccessArray($user_guid = 0, $flush = false) {
        $cache = $this->access_cache;

        if ($flush) {
            $cache->clear();
        }

        if ($user_guid == 0) {
            $user_guid = $this->session->getLoggedInUserGuid();
        }

        $user_guid = (int) $user_guid;

        $hash = $user_guid . 'get_access_array';

        if ($cache[$hash]) {
            $access_array = $cache[$hash];
        } else {
            // Public access is always visible
            $access_array = [ACCESS_PUBLIC];

            // The following can only return sensible data for a known user.
            if ($user_guid) {
                $access_array[] = ACCESS_LOGGED_IN;

                // Get ACLs that user owns or is a member of
                $query = "
                    SELECT ac.id
                    FROM {$this->table} ac
                    WHERE ac.owner_guid = :user_guid
                    OR EXISTS (SELECT 1
                               FROM {$this->membership_table}
                               WHERE access_collection_id = ac.id
                               AND user_guid = :user_guid)
                ";

                $collections = $this->db->getData($query, null, [
                    ':user_guid' => $user_guid,
                ]);

                if (!empty($collections)) {
                    foreach ($collections as $collection) {
                        $access_array[] = (int) $collection->id;
                    }
                }

                $ignore_access = $this->capabilities->canBypassPermissionsCheck($user_guid);

                if ($ignore_access === true) {
                    $access_array[] = ACCESS_PRIVATE;
                }
            }

            if ($this->init_complete) {
                $cache[$hash] = $access_array;
            }
        }

        $options = [
            'user_id' => $user_guid,
        ];

        // see the warning in the docs for this function about infinite loop potential
        return $this->hooks->trigger('access:collections:read', 'user', $options, $access_array);
    }

    public function hasAccessToEntity($entity, $user = null) {
        if (!$entity instanceof \ElggEntity) {
            return false;
        }

        if ($entity->access_id == ACCESS_PUBLIC) {
            // Public entities are always accessible
            return true;
        }

        $user_guid = isset($user) ? (int) $user->guid : _elgg_services()->session->getLoggedInUserGuid();

        if ($user_guid && $user_guid == $entity->owner_guid) {
            // Owners have access to their own content
            return true;
        }

        if ($user_guid && $entity->access_id == ACCESS_LOGGED_IN) {
            // Existing users have access to entities with logged in access
            return true;
        }

        // See #7159. Must not allow ignore access to affect query
        $ia = _elgg_services()->session->setIgnoreAccess(false);

        $row = $this->entities->getRow($entity->guid, $user_guid);

        _elgg_services()->session->setIgnoreAccess($ia);

        return !empty($row);
    }

    public function getWriteAccessArray($user_guid = 0, $flush = false, array $input_params = []) {
        $cache = $this->access_cache;

        if ($flush) {
            $cache->clear();
        }

        if ($user_guid == 0) {
            $user_guid = $this->session->getLoggedInUserGuid();
        }

        $user_guid = (int) $user_guid;

        $hash = $user_guid . 'get_write_access_array';

        if ($cache[$hash]) {
            $access_array = $cache[$hash];
        } else {
            $access_array = [
                ACCESS_PRIVATE => $this->getReadableAccessLevel(ACCESS_PRIVATE),
                ACCESS_LOGGED_IN => $this->getReadableAccessLevel(ACCESS_LOGGED_IN),
                ACCESS_PUBLIC => $this->getReadableAccessLevel(ACCESS_PUBLIC)
            ];

            $collections = $this->getEntityCollections(['owner_guid' => $user_guid]);
            if (!empty($collections)) {
                foreach ($collections as $collection) {
                    $access_array[$collection->id] = $collection->getDisplayName();
                }
            }

            if ($this->init_complete) {
                $cache[$hash] = $access_array;
            }
        }

        $options = [
            'user_id' => $user_guid,
            'input_params' => $input_params,
        ];
        
        $access_array = $this->hooks->trigger('access:collections:write', 'user', $options, $access_array);
        
        // move logged in and public to the end of the array
        foreach ([ACCESS_LOGGED_IN, ACCESS_PUBLIC] as $access) {
            if (!isset($access_array[$access])) {
                continue;
            }
        
            $temp = $access_array[$access];
            unset($access_array[$access]);
            $access_array[$access] = $temp;
        }
        
        
        return $access_array;
    }

    public function canEdit($collection_id, $user_guid = null) {
        try {
            $user = $this->entities->getUserForPermissionsCheck($user_guid);
        } catch (UserFetchFailureException $e) {
            return false;
        }

        $collection = $this->get($collection_id);

        if (!$user instanceof \ElggUser || !$collection instanceof \ElggAccessCollection) {
            return false;
        }

        if ($this->capabilities->canBypassPermissionsCheck($user->guid)) {
            return true;
        }

        $write_access = $this->getWriteAccessArray($user->guid, true);
        return array_key_exists($collection_id, $write_access);
    }

    public function create($name, $owner_guid = 0, $subtype = null) {
        $name = trim($name);
        if (empty($name)) {
            return false;
        }

        if (isset($subtype)) {
            $subtype = trim($subtype);
            if (strlen($subtype) > 255) {
                _elgg_services()->logger->error("The subtype length for access collections cannot be greater than 255");
                return false;
            }
        }

        if ($owner_guid == 0) {
            $owner_guid = $this->session->getLoggedInUserGuid();
        }

        $query = "
            INSERT INTO {$this->table}
            SET name = :name,
                subtype = :subtype,
                owner_guid = :owner_guid
        ";

        $params = [
            ':name' => $name,
            ':subtype' => $subtype,
            ':owner_guid' => (int) $owner_guid,
        ];

        $id = $this->db->insertData($query, $params);
        if (!$id) {
            return false;
        }

        $this->access_cache->clear();

        $hook_params = [
            'collection_id' => $id,
            'name' => $name,
            'subtype' => $subtype,
            'owner_guid' => $owner_guid,
        ];

        if (!$this->hooks->trigger('access:collections:addcollection', 'collection', $hook_params, true)) {
            $this->delete($id);
            return false;
        }

        return $id;
    }

    public function rename($collection_id, $name) {

        $query = "
            UPDATE {$this->table}
            SET name = :name
            WHERE id = :id
        ";

        $params = [
            ':name' => $name,
            ':id' => (int) $collection_id,
        ];

        if ($this->db->insertData($query, $params)) {
            $this->access_cache->clear();
            return (int) $collection_id;
        }

        return false;
    }


    public function update($collection_id, array $new_members = []) {
        $acl = $this->get($collection_id);

        if (!$acl instanceof \ElggAccessCollection) {
            return false;
        }

        $to_guid = function($elem) {
            if (empty($elem)) {
                return 0;
            }
            if (is_object($elem)) {
                return (int) $elem->guid;
            }
            return (int) $elem;
        };

        $current_members = [];
        $new_members = array_map($to_guid, $new_members);

        $current_members_batch = $this->getMembers($collection_id, [
            'batch' => true,
            'limit' => 0,
            'callback' => false,
        ]);

        foreach ($current_members_batch as $row) {
            $current_members[] = $to_guid($row);
        }

        $remove_members = array_diff($current_members, $new_members);
        $add_members = array_diff($new_members, $current_members);

        $result = true;

        foreach ($add_members as $guid) {
            $result = $result && $this->addUser($guid, $collection_id);
        }

        foreach ($remove_members as $guid) {
            $result = $result && $this->removeUser($guid, $collection_id);
        }

        $this->access_cache->clear();

        return $result;
    }

    public function delete($collection_id) {
        $collection_id = (int) $collection_id;

        $params = [
            'collection_id' => $collection_id,
        ];

        if (!$this->hooks->trigger('access:collections:deletecollection', 'collection', $params, true)) {
            return false;
        }

        // Deleting membership doesn't affect result of deleting ACL.
        $query = "
            DELETE FROM {$this->membership_table}
            WHERE access_collection_id = :access_collection_id
        ";
        $this->db->deleteData($query, [
            ':access_collection_id' => $collection_id,
        ]);

        $query = "
            DELETE FROM {$this->table}
            WHERE id = :id
        ";
        $result = $this->db->deleteData($query, [
            ':id' => $collection_id,
        ]);

        $this->access_cache->clear();

        return (bool) $result;
    }

    public function rowToElggAccessCollection(\stdClass $row) {
        return new \ElggAccessCollection($row);
    }

    public function get($collection_id) {

        $callback = [$this, 'rowToElggAccessCollection'];

        $query = "
            SELECT * FROM {$this->table}
            WHERE id = :id
        ";

        $result = $this->db->getDataRow($query, $callback, [
            ':id' => (int) $collection_id,
        ]);

        if (empty($result)) {
            return false;
        }

        return $result;
    }

    public function hasUser($user_guid, $collection_id) {
        $options = [
            'guids' => (int) $user_guid,
            'count' => true,
        ];
        return (bool) $this->getMembers($collection_id, $options);
    }

    public function addUser($user_guid, $collection_id) {

        $collection = $this->get($collection_id);

        if (!$collection instanceof \ElggAccessCollection) {
            return false;
        }

        if (!$this->entities->exists($user_guid)) {
            return false;
        }

        $hook_params = [
            'collection_id' => $collection->id,
            'user_guid' => (int) $user_guid
        ];

        $result = $this->hooks->trigger('access:collections:add_user', 'collection', $hook_params, true);
        if ($result == false) {
            return false;
        }

        // if someone tries to insert the same data twice, we do a no-op on duplicate key
        $query = "
            INSERT INTO {$this->membership_table}
                SET access_collection_id = :access_collection_id,
                    user_guid = :user_guid
                ON DUPLICATE KEY UPDATE user_guid = user_guid
        ";

        $result = $this->db->insertData($query, [
            ':access_collection_id' => (int) $collection->id,
            ':user_guid' => (int) $user_guid,
        ]);

        $this->access_cache->clear();

        return $result !== false;
    }

    public function removeUser($user_guid, $collection_id) {

        $params = [
            'collection_id' => (int) $collection_id,
            'user_guid' => (int) $user_guid,
        ];

        if (!$this->hooks->trigger('access:collections:remove_user', 'collection', $params, true)) {
            return false;
        }

        $query = "
            DELETE FROM {$this->membership_table}
            WHERE access_collection_id = :access_collection_id
                AND user_guid = :user_guid
        ";

        $this->access_cache->clear();

        return (bool) $this->db->deleteData($query, [
            ':access_collection_id' => (int) $collection_id,
            ':user_guid' => (int) $user_guid,
        ]);
    }

    public function getEntityCollections($options = []) {

        $callback = [$this, 'rowToElggAccessCollection'];

        $supported_options = ['owner_guid', 'subtype'];

        $wheres = [];
        $params = [];
        foreach ($supported_options as $option) {
            $option_value = elgg_extract($option, $options);
            if (!isset($option_value)) {
                continue;
            }
            $wheres[] = "{$option} = :{$option}";
            $params[":{$option}"] = $option_value;
        }

        $query = "SELECT * FROM {$this->table}";
        if (!empty($wheres)) {
            $query .= ' WHERE ' . implode(' AND ', $wheres);
        }
        $query .= ' ORDER BY name ASC';

        return $this->db->getData($query, $callback, $params);
    }

    public function getMembers($collection_id, array $options = []) {
        $options['wheres'][] = function(QueryBuilder $qb, $table_alias) use ($collection_id) {
            $qb->join($table_alias, 'access_collection_membership', 'acm', $qb->compare('acm.user_guid', '=', "$table_alias.guid"));
            return $qb->compare('acm.access_collection_id', '=', $collection_id, ELGG_VALUE_INTEGER);
        };

        return Entities::find($options);
    }

    public function getCollectionsByMember($member_guid) {

        $callback = [$this, 'rowToElggAccessCollection'];

        $query = "
            SELECT ac.* FROM {$this->table} ac
                JOIN {$this->membership_table} acm
                    ON ac.id = acm.access_collection_id
                WHERE acm.user_guid = :member_guid
                ORDER BY name ASC
        ";

        return $this->db->getData($query, $callback, [
            ':member_guid' => (int) $member_guid,
        ]);
    }

    public function getReadableAccessLevel($entity_access_id) {
        $access = (int) $entity_access_id;

        $translator = $this->translator;

        // Check if entity access id is a defined global constant
        $access_array = [
            ACCESS_PRIVATE => $translator->translate('access:label:private'),
            ACCESS_FRIENDS => $translator->translate('access:label:friends'),
            ACCESS_LOGGED_IN => $translator->translate('access:label:logged_in'),
            ACCESS_PUBLIC => $translator->translate('access:label:public'),
        ];

        if (array_key_exists($access, $access_array)) {
            return $access_array[$access];
        }

        // Entity access id is probably a custom access collection
        // Check if the user has write access to it and can see it's label
        // Admins should always be able to see the readable version
        $collection = $this->get($access);

        if (!$collection instanceof \ElggAccessCollection || !$collection->canEdit()) {
            // return 'Limited' if the collection can not be loaded or it can not be edited
            return $translator->translate('access:limited:label');
        }

        return $collection->getDisplayName();
    }

}