// // Returning FALSE to this function will generate a standard
// // "Could not log you in" message.
// // Plugins should use this hook to provide details, and then return TRUE.
- // if (!trigger_plugin_hook('failed_login', 'user', $params, FALSE)) {
+ // if (!elgg_trigger_plugin_hook('failed_login', 'user', $params, FALSE)) {
// register_error(elgg_echo('loginerror'));
// }
}
system_message(elgg_echo('plugins:settings:save:ok', array($plugin_name)));
forward(REFERER);
//
-//$trigger = trigger_plugin_hook('plugin:save_settings', $plugin, $options, NULL);
+//$trigger = elgg_trigger_plugin_hook('plugin:save_settings', $plugin, $options, NULL);
//if ($trigger === NULL) {
// foreach ($params as $k => $v) {
// if (!$result = set_plugin_setting($k, $v, $plugin)) {
);
// @todo should registration be allowed no matter what the plugins return?
- if (!trigger_plugin_hook('register', 'user', $params, TRUE)) {
+ if (!elgg_trigger_plugin_hook('register', 'user', $params, TRUE)) {
$new_user->delete();
// @todo this is a generic messages. We could have plugins
// throw a RegistrationException, but that is very odd
gatekeeper();
-trigger_plugin_hook('usersettings:save', 'user');
+elgg_trigger_plugin_hook('usersettings:save', 'user');
forward(REFERER);
<?php
-register_elgg_event_handler('create', 'object', 'example_event_handler');
+elgg_register_event_handler('create', 'object', 'example_event_handler');
function example_event_handler($event, $type, $params) {
// Don't allow any non-admin users to create objects
<?php
-register_elgg_event_handler('all', 'object', 'example_event_handler');
+elgg_register_event_handler('all', 'object', 'example_event_handler');
// This function will be called for any event of type 'object'
function example_event_handler($event, $type, $params) {
<?php
-register_elgg_event_handler('init', 'system', 'example_event_handler');
+elgg_register_event_handler('init', 'system', 'example_event_handler');
function example_event_handler($event, $type, $params) {
var_dump($event);
<?php
$params = new ElggObject();
-trigger_elgg_event('test', 'example', $params);
+elgg_trigger_event('test', 'example', $params);
// handlers would be registered by saying
-register_elgg_event_handler('test', 'example', 'example_event_handler');
+elgg_register_event_handler('test', 'example', 'example_event_handler');
<?php
-register_plugin_hook('get_items', 'example', 'example_plugin_hook');
-register_plugin_hook('get_items', 'example', 'example_plugin_hook_2');
+elgg_register_plugin_hook_handler('get_items', 'example', 'example_plugin_hook');
+elgg_register_plugin_hook_handler('get_items', 'example', 'example_plugin_hook_2');
$params = array('username' => 'Joe');
-$items = trigger_plugin_hook('get_items', 'example', $params, $default);
+$items = elgg_trigger_plugin_hook('get_items', 'example', $params, $default);
var_dump($items);
<?php
// the output:page hook is triggered by elgg_view_page().
-register_plugin_hook('output', 'page', 'example_plugin_hook_handler', 600);
-register_plugin_hook('output', 'page', 'example_plugin_hook_handler_2', 601);
+elgg_register_plugin_hook_handler('output', 'page', 'example_plugin_hook_handler', 600);
+elgg_register_plugin_hook_handler('output', 'page', 'example_plugin_hook_handler_2', 601);
function example_plugin_hook_handler($event, $type, $value, $params) {
// change A to @
$value = str_replace('A', '@', $value);
-
+
return $value;
}
function example_plugin_hook_handler_2($event, $type, $value, $params) {
// change S to $
$value = str_replace('S', '$', $value);
-
+
return $value;
}
<?php
-register_plugin_hook('all', 'system', 'example_plugin_hook_handler');
+elgg_register_plugin_hook_handler('all', 'system', 'example_plugin_hook_handler');
// This function will be called for any hook of type 'system'
function example_plugin_hook_handler($hook, $type, $value, $params) {
<?php
-register_plugin_hook('forward', 'system', 'example_plugin_hook_handler');
+elgg_register_plugin_hook_handler('forward', 'system', 'example_plugin_hook_handler');
function example_plugin_hook_handler($event, $type, $value, $params) {
var_dump($event);
<?php
// @todo this is an event, not a hook
-register_elgg_event_handler('test', 'example', 'example_init_system_callback');
+elgg_register_event_handler('test', 'example', 'example_init_system_callback');
$params = new ElggObject();
-trigger_elgg_event('test', 'example', $params);
+elgg_trigger_event('test', 'example', $params);
$default = array('Entry 1', 'Entry 2', 'Entry 3');
-$menu = trigger_plugin_hook('get_menu_items', 'menu', null, $default);
+$menu = elgg_trigger_plugin_hook('get_menu_items', 'menu', null, $default);
foreach ($menu as $item) {
var_dump($item);
<?php
-$result = trigger_plugin_hook('get_status', 'example', null, true);
+$result = elgg_trigger_plugin_hook('get_status', 'example', null, true);
if ($result) {
var_dump('Plugin hook says ok!');
/**
* Event information for the events subsystem.
*
- * Events are added with {@link register_elgg_event_handler()} and
- * can be removed in >= 1.8 with {@link unregister_elgg_event_handler()}.
+ * Events are added with {@link elgg_register_event_handler()} and
+ * can be removed in >= 1.8 with {@link elgg_unregister_event_handler()}.
*
* Events are stored as a multidimensional array in the format:
* <code>
* @global array $CONFIG->events
* @name $CONFIG->events
* @see events()
- * @see register_elgg_event_handler()
- * @see unregister_elgg_event_handler()
- * @see trigger_elgg_event()
+ * @see elgg_register_event_handler()
+ * @see elgg_unregister_event_handler()
+ * @see elgg_trigger_event()
*/
$CONFIG->events;
/**
* Plugin Hook information for the plugin hooks subsystem.
*
- * Hooks are added with {@link register_plugin_hook()} and
- * can be removed in >= 1.8 with {@link unregister_plugin_hook()}.
+ * Hooks are added with {@link elgg_register_plugin_hook_handler()} and
+ * can be removed in >= 1.8 with {@link elgg_unregister_plugin_hook_handler()}.
*
* Hooks are stored as a multidimensional array in the format:
* <code>
* </code>
*
* @global array $CONFIG->hooks
- * @see register_plugin_hook()
- * @see unregister_plugin_hook()
- * @see trigger_plugin_hook()
+ * @see elgg_register_plugin_hook_handler()
+ * @see elgg_unregister_plugin_hook_handler()
+ * @see elgg_trigger_plugin_hook()
*/
$CONFIG->hooks;
}
$value = NULL;
- $value = trigger_plugin_hook('session:get', $key, NULL, $value);
+ $value = elgg_trigger_plugin_hook('session:get', $key, NULL, $value);
ElggSession::$__localcache[$key] = $value;
if ($CONFIG->walled_garden && !isloggedin()) {
// hook into the index system call at the highest priority
- register_plugin_hook('index', 'system', 'elgg_walled_garden_index', 1);
+ elgg_register_plugin_hook_handler('index', 'system', 'elgg_walled_garden_index', 1);
if (!$this->isPublicPage()) {
register_error(elgg_echo('loggedinrequired'));
);
// include a hook for plugin authors to include public pages
- $plugins = trigger_plugin_hook('public_pages', 'walled_garden', NULL, array());
+ $plugins = elgg_trigger_plugin_hook('public_pages', 'walled_garden', NULL, array());
// lookup admin-specific public pages
$old_stdout = "";
ob_start();
-$old_stdout = trigger_plugin_hook('cron', $period, $params, $old_stdout);
+$old_stdout = elgg_trigger_plugin_hook('cron', $period, $params, $old_stdout);
$std_out = ob_get_clean();
// Return event
}
$options = array('user_id' => $user_id, 'site_id' => $site_id);
- return trigger_plugin_hook('access:collections:read', 'user', $options, $tmp_access_array);
+ return elgg_trigger_plugin_hook('access:collections:read', 'user', $options, $tmp_access_array);
}
/**
}
$options = array('user_id' => $user_id, 'site_id' => $site_id);
- $tmp_access_array = trigger_plugin_hook('access:collections:write', 'user',
+ $tmp_access_array = elgg_trigger_plugin_hook('access:collections:write', 'user',
$options, $tmp_access_array);
return $tmp_access_array;
'collection_id' => $id
);
- if (!trigger_plugin_hook('access:collections:addcollection', 'collection', $params, true)) {
+ if (!elgg_trigger_plugin_hook('access:collections:addcollection', 'collection', $params, true)) {
return false;
}
$collections = get_write_access_array(null, null, TRUE);
$params = array('collection_id' => $collection_id);
- if (!trigger_plugin_hook('access:collections:deletecollection', 'collection', $params, true)) {
+ if (!elgg_trigger_plugin_hook('access:collections:deletecollection', 'collection', $params, true)) {
return false;
}
'user_guid' => $user_guid
);
- if (!trigger_plugin_hook('access:collections:add_user', 'collection', $params, true)) {
+ if (!elgg_trigger_plugin_hook('access:collections:add_user', 'collection', $params, true)) {
return false;
}
'user_guid' => $user_guid
);
- if (!trigger_plugin_hook('access:collections:remove_user', 'collection', $params, true)) {
+ if (!elgg_trigger_plugin_hook('access:collections:remove_user', 'collection', $params, true)) {
return false;
}
}
// This function will let us know when 'init' has finished
-register_elgg_event_handler('init', 'system', 'access_init', 9999);
+elgg_register_event_handler('init', 'system', 'access_init', 9999);
// For overrided permissions
-register_plugin_hook('permissions_check', 'all', 'elgg_override_permissions_hook');
-register_plugin_hook('container_permissions_check', 'all', 'elgg_override_permissions_hook');
\ No newline at end of file
+elgg_register_plugin_hook_handler('permissions_check', 'all', 'elgg_override_permissions_hook');
+elgg_register_plugin_hook_handler('container_permissions_check', 'all', 'elgg_override_permissions_hook');
\ No newline at end of file
// Trigger action event
// @todo This is only called before the primary action is called.
$event_result = true;
- $event_result = trigger_plugin_hook('action', $action, null, $event_result);
+ $event_result = elgg_trigger_plugin_hook('action', $action, null, $event_result);
// Include action
// Event_result being false doesn't produce an error
// else says something to the contry we assume we're ok
$returnval = true;
- $returnval = trigger_plugin_hook('action_gatekeeper:permissions:check', 'all', array(
+ $returnval = elgg_trigger_plugin_hook('action_gatekeeper:permissions:check', 'all', array(
'token' => $token,
'time' => $ts
), $returnval);
elgg_view_register_simplecache('js/languages/en');
- register_plugin_hook('action', 'all', 'ajax_action_hook');
- register_plugin_hook('forward', 'all', 'ajax_forward_hook');
+ elgg_register_plugin_hook_handler('action', 'all', 'ajax_action_hook');
+ elgg_register_plugin_hook_handler('forward', 'all', 'ajax_forward_hook');
}
/**
}
}
-register_elgg_event_handler('init', 'system', 'actions_init');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'actions_init');
\ No newline at end of file
}
// Register init functions
-register_elgg_event_handler('init', 'system', 'admin_init');
-register_elgg_event_handler('pagesetup', 'system', 'admin_pagesetup');
+elgg_register_event_handler('init', 'system', 'admin_init');
+elgg_register_event_handler('pagesetup', 'system', 'admin_pagesetup');
$entity = get_entity($entity_guid);
- if (trigger_elgg_event('annotate', $entity->type, $entity)) {
+ if (elgg_trigger_event('annotate', $entity->type, $entity)) {
system_log($entity, 'annotate');
// If ok then add it
if ($result !== false) {
$obj = get_annotation($result);
- if (trigger_elgg_event('create', 'annotation', $obj)) {
+ if (elgg_trigger_event('create', 'annotation', $obj)) {
return $result;
} else {
// plugin returned false to reject annotation
if ($result !== false) {
$obj = get_annotation($annotation_id);
- if (trigger_elgg_event('update', 'annotation', $obj)) {
+ if (elgg_trigger_event('update', 'annotation', $obj)) {
return true;
} else {
// @todo add plugin hook that sends old and new annotation information before db access
* Returns a viewable list of entities from annotations.
*
* @param array $options
- *
+ *
* @see elgg_get_entities_from_annotations()
* @see elgg_list_entities()
*
$access = get_access_sql_suffix();
$annotation = get_annotation($id);
- if (trigger_elgg_event('delete', 'annotation', $annotation)) {
+ if (elgg_trigger_event('delete', 'annotation', $annotation)) {
remove_from_river_by_annotation($id);
return delete_data("DELETE from {$CONFIG->dbprefix}annotations where id=$id and $access");
}
}
/** Register the hook */
-register_plugin_hook("export", "all", "export_annotation_plugin_hook", 2);
+elgg_register_plugin_hook_handler("export", "all", "export_annotation_plugin_hook", 2);
// can be used for keeping stats
// plugin can also return false to fail this authentication method
- return trigger_plugin_hook('api_key', 'use', $api_key, true);
+ return elgg_trigger_plugin_hook('api_key', 'use', $api_key, true);
}
// Register a page handler, so we can have nice URLs
register_service_handler('rest', 'rest_handler');
- register_plugin_hook('unit_test', 'system', 'api_unit_test');
+ elgg_register_plugin_hook_handler('unit_test', 'system', 'api_unit_test');
// expose the list of api methods
expose_function("system.api.list", "list_all_apis", NULL,
}
-register_elgg_event_handler('init', 'system', 'api_init');
+elgg_register_event_handler('init', 'system', 'api_init');
get_all_config();
}
-register_elgg_event_handler('boot', 'system', 'configuration_boot', 10);
\ No newline at end of file
+elgg_register_event_handler('boot', 'system', 'configuration_boot', 10);
\ No newline at end of file
register_page_handler('cron', 'cron_page_handler');
// register a hook for Walled Garden public pages
- register_plugin_hook('public_pages', 'walled_garden', 'cron_public_pages');
+ elgg_register_plugin_hook_handler('public_pages', 'walled_garden', 'cron_public_pages');
}
/**
}
// Register a startup event
-register_elgg_event_handler('init', 'system', 'cron_init');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'cron_init');
\ No newline at end of file
/**
* @elgg_register_event boot system init_db
*/
-register_elgg_event_handler('boot', 'system', 'init_db', 0);
\ No newline at end of file
+elgg_register_event_handler('boot', 'system', 'init_db', 0);
\ No newline at end of file
// return new forward location or false to stop the forward or empty string to exit
$current_page = current_page_url();
$params = array('current_url' => $current_page, 'forward_url' => $location);
- $location = trigger_plugin_hook('forward', 'system', $params, $location);
+ $location = elgg_trigger_plugin_hook('forward', 'system', $params, $location);
if ($location) {
header("Location: {$location}");
function elgg_get_external_file($type, $location) {
global $CONFIG;
- if (isset($CONFIG->externals) &&
+ if (isset($CONFIG->externals) &&
isset($CONFIG->externals[$type]) &&
isset($CONFIG->externals[$type][$location])) {
-
+
return array_values($CONFIG->externals[$type][$location]);
}
return array();
return false;
}
- if ($likes = trigger_plugin_hook('likes', $entity->getType(), array('entity' => $entity), false)) {
+ if ($likes = elgg_trigger_plugin_hook('likes', $entity->getType(), array('entity' => $entity), false)) {
return $likes;
} else {
$likes = elgg_view('likes/forms/edit', array('entity' => $entity));
* @since 1.8
*/
function elgg_count_likes($entity) {
- if ($likeno = trigger_plugin_hook('likes:count', $entity->getType(),
+ if ($likeno = elgg_trigger_plugin_hook('likes:count', $entity->getType(),
array('entity' => $entity), false)) {
return $likeno;
} else {
* @return int Number of comments
*/
function elgg_count_comments($entity) {
- if ($commentno = trigger_plugin_hook('comments:count', $entity->getType(),
+ if ($commentno = elgg_trigger_plugin_hook('comments:count', $entity->getType(),
array('entity' => $entity), false)) {
return $commentno;
} else {
}
/**
- * Deprecated events core function. Code divided between register_elgg_event_handler()
+ * Deprecated events core function. Code divided between elgg_register_event_handler()
* and trigger_elgg_event().
*
* @param string $event The type of event (eg 'init', 'update', 'delete')
// leaving this here just in case someone was directly calling this internal function
if (!$call) {
- return register_elgg_event_handler($event, $object_type, $function, $priority);
+ return elgg_register_event_handler($event, $object_type, $function, $priority);
} else {
return trigger_elgg_event($event, $object_type, $object);
}
* @param string $event The event type
* @param string $object_type The object type
* @param string $callback The handler callback
- * @param int $priority The priority of the event
+ * @param int $priority The priority - 0 is default, negative before, positive after
*
* @return bool
* @link http://docs.elgg.org/Tutorials/Plugins/Events
* callback and halting execution.
* @example events/all.php Example of how to use the 'all' keyword.
*/
-function register_elgg_event_handler($event, $object_type, $callback, $priority = 500) {
+function elgg_register_event_handler($event, $object_type, $callback, $priority = 500) {
global $CONFIG;
if (empty($event) || empty($object_type)) {
return FALSE;
}
- $priority = (int) $priority;
- if ($priority < 0) {
- $priority = 0;
- }
+ $priority = max((int) $priority, 0);
+
while (isset($CONFIG->events[$event][$object_type][$priority])) {
$priority++;
}
return TRUE;
}
+/**
+ * @deprecated 1.8 Use elgg_register_event_handler() instead
+ */
+function register_elgg_event_handler($event, $object_type, $callback, $priority = 500) {
+ elgg_deprecated_notice("register_elgg_event_handler() was deprecated by elgg_register_event_handler()", 1.8);
+ return elgg_register_event_handler($event, $object_type, $callback, $priority);
+}
+
/**
* Unregisters a callback for an event.
*
* @param string $callback The callback
*
* @return void
- * @since 1.7.0
+ * @since 1.7
*/
-function unregister_elgg_event_handler($event, $object_type, $callback) {
+function elgg_unregister_event_handler($event, $object_type, $callback) {
global $CONFIG;
foreach ($CONFIG->events[$event][$object_type] as $key => $event_callback) {
if ($event_callback == $callback) {
}
}
+/**
+ * @deprecated 1.8 Use elgg_unregister_event_handler instead
+ */
+function unregister_elgg_event_handler($event, $object_type, $callback) {
+ elgg_deprecated_notice("unregister_elgg_event_handler() was deprecated by elgg_unregister_event_handler()", 1.8);
+ elgg_unregister_event_handler($event, $object_type, $callback);
+}
+
/**
* Trigger an Elgg Event and run all handler callbacks registered to that event, type.
*
* @link http://docs.elgg.org/Tutorials/Core/Events
* @internal @example events/emit.php Basic emitting of an Elgg event.
*/
-function trigger_elgg_event($event, $object_type, $object = null) {
+function elgg_trigger_event($event, $object_type, $object = null) {
global $CONFIG;
if (!empty($CONFIG->events[$event][$object_type]) && is_array($CONFIG->events[$event][$object_type])) {
return TRUE;
}
+/**
+ * @deprecated 1.8 Use elgg_trigger_event() instead
+ */
+function trigger_elgg_event($event, $object_type, $object = null) {
+ elgg_deprecated_notice('trigger_elgg_event() was deprecated by elgg_trigger_event()', 1.8);
+ return elgg_trigger_event($event, $object_type, $object);
+}
+
/**
* Register a callback as a plugin hook handler.
*
* Plugin hooks allow developers to losely couple plugins and features by
- * repsonding to and emitting {@link trigger_plugin_hook()} customizable hooks.
+ * repsonding to and emitting {@link elgg_trigger_plugin_hook()} customizable hooks.
* Handler callbacks can respond to the hook, change the details of the hook, or
* ignore it.
*
* is called in order of priority. If the return value of a handler is not
* null, that value is passed to the next callback in the call stack. When all
* callbacks have been run, the final value is passed back to the caller
- * via {@link trigger_plugin_hook()}.
+ * via {@link elgg_trigger_plugin_hook()}.
*
* Similar to Elgg Events, plugin hook handler callbacks are registered by passing
* a hook, a type, and a priority.
* @param string $hook The name of the hook
* @param string $type The type of the hook
* @param callback $callback The name of a valid function or an array with object and method
- * @param string $priority The priority - 0 is first, 1000 last, default is 500
+ * @param int $priority The priority - 0 is default, negative before, positive after
*
* @return bool
*
* @example hooks/register/basic.php Registering for a plugin hook and examining the variables.
* @example hooks/register/advanced.php Registering for a plugin hook and changing the params.
* @link http://docs.elgg.org/Tutorials/Plugins/Hooks
+ * @since 1.8
*/
-function register_plugin_hook($hook, $type, $callback, $priority = 500) {
+function elgg_register_plugin_hook_handler($hook, $type, $callback, $priority = 500) {
global $CONFIG;
if (empty($hook) || empty($type)) {
if ($priority < 0) {
$priority = 0;
}
+
while (isset($CONFIG->hooks[$hook][$type][$priority])) {
$priority++;
}
return TRUE;
}
+/**
+ * @deprecated 1.8 Use elgg_register_plugin_hook_handler() instead
+ */
+function register_plugin_hook($hook, $type, $callback, $priority = 500) {
+ elgg_deprecated_notice("register_plugin_hook() was deprecated by elgg_register_plugin_hook_handler()", 1.8);
+ return elgg_register_plugin_hook_handler($hook, $type, $callback, $priority);
+}
+
/**
* Unregister a callback as a plugin hook.
*
* @param callback $callback The PHP callback to be removed
*
* @return void
- * @since 1.7.0
+ * @since 1.8
*/
-function unregister_plugin_hook($hook, $entity_type, $callback) {
+function elgg_unregister_plugin_hook_handler($hook, $entity_type, $callback) {
global $CONFIG;
foreach ($CONFIG->hooks[$hook][$entity_type] as $key => $hook_callback) {
if ($hook_callback == $callback) {
}
}
+/**
+ * @deprecated 1.8 Use elgg_unregister_plugin_hook_handler() instead
+ */
+function unregister_plugin_hook($hook, $entity_type, $callback) {
+ elgg_deprecated_notice("unregister_plugin_hook() was deprecated by elgg_unregister_plugin_hook_handler()", 1.8);
+ elgg_unregister_plugin_hook_handler($hook, $entity_type, $callback);
+}
+
/**
* Trigger a Plugin Hook and run all handler callbacks registered to that hook:type.
*
* called for all hooks of type $event, regardless of $object_type. If $hook
* and $type both are 'all', the handler will be called for all hooks.
*
- * @see register_plugin_hook()
+ * @see elgg_register_plugin_hook_handler()
*
* @param string $hook The name of the hook to trigger ("all" will
* trigger for all $types regardless of $hook value)
* the results to populate a menu.
* @example hooks/basic.php Trigger and respond to a basic plugin hook.
* @link http://docs.elgg.org/Tutorials/Plugins/Hooks
+ *
+ * @since 1.8
*/
-function trigger_plugin_hook($hook, $type, $params = null, $returnvalue = null) {
+function elgg_trigger_plugin_hook($hook, $type, $params = null, $returnvalue = null) {
global $CONFIG;
if (!empty($CONFIG->hooks[$hook][$type]) && is_array($CONFIG->hooks[$hook][$type])) {
return $returnvalue;
}
+/**
+ * @deprecated 1.8 Use elgg_trigger_plugin_hook() instead
+ */
+function trigger_plugin_hook($hook, $type, $params = null, $returnvalue = null) {
+ elgg_deprecated_notice("trigger_plugin_hook() was deprecated by elgg_trigger_plugin_hook()", 1.8);
+ return elgg_trigger_plugin_hook($hook, $type, $params, $returnvalue);
+}
+
/**
* Intercepts, logs, and display uncaught exceptions.
*
$params = array('level' => $level,
'msg' => $value,
'to_screen' => $to_screen);
- if (!trigger_plugin_hook('debug', 'log', $params, true)) {
+ if (!elgg_trigger_plugin_hook('debug', 'log', $params, true)) {
return;
}
/**
* Get the URL for the current (or specified) site
- *
+ *
* @param int $site_guid The GUID of the site whose URL we want to grab
* @return string
*/
global $CONFIG;
return $CONFIG->wwwroot;
}
-
+
$site = get_entity($site_guid);
-
+
if (!$site instanceof ElggSite) {
return false;
}
-
+
return $site->url;
}
function _elgg_shutdown_hook() {
global $START_MICROTIME;
- trigger_elgg_event('shutdown', 'system');
+ elgg_trigger_event('shutdown', 'system');
$time = (float)(microtime(TRUE) - $START_MICROTIME);
// demoted to NOTICE from DEBUG so javascript is not corrupted
*/
define('REFERER', -1);
-register_elgg_event_handler('init', 'system', 'elgg_init');
-register_plugin_hook('unit_test', 'system', 'elgg_api_test');
+elgg_register_event_handler('init', 'system', 'elgg_init');
+elgg_register_plugin_hook_handler('unit_test', 'system', 'elgg_api_test');
-register_elgg_event_handler('init', 'system', 'add_custom_menu_items', 1000);
-register_elgg_event_handler('init', 'system', 'elgg_walled_garden', 1000);
+elgg_register_event_handler('init', 'system', 'add_custom_menu_items', 1000);
+elgg_register_event_handler('init', 'system', 'elgg_walled_garden', 1000);
$entity = get_entity($guid);
if ($entity && $entity->canEdit()) {
- if (trigger_elgg_event('update', $entity->type, $entity)) {
+ if (elgg_trigger_event('update', $entity->type, $entity)) {
$ret = update_data("UPDATE {$CONFIG->dbprefix}entities"
. " set owner_guid='$owner_guid', access_id='$access_id',"
. " container_guid='$container_guid', time_updated='$time' WHERE guid=$guid");
}
// See if anyone else has anything to say
- return trigger_plugin_hook('container_permissions_check', $type,
+ return elgg_trigger_plugin_hook('container_permissions_check', $type,
array('container' => $container, 'user' => $user, 'subtype' => $subtype), $return);
}
$reason = sanitise_string($reason);
if ($entity = get_entity($guid)) {
- if (trigger_elgg_event('disable', $entity->type, $entity)) {
+ if (elgg_trigger_event('disable', $entity->type, $entity)) {
if ($entity->canEdit()) {
if ($reason) {
create_metadata($guid, 'disable_reason', $reason, '', 0, ACCESS_PUBLIC);
access_show_hidden_entities(true);
if ($entity = get_entity($guid)) {
- if (trigger_elgg_event('enable', $entity->type, $entity)) {
+ if (elgg_trigger_event('enable', $entity->type, $entity)) {
if ($entity->canEdit()) {
access_show_hidden_entities($access_status);
$guid = (int)$guid;
if ($entity = get_entity($guid)) {
- if (trigger_elgg_event('delete', $entity->type, $entity)) {
+ if (elgg_trigger_event('delete', $entity->type, $entity)) {
if ($entity->canEdit()) {
// delete cache
}
}
- return trigger_plugin_hook('permissions_check', $entity->type,
+ return elgg_trigger_plugin_hook('permissions_check', $entity->type,
array('entity' => $entity, 'user' => $user), $return);
} else {
* @param ElggMetadata $metadata The metadata to specifically check (if any; default null)
*
* @return bool
- * @see register_plugin_hook()
+ * @see elgg_register_plugin_hook_handler()
*/
function can_edit_entity_metadata($entity_guid, $user_guid = 0, $metadata = null) {
if ($entity = get_entity($entity_guid)) {
$user = get_entity($user_guid);
$params = array('entity' => $entity, 'user' => $user, 'metadata' => $metadata);
- $return = trigger_plugin_hook('permissions_check:metadata', $entity->type, $parms, $return);
+ $return = elgg_trigger_plugin_hook('permissions_check:metadata', $entity->type, $parms, $return);
return $return;
} else {
return false;
// Step one, see if anyone knows how to render this in the current view
$params = array('entity' => $entity, 'viewtype' => $viewtype, 'size' => $size);
- $url = trigger_plugin_hook('entity:icon:url', $entity->getType(), $params, $url);
+ $url = elgg_trigger_plugin_hook('entity:icon:url', $entity->getType(), $params, $url);
// Fail, so use default
if (!$url) {
function entities_init() {
register_page_handler('view', 'entities_page_handler');
- register_plugin_hook('unit_test', 'system', 'entities_test');
+ elgg_register_plugin_hook_handler('unit_test', 'system', 'entities_test');
// Allow a permission override for recursive entity deletion
// @todo Can this be done better?
- register_plugin_hook('permissions_check', 'all', 'recursive_delete_permissions_check');
- register_plugin_hook('permissions_check:metadata', 'all', 'recursive_delete_permissions_check');
+ elgg_register_plugin_hook_handler('permissions_check', 'all', 'recursive_delete_permissions_check');
+ elgg_register_plugin_hook_handler('permissions_check:metadata', 'all', 'recursive_delete_permissions_check');
- register_plugin_hook('gc', 'system', 'entities_gc');
+ elgg_register_plugin_hook_handler('gc', 'system', 'entities_gc');
}
/** Register the import hook */
-register_plugin_hook("import", "all", "import_entity_plugin_hook", 0);
+elgg_register_plugin_hook_handler("import", "all", "import_entity_plugin_hook", 0);
/** Register the hook, ensuring entities are serialised first */
-register_plugin_hook("export", "all", "export_entity_plugin_hook", 0);
+elgg_register_plugin_hook_handler("export", "all", "export_entity_plugin_hook", 0);
/** Hook to get certain named bits of volatile data about an entity */
-register_plugin_hook('volatile', 'metadata', 'volatile_data_export_plugin_hook');
+elgg_register_plugin_hook_handler('volatile', 'metadata', 'volatile_data_export_plugin_hook');
/** Hook for rendering a default icon for entities */
-register_plugin_hook('entity:icon:url', 'all', 'default_entity_icon_hook', 1000);
+elgg_register_plugin_hook_handler('entity:icon:url', 'all', 'default_entity_icon_hook', 1000);
/** Register init system event **/
-register_elgg_event_handler('init', 'system', 'entities_init');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'entities_init');
\ No newline at end of file
// See if anyone handles this element, return true if it is.
if ($odd) {
- $handled = trigger_plugin_hook("import", "all", array("element" => $odd), $to_be_serialised);
+ $handled = elgg_trigger_plugin_hook("import", "all", array("element" => $odd), $to_be_serialised);
}
// If not, then see if any of its sub elements are handled
$guid = (int)$guid;
// Trigger a hook to
- $to_be_serialised = trigger_plugin_hook("export", "all", array("guid" => $guid), array());
+ $to_be_serialised = elgg_trigger_plugin_hook("export", "all", array("guid" => $guid), array());
// Sanity check
if ((!is_array($to_be_serialised)) || (count($to_be_serialised) == 0)) {
}
// Register a startup event
-register_elgg_event_handler('init', 'system', 'export_init', 100);
+elgg_register_event_handler('init', 'system', 'export_init', 100);
// Trigger plugin hooks
$params = array('entity' => $entity, 'user' => $user);
- return trigger_plugin_hook('permissions_check', $type, $params, false);
+ return elgg_trigger_plugin_hook('permissions_check', $type, $params, false);
}
/**
}
/** Register the hook */
-register_plugin_hook("import", "all", "import_extender_plugin_hook", 2);
\ No newline at end of file
+elgg_register_plugin_hook_handler("import", "all", "import_extender_plugin_hook", 2);
\ No newline at end of file
// Register a startup event
-register_elgg_event_handler('init', 'system', 'filestore_init', 100);
+elgg_register_event_handler('init', 'system', 'filestore_init', 100);
// Unit testing
-register_plugin_hook('unit_test', 'system', 'filestore_test');
\ No newline at end of file
+elgg_register_plugin_hook_handler('unit_test', 'system', 'filestore_test');
\ No newline at end of file
if ($result != false) {
// Update succeeded, continue
$entity = get_entity($guid);
- if (trigger_elgg_event('update', $entity->type, $entity)) {
+ if (elgg_trigger_event('update', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete();
$result = insert_data($query);
if ($result !== false) {
$entity = get_entity($guid);
- if (trigger_elgg_event('create', $entity->type, $entity)) {
+ if (elgg_trigger_event('create', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete();
$result = add_entity_relationship($user_guid, 'member', $group_guid);
$param = array('group' => get_entity($group_guid), 'user' => get_entity($user_guid));
- trigger_elgg_event('join', 'group', $params);
+ elgg_trigger_event('join', 'group', $params);
return $result;
}
// event needs to be triggered while user is still member of group to have access to group acl
$params = array('group' => get_entity($group_guid), 'user' => get_entity($user_guid));
- trigger_elgg_event('leave', 'group', $params);
+ elgg_trigger_event('leave', 'group', $params);
$result = remove_entity_relationship($user_guid, 'member', $group_guid);
return $result;
}
register_entity_type('group', '');
}
-register_elgg_event_handler('init', 'system', 'group_init');
+elgg_register_event_handler('init', 'system', 'group_init');
* @return mixed The filtered result - everything will be strings
*/
function filter_tags($var) {
- return trigger_plugin_hook('validate', 'input', null, $var);
+ return elgg_trigger_plugin_hook('validate', 'input', null, $var);
}
/**
}
}
-register_elgg_event_handler('init', 'system', 'input_init');
+elgg_register_event_handler('init', 'system', 'input_init');
// Trigger geocode event if not cached
$return = false;
- $return = trigger_plugin_hook('geocode', 'location', array('location' => $location), $return);
+ $return = elgg_trigger_plugin_hook('geocode', 'location', array('location' => $location), $return);
// If returned, cache and return value
if (($return) && (is_array($return))) {
if ($id !== false) {
$obj = get_metadata($id);
- if (trigger_elgg_event('create', 'metadata', $obj)) {
+ if (elgg_trigger_event('create', 'metadata', $obj)) {
return $id;
} else {
delete_metadata($id);
$result = update_data($query);
if ($result !== false) {
$obj = get_metadata($id);
- if (trigger_elgg_event('update', 'metadata', $obj)) {
+ if (elgg_trigger_event('update', 'metadata', $obj)) {
return true;
} else {
delete_metadata($id);
$metabyname_memcache->delete("{$metadata->entity_guid}:{$metadata->name_id}");
}
- if (($metadata->canEdit()) && (trigger_elgg_event('delete', 'metadata', $metadata))) {
+ if (($metadata->canEdit()) && (elgg_trigger_event('delete', 'metadata', $metadata))) {
return delete_data("DELETE from {$CONFIG->dbprefix}metadata where id=$id");
}
}
}
/** Register the hook */
-register_plugin_hook("export", "all", "export_metadata_plugin_hook", 2);
+elgg_register_plugin_hook_handler("export", "all", "export_metadata_plugin_hook", 2);
/** Call a function whenever an entity is updated **/
-register_elgg_event_handler('update', 'all', 'metadata_update');
+elgg_register_event_handler('update', 'all', 'metadata_update');
// unit testing
-register_plugin_hook('unit_test', 'system', 'metadata_test');
+elgg_register_plugin_hook_handler('unit_test', 'system', 'metadata_test');
/**
* Metadata unit test
'params' => $params
);
- $result = trigger_plugin_hook('email', 'system', $mail_params, NULL);
+ $result = elgg_trigger_plugin_hook('email', 'system', $mail_params, NULL);
if ($result !== NULL) {
return $result;
}
// Add settings view to user settings & register action
extend_elgg_settings_page('notifications/settings/usersettings', 'usersettings/user');
- register_plugin_hook('usersettings:save', 'user', 'notification_user_settings_save');
+ elgg_register_plugin_hook_handler('usersettings:save', 'user', 'notification_user_settings_save');
}
/**
// Get config data
global $CONFIG, $SESSION, $NOTIFICATION_HANDLERS;
- $hookresult = trigger_plugin_hook('object:notifications', $object_type, array(
+ $hookresult = elgg_trigger_plugin_hook('object:notifications', $object_type, array(
'event' => $event,
'object_type' => $object_type,
'object' => $object,
if ($user instanceof ElggUser && !$user->isBanned()) {
if (($user->guid != $SESSION['user']->guid) && has_access_to_entity($object, $user)
&& $object->access_id != ACCESS_PRIVATE) {
- $methodstring = trigger_plugin_hook('notify:entity:message', $object->getType(), array(
+ $methodstring = elgg_trigger_plugin_hook('notify:entity:message', $object->getType(), array(
'entity' => $object,
'to_entity' => $user,
'method' => $method), $string);
}
// Register a startup event
-register_elgg_event_handler('init', 'system', 'notification_init', 0);
-register_elgg_event_handler('create', 'object', 'object_notifications');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'notification_init', 0);
+elgg_register_event_handler('create', 'object', 'object_notifications');
\ No newline at end of file
if ($result != false) {
// Update succeeded, continue
$entity = get_entity($guid);
- if (trigger_elgg_event('update', $entity->type, $entity)) {
+ if (elgg_trigger_event('update', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete();
$result = insert_data($query);
if ($result !== false) {
$entity = get_entity($guid);
- if (trigger_elgg_event('create', $entity->type, $entity)) {
+ if (elgg_trigger_event('create', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete();
}
}
-register_elgg_event_handler('init', 'system', 'objects_init', 0);
-register_plugin_hook('unit_test', 'system', 'objects_test');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'objects_init', 0);
+elgg_register_plugin_hook_handler('unit_test', 'system', 'objects_test');
\ No newline at end of file
// return a URL friendly title to short circuit normal title formatting
$params = array('title' => $title);
- $result = trigger_plugin_hook('format', 'friendly:title', $params, NULL);
+ $result = elgg_trigger_plugin_hook('format', 'friendly:title', $params, NULL);
if ($result) {
return $result;
}
// return a time string to short circuit normal time formatting
$params = array('time' => $time);
- $result = trigger_plugin_hook('format', 'friendly:time', $params, NULL);
+ $result = elgg_trigger_plugin_hook('format', 'friendly:time', $params, NULL);
if ($result) {
return $result;
}
$params['original_string'] = $string;
$string = strip_tags($string);
- $string = trigger_plugin_hook('format', 'strip_tags', $params, $string);
+ $string = elgg_trigger_plugin_hook('format', 'strip_tags', $params, $string);
return $string;
}
return $page_owner_guid;
}
- $guid = trigger_plugin_hook('page_owner', 'system', NULL, 0);
+ $guid = elgg_trigger_plugin_hook('page_owner', 'system', NULL, 0);
$page_owner_guid = $guid;
function page_owner_boot() {
global $CONFIG;
- register_plugin_hook('page_owner', 'system', 'default_page_owner_handler');
+ elgg_register_plugin_hook_handler('page_owner', 'system', 'default_page_owner_handler');
// initial context - will be replaced by page handler
$CONFIG->context = array('main');
}
-register_elgg_event_handler('boot', 'system', 'page_owner_boot');
\ No newline at end of file
+elgg_register_event_handler('boot', 'system', 'page_owner_boot');
\ No newline at end of file
//$user->save();
// Hook to validate setting
- $value = trigger_plugin_hook('plugin:usersetting', 'user', array(
+ $value = elgg_trigger_plugin_hook('plugin:usersetting', 'user', array(
'user' => $user,
'plugin' => $plugin_name,
'name' => $name,
if ($name != 'title') {
// Hook to validate setting
- $value = trigger_plugin_hook('plugin:setting', 'plugin', array(
+ $value = elgg_trigger_plugin_hook('plugin:setting', 'plugin', array(
'plugin' => $plugin_name,
'name' => $name,
'value' => $value
// for other plugins that want to hook into this.
$params = array('plugin' => $plugin, 'manifest' => $plugin_info);
- if ($return && !trigger_elgg_event('enable', 'plugin', $params)) {
+ if ($return && !elgg_trigger_event('enable', 'plugin', $params)) {
$return = FALSE;
}
if ($return) {
// for other plugins that want to hook into this.
$params = array('plugin' => $plugin, 'manifest' => $plugin_info);
- if ($return && !trigger_elgg_event('disable', 'plugin', $params)) {
+ if ($return && !elgg_trigger_event('disable', 'plugin', $params)) {
$return = FALSE;
}
}
// Register a startup event
-register_elgg_event_handler('init', 'system', 'plugin_init');
+elgg_register_event_handler('init', 'system', 'plugin_init');
$relationship = get_relationship($id);
- if (trigger_elgg_event('delete', 'relationship', $relationship)) {
+ if (elgg_trigger_event('delete', 'relationship', $relationship)) {
return delete_data("delete from {$CONFIG->dbprefix}entity_relationships where id=$id");
}
if ($result !== false) {
$obj = get_relationship($result);
- if (trigger_elgg_event('create', $relationship, $obj)) {
+ if (elgg_trigger_event('create', $relationship, $obj)) {
return true;
} else {
delete_relationship($result);
return false;
}
- if (trigger_elgg_event('delete', $relationship, $obj)) {
+ if (elgg_trigger_event('delete', $relationship, $obj)) {
$query = "DELETE from {$CONFIG->dbprefix}entity_relationships
where guid_one=$guid_one
and relationship='$relationship'
}
/** Register the import hook */
-register_plugin_hook("import", "all", "import_relationship_plugin_hook", 3);
+elgg_register_plugin_hook_handler("import", "all", "import_relationship_plugin_hook", 3);
/** Register the hook, ensuring entities are serialised first */
-register_plugin_hook("export", "all", "export_relationship_plugin_hook", 3);
+elgg_register_plugin_hook_handler("export", "all", "export_relationship_plugin_hook", 3);
/** Register event to listen to some events **/
-register_elgg_event_handler('create', 'friend', 'relationship_notification_hook');
+elgg_register_event_handler('create', 'friend', 'relationship_notification_hook');
setcookie("elggperm", $code, (time() + (86400 * 30)), "/");
}
- if (!$user->save() || !trigger_elgg_event('login', 'user', $user)) {
+ if (!$user->save() || !elgg_trigger_event('login', 'user', $user)) {
unset($_SESSION['username']);
unset($_SESSION['name']);
unset($_SESSION['code']);
global $CONFIG;
if (isset($_SESSION['user'])) {
- if (!trigger_elgg_event('logout', 'user', $_SESSION['user'])) {
+ if (!elgg_trigger_event('logout', 'user', $_SESSION['user'])) {
return false;
}
$_SESSION['user']->code = "";
return true;
}
-register_elgg_event_handler("boot", "system", "session_init", 20);
+elgg_register_event_handler("boot", "system", "session_init", 20);
if ($result != false) {
// Update succeeded, continue
$entity = get_entity($guid);
- if (trigger_elgg_event('update', $entity->type, $entity)) {
+ if (elgg_trigger_event('update', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete();
if ($result !== false) {
$entity = get_entity($guid);
- if (trigger_elgg_event('create', $entity->type, $entity)) {
+ if (elgg_trigger_event('create', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete();
function sites_boot($event, $object_type, $object) {
global $CONFIG;
- $site = trigger_plugin_hook("siteid", "system");
+ $site = elgg_trigger_plugin_hook("siteid", "system");
if ($site === null || $site === false) {
$CONFIG->site_id = (int) datalist_get('default_site');
} else {
}
// Register event handlers
-register_elgg_event_handler('boot', 'system', 'sites_boot', 2);
+elgg_register_event_handler('boot', 'system', 'sites_boot', 2);
// Register with unit test
-register_plugin_hook('unit_test', 'system', 'sites_test');
+elgg_register_plugin_hook_handler('unit_test', 'system', 'sites_test');
/**
* Unit tests for sites
}
/// Register init function
-register_elgg_event_handler('init', 'system', 'statistics_init');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'statistics_init');
\ No newline at end of file
*/
function system_log_listener($event, $object_type, $object) {
if (($object_type != 'systemlog') && ($event != 'log')) {
- trigger_elgg_event('log', 'systemlog', array('object' => $object, 'event' => $event));
+ elgg_trigger_event('log', 'systemlog', array('object' => $object, 'event' => $event));
}
return true;
}
/** Register event to listen to all events **/
-register_elgg_event_handler('all', 'all', 'system_log_listener', 400);
+elgg_register_event_handler('all', 'all', 'system_log_listener', 400);
/** Register a default system log handler */
-register_elgg_event_handler('log', 'systemlog', 'system_log_default_logger', 999);
\ No newline at end of file
+elgg_register_event_handler('log', 'systemlog', 'system_log_default_logger', 999);
\ No newline at end of file
if ($result != false) {
// Update succeeded, continue
$entity = get_entity($guid);
- if (trigger_elgg_event('update', $entity->type, $entity)) {
+ if (elgg_trigger_event('update', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete();
$result = insert_data($query);
if ($result !== false) {
$entity = get_entity($guid);
- if (trigger_elgg_event('create', $entity->type, $entity)) {
+ if (elgg_trigger_event('create', $entity->type, $entity)) {
return $guid;
} else {
$entity->delete(); //delete_entity($guid);
global $CONFIG;
$owner_guid = (int) $owner_guid;
if ($entity = get_entity($owner_guid)) {
- if (trigger_elgg_event('disable', $entity->type, $entity)) {
+ if (elgg_trigger_event('disable', $entity->type, $entity)) {
if ($entity->canEdit()) {
$query = "UPDATE {$CONFIG->dbprefix}entities
set enabled='no' where owner_guid={$owner_guid}
$user = get_entity($user_guid);
if (($user) && ($user->canEdit()) && ($user instanceof ElggUser)) {
- if (trigger_elgg_event('ban', 'user', $user)) {
+ if (elgg_trigger_event('ban', 'user', $user)) {
// Add reason
if ($reason) {
create_metadata($user_guid, 'ban_reason', $reason, '', 0, ACCESS_PUBLIC);
$user = get_entity($user_guid);
if (($user) && ($user->canEdit()) && ($user instanceof ElggUser)) {
- if (trigger_elgg_event('unban', 'user', $user)) {
+ if (elgg_trigger_event('unban', 'user', $user)) {
create_metadata($user_guid, 'ban_reason', '', '', 0, ACCESS_PUBLIC);
// invalidate memcache for this user
$user = get_entity((int)$user_guid);
if (($user) && ($user instanceof ElggUser) && ($user->canEdit())) {
- if (trigger_elgg_event('make_admin', 'user', $user)) {
+ if (elgg_trigger_event('make_admin', 'user', $user)) {
// invalidate memcache for this user
static $newentity_cache;
$user = get_entity((int)$user_guid);
if (($user) && ($user instanceof ElggUser) && ($user->canEdit())) {
- if (trigger_elgg_event('remove_admin', 'user', $user)) {
+ if (elgg_trigger_event('remove_admin', 'user', $user)) {
// invalidate memcache for this user
static $newentity_cache;
}
$result = true;
- return trigger_plugin_hook('registeruser:validate:username', 'all',
+ return elgg_trigger_plugin_hook('registeruser:validate:username', 'all',
array('username' => $username), $result);
}
}
$result = true;
- return trigger_plugin_hook('registeruser:validate:password', 'all',
+ return elgg_trigger_plugin_hook('registeruser:validate:password', 'all',
array('password' => $password), $result);
}
// Got here, so lets try a hook (defaulting to ok)
$result = true;
- return trigger_plugin_hook('registeruser:validate:email', 'all',
+ return elgg_trigger_plugin_hook('registeruser:validate:email', 'all',
array('email' => $address), $result);
}
// Register the user type
register_entity_type('user', '');
- register_plugin_hook('usersettings:save', 'user', 'users_settings_save');
+ elgg_register_plugin_hook_handler('usersettings:save', 'user', 'users_settings_save');
- register_elgg_event_handler('create', 'user', 'user_create_hook_add_site_relationship');
+ elgg_register_event_handler('create', 'user', 'user_create_hook_add_site_relationship');
}
/**
return $value;
}
-register_elgg_event_handler('init', 'system', 'users_init', 0);
-register_elgg_event_handler('pagesetup', 'system', 'users_pagesetup', 0);
-register_plugin_hook('unit_test', 'system', 'users_test');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'users_init', 0);
+elgg_register_event_handler('pagesetup', 'system', 'users_pagesetup', 0);
+elgg_register_plugin_hook_handler('unit_test', 'system', 'users_test');
\ No newline at end of file
}
/// Register init function
-register_elgg_event_handler('init', 'system', 'usersettings_init');
-register_elgg_event_handler('pagesetup', 'system', 'usersettings_pagesetup');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'usersettings_init');
+elgg_register_event_handler('pagesetup', 'system', 'usersettings_pagesetup');
\ No newline at end of file
$upgrade_details->from = $dbversion;
$upgrade_details->to = get_version();
- trigger_elgg_event('upgrade', 'upgrade', $upgrade_details);
+ elgg_trigger_event('upgrade', 'upgrade', $upgrade_details);
// Update the version
datalist_set('version', get_version());
// Trigger the pagesetup event
if (!isset($CONFIG->pagesetupdone)) {
- trigger_elgg_event('pagesetup', 'system');
+ elgg_trigger_event('pagesetup', 'system');
$CONFIG->pagesetupdone = true;
}
$content = ob_get_clean();
// Plugin hook
- $content = trigger_plugin_hook('view', $view_orig,
+ $content = elgg_trigger_plugin_hook('view', $view_orig,
array('view' => $view_orig, 'vars' => $vars), $content);
// backward compatibility with less grandular hook will be gone in 2.0
$params = array('view' => $view_orig, 'vars' => $vars);
- $content_tmp = trigger_plugin_hook('display', 'view', $params, $content);
+ $content_tmp = elgg_trigger_plugin_hook('display', 'view', $params, $content);
if ($content_tmp != $content) {
$content = $content_tmp;
$entity_type = $entity->getType();
- $annotations = trigger_plugin_hook('entity:annotate', $entity_type,
+ $annotations = elgg_trigger_plugin_hook('entity:annotate', $entity_type,
array(
'entity' => $entity,
'full' => $full,
return false;
}
- $comments = trigger_plugin_hook('comments', $entity->getType(), array('entity' => $entity), false);
+ $comments = elgg_trigger_plugin_hook('comments', $entity->getType(), array('entity' => $entity), false);
if ($comemnts) {
return $comments;
} else {
$vars['page_shell'] = $page_shell;
// Allow plugins to mod output
- return trigger_plugin_hook('output', 'page', $vars, $output);
+ return elgg_trigger_plugin_hook('output', 'page', $vars, $output);
}
/**
elgg_register_js("{$base}vendors/jquery/jquery-ui-1.7.2.min.js", 'jquery-ui');
elgg_register_js("{$base}vendors/jquery/jquery.form.js", 'jquery.form');
- register_elgg_event_handler('pagesetup', 'system', 'elgg_views_register_core_head_elements');
+ elgg_register_event_handler('pagesetup', 'system', 'elgg_views_register_core_head_elements');
// discover the built-in view types
// @todo cache this
}
}
-register_elgg_event_handler('boot', 'system', 'elgg_views_boot', 1000);
\ No newline at end of file
+elgg_register_event_handler('boot', 'system', 'elgg_views_boot', 1000);
\ No newline at end of file
}
// Register event
-register_elgg_event_handler('init', 'system', 'widgets_init');
+elgg_register_event_handler('init', 'system', 'widgets_init');
// Use widgets on the dashboard
use_widgets('dashboard');
\ No newline at end of file
// Trigger boot events for core. Plugins can't hook
// into this because they haven't been loaded yet.
-trigger_elgg_event('boot', 'system');
+elgg_trigger_event('boot', 'system');
// Load the plugins that are active
load_plugins();
-trigger_elgg_event('plugins_boot', 'system');
+elgg_trigger_event('plugins_boot', 'system');
// Trigger system init event for plugins
-trigger_elgg_event('init', 'system');
+elgg_trigger_event('init', 'system');
// Regenerate the simple cache if expired.
// Don't do it on upgrade because upgrade does it itself.
require_once("$test_path/elgg_unit_test.php");
// turn off system log
-unregister_elgg_event_handler('all', 'all', 'system_log_listener');
-unregister_elgg_event_handler('log', 'systemlog', 'system_log_default_logger');
+elgg_unregister_event_handler('all', 'all', 'system_log_listener');
+elgg_unregister_event_handler('log', 'systemlog', 'system_log_default_logger');
// Disable maximum execution time.
// Tests take a while...
$suite = new TestSuite('Elgg Core Unit Tests');
// emit a hook to pull in all tests
-$test_files = trigger_plugin_hook('unit_test', 'system', null, array());
+$test_files = elgg_trigger_plugin_hook('unit_test', 'system', null, array());
foreach ($test_files as $file) {
$suite->addTestFile($file);
}
* Plugin authors: copy this file to your plugin's test directory. Register an Elgg
* plugin hook and function similar to:
*
- * register_plugin_hook('unit_test', 'system', 'my_new_unit_test');
+ * elgg_register_plugin_hook_handler('unit_test', 'system', 'my_new_unit_test');
*
* function my_new_unit_test($hook, $type, $value, $params) {
* $value[] = "path/to/my/unit_test.php";
*/
require_once(dirname(__FILE__) . "/engine/start.php");
-if (!trigger_plugin_hook('index', 'system', null, FALSE)) {
+if (!elgg_trigger_plugin_hook('index', 'system', null, FALSE)) {
if (isloggedin()) {
forward('pg/dashboard/');
}
// install has its own session handling before the db created and set up
session_name('Elgg');
session_start();
- unregister_elgg_event_handler('boot', 'system', 'session_init');
+ elgg_unregister_event_handler('boot', 'system', 'session_init');
}
if ($stepIndex > $dbIndex) {
set_default_config();
- trigger_elgg_event('boot', 'system');
- trigger_elgg_event('init', 'system');
+ elgg_trigger_event('boot', 'system');
+ elgg_trigger_event('init', 'system');
}
}
elgg_extend_view('css', 'blog/css');
- register_elgg_event_handler('pagesetup', 'system', 'blog_page_setup');
+ elgg_register_event_handler('pagesetup', 'system', 'blog_page_setup');
register_page_handler('blog', 'blog_page_handler');
register_entity_url_handler('blog_url_handler', 'object', 'blog');
// notifications
register_notification_object('object', 'blog', elgg_echo('blog:newpost'));
- register_plugin_hook('notify:entity:message', 'object', 'blog_notify_message');
+ elgg_register_plugin_hook_handler('notify:entity:message', 'object', 'blog_notify_message');
// pingbacks
- //register_elgg_event_handler('create', 'object', 'blog_incoming_ping');
- //register_plugin_hook('pingback:object:subtypes', 'object', 'blog_pingback_subtypes');
+ //elgg_register_event_handler('create', 'object', 'blog_incoming_ping');
+ //elgg_register_plugin_hook_handler('pingback:object:subtypes', 'object', 'blog_pingback_subtypes');
// Register for search.
register_entity_type('object', 'blog');
register_action('blog/delete', FALSE, "$action_path/delete.php");
// ecml
- register_plugin_hook('get_views', 'ecml', 'blog_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'blog_ecml_views_hook');
// Register profile menu hook
- register_plugin_hook('profile_menu', 'profile', 'blog_profile_menu');
+ elgg_register_plugin_hook_handler('profile_menu', 'profile', 'blog_profile_menu');
}
/**
return $return_value;
}
-register_elgg_event_handler('init', 'system', 'blog_init');
+elgg_register_event_handler('init', 'system', 'blog_init');
}
// Listen to notification events and supply a more useful message
- register_plugin_hook('notify:entity:message', 'object', 'bookmarks_notify_message');
+ elgg_register_plugin_hook_handler('notify:entity:message', 'object', 'bookmarks_notify_message');
// Register a URL handler for shared items
register_entity_url_handler('bookmark_url','object','bookmarks');
elgg_extend_view('groups/tool_latest','bookmarks/group_bookmarks');
// Register profile menu hook
- register_plugin_hook('profile_menu', 'profile', 'bookmarks_profile_menu');
+ elgg_register_plugin_hook_handler('profile_menu', 'profile', 'bookmarks_profile_menu');
}
/**
}
// Make sure the initialisation function is called on initialisation
-register_elgg_event_handler('init','system','bookmarks_init');
-register_elgg_event_handler('pagesetup','system','bookmarks_pagesetup');
+elgg_register_event_handler('init','system','bookmarks_init');
+elgg_register_event_handler('pagesetup','system','bookmarks_pagesetup');
// Register actions
global $CONFIG;
$CONFIG->captcha_length = 5;
// Register a function that provides some default override actions
- register_plugin_hook('actionlist', 'captcha', 'captcha_actionlist_hook');
+ elgg_register_plugin_hook_handler('actionlist', 'captcha', 'captcha_actionlist_hook');
// Register actions to intercept
$actions = array();
- $actions = trigger_plugin_hook('actionlist', 'captcha', NULL, $actions);
+ $actions = elgg_trigger_plugin_hook('actionlist', 'captcha', NULL, $actions);
if (($actions) && (is_array($actions))) {
foreach ($actions as $action) {
- register_plugin_hook("action", $action, "captcha_verify_action_hook");
+ elgg_register_plugin_hook_handler("action", $action, "captcha_verify_action_hook");
}
}
}
return $returnvalue;
}
-register_elgg_event_handler('init', 'system', 'captcha_init');
+elgg_register_event_handler('init', 'system', 'captcha_init');
register_page_handler('categories', 'categories_page_handler');
- register_elgg_event_handler('update','all','categories_save');
- register_elgg_event_handler('create','all','categories_save');
+ elgg_register_event_handler('update','all','categories_save');
+ elgg_register_event_handler('create','all','categories_save');
}
elgg_delete_admin_notice('categories_admin_notice_no_categories');
}
-register_elgg_event_handler('init','system','categories_init');
\ No newline at end of file
+elgg_register_event_handler('init','system','categories_init');
\ No newline at end of file
*/
function crontrigger_init()
{
- register_elgg_event_handler('shutdown', 'system', 'crontrigger_shutdownhook');
+ elgg_register_event_handler('shutdown', 'system', 'crontrigger_shutdownhook');
}
- function crontrigger_trigger($period) { trigger_plugin_hook('cron', $period); }
+ function crontrigger_trigger($period) { elgg_trigger_plugin_hook('cron', $period); }
function crontrigger_minute() { crontrigger_trigger('minute'); }
// Initialise plugin
- register_elgg_event_handler('init','system','crontrigger_init');
+ elgg_register_event_handler('init','system','crontrigger_init');
?>
\ No newline at end of file
* Elgg default_widgets plugin.
*
* @package DefaultWidgets
- *
+ *
* Code based on the work of:
* @link http://www.tastyseed.com
* @link http://www.chadsowald.com
* @links http://www.somosmas.org
- *
+ *
*/
global $CONFIG;
* Default widgets initialisation
*
* These parameters are required for the event API, but we won't use them:
- *
+ *
* @param unknown_type $event
* @param unknown_type $object_type
* @param unknown_type $object
function defaultwidgets_init() {
// register create user event hook
register_elgg_event_handler ( 'create', 'user', 'defaultwidgets_newusers' );
-
+
// set the widget access to the default access on validation if this is not an admin-created user
if (!isadminloggedin()) {
- register_elgg_event_handler('validate', 'user', 'defaultwidgets_reset_access');
+ elgg_register_event_handler('validate', 'user', 'defaultwidgets_reset_access');
}
-
+
// @todo These submenu pages should be DRYed up
elgg_add_admin_submenu_item('default_profile_widgets', elgg_echo('defaultwidgets:menu:profile'), 'appearance');
elgg_add_admin_submenu_item('default_dashboard_widgets', elgg_echo('defaultwidgets:menu:dashboard'), 'appearance');
/**
* Overrides default permissions for the default widgets context
- *
+ *
*/
function defaultwidgets_can_edit($hook_name, $entity_type, $return_value, $parameters) {
global $defaultwidget_access;
-
+
if ($defaultwidget_access) {
return true;
}
*/
function defaultwidgets_can_edit_metadata($hook_name, $entity_type, $return_value, $parameters) {
global $defaultwidget_access;
-
+
if ($defaultwidget_access) {
return true;
}
*/
function defaultwidgets_can_edit_container($hook_name, $entity_type, $return_value, $parameters) {
global $defaultwidget_access;
-
+
if ($defaultwidget_access) {
return true;
}
* Extends the create user event to add admin defined widgets to the dashboard/profile context
*/
function defaultwidgets_newusers($event, $object_type, $object) {
-
+
// turn on permissions override
global $defaultwidget_access, $CONFIG;
$defaultwidget_access = true;
-
+
// get the new user guid
$guid = $object->guid;
-
+
if (isadminloggedin()) {
// this is an admin-created user
// no permissions problems, so set proper access now
// to avoid Elgg permissions problems
$widget_access = ACCESS_PUBLIC;
}
-
+
// check if it's set
if (! empty ( $guid )) {
-
+
// get the user entity
if ($user = get_entity ( $guid )) {
-
+
// can this user edit
if ($user->canEdit ()) {
-
+
// each of the contexts to add widgets for
$contexts = array ('profile', 'dashboard' );
-
+
// get the entities for the module
$entities = elgg_get_entities (array('type' => 'object', 'subtype' => 'moddefaultwidgets', 'limit' => 9999));
-
+
// check if the entity exists
if (isset ( $entities [0] )) {
-
+
// get the widgets for the context
$entity = $entities [0];
-
+
foreach ( $contexts as $context ) {
$current_widgets = $entity->$context;
list ( $left, $middle, $right ) = split ( '%%', $current_widgets );
-
+
// split columns into seperate widgets
$area1widgets = split ( '::', $left );
$area2widgets = split ( '::', $middle );
$area3widgets = split ( '::', $right );
-
+
// clear out variables if no widgets are available
if ($area1widgets [0] == "")
$area1widgets = false;
$area2widgets = false;
if ($area3widgets [0] == "")
$area3widgets = false;
-
- // generate left column widgets for a new user
+
+ // generate left column widgets for a new user
if ($area1widgets) {
foreach ( $area1widgets as $i => $widget ) {
add_widget ( $guid, $widget, $context, ($i + 1), 1, $widget_access );
}
}
-
+
// generate middle column widgets for a new user
if ($area2widgets) {
foreach ( $area2widgets as $i => $widget ) {
add_widget ( $guid, $widget, $context, ($i + 1), 2, $widget_access );
}
}
-
+
// generate right column widgets for a new user
if ($area3widgets) {
foreach ( $area3widgets as $i => $widget ) {
}
}
}
-
+
// turn off permissions override
$defaultwidget_access = false;
}
function defaultwidgets_reset_access($event, $object_type, $object) {
-
+
global $defaultwidget_access;
-
+
// turn on permissions override
$defaultwidget_access = true;
-
+
// the widgets are disabled, so turn on the ability to see disabled entities
-
+
$access_status = access_get_show_hidden_status();
access_show_hidden_entities(true);
-
+
$widgets = elgg_get_entities(array('type' => 'object', 'subtype' => 'widget', 'owner_guid' => $object->getGUID()));
-
+
if ($widgets) {
foreach($widgets as $widget) {
$widget->access_id = get_default_access();
$widget->save();
}
}
-
+
access_show_hidden_entities($access_status);
-
+
// turn off permissions override
$defaultwidget_access = false;
-
+
return true;
}
// Make sure the status initialisation function is called on initialisation
-register_elgg_event_handler ( 'init', 'system', 'defaultwidgets_init' );
+elgg_register_event_handler('init', 'system', 'defaultwidgets_init');
-register_plugin_hook ( 'permissions_check', 'user', 'defaultwidgets_can_edit' );
-register_plugin_hook ( 'permissions_check', 'object', 'defaultwidgets_can_edit' );
-register_plugin_hook ( 'container_permissions_check', 'user', 'defaultwidgets_can_edit_container' );
+elgg_register_plugin_hook_handler('permissions_check', 'user', 'defaultwidgets_can_edit');
+elgg_register_plugin_hook_handler('permissions_check', 'object', 'defaultwidgets_can_edit');
+elgg_register_plugin_hook_handler('container_permissions_check', 'user', 'defaultwidgets_can_edit_container');
-register_action ( "defaultwidgets/update", false, $CONFIG->pluginspath . "defaultwidgets/actions/update.php" );
+register_action("defaultwidgets/update", false, $CONFIG->pluginspath . "defaultwidgets/actions/update.php");
admin_gatekeeper();
$output = elgg_echo('diagnostics:header', array(date('r'), get_loggedin_user()->name));
- $output = trigger_plugin_hook('diagnostics:report', 'system', null, $output);
+ $output = elgg_trigger_plugin_hook('diagnostics:report', 'system', null, $output);
header("Cache-Control: public");
header("Content-Description: File Transfer");
}
// Initialise log browser
-register_elgg_event_handler('init','system','diagnostics_init');
-register_elgg_event_handler('pagesetup','system','diagnostics_pagesetup');
+elgg_register_event_handler('init','system','diagnostics_init');
+elgg_register_event_handler('pagesetup','system','diagnostics_pagesetup');
-register_plugin_hook("diagnostics:report", "system", "diagnostics_basic_hook", 0); // show basics first
-register_plugin_hook("diagnostics:report", "system", "diagnostics_plugins_hook", 2); // Now the plugins
-register_plugin_hook("diagnostics:report", "system", "diagnostics_sigs_hook", 1); // Now the signatures
+elgg_register_plugin_hook_handler("diagnostics:report", "system", "diagnostics_basic_hook", 0); // show basics first
+elgg_register_plugin_hook_handler("diagnostics:report", "system", "diagnostics_plugins_hook", 2); // Now the plugins
+elgg_register_plugin_hook_handler("diagnostics:report", "system", "diagnostics_sigs_hook", 1); // Now the signatures
-register_plugin_hook("diagnostics:report", "system", "diagnostics_globals_hook"); // Global variables
-register_plugin_hook("diagnostics:report", "system", "diagnostics_phpinfo_hook"); // PHP info
+elgg_register_plugin_hook_handler("diagnostics:report", "system", "diagnostics_globals_hook"); // Global variables
+elgg_register_plugin_hook_handler("diagnostics:report", "system", "diagnostics_phpinfo_hook"); // PHP info
?>
\ No newline at end of file
return $CONFIG->ecml_keywords;
}
- $keywords = trigger_plugin_hook('get_keywords', 'ecml', NULL, array());
+ $keywords = elgg_trigger_plugin_hook('get_keywords', 'ecml', NULL, array());
$CONFIG->ecml_keywords = $keywords;
return $keywords;
}
//elgg_extend_view('input/text', 'ecml/input_ext');
// add parsing for core views.
- register_plugin_hook('get_views', 'ecml', 'ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'ecml_views_hook');
// get register the views we want to parse for ecml
// @todo will need to do profiling to see if it would be faster
// to foreach through this list and register to specific views or
// do the check in a single plugin hook.
// Wants array('view_name' => 'Short Description')
- $CONFIG->ecml_parse_views = trigger_plugin_hook('get_views', 'ecml', NULL, array());
+ $CONFIG->ecml_parse_views = elgg_trigger_plugin_hook('get_views', 'ecml', NULL, array());
foreach ($CONFIG->ecml_parse_views as $view => $desc) {
- register_plugin_hook('view', $view, 'ecml_parse_view');
+ elgg_register_plugin_hook_handler('view', $view, 'ecml_parse_view');
}
// provide a few built-in ecml keywords.
// @todo could pull this out into an array here to save an API call.
- register_plugin_hook('get_keywords', 'ecml', 'ecml_keyword_hook');
+ elgg_register_plugin_hook_handler('get_keywords', 'ecml', 'ecml_keyword_hook');
// grab the list of keywords and their views from plugins
- $CONFIG->ecml_keywords = trigger_plugin_hook('get_keywords', 'ecml', NULL, array());
+ $CONFIG->ecml_keywords = elgg_trigger_plugin_hook('get_keywords', 'ecml', NULL, array());
// grab permissions for specific views/contexts
// this is a black list.
$CONFIG->ecml_permissions = unserialize(get_plugin_setting('ecml_permissions', 'ecml'));
// 3rd party media embed section
- register_plugin_hook('embed_get_sections', 'all', 'ecml_embed_web_services_hook');
+ elgg_register_plugin_hook_handler('embed_get_sections', 'all', 'ecml_embed_web_services_hook');
// remove ecml when stripping tags
- register_plugin_hook('format', 'strip_tags', 'ecml_strip_tags');
+ elgg_register_plugin_hook_handler('format', 'strip_tags', 'ecml_strip_tags');
}
/**
}
// be sure to run after other plugins
-register_elgg_event_handler('init', 'system', 'ecml_init', 9999);
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'ecml_init', 9999);
\ No newline at end of file
// default to embed/listing | item if not found.
// @todo trigger for all right now. If we categorize these later we can trigger
// for certain categories.
- $sections = trigger_plugin_hook('embed_get_sections', 'all', NULL, array());
- $upload_sections = trigger_plugin_hook('embed_get_upload_sections', 'all', NULL, array());
+ $sections = elgg_trigger_plugin_hook('embed_get_sections', 'all', NULL, array());
+ $upload_sections = elgg_trigger_plugin_hook('embed_get_upload_sections', 'all', NULL, array());
elgg_sort_3d_array_by_value($sections, 'name');
elgg_sort_3d_array_by_value($upload_sections, 'name');
exit;
}
-register_elgg_event_handler('init', 'system', 'embed_init');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'embed_init');
\ No newline at end of file
if ($section_content = elgg_view("embed/$active_section/content", $params)) {
// handles its own pagination
$content .= $section_content;
- } elseif ($embed_info = trigger_plugin_hook('embed_get_items', $active_section, $params, array('items' => array(), 'count' => 0))) {
+ } elseif ($embed_info = elgg_trigger_plugin_hook('embed_get_items', $active_section, $params, array('items' => array(), 'count' => 0))) {
// check if we have an override for this section type.
$view = "embed/$active_section/item/$layout";
}
// Listen to notification events and supply a more useful message
- register_plugin_hook('notify:entity:message', 'object', 'file_notify_message');
+ elgg_register_plugin_hook_handler('notify:entity:message', 'object', 'file_notify_message');
// add the group files tool option
add_group_tool_option('file',elgg_echo('groups:enablefiles'),true);
register_entity_type('object','file');
// embed support
- register_plugin_hook('embed_get_sections', 'all', 'file_embed_get_sections');
- register_plugin_hook('embed_get_items', 'file', 'file_embed_get_items');
- register_plugin_hook('embed_get_upload_sections', 'all', 'file_embed_get_upload_sections');
+ elgg_register_plugin_hook_handler('embed_get_sections', 'all', 'file_embed_get_sections');
+ elgg_register_plugin_hook_handler('embed_get_items', 'file', 'file_embed_get_items');
+ elgg_register_plugin_hook_handler('embed_get_upload_sections', 'all', 'file_embed_get_upload_sections');
}
}
// Make sure test_init is called on initialisation
- register_elgg_event_handler('init','system','file_init');
- register_elgg_event_handler('pagesetup','system','file_submenus');
+ elgg_register_event_handler('init','system','file_init');
+ elgg_register_event_handler('pagesetup','system','file_submenus');
// Register actions
register_action("file/upload", false, $CONFIG->pluginspath . "file/actions/upload.php");
add_widget_type('friends', elgg_echo("friends"), elgg_echo('friends:widget:description'));
}
-register_elgg_event_handler('init', 'system', 'friends_init');
+elgg_register_event_handler('init', 'system', 'friends_init');
}
// Register cron hook
- register_plugin_hook('cron', $period, 'garbagecollector_cron');
+ elgg_register_plugin_hook_handler('cron', $period, 'garbagecollector_cron');
}
/**
// Now, because we are nice, trigger a plugin hook to let other plugins do some GC
$rv = true;
$period = get_plugin_setting('period','garbagecollector');
- trigger_plugin_hook('gc', 'system', array('period' => $period));
+ elgg_trigger_plugin_hook('gc', 'system', array('period' => $period));
// Now we optimize all tables
$tables = get_db_tables();
}
// Initialise plugin
- register_elgg_event_handler('init','system','garbagecollector_init');
+ elgg_register_event_handler('init','system','garbagecollector_init');
?>
\ No newline at end of file
elgg_extend_view('css','groups/css');
// Access permissions
- register_plugin_hook('access:collections:write', 'all', 'groups_write_acl_plugin_hook');
- //register_plugin_hook('access:collections:read', 'all', 'groups_read_acl_plugin_hook');
+ elgg_register_plugin_hook_handler('access:collections:write', 'all', 'groups_write_acl_plugin_hook');
+ //elgg_register_plugin_hook_handler('access:collections:read', 'all', 'groups_read_acl_plugin_hook');
// Notification hooks
if (is_callable('register_notification_object'))
register_notification_object('object', 'groupforumtopic', elgg_echo('groupforumtopic:new'));
- register_plugin_hook('object:notifications','object','group_object_notifications_intercept');
+ elgg_register_plugin_hook_handler('object:notifications','object','group_object_notifications_intercept');
// Listen to notification events and supply a more useful message
- register_plugin_hook('notify:entity:message', 'object', 'groupforumtopic_notify_message');
+ elgg_register_plugin_hook_handler('notify:entity:message', 'object', 'groupforumtopic_notify_message');
// add the forum tool option
add_group_tool_option('forum',elgg_echo('groups:enableforum'),true);
// Now override icons
- register_plugin_hook('entity:icon:url', 'group', 'groups_groupicon_hook');
+ elgg_register_plugin_hook_handler('entity:icon:url', 'group', 'groups_groupicon_hook');
// Register profile menu hook
- register_plugin_hook('profile_menu', 'profile', 'forum_profile_menu');
- register_plugin_hook('profile_menu', 'profile', 'activity_profile_menu');
+ elgg_register_plugin_hook_handler('profile_menu', 'profile', 'forum_profile_menu');
+ elgg_register_plugin_hook_handler('profile_menu', 'profile', 'activity_profile_menu');
// allow ecml in discussion and profiles
- register_plugin_hook('get_views', 'ecml', 'groups_ecml_views_hook');
- register_plugin_hook('get_views', 'ecml', 'groupprofile_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'groups_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'groupprofile_ecml_views_hook');
}
//'website' => 'url',
);
- $CONFIG->group = trigger_plugin_hook('profile:fields', 'group', NULL, $profile_defaults);
+ $CONFIG->group = elgg_trigger_plugin_hook('profile:fields', 'group', NULL, $profile_defaults);
// register any tag metadata names
foreach ($CONFIG->group as $name => $type) {
register_extender_url_handler('group_topicpost_url','annotation', 'group_topic_post');
// Register a handler for create groups
- register_elgg_event_handler('create', 'group', 'groups_create_event_listener');
+ elgg_register_event_handler('create', 'group', 'groups_create_event_listener');
// Register a handler for delete groups
- register_elgg_event_handler('delete', 'group', 'groups_delete_event_listener');
+ elgg_register_event_handler('delete', 'group', 'groups_delete_event_listener');
// Make sure the groups initialisation function is called on initialisation
- register_elgg_event_handler('init','system','groups_init');
- register_elgg_event_handler('init','system','groups_fields_setup', 10000); // Ensure this runs after other plugins
- register_elgg_event_handler('join','group','groups_user_join_event_listener');
- register_elgg_event_handler('leave','group','groups_user_leave_event_listener');
- register_elgg_event_handler('pagesetup','system','groups_submenus');
- register_elgg_event_handler('annotate','all','group_object_notifications');
+ elgg_register_event_handler('init','system','groups_init');
+ elgg_register_event_handler('init','system','groups_fields_setup', 10000); // Ensure this runs after other plugins
+ elgg_register_event_handler('join','group','groups_user_join_event_listener');
+ elgg_register_event_handler('leave','group','groups_user_leave_event_listener');
+ elgg_register_event_handler('pagesetup','system','groups_submenus');
+ elgg_register_event_handler('annotate','all','group_object_notifications');
// Register actions
global $CONFIG;
//. 'style:color,cursor,text-align,font-size,font-weight,font-style,border,margin,padding,float'
);
- register_plugin_hook('validate', 'input', 'htmlawed_filter_tags', 1);
+ elgg_register_plugin_hook_handler('validate', 'input', 'htmlawed_filter_tags', 1);
}
/**
if ($string = trim($string)) {
$string = " $string";
}
-
+
$r = "<$element$string>";
return $r;
}
$return = "";
$return = htmLawed($var, $htmlawed_config);
} else {
-
+
array_walk_recursive($var, 'htmLawedArray', $htmlawed_config);
$return = $var;
-register_elgg_event_handler('init', 'system', 'htmlawed_init');
+elgg_register_event_handler('init', 'system', 'htmlawed_init');
}
register_action('invitefriends/invite', false, $CONFIG->pluginspath . 'invitefriends/actions/invite.php');
-register_elgg_event_handler('pagesetup', 'system', 'invitefriends_pagesetup');
+elgg_register_event_handler('pagesetup', 'system', 'invitefriends_pagesetup');
}
// Initialise log browser
-register_elgg_event_handler('init','system','logbrowser_init');
+elgg_register_event_handler('init','system','logbrowser_init');
}
// Register cron hook
- register_plugin_hook('cron', $period, 'logrotate_cron');
+ elgg_register_plugin_hook_handler('cron', $period, 'logrotate_cron');
}
/**
}
// Initialise plugin
- register_elgg_event_handler('init','system','logrotate_init');
+ elgg_register_event_handler('init','system','logrotate_init');
?>
\ No newline at end of file
$options['type'] = "user";
$options['offset'] = $offset;
$options['limit'] = $limit;
- $results = trigger_plugin_hook('search', 'tags', $options, array());
+ $results = elgg_trigger_plugin_hook('search', 'tags', $options, array());
$count = $results['count'];
$users = $results['entities'];
$filter_content = elgg_view_entity_list($users, $count, $offset, $limit, false, false, true);
}
// @todo - use page handler for members index
-register_elgg_event_handler('pagesetup','system','members_pagesetup');
-register_elgg_event_handler('init','system','members_init');
\ No newline at end of file
+elgg_register_event_handler('pagesetup','system','members_pagesetup');
+elgg_register_event_handler('init','system','members_init');
\ No newline at end of file
// Register initialisation callback
-register_elgg_event_handler('init', 'system', 'messageboard_init');
+elgg_register_event_handler('init', 'system', 'messageboard_init');
// Register actions
register_action("messageboard/add", FALSE, $CONFIG->pluginspath . "messageboard/actions/add.php");
// Register a notification handler for site messages
register_notification_handler("site", "messages_site_notify_handler");
- register_plugin_hook('notify:entity:message','object','messages_notification_msg');
+ elgg_register_plugin_hook_handler('notify:entity:message','object','messages_notification_msg');
register_notification_object('object','messages',elgg_echo('messages:new'));
// Override metadata permissions
- register_plugin_hook('permissions_check:metadata','object','messages_can_edit_metadata');
+ elgg_register_plugin_hook_handler('permissions_check:metadata','object','messages_can_edit_metadata');
// ecml
- register_plugin_hook('get_views', 'ecml', 'messages_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'messages_ecml_views_hook');
}
// Make sure the messages initialisation function is called on initialisation
-register_elgg_event_handler('init','system','messages_init');
+elgg_register_event_handler('init','system','messages_init');
-register_plugin_hook('permissions_check','object','messages_can_edit');
-register_plugin_hook('container_permissions_check','object','messages_can_edit_container');
+elgg_register_plugin_hook_handler('permissions_check','object','messages_can_edit');
+elgg_register_plugin_hook_handler('container_permissions_check','object','messages_can_edit_container');
// Register actions
global $CONFIG;
register_page_handler('notifications', 'notifications_page_handler');
- register_elgg_event_handler('pagesetup', 'system', 'notifications_plugin_pagesetup');
+ elgg_register_event_handler('pagesetup', 'system', 'notifications_plugin_pagesetup');
// Unset the default notification settings
- unregister_plugin_hook('usersettings:save', 'user', 'notification_user_settings_save');
+ elgg_unregister_plugin_hook_handler('usersettings:save', 'user', 'notification_user_settings_save');
elgg_unextend_view('usersettings/user', 'notifications/settings/usersettings');
// update notifications based on relationships changing
- register_elgg_event_handler('delete', 'member', 'notifications_relationship_remove');
- register_elgg_event_handler('delete', 'friend', 'notifications_relationship_remove');
+ elgg_register_event_handler('delete', 'member', 'notifications_relationship_remove');
+ elgg_register_event_handler('delete', 'friend', 'notifications_relationship_remove');
// update notifications when new friend or access collection membership
- register_elgg_event_handler('create', 'friend', 'notifications_update_friend_notify');
- register_plugin_hook('access:collections:add_user', 'collection', 'notifications_update_collection_notify');
+ elgg_register_event_handler('create', 'friend', 'notifications_update_friend_notify');
+ elgg_register_plugin_hook_handler('access:collections:add_user', 'collection', 'notifications_update_collection_notify');
}
/**
}
}
-register_elgg_event_handler('init', 'system', 'notifications_plugin_init', 1000);
+elgg_register_event_handler('init', 'system', 'notifications_plugin_init', 1000);
register_action("notificationsettings/save", FALSE, $CONFIG->pluginspath . "notifications/actions/save.php");
}
// Listen to notification events and supply a more useful message
- register_plugin_hook('notify:entity:message', 'object', 'page_notify_message');
+ elgg_register_plugin_hook_handler('notify:entity:message', 'object', 'page_notify_message');
// add the group pages tool option
add_group_tool_option('pages',elgg_echo('groups:enablepages'),true);
);
// register ecml views to parse
- register_plugin_hook('get_views', 'ecml', 'pages_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'pages_ecml_views_hook');
}
function pages_url($entity) {
}
// write permission plugin hooks
-register_plugin_hook('permissions_check', 'object', 'pages_write_permission_check');
-register_plugin_hook('container_permissions_check', 'object', 'pages_container_permission_check');
+elgg_register_plugin_hook_handler('permissions_check', 'object', 'pages_write_permission_check');
+elgg_register_plugin_hook_handler('container_permissions_check', 'object', 'pages_container_permission_check');
// Make sure the pages initialisation function is called on initialisation
-register_elgg_event_handler('init','system','pages_init');
-register_elgg_event_handler('pagesetup','system','pages_submenus');
\ No newline at end of file
+elgg_register_event_handler('init','system','pages_init');
+elgg_register_event_handler('pagesetup','system','pages_submenus');
\ No newline at end of file
$profile_owner->save();
// Notify of profile update
- trigger_elgg_event('profileupdate',$user->type,$user);
+ elgg_trigger_event('profileupdate',$user->type,$user);
//add to river if edited by self
if (get_loggedin_userid() == $user->guid) {
}
$profile_owner->icontime = time();
-if (trigger_elgg_event('profileiconupdate', $profile_owner->type, $profile_owner)) {
+if (elgg_trigger_event('profileiconupdate', $profile_owner->type, $profile_owner)) {
// pull this out into the river plugin.
//add_to_river('river/user/default/profileiconupdate','update',$user->guid,$user->guid);
system_message(elgg_echo("profile:icon:uploaded"));
elgg_extend_view('js/initialise_elgg', 'profile/javascript');
// Now override icons
- register_plugin_hook('entity:icon:url', 'user', 'profile_usericon_hook');
+ elgg_register_plugin_hook_handler('entity:icon:url', 'user', 'profile_usericon_hook');
// allow ECML in parts of the profile
- register_plugin_hook('get_views', 'ecml', 'profile_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'profile_ecml_views_hook');
// default profile fields admin item
elgg_add_admin_submenu_item('defaultprofile', elgg_echo('profile:edit:default'), 'appearance');
$profile_defaults = $loaded_defaults;
}
- $CONFIG->profile = trigger_plugin_hook('profile:fields', 'profile', NULL, $profile_defaults);
+ $CONFIG->profile = elgg_trigger_plugin_hook('profile:fields', 'profile', NULL, $profile_defaults);
// register any tag metadata names
foreach ($CONFIG->profile as $name => $type) {
}
// Make sure the profile initialisation function is called on initialisation
-register_elgg_event_handler('init','system','profile_init',1);
-register_elgg_event_handler('init','system','profile_fields_setup', 10000); // Ensure this runs after other plugins
+elgg_register_event_handler('init','system','profile_init',1);
+elgg_register_event_handler('init','system','profile_fields_setup', 10000); // Ensure this runs after other plugins
-register_elgg_event_handler('pagesetup','system','profile_pagesetup');
-register_elgg_event_handler('profileupdate','all','object_notifications');
+elgg_register_event_handler('pagesetup','system','profile_pagesetup');
+elgg_register_event_handler('profileupdate','all','object_notifications');
// Register actions
$report->access_id = $access;
if ($report->save()) {
- if (!trigger_plugin_hook('reportedcontent:add', 'system', array('report'=>$report), true)) {
+ if (!elgg_trigger_plugin_hook('reportedcontent:add', 'system', array('report'=>$report), true)) {
$report->delete();
register_error(elgg_echo('reportedcontent:failed'));
} else {
$report = get_entity($guid);
if ($report->getSubtype() == "reported_content" && $report->canEdit()) {
// change the state
- if (!trigger_plugin_hook('reportedcontent:archive', 'system', array('report'=>$report), TRUE)) {
+ if (!elgg_trigger_plugin_hook('reportedcontent:archive', 'system', array('report'=>$report), TRUE)) {
system_message(elgg_echo("reportedcontent:notarchived"));
forward('pg/admin/reportedcontent');
}
$report = get_entity($guid);
if ($report->getSubtype() == "reported_content" && $report->canEdit()) {
// Delete it!
- if (!trigger_plugin_hook('reportedcontent:delete', '$system', array('report'=>$report), true)) {
+ if (!elgg_trigger_plugin_hook('reportedcontent:delete', '$system', array('report'=>$report), true)) {
register_error(elgg_echo("reportedcontent:notdeleted"));
forward('pg/admin/reportedcontent');
}
}
// Initialise Reported Content
-register_elgg_event_handler('init','system','reportedcontent_init');
+elgg_register_event_handler('init','system','reportedcontent_init');
// add an activity stream ECML keyword
// we'll restrict it to use in sitepages's custom_frontpage
- register_plugin_hook('get_keywords', 'ecml', 'riverdashboard_ecml_keywords_hook');
+ elgg_register_plugin_hook_handler('get_keywords', 'ecml', 'riverdashboard_ecml_keywords_hook');
- register_plugin_hook('get_views', 'ecml', 'riverdashboard_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'riverdashboard_ecml_views_hook');
}
/**
return $return_value;
}
-register_elgg_event_handler('init', 'system', 'riverdashboard_init');
+elgg_register_event_handler('init', 'system', 'riverdashboard_init');
);
$types = get_registered_entity_types();
-$custom_types = trigger_plugin_hook('search_types', 'get_types', $params, array());
+$custom_types = elgg_trigger_plugin_hook('search_types', 'get_types', $params, array());
// add submenu items for all and native types
// @todo should these maintain any existing type / subtype filters or reset?
$current_params['subtype'] = $subtype;
$current_params['type'] = $type;
- $results = trigger_plugin_hook('search', "$type:$subtype", $current_params, NULL);
+ $results = elgg_trigger_plugin_hook('search', "$type:$subtype", $current_params, NULL);
if ($results === FALSE) {
// someone is saying not to display these types in searches.
continue;
// no results and not hooked. use default type search.
// don't change the params here, since it's really a different subtype.
// Will be passed to elgg_get_entities().
- $results = trigger_plugin_hook('search', $type, $current_params, array());
+ $results = elgg_trigger_plugin_hook('search', $type, $current_params, array());
}
if (is_array($results['entities']) && $results['count']) {
$current_params['type'] = $type;
$current_params['subtype'] = ELGG_ENTITIES_NO_VALUE;
- $results = trigger_plugin_hook('search', $type, $current_params, array());
+ $results = elgg_trigger_plugin_hook('search', $type, $current_params, array());
if ($results === FALSE) {
// someone is saying not to display these types in searches.
continue;
// custom search types have no subtype.
unset($current_params['subtype']);
- $results = trigger_plugin_hook('search', $type, $current_params, array());
+ $results = elgg_trigger_plugin_hook('search', $type, $current_params, array());
if ($results === FALSE) {
// someone is saying not to display these types in searches.
register_page_handler('search','search_page_handler');
// register some default search hooks
- register_plugin_hook('search', 'object', 'search_objects_hook');
- register_plugin_hook('search', 'user', 'search_users_hook');
+ elgg_register_plugin_hook_handler('search', 'object', 'search_objects_hook');
+ elgg_register_plugin_hook_handler('search', 'user', 'search_users_hook');
// @todo pull this out into groups
- register_plugin_hook('search', 'group', 'search_groups_hook');
+ elgg_register_plugin_hook_handler('search', 'group', 'search_groups_hook');
// tags and comments are a bit different.
// register a search types and a hooks for them.
- register_plugin_hook('search_types', 'get_types', 'search_custom_types_tags_hook');
- register_plugin_hook('search', 'tags', 'search_tags_hook');
+ elgg_register_plugin_hook_handler('search_types', 'get_types', 'search_custom_types_tags_hook');
+ elgg_register_plugin_hook_handler('search', 'tags', 'search_tags_hook');
- register_plugin_hook('search_types', 'get_types', 'search_custom_types_comments_hook');
- register_plugin_hook('search', 'comments', 'search_comments_hook');
+ elgg_register_plugin_hook_handler('search_types', 'get_types', 'search_custom_types_comments_hook');
+ elgg_register_plugin_hook_handler('search', 'comments', 'search_comments_hook');
// get server min and max allowed chars for ft searching
$CONFIG->search_info = array();
}
/** Register init system event **/
-register_elgg_event_handler('init','system','search_init');
+elgg_register_event_handler('init','system','search_init');
// Replace the default index page if user has requested and the site is not running walled garden
if (get_plugin_setting('ownfrontpage', 'sitepages') == 'yes') {
- register_plugin_hook('index', 'system', 'sitepages_custom_index');
+ elgg_register_plugin_hook_handler('index', 'system', 'sitepages_custom_index');
}
// define our own ecml keywords and views
- register_plugin_hook('get_keywords', 'ecml', 'sitepages_ecml_keyword_hook');
- register_plugin_hook('get_views', 'ecml', 'sitepages_ecml_views_hook');
+ elgg_register_plugin_hook_handler('get_keywords', 'ecml', 'sitepages_ecml_keyword_hook');
+ elgg_register_plugin_hook_handler('get_views', 'ecml', 'sitepages_ecml_views_hook');
// hook into the walled garden pages
- register_plugin_hook('public_pages', 'walled_garden', 'sitepages_public_pages');
+ elgg_register_plugin_hook_handler('public_pages', 'walled_garden', 'sitepages_public_pages');
register_action('settings/sitepages/save', FALSE, "{$CONFIG->pluginspath}sitepages/actions/edit_settings.php");
return $return_value;
}
-register_elgg_event_handler('init', 'system', 'sitepages_init');
+elgg_register_event_handler('init', 'system', 'sitepages_init');
elgg_extend_view('css','tagcloud/css');
}
-register_elgg_event_handler('init', 'system', 'tagcloud_init');
+elgg_register_event_handler('init', 'system', 'tagcloud_init');
register_entity_type('object','thewire');
// Listen for SMS create event
- register_elgg_event_handler('create','object','thewire_incoming_sms');
+ elgg_register_event_handler('create','object','thewire_incoming_sms');
// Register granular notification for this type
if (is_callable('register_notification_object'))
register_notification_object('object', 'thewire', elgg_echo('thewire:newpost'));
// Listen to notification events and supply a more useful message for SMS'
- register_plugin_hook('notify:entity:message', 'object', 'thewire_notify_message');
+ elgg_register_plugin_hook_handler('notify:entity:message', 'object', 'thewire_notify_message');
}
function thewire_pagesetup() {
}
// Make sure the thewire initialisation function is called on initialisation
- register_elgg_event_handler('init','system','thewire_init');
- register_elgg_event_handler('pagesetup','system','thewire_pagesetup');
+ elgg_register_event_handler('init','system','thewire_init');
+ elgg_register_event_handler('pagesetup','system','thewire_pagesetup');
// Register actions
global $CONFIG;
elgg_extend_view('embed/custom_insert_js', 'tinymce/embed_custom_insert_js');
}
-register_elgg_event_handler('init', 'system', 'tinymce_init', 9999);
+elgg_register_event_handler('init', 'system', 'tinymce_init', 9999);
}
- register_elgg_event_handler('init','system','twitter_init');
+ elgg_register_event_handler('init','system','twitter_init');
?>
\ No newline at end of file
register_page_handler('uservalidationbyemail', 'uservalidationbyemail_page_handler');
// mark users as unvalidated and disable when they register
- register_plugin_hook('register', 'user', 'uservalidationbyemail_disable_new_user');
+ elgg_register_plugin_hook_handler('register', 'user', 'uservalidationbyemail_disable_new_user');
// canEdit override to allow not logged in code to disable a user
- register_plugin_hook('permissions_check', 'user', 'uservalidationbyemail_allow_new_user_can_edit');
+ elgg_register_plugin_hook_handler('permissions_check', 'user', 'uservalidationbyemail_allow_new_user_can_edit');
// prevent users from logging in if they aren't validated
- register_plugin_hook('action', 'login', 'uservalidationbyemail_check_login_attempt');
+ elgg_register_plugin_hook_handler('action', 'login', 'uservalidationbyemail_check_login_attempt');
// when requesting a new password
- register_plugin_hook('action', 'user/requestnewpassword', 'uservalidationbyemail_check_request_password');
+ elgg_register_plugin_hook_handler('action', 'user/requestnewpassword', 'uservalidationbyemail_check_request_password');
// prevent the engine from logging in users via login()
- register_elgg_event_handler('login', 'user', 'uservalidationbyemail_check_manual_login');
+ elgg_register_event_handler('login', 'user', 'uservalidationbyemail_check_manual_login');
// make admin users always validated
- register_elgg_event_handler('make_admin', 'user', 'uservalidationbyemail_validate_new_admin_user');
+ elgg_register_event_handler('make_admin', 'user', 'uservalidationbyemail_validate_new_admin_user');
// register Walled Garden public pages
- register_plugin_hook('public_pages', 'walled_garden', 'uservalidationbyemail_public_pages');
+ elgg_register_plugin_hook_handler('public_pages', 'walled_garden', 'uservalidationbyemail_public_pages');
// admin interface to manually validate users
elgg_add_admin_submenu_item('unvalidated', elgg_echo('uservalidationbyemail:admin:unvalidated'), 'users');
return $value;
}
-register_elgg_event_handler('init', 'system', 'uservalidationbyemail_init');
\ No newline at end of file
+elgg_register_event_handler('init', 'system', 'uservalidationbyemail_init');
\ No newline at end of file
}
// Make sure the status initialisation function is called on initialisation
- register_elgg_event_handler('init','system','zaudio_init',999);
+ elgg_register_event_handler('init','system','zaudio_init',999);
?>
\ No newline at end of file
}
// plugins should return true to control what API and user authentication handlers are registered
-if (trigger_plugin_hook('rest', 'init', null, false) == false) {
+if (elgg_trigger_plugin_hook('rest', 'init', null, false) == false) {
// for testing from a web browser, you can use the session PAM
// do not use for production sites!!
//register_pam_handler('pam_auth_session');
$r = get_relationship($id_or_name);
break;
case 'volatile' :
- $m = trigger_plugin_hook('volatile', 'metadata',
+ $m = elgg_trigger_plugin_hook('volatile', 'metadata',
array('guid' => $guid, 'varname' => $id_or_name));
break;
// Trigger owner block menu
$params = array('owner' => $owner);
- $links = trigger_plugin_hook('profile_menu', 'profile', $params, array());
+ $links = elgg_trigger_plugin_hook('profile_menu', 'profile', $params, array());
if (is_array($links) && !empty($links)) {
// sort the links by name
usort($links, create_function(
projects / lorea / elgg.git / commitdiff