changeset 1672:dbd7c79aab2b

plugin group blog: big cleaning
author Goffi <goffi@goffi.org>
date Wed, 25 Nov 2015 11:12:51 +0100 (2015-11-25)
parents 1895846fc9cb
children 95522b37bf5a
files src/plugins/plugin_exp_pipe.py src/plugins/plugin_misc_groupblog.py
diffstat 2 files changed, 4 insertions(+), 847 deletions(-) [+]
line wrap: on
line diff
--- a/src/plugins/plugin_exp_pipe.py	Wed Nov 25 10:45:22 2015 +0100
+++ b/src/plugins/plugin_exp_pipe.py	Wed Nov 25 11:12:51 2015 +0100
@@ -26,7 +26,7 @@
 from twisted.words.protocols.jabber import jid
 from twisted.internet import defer
 
-NS_PIPE = 'org.salut-a-toi/pipe'
+NS_PIPE = 'http://salut-a-toi.org/protocol/pipe'
 SECURITY_LIMIT=30
 
 PLUGIN_INFO = {
--- a/src/plugins/plugin_misc_groupblog.py	Wed Nov 25 10:45:22 2015 +0100
+++ b/src/plugins/plugin_misc_groupblog.py	Wed Nov 25 11:12:51 2015 +0100
@@ -22,14 +22,10 @@
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from twisted.internet import defer
-from twisted.words.protocols.jabber import jid
-from twisted.words.xish.domish import generateElementsNamed
 from sat.core import exceptions
 from wokkel import disco, data_form, iwokkel
-from wokkel import rsm
 from zope.interface import implements
 from sat.tools import common
-# import uuid
 
 try:
     from twisted.words.protocols.xmlstream import XMPPHandler
@@ -37,26 +33,15 @@
     from wokkel.subprotocols import XMPPHandler
 
 NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
-NS_GROUPBLOG = 'http://goffi.org/protocol/groupblog'
-NS_NODE_PREFIX = 'urn:xmpp:groupblog:'
+NS_GROUPBLOG = 'http://salut-a-toi.org/protocol/groupblog'
 #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_GROUPBLOG = NS_PUBSUB_EXP + "#groupblog"
-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"
-ACCESS_TYPE_MAP = { 'PUBLIC': 'open',
-                    'GROUP': 'roster',
-                    'JID': None, #JID is not yet managed
-                 }
 
-MAX_ITEMS = 5
-MAX_COMMENTS = 5
-DO_NOT_COUNT_COMMENTS = -1  # must be lower than 0
 
 PLUGIN_INFO = {
-    "name": "Group blogging throught collections",
+    "name": "Group blogging through collections",
     "import_name": "GROUPBLOG",
     "type": "MISC",
     "protocols": [],
@@ -67,21 +52,6 @@
 }
 
 
-class NoCompatiblePubSubServerFound(Exception):
-    pass
-
-
-class BadAccessTypeError(Exception):
-    pass
-
-
-class BadAccessListError(Exception):
-    pass
-
-
-class UnknownType(Exception):
-    pass
-
 class GroupBlog(object):
     """This class use a SàT PubSub Service to manage access on microblog"""
 
@@ -89,48 +59,6 @@
         log.info(_("Group blog plugin initialization"))
         self.host = host
         self._p = self.host.plugins["XEP-0060"]
-
-        # host.bridge.addMethod("sendGroupBlog", ".plugin", in_sign='sassa{ss}s', out_sign='',
-        #                       method=self.sendGroupBlog,
-        #                       async=True)
-
-        # host.bridge.addMethod("deleteGroupBlog", ".plugin", in_sign='(sss)ss', out_sign='',
-        #                       method=self.deleteGroupBlog,
-        #                       async=True)
-
-        # host.bridge.addMethod("updateGroupBlog", ".plugin", in_sign='(sss)ssa{ss}s', out_sign='',
-        #                       method=self.updateGroupBlog,
-        #                       async=True)
-
-        # host.bridge.addMethod("sendGroupBlogComment", ".plugin", in_sign='ssa{ss}s', out_sign='',
-        #                       method=self.sendGroupBlogComment,
-        #                       async=True)
-
-        # host.bridge.addMethod("getGroupBlogs", ".plugin",
-        #                       in_sign='sasa{ss}bs', out_sign='(aa{ss}a{ss})',
-        #                       method=self.getGroupBlogs,
-        #                       async=True)
-
-        # host.bridge.addMethod("getGroupBlogsWithComments", ".plugin",
-        #                       in_sign='sasa{ss}is', out_sign='(a(a{ss}(aa{ss}a{ss}))a{ss})',
-        #                       method=self.getGroupBlogsWithComments,
-        #                       async=True)
-
-        # host.bridge.addMethod("getMassiveGroupBlogs", ".plugin",
-        #                       in_sign='sasa{ss}s', out_sign='a{s(aa{ss}a{ss})}',
-        #                       method=self._getMassiveGroupBlogs,
-        #                       async=True)
-
-        # host.bridge.addMethod("getGroupBlogComments", ".plugin",
-        #                       in_sign='ssa{ss}s', out_sign='(aa{ss}a{ss})',
-        #                       method=self.getGroupBlogComments,
-        #                       async=True)
-
-        # host.bridge.addMethod("subscribeGroupBlog", ".plugin", in_sign='ss', out_sign='',
-        #                       method=self.subscribeGroupBlog,
-        #                       async=True)
-
-        # host.trigger.add("PubSubItemsReceived", self.pubSubItemsReceivedTrigger)
         host.trigger.add("XEP-0277_item2data", self._item2dataTrigger)
         host.trigger.add("XEP-0277_data2entry", self._data2entryTrigger)
         host.trigger.add("XEP-0277_comments", self._commentsTrigger)
@@ -172,6 +100,7 @@
         if config_form is None:
             return
         access_model = config_form.get(self._p.OPT_ACCESS_MODEL, self._p.ACCESS_OPEN)
+        # FIXME: ACCESS_ROSTER need to be changed to a new ACCESS_PUBLISHER_ROSTER when available
         if access_model == self._p.ACCESS_ROSTER:
             common.iter2dict('group', config_form.fields[self._p.OPT_ROSTER_GROUPS_ALLOWED].values, microblog_data)
 
@@ -205,778 +134,6 @@
             options[self._p.OPT_ACCESS_MODEL] = self._p.ACCESS_ROSTER
             options[self._p.OPT_ROSTER_GROUPS_ALLOWED] = list(common.dict2iter('group', mb_data))
 
-    @defer.inlineCallbacks
-    def _initialise(self, profile_key):
-        """Check that the data for this profile are initialised, and do it else
-        @param profile_key: %(doc_profile)s"""
-        profile = self.host.memory.getProfileName(profile_key)
-        if not profile:
-            raise exceptions.ProfileUnknownError
-
-        client = self.host.getClient(profile)
-
-        #we first check that we have a item-access pubsub server
-        if not hasattr(client, "item_access_pubsub"):
-            log.debug(_('Looking for item-access powered pubsub server'))
-            #we don't have any pubsub server featuring item access yet
-            item_access_pubsubs = yield self.host.findFeaturesSet((NS_PUBSUB_AUTO_CREATE, NS_PUBSUB_CREATOR_JID_CHECK), "pubsub", "service", profile=profile)
-            # item_access_pubsubs = yield self.host.findFeaturesSet((NS_PUBSUB_ITEM_ACCESS, NS_PUBSUB_AUTO_CREATE, NS_PUBSUB_CREATOR_JID_CHECK), "pubsub", "service", profile_key=profile)
-            try:
-                client.item_access_pubsub = item_access_pubsubs.pop()
-                log.info(_(u"item-access powered pubsub service found: [%s]") % client.item_access_pubsub.full())
-            except KeyError:
-                client.item_access_pubsub = None
-
-        if not client.item_access_pubsub:
-            log.error(_(u"No item-access powered pubsub server found, can't use group blog"))
-            raise NoCompatiblePubSubServerFound
-
-        defer.returnValue((profile, client))
-
-    # 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('.')
-    #         #FIXME: basic origin check, must be improved
-    #         #TODO: automatic security test
-    #         if (not (origin_host)
-    #                 or len(event_host) < len(origin_host)
-    #                 or event_host[-len(origin_host):] != origin_host):
-    #             log.warning(u"Host incoherence between %s and %s (hack attempt ?)" % (unicode(event.sender),
-    #                                                                              unicode(publisher)))
-    #             return False
-
-    #         client = self.host.getClient(profile)
-
-    #         def gbdataManagementMicroblog(gbdata):
-    #             for gbdatum in gbdata:
-    #                 self.host.bridge.personalEvent(publisher.full(), "MICROBLOG", gbdatum, profile)
-
-    #         d = self._itemsConstruction(event.items, publisher, client)
-    #         d.addCallback(gbdataManagementMicroblog)
-    #         return False
-
-    #     elif event.nodeIdentifier.startswith(NS_COMMENT_PREFIX):
-    #         # Comment
-    #         def gbdataManagementComments(gbdata):
-    #             for gbdatum in gbdata:
-    #                 publisher = None # FIXME: see below (_handleCommentsItems)
-    #                 self.host.bridge.personalEvent(publisher.full() if publisher else gbdatum["author"], "MICROBLOG", gbdatum, profile)
-    #         d = self._handleCommentsItems(event.items, event.sender, event.nodeIdentifier)
-    #         d.addCallback(gbdataManagementComments)
-    #         return False
-    #     return True
-
-    ## internal helping methodes ##
-
-    def _handleCommentsItems(self, items, service, node_identifier):
-        """ Convert comments items to groupblog data, and send them as signals
-
-        @param items: comments items
-        @param service: jid of the PubSub service used
-        @param node_identifier: comments node
-        @return: deferred list of group blog data
-        """
-        d_list = []
-
-        def cb(microblog_data):
-            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["service"] = service.userhost()
-            microblog_data["node"] = node_identifier
-            microblog_data["verified_publisher"] = "true" if publisher else "false"
-            return microblog_data
-
-        for item in items:
-            d_list.append(self.item2gbdata(item, "comment").addCallback(cb))
-        return defer.DeferredList(d_list, consumeErrors=True).addCallback(lambda result: [value for (success, value) in result if success])
-
-    def _parseAccessData(self, microblog_data, item):
-        P = self.host.plugins["XEP-0060"]
-        form_elts = [child for child in item.elements() if child.name == "x"]
-        for form_elt in form_elts:
-            form = data_form.Form.fromElement(form_elt)
-
-            if (form.formNamespace == NS_PUBSUB_ITEM_CONFIG):
-                access_model = form.get(P.OPT_ACCESS_MODEL, 'open')
-                if access_model == "roster":
-                    try:
-                        # FIXME: groups are xs:string, so they can contain "\n" ! This code is bugged
-                        microblog_data["groups"] = '\n'.join(form.fields[P.OPT_ROSTER_GROUPS_ALLOWED].values)
-                    except KeyError:
-                        log.warning("No group found for roster access-model")
-                        microblog_data["groups"] = ''
-
-                break
-
-    @defer.inlineCallbacks
-    def item2gbdata(self, item, _type="main_item"):
-        """ Convert item to microblog data dictionary + add access data """
-        microblog_data = yield self.host.plugins["XEP-0277"].item2mbdata(item)
-        microblog_data["type"] = _type
-        self._parseAccessData(microblog_data, item)
-        defer.returnValue(microblog_data)
-
-    def getNodeName(self, publisher):
-        """Retrieve the name of publisher's node
-
-        @param publisher: publisher's jid
-        @return: node's name (string)
-        """
-        return NS_NODE_PREFIX + publisher.userhost()
-
-    ## publish ##
-
-    def _publishMblog(self, service, client, access_type, access_list, message, extra):
-        """Actually publish the message on the group blog
-
-        @param service: jid of the item-access pubsub service
-        @param client: SatXMPPClient of the publisher
-        @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 extra: dict which option name as key, which can be:
-            - allow_comments: True to accept comments, False else (default: False)
-            - rich: if present, contain rich text in currently selected syntax
-        """
-        node_name = self.getNodeName(client.jid)
-        mblog_data = {'content': message}
-
-        for attr in ['content_rich', 'title', 'title_rich']:
-            if attr in extra and extra[attr]:
-                mblog_data[attr] = extra[attr]
-        P = self.host.plugins["XEP-0060"]
-        access_model_value = ACCESS_TYPE_MAP[access_type]
-
-        if extra.get('allow_comments', 'False').lower() == 'true':
-            # XXX: use the item identifier? http://bugs.goffi.org/show_bug.cgi?id=63
-            comments_node = self._fillCommentsElement(mblog_data, None, node_name, service)
-            _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)
-            self.host.plugins["XEP-0060"].createNode(service, comments_node, _options, profile_key=client.profile)
-
-        def itemCreated(mblog_item):
-            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, P.OPT_ACCESS_MODEL, value=access_model_value)
-                form.addField(access)
-            elif access_type == "GROUP":
-                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())
-            elif access_type == "JID":
-                raise NotImplementedError
-            else:
-                log.error(_("Unknown access_type"))
-                raise BadAccessTypeError
-
-            defer_blog = self.host.plugins["XEP-0060"].publish(service, node_name, items=[mblog_item], profile_key=client.profile)
-            defer_blog.addErrback(self._mblogPublicationFailed)
-            return defer_blog
-
-        entry_d = self.host.plugins["XEP-0277"].data2entry(mblog_data, client.profile)
-        entry_d.addCallback(itemCreated)
-        return entry_d
-
-    # def _fillCommentsElement(self, mblog_data, entry_id, node_name, service_jid):
-    #     """
-    #     @param mblog_data: dict containing the microblog data
-    #     @param entry_id: unique identifier of the entry
-    #     @param node_name: the pubsub node name
-    #     @param service_jid: the JID of the pubsub service
-    #     @return: the comments node string
-    #     """
-    #     if entry_id is None:
-    #         entry_id = unicode(uuid.uuid4())
-    #     comments_node = "%s_%s__%s" % (NS_COMMENT_PREFIX, entry_id, node_name)
-    #     mblog_data['comments'] = "xmpp:%(service)s?%(query)s" % {'service': service_jid.userhost(),
-    #                                                              'query': urllib.urlencode([('node', comments_node.encode('utf-8'))])}
-    #     return comments_node
-
-    def _mblogPublicationFailed(self, failure):
-        #TODO
-        return failure
-
-    def sendGroupBlog(self, access_type, access_list, message, extra, profile_key=C.PROF_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 extra: dict which option name as key, which can be:
-            - allow_comments: True to accept comments, False else (default: False)
-            - rich: if present, contain rich text in currently selected syntax
-        @profile_key: %(doc_profile_key)s
-        """
-
-        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")
-                return self._publishMblog(client.item_access_pubsub, client, "PUBLIC", [], message, extra)
-            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")
-                return self._publishMblog(client.item_access_pubsub, client, "GROUP", _groups, message, extra)
-            elif access_type == "JID":
-                raise NotImplementedError
-            else:
-                log.error(_("Unknown access type"))
-                raise BadAccessTypeError
-
-        return self._initialise(profile_key).addCallback(initialised)
-
-    def sendGroupBlogComment(self, node_url, message, extra, profile_key=C.PROF_KEY_NONE):
-        """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
-        @param extra: dict which option name as key, which can be:
-            - allow_comments: True to accept an other level of comments, False else (default: False)
-            - rich: if present, contain rich text in currently selected syntax
-        @profile_key: %(doc_profile)s
-        """
-        def initialised(result):
-            profile, client = result
-            service, node = self.host.plugins["XEP-0277"].parseCommentUrl(node_url)
-            mblog_data = {'content': message}
-            for attr in ['content_rich', 'title', 'title_rich']:
-                if attr in extra and extra[attr]:
-                    mblog_data[attr] = extra[attr]
-            if 'allow_comments' in extra:
-                raise NotImplementedError # TODO
-            entry_d = self.host.plugins["XEP-0277"].data2entry(mblog_data, profile)
-            entry_d.addCallback(lambda mblog_item: self.host.plugins["XEP-0060"].publish(service, node, items=[mblog_item], profile_key=profile))
-            return entry_d
-
-        return self._initialise(profile_key).addCallback(initialised)
-
-    def _itemsConstruction(self, items, pub_jid, client):
-        """ Transforms items to group blog data and manage comments node
-
-        @param items: iterable of items
-        @param pub_jid: jid of the publisher or None to use items data
-        @param client: SatXMPPClient instance
-        @return: deferred which fire list of group blog data """
-        # TODO: use items data when pub_jid is None
-        d_list = []
-
-        @defer.inlineCallbacks
-        def cb(gbdata):
-            try:
-                gbdata['service'] = client.item_access_pubsub.full()
-            except AttributeError:
-                log.warning(_(u"Pubsub service is unknown for blog entry %s") % gbdata['id'])
-            # every comments node must be subscribed, except if we are the publisher (we are already subscribed in this case)
-            if "comments_node" in gbdata and pub_jid.userhostJID() != client.jid.userhostJID():
-                try:
-                    service = jid.JID(gbdata["comments_service"])
-                    node = gbdata["comments_node"]
-                except KeyError:
-                    log.error(_(u"Missing key for blog comment %s") % gbdata['id'])
-                    defer.returnValue(gbdata)
-                # TODO: see if it is really needed to check for not subscribing twice to the node
-                # It previously worked without this check, but the pubsub service logs were polluted
-                # or, if in debug mode, it made sat-pubsub very difficult to debug.
-                subscribed_nodes = yield self.host.plugins['XEP-0060'].listSubscribedNodes(service, profile=client.profile)
-                if node not in subscribed_nodes:  # avoid sat-pubsub "SubscriptionExists" error
-                    self.host.plugins["XEP-0060"].subscribe(service, node, profile_key=client.profile)
-            defer.returnValue(gbdata)
-
-        for item in items:
-            d_list.append(self.item2gbdata(item).addCallback(cb))
-        return defer.DeferredList(d_list, consumeErrors=True).addCallback(lambda result: [value for (success, value) in result if success])
-
-    ## modify ##
-
-    def updateGroupBlog(self, pub_data, comments, message, extra, profile_key=C.PROF_KEY_NONE):
-        """Modify a microblog node
-
-        @param pub_data: a tuple (service, node identifier, item identifier)
-        @param comments: comments node identifier (for main item) or empty string
-        @param message: new message
-        @param extra: dict which option name as key, which can be:
-            - allow_comments: True to accept an other level of comments, False else (default: False)
-            - rich: if present, contain rich text in currently selected syntax
-        @param profile_key: %(doc_profile)
-        """
-
-        def initialised(result):
-            profile, client = result
-            mblog_data = {'content': message}
-            for attr in ['content_rich', 'title', 'title_rich']:
-                if attr in extra and extra[attr]:
-                    mblog_data[attr] = extra[attr]
-            service, node, item_id = pub_data
-            service_jid = jid.JID(service) if service else client.item_access_pubsub
-            if comments or not node:  # main item
-                node = self.getNodeName(client.jid)
-            mblog_data['id'] = unicode(item_id)
-            if 'published' in extra:
-                mblog_data['published'] = extra['published']
-            if extra.get('allow_comments', 'False').lower() == 'true':
-                comments_service, comments_node = self.host.plugins["XEP-0277"].parseCommentUrl(comments)
-                # we could use comments_node directly but it's safer to rebuild it
-                # XXX: use the item identifier? http://bugs.goffi.org/show_bug.cgi?id=63
-                entry_id = comments_node.split('_')[1].split('__')[0]
-                self._fillCommentsElement(mblog_data, entry_id, node, service_jid)
-            entry_d = self.host.plugins["XEP-0277"].data2entry(mblog_data, profile)
-            entry_d.addCallback(lambda mblog_item: self.host.plugins["XEP-0060"].publish(service_jid, node, items=[mblog_item], profile_key=profile))
-            entry_d.addErrback(lambda failure: log.error(u"Modification of %s failed: %s" % (pub_data, failure.getErrorMessage())))
-            return entry_d
-
-        return self._initialise(profile_key).addCallback(initialised)
-
-    ## get ##
-
-    def _getOrCountComments(self, items, max_=0, profile_key=C.PROF_KEY_NONE):
-        """Get and/or count the comments of the given items.
-
-        @param items (list): items to consider.
-        @param max_ (int): maximum number of comments to get, if 0 only count
-            them. The count is set to the item data of key "comments_count".
-        @param profile_key (str): %(doc_profile_key)s
-        @return: a deferred list of:
-            - if max_ == 0: microblog data
-            - else: couple (dict, (list[dict], dict)) containing:
-                - microblog data (main item)
-                - couple (comments data, RSM response data for the comments)
-        """
-        def comments_cb(comments_data, entry):
-            try:
-                entry['comments_count'] = comments_data[1]['count']
-            except KeyError:  # target pubsub server probably doesn't handle RSM
-                pass
-            return (entry, comments_data) if max_ > 0 else entry
-
-        assert max_ >= 0
-        d_list = []
-        for entry in items:
-            if entry.get('comments', False):
-                comments_rsm = {'max_': max_}
-                d = self.getGroupBlogComments(entry['comments_service'], entry['comments_node'], rsm_data=comments_rsm, profile_key=profile_key)
-                d.addCallback(comments_cb, entry)
-                d_list.append(d)
-            else:
-                if max_ > 0:
-                    d_list.append(defer.succeed((entry, ([], {}))))
-                else:
-                    d_list.append(defer.succeed(entry))
-        deferred_list = defer.DeferredList(d_list)
-        deferred_list.addCallback(lambda result: [value for (success, value) in result if success])
-        return deferred_list
-
-    def _getGroupBlogs(self, pub_jid_s, item_ids=None, rsm_data=None, max_comments=0, profile_key=C.PROF_KEY_NONE):
-        """Retrieve previously published items from a publish subscribe node.
-
-        @param pub_jid_s: jid of the publisher
-        @param item_ids: list of microblogs items IDs
-        @param rsm_data (dict): RSM request data
-        @param max_comments (int): maximum number of comments to retrieve
-        @param profile_key (str): %(doc_profile_key)s
-        @return: a deferred couple (list, dict) containing:
-            - list of:
-                - if max_comments == 0: microblog data
-                - else: couple (dict, (list[dict], dict)) containing:
-                    - microblog data (main item)
-                    - couple (comments data, RSM response data for the comments)
-            - RSM response data
-        """
-        pub_jid = jid.JID(pub_jid_s)
-
-        def cb(items, client):
-            d = self._itemsConstruction(items, pub_jid, client)
-            if max_comments == DO_NOT_COUNT_COMMENTS:
-                return d
-            return d.addCallback(self._getOrCountComments, max_comments, profile_key)
-
-        return DeferredItems(self, cb, None, profile_key).get(self.getNodeName(pub_jid), item_ids, rsm_data=rsm_data)
-
-    # def getGroupBlogs(self, pub_jid_s, item_ids=None, rsm_data=None, count_comments=True, profile_key=C.PROF_KEY_NONE):
-    #     """Get the published microblogs of the specified IDs. If item_ids is
-    #     None, the result would be the same than calling getGroupBlogs
-    #     with the default value for the attribute max_items.
-
-    #     @param pub_jid_s: jid of the publisher
-    #     @param item_ids: list of microblogs items IDs
-    #     @param rsm_data (dict): RSM request data
-    #     @param count_comments (bool): also count the comments if True
-    #     @param profile_key (str): %(doc_profile_key)s
-    #     @return: a deferred couple (list, dict) containing:
-    #         - list of microblog data
-    #         - RSM response data
-    #     """
-    #     max_comments = 0 if count_comments else DO_NOT_COUNT_COMMENTS
-    #     return self._getGroupBlogs(pub_jid_s, item_ids=item_ids, rsm_data=rsm_data, max_comments=max_comments, profile_key=profile_key)
-
-    def getGroupBlogsWithComments(self, pub_jid_s, item_ids=None, rsm_data=None, max_comments=None, profile_key=C.PROF_KEY_NONE):
-        """Get the published microblogs of the specified IDs and their comments. If
-        item_ids is None, returns the last published microblogs and their comments.
-
-        @param pub_jid_s: jid of the publisher
-        @param item_ids: list of microblogs items IDs
-        @param rsm (dict): RSM request data
-        @param max_comments (int): maximum number of comments to retrieve
-        @param profile_key (str): %(doc_profile_key)s
-        @return: a deferred couple (list, dict) containing:
-            - list of couple (dict, (list[dict], dict)) containing:
-                - microblog data (main item)
-                - couple (comments data, RSM response data for the comments)
-            - RSM response data
-        """
-        if max_comments is None:
-            max_comments = MAX_COMMENTS
-        assert max_comments > 0  # otherwise the return signature is not the same
-        return self._getGroupBlogs(pub_jid_s, item_ids=item_ids, rsm_data=rsm_data, max_comments=max_comments, profile_key=profile_key)
-
-    # def _getMassiveGroupBlogs(self, publishers_type, publishers, rsm_data=None, profile_key=C.PROF_KEY_NONE):
-    #     if publishers_type == 'JID':
-    #         publishers_jids = [jid.JID(publisher) for publisher in publishers]
-    #     else:
-    #         publishers_jids = publishers
-    #     return self.getMassiveGroupBlogs(publishers_type, publishers_jids, rsm_data, profile_key)
-
-    # def _getPublishersJIDs(self, publishers_type, publishers, client):
-    #     #TODO: custom exception
-    #     if publishers_type not in ["GROUP", "JID", "ALL"]:
-    #         raise Exception("Bad call, unknown publishers_type")
-    #     if publishers_type == "ALL" and publishers:
-    #         raise Exception("Publishers list must be empty when getting microblogs for all contacts")
-
-    #     if publishers_type == "ALL":
-    #         contacts = client.roster.getItems()
-    #         jids = [contact.jid.userhostJID() for contact in contacts]
-    #     elif publishers_type == "GROUP":
-    #         jids = []
-    #         for _group in publishers:
-    #             jids.extend(client.roster.getJidsFromGroup(_group))
-    #     elif publishers_type == 'JID':
-    #         jids = publishers
-    #     else:
-    #         raise UnknownType
-    #     return jids
-
-    # def getMassiveGroupBlogs(self, publishers_type, publishers, rsm_data=None, profile_key=C.PROF_KEY_NONE):
-    #     """Get the last published microblogs for a list of groups or jids
-    #     @param publishers_type (str): type of the list of publishers (one of "GROUP" or "JID" or "ALL")
-    #     @param publishers (list): list of publishers, according to publishers_type (list of groups or list of jids)
-    #     @param rsm_data (dict): RSM request data, common to all publishers
-    #     @param profile_key: profile key
-    #     @return: a deferred dict with:
-    #         - key: publisher (unicode)
-    #         - value: couple (list[dict], dict) with:
-    #             - the microblogs data
-    #             - RSM response data
-    #     """
-    #     def cb(items, publisher, client):
-    #         d = self._itemsConstruction(items, publisher, client)
-    #         return d.addCallback(self._getOrCountComments, False, profile_key)
-
-    #     #TODO: we need to use the server corresponding to the host of the jid
-    #     return DeferredItemsFromMany(self, cb, profile_key).get(publishers_type, publishers, rsm_data=rsm_data)
-
-    ## subscribe ##
-
-    # def subscribeGroupBlog(self, pub_jid, profile_key=C.PROF_KEY_NONE):
-    #     def initialised(result):
-    #         profile, client = result
-    #         d = self.host.plugins["XEP-0060"].subscribe(client.item_access_pubsub, self.getNodeName(jid.JID(pub_jid)),
-    #                                                     profile_key=profile_key)
-    #         return d
-
-    #     #TODO: we need to use the server corresponding the the host of the jid
-    #     return self._initialise(profile_key).addCallback(initialised)
-
-
-    ## delete ##
-
-    def deleteGroupBlog(self, pub_data, comments, profile_key=C.PROF_KEY_NONE):
-        """Delete a microblog item from a node.
-
-        @param pub_data: a tuple (service, node identifier, item identifier)
-        @param comments: comments node identifier (for main item) or empty string
-        @param profile_key: %(doc_profile_key)s
-        """
-
-        def initialised(result):
-            profile, client = result
-            service, node, item_id = pub_data
-            service_jid = jid.JID(service) if service else client.item_access_pubsub
-            if comments or not node:  # main item
-                node = self.getNodeName(client.jid)
-            if comments:
-                # remove the associated comments node
-                comments_service, comments_node = self.host.plugins["XEP-0277"].parseCommentUrl(comments)
-                d = self.host.plugins["XEP-0060"].deleteNode(comments_service, comments_node, profile_key=profile)
-                d.addErrback(lambda failure: log.error(u"Deletion of node %s failed: %s" % (comments_node, failure.getErrorMessage())))
-            # remove the item itself
-            d = self.host.plugins["XEP-0060"].retractItems(service_jid, node, [item_id], profile_key=profile)
-            d.addErrback(lambda failure: log.error(u"Deletion of item %s from %s failed: %s" % (item_id, node, failure.getErrorMessage())))
-            return d
-
-        def notify(d):
-            # TODO: this works only on the same host, and notifications for item deletion should be
-            # implemented according to http://xmpp.org/extensions/xep-0060.html#publisher-delete-success-notify
-            # instead. The notification mechanism implemented in sat_pubsub and wokkel have apriori
-            # a problem with retrieving the subscriptions, or something else.
-            service, node, item_id = pub_data
-            publisher = self.host.getJidNStream(profile_key)[0]
-            profile = self.host.memory.getProfileName(profile_key)
-            gbdatum = {'id': item_id, 'type': 'main_item' if (comments or not node) else 'comment'}
-            self.host.bridge.personalEvent(publisher.full(), "MICROBLOG_DELETE", gbdatum, profile)
-            return d
-
-        return self._initialise(profile_key).addCallback(initialised).addCallback(notify)
-
-    def deleteAllGroupBlogsAndComments(self, profile_key=C.PROF_KEY_NONE):
-        """Delete absolutely all the microblog data that the user has posted"""
-        calls = [self.deleteAllGroupBlogs(profile_key), self.deleteAllGroupBlogsComments(profile_key)]
-        return defer.DeferredList(calls)
-
-    def deleteAllGroupBlogs(self, profile_key=C.PROF_KEY_NONE):
-        """Delete all the main items that the user has posted and their comments.
-        """
-        def initialised(result):
-            profile, client = result
-            service = client.item_access_pubsub
-            jid_ = client.jid
-            main_node = self.getNodeName(jid_)
-
-            def cb(nodes):
-                d_list = []
-                for node in [node for node in nodes if node.endswith(main_node)]:
-                    d = self.host.plugins["XEP-0060"].deleteNode(service, node, profile_key=profile)
-                    d.addErrback(lambda failure: log.error(_(u"Deletion of node %(node)s failed: %(message)s") %
-                                                           {'node': node, 'message': failure.getErrorMessage()}))
-                    d_list.append(d)
-                return defer.DeferredList(d_list)
-
-            d = self.host.plugins["XEP-0060"].listNodes(service, profile=profile)
-            d.addCallback(cb)
-            d.addCallback(lambda dummy: log.info(_(u"All microblog's main items from %s have been deleted!") % jid_.userhost()))
-            return d
-
-        return self._initialise(profile_key).addCallback(initialised)
-
-    def deleteAllGroupBlogsComments(self, profile_key=C.PROF_KEY_NONE):
-        """Delete all the comments that the user posted on other's main items.
-        We avoid the conversions from item to microblog data as we only need
-        to retrieve some attributes, no need to convert text syntax...
-        """
-        def initialised(result):
-            """Get all the main items from our contact list
-            @return: a DeferredList
-            """
-            profile, client = result
-            service = client.item_access_pubsub
-            jids = [contact.jid.userhostJID() for contact in client.roster.getItems()]
-            blogs = []
-            for jid_ in jids:
-                if jid_ == client.jid.userhostJID():
-                    continue  # do not remove the comments on our own node
-                main_node = self.getNodeName(jid_)
-                d = self.host.plugins["XEP-0060"].getItems(service, main_node, profile_key=profile)
-                d.addCallback(lambda res: getComments(res[0], client))
-                d.addErrback(lambda failure, main_node: log.error(_(u"Retrieval of items for node %(node)s failed: %(message)s") %
-                                                              {'node': main_node, 'message': failure.getErrorMessage()}), main_node)
-                blogs.append(d)
-
-            return defer.DeferredList(blogs)
-
-        def getComments(items, client):
-            """Get all the comments for a list of items
-            @param items: a list of main items for one user
-            @param client: the client of the user
-            @return: a DeferredList
-            """
-            comments = []
-            for item in items:
-                try:
-                    entry = generateElementsNamed(item.elements(), 'entry').next()
-                    link = generateElementsNamed(entry.elements(), 'link').next()
-                except StopIteration:
-                    continue
-                href = link.getAttribute('href')
-                service, node = self.host.plugins['XEP-0277'].parseCommentUrl(href)
-                d = self.host.plugins["XEP-0060"].getItems(service, node, profile_key=profile_key)
-                d.addCallback(lambda items: (service, node, items[0]))
-                d.addErrback(lambda failure, node: log.error(_(u"Retrieval of comments for node %(node)s failed: %(message)s") %
-                                                         {'node': node, 'message': failure.getErrorMessage()}), node)
-                comments.append(d)
-            dlist = defer.DeferredList(comments)
-            dlist.addCallback(deleteComments, client)
-            return dlist
-
-        def deleteComments(result, client):
-            """Delete all the comments of the user that are found in result
-            @param result: a list of couple (success, value) with success a
-            boolean and value a tuple (service as JID, node_id, comment_items)
-            @param client: the client of the user
-            @return: a DeferredList with the deletions result
-            """
-            user_jid_s = client.jid.userhost()
-            for (success, value) in result:
-                if not success:
-                    continue
-                service, node_id, comment_items = value
-                item_ids = []
-                for comment_item in comment_items:  # for all the comments on one post
-                    try:
-                        entry = generateElementsNamed(comment_item.elements(), 'entry').next()
-                        author = generateElementsNamed(entry.elements(), 'author').next()
-                        name = generateElementsNamed(author.elements(), 'name').next()
-                    except StopIteration:
-                        continue
-                    if name.children[0] == user_jid_s:
-                        item_ids.append(comment_item.getAttribute('id'))
-                deletions = []
-                if item_ids:  # remove the comments of the user on the given post
-                    d = self.host.plugins['XEP-0060'].retractItems(service, node_id, item_ids, profile_key=profile_key)
-                    d.addCallback(lambda dummy, node_id: log.debug(_(u'Comments of user %(user)s in node %(node)s have been retracted') %
-                                                      {'user': user_jid_s, 'node': node_id}), node_id)
-                    d.addErrback(lambda failure, node_id: log.error(_(u"Retraction of comments from %(user)s in node %(node)s failed: %(message)s") %
-                                                       {'user': user_jid_s, 'node': node_id, 'message': failure.getErrorMessage()}), node_id)
-                    deletions.append(d)
-            return defer.DeferredList(deletions)
-
-        return self._initialise(profile_key).addCallback(initialised)
-
-## helper classes to manipulate items ##
-
-class DeferredItems():
-    """Retrieve items using XEP-0060"""
-
-    def __init__(self, parent, cb, eb=None, profile_key=C.PROF_KEY_NONE):
-        """
-        @param parent (GroupBlog): GroupBlog instance
-        @param cb (callable): callback method to be applied on items
-        @param eb (callable): errback method to be applied on items
-        @param profile_key (str): %(doc_profile_key)s
-        """
-        self.parent = parent
-        self.cb = cb
-        self.eb = (lambda dummy: ([], {})) if eb is None else eb
-        self.profile_key = profile_key
-
-    def get(self, node, item_ids=None, sub_id=None, rsm_data=None):
-        """Retrieve and process a page of pubsub items
-
-        @param node (str): node identifier.
-        @param item_ids (list[str]): list of items identifiers.
-        @param sub_id (str): optional subscription identifier.
-        @param rsm_data (dict): RSM request data
-        @return: a deferred couple (list, dict) containing:
-            - list of microblog data
-            - RSM response data
-        """
-        if rsm_data is None:
-            rsm_data = {'max_': (len(item_ids) if item_ids else MAX_ITEMS)}
-
-        def initialised(result):
-            profile, client = result
-            rsm_request = rsm.RSMRequest(**rsm_data)
-            d = self.parent.host.plugins["XEP-0060"].getItems(client.item_access_pubsub,
-                                                              node, rsm_request.max,
-                                                              item_ids, sub_id, rsm_request,
-                                                              profile_key=profile)
-
-            def cb(result):
-                d = defer.maybeDeferred(self.cb, result[0], client)
-                return d.addCallback(lambda items: (items, result[1]))
-
-            d.addCallbacks(cb, self.eb)
-            return d
-
-        #TODO: we need to use the server corresponding to the host of the jid
-        return self.parent._initialise(self.profile_key).addCallback(initialised)
-
-
-class DeferredItemsFromMany():
-    def __init__(self, parent, cb, profile_key=C.PROF_KEY_NONE):
-        """
-        @param parent (GroupBlog): GroupBlog instance
-        @param cb (callable): callback method to be applied on items
-        @param profile_key (str): %(doc_profile_key)s
-        """
-        self.parent = parent
-        self.cb = cb
-        self.profile_key = profile_key
-
-    def _buildData(self, publishers_type, publishers, client):
-        jids = self.parent._getPublishersJIDs(publishers_type, publishers, client)
-        return {publisher: self.parent.getNodeName(publisher) for publisher in jids}
-
-    def get(self, publishers_type, publishers, sub_id=None, rsm_data=None):
-        """Retrieve and process a page of pubsub items
-
-        @param publishers_type (str): type of the list of publishers (one of "GROUP" or "JID" or "ALL")
-        @param publishers (list): list of publishers, according to publishers_type (list of groups or list of jids)
-        @param sub_id (str): optional subscription identifier.
-        @param rsm_data (dict): RSM request data
-        @return: a deferred dict with:
-            - key: publisher (unicode)
-            - value: couple (list[dict], dict) with:
-                - the microblogs data
-                - RSM response data
-        """
-        if rsm_data is None:
-            rsm_data = {'max_': MAX_ITEMS}
-
-        def initialised(result):
-            profile, client = result
-
-            data = self._buildData(publishers_type, publishers, client)
-            rsm_request = rsm.RSMRequest(**rsm_data)
-            d = self.parent.host.plugins["XEP-0060"].getItemsFromMany(client.item_access_pubsub,
-                                                                      data, rsm_request.max, sub_id,
-                                                                      rsm_request, profile_key=profile)
-
-            def cb(publisher):
-                def callback(result):
-                    d = defer.maybeDeferred(self.cb, result[0], publisher, client)
-                    d.addCallback(lambda items: (publisher.full(), (items, result[1])))
-                    return d
-                return callback
-
-            def cb_list(result):
-                return {value[0]: value[1] for success, value in result if success}
-
-            def main_cb(result):
-                d_list = []
-                for publisher, d_items in result.items():
-                    # XXX: trick needed as publisher is a loop variable
-                    d_list.append(d_items.addCallback(cb(publisher)))
-                return defer.DeferredList(d_list, consumeErrors=False).addCallback(cb_list)
-
-            d.addCallback(main_cb)
-            return d
-
-        #TODO: we need to use the server corresponding to the host of the jid
-        return self.parent._initialise(self.profile_key).addCallback(initialised)
-
 
 class GroupBlog_handler(XMPPHandler):
     implements(iwokkel.IDisco)