entities.php

Go to the documentation of this file.

<?php
use Elgg\Database\EntityTable\UserFetchFailureException;

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 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') {
    elgg_deprecated_notice(__FUNCTION__ . ' is deprecated. Use ElggEntity::canWriteToContainer()', '2.2');
    if (!$container_guid) {
        $container_guid = elgg_get_page_owner_guid();
    }
    $container = get_entity($container_guid);
    if (!$container) {
        return false;
    }

    return $container->canWriteToContainer($user_guid, $type, $subtype);
}

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_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') {

    elgg_register_rss_link();

    $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'] = false;
    $entities = call_user_func($getter, $options);
    $options['count'] = is_array($entities) ? count($entities) : 0;
    
    if (!empty($entities)) {
        $count_needed = true;
        if (!$options['pagination']) {
            $count_needed = false;
        } elseif (!$options['offset'] && !$options['limit']) {
            $count_needed = false;
        } elseif (($options['count'] < (int) $options['limit']) && !$options['offset']) {
            $count_needed = false;
        }
        
        if ($count_needed) {
            $options['count'] = true;
        
            $options['count'] = (int) call_user_func($getter, $options);
        }
    }
    
    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()) {
    elgg_register_rss_link();

    $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) {
    elgg_deprecated_notice(__FUNCTION__ . ' has been deprecated. Refrain from updating last action timestamp manually', '2.3');

    $result = false;
    $ia = elgg_set_ignore_access(true);
    $entity = get_entity($guid);
    if ($entity) {
        $result = $entity->updateLastAction($posted);
    }
    elgg_set_ignore_access($ia);
    return $result;
}

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');
};