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:
parent
b9f967ea5f
commit
e4708c9cbb
7 changed files with 1583 additions and 969 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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 """
|
||||
|
|
|
|||
187
frontends/src/quick_frontend/quick_widgets.py
Normal file
187
frontends/src/quick_frontend/quick_widgets.py
Normal 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
|
||||
Loading…
Reference in a new issue