View source
<?php
define('MESSAGING_TYPE_PUSH', 1);
define('MESSAGING_TYPE_PULL', 2);
define('MESSAGING_TYPE_OUTGOING', 4);
define('MESSAGING_TYPE_INCOMING', 8);
define('MESSAGING_TYPE_NOQUEUE', 16);
define('MESSAGING_TYPE_SEND', MESSAGING_TYPE_PUSH | MESSAGING_TYPE_OUTGOING);
define('MESSAGING_EMPTY', '<none>');
define('MESSAGING_CACHE_LIMIT', variable_get('messaging_cache_limit', 1000));
define('MESSAGING_DEFAULT_CRON_PERCENT', variable_get('messaging_default_cron_percent', 80));
function messaging_autoload_info() {
return array(
'Messaging_User_Object' => array(
'file' => 'includes/messaging_object.class.inc',
),
'Messaging_Object' => array(
'file' => 'includes/messaging_object.class.inc',
),
'Messaging_Cached_Object' => array(
'file' => 'includes/messaging_object.class.inc',
),
'Messaging_Destination' => array(
'file' => 'includes/messaging_destination.class.inc',
),
'Messaging_Message' => array(
'file' => 'includes/messaging_message.class.inc',
),
'Messaging_Send_Method' => array(
'file' => 'includes/messaging_method.class.inc',
),
'Messaging_Store' => array(
'file' => 'includes/messaging_store.class.inc',
),
'Messaging_None' => array(
'file' => 'includes/messaging_object.class.inc',
),
);
}
function messaging_help($path, $arg) {
switch ($path) {
case 'admin/help#messaging':
$output = '<p>' . t('The messaging module is the engine that handles outgoing messages and message queueing for different sending methods.') . '</p>';
$output .= '<p>' . t('You need to enable one or more of the included plug-ins to be able to actually take advantage of it.') . '</p>';
return $output;
case 'admin/messaging/settings/method/filters':
$output = '<p>' . t('These are the filters for the message body. They should depend on the content and the tokens you are using for messages. This is important for getting the right formatting and also for security.') . '</p>';
$oubput .= t('If using raw tokens for templates, possibly you\'ll need some additional formatting here.');
$items[] = t('You can set up Input formats for specific message parts on the <a href="@message_templates">Message templates pages</a>. These will be run first on each piece of text.', array(
'@message_templates' => url('admin/messaging/template'),
));
$items[] = t('Once the message body is built you can set a <strong>Format filter</strong> on this page to format and filter it. Set up the filters you need using the <a href="@input_formats">Input formats</a> page', array(
'@input_formats' => url('admin/settings/filters'),
));
$items[] = t('Last, the <strong>Final filter</strong> will be run for adjusting the text to the format required by each Send method.');
$output .= theme('item_list', $items);
return $output;
}
}
function messaging_menu() {
$items['admin/messaging'] = array(
'title' => 'Messaging',
'access arguments' => array(
'administer site configuration',
),
'description' => 'Administer and configure messaging',
'page callback' => 'system_admin_menu_block_page',
'file' => 'system.admin.inc',
'file path' => drupal_get_path('module', 'system'),
);
$items['admin/messaging/settings'] = array(
'title' => 'Messaging settings',
'description' => 'Configuration of messaging framework',
'page callback' => 'drupal_get_form',
'page arguments' => array(
'messaging_admin_settings',
),
'access arguments' => array(
'administer site configuration',
),
'file' => 'messaging.admin.inc',
);
$items['admin/messaging/settings/overview'] = array(
'title' => 'Messaging',
'description' => 'Configuration of sending methods',
'type' => MENU_DEFAULT_LOCAL_TASK,
'weight' => -10,
);
$items['admin/messaging/settings/method'] = array(
'title' => 'Send methods',
'description' => 'Configuration of sending methods',
'page callback' => 'drupal_get_form',
'page arguments' => array(
'messaging_admin_method_settings',
),
'access arguments' => array(
'administer site configuration',
),
'weight' => -10,
'file' => 'messaging.admin.inc',
'type' => MENU_LOCAL_TASK,
);
$items['admin/messaging/settings/method/overview'] = array(
'title' => 'Options',
'description' => 'General settings',
'type' => MENU_DEFAULT_LOCAL_TASK,
'weight' => -10,
);
$items['admin/messaging/settings/method/filters'] = array(
'title' => 'Filters',
'description' => 'Filters and formatting',
'page callback' => 'drupal_get_form',
'page arguments' => array(
'messaging_admin_method_filters',
),
'access arguments' => array(
'administer filters',
),
'file' => 'messaging.admin.inc',
'type' => MENU_LOCAL_TASK,
);
$items['admin/messaging/settings/test'] = array(
'title' => 'Test',
'description' => 'Test message sending',
'page callback' => 'drupal_get_form',
'page arguments' => array(
'messaging_admin_test_post_form',
),
'access arguments' => array(
'administer site configuration',
),
'file' => 'messaging.admin.inc',
'weight' => -10,
'type' => MENU_LOCAL_TASK,
);
return $items;
}
function messaging_perm() {
return array(
'administer messaging',
);
}
function messaging_user($type, $edit, &$user, $category = NULL) {
switch ($type) {
case 'delete':
Messaging_Destination::delete_multiple(array(
'uid' => $user->uid,
));
messaging_store()
->delete_multiple(array(
'uid' => $user->uid,
));
break;
case 'form':
if ($category == 'account' && ($list = messaging_method_list($user))) {
$form['messaging'] = array(
'#type' => 'fieldset',
'#title' => t('Messaging settings'),
'#weight' => 5,
'#collapsible' => TRUE,
);
$form['messaging']['messaging_default'] = array(
'#type' => 'select',
'#title' => t('Default send method'),
'#default_value' => messaging_method_default($user),
'#options' => $list,
'#description' => t('Default sending method for getting messages from this system.'),
'#disabled' => count($list) == 1,
);
return $form;
}
break;
}
}
function messaging_send_method($method, $method_info = array()) {
$send_methods =& messaging_static(__FUNCTION__);
if (is_object($method)) {
return $method;
}
if (!isset($send_methods[$method])) {
if ($info = messaging_method_info($method)) {
$class = !empty($info['class']) ? $info['class'] : 'Messaging_Send_Method';
$send_methods[$method] = new $class($method, $method_info + $info);
}
else {
$send_methods[$method] = new Messaging_Send_Method($method, $method_info);
$static_info =& messaging_info('send methods');
$static_info[$method] = $method_info;
}
}
return $send_methods[$method];
}
function messaging_message_build($message) {
return messaging_check_object($message, 'Messaging_Message', TRUE);
}
function messaging_message_send($destinations, $message, $method, $queue = FALSE) {
messaging_debug('Sending message', array(
'destinations' => $destinations,
'message' => $message,
'method' => $method,
'queue' => $queue,
));
$message = messaging_message_build($message);
$message->method = $method;
if (is_array($destinations)) {
$message
->set_multiple($destinations);
}
else {
$message
->set_destination($destinations);
}
return $queue ? $message
->queue() : $message
->send();
}
function messaging_message_send_destination($method, $destination, $message, $queue = FALSE) {
messaging_debug('Sending message to destination', array(
'destination' => $destination,
'message' => $message,
));
$message = messaging_message_build($message);
$message->method = $method;
$message
->set_destination($destination);
return $queue ? $message
->queue() : $message
->send();
}
function messaging_message_send_user($account, $message, $method = NULL, $queue = FALSE) {
messaging_debug('Sending message to user', array(
'account' => $account,
'message' => $message,
'method' => $method,
));
$message = messaging_message_build($message);
if (isset($method)) {
$message->method = $method;
}
if ($message
->set_user($account)) {
messaging_debug('Found destination for user, sending message', array(
'method' => $message->method,
'destination' => $message->destination,
));
return $queue ? $message
->queue() : $message
->send();
}
else {
watchdog('messaging', 'Cannot send message to user !username. @message', array(
'!username' => theme('username', $account),
'@message' => (string) $message,
), WATCHDOG_WARNING);
return FALSE;
}
}
function messaging_message_bulk_send($users, $message, $queue = FALSE) {
$users = is_array($users) ? $users : array(
$users,
);
$users = array_map('messaging_user_object', $users);
$template = messaging_message_build($message);
$results = array();
foreach ($users as $account) {
$message = clone $template;
$results[$account->uid] = messaging_message_send_user($account, $message, NULL, $queue);
}
return $results;
}
function messaging_account_build_destination($account, $method = NULL, $address = NULL) {
if ($account->uid) {
if ($method && !$address) {
$address = messaging_user_destination($account, $method);
}
if ($method && $address) {
return Messaging_Destination::create_method($method, $address, $account->uid);
}
elseif (($fallback = messaging_method_default($account)) && $fallback != $method) {
return messaging_account_build_destination($account, $fallback);
}
}
elseif ($method && $address) {
return Messaging_Destination::create_method($method, $address, 0);
}
}
function messaging_user_destination($account, $method, $message = NULL) {
return messaging_send_method($method)
->get_user_address($account);
}
function messaging_message_test($message, $destinations = array()) {
$message
->prepare();
$message
->render();
messaging_log('Emulating message sending (test run)', array(
'summary' => (string) $message,
'message' => $message,
'destinations' => $destinations,
));
return $message->success = TRUE;
}
function messaging_cron() {
if (variable_get('messaging_queue_process_cron', TRUE)) {
messaging_store()
->cron_process();
}
}
function messaging_method_type($type) {
$result = array();
foreach (messaging_method_info() as $method => $info) {
if ($info['type'] & $type) {
$result[$method] = $info;
}
}
return $result;
}
function messaging_method_list($account = NULL) {
$info = messaging_method_info(NULL, 'name');
if ($account) {
foreach (array_keys($info) as $method) {
if (!messaging_method_permission($method, $account) || !messaging_user_destination($account, $method)) {
unset($info[$method]);
}
else {
$info[$method] = messaging_translate("method:{$method}:name", $info[$method]);
}
}
}
return array_map('check_plain', $info);
}
function messaging_method_permission($method, $account = NULL) {
return messaging_method_info($method, 'enabled') && messaging_send_method($method)
->user_access($account);
}
function messaging_method_default($account = NULL) {
if ($account && !empty($account->messaging_default) && messaging_method_permission($account->messaging_default, $account)) {
return $account->messaging_default;
}
elseif ($method = variable_get('messaging_default_method', '')) {
return $method;
}
else {
return key(messaging_method_info());
}
}
function messaging_user_setting($name, $account = NULL, $default = NULL) {
$variable = 'messaging_' . $name;
if ($account && isset($account->{$variable}) && variable_get('messaging_peruser_' . $name, 1)) {
return $account->{$variable};
}
else {
return variable_get('messaging_default_' . $name, $default);
}
}
function messaging_method_info($method = NULL, $property = NULL, $default = NULL) {
static $info;
if (!isset($info)) {
$info =& messaging_info('send methods', NULL, FALSE, FALSE);
$enabled = variable_get('messaging_method_enabled', array());
foreach (array_keys($info) as $name) {
$info[$name] = array_merge($info[$name], variable_get('messaging_method_' . $name, array()), variable_get('messaging_filters_' . $name, array()));
$info[$name]['enabled'] = isset($enabled[$name]) ? $enabled[$name] : TRUE;
}
drupal_alter('messaging_send_methods', $info);
}
return messaging_array_info($info, $method, $property, $default);
}
function messaging_address_info($type = NULL, $property = NULL, $default = NULL) {
$info =& messaging_info('address types');
return messaging_array_info($info, $type, $property, $default);
}
function messaging_messaging($op, $type = NULL) {
switch ($op) {
case 'text filters':
messaging_include('text.inc');
return _messaging_text_filter_info();
case 'address types':
$types['user'] = array(
'name' => t('User name'),
'format callback' => 'messaging_user_format_name',
'account_property' => 'uid',
'field_name' => 'uid',
'field_table' => 'users',
);
return $types;
}
}
function messaging_address_get_uid($address, $property = 'mail') {
return db_result(db_query("SELECT uid FROM {users} WHERE {$property} = '%s'", $address));
}
function messaging_store() {
static $messaging_store;
if (!isset($messaging_store)) {
$class = variable_get('messaging_store', 'Messaging_Store');
$messaging_store = new $class();
}
return $messaging_store;
}
function messaging_load_user($uid) {
$cache =& messaging_static(__FUNCTION__);
if (!$cache || !array_key_exists($uid, $cache)) {
if ($uid) {
$cache[$uid] = user_load($uid);
}
else {
$cache[0] = drupal_anonymous_user();
$cache[0]->name = variable_get('anonymous', 'Anonymous');
}
}
return $cache[$uid];
}
function messaging_message_load($mqid, $refresh = FALSE) {
return messaging_store()
->message_load($mqid, $refresh);
}
function messaging_requirements($phase) {
$requirements = array();
$t = get_t();
if ($phase == 'runtime') {
$methods = messaging_method_list();
if (!$methods) {
$requirements['messaging'] = array(
'title' => $t('Messaging sending methods'),
'value' => $t('No sending method plug-ins available. Please enable some Sending Method on the !admin-modules page.', array(
'!admin-modules' => l($t('Modules administration'), 'admin/build/modules'),
)),
'severity' => REQUIREMENT_ERROR,
);
}
}
return $requirements;
}
function messaging_message_in($method, $channel, $message, $params = array()) {
if (function_exists('messaging_incoming_post')) {
return messaging_incoming_post($method, $channel, $message, $params);
}
else {
return FALSE;
}
}
function messaging_method_disable($method, $replace = NULL) {
module_load_include('install', 'messaging');
$replace = isset($replace) ? $replace : messaging_update_method_replace($method, TRUE);
messaging_update_method_disable($method, $replace);
if ($replace) {
drupal_set_message(t('Disabled messaging sending method %method and replaced by %replace', array(
'%method' => messaging_method_info($method, 'title'),
'%replace' => messaging_method_info($replace, 'title'),
)));
}
else {
drupal_set_message(t('Disabled messaging sending method but cannot find a replacement. Please, enable some other sending method.'), 'error');
}
}
function _messaging_callback() {
$args = func_get_args();
if (count($args) > 1) {
return $args;
}
else {
return array_shift($args);
}
}
function _messaging_callback_invoke() {
$args = func_get_args();
$callback = array_shift($args);
if (is_array($callback)) {
$function = array_shift($callback);
$params = $callback;
}
else {
$function = $callback;
$params = array();
}
$params = array_merge($params, $args);
return call_user_func_array($function, $params);
}
function messaging_check_object($object, $class, $create = FALSE) {
if ($object && is_object($object) && is_a($object, $class)) {
return $object;
}
elseif ($create) {
return new $class($object);
}
}
function messaging_token_list($type = 'all') {
$tokens = array();
if ($type == 'message' || $type == 'all') {
$tokens['message']['message-subject'] = t('The message subject.');
$tokens['message']['message-body'] = t('The message body.');
$tokens['message']['message-author-name'] = t('The message\'s author name.');
$tokens['message']['message-method'] = t('The message\'s method name.');
$tokens['message']['message-date'] = t('The message\'s sending date.');
}
if ($type == 'destination' || $type == 'all') {
$tokens['destination']['destination-address'] = t('Destination address.');
$tokens['destination']['destination-type'] = t('Destination address type.');
}
return $tokens;
}
function messaging_token_values($type, $object = NULL, $options = array()) {
$language = isset($options['language']) ? $options['language'] : $GLOBALS['language'];
switch ($type) {
case 'message':
if ($message = messaging_check_object($object, 'Messaging_Message')) {
$values['message-subject'] = check_plain($message
->get_subject());
$values['message-body'] = filter_xss($message
->get_body());
$values['message-author-name'] = check_plain($message
->get_sender_name());
$values['message-method'] = messaging_method_info($message->method, 'name');
$timezone = isset($options['timezone']) ? $options['timezone'] : variable_get('date_default_timezone', 0);
$values['message-date'] = format_date($message->sent, 'medium', '', $timezone, $language->language);
return $values;
}
break;
case 'destination':
if ($destination = messaging_check_object($object, 'Messaging_Destination')) {
$values['destination-address'] = $destination
->format_address(FALSE);
$values['destination-type'] = $destination
->address_name();
return $values;
}
break;
}
}
function messaging_theme() {
return array(
'messaging_admin_methods_table' => array(
'arguments' => array(
'elements' => NULL,
),
'file' => 'messaging.admin.inc',
),
'messaging_admin_settings_table' => array(
'arguments' => array(
'elements' => NULL,
),
'file' => 'messaging.admin.inc',
),
);
}
function _messaging_callback_add(&$callback_list, $type, $callback) {
$name = $type . ' callback';
if (!empty($callback_list[$name]) && !is_array($callback_list[$name])) {
$callback_list[$name] = array(
$callback_list[$name],
);
}
$callback_list[$name][] = $callback;
}
function _messaging_callback_get($info, $type, $default = NULL) {
if (!empty($info[$type . ' callback'])) {
return $info[$type . ' callback'];
}
else {
return $default;
}
}
function messaging_array_info($info, $method = NULL, $property = NULL, $default = NULL) {
if ($method && $property) {
return isset($info[$method][$property]) ? $info[$method][$property] : $default;
}
elseif ($method) {
return isset($info[$method]) ? $info[$method] : $default;
}
elseif ($property) {
$props = array();
foreach ($info as $method => $values) {
if (isset($values[$property])) {
$props[$method] = $values[$property];
}
}
return $props;
}
else {
return $info;
}
}
function _messaging_query_conditions($table, $params, $table_alias = NULL) {
$query = _messaging_query_where($table, $params, $table_alias);
return array(
'conditions' => $query['where'],
'args' => $query['args'],
'where' => implode(' AND ', $query['where']),
);
}
function _messaging_query_where($table, $params, $table_alias = NULL) {
$schema = drupal_get_schema($table);
$conditions = $args = array();
foreach ($params as $field => $value) {
if (isset($schema['fields'][$field])) {
$type = $schema['fields'][$field]['type'];
$field_name = $table_alias ? "{$table_alias}.{$field}" : $field;
if (is_array($value)) {
$conditions[] = $field_name . ' IN (' . db_placeholders($value, $type) . ')';
$args = array_merge($args, $value);
}
elseif (is_null($value)) {
$condtions[] = $field_name . ' IS NULL';
}
else {
$conditions[] = $field_name . ' = ' . db_type_placeholder($type);
$args[] = $value;
}
}
}
return array(
'where' => $conditions,
'args' => $args,
);
}
function messaging_query_sql($query, $execute = FALSE) {
$sql = !empty($query['sql']) ? $query['sql'] : '';
if (!empty($query['insert'])) {
$sql .= 'INSERT INTO ' . $query['into'] . ' (' . implode(', ', $query['insert']) . ') ';
}
if (!empty($query['select'])) {
$sql .= !empty($query['distinct']) ? 'SELECT DISTINCT ' : 'SELECT ';
$sql .= implode(', ', $query['select']);
$sql .= ' FROM ' . implode(', ', $query['from']);
}
if (!empty($query['join'])) {
$sql .= ' ' . implode(' ', $query['join']);
}
if (!empty($query['where'])) {
$sql .= ' WHERE (' . implode(') AND (', $query['where']) . ')';
}
if (!empty($query['group'])) {
$sql .= ' GROUP BY ' . implode(', ', $query['group']);
}
if (!empty($query['having'])) {
$sql .= ' HAVING ' . implode(' AND ', $query['having']);
}
$args = !empty($query['args']) ? $query['args'] : array();
foreach (array(
'select',
'join',
'where',
'having',
) as $key) {
if (!empty($query[$key . ' args'])) {
$args = array_merge($args, $query[$key . ' args']);
}
}
if (!empty($query['order'])) {
$sql .= ' ORDER BY ' . implode(', ', $query['order']);
}
if (!$execute) {
return array(
$sql,
$args,
);
}
elseif (!empty($query['pager'])) {
return pager_query($sql, $query['limit'], $query['pager'], NULL, $args);
}
elseif (!empty($query['limit'])) {
return db_query_range($sql, $args, 0, $query['limit']);
}
else {
return db_query($sql, $args);
}
}
function messaging_log($txt = NULL, $variables = NULL) {
return _messaging_log('info', $txt, $variables);
}
function messaging_log_get() {
if ($logs = _messaging_log('return')) {
_messaging_log('reset');
return $logs;
}
}
function messaging_log_start() {
return _messaging_log('start');
}
function messaging_debug($txt = NULL, $variables = NULL) {
if (function_exists('messaging_debug_log')) {
return messaging_debug_log($txt, $variables);
}
}
function messaging_log_format($logs) {
$rows = array();
foreach ($logs as $log) {
list($type, $string, $append, $objects) = _messaging_log_format($log);
if ($objects && function_exists('_messaging_debug_format_log')) {
$text = _messaging_debug_format_log($type, $string, $append, $objects);
}
else {
$text = $string;
if ($append) {
$text .= '<br />' . implode(' ', $append);
}
}
$rows[] = array(
$type,
$text,
);
}
return theme('table', array(
t('Type'),
t('Message'),
), $rows);
}
function _messaging_log($type, $txt = NULL, $variables = NULL, $severity = WATCHDOG_NOTICE) {
static $enabled = FALSE;
switch ($type) {
case 'info':
case 'debug':
if ($enabled) {
$_SESSION['messaging_log'][] = array(
$type,
$txt,
$variables,
$severity,
);
}
break;
case 'return':
return isset($_SESSION['messaging_log']) ? $_SESSION['messaging_log'] : NULL;
break;
case 'reset':
unset($_SESSION['messaging_log']);
break;
case 'start':
$enabled = TRUE;
break;
case 'stop':
$enabled = FALSE;
break;
}
}
function _messaging_log_format($log) {
list($type, $string, $args, $severity) = $log;
$append = $replace = $objects = array();
if ($args) {
foreach ($args as $key => $value) {
if (is_numeric($value) || is_string($value)) {
switch ($key[0]) {
case '@':
$replace[$key] = check_plain($value);
break;
case '%':
$replace[$key] = theme('placeholder', $value);
break;
case '!':
$replace[$key] = $value;
break;
default:
$append[$key] = '<strong>' . $key . '</strong>= ' . check_plain($value);
break;
}
}
elseif (is_array($value) || is_object($value)) {
$objects[$key] = $value;
}
}
$string = strtr($string, $replace);
}
return array(
$type,
$string,
$append,
$objects,
);
}
function messaging_translate($name, $string, $langcode = NULL, $textgroup = 'messaging') {
return function_exists('i18nstrings') ? i18nstrings($textgroup . ':' . $name, $string, $langcode) : $string;
}
function messaging_locale($op = 'groups') {
switch ($op) {
case 'groups':
return array(
'messaging' => t('Messaging'),
);
case 'info':
$info['messaging']['refresh callback'] = 'messaging_locale_refresh';
$info['messaging']['format'] = TRUE;
return $info;
}
}
function messaging_locale_refresh() {
foreach (messaging_method_info() as $name => $info) {
i18nstrings_update("messaging:method:{$name}:name", $info['name']);
}
return TRUE;
}
function messaging_static_cache_set($cache_name, $key, $value) {
$cache =& messaging_static($cache_name);
if ($cache && MESSAGING_CACHE_LIMIT && count($cache) > MESSAGING_CACHE_LIMIT) {
$cache = array();
}
$cache[$key] = $value;
}
function messaging_static_cache_get($cache_name, $key) {
$cache =& messaging_static($cache_name);
return isset($cache[$key]) ? $cache[$key] : NULL;
}
function &messaging_static($name, $default_value = NULL, $reset = FALSE) {
static $data = array(), $default = array();
if (!isset($name)) {
foreach ($default as $name => $value) {
$data[$name] = $value;
}
return $data;
}
if ($reset) {
if (array_key_exists($name, $default)) {
$data[$name] = $default[$name];
}
else {
return $data;
}
}
elseif (!array_key_exists($name, $data)) {
$default[$name] = $data[$name] = $default_value;
}
return $data[$name];
}
function messaging_static_reset($name = NULL) {
messaging_static($name, NULL, TRUE);
}
function messaging_destination_load($mdid) {
return Messaging_Destination::load($mdid);
}
function messaging_include($file, $module = 'messaging') {
static $included = array();
if (!isset($included[$module][$file])) {
require_once './' . drupal_get_path('module', $module) . '/includes/' . $file;
$included[$module][$file] = TRUE;
}
}
function &messaging_info($name, $param = NULL, $refresh = FALSE, $alter = TRUE) {
$info =& messaging_static('messaging_info_' . $name);
if (!isset($info) || $refresh) {
$info = messaging_module_invoke_all('messaging', $name, $param);
if ($alter) {
drupal_alter('messaging_' . strtr($name, ' ', '_'), $info);
}
}
return $info;
}
function messaging_module_invoke_all() {
$args = func_get_args();
$hook = $args[0];
unset($args[0]);
$return = array();
foreach (module_implements($hook) as $module) {
$function = $module . '_' . $hook;
$result = call_user_func_array($function, $args);
if (isset($result) && is_array($result)) {
foreach ($result as $key => &$value) {
if (is_array($value)) {
$value += array(
'module' => $module,
);
}
}
$return = array_merge($return, $result);
}
else {
if (isset($result)) {
$return[] = $result;
}
}
}
return $return;
}
function messaging_user_uid($account) {
return is_object($account) ? $account->uid : (int) $account;
}
function messaging_user_object($account) {
return is_object($account) ? $account : messaging_load_user((int) $account);
}
function messaging_user_property($account, $property) {
$account = messaging_user_object($account);
return $account && isset($account->{$property}) ? $account->{$property} : NULL;
}
function messaging_user_format_name($account, $html = FALSE) {
$account = messaging_user_object($account);
return $html ? theme('username', $account) : check_plain($account->name);
}