724a97b14d
/!\ the experimental muc branche of wokkel must be used - bridge: new roomJoined signal - wix: contact list widget is now in a separate file, and manage different kinds of presentation - wix: chat window now manage group chat (first draft, not working yet) - wix: constants are now in a separate class, so then can be accessible from everywhere - wix: new menu to join room (do nothing yet, except entering in a test room) - new plugin for xep 0045 (MUC), use wokkel experimental MUC branch - plugins: the profile is now given for get_handler, cause it can be used internally by a plugin (e.g.: xep-0045 plugin)
246 lines
9.4 KiB
Python
Executable file
246 lines
9.4 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, profile):
|
|
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('card_'+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 vcard 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)
|