libervia-backend: src/plugins/plugin_xep

comparison src/plugins/plugin_xep_0045.py @ 1970:200cd707a46d

plugin XEP-0045, quick_frontend + primitivus (chat): cleaning of XEP-0045 (first pass): - bridge methods/signals now all start with "muc" to follow new convention - internal method use client instead of profile to follow new convention - removed excetpions from plugin XEP-0045 in favor of core.exceptions, NotReady added - cleaned/simplified several part of the code. checkClient removed as it is not needed anymore - self.clients map removed, muc data are now stored directly in client - getRoomEntityNick and getRoomNicksOfUsers are removed as they don't look sane. /!\ This break all room game plugins for the moment - use of uuid4 instead of uuid1 for getUniqueName, as host ID and current time are used for uuid1

author	Goffi <goffi@goffi.org>
date	Mon, 27 Jun 2016 21:45:11 +0200
parents	a2bc5089c2eb
children	bdc6a5b07922

comparison

equal deleted inserted replaced

-:5fbe09b9b568
+:200cd707a46d
 CONFIG_SECTION = u'plugin muc'
 default_conf = {"default_muc": u'sat@chat.jabberfr.org'}
-class UnknownRoom(Exception):
-pass
-class AlreadyJoinedRoom(Exception):
-pass
-class NotReadyYet(Exception):
-pass
 class XEP_0045(object):
-# TODO: this plugin is messy, need a big cleanup/refactoring
 def __init__(self, host):
 log.info(_("Plugin XEP_0045 initialization"))
 self.host = host
-self.clients = {}  # FIXME: should be moved to profile's client
 self._sessions = memory.Sessions()
 host.bridge.addMethod("mucJoin", ".plugin", in_sign='ssa{ss}s', out_sign='s', method=self._join, async=True)
-host.bridge.addMethod("mucNick", ".plugin", in_sign='sss', out_sign='', method=self.mucNick)
+host.bridge.addMethod("mucNick", ".plugin", in_sign='sss', out_sign='', method=self._nick)
-host.bridge.addMethod("mucLeave", ".plugin", in_sign='ss', out_sign='', method=self.mucLeave, async=True)
+host.bridge.addMethod("mucLeave", ".plugin", in_sign='ss', out_sign='', method=self._leave, async=True)
-host.bridge.addMethod("getRoomsJoined", ".plugin", in_sign='s', out_sign='a(sa{sa{ss}}ss)', method=self.getRoomsJoined)
+host.bridge.addMethod("mucGetRoomsJoined", ".plugin", in_sign='s', out_sign='a(sa{sa{ss}}ss)', method=self._getRoomsJoined)
-host.bridge.addMethod("getRoomsSubjects", ".plugin", in_sign='s', out_sign='a(ss)', method=self.getRoomsSubjects)
+host.bridge.addMethod("mucGetUniqueRoomName", ".plugin", in_sign='ss', out_sign='s', method=self._getUniqueName)
-host.bridge.addMethod("getUniqueRoomName", ".plugin", in_sign='ss', out_sign='s', method=self._getUniqueName)
+host.bridge.addMethod("mucConfigureRoom", ".plugin", in_sign='ss', out_sign='s', method=self._configureRoom, async=True)
-host.bridge.addMethod("configureRoom", ".plugin", in_sign='ss', out_sign='s', method=self._configureRoom, async=True)
+host.bridge.addMethod("mucGetDefaultService", ".plugin", in_sign='', out_sign='s', method=self.getDefaultMUC)
-host.bridge.addMethod("getDefaultMUC", ".plugin", in_sign='', out_sign='s', method=self.getDefaultMUC)
+host.bridge.addSignal("mucRoomJoined", ".plugin", signature='sa{sa{ss}}sss')  # args: room_jid, occupants, user_nick, subject, profile
-host.bridge.addSignal("roomJoined", ".plugin", signature='sa{sa{ss}}sss')  # args: room_jid, occupants, user_nick, subject, profile
+host.bridge.addSignal("mucRoomLeft", ".plugin", signature='ss')  # args: room_jid, profile
-host.bridge.addSignal("roomLeft", ".plugin", signature='ss')  # args: room_jid, profile
+host.bridge.addSignal("mucRoomUserChangedNick", ".plugin", signature='ssss')  # args: room_jid, old_nick, new_nick, profile
-host.bridge.addSignal("roomUserChangedNick", ".plugin", signature='ssss')  # args: room_jid, old_nick, new_nick, profile
+host.bridge.addSignal("mucRoomNewSubject", ".plugin", signature='sss')  # args: room_jid, subject, profile
-host.bridge.addSignal("roomNewSubject", ".plugin", signature='sss')  # args: room_jid, subject, profile
 self.__submit_conf_id = host.registerCallback(self._submitConfiguration, with_data=True)
 host.importMenu((D_("MUC"), D_("configure")), self._configureRoomMenu, security_limit=0, help_string=D_("Configure Multi-User Chat room"), type_=C.MENU_ROOM)
 try:
-self.host.plugins[C.TEXT_CMDS].registerTextCommands(self)
+txt_cmds = self.host.plugins[C.TEXT_CMDS]
-self.host.plugins[C.TEXT_CMDS].addWhoIsCb(self._whois, 100)
 except KeyError:
-log.info(_("Text commands not available"))
+log.info(_(u"Text commands not available"))
+else:
+txt_cmds.registerTextCommands(self)
+txt_cmds.addWhoIsCb(self._whois, 100)
 host.trigger.add("presence_available", self.presenceTrigger)
 host.trigger.add("MessageReceived", self.MessageReceivedTrigger, priority=1000000)
 def profileConnected(self, profile):
 if message_elt.getAttribute("type") == C.MESS_TYPE_GROUPCHAT:
 if message_elt.subject or message_elt.delay:
 return False
 from_jid = jid.JID(message_elt['from'])
 room_jid = from_jid.userhostJID()
-if room_jid in self.clients[client.profile].joined_rooms:
+if room_jid in client._muc_client.joined_rooms:
-room = self.clients[client.profile].joined_rooms[room_jid]
+room = client._muc_client.joined_rooms[room_jid]
 if not room._room_ok:
 log.warning(u"Received non delayed message in a room before its initialisation: {}".format(message_elt.toXml()))
 room._cache.append(message_elt)
 return False
 else:
 log.warning(u"Received groupchat message for a room which has not been joined, ignoring it: {}".format(message_elt.toXml()))
 return False
 return True
-def checkClient(self, profile):
+def checkRoomJoined(self, client, room_jid):
-"""Check if the profile is connected and has used the MUC feature.
+"""Check that given room has been joined in current session
-If profile was using MUC feature but is now disconnected, remove it from the client list.
+@param room_jid (JID): room JID
-@param profile: profile to check
+"""
-@return: True if the profile is connected and has used the MUC feature, else False"""
+if room_jid not in client._muc_client.joined_rooms:
-if not profile or profile not in self.clients or not self.host.isConnected(profile):
+raise exceptions.NotFound(_(u"This room has not been joined"))
-log.error(_(u'Unknown or disconnected profile (%s)') % profile)
-if profile in self.clients:
+def isJoinedRoom(self, client, room_jid):
-del self.clients[profile]
+"""Tell if a jid is a known and joined room
+@room_jid(jid.JID): jid of the room
+"""
+try:
+self.checkRoomJoined(client, room_jid)
+except exceptions.NotFound:
 return False
-return True
+else:
+return True
-def getProfileAssertInRoom(self, room_jid, profile_key):
-"""Retrieve the profile name, assert that it's connected and participating in the given room.
+def _joinCb(self, room, client):
-@param room_jid (JID): room JID
-@param profile_key (str): %(doc_profile_key)
-@return: the profile name
-"""
-profile = self.host.memory.getProfileName(profile_key)
-if not self.checkClient(profile):
-raise exceptions.ProfileUnknownError("Unknown or disconnected profile")
-if room_jid not in self.clients[profile].joined_rooms:
-raise UnknownRoom("This room has not been joined")
-return profile
-def _joinCb(self, room, profile):
 """Called when the user is in the requested room"""
 if room.locked:
 # FIXME: the current behaviour is to create an instant room
 # and send the signal only when the room is unlocked
 # a proper configuration management should be done
-print "room locked !"
+log.debug(_(u"room locked !"))
-d = self.clients[profile].configure(room.roomJID, {})
+d = client._muc_client.configure(room.roomJID, {})
 d.addErrback(lambda dummy: log.error(_(u'Error while configuring the room')))
 return room
-def _joinEb(self, failure, room_jid, nick, password, profile):
+def _joinEb(self, failure, client, room_jid, nick, password):
 """Called when something is going wrong when joining the room"""
-if hasattr(failure.value, "condition") and failure.value.condition == 'conflict':
-# we have a nickname conflict, we try again with "_" suffixed to current nickname
-nick += '_'
-return self.clients[profile].join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={'profile': profile}, errbackArgs=[room_jid, nick, password, profile])
-mess = D_("Error while joining the room %s" % room_jid.userhost())
 try:
-mess += " with condition '%s'" % failure.value.condition
+condition = failure.value.condition
 except AttributeError:
-pass
+msg_suffix = ''
+else:
+if condition == 'conflict':
+# we have a nickname conflict, we try again with "_" suffixed to current nickname
+nick += '_'
+return client.join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={client: client}, errbackArgs=[client, room_jid, nick, password])
+msg_suffix = ' with condition "{}"'.format(failure.value.condition)
+mess = D_(u"Error while joining the room {room}{suffix}".format(
+room = room_jid.userhost(), suffix = msg_suffix))
 log.error(mess)
-self.host.bridge.newAlert(mess, D_("Group chat error"), "ERROR", profile)
+xmlui = xml_tools.note(mess, D_(u"Group chat error"), level=C.XMLUI_DATA_LVL_ERROR)
-raise failure
+self.host.actionNew({'xmlui': xmlui.toXml()}, profile=client.profile)
 @staticmethod
 def _getOccupants(room):
 """Get occupants of a room in a form suitable for bridge"""
 return {u.nick: {k:unicode(getattr(u,k) or '') for k in OCCUPANT_KEYS} for u in room.roster.values()}
-def isRoom(self, entity_bare, profile_key):
+def _getRoomsJoined(self, profile_key=C.PROF_KEY_NONE):
-"""Tell if a bare entity is a MUC room.
+client = self.host.getClient(profile_key)
+return self.getRoomsJoined(client)
-@param entity_bare (jid.JID): bare entity
-@param profile_key (unicode): %(doc_profile_key)s
+def getRoomsJoined(self, client):
-@return bool
+"""Return rooms where user is"""
-"""
-profile = self.host.memory.getProfileName(profile_key)
-return entity_bare in self.clients[profile].joined_rooms
-def getRoomsJoined(self, profile_key=C.PROF_KEY_NONE):
-"""Return room where user is"""
-profile = self.host.memory.getProfileName(profile_key)
 result = []
-if not self.checkClient(profile):
+for room in client._muc_client.joined_rooms.values():
-return result
-for room in self.clients[profile].joined_rooms.values():
 if room._room_ok:
 result.append((room.roomJID.userhost(), self._getOccupants(room), room.nick, room.subject))
 return result
-def getRoomNick(self, room_jid, profile_key=C.PROF_KEY_NONE):
+def getRoomNick(self, client, room_jid):
 """return nick used in room by user
 @param room_jid (jid.JID): JID of the room
 @profile_key: profile
-@return: nick or empty string in case of error"""
+@return: nick or empty string in case of error
-profile = self.host.memory.getProfileName(profile_key)
+"""
-if not self.checkClient(profile) or room_jid not in self.clients[profile].joined_rooms:
+try:
-return ''
+self.checkRoomJoined(client, room_jid)
-return self.clients[profile].joined_rooms[room_jid].nick
+except exceptions.NotFound:
+return ''  # FIXME: should not return empty string but raise the error
-def getRoomNickOfUser(self, room, user_jid, secure=True):
+return client._muc_client.joined_rooms[room_jid].nick
-"""Returns the nick of the given user in the room.
+# FIXME: broken, to be removed !
-@param room (wokkel.muc.Room): the room
+# def getRoomEntityNick(self, client, room_jid, entity_jid, =True):
-@param user (jid.JID): bare JID of the user
+#     """Returns the nick of the given user in the room.
-@param secure (bool): set to True for a secure check
-@return: unicode or None if the user didn't join the room.
+#     @param room (wokkel.muc.Room): the room
-"""
+#     @param user (jid.JID): bare JID of the user
-for user in room.roster.values():
+#     @param secure (bool): set to True for a secure check
-if user.entity is not None:
+#     @return: unicode or None if the user didn't join the room.
-if user.entity.userhostJID() == user_jid.userhostJID():
+#     """
-return user.nick
+#     for user in room.roster.values():
-elif not secure:
+#         if user.entity is not None:
-# FIXME: this is NOT ENOUGH to check an identity!!
+#             if user.entity.userhostJID() == user_jid.userhostJID():
-# See in which conditions user.entity could be None.
+#                 return user.nick
-if user.nick == user_jid.user:
+#         elif not secure:
-return user.nick
+#             # FIXME: this is NOT ENOUGH to check an identity!!
-return None
+#             # See in which conditions user.entity could be None.
+#             if user.nick == user_jid.user:
-def getRoomNicksOfUsers(self, room, users=[], secure=True):
+#                 return user.nick
-"""Returns the nicks of the given users in the room.
+#     return None
-@param room (wokkel.muc.Room): the room
+# def getRoomNicksOfUsers(self, room, users=[], secure=True):
-@param users (list[jid.JID]): list of users
+#     """Returns the nicks of the given users in the room.
-@param secure (True): set to True for a secure check
-@return: a couple (x, y) with:
+#     @param room (wokkel.muc.Room): the room
-- x (list[unicode]): nicks of the users who are in the room
+#     @param users (list[jid.JID]): list of users
-- y (list[jid.JID]): JID of the missing users.
+#     @param secure (True): set to True for a secure check
-"""
+#     @return: a couple (x, y) with:
-nicks = []
+#         - x (list[unicode]): nicks of the users who are in the room
-missing = []
+#         - y (list[jid.JID]): JID of the missing users.
-for user in users:
+#     """
-nick = self.getRoomNickOfUser(room, user, secure)
+#     nicks = []
-if nick is None:
+#     missing = []
-missing.append(user)
+#     for user in users:
-else:
+#         nick = self.getRoomNickOfUser(room, user, secure)
-nicks.append(nick)
+#         if nick is None:
-return nicks, missing
+#             missing.append(user)
+#         else:
+#             nicks.append(nick)
+#     return nicks, missing
 def _configureRoom(self, room_jid_s, profile_key=C.PROF_KEY_NONE):
-d = self.configureRoom(jid.JID(room_jid_s), profile_key)
+client = self.host.getClient(profile_key)
+d = self.configureRoom(client, jid.JID(room_jid_s))
 d.addCallback(lambda xmlui: xmlui.toXml())
 return d
 def _configureRoomMenu(self, menu_data, profile):
 """Return room configuration form
 @param menu_data: %(menu_data)s
 @param profile: %(doc_profile)s
 """
+client = self.host.getClient(profile)
 try:
 room_jid = jid.JID(menu_data['room_jid'])
 except KeyError:
 log.error(_("room_jid key is not present !"))
 return defer.fail(exceptions.DataError)
 def xmluiReceived(xmlui):
 return {"xmlui": xmlui.toXml()}
-return self.configureRoom(room_jid, profile).addCallback(xmluiReceived)
+return self.configureRoom(client, room_jid).addCallback(xmluiReceived)
-def configureRoom(self, room_jid, profile_key=C.PROF_KEY_NONE):
+def configureRoom(self, client, room_jid):
 """return the room configuration form
 @param room: jid of the room to configure
-@param profile_key: %(doc_profile_key)s
 @return: configuration form as XMLUI
 """
-profile = self.getProfileAssertInRoom(room_jid, profile_key)
+self.checkRoomJoined(client, room_jid)
 def config2XMLUI(result):
 if not result:
 return ""
-session_id, session_data = self._sessions.newSession(profile=profile)
+session_id, session_data = self._sessions.newSession(profile=client.profile)
 session_data["room_jid"] = room_jid
 xmlui = xml_tools.dataForm2XMLUI(result, submit_id=self.__submit_conf_id)
 xmlui.session_id = session_id
 return xmlui
-d = self.clients[profile].getConfiguration(room_jid)
+d = client._muc_client.getConfiguration(room_jid)
 d.addCallback(config2XMLUI)
 return d
 def _submitConfiguration(self, raw_data, profile):
+client = self.host.getClient(profile)
 try:
 session_data = self._sessions.profileGet(raw_data["session_id"], profile)
 except KeyError:
 log.warning(D_("Session ID doesn't exist, session has probably expired."))
 _dialog = xml_tools.XMLUI('popup', title=D_('Room configuration failed'))
 _dialog.addText(D_("Session ID doesn't exist, session has probably expired."))
 return defer.succeed({'xmlui': _dialog.toXml()})
 data = xml_tools.XMLUIResult2DataFormResult(raw_data)
-d = self.clients[profile].configure(session_data['room_jid'], data)
+d = client._muc_client.configure(session_data['room_jid'], data)
 _dialog = xml_tools.XMLUI('popup', title=D_('Room configuration succeed'))
 _dialog.addText(D_("The new settings have been saved."))
 d.addCallback(lambda ignore: {'xmlui': _dialog.toXml()})
 del self._sessions[raw_data["session_id"]]
 return d
-def isNickInRoom(self, room_jid, nick, profile):
+def isNickInRoom(self, client, room_jid, nick):
 """Tell if a nick is currently present in a room"""
-profile = self.getProfileAssertInRoom(room_jid, profile)
+self.checkRoomJoined(client, room_jid)
-return self.clients[profile].joined_rooms[room_jid].inRoster(muc.User(nick))
+return client._muc_client.joined_rooms[room_jid].inRoster(muc.User(nick))
-def getRoomsSubjects(self, profile_key=C.PROF_KEY_NONE):
-"""Return received subjects of rooms"""
-# FIXME: to be removed
-profile = self.host.memory.getProfileName(profile_key)
-if not self.checkClient(profile):
-return []
-return self.clients[profile].rec_subjects.values()
 @defer.inlineCallbacks
 def getMUCService(self, jid_=None, profile=C.PROF_KEY_NONE):
 """Return first found MUC service of an entity
 muc_service = service
 break
 defer.returnValue(muc_service)
 def _getUniqueName(self, muc_service="", profile_key=C.PROF_KEY_NONE):
-return self.getUniqueName(muc_service or None, profile_key).full()
+client = self.host.getClient(profile_key)
+return self.getUniqueName(client, muc_service or None).full()
-def getUniqueName(self, muc_service=None, profile_key=C.PROF_KEY_NONE):
+def getUniqueName(self, client, muc_service=None):
 """Return unique name for a room, avoiding collision
 @param muc_service (jid.JID) : leave empty string to use the default service
 @return: jid.JID (unique room bare JID)
 """
 # TODO: we should use #RFC-0045 10.1.4 when available here
-client = self.host.getClient(profile_key)
+room_name = unicode(uuid.uuid4())
-room_name = uuid.uuid1()
 if muc_service is None:
 try:
 muc_service = client.muc_service
 except AttributeError:
-raise NotReadyYet("Main server MUC service has not been checked yet")
+raise exceptions.NotReady(u"Main server MUC service has not been checked yet")
 if muc_service is None:
 log.warning(_("No MUC service found on main server"))
 raise exceptions.FeatureNotFound
 muc_service = muc_service.userhost()
-return jid.JID("%s@%s" % (room_name, muc_service))
+return jid.JID(u"{}@{}".format(room_name, muc_service))
 def getDefaultMUC(self):
 """Return the default MUC.
 @return: unicode
 """
 return self.host.memory.getConfig(CONFIG_SECTION, 'default_muc', default_conf['default_muc'])
 def join(self, client, room_jid, nick, options):
-def _errDeferred(exc_obj=Exception, txt='Error while joining room'):
+def _errDeferred(exc_obj=Exception, txt=u'Error while joining room'):
 d = defer.Deferred()
 d.errback(exc_obj(txt))
 return d
-if room_jid in self.clients[client.profile].joined_rooms:
+if room_jid in client._muc_client.joined_rooms:
-log.warning(_(u'%(profile)s is already in room %(room_jid)s') % {'profile': client.profile, 'room_jid': room_jid.userhost()})
+log.warning(_(u'{profile} is already in room {room_jid}').format(profile=client.profile, room_jid = room_jid.userhost()))
-return _errDeferred(AlreadyJoinedRoom, D_(u"The room has already been joined"))
+return defer.fail(exceptions.ConflictError(_(u"The room has already been joined")))
-log.info(_(u"[%(profile)s] is joining room %(room)s with nick %(nick)s") % {'profile': client.profile, 'room': room_jid.userhost(), 'nick': nick})
+log.info(_(u"[{profile}] is joining room {room} with nick {nick}").format(profile=client.profile, room=room_jid.userhost(), nick=nick))
 password = options["password"] if "password" in options else None
-return self.clients[client.profile].join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={'profile': client.profile}, errbackArgs=[room_jid, nick, password, client.profile])
+return client._muc_client.join(room_jid, nick, password).addCallbacks(self._joinCb, self._joinEb, callbackKeywords={'client': client}, errbackArgs=[client, room_jid, nick, password])
 def _join(self, room_jid_s, nick, options=None, profile_key=C.PROF_KEY_NONE):
 """join method used by bridge
 @return: unicode (the room bare)
 room_jid = self.getUniqueName(profile_key=client.profile)
 # TODO: error management + signal in bridge
 d = self.join(client, room_jid, nick, options)
 return d.addCallback(lambda room: room.roomJID.userhost())
-def nick(self, room_jid, nick, profile_key):
+def _nick(self, room_jid_s, nick, profile_key=C.PROF_KEY_NONE):
-profile = self.getProfileAssertInRoom(room_jid, profile_key)
+client = self.host.getClient(profile_key)
-return self.clients[profile].nick(room_jid, nick)
+return self.nick(client, jid.JID(room_jid_s), nick)
-def leave(self, room_jid, profile_key):
+def nick(self, client, room_jid, nick):
-profile = self.getProfileAssertInRoom(room_jid, profile_key)
-return self.clients[profile].leave(room_jid)
-def subject(self, room_jid, subject, profile_key):
-profile = self.getProfileAssertInRoom(room_jid, profile_key)
-return self.clients[profile].subject(room_jid, subject)
-def mucNick(self, room_jid_s, nick, profile_key=C.PROF_KEY_NONE):
 """Change nickname in a room"""
-return self.nick(jid.JID(room_jid_s), nick, profile_key)
+self.checkRoomJoined(client, room_jid)
+return client._muc_client.nick(room_jid, nick)
-def mucLeave(self, room_jid_s, profile_key=C.PROF_KEY_NONE):
-"""Leave a room"""
+def _leave(self, room_jid, profile_key):
-return self.leave(jid.JID(room_jid_s), profile_key)
+client = self.host.getClient(profile_key)
+return self.leave(client, jid.JID(room_jid))
+def leave(self, client, room_jid):
+self.checkRoomJoined(client, room_jid)
+return client._muc_client.leave(room_jid)
+def subject(self, client, room_jid, subject):
+self.checkRoomJoined(client, room_jid)
+return client._muc_client.subject(room_jid, subject)
 def getHandler(self, profile):
-self.clients[profile] = SatMUCClient(self)
+# create a MUC client and associate it with profile' session
-return self.clients[profile]
+client = self.host.getClient(profile)
+muc_client = client._muc_client = SatMUCClient(self)
-def profileDisconnected(self, profile):
+return muc_client
-try:
-del self.clients[profile]
+def kick(self, client, nick, room_jid, options=None):
-except KeyError:
-pass
-def kick(self, nick, room_jid, options={}, profile_key=C.PROF_KEY_NONE):
 """
 Kick a participant from the room
 @param nick (str): nick of the user to kick
 @param room_jid_s (JID): jid of the room
 @param options (dict): attribute with extra info (reason, password) as in #XEP-0045
-@param profile_key (str): %(doc_profile_key)s
+"""
-"""
+if options is None:
-profile = self.getProfileAssertInRoom(room_jid, profile_key)
+options = {}
-return self.clients[profile].kick(room_jid, nick, reason=options.get('reason', None))
+self.checkRoomJoined(client, room_jid)
+return client._muc_client.kick(room_jid, nick, reason=options.get('reason', None))
-def ban(self, entity_jid, room_jid, options={}, profile_key=C.PROF_KEY_NONE):
-"""
+def ban(self, client, entity_jid, room_jid, options=None):
-Ban an entity from the room
+"""Ban an entity from the room
 @param entity_jid (JID): bare jid of the entity to be banned
-@param room_jid_s (JID): jid of the room
+@param room_jid (JID): jid of the room
 @param options: attribute with extra info (reason, password) as in #XEP-0045
-@param profile_key (str): %(doc_profile_key)s
+"""
-"""
+self.checkRoomJoined(client, room_jid)
-assert(not entity_jid.resource)
+if options is None:
-assert(not room_jid.resource)
+options = {}
-profile = self.getProfileAssertInRoom(room_jid, profile_key)
+assert not entity_jid.resource
-return self.clients[profile].ban(room_jid, entity_jid, reason=options.get('reason', None))
+assert not room_jid.resource
+return client._muc_client.ban(room_jid, entity_jid, reason=options.get('reason', None))
-def affiliate(self, entity_jid, room_jid, options=None, profile_key=C.PROF_KEY_NONE):
-"""
+def affiliate(self, client, entity_jid, room_jid, options):
-Change the affiliation of an entity
+"""Change the affiliation of an entity
 @param entity_jid (JID): bare jid of the entity
 @param room_jid_s (JID): jid of the room
 @param options: attribute with extra info (reason, nick) as in #XEP-0045
-@param profile_key (str): %(doc_profile_key)s
+"""
-"""
+self.checkRoomJoined(client, room_jid)
-assert(not entity_jid.resource)
+assert not entity_jid.resource
-assert(not room_jid.resource)
+assert not room_jid.resource
-assert('affiliation' in options)
+assert 'affiliation' in options
-profile = self.getProfileAssertInRoom(room_jid, profile_key)
 # TODO: handles reason and nick
-return self.clients[profile].modifyAffiliationList(room_jid, [entity_jid], options['affiliation'])
+return client._muc_client.modifyAffiliationList(room_jid, [entity_jid], options['affiliation'])
 # Text commands #
 def cmd_nick(self, client, mess_data):
 """change nickname
 @command (all): JID
 - JID: room to join (on the same service if full jid is not specified)
 """
 if mess_data["unparsed"].strip():
 room_jid = self.host.plugins[C.TEXT_CMDS].getRoomJID(mess_data["unparsed"].strip(), mess_data["to"].host)
-nick = (self.getRoomNick(room_jid, client.profile) or
+nick = (self.getRoomNick(client, room_jid) or
 self.host.getClient(client.profile).jid.user)
 self.join(client, room_jid, nick, {})
 return False
 - ROOM_NICK: the nick of the person to kick
 """
 options = mess_data["unparsed"].strip().split()
 try:
 nick = options[0]
-assert(self.isNickInRoom(mess_data["to"], nick, client.profile))
+assert self.isNickInRoom(client, mess_data["to"], nick)
 except (IndexError, AssertionError):
 feedback = _(u"You must provide a member's nick to kick.")
 self.host.plugins[C.TEXT_CMDS].feedBack(client, feedback, mess_data)
 return False
 """
 subject = mess_data["unparsed"].strip()
 if subject:
 room = mess_data["to"]
-self.subject(room, subject, client.profile)
+self.subject(client, room, subject)
 return False
 def cmd_topic(self, client, mess_data):
 """just a synonym of /title
 def _whois(self, client, whois_msg, mess_data, target_jid):
 """ Add MUC user information to whois """
 if mess_data['type'] != "groupchat":
 return
-if target_jid.userhostJID() not in self.clients[client.profile].joined_rooms:
+if target_jid.userhostJID() not in client._muc_client.joined_rooms:
 log.warning(_("This room has not been joined"))
 return
 if not target_jid.resource:
 return
-user = self.clients[client.profile].joined_rooms[target_jid.userhostJID()].getUser(target_jid.resource)
+user = client._muc_client.joined_rooms[target_jid.userhostJID()].getUser(target_jid.resource)
 whois_msg.append(_("Nickname: %s") % user.nick)
 if user.entity:
 whois_msg.append(_("Entity: %s") % user.entity)
 if user.affiliation != 'none':
 whois_msg.append(_("Affiliation: %s") % user.affiliation)
 if user.show:
 whois_msg.append(_("Show: %s") % user.show)
 def presenceTrigger(self, presence_elt, client):
 # XXX: shouldn't it be done by the server ?!!
-muc_client = self.clients[client.profile]
+muc_client = client._muc_client
 for room_jid, room in muc_client.joined_rooms.iteritems():
 elt = copy.deepcopy(presence_elt)
 elt['to'] = room_jid.userhost() + '/' + room.nick
 client.presence.send(elt)
 return True
-class SatMUCClient (muc.MUCClient):
+class SatMUCClient(muc.MUCClient):
 implements(iwokkel.IDisco)
 def __init__(self, plugin_parent):
 self.plugin_parent = plugin_parent
 self.host = plugin_parent.host
 # we left the room
 room_jid_s = room.roomJID.userhost()
 log.info(_(u"Room ({room}) left ({profile})").format(
 room = room_jid_s, profile = self.parent.profile))
 self.host.memory.delEntityCache(room.roomJID, profile_key=self.parent.profile)
-self.host.bridge.roomLeft(room.roomJID.userhost(), self.parent.profile)
+self.host.bridge.mucRoomLeft(room.roomJID.userhost(), self.parent.profile)
 else:
 log.debug(_(u"user {nick} left room {room_id}").format(nick=user.nick, room_id=room.occupantJID.userhost()))
 extra = {'info_type': ROOM_USER_LEFT,
 'user_affiliation': user.affiliation,
 'user_role': user.role,
 }
 self.host.messageAddToHistory(mess_data, self.parent)
 self.host.messageSendToBridge(mess_data, self.parent)
 def userChangedNick(self, room, user, new_nick):
-self.host.bridge.roomUserChangedNick(room.roomJID.userhost(), user.nick, new_nick, self.parent.profile)
+self.host.bridge.mucRoomUserChangedNick(room.roomJID.userhost(), user.nick, new_nick, self.parent.profile)
 def userUpdatedStatus(self, room, user, show, status):
 self.host.bridge.presenceUpdate(room.roomJID.userhost() + '/' + user.nick, show or '', 0, {C.PRESENCE_STATUSES_DEFAULT: status or ''}, self.parent.profile)
 ## messages ##
 def subject(self, room, subject):
 return muc.MUCClientProtocol.subject(self, room, subject)
 def _historyCb(self, dummy, room):
-self.host.bridge.roomJoined(
+self.host.bridge.mucRoomJoined(
 room.roomJID.userhost(),
 XEP_0045._getOccupants(room),
 room.nick,
 room.subject,
 self.parent.profile)
 room._room_ok = False
 room._history_d.addCallbacks(self._historyCb, self._historyEb, [room], errbackArgs=[room])
 else:
 # the subject has been changed
 log.debug(_(u"New subject for room ({room_id}): {subject}").format(room_id = room.roomJID.full(), subject = subject))
-self.host.bridge.roomNewSubject(room.roomJID.userhost(), subject, self.parent.profile)
+self.host.bridge.mucRoomNewSubject(room.roomJID.userhost(), subject, self.parent.profile)
 ## disco ##
 def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
 return [disco.DiscoFeature(NS_MUC)]

Mercurial > libervia-backend

comparison src/plugins/plugin_xep_0045.py @ 1970:200cd707a46d