quick_frontend, primitivus: multi-profiles refactoring part 1 (big commit, sorry :p):

This refactoring allow primitivus to manage correctly several profiles at once, with various other improvments:
    - profile_manager can now plug several profiles at once, requesting password when needed. No more profile plug specific method is used anymore in backend, instead a "validated" key is used in actions
    - Primitivus widget are now based on a common "PrimitivusWidget" classe which mainly manage the decoration so far
    - all widgets are treated in the same way (contactList, Chat, Progress, etc), no more chat_wins specific behaviour
    - widgets are created in a dedicated manager, with facilities to react on new widget creation or other events
    - quick_frontend introduce a new QuickWidget class, which aims to be as generic and flexible as possible. It can manage several targets (jids or something else), and several profiles
    - each widget class return a Hash according to its target. For example if given a target jid and a profile, a widget class return a hash like (target.bare, profile), the same widget will be used for all resources of the same jid
    - better management of CHAT_GROUP mode for Chat widgets
    - some code moved from Primitivus to QuickFrontend, the final goal is to have most non backend code in QuickFrontend, and just graphic code in subclasses
    - no more (un)escapePrivate/PRIVATE_PREFIX
    - contactList improved a lot: entities not in roster and special entities (private MUC conversations) are better managed
    - resources can be displayed in Primitivus, and their status messages
    - profiles are managed in QuickFrontend with dedicated managers


This is work in progress, other frontends are broken. Urwid SàText need to be updated. Most of features of Primitivus should work as before (or in a better way ;))
This commit is contained in:
Goffi 2014-12-10 19:00:09 +01:00
commit e4708c9cbb
7 changed files with 1583 additions and 969 deletions

View file

@ -22,4 +22,15 @@ from sat_frontends import constants
class Const(constants.Const):
PRIVATE_PREFIX = "@private@"
#Chats
CHAT_ONE2ONE = 'one2one'
CHAT_GROUP = 'group'
#Contact list
CONTACT_GROUPS = 'groups'
CONTACT_RESOURCES = 'resources'
CONTACT_MAIN_RESOURCE = 'main_resource'
CONTACT_SPECIAL = 'special'
CONTACT_SPECIAL_GROUP = 'group' # group chat special entity
CONTACT_SPECIAL_ALLOWED = (CONTACT_SPECIAL_GROUP,) # set of allowed values for special flag
CONTACT_DATA_FORBIDDEN = {CONTACT_GROUPS, CONTACT_RESOURCES, CONTACT_MAIN_RESOURCE} # set of forbidden names for contact data

View file

@ -21,23 +21,128 @@ from sat.core.i18n import _
import sys
from sat.core.log import getLogger
log = getLogger(__name__)
from sat_frontends.tools.jid import JID
from sat_frontends.bridge.DBus import DBusBridgeFrontend
from sat.core import exceptions
from sat_frontends.quick_frontend.quick_utils import escapePrivate, unescapePrivate
from sat_frontends.bridge.DBus import DBusBridgeFrontend
from sat_frontends.tools import jid
from sat_frontends.quick_frontend.quick_widgets import QuickWidgetsManager
from sat_frontends.quick_frontend import quick_chat
from optparse import OptionParser
from sat_frontends.quick_frontend.constants import Const as C
class ProfileManager(object):
"""Class managing all data relative to one profile, and plugging in mechanism"""
host = None
bridge = None
def __init__(self, profile):
self.profile = profile
self.whoami = None
self.data = {}
def __getitem__(self, key):
return self.data[key]
def __setitem__(self, key, value):
self.data[key] = value
def plug(self):
"""Plug the profile to the host"""
# we get the essential params
self.bridge.asyncGetParamA("JabberID", "Connection", profile_key=self.profile,
callback=self._plug_profile_jid, errback=self._getParamError)
def _plug_profile_jid(self, _jid):
self.whoami = jid.JID(_jid)
self.bridge.asyncGetParamA("autoconnect", "Connection", profile_key=self.profile,
callback=self._plug_profile_autoconnect, errback=self._getParamError)
def _plug_profile_autoconnect(self, value_str):
autoconnect = C.bool(value_str)
if autoconnect and not self.bridge.isConnected(self.profile):
self.host.asyncConnect(self.profile, callback=lambda dummy: self._plug_profile_afterconnect())
else:
self._plug_profile_afterconnect()
def _plug_profile_afterconnect(self):
# Profile can be connected or not
# TODO: watched plugin
contact_list = self.host.addContactList(self.profile)
if not self.bridge.isConnected(self.profile):
self.host.setStatusOnline(False, profile=self.profile)
else:
self.host.setStatusOnline(True, profile=self.profile)
contact_list.fill()
#The waiting subscription requests
waitingSub = self.bridge.getWaitingSub(self.profile)
for sub in waitingSub:
self.host.subscribeHandler(waitingSub[sub], sub, self.profile)
#Now we open the MUC window where we already are:
for room_args in self.bridge.getRoomsJoined(self.profile):
self.host.roomJoinedHandler(*room_args, profile=self.profile)
for subject_args in self.bridge.getRoomsSubjects(self.profile):
self.host.roomNewSubjectHandler(*subject_args, profile=self.profile)
#Finaly, we get the waiting confirmation requests
for confirm_id, confirm_type, data in self.bridge.getWaitingConf(self.profile):
self.host.askConfirmationHandler(confirm_id, confirm_type, data, self.profile)
def _getParamError(self, ignore):
log.error(_("Can't get profile parameter"))
class ProfilesManager(object):
"""Class managing collection of profiles"""
def __init__(self):
self._profiles = {}
def __contains__(self, profile):
return profile in self._profiles
def __iter__(self):
return self._profiles.iterkeys()
def __getitem__(self, profile):
return self._profiles[profile]
def __len__(self):
return len(self._profiles)
def plug(self, profile):
if profile in self._profiles:
raise exceptions.ConflictError('A profile of the name [{}] is already plugged'.format(profile))
self._profiles[profile] = ProfileManager(profile)
self._profiles[profile].plug()
def unplug(self, profile):
if profile not in self._profiles:
raise ValueError('The profile [{}] is not plugged'.format(profile))
del self._profiles[profile]
def chooseOneProfile(self):
return self._profiles.keys()[0]
class QuickApp(object):
"""This class contain the main methods needed for the frontend"""
def __init__(self, single_profile=True):
self.profiles = {}
self.single_profile = single_profile
def __init__(self):
ProfileManager.host = self
self.profiles = ProfilesManager()
self.contact_lists = {}
self.widgets = QuickWidgetsManager(self)
self.check_options()
# widgets
self.visible_widgets = set() # widgets currently visible (must be filled by frontend)
self.selected_widget = None # widget currently selected (must be filled by frontend)
## bridge ##
try:
self.bridge = DBusBridgeFrontend()
@ -47,6 +152,7 @@ class QuickApp(object):
except exceptions.BridgeInitError:
print(_(u"Can't init bridge"))
sys.exit(1)
ProfileManager.bridge = self.bridge
self.registerSignal("connected")
self.registerSignal("disconnected")
self.registerSignal("newContact")
@ -84,10 +190,18 @@ class QuickApp(object):
self.registerSignal("quizGameTimerRestarted", iface="plugin")
self.registerSignal("chatStateReceived", iface="plugin")
self.current_action_ids = set()
self.current_action_ids_cb = {}
self.current_action_ids = set() # FIXME: to be removed
self.current_action_ids_cb = {} # FIXME: to be removed
self.media_dir = self.bridge.getConfig('', 'media_dir')
@property
def current_profile(self):
"""Profile that a user would expect to use"""
try:
return self.selected_widget.profile
except (TypeError, AttributeError):
return self.profiles.chooseOneProfile()
def registerSignal(self, functionName, handler=None, iface="core", with_profile=True):
"""Register a handler for a signal
@ -115,15 +229,15 @@ class QuickApp(object):
def check_profile(self, profile):
"""Tell if the profile is currently followed by the application"""
return profile in self.profiles.keys()
return profile in self.profiles
def postInit(self):
"""Must be called after initialization is done, do all automatic task (auto plug profile)"""
def postInit(self, profile_manager):
"""Must be called after initialization is done, do all automatic task (auto plug profile)
@param profile_manager: instance of a subclass of Quick_frontend.QuickProfileManager
"""
if self.options.profile:
if not self.bridge.getProfileName(self.options.profile):
log.error(_("Trying to plug an unknown profile (%s)" % self.options.profile))
else:
self.plug_profile(self.options.profile)
profile_manager.autoconnect([self.options.profile])
def check_options(self):
"""Check command line options"""
@ -132,7 +246,7 @@ class QuickApp(object):
%prog --help for options list
""")
parser = OptionParser(usage=usage)
parser = OptionParser(usage=usage) # TODO: use argparse
parser.add_option("-p", "--profile", help=_("Select the profile to use"))
@ -141,46 +255,6 @@ class QuickApp(object):
self.options.profile = self.options.profile.decode('utf-8')
return args
def _getParamError(self, ignore):
log.error(_("Can't get profile parameter"))
def plug_profile(self, profile_key='@DEFAULT@'):
"""Tell application which profile must be used"""
if self.single_profile and self.profiles:
log.error(_('There is already one profile plugged (we are in single profile mode) !'))
return
profile = self.bridge.getProfileName(profile_key)
if not profile:
log.error(_("The profile asked doesn't exist"))
return
if profile in self.profiles:
log.warning(_("The profile is already plugged"))
return
self.profiles[profile] = {}
if self.single_profile:
self.profile = profile # FIXME: must be refactored (multi profiles are not managed correclty)
raw_menus = self.bridge.getMenus("", C.NO_SECURITY_LIMIT )
menus = self.profiles[profile]['menus'] = {}
for raw_menu in raw_menus:
id_, type_, path, path_i18n = raw_menu
menus_data = menus.setdefault(type_, [])
menus_data.append((id_, path, path_i18n))
self.launchAction(C.AUTHENTICATE_PROFILE_ID, {'caller': 'plug_profile'}, profile_key=profile)
def plug_profile_1(self, profile):
###now we get the essential params###
self.bridge.asyncGetParamA("JabberID", "Connection", profile_key=profile,
callback=lambda _jid: self.plug_profile_2(_jid, profile), errback=self._getParamError)
def plug_profile_2(self, _jid, profile):
self.profiles[profile]['whoami'] = JID(_jid)
self.bridge.asyncGetParamA("autoconnect", "Connection", profile_key=profile,
callback=lambda value: self.plug_profile_3(value == "true", profile), errback=self._getParamError)
def plug_profile_3(self, autoconnect, profile):
self.bridge.asyncGetParamA("Watched", "Misc", profile_key=profile,
callback=lambda watched: self.plug_profile_4(watched, autoconnect, profile), errback=self._getParamError)
def asyncConnect(self, profile, callback=None, errback=None):
if not callback:
callback = lambda dummy: None
@ -188,134 +262,74 @@ class QuickApp(object):
def errback(failure):
log.error(_(u"Can't connect profile [%s]") % failure)
if failure.module.startswith('twisted.words.protocols.jabber') and failure.condition == "not-authorized":
self.launchAction(C.CHANGE_XMPP_PASSWD_ID, {}, profile_key=profile)
self.launchAction(C.CHANGE_XMPP_PASSWD_ID, {}, profile=profile)
else:
self.showDialog(failure.message, failure.fullname, 'error')
self.bridge.asyncConnect(profile, callback=callback, errback=errback)
def plug_profile_4(self, watched, autoconnect, profile):
if autoconnect and not self.bridge.isConnected(profile):
#Does the user want autoconnection ?
self.asyncConnect(profile, callback=lambda dummy: self.plug_profile_5(watched, autoconnect, profile))
else:
self.plug_profile_5(watched, autoconnect, profile)
def plug_profiles(self, profiles):
"""Tell application which profiles must be used
def plug_profile_5(self, watched, autoconnect, profile):
self.profiles[profile]['watched'] = watched.split() # TODO: put this in a plugin
@param profiles: list of valid profile names
"""
self.plugging_profiles()
for profile in profiles:
self.profiles.plug(profile)
## misc ##
self.profiles[profile]['onlineContact'] = set() # FIXME: temporary
def plugging_profiles(self):
"""Method to subclass to manage frontend specific things to do
#TODO: manage multi-profiles here
if not self.bridge.isConnected(profile):
self.setStatusOnline(False)
else:
self.setStatusOnline(True)
### now we fill the contact list ###
for contact in self.bridge.getContacts(profile):
self.newContactHandler(*contact, profile=profile)
presences = self.bridge.getPresenceStatuses(profile)
for contact in presences:
for res in presences[contact]:
jabber_id = ('%s/%s' % (JID(contact).bare, res)) if res else contact
show = presences[contact][res][0]
priority = presences[contact][res][1]
statuses = presences[contact][res][2]
self.presenceUpdateHandler(jabber_id, show, priority, statuses, profile)
data = self.bridge.getEntityData(contact, ['avatar', 'nick'], profile)
for key in ('avatar', 'nick'):
if key in data:
self.entityDataUpdatedHandler(contact, key, data[key], profile)
#The waiting subscription requests
waitingSub = self.bridge.getWaitingSub(profile)
for sub in waitingSub:
self.subscribeHandler(waitingSub[sub], sub, profile)
#Now we open the MUC window where we already are:
for room_args in self.bridge.getRoomsJoined(profile):
self.roomJoinedHandler(*room_args, profile=profile)
for subject_args in self.bridge.getRoomsSubjects(profile):
self.roomNewSubjectHandler(*subject_args, profile=profile)
#Finaly, we get the waiting confirmation requests
for confirm_id, confirm_type, data in self.bridge.getWaitingConf(profile):
self.askConfirmationHandler(confirm_id, confirm_type, data, profile)
will be called when profiles are choosen and are to be plugged soon
"""
raise NotImplementedError
def unplug_profile(self, profile):
"""Tell the application to not follow anymore the profile"""
if not profile in self.profiles:
log.warning(_("This profile is not plugged"))
return
raise ValueError("The profile [{}] is not plugged".format(profile))
self.profiles.remove(profile)
def clear_profile(self):
self.profiles.clear()
def newWidget(self, widget):
raise NotImplementedError
def connectedHandler(self, profile):
"""called when the connection is made"""
log.debug(_("Connected"))
self.setStatusOnline(True)
self.setStatusOnline(True, profile=profile)
def disconnectedHandler(self, profile):
"""called when the connection is closed"""
log.debug(_("Disconnected"))
self.contact_list.clearContacts()
self.setStatusOnline(False)
self.contact_lists[profile].clearContacts()
self.setStatusOnline(False, profile=profile)
def newContactHandler(self, JabberId, attributes, groups, profile):
entity = JID(JabberId)
entity = jid.JID(JabberId)
_groups = list(groups)
self.contact_list.replace(entity, _groups, attributes)
self.contact_lists[profile].setContact(entity, _groups, attributes, in_roster=True)
def _newMessage(self, from_jid_s, msg, type_, to_jid_s, extra, profile):
"""newMessage premanagement: a dirty hack to manage private messages
if a private MUC message is detected, from_jid or to_jid is prefixed and resource is escaped
"""
# FIXME: must be refactored for 0.6
from_jid = JID(from_jid_s)
to_jid = JID(to_jid_s)
from_me = from_jid.bare == self.profiles[profile]['whoami'].bare
win = to_jid if from_me else from_jid
if ((type_ != "groupchat" and self.contact_list.getSpecial(win) == "MUC") and
(type_ != C.MESS_TYPE_INFO or (type_ == C.MESS_TYPE_INFO and win.resource))):
#we have a private message in a MUC room
#XXX: normaly we use bare jid as key, here we need the full jid
# so we cheat by replacing the "/" before the resource by
# a "@", so the jid is invalid,
new_jid = escapePrivate(win)
if from_me:
to_jid = new_jid
else:
from_jid = new_jid
if new_jid not in self.contact_list:
self.contact_list.add(new_jid, [C.GROUP_NOT_IN_ROSTER])
from_jid = jid.JID(from_jid_s)
to_jid = jid.JID(to_jid_s)
self.newMessageHandler(from_jid, to_jid, msg, type_, extra, profile)
def newMessageHandler(self, from_jid, to_jid, msg, type_, extra, profile):
from_me = from_jid.bare == self.profiles[profile]['whoami'].bare
win = to_jid if from_me else from_jid
from_me = from_jid.bare == self.profiles[profile].whoami.bare
target = to_jid if from_me else from_jid
self.current_action_ids = set()
self.current_action_ids_cb = {}
chat_type = C.CHAT_GROUP if type_ == C.MESS_TYPE_GROUPCHAT else C.CHAT_ONE2ONE
timestamp = extra.get('archive')
if type_ == C.MESS_TYPE_INFO:
self.chat_wins[win.bare].printInfo(msg, timestamp=float(timestamp) if timestamp else None)
else:
self.chat_wins[win.bare].printMessage(from_jid, msg, profile, float(timestamp) if timestamp else None)
chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, target, type_=chat_type, profile=profile)
def sendMessage(self, to_jid, message, subject='', mess_type="auto", extra={}, callback=None, errback=None, profile_key="@NONE@"):
if to_jid.startswith(C.PRIVATE_PREFIX):
to_jid = unescapePrivate(to_jid)
mess_type = "chat"
self.current_action_ids = set() # FIXME: to be removed
self.current_action_ids_cb = {} # FIXME: to be removed
chat_widget.newMessage(from_jid, target, msg, type_, extra, profile)
def sendMessage(self, to_jid, message, subject='', mess_type="auto", extra={}, callback=None, errback=None, profile_key=C.PROF_KEY_NONE):
if callback is None:
callback = lambda: None
if errback is None:
@ -326,100 +340,78 @@ class QuickApp(object):
assert alert_type in ['INFO', 'ERROR']
self.showDialog(unicode(msg), unicode(title), alert_type.lower())
def setStatusOnline(self, online=True, show="", statuses={}):
def setStatusOnline(self, online=True, show="", statuses={}, profile=C.PROF_KEY_NONE):
raise NotImplementedError
def presenceUpdateHandler(self, jabber_id, show, priority, statuses, profile):
def presenceUpdateHandler(self, entity_s, show, priority, statuses, profile):
log.debug(_("presence update for %(jid)s (show=%(show)s, priority=%(priority)s, statuses=%(statuses)s) [profile:%(profile)s]")
% {'jid': jabber_id, 'show': show, 'priority': priority, 'statuses': statuses, 'profile': profile})
from_jid = JID(jabber_id)
log.debug(_("presence update for %(entity)s (show=%(show)s, priority=%(priority)s, statuses=%(statuses)s) [profile:%(profile)s]")
% {'entity': entity_s, C.PRESENCE_SHOW: show, C.PRESENCE_PRIORITY: priority, C.PRESENCE_STATUSES: statuses, 'profile': profile})
entity = jid.JID(entity_s)
if from_jid == self.profiles[profile]['whoami']:
if entity == self.profiles[profile].whoami:
if show == "unavailable":
self.setStatusOnline(False)
self.setStatusOnline(False, profile=profile)
else:
self.setStatusOnline(True, show, statuses)
self.setStatusOnline(True, show, statuses, profile=profile)
return
presences = self.profiles[profile].setdefault('presences', {})
# #FIXME: must be moved in a plugin
# if entity.bare in self.profiles[profile].data.get('watched',[]) and not entity.bare in self.profiles[profile]['onlineContact']:
# self.showAlert(_("Watched jid [%s] is connected !") % entity.bare)
if show != 'unavailable':
self.contact_lists[profile].updatePresence(entity, show, priority, statuses)
#FIXME: must be moved in a plugin
if from_jid.bare in self.profiles[profile].get('watched',[]) and not from_jid.bare in self.profiles[profile]['onlineContact']:
self.showAlert(_("Watched jid [%s] is connected !") % from_jid.bare)
presences[jabber_id] = {'show': show, 'priority': priority, 'statuses': statuses}
self.profiles[profile].setdefault('onlineContact',set()).add(from_jid) # FIXME onlineContact is useless with CM, must be removed
#TODO: vcard data (avatar)
if show == "unavailable" and from_jid in self.profiles[profile].get('onlineContact',set()):
try:
del presences[jabber_id]
except KeyError:
pass
self.profiles[profile]['onlineContact'].remove(from_jid)
# check if the contact is connected with another resource, use the one with highest priority
jids = [jid for jid in presences if JID(jid).bare == from_jid.bare]
if jids:
max_jid = max(jids, key=lambda jid: presences[jid]['priority'])
data = presences[max_jid]
max_priority = data['priority']
if show == "unavailable": # do not check the priority here, because 'unavailable' has a dummy one
from_jid = JID(max_jid)
show, priority, statuses = data['show'], data['priority'], data['statuses']
if not jids or priority >= max_priority:
# case 1: not jids means all resources are disconnected, send the 'unavailable' presence
# case 2: update (or confirm) with the values of the resource which takes precedence
self.contact_list.updatePresence(from_jid, show, priority, statuses)
def roomJoinedHandler(self, room_jid, room_nicks, user_nick, profile):
def roomJoinedHandler(self, room_jid_s, room_nicks, user_nick, profile):
"""Called when a MUC room is joined"""
log.debug(_("Room [%(room_jid)s] joined by %(profile)s, users presents:%(users)s") % {'room_jid': room_jid, 'profile': profile, 'users': room_nicks})
self.chat_wins[room_jid].setUserNick(user_nick)
self.chat_wins[room_jid].setType("group")
self.chat_wins[room_jid].id = room_jid
self.chat_wins[room_jid].setPresents(list(set([user_nick] + room_nicks)))
self.contact_list.setSpecial(JID(room_jid), "MUC", show=True)
log.debug("Room [%(room_jid)s] joined by %(profile)s, users presents:%(users)s" % {'room_jid': room_jid_s, 'profile': profile, 'users': room_nicks})
room_jid = jid.JID(room_jid_s)
chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_='group', profile=profile)
chat_widget.setUserNick(user_nick)
chat_widget.id = room_jid # FIXME: to be removed
chat_widget.setPresents(list(set([user_nick] + room_nicks)))
self.contact_lists[profile].setSpecial(room_jid, C.CONTACT_SPECIAL_GROUP)
def roomLeftHandler(self, room_jid_s, profile):
"""Called when a MUC room is left"""
log.debug(_("Room [%(room_jid)s] left by %(profile)s") % {'room_jid': room_jid_s, 'profile': profile})
log.debug("Room [%(room_jid)s] left by %(profile)s" % {'room_jid': room_jid_s, 'profile': profile})
del self.chat_wins[room_jid_s]
self.contact_list.remove(JID(room_jid_s))
self.contact_lists[profile].remove(jid.JID(room_jid_s))
def roomUserJoinedHandler(self, room_jid, user_nick, user_data, profile):
def roomUserJoinedHandler(self, room_jid_s, user_nick, user_data, profile):
"""Called when an user joined a MUC room"""
if room_jid in self.chat_wins:
self.chat_wins[room_jid].replaceUser(user_nick)
log.debug(_("user [%(user_nick)s] joined room [%(room_jid)s]") % {'user_nick': user_nick, 'room_jid': room_jid})
room_jid = jid.JID(room_jid_s)
chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_='group', profile=profile)
chat_widget.replaceUser(user_nick)
log.debug("user [%(user_nick)s] joined room [%(room_jid)s]" % {'user_nick': user_nick, 'room_jid': room_jid})
def roomUserLeftHandler(self, room_jid, user_nick, user_data, profile):
def roomUserLeftHandler(self, room_jid_s, user_nick, user_data, profile):
"""Called when an user joined a MUC room"""
if room_jid in self.chat_wins:
self.chat_wins[room_jid].removeUser(user_nick)
log.debug(_("user [%(user_nick)s] left room [%(room_jid)s]") % {'user_nick': user_nick, 'room_jid': room_jid})
room_jid = jid.JID(room_jid_s)
chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_='group', profile=profile)
chat_widget.removeUser(user_nick)
log.debug("user [%(user_nick)s] left room [%(room_jid)s]" % {'user_nick': user_nick, 'room_jid': room_jid})
def roomUserChangedNickHandler(self, room_jid, old_nick, new_nick, profile):
def roomUserChangedNickHandler(self, room_jid_s, old_nick, new_nick, profile):
"""Called when an user joined a MUC room"""
if room_jid in self.chat_wins:
self.chat_wins[room_jid].changeUserNick(old_nick, new_nick)
log.debug(_("user [%(old_nick)s] is now known as [%(new_nick)s] in room [%(room_jid)s]") % {'old_nick': old_nick, 'new_nick': new_nick, 'room_jid': room_jid})
room_jid = jid.JID(room_jid_s)
chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_='group', profile=profile)
chat_widget.changeUserNick(old_nick, new_nick)
log.debug("user [%(old_nick)s] is now known as [%(new_nick)s] in room [%(room_jid)s]" % {'old_nick': old_nick, 'new_nick': new_nick, 'room_jid': room_jid})
def roomNewSubjectHandler(self, room_jid, subject, profile):
def roomNewSubjectHandler(self, room_jid_s, subject, profile):
"""Called when subject of MUC room change"""
if room_jid in self.chat_wins:
self.chat_wins[room_jid].setSubject(subject)
log.debug(_("new subject for room [%(room_jid)s]: %(subject)s") % {'room_jid': room_jid, "subject": subject})
room_jid = jid.JID(room_jid_s)
chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_='group', profile=profile)
chat_widget.setSubject(subject)
log.debug("new subject for room [%(room_jid)s]: %(subject)s" % {'room_jid': room_jid, "subject": subject})
def tarotGameStartedHandler(self, room_jid, referee, players, profile):
def tarotGameStartedHandler(self, room_jid_s, referee, players, profile):
log.debug(_("Tarot Game Started \o/"))
if room_jid in self.chat_wins:
self.chat_wins[room_jid].startGame("Tarot", referee, players)
log.debug(_("new Tarot game started by [%(referee)s] in room [%(room_jid)s] with %(players)s") % {'referee': referee, 'room_jid': room_jid, 'players': [str(player) for player in players]})
room_jid = jid.JID(room_jid_s)
chat_widget = self.widgets.getOrCreateWidget(quick_chat.QuickChat, room_jid, type_='group', profile=profile)
chat_widget.startGame("Tarot", referee, players)
log.debug("new Tarot game started by [%(referee)s] in room [%(room_jid)s] with %(players)s" % {'referee': referee, 'room_jid': room_jid, 'players': [str(player) for player in players]})
def tarotGameNewHandler(self, room_jid, hand, profile):
log.debug(_("New Tarot Game"))
@ -501,27 +493,17 @@ class QuickApp(object):
self.chat_wins[room_jid].getGame("Quiz").quizGameTimerRestartedHandler(time_left)
def chatStateReceivedHandler(self, from_jid_s, state, profile):
"""Callback when a new chat state is received.
"""Called when a new chat state is received.
@param from_jid_s: JID of the contact who sent his state, or '@ALL@'
@param state: new state (string)
@profile: current profile
"""
if from_jid_s == '@ALL@':
target = '@ALL@'
nick = C.ALL_OCCUPANTS
else:
from_jid = JID(from_jid_s)
target = from_jid.bare
nick = from_jid.resource
for bare in self.chat_wins.keys():
if target == '@ALL' or target == bare:
chat_win = self.chat_wins[bare]
if chat_win.type == 'one2one':
chat_win.updateChatState(state)
elif chat_win.type == 'group':
chat_win.updateChatState(state, nick=nick)
from_jid = jid.JID(from_jid_s) if from_jid_s != C.ENTITY_ALL else C.ENTITY_ALL
for widget in self.visible_widgets:
if isinstance(widget, quick_chat.QuickChat):
if from_jid == C.ENTITY_ALL or from_jid.bare == widget.target.bare:
widget.updateChatState(from_jid, state)
def _subscribe_cb(self, answer, data):
entity, profile = data
@ -532,7 +514,7 @@ class QuickApp(object):
def subscribeHandler(self, type, raw_jid, profile):
"""Called when a subsciption management signal is received"""
entity = JID(raw_jid)
entity = jid.JID(raw_jid)
if type == "subscribed":
# this is a subscription confirmation, we just have to inform user
self.showDialog(_("The contact %s has accepted your subscription") % entity.bare, _('Subscription confirmation'))
@ -553,33 +535,27 @@ class QuickApp(object):
log.debug(_("param update: [%(namespace)s] %(name)s = %(value)s") % {'namespace': namespace, 'name': name, 'value': value})
if (namespace, name) == ("Connection", "JabberID"):
log.debug(_("Changing JID to %s") % value)
self.profiles[profile]['whoami'] = JID(value)
self.profiles[profile].whoami = jid.JID(value)
elif (namespace, name) == ("Misc", "Watched"):
self.profiles[profile]['watched'] = value.split()
elif (namespace, name) == ('General', C.SHOW_OFFLINE_CONTACTS):
self.contact_list.showOfflineContacts(C.bool(value))
self.contact_lists[profile].showOfflineContacts(C.bool(value))
elif (namespace, name) == ('General', C.SHOW_EMPTY_GROUPS):
self.contact_list.showEmptyGroups(C.bool(value))
self.contact_lists[profile].showEmptyGroups(C.bool(value))
def contactDeletedHandler(self, jid, profile):
target = JID(jid)
self.contact_list.remove(target)
try:
self.profiles[profile]['onlineContact'].remove(target.bare)
except KeyError:
pass
target = jid.JID(jid)
self.contact_lists[profile].remove(target)
def entityDataUpdatedHandler(self, jid_str, key, value, profile):
jid = JID(jid_str)
def entityDataUpdatedHandler(self, entity_s, key, value, profile):
entity = jid.JID(entity_s)
if key == "nick":
if jid in self.contact_list:
self.contact_list.setCache(jid, 'nick', value)
self.contact_list.replace(jid)
if entity in self.contact_lists[profile]:
self.contact_lists[profile].setCache(entity, 'nick', value)
elif key == "avatar":
if jid in self.contact_list:
if entity in self.contact_lists[profile]:
filename = self.bridge.getAvatarFile(value)
self.contact_list.setCache(jid, 'avatar', filename)
self.contact_list.replace(jid)
self.contact_lists[profile].setCache(entity, 'avatar', filename)
def askConfirmationHandler(self, confirm_id, confirm_type, data, profile):
raise NotImplementedError
@ -587,22 +563,23 @@ class QuickApp(object):
def actionResultHandler(self, type, id, data, profile):
raise NotImplementedError
def launchAction(self, callback_id, data=None, profile_key="@NONE@"):
""" Launch a dynamic action
def launchAction(self, callback_id, data=None, callback=None, profile="@NONE@"):
"""Launch a dynamic action
@param callback_id: id of the action to launch
@param data: data needed only for certain actions
@param profile_key: %(doc_profile_key)s
@param callback: if not None and 'validated' key is present, it will be called with the following parameters:
- callback_id
- data
- profile_key
@param profile_key: %(doc_profile)s
"""
raise NotImplementedError
def onExit(self):
"""Must be called when the frontend is terminating"""
#TODO: mange multi-profile here
try:
if self.bridge.isConnected(self.profile):
if self.bridge.getParamA("autodisconnect", "Connection", profile_key=self.profile) == "true":
for profile in self.profiles:
if self.bridge.isConnected(profile):
if C.bool(self.bridge.getParamA("autodisconnect", "Connection", profile_key=profile)):
#The user wants autodisconnection
self.bridge.disconnect(self.profile)
except:
pass
self.bridge.disconnect(profile)

View file

@ -21,32 +21,75 @@ from sat.core.i18n import _
from sat.core.log import getLogger
log = getLogger(__name__)
from sat_frontends.tools.jid import JID
from sat_frontends.quick_frontend.quick_utils import unescapePrivate
from sat_frontends.quick_frontend import quick_widgets
from sat_frontends.quick_frontend.constants import Const as C
class QuickChat(object):
class QuickChat(quick_widgets.QuickWidget):
def __init__(self, target, host, type_='one2one'):
self.target = target
self.host = host
def __init__(self, host, target, type_=C.CHAT_ONE2ONE, profiles=None):
"""
@param type_: can be C.CHAT_ONE2ONE for single conversation or C.CHAT_GROUP for chat à la IRC
"""
quick_widgets.QuickWidget.__init__(self, host, target, profiles=profiles)
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 = ""
self.id = "" # FIXME: to be removed
self.nick = None
self.occupants = set()
def setType(self, type_):
"""Set the type of the chat
@param type: can be 'one2one' for single conversation or 'group' for chat à la IRC
def __str__(self):
return u"Chat Widget [target: {}, type: {}, profile: {}]".format(self.target, self.type, self.profile)
@staticmethod
def getWidgetHash(target, profile):
return (unicode(profile), target.bare)
@staticmethod
def getPrivateHash(target, profile):
"""Get unique hash for private conversations
This method should be used with force_hash to get unique widget for private MUC conversations
"""
self.type = type_
return (unicode(profile), target)
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
@property
def target(self):
if self.type == C.CHAT_GROUP:
return self.current_target.bare
return self.current_target
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 newMessage
@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:
return True
else:
if mess_type != C.MESS_TYPE_GROUPCHAT and entity in self.targets:
return True
return False
def setPresents(self, nicks):
"""Set the users presents in the contact list for a group chat
@param nicks: list of nicknames
"""
log.debug (_("Adding users %s to room") % nicks)
if self.type != "group":
if self.type != C.CHAT_GROUP:
log.error (_("[INTERNAL] trying to set presents nicks for a non group chat window"))
raise Exception("INTERNAL ERROR") #TODO: raise proper Exception here
self.occupants.update(nicks)
@ -54,7 +97,7 @@ class QuickChat(object):
def replaceUser(self, nick, show_info=True):
"""Add user if it is not in the group list"""
log.debug (_("Replacing user %s") % nick)
if self.type != "group":
if self.type != C.CHAT_GROUP:
log.error (_("[INTERNAL] trying to replace user for a non group chat window"))
raise Exception("INTERNAL ERROR") #TODO: raise proper Exception here
len_before = len(self.occupants)
@ -65,7 +108,7 @@ class QuickChat(object):
def removeUser(self, nick, show_info=True):
"""Remove a user from the group list"""
log.debug(_("Removing user %s") % nick)
if self.type != "group":
if self.type != C.CHAT_GROUP:
log.error (_("[INTERNAL] trying to remove user for a non group chat window"))
raise Exception("INTERNAL ERROR") #TODO: raise proper Exception here
self.occupants.remove(nick)
@ -82,7 +125,7 @@ class QuickChat(object):
def changeUserNick(self, old_nick, new_nick):
"""Change nick of a user in group list"""
log.debug(_("Changing nick of user %(old_nick)s to %(new_nick)s") % {"old_nick": old_nick, "new_nick": new_nick})
if self.type != "group":
if self.type != C.CHAT_GROUP:
log.error (_("[INTERNAL] trying to change user nick for a non group chat window"))
raise Exception("INTERNAL ERROR") #TODO: raise proper Exception here
self.removeUser(old_nick, show_info=False)
@ -92,7 +135,7 @@ class QuickChat(object):
def setSubject(self, subject):
"""Set title for a group chat"""
log.debug(_("Setting subject to %s") % subject)
if self.type != "group":
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
@ -111,8 +154,8 @@ class QuickChat(object):
def onHistory(history):
for line in history:
timestamp, from_jid, to_jid, message, _type, extra = line
if ((self.type == 'group' and _type != 'groupchat') or
(self.type == 'one2one' and _type == 'groupchat')):
if ((self.type == C.CHAT_GROUP and _type != C.MESS_TYPE_GROUPCHAT) or
(self.type == C.CHAT_ONE2ONE and _type == C.MESS_TYPE_GROUPCHAT)):
continue
self.printMessage(JID(from_jid), message, profile, timestamp)
self.afterHistoryPrint()
@ -120,26 +163,47 @@ class QuickChat(object):
def onHistoryError(err):
log.error(_("Can't get history"))
if self.target.startswith(C.PRIVATE_PREFIX):
target = unescapePrivate(self.target)
target = self.target.bare
return self.host.bridge.getHistory(self.host.profiles[profile].whoami.bare, target, size, search=search, profile=profile, callback=onHistory, errback=onHistoryError)
def _get_nick(self, entity):
"""Return nick of this entity when possible"""
if self.type == C.CHAT_GROUP:
return entity.resource
contact_list = self.host.contact_lists[self.profile]
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 newMessage(self, from_jid, target, msg, type_, extra, profile):
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.newMessage(from_jid, target, msg, type_, extra, profile)
else:
target = self.target.bare
return self.host.bridge.getHistory(self.host.profiles[profile]['whoami'].bare, target, size, search=search, profile=profile, callback=onHistory, errback=onHistoryError)
def _get_nick(self, jid):
"""Return nick of this jid when possible"""
if self.target.startswith(C.PRIVATE_PREFIX):
unescaped = unescapePrivate(self.target)
if jid.startswith(C.PRIVATE_PREFIX) or unescaped.bare == jid.bare:
return unescaped.resource
return jid.resource if self.type == "group" else (self.host.contact_list.getCache(jid,'nick') or self.host.contact_list.getCache(jid,'name') or jid.node)
timestamp = extra.get('archive')
if type_ == C.MESS_TYPE_INFO:
self.printInfo(msg, timestamp=float(timestamp) if timestamp else None)
else:
self.printMessage(from_jid, msg, profile, float(timestamp) if timestamp else None)
def printMessage(self, from_jid, msg, profile, timestamp=None):
"""Print message in chat window. Must be implemented by child class"""
jid = JID(from_jid)
nick = self._get_nick(jid)
mymess = (jid.resource == self.nick) if self.type == "group" else (jid.bare == self.host.profiles[profile]['whoami'].bare) #mymess = True if message comes from local user
mymess = (jid.resource == self.nick) if self.type == C.CHAT_GROUP else (jid.bare == self.host.profiles[profile].whoami.bare) #mymess = True if message comes from local user
if msg.startswith('/me '):
self.printInfo('* %s %s' % (nick, msg[4:]), type_='me', timestamp=timestamp)
return
@ -165,12 +229,11 @@ class QuickChat(object):
#No need to raise an error as game are not mandatory
log.warning(_('getGame is not implemented in this frontend'))
def updateChatState(self, state, nick=None):
"""Set the chat state (XEP-0085) of the contact. Leave nick to None
to set the state for a one2one conversation, or give a nickname or
C.ALL_OCCUPANTS to set the state of a participant within a MUC.
def updateChatState(self, from_jid, state):
"""Set the chat state (XEP-0085) of the contact.
@param state: the new chat state
@param nick: None for one2one, the MUC user nick or ALL_OCCUPANTS
"""
raise NotImplementedError
quick_widgets.register(QuickChat)

View file

@ -1,39 +0,0 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
# helper class for making a SAT frontend
# Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 Jérôme Poisson (goffi@goffi.org)
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from sat_frontends.tools.jid import JID
class QuickChatList(dict):
"""This class is used to manage the list of chat windows.
It act as a dict, but create a chat window when the name is found for the first time."""
def __init__(self, host):
dict.__init__(self)
self.host = host
def __getitem__(self, to_jid):
target = JID(to_jid)
if not target.bare in self:
#we have to create the chat win
self[target.bare] = self.createChat(target)
return dict.__getitem__(self, target.bare)
def createChat(self, target):
raise NotImplementedError

View file

@ -20,41 +20,158 @@
from sat.core.i18n import _
from sat.core.log import getLogger
log = getLogger(__name__)
from sat_frontends.quick_frontend.quick_widgets import QuickWidget
from sat_frontends.quick_frontend.constants import Const as C
from sat_frontends.tools import jid
class QuickContactList(object):
class QuickContactList(QuickWidget):
"""This class manage the visual representation of contacts"""
def __init__(self):
def __init__(self, host, profile):
log.debug(_("Contact List init"))
super(QuickContactList, self).__init__(host, profile, profile)
# bare jids as keys, resources are used in data
self._cache = {}
self.specials={}
def update_jid(self, jid):
"""Update the jid in the list when something changed"""
# special entities (groupchat, gateways, etc), bare jids
self._specials = set()
# extras are specials with full jids (e.g.: private MUC conversation)
self._special_extras = set()
# group data contain jids in groups and misc frontend data
self._groups = {} # groups to group data map
# contacts in roster (bare jids)
self._roster = set()
# entities with an alert (usually a waiting message), full jid
self._alerts = set()
# selected entities, full jid
self._selected = set()
# options
self.show_disconnected = False
self.show_empty_groups = True
self.show_resources = False
self.show_status = False
# TODO: this may lead to two successive UI refresh and needs an optimization
self.host.bridge.asyncGetParamA(C.SHOW_EMPTY_GROUPS, "General", profile_key=profile, callback=self.showEmptyGroups)
self.host.bridge.asyncGetParamA(C.SHOW_OFFLINE_CONTACTS, "General", profile_key=profile, callback=self.showOfflineContacts)
def __contains__(self, entity):
"""Check if entity is in contact list
@param entity (jid.JID): jid of the entity (resource is not ignored, use bare jid if needed)
"""
if entity.resource:
try:
return entity.resource in self.getCache(entity.bare, C.CONTACT_RESOURCES)
except KeyError:
return False
return entity in self._cache
def fill(self):
"""Get all contacts from backend, and fill the widget"""
def gotContacts(contacts):
for contact in contacts:
self.host.newContactHandler(*contact, profile=self.profile)
presences = self.host.bridge.getPresenceStatuses(self.profile)
for contact in presences:
for res in presences[contact]:
jabber_id = ('%s/%s' % (jid.JID(contact).bare, res)) if res else contact
show = presences[contact][res][0]
priority = presences[contact][res][1]
statuses = presences[contact][res][2]
self.host.presenceUpdateHandler(jabber_id, show, priority, statuses, self.profile)
data = self.host.bridge.getEntityData(contact, ['avatar', 'nick'], self.profile)
for key in ('avatar', 'nick'):
if key in data:
self.host.entityDataUpdatedHandler(contact, key, data[key], self.profile)
self.host.bridge.getContacts(self.profile, callback=gotContacts)
def update(self):
"""Update the display when something changed"""
raise NotImplementedError
def getCache(self, jid, name):
def getCache(self, entity, name=None):
"""Return a cache value for a contact
@param entity(entity.entity): entity of the contact from who we want data (resource is used if given)
if a resource specific information is requested:
- if no resource is given (bare jid), the main resource is used, according to priority
- if resource is given, it is used
@param name(unicode): name the data to get, or None to get everything
"""
cache = self._cache[entity.bare]
if name is None:
return cache
try:
jid_cache = self._cache[jid.bare]
if name == 'status': #XXX: we get the first status for 'status' key
return jid_cache['statuses'].get('default','')
return jid_cache[name]
except (KeyError, IndexError):
if name in ('status', C.PRESENCE_STATUSES, C.PRESENCE_PRIORITY, C.PRESENCE_SHOW):
# these data are related to the resource
if not entity.resource:
main_resource = cache[C.CONTACT_MAIN_RESOURCE]
cache = cache[C.CONTACT_RESOURCES][main_resource]
else:
cache = cache[C.CONTACT_RESOURCES][entity.resource]
if name == 'status': #XXX: we get the first status for 'status' key
# TODO: manage main language for statuses
return cache[C.PRESENCE_STATUSES].get('default','')
return cache[name]
except KeyError:
return None
def setCache(self, jid, name, value):
jid_cache = self._cache.setdefault(jid.bare, {})
jid_cache[name] = value
def setCache(self, entity, name, value):
"""Set or update value for one data in cache
def __contains__(self, jid):
raise NotImplementedError
@param entity(JID): entity to update
@param name(unicode): value to set or update
"""
self.setContact(entity, None, {name: value})
def setGroupData(self, group, name, value):
"""Register a data for a group
@param group: a valid (existing) group name
@param name: name of the data (can't be "jids")
@param value: value to set
"""
assert name is not 'jids'
self._groups[group][name] = value
def getGroupData(self, group, name=None):
"""Return value associated to group data
@param group: a valid (existing) group name
@param name: name of the data or None to get the whole dict
@return: registered value
"""
if name is None:
return self._groups[group]
return self._groups[group][name]
def setSpecial(self, entity, special_type):
"""Set special flag on an entity
@param entity(jid.JID): jid of the special entity
@param special_type: one of special type (e.g. C.CONTACT_SPECIAL_GROUP) or None to remove special flag
"""
assert special_type in C.CONTACT_SPECIAL_ALLOWED + (None,)
self.setCache(entity, C.CONTACT_SPECIAL, special_type)
def clearContacts(self):
"""Clear all the contact list"""
self.specials.clear()
self.unselectAll()
self._cache.clear()
self._groups.clear()
self._specials.clear()
self.update()
def replace(self, jid, groups=None, attributes=None):
def setContact(self, entity, groups=None, attributes=None, in_roster=False):
"""Add a contact to the list if doesn't exist, else update it.
This method can be called with groups=None for the purpose of updating
@ -64,49 +181,177 @@ class QuickContactList(object):
None value for 'groups' has a different meaning than [None] which is for the default group.
@param jid (JID)
@param entity (jid.JID): entity to add or replace
@param groups (list): list of groups or None to ignore the groups membership.
@param attributes (dict)
@param attributes (dict): attibutes of the added jid or to update
@param in_roster (bool): True if contact is from roster
"""
if attributes and 'name' in attributes:
self.setCache(jid, 'name', attributes['name'])
if attributes is None:
attributes = {}
def remove(self, jid):
"""remove a contact from the list"""
entity_bare = entity.bare
if in_roster:
self._roster.add(entity_bare)
cache = self._cache.setdefault(entity_bare, {C.CONTACT_RESOURCES: {}})
assert not C.CONTACT_DATA_FORBIDDEN.intersection(attributes) # we don't want forbidden data in attributes
# we set groups and fill self._groups accordingly
if groups is not None:
if not groups:
groups = [None] # [None] is the default group
cache[C.CONTACT_GROUPS] = groups
for group in groups:
self._groups.setdefault(group, {}).setdefault('jids', set()).add(entity_bare)
# special entities management
if C.CONTACT_SPECIAL in attributes:
if attributes[C.CONTACT_SPECIAL] is None:
del attributes[C.CONTACT_SPECIAL]
self._specials.remove(entity_bare)
else:
self._specials.add(entity_bare)
# now the attribute we keep in cache
for attribute, value in attributes.iteritems():
cache[attribute] = value
# we can update the display
self.update()
def getContacts(self):
"""Return contacts currently selected
@return (set): set of selected entities"""
return self._selected
def entityToShow(self, entity, check_resource=False):
"""Tell if the contact should be showed or hidden.
@param contact (jid.JID): jid of the contact
@param check_resource (bool): True if resource must be significant
@return: True if that contact should be showed in the list
"""
show = self.getCache(entity, C.PRESENCE_SHOW)
if check_resource:
alerts = self._alerts
selected = self._selected
else:
alerts = {alert.bare for alert in self._alerts}
selected = {selected.bare for selected in self._selected}
return ((show is not None and show != "unavailable")
or self.show_disconnected
or entity in alerts
or entity in selected)
def anyEntityToShow(self, entities, check_resources=False):
"""Tell if in a list of entities, at least one should be shown
@param entities (list[jid.JID]): list of jids
@param check_resources (bool): True if resources must be significant
@return: bool
"""
for entity in entities:
if self.entityToShow(entity, check_resources):
return True
return False
def remove(self, entity):
"""remove a contact from the list
@param entity(jid.JID): jid of the entity to remove (bare jid is used)
"""
entity_bare = entity.bare
try:
del self.specials[jid.bare]
groups = self._cache[entity_bare].get(C.CONTACT_GROUPS, set())
except KeyError:
pass
log.warning(_("Trying to delete an unknow entity [{}]").format(entity))
del self._cache[entity_bare]
for group in groups:
self._groups[group]['jids'].remove(entity_bare)
for set_ in (self._selected, self._alerts, self._specials, self._special_extras):
to_remove = set()
for set_entity in set_:
if set_entity.bare == entity.bare:
to_remove.add(set_entity)
set_.difference_update(to_remove)
self.update()
def add(self, jid, param_groups=None):
"""add a contact to the list"""
raise NotImplementedError
def getSpecial(self, jid):
"""Return special type of jid, or None if it's not special"""
return self.specials.get(jid.bare)
def setSpecial(self, jid, _type, show=False):
"""Set entity as a special
@param jid: jid of the entity
@param _type: special type (e.g.: "MUC")
@param show: True to display the dialog to chat with this entity
"""
self.specials[jid.bare] = _type
def updatePresence(self, jid, show, priority, statuses):
def updatePresence(self, entity, show, priority, statuses):
"""Update entity's presence status
@param jid: entity to update's jid
@param entity(jid.JID): entity to update's entity
@param show: availability
@parap priority: resource's priority
@param statuses: dict of statuses"""
self.setCache(jid, 'show', show)
self.setCache(jid, 'prority', priority)
self.setCache(jid, 'statuses', statuses)
self.update_jid(jid)
@param statuses: dict of statuses
"""
cache = self.getCache(entity)
if show == C.PRESENCE_UNAVAILABLE:
if not entity.resource:
cache[C.CONTACT_RESOURCES].clear()
cache[C.CONTACT_MAIN_RESOURCE]= None
else:
del cache[C.CONTACT_RESOURCES][entity.resource]
if not cache[C.CONTACT_RESOURCES]:
cache[C.CONTACT_MAIN_RESOURCE] = None
else:
assert entity.resource
resources_data = cache[C.CONTACT_RESOURCES]
resource_data = resources_data.setdefault(entity.resource, {})
resource_data[C.PRESENCE_SHOW] = show
resource_data[C.PRESENCE_PRIORITY] = int(priority)
resource_data[C.PRESENCE_STATUSES] = statuses
priority_resource = max(resources_data, key=lambda res: resources_data[res][C.PRESENCE_PRIORITY])
cache[C.CONTACT_MAIN_RESOURCE] = priority_resource
self.update()
def unselectAll(self):
"""Unselect all contacts"""
self._selected.clear()
self.update()
def select(self, entity):
"""Select an entity
@param entity(jid.JID): entity to select (resource is significant)
"""
log.debug("select %s" % entity)
self._selected.add(entity)
self.update()
def setAlert(self, entity):
"""Set an alert on the entity (usually for a waiting message)
@param entity(jid.JID): entity which must displayed in alert mode (resource is significant)
"""
self._alerts.add(entity)
self.update()
def showOfflineContacts(self, show):
pass
show = C.bool(show)
if self.show_disconnected == show:
return
self.show_disconnected = show
self.update()
def showEmptyGroups(self, show):
pass
show = C.bool(show)
if self.show_empty_groups == show:
return
self.show_empty_groups = show
self.update()
def showResources(self, show):
show = C.bool(show)
if self.show_resources == show:
return
self.show_resources = show
self.update()

View file

@ -17,20 +17,7 @@
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from sat_frontends.tools.jid import JID
from os.path import exists, splitext
from sat_frontends.quick_frontend.constants import Const
def escapePrivate(ori_jid):
"""Escape a private jid"""
return JID(Const.PRIVATE_PREFIX + ori_jid.bare + '@' + ori_jid.resource)
def unescapePrivate(escaped_jid):
if not escaped_jid.startswith(Const.PRIVATE_PREFIX):
return escaped_jid
escaped_split = tuple(escaped_jid[len(Const.PRIVATE_PREFIX):].split('@'))
assert(len(escaped_split) == 3)
return JID("%s@%s/%s" % escaped_split)
def getNewPath(path):
""" Check if path exists, and find a non existant path if needed """

View file

@ -0,0 +1,187 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
# helper class for making a SAT frontend
# Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 Jérôme Poisson (goffi@goffi.org)
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from sat.core.log import getLogger
log = getLogger(__name__)
from sat.core import exceptions
classes_map = {}
def register(base_cls, child_cls=None):
"""Register a child class to use by default when a base class is needed
@param base_cls: "Quick..." base class (like QuickChat or QuickContact), must inherit from QuickWidget
@param child_cls: inherited class to use when Quick... class is requested, must inherit from base_cls.
Can be None if it's the base_cls itself which register
"""
classes_map[base_cls] = child_cls
class QuickWidgetsManager(object):
"""This class is used to manage all the widgets of a frontend
A widget can be a window, a graphical thing, or someting else depending of the frontend"""
def __init__(self, host):
self.host = host
self._widgets = {}
def getOrCreateWidget(self, class_, target, *args, **kwargs):
"""Get an existing widget or create a new one when necessary
If the widget is new, self.host.newWidget will be called with it.
@param class_(class): class of the widget to create
@param target: target depending of the widget, usually a JID instance
@param args(list): optional args to create a new instance of class_
@param kwargs(list): optional kwargs to create anew instance of class_
if 'profile' key is present, it will be popped and put in 'profiles'
if there is neither 'profile' nor 'profiles', None will be used for 'profiles'
if 'on_new_widget' is present it can have the following values:
'NEW_WIDGET' [default]: self.host.newWidget will be called on widget creation
[callable]: this method will be called instead of self.host.newWidget
None: do nothing
if 'force_hash' is present, the hash given in value will be used instead of the one returned by class_.getWidgetHash
@return: a class_ instance, either new or already existing
"""
# class management
try:
cls = classes_map[class_]
except KeyError:
cls = class_
if cls is None:
raise exceptions.InternalError("There is not class registered for {}".format(class_))
# arguments management
_args = [self.host, target] + list(args) or [] # FIXME: check if it's really necessary to use optional args
_kwargs = kwargs or {}
if 'profiles' in _kwargs and 'profile' in _kwargs:
raise ValueError("You can't have 'profile' and 'profiles' keys at the same time")
try:
_kwargs['profiles'] = _kwargs.pop('profile')
except KeyError:
if not 'profiles' in _kwargs:
_kwargs['profiles'] = None
# we get the hash
try:
hash_ = _kwargs.pop('force_hash')
except KeyError:
hash_ = cls.getWidgetHash(target, _kwargs['profiles'])
# widget creation or retrieval
widgets_list = self._widgets.setdefault(cls, {}) # we sorts widgets by classes
if not cls.SINGLE:
widget = None # if the class is not SINGLE, we always create a new widget
else:
try:
widget = widgets_list[hash_]
widget.addTarget(target)
except KeyError:
widget = None
if widget is None:
# we need to create a new widget
try:
#on_new_widget tell what to do for the new widget creation
on_new_widget = _kwargs.pop('on_new_widget')
except KeyError:
on_new_widget = 'NEW_WIDGET'
log.debug(u"Creating new widget for target {} {}".format(target, cls))
widget = cls(*_args, **_kwargs)
widgets_list[hash_] = widget
if on_new_widget == 'NEW_WIDGET':
self.host.newWidget(widget)
elif callable(on_new_widget):
on_new_widget(widget)
else:
assert on_new_widget is None
return widget
class QuickWidget(object):
"""generic widget base"""
SINGLE=True # if True, there can be only one widget per target(s)
PROFILES_MULTIPLE=False
PROFILES_ALLOW_NONE=False
def __init__(self, host, target, profiles=None):
"""
@param host: %(doc_host)s
@param target: target specific for this widget class
@param profiles: can be either:
- (unicode): used when widget class manage a unique profile
- (iterable): some widget class can manage several profiles, several at once can be specified here
- None: no profile is managed by this widget class (rare)
@raise: ValueError when (iterable) or None is given to profiles for a widget class which manage one unique profile.
"""
self.host = host
self.targets = set()
self.addTarget(target)
self.profiles = set()
if isinstance(profiles, basestring):
self.addProfile(profiles)
elif profiles is None:
if not self.PROFILES_ALLOW_NONE:
raise ValueError("profiles can't have a value of None")
else:
if not self.PROFILES_MULTIPLE:
raise ValueError("multiple profiles are not allowed")
for profile in profiles:
self.addProfile(profile)
@property
def profile(self):
assert len(self.profiles) == 1 and not self.PROFILES_MULTIPLE and not self.PROFILES_ALLOW_NONE
return list(self.profiles)[0]
def addTarget(self, target):
"""Add a target if it doesn't already exists
@param target: target to add
"""
self.targets.add(target)
def addProfile(self, profile):
"""Add a profile is if doesn't already exists
@param profile: profile to add
"""
if self.profiles and not self.PROFILES_MULTIPLE:
raise ValueError("multiple profiles are not allowed")
self.profiles.add(profile)
@staticmethod
def getWidgetHash(target, profiles):
"""Return the hash associated with this target for this widget class
some widget classes can manage several target on the same instance
(e.g.: a chat widget with multiple resources on the same bare jid),
this method allow to return a hash associated to one or several targets
to retrieve the good instance. For example, a widget managing JID targets,
and all resource of the same bare jid would return the bare jid as hash.
@param target: target to check
@param profiles: profile(s) associated to target, see __init__ docstring
@return: a hash (can correspond to one or many targets or profiles, depending of widget class)
"""
return unicode(target) # by defaut, there is one hash for one target