libervia-backend: frontends/src/quick_frontend/quick

comparison frontends/src/quick_frontend/quick_chat.py @ 1963:a2bc5089c2eb

backend, frontends: message refactoring (huge commit): /!\ several features are temporarily disabled, like notifications in frontends next step in refactoring, with the following changes: - jp: updated jp message to follow changes in backend/bridge - jp: added --lang, --subject, --subject_lang, and --type options to jp message + fixed unicode handling for jid - quick_frontend (QuickApp, QuickChat): - follow backend changes - refactored chat, message are now handled in OrderedDict and uid are kept so they can be updated - Message and Occupant classes handle metadata, so frontend just have to display them - Primitivus (Chat): - follow backend/QuickFrontend changes - info & standard messages are handled in the same MessageWidget class - improved/simplified handling of messages, removed update() method - user joined/left messages are merged when next to each other - a separator is shown when message is received while widget is out of focus, so user can quickly see the new messages - affiliation/role are shown (in a basic way for now) in occupants panel - removed "/me" messages handling, as it will be done by a backend plugin - message language is displayed when available (only one language per message for now) - fixed :history and :search commands - core (constants): new constants for messages type, XML namespace, entity type - core: *Message methods renamed to follow new code sytle (e.g. sendMessageToBridge => messageSendToBridge) - core (messages handling): fixed handling of language - core (messages handling): mes_data['from'] and ['to'] are now jid.JID - core (core.xmpp): reorganised message methods, added getNick() method to client.roster - plugin text commands: fixed plugin and adapted to new messages behaviour. client is now used in arguments instead of profile - plugins: added information for cancellation reason in CancelError calls - plugin XEP-0045: various improvments, but this plugin still need work: - trigger is used to avoid message already handled by the plugin to be handled a second time - changed the way to handle history, the last message from DB is checked and we request only messages since this one, in seconds (thanks Poezio folks :)) - subject reception is waited before sending the roomJoined signal, this way we are sure that everything including history is ready - cmd_* method now follow the new convention with client instead of profile - roomUserJoined and roomUserLeft messages are removed, the events are now handled with info message with a "ROOM_USER_JOINED" info subtype - probably other forgotten stuffs :p

author	Goffi <goffi@goffi.org>
date	Mon, 20 Jun 2016 18:41:53 +0200
parents	633b5c21aefd
children	02d21a589be2

comparison

equal deleted inserted replaced

-:a45235d8dc93
+:a2bc5089c2eb
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 from sat.core.i18n import _
 from sat.core.log import getLogger
 log = getLogger(__name__)
-from sat_frontends.tools import jid
+from sat.core import exceptions
 from sat_frontends.quick_frontend import quick_widgets
 from sat_frontends.quick_frontend.constants import Const as C
 from collections import OrderedDict
-from datetime import datetime
+from sat_frontends.tools import jid
+ROOM_USER_JOINED = 'ROOM_USER_JOINED'
+ROOM_USER_LEFT = 'ROOM_USER_LEFT'
+ROOM_USER_MOVED = (ROOM_USER_JOINED, ROOM_USER_LEFT)
+# from datetime import datetime
 try:
 # FIXME: to be removed when an acceptable solution is here
 unicode('') # XXX: unicode doesn't exist in pyjamas
 except (TypeError, AttributeError): # Error raised is not the same depending on pyjsbuild options
 unicode = str
+# FIXME: day_format need to be settable (i18n)
+class Message(object):
+"""Message metadata"""
+def __init__(self, parent, uid, timestamp, from_jid, to_jid, msg, subject, type_, extra, profile):
+self.parent = parent
+self.profile = profile
+self.uid = uid
+self.timestamp = timestamp
+self.from_jid = from_jid
+self.to_jid = to_jid
+self.message = msg
+self.subject = subject
+self.type = type_
+self.extra = extra
+self.nick = self.getNick(from_jid)
+# own_mess is True if message was sent by profile's jid
+self.own_mess = (from_jid.resource == self.parent.nick) if self.parent.type == C.CHAT_GROUP else (from_jid.bare == self.host.profiles[profile].whoami.bare)
+self.widgets = set()  # widgets linked to this message
+@property
+def host(self):
+return self.parent.host
+@property
+def info_type(self):
+return self.extra.get('info_type')
+def getNick(self, entity):
+"""Return nick of an entity when possible"""
+contact_list = self.host.contact_lists[self.profile]
+if self.type == C.MESS_TYPE_INFO and self.info_type in ROOM_USER_MOVED:
+try:
+return self.extra['user_nick']
+except KeyError:
+log.error(u"extra data is missing user nick for uid {}".format(self.uid))
+return ""
+if self.parent.type == C.CHAT_GROUP or entity in contact_list.getSpecialExtras(C.CONTACT_SPECIAL_GROUP):
+return entity.resource or ""
+if entity.bare in contact_list:
+return contact_list.getCache(entity, 'nick') or contact_list.getCache(entity, 'name') or entity.node or entity
+return entity.node or entity
+class Occupant(object):
+"""Occupant metadata"""
+def __init__(self, parent, data, profile):
+self.parent = parent
+self.profile = profile
+self.nick = data['nick']
+self.entity = data.get('entity')
+if not self.entity:
+self.entity = jid.JID(u"{}/{}".format(parent.target.bare, self.nick)),
+self.affiliation = data['affiliation']
+self.role = data['role']
+self.widgets = set()  # widgets linked to this occupant
+@property
+def host(self):
+return self.parent.host
 class QuickChat(quick_widgets.QuickWidget):
 visible_states = ['chat_state']
-def __init__(self, host, target, type_=C.CHAT_ONE2ONE, profiles=None):
+def __init__(self, host, target, type_=C.CHAT_ONE2ONE, occupants=None, subject=None, profiles=None):
 """
 @param type_: can be C.CHAT_ONE2ONE for single conversation or C.CHAT_GROUP for chat à la IRC
 """
+self.lang = ''  # default language to use for messages
 quick_widgets.QuickWidget.__init__(self, host, target, profiles=profiles)
+self._locked = False  # True when we are waiting for history/search
+# messageNew signals are cached when locked
+self._cache = []
 assert type_ in (C.CHAT_ONE2ONE, C.CHAT_GROUP)
-if type_ == C.CHAT_GROUP and target.resource:
-raise ValueError("A group chat entity can't have a resource")
 self.current_target = target
 self.type = type_
-self.id = "" # FIXME: to be removed
+if type_ == C.CHAT_GROUP:
-self.nick = None
+if target.resource:
+raise exceptions.InternalError(u"a group chat entity can't have a resource")
+self.nick = None
+self.occupants = {}
+self.setOccupants(occupants)
+else:
+if occupants is not None:
+raise exceptions.InternalError(u"only group chat can have occupants")
+self.messages = OrderedDict()  # key: uid, value: Message instance
 self.games = {}  # key=game name (unicode), value=instance of quick_games.RoomGame
+self.subject = subject
+def postInit(self):
+"""Method to be called by frontend after widget is initialised
+handle the display of history and subject
+"""
 self.historyPrint(profile=self.profile)
+if self.subject is not None:
+self.setSubject(self.subject)
+## Widget management ##
 def __str__(self):
 return u"Chat Widget [target: {}, type: {}, profile: {}]".format(self.target, self.type, self.profile)
 @staticmethod
 def addTarget(self, target):
 super(QuickChat, self).addTarget(target)
 if target.resource:
 self.current_target = target # FIXME: tmp, must use resource priority throught contactList instead
+def onPrivateCreated(self, widget):
+"""Method called when a new widget for private conversation (MUC) is created"""
+raise NotImplementedError
+def getOrCreatePrivateWidget(self, entity):
+"""Create a widget for private conversation, or get it if it already exists
+@param entity: full jid of the target
+"""
+return self.host.widgets.getOrCreateWidget(QuickChat, entity, type_=C.CHAT_ONE2ONE, force_hash=self.getPrivateHash(self.profile, entity), on_new_widget=self.onPrivateCreated, profile=self.profile) # we force hash to have a new widget, not this one again
 @property
 def target(self):
 if self.type == C.CHAT_GROUP:
 return self.current_target.bare
 return self.current_target
-@property
+## occupants ##
-def occupants(self):
-"""Return the occupants of a group chat (nicknames).
+def setOccupants(self, occupants):
+"""set the whole list of occupants"""
-@return: set(unicode)
+assert len(self.occupants) == 0
-"""
+for nick, data in occupants.iteritems():
-if self.type != C.CHAT_GROUP:
+self.occupants[nick] = Occupant(
-return set()
+self,
-contact_list = self.host.contact_lists[self.profile]
+data,
-return contact_list.getCache(self.target, C.CONTACT_RESOURCES).keys()
+self.profile
+)
+def addUser(self, occupant_data):
+"""Add user if it is not in the group list"""
+occupant = Occupant(
+self,
+occupant_data,
+self.profile
+)
+self.occupants[occupant.nick] = occupant
+return occupant
+def removeUser(self, occupant_data):
+"""Remove a user from the group list"""
+nick = occupant_data['nick']
+try:
+occupant = self.occupants.pop(nick)
+except KeyError:
+log.warning(u"Trying to remove an unknown occupant: {}".format(nick))
+else:
+return occupant
+def setUserNick(self, nick):
+"""Set the nick of the user, usefull for e.g. change the color of the user"""
+self.nick = nick
+def changeUserNick(self, old_nick, new_nick):
+"""Change nick of a user in group list"""
+self.printInfo("%s is now known as %s" % (old_nick, new_nick))
+## Messages ##
 def manageMessage(self, entity, mess_type):
 """Tell if this chat widget manage an entity and message type couple
 @param entity (jid.JID): (full) jid of the sending entity
 @param mess_type (str): message type as given by messageNew
 @return (bool): True if this Chat Widget manage this couple
 """
 if self.type == C.CHAT_GROUP:
-if mess_type == C.MESS_TYPE_GROUPCHAT and self.target == entity.bare:
+if mess_type in (C.MESS_TYPE_GROUPCHAT, C.MESS_TYPE_INFO) and self.target == entity.bare:
 return True
 else:
 if mess_type != C.MESS_TYPE_GROUPCHAT and entity in self.targets:
 return True
 return False
-def addUser(self, nick):
+def updateHistory(self, size=C.HISTORY_LIMIT_DEFAULT, search='', profile='@NONE@'):
-"""Add user if it is not in the group list"""
+"""Called when history need to be recreated
-self.printInfo("=> %s has joined the room" % nick)
+Remove all message from history then call historyPrint
-def removeUser(self, nick):
+Must probably be overriden by frontend to clear widget
-"""Remove a user from the group list"""
-self.printInfo("<= %s has left the room" % nick)
-def setUserNick(self, nick):
-"""Set the nick of the user, usefull for e.g. change the color of the user"""
-self.nick = nick
-def changeUserNick(self, old_nick, new_nick):
-"""Change nick of a user in group list"""
-self.printInfo("%s is now known as %s" % (old_nick, new_nick))
-def setSubject(self, subject):
-"""Set title for a group chat"""
-log.debug(_("Setting subject to %s") % subject)
-if self.type != C.CHAT_GROUP:
-log.error (_("[INTERNAL] trying to set subject for a non group chat window"))
-raise Exception("INTERNAL ERROR") #TODO: raise proper Exception here
-def afterHistoryPrint(self):
-"""Refresh or scroll down the focus after the history is printed"""
-pass
-def historyPrint(self, size=C.HISTORY_LIMIT_DEFAULT, search='', profile='@NONE@'):
-"""Print the current history
 @param size (int): number of messages
 @param search (str): pattern to filter the history results
 @param profile (str): %(doc_profile)s
 """
+self._locked = True
+self.messages.clear()
+self.historyPrint(size, search, profile)
+def _onHistoryPrinted(self):
+"""Method called when history is printed (or failed)
+unlock the widget, and can be used to refresh or scroll down
+the focus after the history is printed
+"""
+self._locked = False
+for data in self._cache:
+self.messageNew(*data)
+def historyPrint(self, size=C.HISTORY_LIMIT_DEFAULT, search='', profile='@NONE@'):
+"""Print the current history
+@param size (int): number of messages
+@param search (str): pattern to filter the history results
+@param profile (str): %(doc_profile)s
+"""
+if size == 0:
+log.debug(u"Empty history requested, skipping")
+self._onHistoryPrinted()
+return
 log_msg = _(u"now we print the history")
 if size != C.HISTORY_LIMIT_DEFAULT:
-log_msg += _(u" (%d messages)" % size)
+log_msg += _(u" ({} messages)".format(size))
 log.debug(log_msg)
 target = self.target.bare
 def _historyGetCb(history):
-day_format = "%A, %d %b %Y"  # to display the day change
+# day_format = "%A, %d %b %Y"  # to display the day change
-previous_day = datetime.now().strftime(day_format)
+# previous_day = datetime.now().strftime(day_format)
+# message_day = datetime.fromtimestamp(timestamp).strftime(self.day_format)
+# if previous_day != message_day:
+#     self.printDayChange(message_day)
+#     previous_day = message_day
 for data in history:
-uid, timestamp, from_jid, to_jid, message, subject, type_, extra = data  # FIXME: extra is unused !
+uid, timestamp, from_jid, to_jid, message, subject, type_, extra = data
-if ((self.type == C.CHAT_GROUP and type_ != C.MESS_TYPE_GROUPCHAT) or
+from_jid = jid.JID(from_jid)
-(self.type == C.CHAT_ONE2ONE and type_ == C.MESS_TYPE_GROUPCHAT)):
+to_jid = jid.JID(to_jid)
-continue
+# if ((self.type == C.CHAT_GROUP and type_ != C.MESS_TYPE_GROUPCHAT) or
-message_day = datetime.fromtimestamp(timestamp).strftime(day_format)
+#    (self.type == C.CHAT_ONE2ONE and type_ == C.MESS_TYPE_GROUPCHAT)):
-if previous_day != message_day:
+#     continue
-self.printDayChange(message_day)
+self.messages[uid] = Message(self, uid, timestamp, from_jid, to_jid, message, subject, type_, extra, profile)
-previous_day = message_day
+self._onHistoryPrinted()
-extra["timestamp"] = timestamp
-self.messageNew(uid, timestamp, jid.JID(from_jid), target, message, subject, type_, extra, profile)
-self.afterHistoryPrint()
 def _historyGetEb(err):
-log.error(_("Can't get history"))
+log.error(_(u"Can't get history"))
+self._onHistoryPrinted()
 self.host.bridge.historyGet(unicode(self.host.profiles[profile].whoami.bare), unicode(target), size, True, search, profile, callback=_historyGetCb, errback=_historyGetEb)
-def _get_nick(self, entity):
+def messageNew(self, uid, timestamp, from_jid, to_jid, msg, subject, type_, extra, profile):
-"""Return nick of this entity when possible"""
+log.debug(u"messageNew ==> {}".format((uid, timestamp, from_jid, to_jid, msg, subject, type_, extra, profile)))
-contact_list = self.host.contact_lists[self.profile]
+if self._locked:
-if self.type == C.CHAT_GROUP or entity in contact_list.getSpecialExtras(C.CONTACT_SPECIAL_GROUP):
+self._cache.append(uid, timestamp, from_jid, to_jid, msg, subject, type_, extra, profile)
-return entity.resource or ""
-if entity.bare in contact_list:
-return contact_list.getCache(entity, 'nick') or contact_list.getCache(entity, 'name') or entity.node or entity
-return entity.node or entity
-def onPrivateCreated(self, widget):
-"""Method called when a new widget for private conversation (MUC) is created"""
-raise NotImplementedError
-def getOrCreatePrivateWidget(self, entity):
-"""Create a widget for private conversation, or get it if it already exists
-@param entity: full jid of the target
-"""
-return self.host.widgets.getOrCreateWidget(QuickChat, entity, type_=C.CHAT_ONE2ONE, force_hash=self.getPrivateHash(self.profile, entity), on_new_widget=self.onPrivateCreated, profile=self.profile) # we force hash to have a new widget, not this one again
-def messageNew(self, uid, timestamp, from_jid, target, msg, subject, type_, extra, profile):
-try:
-msg = msg.itervalues().next() # FIXME: tmp fix until message refactoring is finished (msg is now a dict)
-except StopIteration:
-log.warning(u"No message found (uid: {})".format(uid))
-msg = ''
-if self.type == C.CHAT_GROUP and target.resource and type_ != C.MESS_TYPE_GROUPCHAT:
-# we have a private message, we forward it to a private conversation widget
-chat_widget = self.getOrCreatePrivateWidget(target)
-chat_widget.messageNew(uid, timestamp, from_jid, target, msg, subject, type_, extra, profile)
 return
+if self.type == C.CHAT_GROUP:
-if type_ == C.MESS_TYPE_INFO:
+if to_jid.resource and type_ != C.MESS_TYPE_GROUPCHAT:
-self.printInfo(msg, extra=extra)
+# we have a private message, we forward it to a private conversation widget
-else:
+chat_widget = self.getOrCreatePrivateWidget(to_jid)
-nick = self._get_nick(from_jid)
+chat_widget.messageNew(uid, timestamp, from_jid, to_jid, msg, subject, type_, extra, profile)
-if msg.startswith('/me '):
+return
-self.printInfo('* {} {}'.format(nick, msg[4:]), type_='me', extra=extra)
+if type_ == C.MESS_TYPE_INFO:
-else:
+try:
-# my_message is True if message comes from local user
+info_type = extra['info_type']
-my_message = (from_jid.resource == self.nick) if self.type == C.CHAT_GROUP else (from_jid.bare == self.host.profiles[profile].whoami.bare)
+except KeyError:
-self.printMessage(nick, my_message, msg, timestamp, extra, profile)
+pass
-# FIXME: to be checked/removed after message refactoring
+else:
-# if timestamp:
+user_data = {k[5:]:v for k,v in extra.iteritems() if k.startswith('user_')}
-self.afterHistoryPrint()
+if info_type == ROOM_USER_JOINED:
+self.addUser(user_data)
-def printMessage(self, nick, my_message, message, timestamp, extra=None, profile=C.PROF_KEY_NONE):
+elif info_type == ROOM_USER_LEFT:
-"""Print message in chat window.
+self.removeUser(user_data)
-@param nick (unicode): author nick
+message = Message(self, uid, timestamp, from_jid, to_jid, msg, subject, type_, extra, profile)
-@param my_message (boolean): True if profile is the author
+self.messages[uid] = message
-@param message (unicode): message content
-@param extra (dict): extra data
+if 'received_timestamp' in extra:
-"""
+log.warning(u"Delayed message received after history, this should not happen")
-# FIXME: check/remove this if necessary (message refactoring)
+self.createMessage(message)
-# if not timestamp:
-#     # XXX: do not send notifications for each line of the history being displayed
+def createMessage(self, message, append=False):
-#     # FIXME: this must be changed in the future if the timestamp is passed with
+"""Must be implemented by frontend to create and show a new message widget
-#     # all messages and not only with the messages coming from the history.
-self.notify(nick, message)
+This is only called on messageNew, not on history.
+You need to override historyPrint to handle the later
-def printInfo(self, msg, type_='normal', extra=None):
+@param message(Message): message data
-"""Print general info.
+"""
+raise NotImplementedError
-@param msg (unicode): message to print
-@param type_ (unicode):
-- 'normal': general info like "toto has joined the room"
-- 'me': "/me" information like "/me clenches his fist" ==> "toto clenches his fist"
-@param extra (dict): message data
-"""
-self.notify(msg=msg)
 def notify(self, contact="somebody", msg=""):
 """Notify the user of a new message if the frontend doesn't have the focus.
 @param contact (unicode): contact who wrote to the users
 @param msg (unicode): the message that has been received
 """
+# FIXME: not called anymore after refactoring
 raise NotImplemented
 def printDayChange(self, day):
 """Display the day on a new line.
 @param day(unicode): day to display (or not if this method is not overwritten)
 """
+# FIXME: not called anymore after refactoring
 pass
-def getEntityStates(self, entity):
+## Room ##
-"""Retrieve states for an entity.
+def setSubject(self, subject):
-@param entity (jid.JID): entity
+"""Set title for a group chat"""
-@return: OrderedDict{unicode: unicode}
+self.subject = subject
-"""
+if self.type != C.CHAT_GROUP:
-states = OrderedDict()
+raise exceptions.InternalError("trying to set subject for a non group chat window")
-clist = self.host.contact_lists[self.profile]
-for key in self.visible_states:
-value = clist.getCache(entity, key)
-if value:
-states[key] = value
-return states
 def addGamePanel(self, widget):
 """Insert a game panel to this Chat dialog.
 @param widget (Widget): the game panel

Mercurial > libervia-backend

comparison frontends/src/quick_frontend/quick_chat.py @ 1963:a2bc5089c2eb