plugins.php

Go to the documentation of this file.

<?php
define('ELGG_PLUGIN_INCLUDE_START', 1);

define('ELGG_PLUGIN_REGISTER_VIEWS', 2);

define('ELGG_PLUGIN_REGISTER_LANGUAGES', 4);

define('ELGG_PLUGIN_REGISTER_CLASSES', 8);

//define('ELGG_PLUGIN_SETTING_PREFIX', 'plugin:setting:');

define('ELGG_PLUGIN_USER_SETTING_PREFIX', 'plugin:user_setting:');

define('ELGG_PLUGIN_INTERNAL_PREFIX', 'elgg:internal:');


function _elgg_get_plugin_dirs_in_dir($dir = null) {
    if (!$dir) {
        $dir = elgg_get_plugins_path();
    }

    $plugin_dirs = array();
    $handle = opendir($dir);

    if ($handle) {
        while ($plugin_dir = readdir($handle)) {
            // must be directory and not begin with a .
            if (substr($plugin_dir, 0, 1) !== '.' && is_dir($dir . $plugin_dir)) {
                $plugin_dirs[] = $plugin_dir;
            }
        }
    }

    sort($plugin_dirs);

    return $plugin_dirs;
}

function _elgg_generate_plugin_entities() {

    $mod_dir = elgg_get_plugins_path();
    $db_prefix = elgg_get_config('dbprefix');

    // ignore access in case this is called with no admin logged in - needed for creating plugins perhaps?
    $old_ia = elgg_set_ignore_access(true);

    // show hidden entities so that we can enable them if appropriate
    $old_access = access_get_show_hidden_status();
    access_show_hidden_entities(true);

    $options = array(
        'type' => 'object',
        'subtype' => 'plugin',
        'selects' => array('plugin_oe.*'),
        'joins' => array("JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"),
        'limit' => ELGG_ENTITIES_NO_VALUE,
    );
    $known_plugins = elgg_get_entities_from_relationship($options);
    /* @var ElggPlugin[] $known_plugins */

    if (!$known_plugins) {
        $known_plugins = array();
    }

    // map paths to indexes
    $id_map = array();
    foreach ($known_plugins as $i => $plugin) {
        // if the ID is wrong, delete the plugin because we can never load it.
        $id = $plugin->getID();
        if (!$id) {
            $plugin->delete();
            unset($known_plugins[$i]);
            continue;
        }
        $id_map[$plugin->getID()] = $i;
    }

    $physical_plugins = _elgg_get_plugin_dirs_in_dir($mod_dir);

    if (!$physical_plugins) {
        return false;
    }

    // check real plugins against known ones
    foreach ($physical_plugins as $plugin_id) {
        // is this already in the db?
        if (array_key_exists($plugin_id, $id_map)) {
            $index = $id_map[$plugin_id];
            $plugin = $known_plugins[$index];
            // was this plugin deleted and its entity disabled?
            if (!$plugin->isEnabled()) {
                $plugin->enable();
                $plugin->deactivate();
                $plugin->setPriority('last');
            }

            // remove from the list of plugins to disable
            unset($known_plugins[$index]);
        } else {
            // create new plugin
            // priority is forced to last in save() if not set.
            $plugin = new ElggPlugin($mod_dir . $plugin_id);
            $plugin->save();
        }
    }

    // everything remaining in $known_plugins needs to be disabled
    // because they are entities, but their dirs were removed.
    // don't delete the entities because they hold settings.
    foreach ($known_plugins as $plugin) {
        if ($plugin->isActive()) {
            $plugin->deactivate();
        }
        // remove the priority.
        $name = _elgg_namespace_plugin_private_setting('internal', 'priority');
        remove_private_setting($plugin->guid, $name);
        if ($plugin->isEnabled()) {
            $plugin->disable();
        }
    }

    access_show_hidden_entities($old_access);
    elgg_set_ignore_access($old_ia);

    _elgg_reindex_plugin_priorities();

    return true;
}

function _elgg_cache_plugin_by_id(ElggPlugin $plugin) {
    $map = (array) elgg_get_config('plugins_by_id_map');
    $map[$plugin->getID()] = $plugin;
    elgg_set_config('plugins_by_id_map', $map);
}

function elgg_get_plugin_from_id($plugin_id) {
    $map = (array) elgg_get_config('plugins_by_id_map');
    if (isset($map[$plugin_id])) {
        return $map[$plugin_id];
    }

    $plugin_id = sanitize_string($plugin_id);
    $db_prefix = get_config('dbprefix');

    $options = array(
        'type' => 'object',
        'subtype' => 'plugin',
        'joins' => array("JOIN {$db_prefix}objects_entity oe on oe.guid = e.guid"),
        'selects' => array("oe.title", "oe.description"),
        'wheres' => array("oe.title = '$plugin_id'"),
        'limit' => 1,
    );

    $plugins = elgg_get_entities($options);

    if ($plugins) {
        return $plugins[0];
    }

    return null;
}

function elgg_plugin_exists($id) {
    $plugin = elgg_get_plugin_from_id($id);

    return ($plugin) ? true : false;
}

function _elgg_get_max_plugin_priority() {
    $db_prefix = get_config('dbprefix');
    $priority = _elgg_namespace_plugin_private_setting('internal', 'priority');
    $plugin_subtype = get_subtype_id('object', 'plugin');

    $q = "SELECT MAX(CAST(ps.value AS unsigned)) as max
        FROM {$db_prefix}entities e, {$db_prefix}private_settings ps
        WHERE ps.name = '$priority'
        AND ps.entity_guid = e.guid
        AND e.type = 'object' and e.subtype = $plugin_subtype";

    $data = get_data($q);
    if ($data) {
        $max = $data[0]->max;
    } else {
        $max = 1;
    }

    // can't have a priority of 0.
    return ($max) ? $max : 1;
}

function elgg_is_active_plugin($plugin_id, $site_guid = null) {
    if ($site_guid) {
        $site = get_entity($site_guid);
    } else {
        $site = elgg_get_site_entity();
    }

    if (!($site instanceof ElggSite)) {
        return false;
    }

    $plugin = elgg_get_plugin_from_id($plugin_id);

    if (!$plugin) {
        return false;
    }

    return $plugin->isActive($site->guid);
}

function _elgg_load_plugins() {
    $plugins_path = elgg_get_plugins_path();
    $start_flags = ELGG_PLUGIN_INCLUDE_START |
                    ELGG_PLUGIN_REGISTER_VIEWS |
                    ELGG_PLUGIN_REGISTER_LANGUAGES |
                    ELGG_PLUGIN_REGISTER_CLASSES;

    if (!$plugins_path) {
        return false;
    }

    // temporary disable all plugins if there is a file called 'disabled' in the plugin dir
    if (file_exists("$plugins_path/disabled")) {
        if (elgg_is_admin_logged_in() && elgg_in_context('admin')) {
            system_message(elgg_echo('plugins:disabled'));
        }
        return false;
    }

    if (elgg_get_config('system_cache_loaded')) {
        $start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_VIEWS;
    }

    if (elgg_get_config('i18n_loaded_from_cache')) {
        $start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_LANGUAGES;
    }

    $return = true;
    $plugins = elgg_get_plugins('active');
    if ($plugins) {
        foreach ($plugins as $plugin) {
            try {
                $plugin->start($start_flags);
            } catch (Exception $e) {
                $plugin->deactivate();
                $msg = elgg_echo('PluginException:CannotStart',
                                array($plugin->getID(), $plugin->guid, $e->getMessage()));
                elgg_add_admin_notice('cannot_start' . $plugin->getID(), $msg);
                $return = false;

                continue;
            }
        }
    }

    return $return;
}

function elgg_get_plugins($status = 'active', $site_guid = null) {
    $db_prefix = get_config('dbprefix');
    $priority = _elgg_namespace_plugin_private_setting('internal', 'priority');

    if (!$site_guid) {
        $site = get_config('site');
        $site_guid = $site->guid;
    }

    // grab plugins
    $options = array(
        'type' => 'object',
        'subtype' => 'plugin',
        'limit' => ELGG_ENTITIES_NO_VALUE,
        'selects' => array('plugin_oe.*'),
        'joins' => array(
            "JOIN {$db_prefix}private_settings ps on ps.entity_guid = e.guid",
            "JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"
            ),
        'wheres' => array("ps.name = '$priority'"),
        'order_by' => "CAST(ps.value as unsigned), e.guid"
    );

    switch ($status) {
        case 'active':
            $options['relationship'] = 'active_plugin';
            $options['relationship_guid'] = $site_guid;
            $options['inverse_relationship'] = true;
            break;

        case 'inactive':
            $options['wheres'][] = "NOT EXISTS (
                    SELECT 1 FROM {$db_prefix}entity_relationships active_er
                    WHERE active_er.guid_one = e.guid
                        AND active_er.relationship = 'active_plugin'
                        AND active_er.guid_two = $site_guid)";
            break;

        case 'all':
        default:
            break;
    }

    $old_ia = elgg_set_ignore_access(true);
    $plugins = elgg_get_entities_from_relationship($options);
    elgg_set_ignore_access($old_ia);

    return $plugins;
}

function _elgg_set_plugin_priorities(array $order) {
    $name = _elgg_namespace_plugin_private_setting('internal', 'priority');

    $plugins = elgg_get_plugins('any');
    if (!$plugins) {
        return false;
    }

    $return = true;

    // reindex to get standard counting. no need to increment by 10.
    // though we do start with 1
    $order = array_values($order);

    $missing_plugins = array();
    /* @var ElggPlugin[] $missing_plugins */

    foreach ($plugins as $plugin) {
        $plugin_id = $plugin->getID();

        if (!in_array($plugin_id, $order)) {
            $missing_plugins[] = $plugin;
            continue;
        }

        $priority = array_search($plugin_id, $order) + 1;

        if (!$plugin->setPrivateSetting($name, $priority)) {
            $return = false;
            break;
        }
    }

    // set the missing plugins' priorities
    if ($return && $missing_plugins) {
        if (!isset($priority)) {
            $priority = 0;
        }
        foreach ($missing_plugins as $plugin) {
            $priority++;
            if (!$plugin->setPrivateSetting($name, $priority)) {
                $return = false;
                break;
            }
        }
    }

    return $return;
}

function _elgg_reindex_plugin_priorities() {
    return _elgg_set_plugin_priorities(array());
}

function _elgg_namespace_plugin_private_setting($type, $name, $id = null) {
    switch ($type) {
        // commented out because it breaks $plugin->$name access to variables
        //case 'setting':
        //  $name = ELGG_PLUGIN_SETTING_PREFIX . $name;
        //  break;

        case 'user_setting':
            if (!$id) {
                elgg_deprecated_notice("You must pass the plugin id to _elgg_namespace_plugin_private_setting() for user settings", 1.9);
                $id = elgg_get_calling_plugin_id();
            }
            $name = ELGG_PLUGIN_USER_SETTING_PREFIX . "$id:$name";
            break;

        case 'internal':
            $name = ELGG_PLUGIN_INTERNAL_PREFIX . $name;
            break;
    }

    return $name;
}

global $ELGG_PLUGINS_PROVIDES_CACHE;

function _elgg_get_plugins_provides($type = null, $name = null) {
    global $ELGG_PLUGINS_PROVIDES_CACHE;
    if (!isset($ELGG_PLUGINS_PROVIDES_CACHE)) {
        $active_plugins = elgg_get_plugins('active');

        $provides = array();

        foreach ($active_plugins as $plugin) {
            $plugin_provides = array();
            $manifest = $plugin->getManifest();
            if ($manifest instanceof ElggPluginManifest) {
                $plugin_provides = $plugin->getManifest()->getProvides();
            }
            if ($plugin_provides) {
                foreach ($plugin_provides as $provided) {
                    $provides[$provided['type']][$provided['name']] = array(
                        'version' => $provided['version'],
                        'provided_by' => $plugin->getID()
                    );
                }
            }
        }

        $ELGG_PLUGINS_PROVIDES_CACHE = $provides;
    }

    if ($type && $name) {
        if (isset($ELGG_PLUGINS_PROVIDES_CACHE[$type][$name])) {
            return $ELGG_PLUGINS_PROVIDES_CACHE[$type][$name];
        } else {
            return false;
        }
    } elseif ($type) {
        if (isset($ELGG_PLUGINS_PROVIDES_CACHE[$type])) {
            return $ELGG_PLUGINS_PROVIDES_CACHE[$type];
        } else {
            return false;
        }
    }

    return $ELGG_PLUGINS_PROVIDES_CACHE;
}

function _elgg_invalidate_plugins_provides_cache() {
    global $ELGG_PLUGINS_PROVIDES_CACHE;
    $ELGG_PLUGINS_PROVIDES_CACHE = null;
    return true;
}

function _elgg_check_plugins_provides($type, $name, $version = null, $comparison = 'ge') {
    $provided = _elgg_get_plugins_provides($type, $name);
    if (!$provided) {
        return array(
            'status' => false,
            'value' => ''
        );
    }

    if ($version) {
        $status = version_compare($provided['version'], $version, $comparison);
    } else {
        $status = true;
    }

    return array(
        'status' => $status,
        'value' => $provided['version']
    );
}

function _elgg_get_plugin_dependency_strings($dep) {
    $dep_system = elgg_extract('type', $dep);
    $info = elgg_extract('dep', $dep);
    $type = elgg_extract('type', $info);

    if (!$dep_system || !$info || !$type) {
        return false;
    }

    // rewrite some of these to be more readable
    $comparison = elgg_extract('comparison', $info);
    switch($comparison) {
        case 'lt':
            $comparison = '<';
            break;
        case 'gt':
            $comparison = '>';
            break;
        case 'ge':
            $comparison = '>=';
            break;
        case 'le':
            $comparison = '<=';
            break;
        default:
            //keep $comparison value intact
            break;
    }

    /*
    'requires'  'plugin oauth_lib'  <1.3    1.3     'downgrade'
    'requires'  'php setting bob'   >3      3       'change it'
    'conflicts' 'php setting'       >3      4       'change it'
    'conflicted''plugin profile'    any     1.8     'disable profile'
    'provides'  'plugin oauth_lib'  1.3     --      --
    'priority'  'before blog'       --      after   'move it'
    */
    $strings = array();
    $strings['type'] = elgg_echo('ElggPlugin:Dependencies:' . ucwords($dep_system));

    switch ($type) {
        case 'elgg_version':
        case 'elgg_release':
            // 'Elgg Version'
            $strings['name'] = elgg_echo('ElggPlugin:Dependencies:Elgg');
            $strings['expected_value'] = "$comparison {$info['version']}";
            $strings['local_value'] = $dep['value'];
            $strings['comment'] = '';
            break;

        case 'php_version':
            // 'PHP version'
            $strings['name'] = elgg_echo('ElggPlugin:Dependencies:PhpVersion');
            $strings['expected_value'] = "$comparison {$info['version']}";
            $strings['local_value'] = $dep['value'];
            $strings['comment'] = '';
            break;

        case 'php_extension':
            // PHP Extension %s [version]
            $strings['name'] = elgg_echo('ElggPlugin:Dependencies:PhpExtension', array($info['name']));
            if ($info['version']) {
                $strings['expected_value'] = "$comparison {$info['version']}";
                $strings['local_value'] = $dep['value'];
            } else {
                $strings['expected_value'] = '';
                $strings['local_value'] = '';
            }
            $strings['comment'] = '';
            break;

        case 'php_ini':
            $strings['name'] = elgg_echo('ElggPlugin:Dependencies:PhpIni', array($info['name']));
            $strings['expected_value'] = "$comparison {$info['value']}";
            $strings['local_value'] = $dep['value'];
            $strings['comment'] = '';
            break;

        case 'plugin':
            $strings['name'] = elgg_echo('ElggPlugin:Dependencies:Plugin', array($info['name']));
            $expected = $info['version'] ? "$comparison {$info['version']}" : elgg_echo('any');
            $strings['expected_value'] = $expected;
            $strings['local_value'] = $dep['value'] ? $dep['value'] : '--';
            $strings['comment'] = '';
            break;

        case 'priority':
            $expected_priority = ucwords($info['priority']);
            $real_priority = ucwords($dep['value']);
            $strings['name'] = elgg_echo('ElggPlugin:Dependencies:Priority');
            $strings['expected_value'] = elgg_echo("ElggPlugin:Dependencies:Priority:$expected_priority", array($info['plugin']));
            $strings['local_value'] = elgg_echo("ElggPlugin:Dependencies:Priority:$real_priority", array($info['plugin']));
            $strings['comment'] = '';
            break;
    }

    if ($dep['type'] == 'suggests') {
        if ($dep['status']) {
            $strings['comment'] = elgg_echo('ok');
        } else {
            $strings['comment'] = elgg_echo('ElggPlugin:Dependencies:Suggests:Unsatisfied');
        }
    } else {
        if ($dep['status']) {
            $strings['comment'] = elgg_echo('ok');
        } else {
            $strings['comment'] = elgg_echo('error');
        }
    }

    return $strings;
}

function elgg_get_calling_plugin_entity() {
    elgg_deprecated_notice("elgg_get_calling_plugin_entity() is deprecated.", 1.9);
    $plugin_id = elgg_get_calling_plugin_id();

    if ($plugin_id) {
        return elgg_get_plugin_from_id($plugin_id);
    }

    return false;
}

function elgg_get_all_plugin_user_settings($user_guid = 0, $plugin_id = null, $return_obj = false) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_get_all_plugin_user_settings() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin instanceof ElggPlugin) {
        return false;
    }

    $settings = $plugin->getAllUserSettings((int)$user_guid);

    if ($settings && $return_obj) {
        $return = new stdClass;

        foreach ($settings as $k => $v) {
            $return->$k = $v;
        }

        return $return;
    } else {
        return $settings;
    }
}

function elgg_set_plugin_user_setting($name, $value, $user_guid = 0, $plugin_id = null) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_set_plugin_user_setting() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin) {
        return false;
    }

    return $plugin->setUserSetting($name, $value, (int)$user_guid);
}

function elgg_unset_plugin_user_setting($name, $user_guid = 0, $plugin_id = null) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_unset_plugin_user_setting() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin) {
        return false;
    }

    return $plugin->unsetUserSetting($name, (int)$user_guid);
}

function elgg_get_plugin_user_setting($name, $user_guid = 0, $plugin_id = null) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_get_plugin_user_setting() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin) {
        return false;
    }

    return $plugin->getUserSetting($name, (int)$user_guid);
}

function elgg_set_plugin_setting($name, $value, $plugin_id = null) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_set_plugin_setting() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin) {
        return false;
    }

    return $plugin->setSetting($name, $value);
}

function elgg_get_plugin_setting($name, $plugin_id = null, $default = null) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_get_plugin_setting() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin) {
        return false;
    }

    return $plugin->getSetting($name, $default);
}

function elgg_unset_plugin_setting($name, $plugin_id = null) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_unset_plugin_setting() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin) {
        return false;
    }

    return $plugin->unsetSetting($name);
}

function elgg_unset_all_plugin_settings($plugin_id = null) {
    if ($plugin_id) {
        $plugin = elgg_get_plugin_from_id($plugin_id);
    } else {
        elgg_deprecated_notice('elgg_unset_all_plugin_settings() requires plugin_id to be set', 1.9);
        $plugin = elgg_get_calling_plugin_entity();
    }

    if (!$plugin) {
        return false;
    }

    return $plugin->unsetAllSettings();
}

function elgg_get_entities_from_plugin_user_settings(array $options = array()) {
    if (!isset($options['plugin_id'])) {
        elgg_deprecated_notice("'plugin_id' is now required for elgg_get_entities_from_plugin_user_settings()", 1.9);
        $options['plugin_id'] = elgg_get_calling_plugin_id();
    }

    $singulars = array('plugin_user_setting_name', 'plugin_user_setting_value',
        'plugin_user_setting_name_value_pair');

    $options = _elgg_normalize_plural_options_array($options, $singulars);

    // rewrite plugin_user_setting_name_* to the right PS ones.
    $map = array(
        'plugin_user_setting_names' => 'private_setting_names',
        'plugin_user_setting_values' => 'private_setting_values',
        'plugin_user_setting_name_value_pairs' => 'private_setting_name_value_pairs',
        'plugin_user_setting_name_value_pairs_operator' => 'private_setting_name_value_pairs_operator',
    );

    foreach ($map as $plugin => $private) {
        if (!isset($options[$plugin])) {
            continue;
        }

        if (isset($options[$private])) {
            if (!is_array($options[$private])) {
                $options[$private] = array($options[$private]);
            }

            $options[$private] = array_merge($options[$private], $options[$plugin]);
        } else {
            $options[$private] = $options[$plugin];
        }
    }

    $prefix = _elgg_namespace_plugin_private_setting('user_setting', '', $options['plugin_id']);
    $options['private_setting_name_prefix'] = $prefix;

    return elgg_get_entities_from_private_settings($options);
}

function _elgg_plugins_test($hook, $type, $value, $params) {
    global $CONFIG;
    $value[] = $CONFIG->path . 'engine/tests/ElggCorePluginsAPITest.php';
    return $value;
}

function _plugins_deactivate_dependency_check($event, $type, $params) {
    $plugin_id = $params['plugin_entity']->getManifest()->getPluginID();
    $plugin_name = $params['plugin_entity']->getManifest()->getName();

    $active_plugins = elgg_get_plugins();

    $dependents = array();
    foreach ($active_plugins as $plugin) {
        $manifest = $plugin->getManifest();
        $requires = $manifest->getRequires();

        foreach ($requires as $required) {
            if ($required['type'] == 'plugin' && $required['name'] == $plugin_id) {
                // there are active dependents
                $dependents[$manifest->getPluginID()] = $plugin;
            }
        }
    }

    if ($dependents) {
        $list = '<ul>';
        // construct error message and prevent disabling
        foreach ($dependents as $dependent) {
            $list .= '<li>' . $dependent->getManifest()->getName() . '</li>';
        }
        $list .= '</ul>';

        register_error(elgg_echo('ElggPlugin:Dependencies:ActiveDependent', array($plugin_name, $list)));

        return false;
    }
}

function _elgg_plugins_init() {

    if (elgg_is_admin_logged_in()) {
        elgg_register_ajax_view('object/plugin/full');
    }

    elgg_register_plugin_hook_handler('unit_test', 'system', '_elgg_plugins_test');

    // note - plugins are booted by the time this handler is registered
    // deactivation due to error may have already occurred
    elgg_register_event_handler('deactivate', 'plugin', '_plugins_deactivate_dependency_check');

    elgg_register_action("plugins/settings/save", '', 'admin');
    elgg_register_action("plugins/usersettings/save");

    elgg_register_action('admin/plugins/activate', '', 'admin');
    elgg_register_action('admin/plugins/deactivate', '', 'admin');
    elgg_register_action('admin/plugins/activate_all', '', 'admin');
    elgg_register_action('admin/plugins/deactivate_all', '', 'admin');

    elgg_register_action('admin/plugins/set_priority', '', 'admin');

    elgg_register_library('elgg:markdown', elgg_get_root_path() . 'vendors/markdown/markdown.php');
}

elgg_register_event_handler('init', 'system', '_elgg_plugins_init');