Changeset 141:3a9bff4e7807 for wokkel/muc.py

Timestamp:

Aug 4, 2011, 9:38:24 PM (11 years ago)

Author:

Ralph Meijer <ralphm@…>

Branch:

wokkel-muc-client-support-24

Message:

Use descendants from wokkel.generic.Stanza in messages and presence.

• Use wokkel.xmppim.AvailabilityPresence as a basis for presence stanzas.
• Split wokkel.xmppim.PresenceProtocol and Base MUCClient on BasePresenceProtocol
• Add new wokkel.xmppim.Message as the basis for message stanzas.
• `receivedGroupChat
• Change order of parameters for invite, as reason is optional.
• Use datetimes everywhere where timestamps are needed.

File:

• wokkel/muc.py (modified) (37 diffs)

wokkel/muc.py

@@ -11 +11 @@
 """
 import datetime
+from dateutil.tz import tzutc
 
 from zope.interface import implements
@@ -18 +19 @@
 from twisted.words.xish import domish
 
-from wokkel import data_form, xmppim
+from wokkel import data_form, generic, xmppim
+from wokkel.delay import Delay, DelayMixin
 from wokkel.subprotocols import XMPPHandler
 from wokkel.iwokkel import IMUCClient
@@ -32 +34 @@
 NS_MUC_REGISTER = NS_MUC + '#register'
 
-NS_DELAY = 'urn:xmpp:delay'
-NS_JABBER_DELAY = 'jabber:x:delay'
-
 NS_REQUEST = 'jabber:iq:register'
 
@@ -179 +178 @@
 
 
-class GroupChat(domish.Element):
-    """
-        A message stanza of type groupchat. Used to send a message to a MUC room that will be
-    broadcasted to people in the room.
-    """
-    def __init__(self, to, body=None, subject=None, frm=None):
-        """
-        """
-        domish.Element.__init__(self, (None, 'message'))
-        self['type'] = 'groupchat'
-        if isinstance(to, jid.JID):
-            self['to'] = to.userhost()
-        else:
-            self['to'] = to
-        if frm:
-            self['from'] = frm
-        if body:
-            self.addElement('body',None, body)
-        if subject:
-            self.addElement('subject',None, subject)
-
-
-
-class PrivateChat(domish.Element):
-    """
-        A chat message.
-    """
-    def __init__(self, to, body=None, frm=None):
-        """
-        Initialize the L{PrivateChat}
-
-        @param to: The xmpp entity you are sending this chat to.
-        @type to: C{unicode} or L{jid.JID}
-
-        @param body: The message you are sending.
-        @type body: C{unicode}
-
-        @param frm: The entity that is sending the message.
-        @param frm: C{unicode}
-        """
-        domish.Element.__init__(self, (None, 'message'))
-        self['type'] = 'chat'
-        if isinstance(to, jid.JID):
-            self['to'] = to.full()
-        else:
-            self['to'] = to
-        if frm:
-            self['from'] = frm
-        if body:
-            self.addElement('body',None, body)
-
-
-
-class InviteMessage(domish.Element):
-    def __init__(self, roomJID, invitee, reason=None):
-        domish.Element.__init__(self, (None, 'message'))
-        self['to'] = unicode(roomJID)
-        x = self.addElement('x', NS_MUC_USER)
-        invite = x.addElement('invite')
-        invite['to'] = invitee
-        if reason:
-            invite.addElement('reason', None, reason)
-
-
-
-class HistoryMessage(GroupChat):
-    """
-        A history message for MUC groupchat history.
-    """
-    def __init__(self, to, stamp, body=None, subject=None, frm=None, h_frm=None):
-        GroupChat.__init__(self, to, body=body, subject=subject, frm=frm)
-        d = self.addElement('delay', NS_DELAY)
-        d['stamp'] = stamp
-        if h_frm:
-            d['from'] = h_frm
+class GroupChat(xmppim.Message, DelayMixin):
+    """
+    A groupchat message.
+    """
+
+    stanzaType = 'groupchat'
+
+    def toElement(self, legacyDelay=False):
+        """
+        Render into a domish Element.
+
+        @param legacyDelay: If C{True} send the delayed delivery information
+        in legacy format.
+        """
+        element = xmppim.Message.toElement(self)
+
+        if self.delay:
+            element.addChild(self.delay.toElement())
+
+        return element
+
+
+
+class PrivateChat(xmppim.Message):
+    """
+    A chat message.
+    """
+
+    stanzaType = 'chat'
+
+
+
+class InviteMessage(xmppim.Message):
+
+    def __init__(self, recipient=None, sender=None, invitee=None, reason=None):
+        xmppim.Message.__init__(self, recipient, sender)
+        self.invitee = invitee
+        self.reason = reason
+
+
+    def toElement(self):
+        element = xmppim.Message.toElement(self)
+
+        child = element.addElement((NS_MUC_USER, 'x'))
+        child.addElement('invite')
+        child.invite['to'] = self.invitee.full()
+
+        if self.reason:
+            child.invite.addElement('reason', content=self.reason)
+
+        return element
 
 
@@ -259 +234 @@
 class HistoryOptions(object):
     """
-        A history configuration object.
+    A history configuration object.
 
     @ivar maxchars: Limit the total number of characters in the history to "X"
-                    (where the character count is the characters of the complete XML stanzas, not only their XML character data).
-    @type maxchars: L{int}
-
-    @ivar  maxstanzas:  Limit the total number of messages in the history to "X".
-    @type mazstanzas: L{int}
-
-    @ivar  seconds: Send only the messages received in the last "X" seconds.
-    @type seconds: L{int}
-
-    @ivar  since: Send only the messages received since the datetime specified (which MUST conform to the DateTime profile specified in XMPP Date and Time Profiles [14]).
+        (where the character count is the characters of the complete XML
+        stanzas, not only their XML character data).
+    @type maxchars: C{int}
+
+    @ivar maxstanzas: Limit the total number of messages in the history to "X".
+    @type mazstanzas: C{int}
+
+    @ivar seconds: Send only the messages received in the last "X" seconds.
+    @type seconds: C{int}
+
+    @ivar since: Send only the messages received since the datetime specified.
+        Note that this must be an offset-aware instance.
     @type since: L{datetime.datetime}
     """
     attributes = ['maxchars', 'maxstanzas', 'seconds', 'since']
 
-    def __init__(self, maxchars=None, maxstanzas=None, seconds=None, since=None):
+    def __init__(self, maxchars=None, maxstanzas=None, seconds=None,
+                       since=None):
         self.maxchars = maxchars
         self.maxstanzas = maxstanzas
@@ -287 +265 @@
         Returns a L{domish.Element} representing the xml for the history options.
         """
-        h = domish.Element((None, 'history'))
+        element = domish.Element((NS_MUC, 'history'))
+
         for key in self.attributes:
-            a = getattr(self, key, None)
-            if a is not None:
+            value = getattr(self, key, None)
+            if value is not None:
                 if key == 'since':
-                    h[key] = a.strftime('%Y%m%dT%H:%M:%S')
+                    stamp = value.astimezone(tzutc())
+                    element[key] = stamp.strftime('%Y%m%dT%H:%M:%SZ')
                 else:
-                    h[key] = str(a)
-
-        return h
+                    element[key] = str(value)
+
+        return element
 
 
@@ -318 +298 @@
 class Room(object):
     """
-    A Multi User Chat Room. An in memory object representing a MUC room.
+    A Multi User Chat Room.
+
+    An in memory object representing a MUC room from the perspective of
+    a client.
+
+    @ivar roomIdentifier: The Room ID of the MUC room.
+    @type roomIdentifier: C{unicode}
+
+    @ivar service: The server where the MUC room is located.
+    @type service: C{unicode}
+
+    @ivar nick: The nick name for the client in this room.
+    @type nick: C{unicode}
+
+    @ivar state: The status code of the room.
+    @type state: L{int}
+
+    @ivar occupantJID: The JID of the occupant in the room. Generated from roomIdentifier, service, and nick.
+    @type occupantJID: L{jid.JID}
     """
 
@@ -325 +323 @@
         """
         Initialize the room.
-
-        @ivar roomIdentifier: The Room ID of the MUC room.
-        @type roomIdentifier: C{unicode}
-
-        @ivar service: The server where the MUC room is located.
-        @type service: C{unicode}
-
-        @ivar nick: The nick name for the client in this room.
-        @type nick: C{unicode}
-
-        @ivar state: The status code of the room.
-        @type state: L{int}
-
-        @ivar occupantJID: The JID of the occupant in the room. Generated from roomIdentifier, service, and nick.
-        @type occupantJID: L{jid.JID}
-        """
-        self.state = state
+        """
         self.roomIdentifier = roomIdentifier
         self.service = service
+        self.setNick(nick)
+        self.state = state
+
+        self.status = 0
+
+        self.roster = {}
+
+
+    def setNick(self, nick):
+        self.occupantJID = jid.internJID(u"%s@%s/%s" % (self.roomIdentifier,
+                                                        self.service,
+                                                        nick))
         self.nick = nick
-        self.status = 0
-
-        self.occupantJID = self.refreshOccupantJID()
-
-        self.roster = {}
-
-
-    def refreshOccupantJID(self):
-        """
-        Refreshes the Room JID.
-
-        This method should be called whenever roomIdentifier, service, or nick
-        change.
-        """
-        self.occupantJID = jid.internJID(u"%s@%s/%s" % (self.roomIdentifier,
-                                                    self.service,
-                                                    self.nick))
-        return self.occupantJID
 
 
@@ -372 +348 @@
         @type user: L{User}
         """
-        self.roster[user.nick.lower()] = user
+        self.roster[user.nick] = user
 
 
@@ -383 +359 @@
         """
 
-        return self.roster.has_key(user.nick.lower())
+        return user.nick in self.roster
 
 
@@ -393 +369 @@
         @type nick: C{unicode}
         """
-        return self.roster.get(nick.lower())
+        return self.roster.get(nick)
 
 
@@ -404 +380 @@
         """
         if self.inRoster(user):
-            del self.roster[user.nick.lower()]
-
-
-
-class BasicPresence(xmppim.AvailablePresence):
-    """
-    This behaves like an object providing L{domish.IElement}.
-    """
-
-    def __init__(self, to=None, show=None, statuses=None):
-        xmppim.AvailablePresence.__init__(self, to=to, show=show, statuses=statuses)
-        # add muc elements
-        x = self.addElement('x', NS_MUC)
-
-
-
-class UserPresence(xmppim.Presence):
-    """
-    This behaves like an object providing L{domish.IElement}.
-    """
-
-    def __init__(self, to=None, type=None, frm=None, affiliation=None, role=None):
-        xmppim.Presence.__init__(self, to, type)
-        if frm:
-            self['from'] = frm
-        # add muc elements
-        x = self.addElement('x', NS_MUC_USER)
-        if affiliation:
-            x['affiliation'] = affiliation
-        if role:
-            x['role'] = role
-
-
-
-class UnavailableUserPresence(xmppim.UnavailablePresence):
-    """
-    This behaves like an object providing L{domish.IElement}.
-    """
-
-    def __init__(self, to=None, type=None, frm=None, affiliation=None, role=None):
-        xmppim.UnavailablePresence.__init__(self, to, type)
-        if frm:
-            self['from'] = frm
-        # add muc elements
-        x = self.addElement('x', NS_MUC_USER)
-        if affiliation:
-            x['affiliation'] = affiliation
-        if role:
-            x['role'] = role
-
-
-
-class PasswordPresence(BasicPresence):
-    """
-        This behaves like an object providing L{domish.IElement}.
-    """
-    def __init__(self, to, password):
-        BasicPresence.__init__(self, to)
-
-        self.x.addElement('password', None, password)
-
-
-
-class MessageVoice(GroupChat):
-    """
-        This behaves like an object providing L{domish.IElement}.
-    """
-    def __init__(self, to=None, frm=None):
-        GroupChat.__init__(self, to=to, frm=frm)
+            del self.roster[user.nick]
+
+
+
+class BasicPresence(xmppim.AvailabilityPresence):
+    """
+    Availability presence sent from MUC client to service.
+
+    @type history: L{HistoryOptions}
+    """
+    history = None
+    password = None
+
+    def toElement(self):
+        element = xmppim.AvailabilityPresence.toElement(self)
+
+        muc = element.addElement((NS_MUC, 'x'))
+        if self.password:
+            muc.addElement('password', content=self.password)
+        if self.history:
+            muc.addChild(self.history.toElement())
+
+        return element
+
+
+
+class UserPresence(xmppim.AvailabilityPresence):
+    """
+    Availability presence sent from MUC service to client.
+    """
+
+    statusCode = None
+
+    childParsers = {(NS_MUC_USER, 'x'): '_childParser_mucUser'}
+
+    def _childParser_mucUser(self, element):
+        for child in element.elements():
+            if child.uri != NS_MUC_USER:
+                continue
+            elif child.name == 'status':
+                self.statusCode = child.getAttribute('code')
+            # TODO: item, destroy
+
+
+
+class VoiceRequest(xmppim.Message):
+    """
+    Voice request message.
+    """
+
+    def toElement(self):
+        element = xmppim.Message.toElement(self)
+
         # build data form
         form = data_form.Form('submit', formNamespace=NS_MUC_REQUEST)
@@ -478 +438 @@
                                       value='participant',
                                       label='Requested role'))
-        self.addChild(form.toElement())
-
-
-
-class MUCClient(XMPPHandler):
+        element.addChild(form.toElement())
+
+        return element
+
+
+
+class MUCClient(xmppim.BasePresenceProtocol):
     """
     Multi-User Chat client protocol.
@@ -504 +466 @@
         self._deferreds = []
 
+    presenceTypeParserMap = {
+                'error': generic.ErrorStanza,
+                'available': UserPresence,
+                'unavailable': UserPresence,
+                }
 
     def connectionInitialized(self):
         """
-        This method is called when the client has successfully authenticated.
-        It initializes several xpath events to handle MUC stanzas that come in.
-        After those are initialized then the method initialized is called to signal that we have finished.
-        """
-        self.xmlstream.addObserver(PRESENCE+"[not(@type) or @type='available']/x", self._onXPresence)
-        self.xmlstream.addObserver(PRESENCE+"[@type='unavailable']", self._onUnavailablePresence)
-        self.xmlstream.addObserver(PRESENCE+"[@type='error']", self._onPresenceError)
+        Called when the XML stream has been initialized.
+
+        It initializes several XPath events to handle MUC stanzas that come in.
+        After those are initialized the method L{initialized} is called to
+        signal that we have finished.
+        """
+        xmppim.BasePresenceProtocol.connectionInitialized(self)
+
         self.xmlstream.addObserver(GROUPCHAT, self._onGroupChat)
         self.xmlstream.addObserver(SUBJECT, self._onSubject)
-        # add history
+        # TODO: add history
 
         self.initialized()
@@ -540 +508 @@
         This uses the Room ID and service parts of the given JID to look up
         the L{Room} instance associated with it.
+
+        @type occupantJID: L{jid.JID}
         """
         roomJID = occupantJID.userhostJID()
@@ -554 +524 @@
 
 
-    def _onUnavailablePresence(self, prs):
-        """
-        This method is called when the stanza matches the xpath observer.
-        The client has received a presence stanza with the 'type' attribute of unavailable.
-        It means a user has exited a MUC room.
-        """
-
-        if not prs.hasAttribute('from'):
-            return
-        occupantJID = jid.internJID(prs.getAttribute('from', ''))
-        self._userLeavesRoom(occupantJID)
-
-
-    def _onPresenceError(self, prs):
-        """
-        This method is called when a presence stanza with the 'type' attribute of error.
-        There are various reasons for receiving a presence error and it means that the user has left the room.
-        """
-        if not prs.hasAttribute('from'):
-            return
-        occupantJID = jid.internJID(prs.getAttribute('from', ''))
-        # add an error hook here?
-        self._userLeavesRoom(occupantJID)
+    def unavailableReceived(self, presence):
+        """
+        Unavailable presence was received.
+
+        If this was received from a MUC room occupant JID, that occupant has
+        left the room.
+        """
+
+        occupantJID = presence.sender
+
+        if occupantJID:
+            self._userLeavesRoom(occupantJID)
+
+
+    def errorReceived(self, presence):
+        """
+        Error presence was received.
+
+        If this was received from a MUC room occupant JID, we conclude the
+        occupant has left the room.
+        """
+        occupantJID = presence.sender
+
+        if occupantJID:
+            self._userLeavesRoom(occupantJID)
 
     def _userLeavesRoom(self, occupantJID):
@@ -593 +565 @@
 
 
-    def _onXPresence(self, prs):
-        """
-        A muc presence has been received.
-        """
-        if not prs.hasAttribute('from'):
+    def availableReceived(self, presence):
+        """
+        Available presence was received.
+        """
+
+        occupantJID = presence.sender
+
+        if not occupantJID:
             return
-        occupantJID = jid.internJID(prs.getAttribute('from', ''))
-
-        status = getattr(prs, 'status', None)
-        show = getattr(prs, 'show', None)
 
         # grab room
@@ -609 +580 @@
             # not in the room yet
             return
-        user = self._changeUserStatus(room, occupantJID, status, show)
+
+        user = self._changeUserStatus(room, occupantJID, presence.status,
+                                      presence.show)
 
         if room.inRoster(user):
             # we changed status or nick
-            muc_status = getattr(prs.x, 'status', None)
-            if muc_status:
-                code = muc_status.getAttribute('code', 0)
+            if presence.statusCode:
+                room.status = presence.statusCode # XXX
             else:
-                self.userUpdatedStatus(room, user, show, status)
+                self.userUpdatedStatus(room, user, presence.show,
+                                       presence.status)
         else:
             room.addUser(user)
@@ -623 +596 @@
 
 
-    def _onGroupChat(self, msg):
+    def _onGroupChat(self, element):
         """
         A group chat message has been received from a MUC room.
@@ -629 +602 @@
         There are a few event methods that may get called here. receviedGroupChat and receivedHistory
         """
-        if not msg.hasAttribute('from'):
-            # need to return an error here
+        message = GroupChat.fromElement(element)
+
+        occupantJID = message.sender
+
+        if not occupantJID:
+            # need to return an error here XXX
             return
-        occupantJID = jid.internJID(msg.getAttribute('from', ''))
 
         room = self._getRoom(occupantJID)
@@ -638 +614 @@
             # not in the room yet
             return
-        user = room.getUser(occupantJID.resource)
-        delay = None
-        # need to check for delay and x stanzas for delay namespace for backwards compatability
-        for e in msg.elements():
-            if e.uri == NS_DELAY or e.uri == NS_JABBER_DELAY:
-                delay = e
-        body = unicode(msg.body)
-        # grab room
-        if delay is None:
-            self.receivedGroupChat(room, user, body)
+
+        if occupantJID.resource:
+            user = room.getUser(occupantJID.resource)
         else:
-            self.receivedHistory(room, user, body, delay['stamp'], frm=delay.getAttribute('from',None))
+            # This message is from the room itself.
+            user = None
+
+        if message.delay is None:
+            self.receivedGroupChat(room, user, message)
+        else:
+            self.receivedHistory(room, user, message)
 
 
@@ -748 +723 @@
         @type room: L{Room}
 
-        @param user: The user that joined the MUC room.
+        @param user: The user that left the MUC room.
         @type user: L{User}
         """
@@ -772 +747 @@
 
 
-    def receivedHistory(self, room, user, message, history, frm=None):
-        """
-        This method will need to be modified inorder for clients to
-        do something when this event occurs.
+    def receivedGroupChat(self, room, user, message):
+        """
+        A groupchat message was received.
+
+        @param room: The room the message was received from.
+        @type room: L{Room}
+
+        @param user: The user that sent the message, or C{None} if it was a
+            message from the room itself.
+        @type user: L{User}
+
+        @param message: The message.
+        @type message: L{GroupChat}
         """
         pass
 
 
-    def _cbDisco(self, iq):
-        # grab query
-
-        return getattr(iq,'query', None)
+    def receivedHistory(self, room, user, message):
+        """
+        A groupchat message from the room's discussion history was received.
+
+        This is identical to L{receivedGroupChat}, with the delayed delivery
+        information (timestamp and original sender) in C{message.delay}. For
+        anonymous rooms, C{message.delay.sender} is the room's address.
+
+        @param room: The room the message was received from.
+        @type room: L{Room}
+
+        @param user: The user that sent the message, or C{None} if it was a
+            message from the room itself.
+        @type user: L{User}
+
+        @param message: The message.
+        @type message: L{GroupChat}
+        """
+        pass
 
 
@@ -873 +872 @@
         self._addRoom(room)
 
-        p = BasicPresence(to=room.occupantJID)
-        if history is not None:
-            p.x.addChild(history.toElement())
-
-        d = self.sendDeferred(p, timeout=DEFER_TIMEOUT)
+        presence = BasicPresence(recipient=room.occupantJID)
+        if history:
+            presence.history = HistoryOptions(maxstanzas=history)
+
+        d = self.sendDeferred(presence.toElement(), timeout=DEFER_TIMEOUT)
 
         # add observer for joining the room
@@ -919 +918 @@
 
 
-    def nick(self, roomJID, new_nick):
-        """
-        Change an entities nick name in a MUC room.
+    def nick(self, roomJID, nick):
+        """
+        Change an entity's nick name in a MUC room.
 
         See: http://xmpp.org/extensions/xep-0045.html#changenick
@@ -928 +927 @@
         @type roomJID: L{jid.JID}
 
-        @param new_nick: The nick name for the entitity joining the room.
-        @type new_nick: C{unicode}
+        @param nick: The new nick name within the room.
+        @type nick: C{unicode}
         """
 
@@ -936 +935 @@
 
         # Change the nickname
-        room.nick = new_nick
-        room.refreshOccupantJID()
+        room.setNick(nick)
 
         # Create presence
-        p = BasicPresence(to=room.occupantJID)
-        d = self.sendDeferred(p, timeout=DEFER_TIMEOUT)
+        presence = BasicPresence(recipient=room.occupantJID)
+        d = self.sendDeferred(presence.toElement(), timeout=DEFER_TIMEOUT)
 
         # Add observer for joining the room
@@ -961 +959 @@
         room = self._getRoom(occupantJID)
 
-        p = xmppim.UnavailablePresence(to=room.occupantJID)
-
-        d = self.sendDeferred(p, timeout=DEFER_TIMEOUT)
+        presence = xmppim.AvailabilityPresence(recipient=room.occupantJID,
+                                               available=False)
+
+        d = self.sendDeferred(presence.toElement(), timeout=DEFER_TIMEOUT)
         # add observer for joining the room
         query = PRESENCE + u"[@from='%s' and @type='unavailable']" % (room.occupantJID)
@@ -988 +987 @@
         room = self._getRoom(occupantJID)
 
-        p = BasicPresence(to=room.occupantJID)
-        if status is not None:
-            p.addElement('status', None, status)
-
-        if show is not None:
-            p.addElement('show', None, show)
-
-        d = self.sendDeferred(p, timeout=DEFER_TIMEOUT)
+        presence = BasicPresence(recipient=room.occupantJID,
+                                 show=show, status=status)
+
+        d = self.sendDeferred(presence.toElement(), timeout=DEFER_TIMEOUT)
 
         # add observer for joining the room
@@ -1004 +999 @@
 
 
-    def _sendMessage(self, msg, children=None):
+    def _sendMessage(self, message, children=None):
         """
         Send a message.
         """
+        element = message.toElement()
         if children:
             for child in children:
-                msg.addChild(child)
-
-        self.xmlstream.send(msg)
-
-
-    def groupChat(self, to, message, children=None):
+                element.addChild(child)
+
+        self.xmlstream.send(element)
+
+
+    def groupChat(self, roomJID, body, children=None):
         """
         Send a groupchat message.
         """
-        msg = GroupChat(to, body=message)
-
-        self._sendMessage(msg, children=children)
-
-
-    def chat(self, occupantJID, message, children=None):
+        message = GroupChat(recipient=roomJID, body=body)
+        self._sendMessage(message, children=children)
+
+
+    def chat(self, occupantJID, body, children=None):
         """
         Send a private chat message to a user in a MUC room.
@@ -1033 +1028 @@
         @type occupantJID: L{jid.JID}
         """
-
-        msg = PrivateChat(occupantJID, body=message)
-
-        self._sendMessage(msg, children=children)
-
-
-    def invite(self, roomJID, reason=None, invitee=None):
+        message = PrivateChat(recipient=occupantJID, body=body)
+        self._sendMessage(message, children=children)
+
+
+    def invite(self, roomJID, invitee, reason=None):
         """
         Invite a xmpp entity to a MUC room.
@@ -1047 +1040 @@
         @param roomJID: The bare JID of the room.
         @type roomJID: L{jid.JID}
+
+        @param invitee: The entity that is being invited.
+        @type invitee: L{jid.JID}
 
         @param reason: The reason for the invite.
         @type reason: C{unicode}
-
-        @param invitee: The entity that is being invited.
-        @type invitee: L{jid.JID}
-        """
-        msg = InviteMessage(roomJID, reason=reason, invitee=invitee)
-        self._sendMessage(msg)
+        """
+        message = InviteMessage(recipient=roomJID, invitee=invitee,
+                                reason=reason)
+        self._sendMessage(message)
 
 
@@ -1070 +1064 @@
         @type password: C{unicode}
         """
-        p = PasswordPresence(roomJID, password)
-
-        self.xmlstream.send(p)
+        presence = BasicPresence(roomJID)
+        presence.password = password
+
+        self.xmlstream.send(presence.toElement())
 
 
@@ -1190 +1185 @@
 
 
-    def getRegisterForm(self, room):
+    def getRegisterForm(self, roomJID):
         """
         Grab the registration form for a MUC room.
@@ -1198 +1193 @@
         """
         iq = RegisterRequest(self.xmlstream)
-        iq['to'] = room.userhost()
+        iq['to'] = roomJID.userhost()
         return iq.send()
 
@@ -1256 +1251 @@
         @type roomJID: L{jid.JID}
         """
-        msg = MessageVoice(to=roomJID.userhostJID())
-        self.xmlstream.send(msg)
+        message = VoiceRequest(recipient=roomJID)
+        self.xmlstream.send(message.toElement())
 
 
@@ -1281 +1276 @@
             stanza['type'] = 'groupchat'
 
-            delay = stanza.addElement('delay', NS_DELAY)
-            delay['stamp'] = message['timestamp']
-
-            sender = stanza.getAttribute('from', None)
+            delay = Delay(stamp=message['timestamp'])
+
+            sender = stanza.getAttribute('from')
             if sender is not None:
-                delay['from'] = sender
+                delay.sender = jid.JID(sender)
+
+            stanza.addChild(delay.toElement())
 
             stanza['to'] = roomJID.userhost()