changeset 615:6f4c31192c7c

plugins XEP-0060, XEP-0277, groupblog: comments implementation (first draft, not finished yet): - PubSub options constants are moved to XEP-0060 - comments url are generated/parsed according to XEP-0277 - microblog data can now have the following keys: - "comments", with the url as given in the <link> tag - "comments_service", with the jid of the PubSub service hosting the comments - "comments_node", with the parsed node - comments nodes use different access_model according to parent microblog item access - publisher is not verified yet, see FIXME warning - so far, comments node are automatically subscribed - some bug fixes
author Goffi <goffi@goffi.org>
date Mon, 20 May 2013 23:21:29 +0200 (2013-05-20)
parents bef0f893482f
children 8782f94e761e
files src/plugins/plugin_misc_groupblog.py src/plugins/plugin_xep_0060.py src/plugins/plugin_xep_0277.py src/tools/xml_tools.py
diffstat 4 files changed, 175 insertions(+), 58 deletions(-) [+]
line wrap: on
line diff
--- a/src/plugins/plugin_misc_groupblog.py	Sun Apr 07 23:27:07 2013 +0200
+++ b/src/plugins/plugin_misc_groupblog.py	Mon May 20 23:21:29 2013 +0200
@@ -25,6 +25,9 @@
 
 from zope.interface import implements
 
+import uuid
+import urllib
+
 try:
     from twisted.words.protocols.xmlstream import XMPPHandler
 except ImportError:
@@ -33,20 +36,18 @@
 NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
 NS_GROUPBLOG = 'http://goffi.org/protocol/groupblog'
 NS_NODE_PREFIX = 'urn:xmpp:groupblog:'
+NS_COMMENT_PREFIX = 'urn:xmpp:comments:'
 #NS_PUBSUB_EXP = 'http://goffi.org/protocol/pubsub' #for non official features
 NS_PUBSUB_EXP = NS_PUBSUB  # XXX: we can't use custom namespace as Wokkel's PubSubService use official NS
 NS_PUBSUB_ITEM_ACCESS = NS_PUBSUB_EXP + "#item-access"
 NS_PUBSUB_CREATOR_JID_CHECK = NS_PUBSUB_EXP + "#creator-jid-check"
 NS_PUBSUB_ITEM_CONFIG = NS_PUBSUB_EXP + "#item-config"
 NS_PUBSUB_AUTO_CREATE = NS_PUBSUB + "#auto-create"
-OPT_ROSTER_GROUPS_ALLOWED = 'pubsub#roster_groups_allowed'
-OPT_ACCESS_MODEL = 'pubsub#access_model'
-OPT_PERSIST_ITEMS = 'pubsub#persist_items'
-OPT_MAX_ITEMS = 'pubsub#max_items'
-OPT_NODE_TYPE = 'pubsub#node_type'
-OPT_SUBSCRIPTION_TYPE = 'pubsub#subscription_type'
-OPT_SUBSCRIPTION_DEPTH = 'pubsub#subscription_depth'
 TYPE_COLLECTION = 'collection'
+ACCESS_TYPE_MAP = { 'PUBLIC': 'open',
+                    'GROUP': 'roster',
+                    'JID': None, #JID is not yet managed
+                  }
 
 PLUGIN_INFO = {
     "name": "Group blogging throught collections",
@@ -83,9 +84,13 @@
         info(_("Group blog plugin initialization"))
         self.host = host
 
-        host.bridge.addMethod("sendGroupBlog", ".plugin", in_sign='sasss', out_sign='',
+        host.bridge.addMethod("sendGroupBlog", ".plugin", in_sign='sassa{ss}s', out_sign='',
                               method=self.sendGroupBlog)
 
+        host.bridge.addMethod("sendGroupBlogComment", ".plugin", in_sign='sss', out_sign='',
+                              method=self.sendGroupBlogComment,
+                              async=True)
+
         host.bridge.addMethod("getLastGroupBlogs", ".plugin",
                               in_sign='sis', out_sign='aa{ss}',
                               method=self.getLastGroupBlogs,
@@ -139,7 +144,7 @@
                     client.item_access_pubsub = entity
             client._item_access_pubsub_pending.callback(None)
 
-        if hasattr(client, "_item_access_pubsub_pending"):
+        if "_item_access_pubsub_pending" in client:
             #XXX: we need to wait for item access pubsub service check
             yield client._item_access_pubsub_pending
             del client._item_access_pubsub_pending
@@ -152,7 +157,9 @@
 
     def pubSubItemsReceivedTrigger(self, event, profile):
         """"Trigger which catch groupblogs events"""
+
         if event.nodeIdentifier.startswith(NS_NODE_PREFIX):
+            # Microblog
             publisher = jid.JID(event.nodeIdentifier[len(NS_NODE_PREFIX):])
             origin_host = publisher.host.split('.')
             event_host = event.sender.host.split('.')
@@ -169,18 +176,32 @@
 
                 self.host.bridge.personalEvent(publisher.full(), "MICROBLOG", microblog_data, profile)
             return False
+        elif event.nodeIdentifier.startswith(NS_COMMENT_PREFIX):
+            # Comment
+            for item in event.items:
+                publisher = "" # FIXME: publisher attribute for item in SàT pubsub is not managed yet, so
+                               #        publisher is not checked and can be easily spoofed. This need to be fixed
+                               #        quickly.
+                microblog_data = self.item2gbdata(item)
+                microblog_data["comments_service"] = event.sender.userhost()
+                microblog_data["comments_node"] = event.nodeIdentifier
+                microblog_data["verified_publisher"] = "true" if publisher else "false"
+
+                self.host.bridge.personalEvent(publisher.full() if publisher else microblog_data["author"], "MICROBLOG_COMMENT", microblog_data, profile)
+            return False
         return True
 
     def _parseAccessData(self, microblog_data, item):
+        P = self.host.plugins["XEP-0060"]
         form_elts = filter(lambda elt: elt.name == "x", item.children)
         for form_elt in form_elts:
             form = data_form.Form.fromElement(form_elt)
 
             if (form.formNamespace == NS_PUBSUB_ITEM_CONFIG):
-                access_model = form.get(OPT_ACCESS_MODEL, 'open')
+                access_model = form.get(P.OPT_ACCESS_MODEL, 'open')
                 if access_model == "roster":
                     try:
-                        microblog_data["groups"] = '\n'.join(form.fields[OPT_ROSTER_GROUPS_ALLOWED].values)
+                        microblog_data["groups"] = '\n'.join(form.fields[P.OPT_ROSTER_GROUPS_ALLOWED].values)
                     except KeyError:
                         warning("No group found for roster access-model")
                         microblog_data["groups"] = ''
@@ -199,24 +220,51 @@
         @return: node's name (string)"""
         return NS_NODE_PREFIX + publisher.userhost()
 
-    def _publishMblog(self, service, client, access_type, access_list, message):
+    def _publishMblog(self, service, client, access_type, access_list, message, options):
         """Actually publish the message on the group blog
         @param service: jid of the item-access pubsub service
         @param client: SatXMPPClient of the published
         @param access_type: one of "PUBLIC", "GROUP", "JID"
         @param access_list: set of entities (empty list for all, groups or jids) allowed to see the item
         @param message: message to publish
+        @param options: dict which option name as key, which can be:
+            - allow_comments: True to accept comments, False else (default: False)
         """
-        mblog_item = self.host.plugins["XEP-0277"].data2entry({'content': message}, client.profile)
+        node_name = self.getNodeName(client.jid)
+        mblog_data = {'content': message}
+        P = self.host.plugins["XEP-0060"]
+        access_model_value = ACCESS_TYPE_MAP[access_type]
+
+        if options.get('allow_comments', 'False').lower() == 'true':
+            comments_node = "%s_%s__%s" % (NS_COMMENT_PREFIX, str(uuid.uuid4()), node_name)
+            mblog_data['comments'] = "xmpp:%(service)s?%(query)s" % {'service': service.userhost(),
+                                                                     'query': urllib.urlencode([('node',comments_node.encode('utf-8'))])}
+            _options = {P.OPT_ACCESS_MODEL: access_model_value,
+                        P.OPT_PERSIST_ITEMS: 1,
+                        P.OPT_MAX_ITEMS: -1,
+                        P.OPT_DELIVER_PAYLOADS: 1,
+                        P.OPT_SEND_ITEM_SUBSCRIBE: 1,
+                        P.OPT_PUBLISH_MODEL: "subscribers", #TODO: should be open if *both* node and item access_model are open (public node and item)
+                       }
+            if access_model_value == 'roster':
+                _options[P.OPT_ROSTER_GROUPS_ALLOWED] = list(access_list)
+
+            # FIXME: check comments node creation success, at the moment this is a potential security risk (if the node
+            #        already exists, the creation will silently fail, but the comments link will stay the same, linking to a
+            #        node owned by somebody else)
+            defer_blog = self.host.plugins["XEP-0060"].createNode(service, comments_node, _options, profile_key=client.profile)
+
+        mblog_item = self.host.plugins["XEP-0277"].data2entry(mblog_data, client.profile)
         form = data_form.Form('submit', formNamespace=NS_PUBSUB_ITEM_CONFIG)
+
         if access_type == "PUBLIC":
             if access_list:
                 raise BadAccessListError("access_list must be empty for PUBLIC access")
-            access = data_form.Field(None, OPT_ACCESS_MODEL, value="open")
+            access = data_form.Field(None, P.OPT_ACCESS_MODEL, value=access_model_value)
             form.addField(access)
         elif access_type == "GROUP":
-            access = data_form.Field(None, OPT_ACCESS_MODEL, value="roster")
-            allowed = data_form.Field(None, OPT_ROSTER_GROUPS_ALLOWED, values=access_list)
+            access = data_form.Field(None, P.OPT_ACCESS_MODEL, value=access_model_value)
+            allowed = data_form.Field(None, P.OPT_ROSTER_GROUPS_ALLOWED, values=access_list)
             form.addField(access)
             form.addField(allowed)
             mblog_item.addChild(form.toElement())
@@ -225,34 +273,36 @@
         else:
             error(_("Unknown access_type"))
             raise BadAccessTypeError
-        defer_blog = self.host.plugins["XEP-0060"].publish(service, self.getNodeName(client.jid), items=[mblog_item], profile_key=client.profile)
+
+        defer_blog = self.host.plugins["XEP-0060"].publish(service, node_name, items=[mblog_item], profile_key=client.profile)
         defer_blog.addErrback(self._mblogPublicationFailed)
 
     def _mblogPublicationFailed(self, failure):
         #TODO
         return failure
 
-    def sendGroupBlog(self, access_type, access_list, message, profile_key='@DEFAULT@'):
+    def sendGroupBlog(self, access_type, access_list, message, options, profile_key='@NONE@'):
         """Publish a microblog with given item access
         @param access_type: one of "PUBLIC", "GROUP", "JID"
         @param access_list: list of authorized entity (empty list for PUBLIC ACCESS,
                             list of groups or list of jids) for this item
         @param message: microblog
+        @param options: dict which option name as key, which can be:
+            - allow_comments: True to accept comments, False else (default: False)
         @profile_key: %(doc_profile)s
         """
-        print "sendGroupBlog"
 
         def initialised(result):
             profile, client = result
             if access_type == "PUBLIC":
                 if access_list:
                     raise Exception("Publishers list must be empty when getting microblogs for all contacts")
-                self._publishMblog(client.item_access_pubsub, client, "PUBLIC", [], message)
+                self._publishMblog(client.item_access_pubsub, client, "PUBLIC", [], message, options)
             elif access_type == "GROUP":
                 _groups = set(access_list).intersection(client.roster.getGroups())  # We only keep group which actually exist
                 if not _groups:
                     raise BadAccessListError("No valid group")
-                self._publishMblog(client.item_access_pubsub, client, "GROUP", _groups, message)
+                self._publishMblog(client.item_access_pubsub, client, "GROUP", _groups, message, options)
             elif access_type == "JID":
                 raise NotImplementedError
             else:
@@ -261,19 +311,56 @@
 
         self.initialise(profile_key).addCallback(initialised)
 
-    def getLastGroupBlogs(self, pub_jid, max_items=10, profile_key='@DEFAULT@'):
+    def sendGroupBlogComment(self, node_url, message, profile_key='@DEFAULT@'):
+        """Publish a comment in the given node
+        @param node url: link to the comments node as specified in XEP-0277 and given in microblog data's comments key
+        @param message: comment
+        @profile_key: %(doc_profile)s
+        """
+        profile = self.host.memory.getProfileName(profile_key)
+        if not profile:
+            error(_("Unknown profile"))
+            raise Exception("Unknown profile")
+
+        service, node = self.host.plugins["XEP-0277"].parseCommentUrl(node_url)
+
+        mblog_data = {'content': message}
+        mblog_item = self.host.plugins["XEP-0277"].data2entry(mblog_data, profile)
+
+        return self.host.plugins["XEP-0060"].publish(service, node, items=[mblog_item], profile_key=profile)
+
+    def _itemsConstruction(self, items, pub_jid, client):
+        """ Transforms items to group blog data and manage comments node
+        @param items: iterable of items
+        @return: list of group blog data """
+        ret = []
+        for item in items:
+            gbdata = self.item2gbdata(item)
+            ret.append(gbdata)
+            # if there is a comments node, we subscribe to it
+            if "comments_node" in gbdata and pub_jid.userhostJID() != client.jid.userhostJID():
+                try:
+                    self.host.plugins["XEP-0060"].subscribe(gbdata["comments_service"], gbdata["comments_node"],
+                                                            profile_key=client.profile)
+                    self.host.plugins["XEP-0060"].getItems(gbdata["comments_service"], gbdata["comments_node"], profile_key=client.profile)
+                except KeyError:
+                    warning("Missing key for comments")
+        return ret
+
+    def getLastGroupBlogs(self, pub_jid_s, max_items=10, profile_key='@DEFAULT@'):
         """Get the last published microblogs
-        @param pub_jid: jid of the publisher
+        @param pub_jid_s: jid of the publisher
         @param max_items: how many microblogs we want to get (see XEP-0060 #6.5.7)
         @param profile_key: profile key
         @return: list of microblog data (dict)
         """
+        pub_jid = jid.JID(pub_jid_s)
 
         def initialised(result):
             profile, client = result
-            d = self.host.plugins["XEP-0060"].getItems(client.item_access_pubsub, self.getNodeName(jid.JID(pub_jid)),
+            d = self.host.plugins["XEP-0060"].getItems(client.item_access_pubsub, self.getNodeName(pub_jid),
                                                        max_items=max_items, profile_key=profile_key)
-            d.addCallback(lambda items: map(self.item2gbdata, items))
+            d.addCallback(self._itemsConstruction, pub_jid, client)
             d.addErrback(lambda ignore: {})  # TODO: more complete error management (log !)
             return d
 
@@ -317,10 +404,12 @@
 
             mblogs = []
 
-            for _jid in jids:
-                d = self.host.plugins["XEP-0060"].getItems(client.item_access_pubsub, self.getNodeName(jid.JID(_jid)),
+            for jid_s in jids:
+                _jid = jid.JID(jid_s)
+                d = self.host.plugins["XEP-0060"].getItems(client.item_access_pubsub, self.getNodeName(_jid),
                                                            max_items=max_items, profile_key=profile_key)
-                d.addCallback(lambda items, source_jid: (source_jid, map(self.item2gbdata, items)), _jid)
+                d.addCallback(lambda items, source_jid: (source_jid, self._itemsConstruction(items, _jid, client)), jid_s)
+
                 mblogs.append(d)
             dlist = defer.DeferredList(mblogs)
             dlist.addCallback(sendResult)
@@ -335,7 +424,7 @@
         return self.initialise(profile_key).addCallback(initialised)
         #TODO: we need to use the server corresponding the the host of the jid
 
-    def subscribeGroupBlog(self, pub_jid, profile_key='@DEFAULT'):
+    def subscribeGroupBlog(self, pub_jid, profile_key='@DEFAULT@'):
         def initialised(result):
             profile, client = result
             d = self.host.plugins["XEP-0060"].subscribe(client.item_access_pubsub, self.getNodeName(jid.JID(pub_jid)),
--- a/src/plugins/plugin_xep_0060.py	Sun Apr 07 23:27:07 2013 +0200
+++ b/src/plugins/plugin_xep_0060.py	Mon May 20 23:21:29 2013 +0200
@@ -18,12 +18,8 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from logging import debug, info, error
-from twisted.internet import protocol
-from twisted.words.protocols.jabber import client, jid
-from twisted.words.protocols.jabber import error as jab_error
-import twisted.internet.error
 
-from wokkel import disco, iwokkel, pubsub
+from wokkel import disco, pubsub
 
 from zope.interface import implements
 
@@ -40,6 +36,16 @@
 
 
 class XEP_0060(object):
+    OPT_ACCESS_MODEL = 'pubsub#access_model'
+    OPT_PERSIST_ITEMS = 'pubsub#persist_items'
+    OPT_MAX_ITEMS = 'pubsub#max_items'
+    OPT_DELIVER_PAYLOADS = 'pubsub#deliver_payloads'
+    OPT_SEND_ITEM_SUBSCRIBE = 'pubsub#send_item_subscribe'
+    OPT_NODE_TYPE = 'pubsub#node_type'
+    OPT_SUBSCRIPTION_TYPE = 'pubsub#subscription_type'
+    OPT_SUBSCRIPTION_DEPTH = 'pubsub#subscription_depth'
+    OPT_ROSTER_GROUPS_ALLOWED = 'pubsub#roster_groups_allowed'
+    OPT_PUBLISH_MODEL = 'pubsub#publish_model'
 
     def __init__(self, host):
         info(_("PubSub plugin initialization"))
@@ -140,9 +146,9 @@
         #TODO: manage delete event
         debug(_("Publish node deleted"))
 
-    def purgeReceived(self, event):
-        import pdb
-        pdb.set_trace()
+    # def purgeReceived(self, event):
+
+
 
     def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
         _disco_info = []
--- a/src/plugins/plugin_xep_0277.py	Sun Apr 07 23:27:07 2013 +0200
+++ b/src/plugins/plugin_xep_0277.py	Mon May 20 23:21:29 2013 +0200
@@ -17,25 +17,18 @@
 # 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 logging import debug, info, error
-from twisted.internet import protocol
-from twisted.words.protocols.jabber import client, jid
-from twisted.words.protocols.jabber import error as jab_error
-import twisted.internet.error
-from twisted.words.xish import domish
+from logging import debug, info, warning, error
+from twisted.words.protocols.jabber import jid
+from sat.core import exceptions
 from sat.tools.xml_tools import ElementParser
 
-from wokkel import disco, pubsub
-from feed.atom import Entry, Author
+from wokkel import pubsub
+from feed import atom
 import uuid
 from time import time
+import urlparse
 
 NS_MICROBLOG = 'urn:xmpp:microblog:0'
-OPT_ACCESS_MODEL = 'pubsub#access_model'
-OPT_PERSIST_ITEMS = 'pubsub#persist_items'
-OPT_MAX_ITEMS = 'pubsub#max_items'
-OPT_DELIVER_PAYLOADS = 'pubsub#deliver_payloads'
-OPT_SEND_ITEM_SUBSCRIBE = 'pubsub#send_item_subscribe'
 
 PLUGIN_INFO = {
     "name": "Microblogging over XMPP Plugin",
@@ -73,6 +66,20 @@
                               async=True,
                               doc={})
 
+    def parseCommentUrl(self, node_url):
+        parsed_url = urlparse.urlparse(node_url, 'xmpp')
+        service = jid.JID(parsed_url.path)
+        queries = parsed_url.query.split(';')
+        parsed_queries = dict()
+        for query in queries:
+            parsed_queries.update(urlparse.parse_qs(query))
+        node = parsed_queries.get('node',[''])[0]
+
+        if not node:
+            raise exceptions.DataError('Invalid comments link')
+
+        return (service, node)
+
     def item2mbdata(self, item):
         """Convert an XML Item to microblog data used in bridge API
         @param item: domish.Element of microblog item
@@ -82,7 +89,7 @@
         except KeyError:
             warning(_('No entry element in microblog item'))
             return
-        _entry = Entry().import_xml(entry_elt.toXml().encode('utf-8'))
+        _entry = atom.Entry().import_xml(entry_elt.toXml().encode('utf-8'))
         microblog_data = {}
         try:
             microblog_data['content'] = _entry.title.text
@@ -90,6 +97,17 @@
                 microblog_data['author'] = _entry.authors[0].name.text
             microblog_data['timestamp'] = str(int(_entry.updated.tf))
             microblog_data['id'] = item['id']
+            for link in _entry.links:
+                try:
+                    if link.attrs["title"] == "comments":
+                        microblog_data['comments'] = link.attrs["href"]
+                        service, node = self.parseCommentUrl(microblog_data["comments"])
+                        microblog_data['comments_service'] = service.full()
+                        microblog_data['comments_node'] = node
+                        break
+                except (KeyError, exceptions.DataError):
+                    continue
+
         except (AttributeError, KeyError):
             error(_('Error while parsing atom entry for microblogging event'))
             return {}
@@ -117,13 +135,19 @@
         @return: domish.Element"""
         _uuid = unicode(uuid.uuid1())
         content = data['content']
-        _entry = Entry()
+        _entry = atom.Entry()
         #FIXME: need to escape html
         _entry.title = unicode(content).encode('utf-8')
-        _entry.author = Author()
+        _entry.author = atom.Author()
         _entry.author.name = data.get('author', self.host.getJidNStream(profile)[0].userhost()).encode('utf-8')
         _entry.updated = float(data.get('timestamp', time()))
         _entry.id = str(_uuid)
+        if 'comments' in data:
+            link = atom.Link()
+            link.attrs['href'] = data['comments']
+            link.attrs['rel'] = 'replies'
+            link.attrs['title'] = 'comments'
+            _entry.links.append(link)
         _entry_elt = ElementParser()(str(_entry).decode('utf-8'))
         item = pubsub.Item(payload=_entry_elt)
         item['id'] = _uuid
@@ -149,10 +173,7 @@
         @param pub_jid: jid of the publisher
         @param max_items: how many microblogs we want to get
         @param profile_key: profile key
-        @param callback: used for the async answer
-        @param errback: used for the async answer
         """
-        assert(callback)
         d = self.host.plugins["XEP-0060"].getItems(jid.JID(pub_jid), NS_MICROBLOG, max_items=max_items, profile_key=profile_key)
         d.addCallback(lambda items: map(self.item2mbdata, items))
 
@@ -166,7 +187,8 @@
         if not _jid:
             error(_("Can't find profile's jid"))
             return
-        _options = {OPT_ACCESS_MODEL: access, OPT_PERSIST_ITEMS: 1, OPT_MAX_ITEMS: -1, OPT_DELIVER_PAYLOADS: 1, OPT_SEND_ITEM_SUBSCRIBE: 1}
+        C = self.host.plugins["XEP-0060"]
+        _options = {C.OPT_ACCESS_MODEL: access, C.OPT_PERSIST_ITEMS: 1, C.OPT_MAX_ITEMS: -1, C.OPT_DELIVER_PAYLOADS: 1, C.OPT_SEND_ITEM_SUBSCRIBE: 1}
 
         def cb(result):
             #Node is created with right permission
--- a/src/tools/xml_tools.py	Sun Apr 07 23:27:07 2013 +0200
+++ b/src/tools/xml_tools.py	Mon May 20 23:21:29 2013 +0200
@@ -320,6 +320,6 @@
         parser.ElementEvent = onElement
         parser.DocumentEndEvent = onEnd
         tmp = domish.Element((None, "s"))
-        tmp.addRawXml(string.replace('\n', '').replace('\t', ''))
+        tmp.addRawXml(string.replace('\n', ' ').replace('\t', ' '))
         parser.parse(tmp.toXml().encode('utf-8'))
         return self.result.firstChildElement()