entities.php

Go to the documentation of this file.

<?php
global $ENTITY_CACHE;
$ENTITY_CACHE = array();

global $ENTITY_CACHE_DISABLED_GUIDS;
$ENTITY_CACHE_DISABLED_GUIDS = array();

function _elgg_disable_caching_for_entity($guid) {
    global $ENTITY_CACHE_DISABLED_GUIDS;

    _elgg_invalidate_cache_for_entity($guid);
    $ENTITY_CACHE_DISABLED_GUIDS[$guid] = true;
}

function _elgg_enable_caching_for_entity($guid) {
    global $ENTITY_CACHE_DISABLED_GUIDS;

    unset($ENTITY_CACHE_DISABLED_GUIDS[$guid]);
}

function _elgg_invalidate_cache_for_entity($guid) {
    global $ENTITY_CACHE;

    $guid = (int)$guid;

    if (isset($ENTITY_CACHE[$guid])) {
        unset($ENTITY_CACHE[$guid]);

        // Purge separate metadata cache. Original idea was to do in entity destructor, but that would
        // have caused a bunch of unnecessary purges at every shutdown. Doing it this way we have no way
        // to know that the expunged entity will be GCed (might be another reference living), but that's
        // OK; the metadata will reload if necessary.
        _elgg_services()->metadataCache->clear($guid);
    }
}

function _elgg_cache_entity(\ElggEntity $entity) {
    global $ENTITY_CACHE, $ENTITY_CACHE_DISABLED_GUIDS;

    // Don't cache non-plugin entities while access control is off, otherwise they could be
    // exposed to users who shouldn't see them when control is re-enabled.
    if (!($entity instanceof \ElggPlugin) && elgg_get_ignore_access()) {
        return;
    }

    $guid = $entity->getGUID();
    if (isset($ENTITY_CACHE_DISABLED_GUIDS[$guid])) {
        return;
    }

    // Don't store too many or we'll have memory problems
    // @todo Pick a less arbitrary limit
    if (count($ENTITY_CACHE) > 256) {
        _elgg_invalidate_cache_for_entity(array_rand($ENTITY_CACHE));
    }

    $ENTITY_CACHE[$guid] = $entity;
}

function _elgg_retrieve_cached_entity($guid) {
    global $ENTITY_CACHE;

    if (isset($ENTITY_CACHE[$guid])) {
        if ($ENTITY_CACHE[$guid]->isFullyLoaded()) {
            return $ENTITY_CACHE[$guid];
        }
    }

    return false;
}

function get_subtype_id($type, $subtype) {
    return _elgg_services()->subtypeTable->getId($type, $subtype);
}

function get_subtype_from_id($subtype_id) {
    return _elgg_services()->subtypeTable->getSubtype($subtype_id);
}

function _elgg_retrieve_cached_subtype($type, $subtype) {
    return _elgg_services()->subtypeTable->retrieveFromCache($type, $subtype);
}

function _elgg_populate_subtype_cache() {
    return _elgg_services()->subtypeTable->populateCache();
}

function get_subtype_class($type, $subtype) {
    return _elgg_services()->subtypeTable->getClass($type, $subtype);
}

function get_subtype_class_from_id($subtype_id) {
    return _elgg_services()->subtypeTable->getClassFromId($subtype_id);
}

function add_subtype($type, $subtype, $class = "") {
    return _elgg_services()->subtypeTable->add($type, $subtype, $class);
}

function remove_subtype($type, $subtype) {
    return _elgg_services()->subtypeTable->remove($type, $subtype);
}

function update_subtype($type, $subtype, $class = '') {
    return _elgg_services()->subtypeTable->update($type, $subtype, $class);
}

function can_write_to_container($user_guid = 0, $container_guid = 0, $type = 'all', $subtype = 'all') {
    $container_guid = (int)$container_guid;
    if (!$container_guid) {
        $container_guid = elgg_get_page_owner_guid();
    }

    $container = get_entity($container_guid);

    $user_guid = (int)$user_guid;
    if ($user_guid == 0) {
        $user = elgg_get_logged_in_user_entity();
        $user_guid = elgg_get_logged_in_user_guid();
    } else {
        $user = get_user($user_guid);
        if (!$user) {
            return false;
        }
    }

    $return = false;
    if ($container) {
        // If the user can edit the container, they can also write to it
        if ($container->canEdit($user_guid)) {
            $return = true;
        }
    }

    // See if anyone else has anything to say
    return elgg_trigger_plugin_hook(
            'container_permissions_check',
            $type,
            array(
                'container' => $container,
                'user' => $user,
                'subtype' => $subtype
            ),
            $return);
}

function get_entity_as_row($guid) {
    return _elgg_services()->entityTable->getRow($guid);
}

function entity_row_to_elggstar($row) {
    return _elgg_services()->entityTable->rowToElggStar($row);
}

function get_entity($guid) {
    return _elgg_services()->entityTable->get($guid);
}

function elgg_entity_exists($guid) {
    return _elgg_services()->entityTable->exists($guid);
}

function elgg_enable_entity($guid, $recursive = true) {
    return _elgg_services()->entityTable->enable($guid, $recursive);
}

function elgg_get_entities(array $options = array()) {
    return _elgg_services()->entityTable->getEntities($options);
}

function _elgg_fetch_entities_from_sql($sql, \ElggBatch $batch = null) {
    return _elgg_services()->entityTable->fetchFromSql($sql, $batch);
}

function _elgg_get_entity_type_subtype_where_sql($table, $types, $subtypes, $pairs) {
    return _elgg_services()->entityTable->getEntityTypeSubtypeWhereSql($table, $types, $subtypes, $pairs);
}

function _elgg_get_guid_based_where_sql($column, $guids) {
    return _elgg_services()->entityTable->getGuidBasedWhereSql($column, $guids);
}

function _elgg_get_entity_time_where_sql($table, $time_created_upper = null,
        $time_created_lower = null, $time_updated_upper = null, $time_updated_lower = null) {
    return _elgg_services()->entityTable->getEntityTimeWhereSql($table,
        $time_created_upper, $time_created_lower, $time_updated_upper, $time_updated_lower);
}

function elgg_list_entities(array $options = array(), $getter = 'elgg_get_entities',
    $viewer = 'elgg_view_entity_list') {

    global $autofeed;
    $autofeed = true;

    $offset_key = isset($options['offset_key']) ? $options['offset_key'] : 'offset';

    $defaults = array(
        'offset' => (int) max(get_input($offset_key, 0), 0),
        'limit' => (int) max(get_input('limit', elgg_get_config('default_limit')), 0),
        'full_view' => false,
        'list_type_toggle' => false,
        'pagination' => true,
        'no_results' => '',
    );

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

    // backward compatibility
    if (isset($options['view_type_toggle'])) {
        elgg_deprecated_notice("Option 'view_type_toggle' deprecated by 'list_type_toggle' in elgg_list* functions", 1.9);
        $options['list_type_toggle'] = $options['view_type_toggle'];
    }

    $options['count'] = true;
    $count = call_user_func($getter, $options);

    if ($count > 0) {
        $options['count'] = false;
        $entities = call_user_func($getter, $options);
    } else {
        $entities = array();
    }

    $options['count'] = $count;

    return call_user_func($viewer, $entities, $options);
}

function elgg_get_entities_from_attributes(array $options = array()) {
    return _elgg_services()->entityTable->getEntitiesFromAttributes($options);
}

function _elgg_get_entity_attribute_where_sql(array $options = array()) {
    return _elgg_services()->entityTable->getEntityAttributeWhereSql($options);
}

function get_entity_dates($type = '', $subtype = '', $container_guid = 0, $site_guid = 0,
        $order_by = 'time_created') {
    return _elgg_services()->entityTable->getDates(
        $type, $subtype, $container_guid, $site_guid, $order_by);
}

function elgg_register_entity_type($type, $subtype = null) {
    global $CONFIG;

    $type = strtolower($type);
    if (!in_array($type, $CONFIG->entity_types)) {
        return false;
    }

    if (!isset($CONFIG->registered_entities)) {
        $CONFIG->registered_entities = array();
    }

    if (!isset($CONFIG->registered_entities[$type])) {
        $CONFIG->registered_entities[$type] = array();
    }

    if ($subtype) {
        $CONFIG->registered_entities[$type][] = $subtype;
    }

    return true;
}

function elgg_unregister_entity_type($type, $subtype = null) {
    global $CONFIG;

    $type = strtolower($type);
    if (!in_array($type, $CONFIG->entity_types)) {
        return false;
    }

    if (!isset($CONFIG->registered_entities)) {
        return false;
    }

    if (!isset($CONFIG->registered_entities[$type])) {
        return false;
    }

    if ($subtype) {
        if (in_array($subtype, $CONFIG->registered_entities[$type])) {
            $key = array_search($subtype, $CONFIG->registered_entities[$type]);
            unset($CONFIG->registered_entities[$type][$key]);
        } else {
            return false;
        }
    } else {
        unset($CONFIG->registered_entities[$type]);
    }

    return true;
}

function get_registered_entity_types($type = null) {
    global $CONFIG;

    if (!isset($CONFIG->registered_entities)) {
        return false;
    }
    if ($type) {
        $type = strtolower($type);
    }
    if (!empty($type) && empty($CONFIG->registered_entities[$type])) {
        return false;
    }

    if (empty($type)) {
        return $CONFIG->registered_entities;
    }

    return $CONFIG->registered_entities[$type];
}

function is_registered_entity_type($type, $subtype = null) {
    global $CONFIG;

    if (!isset($CONFIG->registered_entities)) {
        return false;
    }

    $type = strtolower($type);

    // @todo registering a subtype implicitly registers the type.
    // see #2684
    if (!isset($CONFIG->registered_entities[$type])) {
        return false;
    }

    if ($subtype && !in_array($subtype, $CONFIG->registered_entities[$type])) {
        return false;
    }
    return true;
}

function elgg_list_registered_entities(array $options = array()) {
    global $autofeed;
    $autofeed = true;

    $defaults = array(
        'full_view' => false,
        'allowed_types' => true,
        'list_type_toggle' => false,
        'pagination' => true,
        'offset' => 0,
        'types' => array(),
        'type_subtype_pairs' => array(),
    );

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

    // backward compatibility
    if (isset($options['view_type_toggle'])) {
        elgg_deprecated_notice("Option 'view_type_toggle' deprecated by 'list_type_toggle' in elgg_list* functions", 1.9);
        $options['list_type_toggle'] = $options['view_type_toggle'];
    }

    $types = get_registered_entity_types();

    foreach ($types as $type => $subtype_array) {
        if (in_array($type, $options['allowed_types']) || $options['allowed_types'] === true) {
            // you must explicitly register types to show up in here and in search for objects
            if ($type == 'object') {
                if (is_array($subtype_array) && count($subtype_array)) {
                    $options['type_subtype_pairs'][$type] = $subtype_array;
                }
            } else {
                if (is_array($subtype_array) && count($subtype_array)) {
                    $options['type_subtype_pairs'][$type] = $subtype_array;
                } else {
                    $options['type_subtype_pairs'][$type] = ELGG_ENTITIES_ANY_VALUE;
                }
            }
        }
    }

    if (!empty($options['type_subtype_pairs'])) {
        $count = elgg_get_entities(array_merge(array('count' => true), $options));
        if ($count > 0) {
            $entities = elgg_get_entities($options);
        } else {
            $entities = array();
        }
    } else {
        $count = 0;
        $entities = array();
    }

    $options['count'] = $count;
    return elgg_view_entity_list($entities, $options);
}

function elgg_instanceof($entity, $type = null, $subtype = null, $class = null) {
    $return = ($entity instanceof \ElggEntity);

    if ($type) {
        /* @var \ElggEntity $entity */
        $return = $return && ($entity->getType() == $type);
    }

    if ($subtype) {
        $return = $return && ($entity->getSubtype() == $subtype);
    }

    if ($class) {
        $return = $return && ($entity instanceof $class);
    }

    return $return;
}

function update_entity_last_action($guid, $posted = null) {
    return _elgg_services()->entityTable->updateLastAction($guid, $posted);
}

function _elgg_entities_test($hook, $type, $value) {
    global $CONFIG;
    $value[] = $CONFIG->path . 'engine/tests/ElggEntityTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreAttributeLoaderTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreGetEntitiesTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreGetEntitiesFromAnnotationsTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreGetEntitiesFromMetadataTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreGetEntitiesFromPrivateSettingsTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreGetEntitiesFromRelationshipTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggCoreGetEntitiesFromAttributesTest.php';
    $value[] = $CONFIG->path . 'engine/tests/ElggEntityPreloaderIntegrationTest.php';
    return $value;
}

function _elgg_entities_init() {
    elgg_register_plugin_hook_handler('unit_test', 'system', '_elgg_entities_test');
}

return function(\Elgg\EventsService $events, \Elgg\HooksRegistrationService $hooks) {
    $events->registerHandler('init', 'system', '_elgg_entities_init');
};