erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

plugins sharing invitation, invitation, list of interest: handle invitation to a file sharing repository

Browse source
This commit is contained in:
Goffi 2019-04-14 08:21:51 +02:00
commit ab861ef91c
3 changed files with 237 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

133
sat/plugins/plugin_exp_file_sharing_invitation.py Normal file
View file

@ -0,0 +1,133 @@
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
# SAT plugin to detect language (experimental)
# Copyright (C) 2009-2019 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.i18n import _
from sat.core.constants import Const as C
from sat.core.log import getLogger
from twisted.internet import defer
from twisted.words.protocols.jabber import jid
from wokkel import disco, iwokkel
from zope.interface import implements
from twisted.words.protocols.jabber.xmlstream import XMPPHandler
log = getLogger(__name__)
PLUGIN_INFO = {
C.PI_NAME: "File Sharing Invitation",
C.PI_IMPORT_NAME: "FILE_SHARING_INVITATION",
C.PI_TYPE: "EXP",
C.PI_PROTOCOLS: [],
C.PI_DEPENDENCIES: ["XEP-0329"],
C.PI_RECOMMENDATIONS: [],
C.PI_MAIN: "FileSharingInvitation",
C.PI_HANDLER: "yes",
C.PI_DESCRIPTION: _(u"Experimental handling of invitations for file sharing"),
}
NS_FILE_SHARING_INVITATION = "https://salut-a-toi/protocol/file-sharing-invitation:0"
INVITATION = '/message/invitation[@xmlns="{ns_invit}"]'.format(
ns_invit=NS_FILE_SHARING_INVITATION
)
class FileSharingInvitation(object):
def __init__(self, host):
log.info(_(u"File Sharing Invitation plugin initialization"))
self.host = host
def getHandler(self, client):
return FileSharingInvitationHandler(self)
def sendFileSharingInvitation(
self, client, invitee_jid, service, repos_type=None, namespace=None,
path=None):
"""Send an invitation in a <message> stanza
@param invitee_jid(jid.JID): entitee to send invitation to
@param service(jid.JID): file sharing service
@param repos_type(unicode, None): type of files repository, can be:
- None, "files": files sharing
- "photos": photos album
@param namespace(unicode, None): namespace of the shared repository
@param path(unicode): pubsub id
"""
mess_data = {
"from": client.jid,
"to": invitee_jid,
"uid": "",
"message": {},
"type": C.MESS_TYPE_CHAT,
"subject": {},
"extra": {},
}
client.generateMessageXML(mess_data)
event_elt = mess_data["xml"].addElement("invitation", NS_FILE_SHARING_INVITATION)
event_elt[u"service"] = service.full()
if repos_type is not None:
event_elt[u"type"] = repos_type
if namespace is not None:
event_elt[u"namespace"] = namespace
if path is not None:
event_elt[u"path"] = path
client.send(mess_data[u"xml"])
@defer.inlineCallbacks
def onInvitation(self, message_elt, client):
invitation_elt = message_elt.invitation
try:
service = jid.JID(invitation_elt["service"])
except (RuntimeError, KeyError):
log.warning(_(u"Bad invitation, ignoring: {xml}").format(
xml=message_elt.toXml()))
return
repos_type = invitation_elt.getAttribute(u"type", u"files")
namespace = invitation_elt.getAttribute(u"namespace")
path = invitation_elt.getAttribute(u"path")
if repos_type == u"files":
type_human = _(u"file sharing")
elif repos_type == u"photos":
type_human = _(u"photos album")
log.info(_(
u'{profile} has received an invitation for a files repository ({type_human}) '
u'with namespace "{namespace}" at path [{path}]').format(
profile=client.profile, type_human=type_human, namespace=namespace, path=path)
)
class FileSharingInvitationHandler(XMPPHandler):
implements(iwokkel.IDisco)
def __init__(self, plugin_parent):
self.plugin_parent = plugin_parent
def connectionInitialized(self):
self.xmlstream.addObserver(
INVITATION, self.plugin_parent.onInvitation, client=self.parent
)
def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
return [
disco.DiscoFeature(NS_FILE_SHARING_INVITATION),
]
def getDiscoItems(self, requestor, target, nodeIdentifier=""):
return []

81
sat/plugins/plugin_exp_invitation.py
View file

@ -35,7 +35,7 @@ PLUGIN_INFO = {
C.PI_IMPORT_NAME: "INVITATION",
C.PI_TYPE: "EXP",
C.PI_PROTOCOLS: [],
C.PI_DEPENDENCIES: ["XEP-0060"],
C.PI_DEPENDENCIES: [u"XEP-0060", u"XEP-0329"],
C.PI_RECOMMENDATIONS: [],
C.PI_MAIN: "Invitation",
C.PI_HANDLER: "yes",
@ -72,6 +72,15 @@ class Invitation(object):
- node(unicode): pubsub node
- item_id(unicode, None): pubsub item id
- item_elt(domish.Element): item of the invitation
For file sharing invitation, it will be called with following arguments:
- client
- service(jid.JID): service jid of the file repository
- repos_type(unicode): type of the repository, can be:
- files: generic file sharing
- photos: photos album
- namespace(unicode, None): namespace of the repository
- path(unicode, None): path of the repository
- name(unicode, None): name of the repository
@raise exceptions.ConflictError: this namespace is already registered
"""
if namespace in self._ns_cb:
@ -80,14 +89,11 @@ class Invitation(object):
.format(namespace=namespace, callback=self._ns_cb[namespace]))
self._ns_cb[namespace] = callback
def sendPubsubInvitation(self, client, invitee_jid, service, node,
item_id):
"""Send an invitation in a <message> stanza
def _generateBaseInvitation(self, client, invitee_jid):
"""Generate common mess_data end invitation_elt
@param invitee_jid(jid.JID): entitee to send invitation to
@param service(jid.JID): pubsub service
@param node(unicode): pubsub node
@param item_id(unicode): pubsub id
@return (tuple[dict, domish.Element): mess_data and invitation_elt
"""
mess_data = {
"from": client.jid,
@ -100,11 +106,53 @@ class Invitation(object):
}
client.generateMessageXML(mess_data)
invitation_elt = mess_data["xml"].addElement("invitation", NS_INVITATION)
return mess_data, invitation_elt
def sendPubsubInvitation(self, client, invitee_jid, service, node,
item_id):
"""Send an pubsub invitation in a <message> stanza
@param invitee_jid(jid.JID): entitee to send invitation to
@param service(jid.JID): pubsub service
@param node(unicode): pubsub node
@param item_id(unicode): pubsub id
"""
mess_data, invitation_elt = self._generateBaseInvitation(client, invitee_jid)
pubsub_elt = invitation_elt.addElement(u"pubsub")
pubsub_elt[u"service"] = service.full()
pubsub_elt[u"node"] = node
pubsub_elt[u"item"] = item_id
client.send(mess_data[u"xml"])
return client.send(mess_data[u"xml"])
def sendFileSharingInvitation(self, client, invitee_jid, service, repos_type=None,
namespace=None, path=None, name=None):
"""Send a file sharing invitation in a <message> stanza
@param invitee_jid(jid.JID): entitee to send invitation to
@param service(jid.JID): file sharing service
@param repos_type(unicode, None): type of files repository, can be:
- None, "files": files sharing
- "photos": photos album
@param namespace(unicode, None): namespace of the shared repository
@param path(unicode, None): path of the shared repository
@param name(unicode, None): name of the shared repository
"""
mess_data, invitation_elt = self._generateBaseInvitation(client, invitee_jid)
file_sharing_elt = invitation_elt.addElement(u"file_sharing")
file_sharing_elt[u"service"] = service.full()
if repos_type is not None:
if repos_type not in (u"files", "photos"):
msg = u"unknown repository type: {repos_type}".format(repos_type=repos_type)
log.warning(msg)
raise exceptions.DateError(msg)
file_sharing_elt[u"type"] = repos_type
if namespace is not None:
file_sharing_elt[u"namespace"] = namespace
if path is not None:
file_sharing_elt[u"path"] = path
if name is not None:
file_sharing_elt[u"name"] = name
return client.send(mess_data[u"xml"])
@defer.inlineCallbacks
def _parsePubsubElt(self, client, pubsub_elt):
@ -138,8 +186,23 @@ class Invitation(object):
args = [service, node, item_id, item_elt]
defer.returnValue((namespace, args))
def _parseFileSharingElt(self, client, file_sharing_elt):
try:
service = jid.JID(file_sharing_elt["service"])
except (RuntimeError, KeyError):
log.warning(_(u"Bad invitation, ignoring"))
raise exceptions.DataError
repos_type = file_sharing_elt.getAttribute(u"type", u"files")
namespace = file_sharing_elt.getAttribute(u"namespace")
path = file_sharing_elt.getAttribute(u"path")
name = file_sharing_elt.getAttribute(u"name")
args = [service, repos_type, namespace, path, name]
ns_fis = self.host.getNamespace(u"fis")
return ns_fis, args
@defer.inlineCallbacks
def onInvitation(self, message_elt, client):
log.debug(u"invitation received [{profile}]".format(profile=client.profile))
invitation_elt = message_elt.invitation
for elt in invitation_elt.elements():
if elt.uri != NS_INVITATION:
@ -147,6 +210,8 @@ class Invitation(object):
continue
if elt.name == u"pubsub":
method = self._parsePubsubElt
elif elt.name == u"file_sharing":
method = self._parseFileSharingElt
else:
log.warning(u"not implemented invitation element: {xml}".format(
xml = elt.toXml()))

33
sat/plugins/plugin_exp_list_of_interest.py
View file

@ -35,7 +35,7 @@ PLUGIN_INFO = {
C.PI_IMPORT_NAME: "LIST_INTEREST",
C.PI_TYPE: "EXP",
C.PI_PROTOCOLS: [],
C.PI_DEPENDENCIES: ["XEP-0060"],
C.PI_DEPENDENCIES: [u"XEP-0060", u"XEP-0329"],
C.PI_RECOMMENDATIONS: [],
C.PI_MAIN: "ListInterest",
C.PI_HANDLER: "yes",
@ -79,7 +79,7 @@ class ListInterest(object):
@param namespace(unicode): namespace of the interest
this is used as a cache, to avoid the need to retrieve the item only to get
its namespace
@param service(jid.JID): pubsub service of the
@param service(jid.JID): target pubsub service
@param node(unicode): target pubsub node
@param item_id(unicode, None): target pubsub id
@param creator(bool): True if client's profile is the creator of the node
@ -107,6 +107,35 @@ class ListInterest(object):
client, client.jid.userhostJID(), NS_LIST_INTEREST, items=[item_elt]
)
@defer.inlineCallbacks
def registerFileSharing(
self, client, service, repos_type=None, namespace=None, path=None, name=None):
"""Register an interesting file repository in personal list
@param service(jid.JID): service of the file repository
@param repos_type(unicode): type of the repository
@param namespace(unicode, None): namespace of the repository
@param path(unicode, None): path of the repository
@param name(unicode, None): name of the repository
"""
yield self.createNode(client)
interest_elt = domish.Element((NS_LIST_INTEREST, u"interest"))
interest_elt[u"namespace"] = self.host.getNamespace(u"fis")
if name is not None:
interest_elt[u'name'] = name
file_sharing_elt = interest_elt.addElement(u"file_sharing")
file_sharing_elt[u"service"] = service.full()
if repos_type is not None:
file_sharing_elt[u"type"] = repos_type
if namespace is not None:
file_sharing_elt[u"namespace"] = namespace
if path is not None:
file_sharing_elt[u"path"] = path
item_elt = pubsub.Item(payload=interest_elt)
yield self._p.publish(
client, client.jid.userhostJID(), NS_LIST_INTEREST, items=[item_elt]
)
@defer.inlineCallbacks
def listInterests(self, client, service=None, node=None, namespace=None):
"""Retrieve list of interests