ElggGroup.php

Go to the documentation of this file.

<?php
 
class ElggGroup extends \ElggEntity
    implements Friendable {
 
    const CONTENT_ACCESS_MODE_UNRESTRICTED = 'unrestricted';
    const CONTENT_ACCESS_MODE_MEMBERS_ONLY = 'members_only';
 
    protected function initializeAttributes() {
        parent::initializeAttributes();
 
        $this->attributes['type'] = "group";
        $this->attributes += self::getExternalAttributes();
    }
 
    final public static function getExternalAttributes() {
        return [
            'name' => null,
            'description' => null,
        ];
    }
 
    public function __construct($row = null) {
        $this->initializeAttributes();
 
        if (!empty($row)) {
            // Is $guid is a entity table DB row
            if ($row instanceof \stdClass) {
                // Load the rest
                if (!$this->load($row)) {
                    $msg = "Failed to load new " . get_class() . " for GUID:" . $row->guid;
                    throw new \IOException($msg);
                }
            } else if (is_numeric($row)) {
                // $row is a GUID so load entity
                elgg_deprecated_notice('Passing a GUID to constructor is deprecated. Use get_entity()', 1.9);
                if (!$this->load($row)) {
                    throw new \IOException("Failed to load new " . get_class() . " from GUID:" . $row);
                }
            } else {
                throw new \InvalidParameterException("Unrecognized value passed to constuctor.");
            }
        }
    }
 
    public function getDisplayName() {
        return $this->name;
    }
    
    public function setDisplayName($displayName) {
        $this->name = $displayName;
    }
 
    public function addObjectToGroup(\ElggObject $object) {
        $object->container_guid = $this->guid;
        return $object->save();
    }
 
    public function removeObjectFromGroup($object) {
        if (is_numeric($object)) {
            elgg_deprecated_notice('\ElggGroup::removeObjectFromGroup() takes an \ElggObject not a guid.', 1.9);
            $object = get_entity($object);
            if (!elgg_instanceof($object, 'object')) {
                return false;
            }
        }
 
        $object->container_guid = $object->owner_guid;
        return $object->save();
    }
 
    public function __get($name) {
        if ($name == 'username') {
            return 'group:' . $this->getGUID();
        }
        return parent::__get($name);
    }
 
    public function get($name) {
        elgg_deprecated_notice("Use -> instead of get()", 1.9);
        return $this->__get($name);
    }
 
    public function addFriend($friend_guid) {
        elgg_deprecated_notice("\ElggGroup::addFriend() is deprecated. Use \ElggGroup::join()", 1.9);
        $user = get_user($friend_guid);
        return $user ? $this->join($user) : false;
    }
 
    public function removeFriend($friend_guid) {
        elgg_deprecated_notice("\ElggGroup::removeFriend() is deprecated. Use \ElggGroup::leave()", 1.9);
        $user = get_user($friend_guid);
        return $user ? $this->leave($user) : false;
    }
 
    public function isFriend() {
        elgg_deprecated_notice("\ElggGroup::isFriend() is deprecated. Use \ElggGroup::isMember()", 1.9);
        return $this->isMember();
    }
 
    public function isFriendsWith($user_guid) {
        elgg_deprecated_notice("\ElggGroup::isFriendsWith() is deprecated. Use \ElggGroup::isMember()", 1.9);
        $user = get_user($user_guid);
        return $user ? $this->isMember($user) : false;
    }
 
    public function isFriendOf($user_guid) {
        elgg_deprecated_notice("\ElggGroup::isFriendOf() is deprecated. Use \ElggGroup::isMember()", 1.9);
        $user = get_user($user_guid);
        return $user ? $this->isMember($user) : false;
    }
 
    public function getFriends($subtype = "", $limit = 10, $offset = 0) {
        elgg_deprecated_notice("\ElggGroup::getFriends() is deprecated. Use \ElggGroup::getMembers()", 1.9);
        $options = [
            'limit' => $limit,
            'offset' => $offset,
        ];
        if ($subtype) {
            $options['subtype'] = $subtype;
        }
        return $this->getMembers($options);
    }
 
    public function getFriendsOf($subtype = "", $limit = 10, $offset = 0) {
        elgg_deprecated_notice("\ElggGroup::getFriendsOf() is deprecated. Use \ElggGroup::getMembers()", 1.9);
        return get_group_members($this->getGUID(), $limit, $offset);
    }
 
    public function getObjects($subtype = "", $limit = 10, $offset = 0) {
        elgg_deprecated_notice("\ElggGroup::getObjects() is deprecated. Use elgg_get_entities()", 1.9);
        $options = [
            'type' => 'object',
            'container_guid' => $this->guid,
            'limit' => $limit,
            'offset' => $offset,
        ];
        if ($subtype) {
            $options['subtype'] = $subtype;
        }
        return elgg_get_entities($options);
    }
 
    public function getFriendsObjects($subtype = "", $limit = 10, $offset = 0) {
        elgg_deprecated_notice("\ElggGroup::getFriendsObjects() is deprecated. Use elgg_get_entities()", 1.9);
        $options = [
            'type' => 'object',
            'limit' => $limit,
            'offset' => $offset,
            'relationship' => 'member',
            'inverse_relationship' => true,
            'relationship_guid' => $this->guid,
            'relationship_join_on' => 'owner_guid',
        ];
        if ($subtype) {
            $options['subtype'] = $subtype;
        }
        return elgg_get_entities_from_relationship($options);
    }
 
    public function countObjects($subtype = "") {
        elgg_deprecated_notice("\ElggGroup::countObjects() is deprecated. Use elgg_get_entities()", 1.9);
        $options = [
            'count' => true,
            'type' => 'object',
            'container_guid' => $this->guid,
        ];
        if ($subtype) {
            $options['subtype'] = $subtype;
        }
        return elgg_get_entities($options);
    }
 
    public function getMembers($options = array(), $offset = 0, $count = false) {
        if (!is_array($options)) {
            elgg_deprecated_notice('\ElggGroup::getMembers() takes an options array.', 1.9);
            $options = array(
                'relationship' => 'member',
                'relationship_guid' => $this->getGUID(),
                'inverse_relationship' => true,
                'type' => 'user',
                'limit' => $options,
                'offset' => $offset,
                'count' => $count,
            );
        } else {
            $options['relationship'] = 'member';
            $options['relationship_guid'] = $this->getGUID();
            $options['inverse_relationship'] = true;
            $options['type'] = 'user';
        }
 
        return elgg_get_entities_from_relationship($options);
    }
 
    public function isPublicMembership() {
        return ($this->membership == ACCESS_PUBLIC);
    }
 
    public function getContentAccessMode() {
        $mode = $this->content_access_mode;
 
        if (!is_string($mode)) {
            // fallback to 1.8 default behavior
            if ($this->isPublicMembership()) {
                $mode = self::CONTENT_ACCESS_MODE_UNRESTRICTED;
            } else {
                $mode = self::CONTENT_ACCESS_MODE_MEMBERS_ONLY;
            }
            $this->content_access_mode = $mode;
        }
 
        // only support two modes for now
        if ($mode === self::CONTENT_ACCESS_MODE_MEMBERS_ONLY) {
            return $mode;
        }
        return self::CONTENT_ACCESS_MODE_UNRESTRICTED;
    }
 
    public function setContentAccessMode($mode) {
        if (!$mode && $this->content_access_mode) {
            return;
        }
 
        // only support two modes for now
        if ($mode !== self::CONTENT_ACCESS_MODE_MEMBERS_ONLY) {
            $mode = self::CONTENT_ACCESS_MODE_UNRESTRICTED;
        }
 
        $this->content_access_mode = $mode;
    }
 
    public function isMember(\ElggUser $user = null) {
        if ($user == null) {
            $user = _elgg_services()->session->getLoggedInUser();
        }
        if (!$user) {
            return false;
        }
 
        $result = (bool)check_entity_relationship($user->guid, 'member', $this->guid);
 
        $params = array(
            'user' => $user,
            'group' => $this,
        );
        return _elgg_services()->hooks->trigger('is_member', 'group', $params, $result);
    }
 
    public function join(\ElggUser $user) {
        $result = add_entity_relationship($user->guid, 'member', $this->guid);
    
        if ($result) {
            $params = array('group' => $this, 'user' => $user);
            _elgg_services()->events->trigger('join', 'group', $params);
        }
    
        return $result;
    }
 
    public function leave(\ElggUser $user) {
        // event needs to be triggered while user is still member of group to have access to group acl
        $params = array('group' => $this, 'user' => $user);
        _elgg_services()->events->trigger('leave', 'group', $params);
 
        return remove_entity_relationship($user->guid, 'member', $this->guid);
    }
 
    protected function load($guid) {
        $attr_loader = new \Elgg\AttributeLoader(get_class(), 'group', $this->attributes);
        $attr_loader->requires_access_control = !($this instanceof \ElggPlugin);
        $attr_loader->secondary_loader = 'get_group_entity_as_row';
 
        $attrs = $attr_loader->getRequiredAttributes($guid);
        if (!$attrs) {
            return false;
        }
 
        $this->attributes = $attrs;
        $this->loadAdditionalSelectValues($attr_loader->getAdditionalSelectValues());
        _elgg_services()->entityCache->set($this);
 
        return true;
    }
 
    protected function update() {
        global $CONFIG;
        
        if (!parent::update()) {
            return false;
        }
        
        $guid = (int)$this->guid;
        $name = sanitize_string($this->name);
        $description = sanitize_string($this->description);
        
        $query = "UPDATE {$CONFIG->dbprefix}groups_entity set"
            . " name='$name', description='$description' where guid=$guid";
 
        return $this->getDatabase()->updateData($query) !== false;
    }
    
    protected function create() {
        global $CONFIG;
        
        $guid = parent::create();
        if (!$guid) {
            // @todo this probably means permission to create entity was denied
            // Is returning false the correct thing to do
            return false;
        }
        
        $name = sanitize_string($this->name);
        $description = sanitize_string($this->description);
 
        $query = "INSERT into {$CONFIG->dbprefix}groups_entity"
            . " (guid, name, description) values ($guid, '$name', '$description')";
 
        $result = $this->getDatabase()->insertData($query);
        if ($result === false) {
            // TODO(evan): Throw an exception here?
            return false;
        }
 
        return $guid;
    }
 
    protected function prepareObject($object) {
        $object = parent::prepareObject($object);
        $object->name = $this->getDisplayName();
        $object->description = $this->description;
        unset($object->read_access);
        return $object;
    }
 
 
    // EXPORTABLE INTERFACE ////////////////////////////////////////////////////////////
 
    public function getExportableValues() {
        return array_merge(parent::getExportableValues(), array(
            'name',
            'description',
        ));
    }
 
    public function canComment($user_guid = 0, $default = null) {
        $result = parent::canComment($user_guid, $default);
        if ($result !== null) {
            return $result;
        }
        return false;
    }
}