social_stream-presence 0.8.4 → 0.8.6

data/lib/social_stream-presence.rb

@@ -14,9 +14,9 @@ module SocialStream
 
     module Models
       autoload :BuddyManager, 'social_stream/presence/models/buddy_manager'
+      autoload :GroupManager, 'social_stream/presence/models/group_manager'
     end
 
-
     mattr_accessor :domain
     mattr_accessor :bosh_service
     mattr_accessor :auth_method

data/lib/social_stream/presence/engine.rb

@@ -6,6 +6,12 @@ module SocialStream
           include SocialStream::Presence::Models::BuddyManager
         end
       end
+      
+      initializer "social_stream-presence.group" do
+        ActiveSupport.on_load(:group) do
+          include SocialStream::Presence::Models::GroupManager
+        end
+      end
 
       initializer "social_stream-presence.views.settings" do
         SocialStream::Views::Settings.module_eval do

data/lib/social_stream/presence/models/buddy_manager.rb

@@ -23,35 +23,41 @@ module SocialStream
             return
           end
 
-          #WEB DOMAIN
-          domain = SocialStream::Presence.domain
-          user_sid = self.sender.slug + "@" + domain
-          user_name =  self.sender.name  
-          buddy_sid = self.receiver.slug + "@" + domain
-          buddy_name =  self.receiver.name
-          site_name = I18n.t('site.name').delete(' ')
-          
-          #Check if is a positive and replied tie         
-          if self.bidirectional?
-            #Execute setRosterForBidirectionalTie(userASid,userBSid,userANick,userBNick,groupForA,groupForB)
-            SocialStream::Presence::XmppServerOrder::setRosterForBidirectionalTie(user_sid,buddy_sid,user_name,buddy_name,site_name,site_name)
-          elsif self.positive?
-            #Case: Possitive tie unidirectional
-            #Execute addBuddyToRoster(userSID,buddySID,buddyNick,buddyGroup,subscription_type)
-            subscription_type = "from"
-            SocialStream::Presence::XmppServerOrder::addBuddyToRoster(user_sid,buddy_sid,buddy_name,site_name,subscription_type)
-          else
-            #Negative Tie
+          begin
+            #WEB DOMAIN
+            domain = SocialStream::Presence.domain
+            user_sid = self.sender.slug + "@" + domain
+            user_name =  self.sender.name  
+            buddy_sid = self.receiver.slug + "@" + domain
+            buddy_name =  self.receiver.name
+            site_name = I18n.t('site.name').delete(' ')
             
-            if self.contact.positive_replied?
-              #Bidirectional contacts
-              #Execute unsetRosterForBidirectionalTie(user_sid,oldfriend_sid,oldfriendNick,oldfriendGroup)
-              SocialStream::Presence::XmppServerOrder::unsetRosterForBidirectionalTie(buddy_sid,user_sid,user_name,site_name)
+            #Check if is a positive and replied tie         
+            if self.bidirectional?
+              #Execute setRosterForBidirectionalTie(userASid,userBSid,userANick,userBNick,groupForA,groupForB)
+              SocialStream::Presence::XmppServerOrder::setRosterForBidirectionalTie(user_sid,buddy_sid,user_name,buddy_name,site_name,site_name)
+            elsif self.positive?
+              #Case: Possitive tie unidirectional
+              #Execute addBuddyToRoster(userSID,buddySID,buddyNick,buddyGroup,subscription_type)
+              subscription_type = "from"
+              SocialStream::Presence::XmppServerOrder::addBuddyToRoster(user_sid,buddy_sid,buddy_name,site_name,subscription_type)
             else
-              SocialStream::Presence::XmppServerOrder::removeBuddyFromRoster(user_sid,buddy_sid)
+              #Negative Tie
+              
+              if self.contact.positive_replied?
+                #Bidirectional contacts
+                #Execute unsetRosterForBidirectionalTie(user_sid,oldfriend_sid,oldfriendNick,oldfriendGroup)
+                SocialStream::Presence::XmppServerOrder::unsetRosterForBidirectionalTie(buddy_sid,user_sid,user_name,site_name)
+              else
+                SocialStream::Presence::XmppServerOrder::removeBuddyFromRoster(user_sid,buddy_sid)
+              end
+              
+              return  
             end
-            
-            return  
+          
+          rescue Exception => e
+            logger.warn ("WARNING Exeception in Buddy Manager save_buddy: " + e.message)
+            puts ("WARNING Exeception in Buddy Manager save_buddy: " + e.message)
           end
           
         end

data/lib/social_stream/presence/models/group_manager.rb

@@ -0,0 +1,51 @@
+module SocialStream
+  module Presence
+    module Models
+      module GroupManager
+        extend ActiveSupport::Concern
+        
+        included do
+          after_create :create_group_room
+          after_destroy :remove_group_room
+        end
+        
+        def create_group_room
+          
+          unless SocialStream::Presence.enable
+            return
+          end
+          
+          unless self.subject_type == "Group"
+            return
+          end 
+          
+          begin
+            SocialStream::Presence::XmppServerOrder::createPersistentRoom(self.slug,SocialStream::Presence.domain)
+          rescue Exception => e
+            logger.warn ("WARNING Exeception in Group Manager create_group_room: " + e.message)
+            puts ("WARNING Exeception in Group Manager create_group_room: " + e.message)
+          end
+        end
+        
+        
+        def remove_group_room
+           
+            unless SocialStream::Presence.enable
+              return
+            end
+            
+            unless self.subject_type == "Group"
+              return
+            end
+            
+            begin
+              SocialStream::Presence::XmppServerOrder::destroyRoom(self.slug,SocialStream::Presence.domain)
+            rescue Exception => e 
+              logger.warn ("WARNING Exeception in Group Manager remove_group_room: " + e.message)
+              puts ("WARNING Exeception in Group Manager remove_group_room: " + e.message)
+            end
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/presence/version.rb

@@ -1,5 +1,5 @@
 module SocialStream
   module Presence
-    VERSION = "0.8.4"
+    VERSION = "0.8.6"
   end
 end

data/lib/social_stream/presence/xmpp_server_order.rb

@@ -7,7 +7,11 @@ module SocialStream
     class XmppServerOrder
       
       class << self
-               
+          
+          ##################
+          #Emanagement Calls
+          ##################
+    
           def setRosterForBidirectionalTie(userASid,userBSid,userANick,userBNick,groupForA,groupForB)
               executeEmanagementCommand("setBidireccionalBuddys",[userASid,userBSid,userANick,userBNick,groupForA,groupForB])
           end 
@@ -27,8 +31,23 @@ module SocialStream
               executeEmanagementCommand("removeBuddyFromRoster",[userSid,buddySid])
           end   
           
+          
+          def createPersistentRoom(roomName,domain)
+              executeEmanagementCommand("createPersistentRoom",[roomName,domain])
+          end
+          
+          
+          def destroyRoom(roomName,domain)
+              executeEmanagementCommand("destroyRoom",[roomName,domain])
+          end
+         
          
+         
+         
+          ##################
           # Presence synchronization
+          ##################
+          
           def synchronizePresence(webDomain)
             if isEjabberdNodeUp
               if (webDomain=="all")
@@ -106,8 +125,12 @@ module SocialStream
           end
           
           
-                    
-          # Rosters synchronization  
+          
+          
+          ##################
+          #  Rosters synchronization
+          ################## 
+         
           def removeAllRosters(webDomain)
               executeEmanagementCommand("removeAllRostersByDomain",[webDomain])
           end
@@ -140,7 +163,39 @@ module SocialStream
           end
           
           
-          #Installation methods
+          
+                    
+          ##################
+          #  Room (MUC) synchronization
+          ################## 
+          
+          def removeAllRooms(webDomain)
+              executeEmanagementCommand("destroyAllRoomsByDomain",[webDomain])
+          end
+          
+          
+          def synchronizeRooms(webDomain)
+            commands = []
+            
+            #Remove all mucs
+            commands << buildCommand("emanagement","destroyAllRoomsByDomain",[webDomain])
+
+            #Populate mucs
+            groups = Group.all
+
+            groups.each do |group|
+              commands << buildCommand("emanagement","createRoom",[group.slug,webDomain])
+            end
+            
+            executeCommands(commands)
+          end
+         
+         
+         
+         
+          ##################
+          #  Installation methods
+          ##################
           
           def copyFolderToXmppServer(oPath,dPath)
             if SocialStream::Presence.remote_xmpp_server
@@ -311,7 +366,12 @@ module SocialStream
             puts "Finish"
           end
           
-          #Execution commands manage  
+          
+          
+          
+          ##################
+          #  Execution commands management
+          ##################
         
           def buildCommand(script,order,params)
             command = SocialStream::Presence.scripts_path + "/" + script + " " + order
@@ -411,7 +471,12 @@ module SocialStream
           end
 
         
-          #Authorization methods
+        
+        
+          ##################
+          #  Authorization methods
+          ##################
+          
           def authorization(params)
             case SocialStream::Presence.secure_rest_api
             when true
@@ -509,11 +574,15 @@ module SocialStream
               #Non Secure Mode
               return params
             end
-          end
+          end        
         
         
-         #Help methods
-         
+        
+
+          ##################
+          #  Help methods
+          ##################
+          
           def isEjabberdNodeUp
               output = executeEmanagementCommand("isEjabberdNodeStarted",[])
               nodeUp = output.split("\n")[0]
@@ -536,7 +605,12 @@ module SocialStream
           end
         
           
-          #Multidomain tasks
+          
+          
+          ##################
+          #  Multidomain tasks
+          ##################
+          
           def addWebDomain(domain,url)
             commands = []
             if url

data/lib/tasks/presence/synchronize.rake

@@ -32,5 +32,20 @@ namespace :presence do
         SocialStream::Presence::XmppServerOrder::synchronizeRosters(domain)
         puts "Rosters Synchronization complete"
     end
+    
+    desc "Synchronize Xmpp Server database with Social Stream Rails Application database."
+    desc "Remove all rooms and create one room (also knowledge as MUC) for each Social Stream group."
+    task :rooms, [:domain] => :environment do |t, args| 
+        puts "Starting presence:synchronize:rooms"
+        unless args[:domain]
+          puts "No web domain specified"
+          domain = SocialStream::Presence.domain
+          puts "Executing  rake presence:synchronize:rooms[" + domain + "]"
+        else
+          domain = args[:domain]
+        end
+        SocialStream::Presence::XmppServerOrder::synchronizeRooms(domain)
+        puts "Rooms Synchronization complete"
+    end
   end
 end

data/vendor/assets/javascripts/strophe.muc.js

@@ -0,0 +1,934 @@
+/*
+ *Plugin to implement the MUC extension.
+   http://xmpp.org/extensions/xep-0045.html
+ *Previous Author:
+    Nathan Zorn <nathan.zorn@gmail.com>
+ *Complete CoffeeScript rewrite:
+    Andreas Guth <guth@dbis.rwth-aachen.de>
+*/
+var Occupant, RoomConfig, XmppRoom,
+  __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+Strophe.addConnectionPlugin('muc', {
+  _connection: null,
+  rooms: [],
+  /*Function
+  Initialize the MUC plugin. Sets the correct connection object and
+  extends the namesace.
+  */
+  init: function(conn) {
+    this._connection = conn;
+    this._muc_handler = null;
+    Strophe.addNamespace('MUC_OWNER', Strophe.NS.MUC + "#owner");
+    Strophe.addNamespace('MUC_ADMIN', Strophe.NS.MUC + "#admin");
+    Strophe.addNamespace('MUC_USER', Strophe.NS.MUC + "#user");
+    return Strophe.addNamespace('MUC_ROOMCONF', Strophe.NS.MUC + "#roomconfig");
+  },
+  /*Function
+  Join a multi-user chat room
+  Parameters:
+  (String) room - The multi-user chat room to join.
+  (String) nick - The nickname to use in the chat room. Optional
+  (Function) msg_handler_cb - The function call to handle messages from the
+  specified chat room.
+  (Function) pres_handler_cb - The function call back to handle presence
+  in the chat room.
+  (String) password - The optional password to use. (password protected
+  rooms only)
+  */
+  join: function(room, nick, msg_handler_cb, pres_handler_cb, roster_cb, password) {
+    var msg, room_nick, _base,
+      _this = this;
+    room_nick = this.test_append_nick(room, nick);
+    msg = $pres({
+      from: this._connection.jid,
+      to: room_nick
+    }).c("x", {
+      xmlns: Strophe.NS.MUC
+    });
+    if (password != null) msg.cnode(Strophe.xmlElement("password", [], password));
+    if (this._muc_handler == null) {
+      this._muc_handler = this._connection.addHandler(function(stanza) {
+        var from, handler, handlers, id, roomname, x, xmlns, xquery, _i, _len;
+        from = stanza.getAttribute('from');
+        roomname = from.split("/")[0];
+        if (!_this.rooms[roomname]) return true;
+        room = _this.rooms[roomname];
+        handlers = {};
+        if (stanza.nodeName === "message") {
+          handlers = room._message_handlers;
+        } else if (stanza.nodeName === "presence") {
+          xquery = stanza.getElementsByTagName("x");
+          if (xquery.length > 0) {
+            for (_i = 0, _len = xquery.length; _i < _len; _i++) {
+              x = xquery[_i];
+              xmlns = x.getAttribute("xmlns");
+              if (xmlns && xmlns.match(Strophe.NS.MUC)) {
+                handlers = room._presence_handlers;
+                break;
+              }
+            }
+          }
+        }
+        for (id in handlers) {
+          handler = handlers[id];
+          if (!handler(stanza, room)) delete handlers[id];
+        }
+        return true;
+      });
+    }
+    if ((_base = this.rooms)[room] == null) {
+      _base[room] = new XmppRoom(this, room, nick, password);
+    }
+    if (pres_handler_cb) this.rooms[room].addHandler('presence', pres_handler_cb);
+    if (msg_handler_cb) this.rooms[room].addHandler('message', msg_handler_cb);
+    if (roster_cb) this.rooms[room].addHandler('roster', roster_cb);
+    return this._connection.send(msg);
+  },
+  /*Function
+  Leave a multi-user chat room
+  Parameters:
+  (String) room - The multi-user chat room to leave.
+  (String) nick - The nick name used in the room.
+  (Function) handler_cb - Optional function to handle the successful leave.
+  (String) exit_msg - optional exit message.
+  Returns:
+  iqid - The unique id for the room leave.
+  */
+  leave: function(room, nick, handler_cb, exit_msg) {
+    var presence, presenceid, room_nick;
+    delete this.rooms[room];
+    if (this.rooms.length === 0) {
+      this._connection.deleteHandler(this._muc_handler);
+      this._muc_handler = null;
+    }
+    room_nick = this.test_append_nick(room, nick);
+    presenceid = this._connection.getUniqueId();
+    presence = $pres({
+      type: "unavailable",
+      id: presenceid,
+      from: this._connection.jid,
+      to: room_nick
+    });
+    if (exit_msg != null) presence.c("status", exit_msg);
+    if (handler_cb != null) {
+      this._connection.addHandler(handler_cb, null, "presence", null, presenceid);
+    }
+    this._connection.send(presence);
+    return presenceid;
+  },
+  /*Function
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) nick - The nick name used in the chat room.
+  (String) message - The plaintext message to send to the room.
+  (String) html_message - The message to send to the room with html markup.
+  (String) type - "groupchat" for group chat messages o
+                  "chat" for private chat messages
+  Returns:
+  msgiq - the unique id used to send the message
+  */
+  message: function(room, nick, message, html_message, type) {
+    var msg, msgid, parent, room_nick;
+    room_nick = this.test_append_nick(room, nick);
+    type = type || (nick != null ? "chat" : "groupchat");
+    msgid = this._connection.getUniqueId();
+    msg = $msg({
+      to: room_nick,
+      from: this._connection.jid,
+      type: type,
+      id: msgid
+    }).c("body", {
+      xmlns: Strophe.NS.CLIENT
+    }).t(message);
+    msg.up();
+    if (html_message != null) {
+      msg.c("html", {
+        xmlns: Strophe.NS.XHTML_IM
+      }).c("body", {
+        xmlns: Strophe.NS.XHTML
+      }).h(html_message);
+      if (msg.node.childNodes.length === 0) {
+        parent = msg.node.parentNode;
+        msg.up().up();
+        msg.node.removeChild(parent);
+      } else {
+        msg.up().up();
+      }
+    }
+    msg.c("x", {
+      xmlns: "jabber:x:event"
+    }).c("composing");
+    this._connection.send(msg);
+    return msgid;
+  },
+  /*Function
+  Convenience Function to send a Message to all Occupants
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) message - The plaintext message to send to the room.
+  (String) html_message - The message to send to the room with html markup.
+  Returns:
+  msgiq - the unique id used to send the message
+  */
+  groupchat: function(room, message, html_message) {
+    return this.message(room, null, message, html_message);
+  },
+  /*Function
+  Send a mediated invitation.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) receiver - The invitation's receiver.
+  (String) reason - Optional reason for joining the room.
+  Returns:
+  msgiq - the unique id used to send the invitation
+  */
+  invite: function(room, receiver, reason) {
+    var invitation, msgid;
+    msgid = this._connection.getUniqueId();
+    invitation = $msg({
+      from: this._connection.jid,
+      to: room,
+      id: msgid
+    }).c('x', {
+      xmlns: Strophe.NS.MUC_USER
+    }).c('invite', {
+      to: receiver
+    });
+    if (reason != null) invitation.c('reason', reason);
+    this._connection.send(invitation);
+    return msgid;
+  },
+  /*Function
+  Send a direct invitation.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) receiver - The invitation's receiver.
+  (String) reason - Optional reason for joining the room.
+  (String) password - Optional password for the room.
+  Returns:
+  msgiq - the unique id used to send the invitation
+  */
+  directInvite: function(room, receiver, reason, password) {
+    var attrs, invitation, msgid;
+    msgid = this._connection.getUniqueId();
+    attrs = {
+      xmlns: 'jabber:x:conference',
+      jid: room
+    };
+    if (reason != null) attrs.reason = reason;
+    if (password != null) attrs.password = password;
+    invitation = $msg({
+      from: this._connection.jid,
+      to: receiver,
+      id: msgid
+    }).c('x', attrs);
+    this._connection.send(invitation);
+    return msgid;
+  },
+  /*Function
+  Queries a room for a list of occupants
+  (String) room - The multi-user chat room name.
+  (Function) success_cb - Optional function to handle the info.
+  (Function) error_cb - Optional function to handle an error.
+  Returns:
+  id - the unique id used to send the info request
+  */
+  queryOccupants: function(room, success_cb, error_cb) {
+    var attrs, info;
+    attrs = {
+      xmlns: Strophe.NS.DISCO_ITEMS
+    };
+    info = $iq({
+      from: this._connection.jid,
+      to: room,
+      type: 'get'
+    }).c('query', attrs);
+    return this._connection.sendIQ(info, success_cb, error_cb);
+  },
+  /*Function
+  Start a room configuration.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (Function) handler_cb - Optional function to handle the config form.
+  Returns:
+  id - the unique id used to send the configuration request
+  */
+  configure: function(room, handler_cb) {
+    var config, id, stanza;
+    config = $iq({
+      to: room,
+      type: "get"
+    }).c("query", {
+      xmlns: Strophe.NS.MUC_OWNER
+    });
+    stanza = config.tree();
+    id = this._connection.sendIQ(stanza);
+    if (handler_cb != null) {
+      this._connection.addHandler(function(stanza) {
+        handler_cb(stanza);
+        return false;
+      }, Strophe.NS.MUC_OWNER, "iq", null, id);
+    }
+    return id;
+  },
+  /*Function
+  Cancel the room configuration
+  Parameters:
+  (String) room - The multi-user chat room name.
+  Returns:
+  id - the unique id used to cancel the configuration.
+  */
+  cancelConfigure: function(room) {
+    var config, stanza;
+    config = $iq({
+      to: room,
+      type: "set"
+    }).c("query", {
+      xmlns: Strophe.NS.MUC_OWNER
+    }).c("x", {
+      xmlns: "jabber:x:data",
+      type: "cancel"
+    });
+    stanza = config.tree();
+    return this._connection.sendIQ(stanza);
+  },
+  /*Function
+  Save a room configuration.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (Array) configarray - an array of form elements used to configure the room.
+  Returns:
+  id - the unique id used to save the configuration.
+  */
+  saveConfiguration: function(room, configarray) {
+    var conf, config, stanza, _i, _len;
+    config = $iq({
+      to: room,
+      type: "set"
+    }).c("query", {
+      xmlns: Strophe.NS.MUC_OWNER
+    }).c("x", {
+      xmlns: "jabber:x:data",
+      type: "submit"
+    });
+    for (_i = 0, _len = configarray.length; _i < _len; _i++) {
+      conf = configarray[_i];
+      config.cnode(conf).up();
+    }
+    stanza = config.tree();
+    return this._connection.sendIQ(stanza);
+  },
+  /*Function
+  Parameters:
+  (String) room - The multi-user chat room name.
+  Returns:
+  id - the unique id used to create the chat room.
+  */
+  createInstantRoom: function(room) {
+    var roomiq;
+    roomiq = $iq({
+      to: room,
+      type: "set"
+    }).c("query", {
+      xmlns: Strophe.NS.MUC_OWNER
+    }).c("x", {
+      xmlns: "jabber:x:data",
+      type: "submit"
+    });
+    return this._connection.sendIQ(roomiq.tree());
+  },
+  /*Function
+  Set the topic of the chat room.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) topic - Topic message.
+  */
+  setTopic: function(room, topic) {
+    var msg;
+    msg = $msg({
+      to: room,
+      from: this._connection.jid,
+      type: "groupchat"
+    }).c("subject", {
+      xmlns: "jabber:client"
+    }).t(topic);
+    return this._connection.send(msg.tree());
+  },
+  /*Function
+  Internal Function that Changes the role or affiliation of a member
+  of a MUC room. This function is used by modifyRole and modifyAffiliation.
+  The modification can only be done by a room moderator. An error will be
+  returned if the user doesn't have permission.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (Object) item - Object with nick and role or jid and affiliation attribute
+  (String) reason - Optional reason for the change.
+  (Function) handler_cb - Optional callback for success
+  (Function) errer_cb - Optional callback for error
+  Returns:
+  iq - the id of the mode change request.
+  */
+  _modifyPrivilege: function(room, item, reason, handler_cb, error_cb) {
+    var iq;
+    iq = $iq({
+      to: room,
+      type: "set"
+    }).c("query", {
+      xmlns: Strophe.NS.MUC_ADMIN
+    }).cnode(item.node);
+    if (reason != null) iq.c("reason", reason);
+    return this._connection.sendIQ(iq.tree(), handler_cb, error_cb);
+  },
+  /*Function
+  Changes the role of a member of a MUC room.
+  The modification can only be done by a room moderator. An error will be
+  returned if the user doesn't have permission.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) nick - The nick name of the user to modify.
+  (String) role - The new role of the user.
+  (String) affiliation - The new affiliation of the user.
+  (String) reason - Optional reason for the change.
+  (Function) handler_cb - Optional callback for success
+  (Function) errer_cb - Optional callback for error
+  Returns:
+  iq - the id of the mode change request.
+  */
+  modifyRole: function(room, nick, role, reason, handler_cb, error_cb) {
+    var item;
+    item = $build("item", {
+      nick: nick,
+      role: role
+    });
+    return this._modifyPrivilege(room, item, reason, handler_cb, error_cb);
+  },
+  kick: function(room, nick, reason, handler_cb, error_cb) {
+    return this.modifyRole(room, nick, 'none', reason, handler_cb, error_cb);
+  },
+  voice: function(room, nick, reason, handler_cb, error_cb) {
+    return this.modifyRole(room, nick, 'participant', reason, handler_cb, error_cb);
+  },
+  mute: function(room, nick, reason, handler_cb, error_cb) {
+    return this.modifyRole(room, nick, 'visitor', reason, handler_cb, error_cb);
+  },
+  op: function(room, nick, reason, handler_cb, error_cb) {
+    return this.modifyRole(room, nick, 'moderator', reason, handler_cb, error_cb);
+  },
+  deop: function(room, nick, reason, handler_cb, error_cb) {
+    return this.modifyRole(room, nick, 'participant', reason, handler_cb, error_cb);
+  },
+  /*Function
+  Changes the affiliation of a member of a MUC room.
+  The modification can only be done by a room moderator. An error will be
+  returned if the user doesn't have permission.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) jid  - The jid of the user to modify.
+  (String) affiliation - The new affiliation of the user.
+  (String) reason - Optional reason for the change.
+  (Function) handler_cb - Optional callback for success
+  (Function) errer_cb - Optional callback for error
+  Returns:
+  iq - the id of the mode change request.
+  */
+  modifyAffiliation: function(room, jid, affiliation, reason, handler_cb, error_cb) {
+    var item;
+    item = $build("item", {
+      jid: jid,
+      affiliation: affiliation
+    });
+    return this._modifyPrivilege(room, item, reason, handler_cb, error_cb);
+  },
+  ban: function(room, jid, reason, handler_cb, error_cb) {
+    return this.modifyAffiliation(room, jid, 'outcast', reason, handler_cb, error_cb);
+  },
+  member: function(room, jid, reason, handler_cb, error_cb) {
+    return this.modifyAffiliation(room, jid, 'member', reason, handler_cb, error_cb);
+  },
+  revoke: function(room, jid, reason, handler_cb, error_cb) {
+    return this.modifyAffiliation(room, jid, 'none', reason, handler_cb, error_cb);
+  },
+  owner: function(room, jid, reason, handler_cb, error_cb) {
+    return this.modifyAffiliation(room, jid, 'owner', reason, handler_cb, error_cb);
+  },
+  admin: function(room, jid, reason, handler_cb, error_cb) {
+    return this.modifyAffiliation(room, jid, 'admin', reason, handler_cb, error_cb);
+  },
+  /*Function
+  Change the current users nick name.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) user - The new nick name.
+  */
+  changeNick: function(room, user) {
+    var presence, room_nick;
+    room_nick = this.test_append_nick(room, user);
+    presence = $pres({
+      from: this._connection.jid,
+      to: room_nick,
+      id: this._connection.getUniqueId()
+    });
+    return this._connection.send(presence.tree());
+  },
+  /*Function
+  Change the current users status.
+  Parameters:
+  (String) room - The multi-user chat room name.
+  (String) user - The current nick.
+  (String) show - The new show-text.
+  (String) status - The new status-text.
+  */
+  setStatus: function(room, user, show, status) {
+    var presence, room_nick;
+    room_nick = this.test_append_nick(room, user);
+    presence = $pres({
+      from: this._connection.jid,
+      to: room_nick
+    });
+    if (show != null) presence.c('show', show).up();
+    if (status != null) presence.c('status', status);
+    return this._connection.send(presence.tree());
+  },
+  /*Function
+  List all chat room available on a server.
+  Parameters:
+  (String) server - name of chat server.
+  (String) handle_cb - Function to call for room list return.
+  */
+  listRooms: function(server, handle_cb) {
+    var iq;
+    iq = $iq({
+      to: server,
+      from: this._connection.jid,
+      type: "get"
+    }).c("query", {
+      xmlns: Strophe.NS.DISCO_ITEMS
+    });
+    return this._connection.sendIQ(iq, handle_cb);
+  },
+  test_append_nick: function(room, nick) {
+    return room + (nick != null ? "/" + (Strophe.escapeNode(nick)) : "");
+  }
+});
+
+XmppRoom = (function() {
+
+  XmppRoom.prototype.roster = {};
+
+  XmppRoom.prototype._message_handlers = {};
+
+  XmppRoom.prototype._presence_handlers = {};
+
+  XmppRoom.prototype._roster_handlers = {};
+
+  XmppRoom.prototype._handler_ids = 0;
+
+  function XmppRoom(client, name, nick, password) {
+    this.client = client;
+    this.name = name;
+    this.nick = nick;
+    this.password = password;
+    this._roomRosterHandler = __bind(this._roomRosterHandler, this);
+    this._addOccupant = __bind(this._addOccupant, this);
+    if (client.muc) this.client = client.muc;
+    this.name = Strophe.getBareJidFromJid(name);
+    this.client.rooms[this.name] = this;
+    this.addHandler('presence', this._roomRosterHandler);
+  }
+
+  XmppRoom.prototype.join = function(msg_handler_cb, pres_handler_cb) {
+    if (!this.client.rooms[this.name]) {
+      return this.client.join(this.name, this.nick, msg_handler_cb, pres_handler_cb, this.password);
+    }
+  };
+
+  XmppRoom.prototype.leave = function(handler_cb, message) {
+    this.client.leave(this.name, this.nick, handler_cb, message);
+    return delete this.client.rooms[this.name];
+  };
+
+  XmppRoom.prototype.message = function(nick, message, html_message, type) {
+    return this.client.message(this.name, nick, message, html_message, type);
+  };
+
+  XmppRoom.prototype.groupchat = function(message, html_message) {
+    return this.client.groupchat(this.name, message, html_message);
+  };
+
+  XmppRoom.prototype.invite = function(receiver, reason) {
+    return this.client.invite(this.name, receiver, reason);
+  };
+
+  XmppRoom.prototype.directInvite = function(receiver, reason) {
+    return this.client.directInvite(this.name, receiver, reason, this.password);
+  };
+
+  XmppRoom.prototype.configure = function(handler_cb) {
+    return this.client.configure(this.name, handler_cb);
+  };
+
+  XmppRoom.prototype.cancelConfigure = function() {
+    return this.client.cancelConfigure(this.name);
+  };
+
+  XmppRoom.prototype.saveConfiguration = function(configarray) {
+    return this.client.saveConfiguration(this.name, configarray);
+  };
+
+  XmppRoom.prototype.queryOccupants = function(success_cb, error_cb) {
+    return this.client.queryOccupants(this.name, success_cb, error_cb);
+  };
+
+  XmppRoom.prototype.setTopic = function(topic) {
+    return this.client.setTopic(this.name, topic);
+  };
+
+  XmppRoom.prototype.modifyRole = function(nick, role, reason, success_cb, error_cb) {
+    return this.client.modifyRole(this.name, nick, role, reason, success_cb, error_cb);
+  };
+
+  XmppRoom.prototype.kick = function(nick, reason, handler_cb, error_cb) {
+    return this.client.kick(this.name, nick, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.voice = function(nick, reason, handler_cb, error_cb) {
+    return this.client.voice(this.name, nick, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.mute = function(nick, reason, handler_cb, error_cb) {
+    return this.client.mute(this.name, nick, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.op = function(nick, reason, handler_cb, error_cb) {
+    return this.client.op(this.name, nick, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.deop = function(nick, reason, handler_cb, error_cb) {
+    return this.client.deop(this.name, nick, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.modifyAffiliation = function(jid, affiliation, reason, success_cb, error_cb) {
+    return this.client.modifyAffiliation(this.name, jid, affiliation, reason, success_cb, error_cb);
+  };
+
+  XmppRoom.prototype.ban = function(jid, reason, handler_cb, error_cb) {
+    return this.client.ban(this.name, jid, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.member = function(jid, reason, handler_cb, error_cb) {
+    return this.client.member(this.name, jid, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.revoke = function(jid, reason, handler_cb, error_cb) {
+    return this.client.revoke(this.name, jid, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.owner = function(jid, reason, handler_cb, error_cb) {
+    return this.client.owner(this.name, jid, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.admin = function(jid, reason, handler_cb, error_cb) {
+    return this.client.admin(this.name, jid, reason, handler_cb, error_cb);
+  };
+
+  XmppRoom.prototype.changeNick = function(nick) {
+    this.nick = nick;
+    return this.client.changeNick(this.name, nick);
+  };
+
+  XmppRoom.prototype.setStatus = function(show, status) {
+    return this.client.setStatus(this.name, this.nick, show, status);
+  };
+
+  /*Function
+  Adds a handler to the MUC room.
+    Parameters:
+  (String) handler_type - 'message', 'presence' or 'roster'.
+  (Function) handler - The handler function.
+  Returns:
+  id - the id of handler.
+  */
+
+  XmppRoom.prototype.addHandler = function(handler_type, handler) {
+    var id;
+    id = this._handler_ids++;
+    switch (handler_type) {
+      case 'presence':
+        this._presence_handlers[id] = handler;
+        break;
+      case 'message':
+        this._message_handlers[id] = handler;
+        break;
+      case 'roster':
+        this._roster_handlers[id] = handler;
+        break;
+      default:
+        this._handler_ids--;
+        return null;
+    }
+    return id;
+  };
+
+  /*Function
+  Removes a handler from the MUC room.
+  This function takes ONLY ids returned by the addHandler function
+  of this room. passing handler ids returned by connection.addHandler
+  may brake things!
+    Parameters:
+  (number) id - the id of the handler
+  */
+
+  XmppRoom.prototype.removeHandler = function(id) {
+    delete this._presence_handlers[id];
+    delete this._message_handlers[id];
+    return delete this._roster_handlers[id];
+  };
+
+  /*Function
+  Creates and adds an Occupant to the Room Roster.
+    Parameters:
+  (Object) data - the data the Occupant is filled with
+  Returns:
+  occ - the created Occupant.
+  */
+
+  XmppRoom.prototype._addOccupant = function(data) {
+    var occ;
+    occ = new Occupant(data, this);
+    this.roster[occ.nick] = occ;
+    return occ;
+  };
+
+  /*Function
+  The standard handler that managed the Room Roster.
+    Parameters:
+  (Object) pres - the presence stanza containing user information
+  */
+
+  XmppRoom.prototype._roomRosterHandler = function(pres) {
+    var data, handler, id, newnick, nick, _ref;
+    data = XmppRoom._parsePresence(pres);
+    nick = data.nick;
+    newnick = data.newnick || null;
+    switch (data.type) {
+      case 'error':
+        return;
+      case 'unavailable':
+        if (newnick) {
+          data.nick = newnick;
+          if (this.roster[nick] && this.roster[newnick]) {
+            this.roster[nick].update(this.roster[newnick]);
+            this.roster[newnick] = this.roster[nick];
+          }
+          if (this.roster[nick] && !this.roster[newnick]) {
+            this.roster[newnick] = this.roster[nick].update(data);
+          }
+        }
+        delete this.roster[nick];
+        break;
+      default:
+        if (this.roster[nick]) {
+          this.roster[nick].update(data);
+        } else {
+          this._addOccupant(data);
+        }
+    }
+    _ref = this._roster_handlers;
+    for (id in _ref) {
+      handler = _ref[id];
+      if (!handler(this.roster, this)) delete this._roster_handlers[id];
+    }
+    return true;
+  };
+
+  /*Function
+  Parses a presence stanza
+    Parameters:
+  (Object) data - the data extracted from the presence stanza
+  */
+
+  XmppRoom._parsePresence = function(pres) {
+    var a, c, c2, data, _i, _j, _len, _len2, _ref, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8;
+    data = {};
+    a = pres.attributes;
+    data.nick = Strophe.getResourceFromJid(a.from.textContent);
+    data.type = ((_ref = a.type) != null ? _ref.textContent : void 0) || null;
+    data.states = [];
+    _ref2 = pres.children;
+    for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+      c = _ref2[_i];
+      switch (c.nodeName) {
+        case "status":
+          data.status = c.textContent || null;
+          break;
+        case "show":
+          data.show = c.textContent || null;
+          break;
+        case "x":
+          a = c.attributes;
+          if (((_ref3 = a.xmlns) != null ? _ref3.textContent : void 0) === Strophe.NS.MUC_USER) {
+            _ref4 = c.children;
+            for (_j = 0, _len2 = _ref4.length; _j < _len2; _j++) {
+              c2 = _ref4[_j];
+              switch (c2.nodeName) {
+                case "item":
+                  a = c2.attributes;
+                  data.affiliation = ((_ref5 = a.affiliation) != null ? _ref5.textContent : void 0) || null;
+                  data.role = ((_ref6 = a.role) != null ? _ref6.textContent : void 0) || null;
+                  data.jid = ((_ref7 = a.jid) != null ? _ref7.textContent : void 0) || null;
+                  data.newnick = ((_ref8 = a.nick) != null ? _ref8.textContent : void 0) || null;
+                  break;
+                case "status":
+                  if (c2.attributes.code) {
+                    data.states.push(c2.attributes.code.textContent);
+                  }
+              }
+            }
+          }
+      }
+    }
+    return data;
+  };
+
+  return XmppRoom;
+
+})();
+
+RoomConfig = (function() {
+
+  function RoomConfig(info) {
+    this.parse = __bind(this.parse, this);    if (info != null) this.parse(info);
+  }
+
+  RoomConfig.prototype.parse = function(result) {
+    var attr, attrs, child, field, identity, query, _i, _j, _k, _len, _len2, _len3, _ref;
+    query = result.getElementsByTagName("query")[0].children;
+    this.identities = [];
+    this.features = [];
+    this.x = [];
+    for (_i = 0, _len = query.length; _i < _len; _i++) {
+      child = query[_i];
+      attrs = child.attributes;
+      switch (child.nodeName) {
+        case "identity":
+          identity = {};
+          for (_j = 0, _len2 = attrs.length; _j < _len2; _j++) {
+            attr = attrs[_j];
+            identity[attr.name] = attr.textContent;
+          }
+          this.identities.push(identity);
+          break;
+        case "feature":
+          this.features.push(attrs["var"].textContent);
+          break;
+        case "x":
+          attrs = child.children[0].attributes;
+          if ((!attrs["var"].textContent === 'FORM_TYPE') || (!attrs.type.textContent === 'hidden')) {
+            break;
+          }
+          _ref = child.children;
+          for (_k = 0, _len3 = _ref.length; _k < _len3; _k++) {
+            field = _ref[_k];
+            if (!(!field.attributes.type)) continue;
+            attrs = field.attributes;
+            this.x.push({
+              "var": attrs["var"].textContent,
+              label: attrs.label.textContent || "",
+              value: field.firstChild.textContent || ""
+            });
+          }
+      }
+    }
+    return {
+      "identities": this.identities,
+      "features": this.features,
+      "x": this.x
+    };
+  };
+
+  return RoomConfig;
+
+})();
+
+Occupant = (function() {
+
+  function Occupant(data, room) {
+    this.room = room;
+    this.update = __bind(this.update, this);
+    this.admin = __bind(this.admin, this);
+    this.owner = __bind(this.owner, this);
+    this.revoke = __bind(this.revoke, this);
+    this.member = __bind(this.member, this);
+    this.ban = __bind(this.ban, this);
+    this.modifyAffiliation = __bind(this.modifyAffiliation, this);
+    this.deop = __bind(this.deop, this);
+    this.op = __bind(this.op, this);
+    this.mute = __bind(this.mute, this);
+    this.voice = __bind(this.voice, this);
+    this.kick = __bind(this.kick, this);
+    this.modifyRole = __bind(this.modifyRole, this);
+    this.update(data);
+  }
+
+  Occupant.prototype.modifyRole = function(role, reason, success_cb, error_cb) {
+    return this.room.modifyRole(this.nick, role, reason, success_cb, error_cb);
+  };
+
+  Occupant.prototype.kick = function(reason, handler_cb, error_cb) {
+    return this.room.kick(this.nick, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.voice = function(reason, handler_cb, error_cb) {
+    return this.room.voice(this.nick, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.mute = function(reason, handler_cb, error_cb) {
+    return this.room.mute(this.nick, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.op = function(reason, handler_cb, error_cb) {
+    return this.room.op(this.nick, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.deop = function(reason, handler_cb, error_cb) {
+    return this.room.deop(this.nick, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.modifyAffiliation = function(affiliation, reason, success_cb, error_cb) {
+    return this.room.modifyAffiliation(this.jid, affiliation, reason, success_cb, error_cb);
+  };
+
+  Occupant.prototype.ban = function(reason, handler_cb, error_cb) {
+    return this.room.ban(this.jid, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.member = function(reason, handler_cb, error_cb) {
+    return this.room.member(this.jid, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.revoke = function(reason, handler_cb, error_cb) {
+    return this.room.revoke(this.jid, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.owner = function(reason, handler_cb, error_cb) {
+    return this.room.owner(this.jid, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.admin = function(reason, handler_cb, error_cb) {
+    return this.room.admin(this.jid, reason, handler_cb, error_cb);
+  };
+
+  Occupant.prototype.update = function(data) {
+    this.nick = data.nick || null;
+    this.affiliation = data.affiliation || null;
+    this.role = data.role || null;
+    this.jid = data.jid || null;
+    this.status = data.status || null;
+    this.show = data.show || null;
+    return this;
+  };
+
+  return Occupant;
+
+})();