entities.php

Go to the documentation of this file.

<?php
use Elgg\Database\Clauses\OrderByClause;
use Elgg\Database\EntityTable;
use Elgg\Database\QueryBuilder;
use Elgg\Database\Select;

function elgg_get_entity_class(string $type, string $subtype): string {
    return _elgg_services()->entityTable->getEntityClass($type, $subtype);
}

function elgg_set_entity_class(string $type, string $subtype, string $class = ''): void {
    _elgg_services()->entityTable->setEntityClass($type, $subtype, $class);
}

function elgg_get_entity_as_row(int $guid): ?\stdClass {
    return _elgg_services()->entityTable->getRow($guid);
}

function get_entity(int $guid): ?\ElggEntity {
    if ($guid === 1) {
        return _elgg_services()->config->site;
    }
    
    return _elgg_services()->entityTable->get($guid);
}

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

function elgg_get_site_entity(): \ElggSite {
    return _elgg_services()->config->site;
}

function elgg_get_entities(array $options = []) {
    return \Elgg\Database\Entities::find($options);
}

function elgg_count_entities(array $options = []): int {
    $options['count'] = true;
    
    return (int) elgg_get_entities($options);
}

function elgg_list_entities(array $options = [], callable $getter = null, callable $viewer = null): string {
    $getter = $getter ?? 'elgg_get_entities'; // callables only support default NULL value
    $viewer = $viewer ?? 'elgg_view_entity_list'; // callables only support default NULL value
    $offset_key = $options['offset_key'] ?? 'offset';

    $defaults = [
        'offset' => (int) max(get_input($offset_key, 0), 0),
        'limit' => (int) max(get_input('limit', _elgg_services()->config->default_limit), 0),
        'sort_by' => get_input('sort_by', []),
        'full_view' => false,
        'pagination' => true,
        'no_results' => '',
        'preload_owners' => true,
        'preload_containers' => true,
    ];

    $options = array_merge($defaults, $options);
    
    $options['register_rss_link'] = elgg_extract('register_rss_link', $options, elgg_extract('pagination', $options));
    if ($options['register_rss_link']) {
        elgg_register_rss_link();
    }

    $options['count'] = false;
    $entities = call_user_func($getter, $options);
    $options['count'] = is_array($entities) ? count($entities) : 0;
    
    if (!is_array($entities) && $viewer === 'elgg_view_entity_list') {
        elgg_log(elgg_echo('list:error:getter:admin', [$getter, gettype($entities), $viewer]), 'ERROR');
        
        return elgg_echo('list:error:getter:user');
    }
    
    if (!empty($entities) || !empty($options['offset'])) {
        $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_entity_dates(array $options = []): array {
    return \Elgg\Database\Entities::with($options)->getDates();
}

function elgg_search(array $options = []) {
    try {
        return _elgg_services()->search->search($options);
    } catch (\Elgg\Exceptions\DomainException $e) {
        return false;
    }
}

function elgg_get_entity_statistics(array $options = []): array {
    $required = [
        'selects' => [
            'count(*) AS total',
        ],
        'group_by' => [
            function(QueryBuilder $qb, $main_alias) {
                return "{$main_alias}.type";
            },
            function(QueryBuilder $qb, $main_alias) {
                return "{$main_alias}.subtype";
            },
        ],
        'order_by' => [
            new OrderByClause('total', 'desc'),
        ],
        'callback' => function($row) {
            return (object) [
                'type' => $row->type,
                'subtype' => $row->subtype,
                'total' => $row->total,
            ];
        },
        'limit' => false,
    ];
    
    $options = array_merge($options, $required);
    
    $rows = elgg_call(ELGG_IGNORE_ACCESS, function() use ($options) {
        return elgg_get_entities($options);
    });
    
    $entity_stats = [];
    foreach ($rows as $row) {
        $type = $row->type;
        if (!isset($entity_stats[$type]) || !is_array($entity_stats[$type])) {
            $entity_stats[$type] = [];
        }
        
        $entity_stats[$type][$row->subtype] = $row->total;
    }
    
    return $entity_stats;
}

function elgg_entity_has_capability(string $type, string $subtype, string $capability, bool $default = false): bool {
    return _elgg_services()->entity_capabilities->hasCapability($type, $subtype, $capability, $default);
}

function elgg_entity_enable_capability(string $type, string $subtype, string $capability): void {
    _elgg_services()->entity_capabilities->setCapability($type, $subtype, $capability, true);
}

function elgg_entity_disable_capability(string $type, string $subtype, string $capability): void {
    _elgg_services()->entity_capabilities->setCapability($type, $subtype, $capability, false);
}

function elgg_entity_types_with_capability(string $capability): array {
    return _elgg_services()->entity_capabilities->getTypesWithCapability($capability);
}