656bea30dd
- core: 2 new convenient methods: getJidNStream and getClient - new param in plugin info: "handler" to know if there is a handler to plug on profiles clients - plugins with handler now use an other class which is returned to profile client with the new method "getHandler" and pluged when connecting
246 lines
9.3 KiB
Python
Executable file
246 lines
9.3 KiB
Python
Executable file
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
SAT plugin for managing xep-0054
|
|
Copyright (C) 2009, 2010 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 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
from logging import debug, info, error
|
|
from twisted.words.xish import domish
|
|
from twisted.internet import protocol, defer, threads, reactor
|
|
from twisted.words.protocols.jabber import client, jid, xmlstream
|
|
from twisted.words.protocols.jabber import error as jab_error
|
|
from twisted.words.protocols.jabber.xmlstream import IQ
|
|
import os.path
|
|
import pdb
|
|
|
|
from zope.interface import implements
|
|
|
|
from wokkel import disco, iwokkel
|
|
|
|
from base64 import b64decode
|
|
from hashlib import sha1
|
|
from time import sleep
|
|
|
|
try:
|
|
from twisted.words.protocols.xmlstream import XMPPHandler
|
|
except ImportError:
|
|
from wokkel.subprotocols import XMPPHandler
|
|
|
|
AVATAR_PATH = "/avatars"
|
|
|
|
IQ_GET = '/iq[@type="get"]'
|
|
NS_VCARD = 'vcard-temp'
|
|
VCARD_REQUEST = IQ_GET + '/vCard[@xmlns="' + NS_VCARD + '"]' #TODO: manage requests
|
|
|
|
PRESENCE = '/presence'
|
|
NS_VCARD_UPDATE = 'vcard-temp:x:update'
|
|
VCARD_UPDATE = PRESENCE + '/x[@xmlns="' + NS_VCARD_UPDATE + '"]'
|
|
|
|
PLUGIN_INFO = {
|
|
"name": "XEP 0054 Plugin",
|
|
"import_name": "XEP_0054",
|
|
"type": "XEP",
|
|
"protocols": ["XEP-0054", "XEP-0153"],
|
|
"dependencies": [],
|
|
"main": "XEP_0054",
|
|
"handler": "yes",
|
|
"description": """Implementation of vcard-temp"""
|
|
}
|
|
|
|
class XEP_0054():
|
|
|
|
def __init__(self, host):
|
|
info("Plugin XEP_0054 initialization")
|
|
self.host = host
|
|
self.avatar_path = os.path.expanduser(self.host.get_const('local_dir') + AVATAR_PATH)
|
|
self.vcard_cache = host.memory.getPrivate("vcard_cache") or {} #used to store nicknames and avatar, key = jid
|
|
if not os.path.exists(self.avatar_path):
|
|
os.makedirs(self.avatar_path)
|
|
host.bridge.addMethod("getCard", ".communication", in_sign='ss', out_sign='s', method=self.getCard)
|
|
host.bridge.addMethod("getAvatarFile", ".communication", in_sign='s', out_sign='s', method=self.getAvatarFile)
|
|
host.bridge.addMethod("getCardCache", ".communication", in_sign='s', out_sign='a{ss}', method=self.getCardCache)
|
|
|
|
def getHandler(self):
|
|
return XEP_0054_handler(self)
|
|
|
|
def update_cache(self, jid, name, value):
|
|
"""update cache value
|
|
- save value in memory in case of change
|
|
- send updatedValue signal if the value is new or updated
|
|
"""
|
|
if not self.vcard_cache.has_key(jid.userhost()):
|
|
self.vcard_cache[jid.userhost()] = {}
|
|
|
|
cache = self.vcard_cache[jid.userhost()]
|
|
old_value = cache[name] if cache.has_key(name) else None
|
|
if not old_value or value != old_value:
|
|
cache[name] = value
|
|
self.host.memory.setPrivate("vcard_cache", self.vcard_cache)
|
|
self.host.bridge.updatedValue('profile_'+name, {'jid':jid.userhost(), name:value})
|
|
|
|
def get_cache(self, jid, name):
|
|
"""return cached value for jid
|
|
@param jid: target contact
|
|
@param name: name of the value ('nick' or 'avatar')
|
|
@return: wanted value or None"""
|
|
try:
|
|
return self.vcard_cache[jid.userhost()][name]
|
|
except KeyError:
|
|
return None
|
|
|
|
|
|
def save_photo(self, photo_xml):
|
|
"""Parse a <PHOTO> elem and save the picture"""
|
|
for elem in photo_xml.elements():
|
|
if elem.name == 'TYPE':
|
|
info('Photo of type [%s] found' % str(elem))
|
|
if elem.name == 'BINVAL':
|
|
debug('Decoding binary')
|
|
decoded = b64decode(str(elem))
|
|
hash = sha1(decoded).hexdigest()
|
|
filename = self.avatar_path+'/'+hash
|
|
if not os.path.exists(filename):
|
|
with open(filename,'wb') as file:
|
|
file.write(decoded)
|
|
debug("file saved to %s" % hash)
|
|
else:
|
|
debug("file [%s] already in cache" % hash)
|
|
return hash
|
|
|
|
@defer.deferredGenerator
|
|
def vCard2Dict(self, vcard, target):
|
|
"""Convert a VCard to a dict, and save binaries"""
|
|
debug ("parsing vcard")
|
|
dictionary = {}
|
|
d = defer.Deferred()
|
|
|
|
for elem in vcard.elements():
|
|
if elem.name == 'FN':
|
|
dictionary['fullname'] = unicode(elem)
|
|
elif elem.name == 'NICKNAME':
|
|
dictionary['nick'] = unicode(elem)
|
|
self.update_cache(target, 'nick', dictionary['nick'])
|
|
elif elem.name == 'URL':
|
|
dictionary['website'] = unicode(elem)
|
|
elif elem.name == 'EMAIL':
|
|
dictionary['email'] = unicode(elem)
|
|
elif elem.name == 'BDAY':
|
|
dictionary['birthday'] = unicode(elem)
|
|
elif elem.name == 'PHOTO':
|
|
d2 = defer.waitForDeferred(
|
|
threads.deferToThread(self.save_photo, elem))
|
|
yield d2
|
|
dictionary["avatar"] = d2.getResult()
|
|
if not dictionary["avatar"]: #can happen in case of e.g. empty photo elem
|
|
del dictionary['avatar']
|
|
else:
|
|
self.update_cache(target, 'avatar', dictionary['avatar'])
|
|
else:
|
|
info ('FIXME: [%s] VCard tag is not managed yet' % elem.name)
|
|
|
|
yield dictionary
|
|
|
|
def vcard_ok(self, answer):
|
|
"""Called after the first get IQ"""
|
|
debug ("VCard found")
|
|
|
|
if answer.firstChildElement().name == "vCard":
|
|
d = self.vCard2Dict(answer.firstChildElement(), jid.JID(answer["from"]))
|
|
d.addCallback(lambda data: self.host.bridge.actionResult("RESULT", answer['id'], data))
|
|
else:
|
|
error ("FIXME: vCard not found as first child element")
|
|
self.host.bridge.actionResult("SUPPRESS", answer['id'], {}) #FIXME: maybe an error message would be best
|
|
|
|
def vcard_err(self, failure):
|
|
"""Called when something is wrong with registration"""
|
|
error ("Can't find VCard of %s" % failure.value.stanza['from'])
|
|
self.host.bridge.actionResult("SUPPRESS", failure.value.stanza['id'], {}) #FIXME: maybe an error message would be best
|
|
|
|
def getCard(self, target, profile_key='@DEFAULT@'):
|
|
"""Ask server for VCard
|
|
@param target: jid from which we want the VCard
|
|
@result: id to retrieve the profile"""
|
|
current_jid, xmlstream = self.host.getJidNStream(profile_key)
|
|
if not xmlstream:
|
|
error ('Asking profile for an non-existant or not connected profile')
|
|
return ""
|
|
to_jid = jid.JID(target)
|
|
debug("Asking for %s's VCard" % to_jid.userhost())
|
|
reg_request=IQ(xmlstream,'get')
|
|
reg_request["from"]=current_jid.full()
|
|
reg_request["to"] = to_jid.userhost()
|
|
query=reg_request.addElement('vCard', NS_VCARD)
|
|
reg_request.send(to_jid.userhost()).addCallbacks(self.vcard_ok, self.vcard_err)
|
|
return reg_request["id"]
|
|
|
|
def getAvatarFile(self, hash):
|
|
"""Give the full path of avatar from hash
|
|
@param hash: SHA1 hash
|
|
@return full_path
|
|
"""
|
|
filename = self.avatar_path+'/'+hash
|
|
if not os.path.exists(filename):
|
|
error ("Asking for an uncached avatar [%s]" % hash)
|
|
return ""
|
|
return filename
|
|
|
|
def getCardCache(self, target):
|
|
"""Request for cached values of profile
|
|
return the cached nickname and avatar if exists, else get VCard
|
|
"""
|
|
to_jid = jid.JID(target)
|
|
result = {}
|
|
nick = self.get_cache(to_jid, 'nick')
|
|
if nick:
|
|
result['nick'] = nick
|
|
avatar = self.get_cache(to_jid, 'avatar')
|
|
if avatar:
|
|
result['avatar'] = avatar
|
|
return result
|
|
|
|
|
|
|
|
class XEP_0054_handler(XMPPHandler):
|
|
implements(iwokkel.IDisco)
|
|
|
|
def __init__(self, plugin_parent):
|
|
self.plugin_parent = plugin_parent
|
|
self.host = plugin_parent.host
|
|
|
|
def connectionInitialized(self):
|
|
self.xmlstream.addObserver(VCARD_UPDATE, self.update)
|
|
|
|
def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
|
|
return [disco.DiscoFeature(NS_VCARD)]
|
|
|
|
def getDiscoItems(self, requestor, target, nodeIdentifier=''):
|
|
return []
|
|
|
|
def update(self, presence):
|
|
"""Request for VCard's nickname
|
|
return the cached nickname if exists, else get VCard
|
|
"""
|
|
to_jid = jid.JID(presence['from'])
|
|
x_elem = filter (lambda x:x.name == "x", presence.elements())[0] #We only want the "x" element
|
|
for elem in x_elem.elements():
|
|
if elem.name == 'photo':
|
|
hash = str(elem)
|
|
old_avatar = self.plugin_parent.get_cache(to_jid, 'avatar')
|
|
if not old_avatar or old_avatar != hash:
|
|
debug('New avatar found, requesting vcard')
|
|
self.plugin_parent.getCard(to_jid.userhost(), self.parent.profile)
|