libervia-backend: src/plugins/plugin_xep

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

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

author	Goffi <goffi@goffi.org>
date	Mon, 27 Jun 2016 21:45:11 +0200
parents	2daf7b4c6756
children	8156f2116dc9

comparison

equal deleted inserted replaced

-:5fbe09b9b568
+:200cd707a46d
 x_elt.addElement('photo', content=avatar_hash)
 presence_elt.addChild(x_elt)
 return True
-def isInRoom(self, entity_jid, profile):
+def isInRoom(self, client, entity_jid):
 """Tell if an full jid is a member of a room
 @param entity_jid(jid.JID): full jid of the entity
 @return (bool): True if the bare jid of the entity is a room jid
 """
 try:
-return self.host.plugins['XEP-0045'].isRoom(entity_jid.userhostJID(), profile_key=profile)
+self.host.plugins['XEP-0045'].checkRoomJoined(client, entity_jid.userhostJID())
-except KeyError:
+except exceptions.NotFound:
 return False
+else:
+return True
 def _fillCachedValues(self, profile):
 #FIXME: this is really suboptimal, need to be reworked
 #       the current naive approach keeps a map between all jids of all profiles
 #       in persistent cache, then put avatar hashs in memory.
 def profileDisconnected(self, profile):
 log.debug(u"Deleting profile cache for avatars")
 del self.cache[profile]
-def updateCache(self, jid_, name, value, profile):
+def updateCache(self, client, jid_, name, value):
 """update cache value
 save value in memory in case of change
 @param jid_(jid.JID): jid of the owner of the vcard
 @param name(str): name of the item which changed
 @param value(unicode): new value of the item
-@param profile(unicode): profile which received the update
 """
 if jid_.resource:
-if not self.isInRoom(jid_, profile):
+if not self.isInRoom(client, jid_):
 # VCard are retrieved with bare jid
 # but MUC room is a special case
 jid_ = jid.userhostJID()
-self.host.memory.updateEntityData(jid_, name, value, profile_key=profile)
+self.host.memory.updateEntityData(jid_, name, value, profile_key=client.profile)
 if name in CACHED_DATA:
 jid_s = jid_.userhost()
-self.cache[profile].setdefault(jid_s, {})[name] = value
+self.cache[client.profile].setdefault(jid_s, {})[name] = value
-self.cache[profile].force(jid_s)
+self.cache[client.profile].force(jid_s)
-def getCache(self, entity_jid, name, profile):
+def getCache(self, client, entity_jid, name):
 """return cached value for jid
 @param entity_jid: target contact
 @param name: name of the value ('nick' or 'avatar')
-@param profile: %(doc_profile)s
 @return: wanted value or None"""
 if entity_jid.resource:
-if not self.isInRoom(entity_jid, profile):
+if not self.isInRoom(client, entity_jid):
 # VCard are retrieved with bare jid
 # but MUC room is a special case
 entity_jid = jid.userhostJID()
 try:
-data = self.host.memory.getEntityData(entity_jid, [name], profile)
+data = self.host.memory.getEntityData(entity_jid, [name], client.profile)
 except exceptions.UnknownEntityError:
 return None
 return data.get(name)
 def _getFilename(self, hash_):
 image_hash = sha1(decoded).hexdigest()
 self.saveAvatarFile(decoded, image_hash)
 return image_hash
 @defer.inlineCallbacks
-def vCard2Dict(self, vcard, target, profile):
+def vCard2Dict(self, client, vcard, target):
 """Convert a VCard to a dict, and save binaries"""
 log.debug(_("parsing vcard"))
 dictionary = {}
 for elem in vcard.elements():
 if elem.name == 'FN':
 dictionary['fullname'] = unicode(elem)
 elif elem.name == 'NICKNAME':
 dictionary['nick'] = unicode(elem)
-self.updateCache(target, 'nick', dictionary['nick'], profile)
+self.updateCache(client, target, 'nick', dictionary['nick'])
 elif elem.name == 'URL':
 dictionary['website'] = unicode(elem)
 elif elem.name == 'EMAIL':
 dictionary['email'] = unicode(elem)
 elif elem.name == 'BDAY':
 elif elem.name == 'PHOTO':
 dictionary["avatar"] = yield threads.deferToThread(self.savePhoto, elem)
 if not dictionary["avatar"]:  # can happen in case of e.g. empty photo elem
 del dictionary['avatar']
 else:
-self.updateCache(target, 'avatar', dictionary['avatar'], profile)
+self.updateCache(client, target, 'avatar', dictionary['avatar'])
 else:
 log.info(_('FIXME: [%s] VCard tag is not managed yet') % elem.name)
 # if a data in cache doesn't exist anymore, we need to reset it
 # so we check CACHED_DATA no gotten (i.e. not in dictionary keys)
 # and we reset them
 for datum in CACHED_DATA.difference(dictionary.keys()):
 log.debug(u"reseting vcard datum [{datum}] for {entity}".format(datum=datum, entity=target.full()))
-self.updateCache(target, datum, '', profile)
+self.updateCache(client, target, datum, '')
 defer.returnValue(dictionary)
-def _VCardCb(self, answer, profile):
+def _VCardCb(self, answer, client):
 """Called after the first get IQ"""
 log.debug(_("VCard found"))
 if answer.firstChildElement().name == "vCard":
-_jid, steam = self.host.getJidNStream(profile)
 try:
 from_jid = jid.JID(answer["from"])
 except KeyError:
-from_jid = _jid.userhostJID()
+from_jid = client.jid.userhostJID()
-d = self.vCard2Dict(answer.firstChildElement(), from_jid, profile)
+d = self.vCard2Dict(client, answer.firstChildElement(), from_jid)
-d.addCallback(lambda data: self.host.bridge.actionResult("RESULT", answer['id'], data, profile))
+d.addCallback(lambda data: self.host.bridge.actionResult("RESULT", answer['id'], data, client.profile))
 else:
 log.error(_("FIXME: vCard not found as first child element"))
-self.host.bridge.actionResult("SUPPRESS", answer['id'], {}, profile)  # FIXME: maybe an error message would be better
+self.host.bridge.actionResult("SUPPRESS", answer['id'], {}, client.profile)  # FIXME: maybe an error message would be better
-def _VCardEb(self, failure, profile):
+def _VCardEb(self, failure, client):
 """Called when something is wrong with registration"""
 try:
-self.host.bridge.actionResult("SUPPRESS", failure.value.stanza['id'], {}, profile)  # FIXME: maybe an error message would be better
+self.host.bridge.actionResult("SUPPRESS", failure.value.stanza['id'], {}, client.profile)  # FIXME: maybe an error message would be better
 log.warning(_(u"Can't find VCard of %s") % failure.value.stanza['from'])
-self.updateCache(jid.JID(failure.value.stanza['from']), "avatar", '', profile)
+self.updateCache(client, jid.JID(failure.value.stanza['from']), "avatar", '')
 except (AttributeError, KeyError):
 # 'ConnectionLost' object has no attribute 'stanza' + sometimes 'from' key doesn't exist
 log.warning(_(u"Can't find VCard: %s") % failure.getErrorMessage())
 def _getCard(self, target_s, profile_key=C.PROF_KEY_NONE):
-return self.getCard(jid.JID(target_s), profile_key)
+client = self.host.getClient(profile_key)
+return self.getCard(client, jid.JID(target_s))
-def getCard(self, target, profile_key=C.PROF_KEY_NONE):
+def getCard(self, client, target):
 """Ask server for VCard
 @param target(jid.JID): jid from which we want the VCard
 @result: id to retrieve the profile
 """
-current_jid, xmlstream = self.host.getJidNStream(profile_key)
-if not xmlstream:
-raise exceptions.ProfileUnknownError('Asking vcard for a non-existant or not connected profile ({})'.format(profile_key))
-profile = self.host.memory.getProfileName(profile_key)
 to_jid = target.userhostJID()
 log.debug(_(u"Asking for %s's VCard") % to_jid.userhost())
-reg_request = IQ(xmlstream, 'get')
+reg_request = client.IQ('get')
-reg_request["from"] = current_jid.full()
+reg_request["from"] = client.jid.full()
 reg_request["to"] = to_jid.userhost()
 reg_request.addElement('vCard', NS_VCARD)
-reg_request.send(to_jid.userhost()).addCallbacks(self._VCardCb, self._VCardEb, callbackArgs=[profile], errbackArgs=[profile])
+reg_request.send(to_jid.userhost()).addCallbacks(self._VCardCb, self._VCardEb, callbackArgs=[client], errbackArgs=[client])
 return reg_request["id"]
 def getAvatarFile(self, avatar_hash):
 """Give the full path of avatar from hash
 @param hash: SHA1 hash
 d = threads.deferToThread(self._buildSetAvatar, vcard_set, filepath)
 def elementBuilt(result):
 """Called once the image is at the right size/format, and the vcard set element is build"""
 set_avatar_elt, img_hash = result
-self.updateCache(client.jid.userhostJID(), 'avatar', img_hash, client.profile)
+self.updateCache(client, client.jid.userhostJID(), 'avatar', img_hash)
 return set_avatar_elt.send().addCallback(lambda ignore: client.presence.available()) # FIXME: should send the current presence, not always "available" !
 d.addCallback(elementBuilt)
 return d
 Check for avatar information, and get VCard if needed
 @param presend(domish.Element): <presence/> stanza
 """
 from_jid = jid.JID(presence['from'])
-if from_jid.resource and not self.plugin_parent.isInRoom(from_jid, self.parent.profile):
+if from_jid.resource and not self.plugin_parent.isInRoom(self.parent, from_jid):
 from_jid = from_jid.userhostJID()
 #FIXME: wokkel's data_form should be used here
 try:
 x_elt = presence.elements(NS_VCARD_UPDATE, 'x').next()
 except StopIteration:
 return
 hash_ = str(photo_elt)
 if not hash_:
 return
-old_avatar = self.plugin_parent.getCache(from_jid, 'avatar', self.parent.profile)
+old_avatar = self.plugin_parent.getCache(self.parent, from_jid, 'avatar')
 filename = self.plugin_parent._getFilename(hash_)
 if not old_avatar or old_avatar != hash_:
 if os.path.exists(filename):
 log.debug(u"New avatar found for [{}], it's already in cache, we use it".format(from_jid.full()))
-self.plugin_parent.updateCache(from_jid, 'avatar', hash_, self.parent.profile)
+self.plugin_parent.updateCache(self.parent, from_jid, 'avatar', hash_)
 else:
 log.debug(u'New avatar found for [{}], requesting vcard'.format(from_jid.full()))
 self.plugin_parent.getCard(from_jid, self.parent.profile)
 else:
 if os.path.exists(filename):

Mercurial > libervia-backend

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