--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sat/plugins/plugin_exp_file_sharing_invitation.py	Sun Apr 14 08:21:51 2019 +0200
@@ -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 []

--- a/sat/plugins/plugin_exp_invitation.py	Sun Apr 14 08:21:51 2019 +0200
+++ b/sat/plugins/plugin_exp_invitation.py	Sun Apr 14 08:21:51 2019 +0200
@@ -35,7 +35,7 @@
     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 @@
                 - 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 @@
                 .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 @@
         }
         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 @@
         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 @@
                 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()))

--- a/sat/plugins/plugin_exp_list_of_interest.py	Sun Apr 14 08:21:51 2019 +0200
+++ b/sat/plugins/plugin_exp_list_of_interest.py	Sun Apr 14 08:21:51 2019 +0200
@@ -35,7 +35,7 @@
     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 @@
         @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
@@ -108,6 +108,35 @@
         )
 
     @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