river.php

Go to the documentation of this file.

<?php
use Elgg\Integration\ElggCoreRiverAPITest;

function elgg_create_river_item(array $options = []) {

    $view = elgg_extract('view', $options, '');
    // use default viewtype for when called from web services api
    if (!empty($view) && !elgg_view_exists($view, 'default')) {
        return false;
    }

    $action_type = elgg_extract('action_type', $options);
    if (empty($action_type)) {
        return false;
    }

    $subject_guid = elgg_extract('subject_guid', $options, elgg_get_logged_in_user_guid());
    if (!(get_entity($subject_guid) instanceof ElggEntity)) {
        return false;
    }

    $object_guid = elgg_extract('object_guid', $options, 0);
    if (!(get_entity($object_guid) instanceof ElggEntity)) {
        return false;
    }

    $target_guid = elgg_extract('target_guid', $options, 0);
    if ($target_guid) {
        // target_guid is not a required parameter so check
        // it only if it is included in the parameters
        if (!(get_entity($target_guid) instanceof ElggEntity)) {
            return false;
        }
    }

    $posted = elgg_extract('posted', $options, time());

    $annotation_id = elgg_extract('annotation_id', $options, 0);
    if ($annotation_id) {
        if (!elgg_get_annotation_from_id($annotation_id)) {
            return false;
        }
    }

    $return_item = elgg_extract('return_item', $options, false);

    $values = [
        'action_type' => $action_type,
        'view' => $view,
        'subject_guid' => $subject_guid,
        'object_guid' => $object_guid,
        'target_guid' => $target_guid,
        'annotation_id' => $annotation_id,
        'posted' => $posted,
    ];
    $col_types = [
        'action_type' => ELGG_VALUE_STRING,
        'view' => ELGG_VALUE_STRING,
        'subject_guid' => ELGG_VALUE_INTEGER,
        'object_guid' => ELGG_VALUE_INTEGER,
        'target_guid' => ELGG_VALUE_INTEGER,
        'annotation_id' => ELGG_VALUE_INTEGER,
        'posted' => ELGG_VALUE_INTEGER,
    ];

    // return false to stop insert
    $values = elgg_trigger_plugin_hook('creating', 'river', null, $values);
    if ($values == false) {
        // inserting did not fail - it was just prevented
        return true;
    }

    $qb = \Elgg\Database\Insert::intoTable('river');
    $query_params = [];
    foreach ($values as $name => $value) {
        $query_params[$name] = $qb->param($value, $col_types[$name]);
    }
    $qb->values($query_params);

    $id = _elgg_services()->db->insertData($qb);
    if (!$id) {
        return false;
    }

    if (!$return_item) {
        return $id;
    }

    $ia = elgg_set_ignore_access(true);
    $item = elgg_get_river_item_from_id($id);
    elgg_set_ignore_access($ia);

    if (!$item) {
        return false;
    }

    elgg_trigger_event('created', 'river', $item);

    return $item;
}

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

function elgg_get_river_item_from_id($id) {
    $items = elgg_get_river([
        'id' => $id,
    ]);

    return $items ? $items[0] : false;
}

function elgg_delete_river(array $options = []) {

    if (!_elgg_is_valid_options_for_batch_operation($options, 'river')) {
        // requirements not met
        return false;
    }

    return elgg_call(ELGG_IGNORE_ACCESS, function() use ($options) {
        $options['batch'] = true;
        $options['batch_size'] = 25;
        $options['batch_inc_offset'] = false;
    
        $river = elgg_get_river($options);
        $count = $river->count();
    
        if (!$count) {
            return;
        }
    
        $success = 0;
        foreach ($river as $river_item) {
            if ($river_item->delete()) {
                $success++;
            }
        }
    
        return $success == $count;
    });
}

function elgg_list_river(array $options = []) {
    $defaults = [
        'offset'     => (int) max(get_input('offset', 0), 0),
        'limit'      => (int) max(get_input('limit', max(20, _elgg_config()->default_limit)), 0),
        'pagination' => true,
        'list_class' => 'elgg-list-river',
    ];

    $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();
    }
    
    if (!$options["limit"] && !$options["offset"]) {
        // no need for pagination if listing is unlimited
        $options["pagination"] = false;
    }
    
    $options['count'] = false;
    $items = elgg_get_river($options);
    $options['count'] = is_array($items) ? count($items) : 0;
    
    if (!empty($items)) {
        $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) elgg_get_river($options);
        }
    }
    
    $options['items'] = $items;

    return elgg_view('page/components/list', $options);
}

function _elgg_river_test($hook, $type, $value) {
    $value[] = ElggCoreRiverAPITest::class;
    return $value;
}

function _elgg_river_update_object_last_action($event, $type, $item) {
    if (!$item instanceof \ElggRiverItem) {
        return;
    }
    
    $object = $item->getObjectEntity();
    if (!$object) {
        return;
    }
    
    $object->updateLastAction($item->getTimePosted());
}

function _elgg_river_disable($event, $type, $entity) {

    if (!$entity instanceof ElggEntity) {
        return;
    }

    $dbprefix = _elgg_config()->dbprefix;
    $query = <<<QUERY
    UPDATE {$dbprefix}river AS rv
    SET rv.enabled = 'no'
    WHERE (rv.subject_guid = {$entity->guid} OR rv.object_guid = {$entity->guid} OR rv.target_guid = {$entity->guid});
QUERY;

    elgg()->db->updateData($query);
    return;
}


function _elgg_river_enable($event, $type, $entity) {

    if (!$entity instanceof ElggEntity) {
        return;
    }

    $dbprefix = _elgg_config()->dbprefix;
    $query = <<<QUERY
    UPDATE {$dbprefix}river AS rv
    LEFT JOIN {$dbprefix}entities AS se ON se.guid = rv.subject_guid
    LEFT JOIN {$dbprefix}entities AS oe ON oe.guid = rv.object_guid
    LEFT JOIN {$dbprefix}entities AS te ON te.guid = rv.target_guid
    SET rv.enabled = 'yes'
    WHERE (
            (se.enabled = 'yes' OR se.guid IS NULL) AND
            (oe.enabled = 'yes' OR oe.guid IS NULL) AND
            (te.enabled = 'yes' OR te.guid IS NULL)
        )
        AND (se.guid = {$entity->guid} OR oe.guid = {$entity->guid} OR te.guid = {$entity->guid});
QUERY;

    elgg()->db->updateData($query);
    return;
}

function _elgg_river_menu_setup(\Elgg\Hook $hook) {
    if (!elgg_is_logged_in()) {
        return;
    }

    $item = $hook->getParam('item');
    if (!($item instanceof ElggRiverItem)) {
        return;
    }

    if (!$item->canDelete()) {
        return;
    }

    $return = $hook->getValue();

    $return[] = \ElggMenuItem::factory([
        'name' => 'delete',
        'href' => "action/river/delete?id={$item->id}",
        'is_action' => true,
        'icon' => 'delete',
        'text' => elgg_echo('river:delete'),
        'confirm' => elgg_echo('deleteconfirm'),
        'priority' => 999,
    ]);

    return $return;
}

function _elgg_river_init() {
    elgg_register_plugin_hook_handler('unit_test', 'system', '_elgg_river_test');

    elgg_register_plugin_hook_handler('register', 'menu:river', '_elgg_river_menu_setup');
    
    elgg_register_event_handler('created', 'river', '_elgg_river_update_object_last_action');
}

return function(\Elgg\EventsService $events, \Elgg\HooksRegistrationService $hooks) {
    $events->registerHandler('init', 'system', '_elgg_river_init');
    $events->registerHandler('disable:after', 'all', '_elgg_river_disable', 600);
    $events->registerHandler('enable:after', 'all', '_elgg_river_enable', 600);
};