ElggSite.php

Go to the documentation of this file.

<?php
class ElggSite extends \ElggEntity {
 
    protected function initializeAttributes() {
        parent::initializeAttributes();
 
        $this->attributes['type'] = "site";
        $this->attributes += self::getExternalAttributes();
        $this->tables_split = 2;
    }
 
    final public static function getExternalAttributes() {
        return [
            'name' => null,
            'description' => null,
            'url' => null,
        ];
    }
 
    public function __construct($row = null) {
        $this->initializeAttributes();
 
        // compatibility for 1.7 api.
        $this->initialise_attributes(false);
 
        if (!empty($row)) {
            // Is $row is a DB entity table 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 ($row instanceof \ElggSite) {
                // $row is an \ElggSite so this is a copy constructor
                elgg_deprecated_notice('This type of usage of the \ElggSite constructor was deprecated. Please use the clone method.', 1.7);
                foreach ($row->attributes as $key => $value) {
                    $this->attributes[$key] = $value;
                }
            } else if (strpos($row, "http") !== false) {
                // url so retrieve by url
                elgg_deprecated_notice("Passing URL to constructor is deprecated. Use get_site_by_url()", 1.9);
                $row = get_site_by_url($row);
                foreach ($row->attributes as $key => $value) {
                    $this->attributes[$key] = $value;
                }
            } else if (is_numeric($row)) {
                // $row is a GUID so load
                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.");
            }
        }
    }
 
    protected function load($guid) {
        $attr_loader = new \Elgg\AttributeLoader(get_class(), 'site', $this->attributes);
        $attr_loader->requires_access_control = !($this instanceof \ElggPlugin);
        $attr_loader->secondary_loader = 'get_site_entity_as_row';
 
        $attrs = $attr_loader->getRequiredAttributes($guid);
        if (!$attrs) {
            return false;
        }
 
        $this->attributes = $attrs;
        $this->tables_loaded = 2;
        $this->loadAdditionalSelectValues($attr_loader->getAdditionalSelectValues());
        _elgg_cache_entity($this);
 
        return true;
    }
 
    protected function create() {
        global $CONFIG;
 
        $guid = parent::create();
 
        $name = sanitize_string($this->attributes['name']);
        $description = sanitize_string($this->attributes['description']);
        $url = sanitize_string($this->attributes['url']);
 
        $query = "INSERT into {$CONFIG->dbprefix}sites_entity
            (guid, name, description, url) values ($guid, '$name', '$description', '$url')";
 
        $result = $this->getDatabase()->insertData($query);
        if ($result === false) {
            // TODO(evan): Throw an exception here?
            return false;
        }
 
        // make sure the site guid is set to self if not already set
        if (!$this->site_guid) {
            $this->site_guid = $guid;
            $this->getDatabase()->updateData("UPDATE {$CONFIG->dbprefix}entities
                SET site_guid = $guid WHERE guid = $guid");
        }
 
        return $guid;
    }
 
    protected function update() {
        global $CONFIG;
 
        if (!parent::update()) {
            return false;
        }
 
        $guid = (int)$this->guid;
        $name = sanitize_string($this->name);
        $description = sanitize_string($this->description);
        $url = sanitize_string($this->url);
 
        $query = "UPDATE {$CONFIG->dbprefix}sites_entity
            SET name='$name', description='$description', url='$url' WHERE guid=$guid";
 
        return $this->getDatabase()->updateData($query) !== false;
    }
 
    public function delete() {
        global $CONFIG;
        if ($CONFIG->site->getGUID() == $this->guid) {
            throw new \SecurityException('You cannot delete the current site');
        }
 
        return parent::delete();
    }
 
    public function disable($reason = "", $recursive = true) {
        global $CONFIG;
 
        if ($CONFIG->site->getGUID() == $this->guid) {
            throw new \SecurityException('You cannot disable the current site');
        }
 
        return parent::disable($reason, $recursive);
    }
    
    public function getURL() {
        return $this->url;
    }
 
    public function getDisplayName() {
        return $this->name;
    }
 
    public function setDisplayName($displayName) {
        $this->name = $displayName;
    }
 
    public function getMembers($options = array(), $offset = 0) {
        elgg_deprecated_notice('\ElggSite::getMembers() is deprecated. Use \ElggSite::getEntities()', 1.9);
        if (!is_array($options)) {
            elgg_deprecated_notice("\ElggSite::getMembers uses different arguments!", 1.8);
            $options = array(
                'limit' => $options,
                'offset' => $offset,
            );
        }
 
        $defaults = array(
            'site_guids' => ELGG_ENTITIES_ANY_VALUE,
            'relationship' => 'member_of_site',
            'relationship_guid' => $this->getGUID(),
            'inverse_relationship' => true,
            'type' => 'user',
        );
 
        $options = array_merge($defaults, $options);
 
        return elgg_get_entities_from_relationship($options);
    }
 
    public function listMembers($options = array()) {
        elgg_deprecated_notice('\ElggSite::listMembers() is deprecated. Use elgg_list_entities_from_relationship()', 1.9);
        $defaults = array(
            'site_guids' => ELGG_ENTITIES_ANY_VALUE,
            'relationship' => 'member_of_site',
            'relationship_guid' => $this->getGUID(),
            'inverse_relationship' => true,
            'type' => 'user',
        );
 
        $options = array_merge($defaults, $options);
 
        return elgg_list_entities_from_relationship($options);
    }
 
    public function addEntity(\ElggEntity $entity) {
        if (elgg_instanceof($entity, 'site')) {
            return false;
        }
        return add_entity_relationship($entity->guid, "member_of_site", $this->guid);
    }
 
    public function removeEntity($entity) {
        if (elgg_instanceof($entity, 'site')) {
            return false;
        }
        return remove_entity_relationship($entity->guid, "member_of_site", $this->guid);
    }
 
    public function getEntities(array $options = array()) {
        $options['relationship'] = 'member_of_site';
        $options['relationship_guid'] = $this->guid;
        $options['inverse_relationship'] = true;
        if (!isset($options['site_guid']) || !isset($options['site_guids'])) {
            $options['site_guids'] = ELGG_ENTITIES_ANY_VALUE;
        }
 
        return elgg_get_entities_from_relationship($options);
    }
 
    public function addUser($user_guid) {
        elgg_deprecated_notice('\ElggSite::addUser() is deprecated. Use \ElggEntity::addEntity()', 1.9);
        return add_site_user($this->getGUID(), $user_guid);
    }
 
    public function removeUser($user_guid) {
        elgg_deprecated_notice('\ElggSite::removeUser() is deprecated. Use \ElggEntity::removeEntity()', 1.9);
        return remove_site_user($this->getGUID(), $user_guid);
    }
 
    public function getObjects($subtype = "", $limit = 10, $offset = 0) {
        elgg_deprecated_notice('\ElggSite::getObjects() is deprecated. Use \ElggSite::getEntities()', 1.9);
        return get_site_objects($this->getGUID(), $subtype, $limit, $offset);
    }
 
    public function addObject($object_guid) {
        elgg_deprecated_notice('\ElggSite::addObject() is deprecated. Use \ElggEntity::addEntity()', 1.9);
        return add_site_object($this->getGUID(), $object_guid);
    }
 
    public function removeObject($object_guid) {
        elgg_deprecated_notice('\ElggSite::removeObject() is deprecated. Use \ElggEntity::removeEntity()', 1.9);
        return remove_site_object($this->getGUID(), $object_guid);
    }
 
    public function getCollections($subtype = "", $limit = 10, $offset = 0) {
        elgg_deprecated_notice("ElggSite::getCollections() is deprecated", 1.8);
        get_site_collections($this->getGUID(), $subtype, $limit, $offset);
    }
 
    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',
            'url',
        ));
    }
 
    public function getDomain() {
        $breakdown = parse_url($this->url);
        return $breakdown['host'];
    }
 
    public function checkWalledGarden() {
        global $CONFIG;
 
        // command line calls should not invoke the walled garden check
        if (PHP_SAPI === 'cli') {
            return;
        }
 
        if ($CONFIG->walled_garden) {
            if ($CONFIG->default_access == ACCESS_PUBLIC) {
                $CONFIG->default_access = ACCESS_LOGGED_IN;
            }
            _elgg_services()->hooks->registerHandler(
                    'access:collections:write',
                    'all',
                    '_elgg_walled_garden_remove_public_access',
                    9999);
 
            if (!_elgg_services()->session->isLoggedIn()) {
                // override the front page
                elgg_register_page_handler('', '_elgg_walled_garden_index');
 
                if (!$this->isPublicPage()) {
                    if (!elgg_is_xhr()) {
                        _elgg_services()->session->set('last_forward_from', current_page_url());
                    }
                    register_error(_elgg_services()->translator->translate('loggedinrequired'));
                    forward('', 'walled_garden');
                }
            }
        }
    }
 
    public function isPublicPage($url = '') {
        global $CONFIG;
 
        if (empty($url)) {
            $url = current_page_url();
 
            // do not check against URL queries
            if ($pos = strpos($url, '?')) {
                $url = substr($url, 0, $pos);
            }
        }
 
        // always allow index page
        if ($url == _elgg_services()->config->getSiteUrl($this->guid)) {
            return true;
        }
 
        // default public pages
        $defaults = array(
            'walled_garden/.*',
            'action/.*',
            'login',
            'register',
            'forgotpassword',
            'changepassword',
            'refresh_token',
            'ajax/view/js/languages',
            'upgrade\.php',
            'css/.*',
            'js/.*',
            'cache/[0-9]+/\w+/js|css/.*',
            'cron/.*',
            'services/.*',
        );
 
        // include a hook for plugin authors to include public pages
        $plugins = _elgg_services()->hooks->trigger('public_pages', 'walled_garden', null, array());
 
        // allow public pages
        foreach (array_merge($defaults, $plugins) as $public) {
            $pattern = "`^{$CONFIG->url}$public/*$`i";
            if (preg_match($pattern, $url)) {
                return true;
            }
        }
 
        // non-public page
        return false;
    }
}