modules/chatroom/chatroom.module

<?php
// $Id: chatroom.module,v 1.63.2.40 2009/11/06 16:40:11 justinrandell Exp $

require_once dirname(__FILE__) . '/chatroom.forms.inc';
require_once dirname(__FILE__) . '/chatroom.theme.inc';

/**
 * @file
 * Enable chat room support in Drupal.
 */

/**
 * Implementation of hook_help().
 */
function chatroom_help($path, $arg) {
  switch ($path) {
    case 'admin/help#chatroom':
      return '<p />';
  }
}

/**
 * Implementation of hook_help().
 */
function chatroom_init() {
  global $user;
  
  if ($user->uid > 0) {
    if ($invites = chatroom_chat_get_user_invites($user)) {
      chatroom_chat_notify_user_of_invites($user, $invites);
    }
  }
}

/**
 * Notify a user of pending chat invites.
 * 
 * @param mixed $chat_user 
 * @param mixed $invites 
 * @return void
 */
function chatroom_chat_notify_user_of_invites($chat_user, $invites) {
  foreach (module_implements('chatroom_chat_invites_notify') as $module) {
    $function = $module . '_chatroom_chat_invites_notify';
    $function($chat_user, $invites);
  }
  $sql = "UPDATE {chatroom_chat_invite} SET notified = 1 WHERE cciid IN (" . db_placeholders(array_keys($invites)) . ')';
  db_query($sql, array_keys($invites));
}

/**
 * Implementation of hook_chatroom_chat_invites_notify().
 *
 * @param mixed $chat_user
 * @param mixed $invites
 * @return void
 */
function chatroom_chatroom_chat_invites_notify($chat_user, $invites) {
  foreach ($invites as $invite) {
    $chat_path = 'node/' . $invite->nid;
    if ($_GET['q'] != $chat_path) { 
      $link = l($invite->title, 'node/' . $invite->nid);
      $message = t("You have been invited to the chat !link by user '%name'", array('!link' => $link, '%name' => $invite->name));
      drupal_set_message($message);
    }
  }
}

/**
 * Get any pending invites for a user.
 *
 * @param mixed $chat_user
 * @return array
 */
function chatroom_chat_get_user_invites($chat_user) {
  $sql = "SELECT cci.cciid, n.title, u.name, u.uid, cci.nid
          FROM {chatroom_chat_invite} cci
          INNER JOIN {node} n ON n.nid = cci.nid
          INNER JOIN {users} u ON u.uid = cci.inviter_uid
          WHERE cci.invitee_uid = %d
          AND cci.accepted = 0
          AND cci.notified = 0";
  $result = db_query($sql, $chat_user->uid);

  $invites = array();
  while ($invite = db_fetch_object($result)) {
    $invites[$invite->cciid] = $invite;
  }
  return $invites;
}

/**
 * Implementation of hook_access().
 */
function chatroom_chat_access($op, $node, $account) {
  if (user_access('administer chats', $account)) {
    return TRUE;
  }
  if ($op == 'view') {
    return user_access('access chats', $account) && chatroom_chat_user_has_access($node, $account);
  }
  if ($op == 'create') {
    return user_access('create chats', $account);
  }
  if ($op == 'update' || $op == 'delete') {
    if (user_access('edit own chats', $account) && ($account->uid == $node->uid)) {
      return TRUE;
    }
  }
  return FALSE;
}  

/**
 * Implementation of hook_access().
 */
function chatroom_access($op, $node, $account) {
  if (user_access('administer chat rooms', $account)) {
    return TRUE;
  }
  if ($op == 'view') {
    return user_access('access chat rooms', $account);
  }
  if ($op == 'create') {
    return user_access('create chat rooms', $account);
  }
  if ($op == 'update' || $op == 'delete') {
    if (user_access('edit own chat rooms', $account) && ($account->uid == $node->uid)) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Implementation of hook_perm().
 */
function chatroom_perm() {
  return array('access chats', 'access chat rooms', 'create chat rooms', 'edit own chats', 'edit own chat rooms', 'administer chats', 'administer chat rooms', 'create chats');
}

/**
 * Implementation of hook_menu().
 */
function chatroom_menu() {
  $items['chatroom/ajax/user/invite/%node'] = array(
    'description' => t('Invite a user to a chat.'),
    'page callback' => 'chatroom_chat_ajax_user_invite',
    'page arguments' => array(4),
    'access callback' => TRUE,
  );
  $items['chatroom/ajax/user/add/%node'] = array(
    'description' => t('Add a user to a private chat.'),
    'page callback' => 'chatroom_chat_ajax_user_add',
    'page arguments' => array(4),
    'access callback' => TRUE,
  );
  $items['chatroom/ajax/user/remove/%node'] = array(
    'description' => t('Remove a user from a private chat.'),
    'page callback' => 'chatroom_chat_ajax_user_remove',
    'page arguments' => array(4),
    'access callback' => TRUE,
  );
  $items['chatroom/popout/redirect/%node'] = array(
    'description' => t('Configure global settings for chat rooms and chats.'),
    'page callback' => 'chatroom_popout_redirect',
    'page arguments' => array(3),
    'access callback' => TRUE,
  );
  $items['chatroom/user/autocomplete'] = array(
    'title' => 'Chat room',
    'page callback' => 'chatroom_user_autocomplete',
    'access callback' => TRUE,
    'type' => MENU_CALLBACK,
  );
  $items['admin/settings/chatroom'] = array(
    'title' => 'Chat room',
    'description' => t('Configure global settings for chat rooms and chats.'),
    'page callback' => 'drupal_get_form',
    'page arguments' => array('chatroom_admin_settings'),
    'access arguments' => array('administer chat rooms'),
  );
  $items['chatroom/access-denied/%node/%'] = array(
    'type' => MENU_CALLBACK,
    'page callback' => 'chatroom_access_denied',
    'page arguments' => array(2, 3),
    'access arguments' => array('access chat rooms'),
  );
  $items['chatroom/chat/post/message/%node/%'] = array(
    'page callback' => 'chatroom_chat_post_message',
    'page arguments' => array(4, 5),
    'access arguments' => array('access chat rooms'),
    'type' => MENU_CALLBACK,
  );
  $items['chatroom/chat/get/latest/messages/%node/%'] = array(
    'page callback' => 'chatroom_chat_get_latest_messages',
    'page arguments' => array(5, 6),
    'access arguments' => array('access chat rooms'),
    'type' => MENU_CALLBACK,
  );
  return $items;
}

/**
 * Implementation of hook_node_info().
 */
function chatroom_node_info() {
  return array(
    'chatroom' => array(
      'name' => t('Chat room'),
      'module' => 'chatroom',
      'description' => t('A chat room provides access to chats and chat archives.'),
    ),
    'chat' => array(
      'name' => t('Chat'),
      'module' => 'chatroom_chat',
      'description' => t('A chat provides the chat interface.'),
    ),
  );
}

/**
 * Implementation of hook_insert().
 */
function chatroom_insert($node) {
  cache_clear_all('chatroom_room_list', 'cache');
  $chatroom = array(
    'nid' => $node->nid,
    'poll_freq' => $node->poll_freq,
    'idle_freq' => $node->idle_freq,
    'kicked_out_message' => $node->kicked_out_message,
    'banned_message' => $node->banned_message,
    'module' => isset($node->module) ? $node->module : 'chatroom',
    'previous_messages_display_count' => $node->previous_messages_display_count,
    'popout' => $node->popout,
    'profile_picture' => $node->profile_picture,
  );
  drupal_write_record('chatroom', $chatroom);
}

/**
 * Implementation of hook_update().
 */
function chatroom_update($node) {
  cache_clear_all('chatroom_room_list', 'cache');
  $chatroom = array(
    'nid' => $node->nid,
    'poll_freq' => $node->poll_freq,
    'idle_freq' => $node->idle_freq,
    'kicked_out_message' => $node->kicked_out_message,
    'banned_message' => $node->banned_message,
    'module' => isset($node->module) ? $node->module : 'chatroom',
    'previous_messages_display_count' => $node->previous_messages_display_count,
    'popout' => $node->popout,
    'profile_picture' => $node->profile_picture,
  );
  drupal_write_record('chatroom', $chatroom, 'nid');
}

/**
 * Implementation of hook_delete().
 */
function chatroom_delete(&$node) {
  cache_clear_all('chatroom_room_list', 'cache');
  db_query('DELETE FROM {chatroom} WHERE nid = %d', $node->nid);
  db_query("DELETE FROM {chatroom_chat} WHERE crid = %d", $node->nid);
  db_query('DELETE FROM {chatroom_ban_list} WHERE nid = %d', $node->nid);
  if (!empty($node->chats)) {
    $ccids = implode(',', array_keys($node->chats));
    db_query('DELETE FROM {chatroom_msg} WHERE ccid IN (%s)', $ccids);
    db_query('DELETE FROM {chatroom_online_list} WHERE ccid IN (%s)', $ccids);
  }
}

/**
 * Implementation of hook_load().
 */
function chatroom_load($node) {
  $room = new StdClass();
  if ($room->chatroom = db_fetch_object(db_query('SELECT * FROM {chatroom} WHERE nid = %d', $node->nid))) {
    $room->chatroom->banned_users = chatroom_get_banned_users($node);
    // If the user is banned, don't load chats.
    if (chatroom_is_banned_user($node)) {
      return $chatroom;
    }
    $room->chatroom->chats = chatroom_load_chats($node->nid);
  }
  return $room;
}

/**
 * Load chats for a given chatroom.
 * 
 * @param mixed $nid 
 * @return array - a list of chats.
 */
function chatroom_load_chats($nid) {
  $chats = array();
  $cmids = array();

  $sql = "SELECT cc.*, n.title, 0 last_cmid, 0 msg_count, NULL last_msg
          FROM {chatroom_chat} cc
          INNER JOIN {node} n ON n.nid = cc.nid
          WHERE cc.crid = %d";
  $result = db_query($sql, $nid);
  while ($chat = db_fetch_object($result)) {
    $chats[$chat->nid] = $chat;
  }
  
  // Load the message count info.
  if (!empty($chats)) {
    $ccids = array_keys($chats);
    $sql = "SELECT ccid, COUNT(*) msg_count, MAX(cmid) last_cmid
            FROM {chatroom_msg} 
            WHERE ccid IN (" . db_placeholders($ccids) . ")
            GROUP BY ccid";
    $result = db_query($sql, $ccids);
    while ($count = db_fetch_object($result)) {
      $chats[$count->ccid]->msg_count = $count->msg_count;
      $chats[$count->ccid]->last_cmid = $count->last_cmid;
      $cmids[] = $count->last_cmid;
    }
  }

  // Fetch the last message if there is one.
  if (!empty($cmids)) {
    // Note we join on the session not the uid, because anon users all have
    // the same uid.
    $sql = "SELECT cm.*, u.name, col.guest_id 
            FROM {chatroom_msg} cm 
            INNER JOIN {chatroom_chat_online_list} col ON col.sid = cm.sid 
            INNER JOIN {users} u ON u.uid = col.uid
            WHERE cm.cmid IN (" . db_placeholders($cmids) . ")";
    $result = db_query($sql, $cmids);
    while ($message = db_fetch_object($result)) {
      $chats[$message->ccid]->last_msg = $message;
    }
  }
  return $chats;
}

/**
 * Chatroom chat node hook functions.
 */
/**
 * Implementation of hook_insert().
 */
function chatroom_chat_insert($node) {
  cache_clear_all('chatroom_chat_list', 'cache');
  $chat = array(
    'nid' => $node->nid,
    'crid' => isset($node->crid) ? $node->crid : 0,
    'poll_freq' => $node->poll_freq,
    'idle_freq' => $node->idle_freq,
    'kicked_out_message' => $node->kicked_out_message,
    'banned_message' => $node->banned_message,
    'module' => isset($node->module) ? $node->module : 'chatroom',
    'previous_messages_display_count' => $node->previous_messages_display_count,
    'popout' => $node->popout,
    'private' => $node->private,
    'profile_picture' => isset($node->profile_picture) ? $node->profile_picture : '',
  );
  drupal_write_record('chatroom_chat', $chat);
}

/**
 * Implementation of hook_update().
 */
function chatroom_chat_update($node) {
  cache_clear_all('chatroom_chat_list', 'cache');
  $chat = array(
    'nid' => $node->nid,
    'crid' => isset($node->crid) ? $node->crid : 0,
    'poll_freq' => $node->poll_freq,
    'idle_freq' => $node->idle_freq,
    'kicked_out_message' => $node->kicked_out_message,
    'banned_message' => $node->banned_message,
    'module' => isset($node->module) ? $node->module : 'chatroom',
    'previous_messages_display_count' => $node->previous_messages_display_count,
    'popout' => $node->popout,
    'private' => $node->private,
    'profile_picture' => $node->profile_picture,
  );
  drupal_write_record('chatroom_chat', $chat, 'nid');
}

/**
 * Write a row for each uid for the given chat to allow access.
 *
 * @param mixed $node
 * @return void
 */
function chatroom_chat_set_user_list($node) {
  db_query("DELETE FROM {chatroom_chat_user} WHERE nid = %d", $node->nid);
  foreach ($node->chat->allowed_uids as $uid) {
    $row = array('uid' => $uid, 'nid' => $node->nid);
    drupal_write_record('chatroom_chat_user', $row);
  }
}

/**
 * Implementation of hook_delete().
 */
function chatroom_chat_delete(&$node) {
  cache_clear_all('chatroom_chat_list', 'cache');
  db_query('DELETE FROM {chatroom_chat} WHERE nid = %d', $node->nid);
  db_query('DELETE FROM {chatroom_chat_online_list} WHERE ccid = %d', $node->nid);
}

/**
 * Implementation of hook_load().
 */
function chatroom_chat_load($node) {
  $chat = new StdClass();
  if ($chat->chat = db_fetch_object(db_query("SELECT * FROM {chatroom_chat} WHERE nid = %d", $node->nid))) { 
    $chat->chat->chatroom = node_load($chat->chat->crid);
    $chat->chat->latest_msg = chatroom_chat_get_latest_message($node->nid);
    $chat->chat->msg_count = chatroom_chat_get_message_count($node->nid);
    if ($chat->chat->private) {
      $chat->chat->allowed_uids = chatroom_chat_load_allowed_uids($node);
    }
    return $chat;
  }
}

/**
 * Load a list of uids allowed in this chat.
 * 
 * @param mixed $node 
 * @return array
 */
function chatroom_chat_load_allowed_uids($node) {
  $uids = array();
  $result = db_query('SELECT uid FROM {chatroom_chat_user} WHERE nid = %d', $node->nid);
  while ($uid = db_result($result)) {
    $uids[] = $uid;
  }
  return $uids;
}

/**
 * Get the latest message id for a given chat.
 * 
 * @param mixed $chat_id 
 */
function chatroom_chat_get_latest_message($chat_id) {
  $sql = "SELECT cm.*, u.name 
          FROM {chatroom_msg} cm
          INNER JOIN {users} u ON u.uid = cm.uid
          WHERE ccid = %d 
          ORDER BY cmid 
          DESC LIMIT 1";
  return db_fetch_object(db_query($sql, $chat_id));
}

/**
 * Get the message count for a chat.
 */
function chatroom_chat_get_message_count($chat_id) {
  $sql = "SELECT COUNT(*) FROM {chatroom_msg} WHERE ccid = %d";
  return db_result(db_query($sql, $chat_id));
}

/**
 * Implementation of hook_view().
 */
function chatroom_view($node, $teaser = FALSE, $page = FALSE) {
  $node = node_prepare($node);
  if (!$teaser && $page) {
    // if the user is banned, just tell them why
    if (chatroom_is_banned_user($node)) {
      $node->content['body']['#value'] = !empty($node->banned_message) ? $node->banned_message : t('You have been banned from %chatroom.', array('%chatroom' => $node->title));
    }
    else {
      // if the user can create chats, show the form
      if (user_access('create chats')) {
        $node->content['add_chat'] = array(
          '#value' => drupal_get_form('chatroom_create_chat_form', $node),
          '#weight' => 1,
        );
      }

      // if there are some chats, build some tables to display them
      if (!empty($node->chatroom->chats)) {
        foreach ($node->chatroom->chats as $chat) {
          if ($chat->when_archived) {
            $rows['archived'][] = array(
              array('data' => l($chat->title, "node/$chat->nid")),
              array('data' => isset($chat->msg_count) ? $chat->msg_count : 0),
              array('data' => t('Archived on !date.', array('!date' => format_date($chat->when_archived, 'medium')))),
            );
          }
          else {
            $rows['open'][] = array(
              array('data' => l($chat->title, "node/$chat->nid")),
              array('data' => isset($chat->msg_count) ? $chat->msg_count : 0),
              array('data' => $chat->last_msg ? theme('chatroom_latest_message', $chat->last_msg) : ('No messages.')),
            );
          }
        }
        if (!empty($rows['open'])) {
          $node->content['open_chats']['#weight'] = 2;
          $node->content['open_chats']['title'] = array(
            '#value' => '<h2>'. t('Open chats in this room') .'</h2>',
            '#weight' => 0,
          );
          $node->content['open_chats']['table'] = array(
            '#value' => theme('table', array(t('Chat name'), t('Message count'), t('Last message')), $rows['open']),
            '#weight' => 1,
          );
        }
        if (!empty($rows['archived'])) {
          $node->content['archived_chats']['#weight'] = 3;
          $node->content['archived_chats']['header'] = array(
            '#value' => '<h2>'. t('Archived chats in this room') .'</h2>',
            '#weight' => 0,
          );
          $node->content['archived_chats']['table'] = array(
            '#value' => theme('table', array(t('Chat name'), t('Message count'), t('When archived')), $rows['archived']),
            '#weight' => 1,
          );
        }
      }
    }
  }
  else {
    $node->content['teaser'] = array('#value' => theme('chatroom_teaser', $node));
  }
  return $node;
}

/**
 * Implementation of hook_view().
 */
function chatroom_chat_view($node, $teaser = FALSE, $page = FALSE) {
  $node = node_prepare($node);
  if (!$teaser && $page) {
    drupal_add_css(drupal_get_path('module', 'chatroom') .'/chatroom.css');
    
    $bc = drupal_get_breadcrumb();
    if ($node->chat->chatroom) {
      $bc[] = l($node->chat->chatroom->title, "node/{$node->chat->chatroom->nid}");
    }
    $bc[] = l($node->title, "node/$node->nid");
    drupal_set_breadcrumb($bc);

    // Display a message if the user is banned.
    if (chatroom_is_banned_user($node)) {
      $content = theme('chatroom_chat_banned_user', $node);
    }
    elseif (!isset($node->chat->when_archived)) {
      if (!chatroom_chat_register_user($node)) {
        chatroom_update_last_seen_time($node, session_id());
      }
      $node->chat->users = chatroom_load_online_users($node);
      chatroom_add_js($node);
      $content = theme('chatroom_chat', $node);
    }
    else {
      $content = theme('chatroom_chat_archive', $node);
      if (user_access('administer chat rooms')) {
        $content .= drupal_get_form('chatroom_unarchive_chat_form', $node->nid);
      }
    }
    $node->content['chatroom_chat_interface'] = array('#value' => $content);
  }
  else {
    $node->content['teaser'] = array('#value' => theme('chatroom_chat_teaser', $node));
  }
  return $node; 
}

/**
 * Gets a list of banned users for a given chat room.
 */
function chatroom_get_banned_users($room) {
  $banned_users = array();
  $result = db_query("
    SELECT bl.uid, u.name FROM {chatroom_ban_list} bl
    INNER JOIN {users} u ON u.uid = bl.uid
    WHERE bl.nid = %d
  ", $room->nid);
  while ($user = db_fetch_object($result)) {
    $banned_users[$user->uid] = $user;
  }
  return $banned_users;
}

/**
 * Unarchive old chat.
 */
function chatroom_unarchive_chat($chat_id) {
  $result = db_query('UPDATE {chatroom_chat} SET when_archived = NULL WHERE nid = %d', $chat_id);
  return $result;
}

/**
 * Archive a chat.
 */
function chatroom_archive_chat($chat_id) {
  $result = db_query('UPDATE {chatroom_chat} SET when_archived = %d WHERE nid = %d', time(), $chat_id);
  return $result;
}

/**
 * Implementation of hook_block().
 */
function chatroom_block($op = 'list', $delta = 0, $edit = array()) {
  $block_name = $delta == 0 ? 'chats' : ($delta == 1 ? 'chatrooms' : '');
  switch ($op) {
    case 'list':
      $blocks[0] = array(
        'info' => t('Chat room: active chats'),
        'cache' => BLOCK_CACHE_GLOBAL,
        'visibility' => 0,
      );
      $blocks[1] = array(
        'info' => t('Chat room: active chat rooms'),
        'cache' => BLOCK_CACHE_GLOBAL,
        'visibility' => 0,
      );
      return $blocks;

    case 'configure':
      switch ($delta) {
        case 0:
          $items = t('chats');
          break;
        case 1:
          $items = t('chat rooms');
      }
      if (isset($items)) {
        $form["chatroom_block_$block_name"] = array(
          '#type' => 'select',
          '#title' => t('Number of !items to display', array('!items' => $items)),
          '#default_value' => variable_get("chatroom_block_$block_name", 5),
          '#options' => drupal_map_assoc(range(1, 15))
        );
        return $form;
      }
      break;

    case 'save':
      variable_set("chatroom_block_$block_name", $edit["chatroom_block_$block_name"]);
      break;

    case 'view':
      switch ($block_name) {
        case 'chats':
          if (user_access('access chats')) {
            return theme('chatroom_block_chats');
          }

        case 'chatrooms':
          if (user_access('access chat rooms')) {
            return theme('chatroom_block_chatrooms');
          }
      }
      break;
  }
}

/**
 * Get a list of active rooms.
 */
function chatroom_get_active_chatrooms($start = NULL, $end = NULL) {
  if ($cache = cache_get('chatroom_room_list')) {
    return $cache->data;
  }
  $result = db_query("SELECT nid FROM {node} WHERE type = 'chatroom' AND status = 1");
  $chatrooms = array();
  while ($nid = db_result($result)) {
    $chatrooms[] = node_load($nid);
  }
  drupal_alter('chatroom_room_list', $chatrooms);
  cache_set('chatroom_room_list', $chatrooms);
  return $chatrooms;
}

/**
 * Get a list of active chats.
 */
function chatroom_get_active_chats() {
  if ($cache = cache_get('chatroom_chat_list')) {
    return $cache->data;
  }
  $chats = array();
  $sql = "SELECT nid FROM {node} WHERE type = 'chat' AND status = 1";
  $result = db_query($sql);
  while ($nid = db_result($result)) {
    $chats[] = node_load($nid);
  }
  drupal_alter('chatroom_chat_list', $chatrooms);
  cache_set('chatroom_chat_list', $chats);
  return $chats;
}

/**
 * Display a page for a user kicked out or banned from a chat.
 * 
 * @param mixed $node 
 * @param mixed $type 
 */
function chatroom_access_denied($node, $type) {
  if ($type == 'banned') {
    $content = theme('chatroom_chat_banned_user', $node);
  }
  else {
    $content = theme('chatroom_chat_kicked_user', $node);
  }
  return $content;
}

/**
 * Move old messages to archive.
 */
function chatroom_archive_old_msgs($chat_id) {
  db_query("UPDATE {chatroom_msg} set archived = 1 WHERE ccid = %d", $chat_id);
}

/**
 * Update an invite and set it to accepted.
 * 
 * @param mixed $node 
 * @param mixed $chat_user 
 * @return void
 */
function chatroom_chat_accept_invite($node, $chat_user) {
  $sql = "UPDATE {chatroom_chat_invite} SET accepted = 1 WHERE nid = %d AND initee_uid = %d";
  db_query($sql, $node->nid, $chat_user->uid);
  foreach (module_implements('chatroom_chat_invite_accepted') as $module) {
    $function = $module . '_chatroom_chat_invite_accepted';
    $function($node, $chat_user);
  }
}

/**
 * Check to see if a user has an invite to the given chat.
 * 
 * @param mixed $node 
 * @param mixed $chat_user 
 * @return boolean
 */
function chatroom_chat_user_has_invite($node, $chat_user) {
  $sql = "SELECT nid FROM {chatroom_chat_invite} WHERE invitee_uid = %d AND nid = %d";
  return db_result(db_query($sql, $chat_user->uid, $node->nid));
}

/**
 * Register a user in a chat.
 */
function chatroom_chat_register_user($node) {
  global $user;

  $session_id = session_id();
  if (!db_result(db_query("SELECT sid FROM {chatroom_chat_online_list} WHERE ccid = %d AND sid = '%s'", $node->nid, $session_id))) {

    if (chatroom_chat_user_has_invite($node, $user)) {
      chatroom_accept_invite($node, $user);
    }

    $params = array($node->nid, $user->uid, $session_id, time());
    if ($user->uid) {
      $sql = "INSERT INTO {chatroom_chat_online_list} (ccid, uid, sid, last_seen_time) VALUES (%d, %d, '%s', %d)";
    }
    else {
      $sql = "INSERT INTO {chatroom_chat_online_list} (ccid, uid, sid, guest_id, last_seen_time) 
                SELECT %d, %d, '%s', COALESCE(MAX(guest_id) + 1, 1), %d
                FROM {chatroom_chat_online_list} 
                WHERE ccid = %d";
      $params[] = $node->nid;
    }
    return db_query($sql, $params);
  }
  return FALSE;
}

/**
 * Add settings to chat page.
 */
function chatroom_add_js($node) {
  global $user;
  $js = array(
    'pollInterval' => (int) isset($node->chat) ? $node->chat->poll_freq : 1,
    'idleInterval' => (int) $node->chat->idle_freq,
    'chatId'       => (int) $node->nid,
    'popoutParams' => chatroom_get_popout_params($node),
    'cacheDirectory' => variable_get('chatroom_cache_directory', '/tmp'), 
    'postMessagePath' => 'chatroom/chat/post/message',
    'chatPath' => 'node/' . $node->nid,
		'successiveCacheHits' => 0,
    'skipCacheCheckCount' => 5,
    'latestMsgId' => $node->chat->latest_msg ? $node->chat->latest_msg->cmid : 0,
    'accessDeniedPath' => 'chatroom/access-denied',
    'viewAsPopout' => $node->chat->popout,
    'popoutRedirect' => 'chatroom/popout/redirect',
  );

  if (variable_get('configurable_timezones', 1) && $user->uid && drupal_strlen($user->timezone)) {
    $js['timezone'] = $user->timezone;
  }
  else {
    $js['timezone'] = variable_get('date_default_timezone', 0);
  }
  if (isset($node->chat, $node->chat->latest_msg_id)) {
    $js['latestMsgId'] = $node->chat->latest_msg_id;
  }

  // Allow modules to alter the js settings sent down for a chat.
  drupal_alter('chatroom_js_settings', $js);

  drupal_add_js(drupal_get_path('module', 'chatroom') . '/chatroom.js');
  drupal_add_js(array('chatroom' => $js), 'setting');
}

/**
 * Get messages for a given chat.
 *
 * @param $chat_id
 *   The chat id.
 * @param $last_cmid
 *   Only load messages with cmids greater than this value.
 * @param $limit
 *   Default: FALSE.
 * @return array $messages
*/
function chatroom_chat_load_messages($chat_id, $last_cmid = 0, $limit = FALSE) {
  $sql = "SELECT cm.*, u.name, 0 guest_id
          FROM {chatroom_msg} cm
          INNER JOIN {users} u ON u.uid = cm.uid
          WHERE cm.ccid = %d 
          AND cm.cmid > %d 
          ORDER BY cm.cmid ASC";
  $args = array($chat_id, $last_cmid);
  if ($limit) {
    $sql .= ' LIMIT %d';
    $args[] = $limit;
  }
  $result = db_query($sql, $args);

  $messages = array();
  $guest_sids = array();
  while ($message = db_fetch_object($result)) {
    if ($message->uid == 0 && !in_array($message->sid, $guest_sids)) {
      $guest_sids[] = $message->sid;
      $message->name = variable_get('chatroom_guest_user_prefix', 'guest-');
    }
    $messages[$message->cmid] = $message;
  }

  if (!empty($guest_sids)) {
    $sql = "SELECT sid, guest_id FROM {chatroom_chat_online_list} WHERE sid IN (" . db_placeholders($guest_sids, 'varchar') . ")";
    $result = db_query($sql, $guest_sids);
    while ($guest = db_fetch_object($result)) {
      foreach ($messages as $message) {
        if ($message->sid == $guest->sid) {
          $messages[$message->cmid]->guest_id = $guest->guest_id;
          $messages[$message->cmid]->name .= $guest->guest_id;
        }
      }
    }
  }
  return $messages;
}

/**
 * Load online users for the given chat.
 */
function chatroom_load_online_users($chat) {
  global $user;

  $sql = "SELECT col.*, u.name, u.picture
          FROM {chatroom_chat_online_list} col
          LEFT JOIN {users} u ON u.uid = col.uid
          WHERE col.ccid = %d
          AND col.last_seen_time >= %d
          ORDER BY u.name ASC";
  $sql = db_rewrite_sql($sql, 'col', 'sid', array('chatroom_chat_online_list' => TRUE));
  $result = db_query($sql, $chat->nid, time() - variable_get('chatroom_online_list_timeout', 10));
  $chat_users = array();
  $logged_in_users = array();
  while ($chat_user = db_fetch_object($result)) {
    if ($chat_user->uid == 0) {
      $chat_user->name = variable_get('chatroom_guest_user_prefix', 'guest-') . $u->guest_id;
    }
    else if (in_array($chat_user->uid, $logged_in_users)) {
      continue;
    }
    if ($chat_user->uid != 0) {
      $logged_in_users[] = $chat_user->uid;
    }
    $chat_users[$chat_user->sid] = $chat_user;
  }
  return $chat_users;
}

/**
 * updates chat's cache file modified time
 */
function chatroom_chat_update_cache($chat_id, $latest_msg_id) {
  $cache_file = variable_get('chatroom_cache_directory', '/tmp') . '/chatroom.chat.' . $chat_id . '.cache';
  file_put_contents($cache_file, "$latest_msg_id\n");
}

/**
 * Check if the current user is banned from the chat room.
 */
function chatroom_is_banned_user($room) {
  global $user;
  // If the node is already loaded, check the ban list. Otherwise, query the
  // database.
  if (isset($room->banned_list) && is_array($room->banned_list)) {
    return in_array($user->uid, array_keys($room->banned_list));
  }
  else {
    return db_result(db_query("SELECT nid FROM {chatroom_ban_list} WHERE nid = %d AND uid = %d", $room->nid, $user->uid));
  }
}

/**
 * Get the latest messages for a chat, and send back to the client.
 */
function chatroom_chat_get_latest_messages($node, $last_msg_id, $command_response = FALSE) {
  global $user;

  if ($node->chat->private && $node->uid != $user->uid && !in_array($user->uid, $node->chat->allowed_uids)) {
    drupal_json(array('data' => array('accessDenied' => 'kicked', 'messages' => array())));
    return;
  }

  if (chatroom_chat_is_banned_user($user, $node)) {
    drupal_json(array('data' => array('accessDenied' => 'banned', 'messages' => array())));
    return;
  }

  if (chatroom_chat_is_kicked_user($user, $node)) {
    print drupal_json(array('data' => array('accessDenied' => 'kicked', 'messages' => array())));
    return;
  }

  $response['messages'] = array();
  if ($node->chat->when_archived) {
    $response['archived'] = $node->chat->when_archived;
    drupal_set_message(t('This chat has been archived.'));
  }
  else {
    chatroom_update_last_seen_time($node, session_id()); 

    foreach (chatroom_chat_load_messages($node->nid, $last_msg_id) as $message) {
      if ($message->msg_type == 'private_message' && $user->uid != $message->recipien_uid) {
        continue;
      }
      $msg = new StdClass();
      $msg->html = theme('chatroom_message', $message, $node);
      $msg->text = strip_tags($message->msg);
      $msg->name = $message->name;
      $msg->cmid = $message->cmid;
      $msg->type = $message->msg_type;
      $response['messages'][] = $msg;
      $latest_msg_id = $message->cmid;
    }
    if (isset($latest_msg_id)) {
      chatroom_chat_update_cache($node->nid, $latest_msg_id);
    }

    $response['usersHtml'] = theme('chatroom_user_list', chatroom_load_online_users($node), $node);
    if (is_object($command_response)) {
      $response['commandResponse'] = $command_response;
    }
  }
  drupal_json(array('data' => $response));
}

/**
 * Posted messages are handled here.
 * 
 * @return void
 */
function chatroom_chat_post_message($node, $last_msg_id) {
  global $user;

  // Check we have a message posted.
  if (!isset($_POST['message'])) {
    exit;
  }

  if ($node->chat->private && $node->uid != $user->uid && !in_array($user->uid, $node->chat->allowed_uids)) {
    drupal_json(array('data' => array('accessDenied' => 'kicked', 'messages' => array())));
    return;
  }

 if (chatroom_chat_is_banned_user($user, $node)) {
    print drupal_json(array('data' => array('accessDenied' => 'banned', 'messages' => array())));
    return;
  }

  if (chatroom_chat_is_kicked_user($user, $node)) {
    print drupal_json(array('data' => array('accessDenied' => 'kicked', 'messages' => array())));
    return;
  }

  $message = array(
    'ccid' => $node->chat->nid, 
    'uid' => $user->uid, 
    'msg' => $_POST['message'],
    'sid' => session_id(), 
    'msg_type' => chatroom_chat_get_message_type($_POST['message']),
    'recipient_uid' => 0, 
    'modified' => time(),
  );
  if ($message['msg_type'] == 'command') {
    $result = chatroom_chat_call_command($message, $node);
  }
  else {
    $result = chatroom_chat_save_message($message, $node);
  }
  chatroom_chat_get_latest_messages($node, $last_msg_id, $result);
}

/**
 * Write a message into a chat, and allow any interested modules to react.
 *
 * @param array $message 
 * @param StdClass $node 
 * @return boolean
 */
function chatroom_chat_save_message($message, $node) {
  drupal_alter('chatroom_chat_msg', $message);
  if (drupal_write_record('chatroom_msg', $message)) {
    $node->chat->latest_msg_id = $message['cmid'];
    foreach (module_implements('chat_msg_saved') as $module) {
      $function = $module . '_chat_msg_saved';
      $function($message, $node);
    }
    return $message['cmid'];
  }
  return FALSE;
}

/**
 * Implementation of hook_chat_commands().
 */
function chatroom_chat_commands() {
  return array(
    'kick' => array(
      'callback' => 'chatroom_command_kick_user',
    ),
    'ban' => array(
      'callback' => 'chatroom_command_ban_user',
    ),
    'msg' => array(
      'callback' => 'chatroom_command_msg_user',
    ),
  );
}

/**
 * Implementation of hook_chat_command_api().
 *
 * This hook allows other modules to react to commands defined by other
 * modules. This hook is only fired after the module that defines the
 * command has run its callback code for the given command.
 *
 * The return value from a modules' callback are stored in the command
 * object in $command->callback_result.
 */
function chatroom_chat_command_api($command, $node) {
  watchdog('chatroom', __FUNCTION__ . ' invoked with command %command for chat %chat.', array('%command' => $command->name, '%chat' => $node->title));
}

/**
 * Ban a user from a chat.
 * 
 * @param mixed $command 
 * @param mixed $node 
 * @return boolean
 */
function chatroom_command_ban_user($command, $node) {
  global $user;
  if ($user_to_ban = chatroom_get_user_from_command_arg($command->args[0])) {
    if (chatroom_ban_user($node, $user_to_ban, $user)) {
      $params = array(
        '!banned_username' => $user_to_ban->name, 
        '!chat' => $node->title,
        '!chat_admin_username' => $user->name, 
      );
      $response = new StdClass();
      $response->name = 'banned';
      $response->msg = t('User !banned_username banned from chat !chat by !chat_admin_username.', $params);
      return $response;
    }
  }
  return FALSE;
}

/**
 * Respond to a command to kick a user out of a chat.
 * 
 * @param mixed $command 
 * @param mixed $node 
 * @return boolean
 */
function chatroom_command_kick_user($command, $node) {
  global $user;
  if ($user_to_kick = chatroom_get_user_from_command_arg($command->args[0])) {
    if (chatroom_kick_user($node, $user_to_kick, $user)) {
      $params = array(
        '!kicked_username' => $user_to_kick->name, 
        '!chat' => $node->title,
        '!chat_admin_username' => $user->name, 
      );
      $response = new StdClass();
      $response->name = 'kicked';
      $response->msg = t('User !kicked_username kicked out of chat !chat by !chat_admin_username.', $params);
      return $response;
    }
  }
  return FALSE;
}

/**
 * Respond to a command to send a message to a specific user in a chat.
 * 
 * @param mixed $command 
 * @param mixed $node 
 * @return boolean
 */
function chatroom_command_msg_user($command, $node) {
  global $user;

  // The second arg is the message, so if there isn't one, just bail.
  if (count($command->args) < 2) {
    return FALSE;
  }
  if ($to_user = chatroom_get_user_from_command_arg(array_shift($command->args))) {
    return chatroom_msg_user($node, $to_user, $user, implode(' ', $command->args));
  }
  return FALSE;
}

/**
 * Ban a user from a chat.
 * 
 * @param mixed $node 
 * @param mixed $user_to_ban
 * @param mixed $chat_admin_user 
 * @return boolean
 */
function chatroom_ban_user($node, $user_to_ban, $chat_admin_user) {
  if ($user_to_ban->uid == $chat_admin_user->uid) {
    return FALSE;
  }
  if (user_access('administer chats', $chat_admin_user) || $node->uid == $chat_admin_user->uid) {
    $ban_data = array(
      'nid' => $node->nid,
      'uid' => $user_to_ban->uid,
      'admin_uid' => $chat_admin_user->uid,
      'modified' => time(),
    );
