libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0277.py @ 2807:0b7ce5daee9b

plugin XEP-0277: blog items data are now entirely serialised before going to bridge: So far, and for historical reasons, blog items data where serialised using a unicode: unicode dict, which was causing trouble for many types of values (timestamps, booleans, lists). This patch changes it by serialising the whole items before going to bridge, and deserialising it when going back. This way, complex data can be used easily in items. This impact psEvent and serItemsData* methods which are renamed transItemsData* because there are not always serialising anymore (a new argument "serialise" allows to specify it). When editing a blog post in jp, metadata are now more easy to manipulate, specially lists like tags.

author	Goffi <goffi@goffi.org>
date	Sat, 23 Feb 2019 18:59:00 +0100
parents	85d3240a400f
children	ab2696e34d29

comparison

equal deleted inserted replaced

-:2400cad2dace
+:0b7ce5daee9b
 )
 host.bridge.addMethod(
 "mbSend",
 ".plugin",
-in_sign="ssa{ss}s",
+in_sign="ssss",
 out_sign="",
 method=self._mbSend,
 async=True,
 )
 host.bridge.addMethod(
 )
 host.bridge.addMethod(
 "mbGet",
 ".plugin",
 in_sign="ssiasa{ss}s",
-out_sign="(aa{ss}a{ss})",
+out_sign="(asa{ss})",
 method=self._mbGet,
 async=True,
 )
 host.bridge.addMethod(
 "mbSetAccess",
 )
 host.bridge.addMethod(
 "mbGetFromManyRTResult",
 ".plugin",
 in_sign="ss",
-out_sign="(ua(sssaa{ss}a{ss}))",
+out_sign="(ua(sssasa{ss}))",
 method=self._mbGetFromManyRTResult,
 async=True,
 )
 host.bridge.addMethod(
 "mbGetFromMany",
 )
 host.bridge.addMethod(
 "mbGetFromManyWithCommentsRTResult",
 ".plugin",
 in_sign="ss",
-out_sign="(ua(sssa(a{ss}a(sssaa{ss}a{ss}))a{ss}))",
+out_sign="(ua(sssa(sa(sssasa{ss}))a{ss}))",
 method=self._mbGetFromManyWithCommentsRTResult,
 async=True,
 )
 host.bridge.addMethod(
 "mbGetFromManyWithComments",
 self.host.bridge.psEvent(
 C.PS_MICROBLOG,
 itemsEvent.sender.full(),
 itemsEvent.nodeIdentifier,
 event,
-data,
+data_format.serialise(data),
 client.profile,
 )
 for item in itemsEvent.items:
 if item.name == C.PS_ITEM:
 ## data/item transformation ##
 @defer.inlineCallbacks
 def item2mbdata(self, item_elt):
-"""Convert an XML Item to microblog data used in bridge API
+"""Convert an XML Item to microblog data
 @param item_elt: domish.Element of microblog item
 @return: microblog data (dictionary)
 """
 microblog_data = {}
 if type_ == "xhtml":
 data_elt = elem.firstChildElement()
 if data_elt is None:
 raise failure.Failure(
 exceptions.DataError(
-u"XHML content not wrapped in a <div/> element, this is not standard !"
+u"XHML content not wrapped in a <div/> element, this is not "
+u"standard !"
 )
 )
 if data_elt.uri != C.NS_XHTML:
 raise failure.Failure(
 exceptions.DataError(
 # atom:id
 try:
 id_elt = entry_elt.elements(NS_ATOM, "id").next()
 except StopIteration:
-msg = u"No atom id found in the pubsub item {}, this is not standard !".format(
+msg = (u"No atom id found in the pubsub item {}, this is not standard !"
-id_
+.format(id_))
-)
 log.warning(msg)
 microblog_data[u"atom_id"] = ""
 else:
 microblog_data[u"atom_id"] = unicode(id_elt)
 try:
 updated_elt = entry_elt.elements(NS_ATOM, "updated").next()
 except StopIteration:
 msg = u"No atom updated element found in the pubsub item {}".format(id_)
 raise failure.Failure(exceptions.DataError(msg))
-microblog_data[u"updated"] = unicode(
+microblog_data[u"updated"] = calendar.timegm(
-calendar.timegm(dateutil.parser.parse(unicode(updated_elt)).utctimetuple())
+dateutil.parser.parse(unicode(updated_elt)).utctimetuple()
 )
 try:
 published_elt = entry_elt.elements(NS_ATOM, "published").next()
 except StopIteration:
 microblog_data[u"published"] = microblog_data[u"updated"]
 else:
-microblog_data[u"published"] = unicode(
+microblog_data[u"published"] = calendar.timegm(
-calendar.timegm(
+dateutil.parser.parse(unicode(published_elt)).utctimetuple()
-dateutil.parser.parse(unicode(published_elt)).utctimetuple()
-)
 )
 # links
 for link_elt in entry_elt.elements(NS_ATOM, "link"):
 if (
 item_elt.getAttribute(u"publisher") or ""
 )
 if not publisher:
 log.debug(u"No publisher attribute, we can't verify author jid")
-microblog_data[u"author_jid_verified"] = C.BOOL_FALSE
+microblog_data[u"author_jid_verified"] = False
 elif jid.JID(publisher).userhostJID() == jid.JID(uri).userhostJID():
-microblog_data[u"author_jid_verified"] = C.BOOL_TRUE
+microblog_data[u"author_jid_verified"] = True
 else:
 log.warning(
-u"item atom:uri differ from publisher attribute, spoofing attempt ? atom:uri = {} publisher = {}".format(
+u"item atom:uri differ from publisher attribute, spoofing "
+u"attempt ? atom:uri = {} publisher = {}".format(
 uri, item_elt.getAttribute("publisher")
 )
 )
-microblog_data[u"author_jid_verified"] = C.BOOL_FALSE
+microblog_data[u"author_jid_verified"] = False
 # email
 try:
 email_elt = author_elt.elements(NS_ATOM, "email").next()
 except StopIteration:
 pass
 else:
 microblog_data[u"author_email"] = unicode(email_elt)
 # categories
-categories = (
+categories = [
 category_elt.getAttribute("term", "")
 for category_elt in entry_elt.elements(NS_ATOM, "category")
-)
+]
-data_format.iter2dict("tag", categories, microblog_data)
+microblog_data[u"tags"] = categories
 ## the trigger ##
 # if other plugins have things to add or change
 yield self.host.trigger.point(
 "XEP-0277_item2data", item_elt, entry_elt, microblog_data
 "published",
 content=utils.xmpp_date(float(data.get("published", current_time))),
 )
 ## categories ##
-for tag in data_format.dict2iter("tag", data):
+for tag in data.get('tags', []):
 category_elt = entry_elt.addElement("category")
 category_elt["term"] = tag
 ## id ##
 entry_id = data.get(
 @param node(unicode): node of the parent item
 @param item_id(unicode): id of the parent item
 @param access(unicode, None): access model
 None to use same access model as parent item
 """
-# FIXME: if 'comments' already exists in mb_data, it is not used to create the Node
+# FIXME: if 'comments' already exists in mb_data,
-allow_comments = C.bool(mb_data.pop("allow_comments", "false"))
+#        it is not used to create the Node
-if not allow_comments:
+allow_comments = mb_data.pop("allow_comments", None)
+if allow_comments is None:
+return
+elif allow_comments == False:
 if "comments" in mb_data:
 log.warning(
-u"comments are not allowed but there is already a comments node, it may be lost: {uri}".format(
+u"comments are not allowed but there is already a comments node, "
+u"it may be lost: {uri}".format(
 uri=mb_data["comments"]
 )
 )
 del mb_data["comments"]
 return
 raise exceptions.DataError(
 u"if comments is present, it must not be empty"
 )
 if "comments_node" in mb_data or "comments_service" in mb_data:
 raise exceptions.DataError(
-u"You can't use comments_service/comments_node and comments at the same time"
+u"You can't use comments_service/comments_node and comments at the "
+u"same time"
 )
 else:
 mb_data["comments"] = self._p.getNodeURI(comments_service, comments_node)
 def _mbSend(self, service, node, data, profile_key):
 service = jid.JID(service) if service else None
 node = node if node else NS_MICROBLOG
 client = self.host.getClient(profile_key)
+data = data_format.deserialise(data)
 return self.send(client, data, service, node)
 @defer.inlineCallbacks
 def send(self, client, data, service=None, node=NS_MICROBLOG):
 """Send XEP-0277's microblog data
 None to publish on profile's PEP
 @param node(unicode, None): PubSub node to use (defaut to microblog NS)
 None is equivalend as using default value
 """
 # TODO: check that all data keys are used, this would avoid sending publicly a private message
-#       by accident (e.g. if group pluging is not loaded, and "grou*" key are not used)
+#       by accident (e.g. if group plugin is not loaded, and "group*" key are not used)
 if node is None:
 node = NS_MICROBLOG
 item_id = data.get("id") or unicode(shortuuid.uuid())
 profile_key,
 )
 ## get ##
+def _mbGetSerialise(self, data):
+items, metadata = data
+items = [data_format.serialise(item) for item in items]
+return items, metadata
 def _mbGet(self, service="", node="", max_items=10, item_ids=None, extra_dict=None,
 profile_key=C.PROF_KEY_NONE):
 """
 @param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
 @param item_ids (list[unicode]): list of item IDs
 """
 client = self.host.getClient(profile_key)
 service = jid.JID(service) if service else None
 max_items = None if max_items == C.NO_LIMIT else max_items
 extra = self._p.parseExtra(extra_dict)
-return self.mbGet(
+d = self.mbGet(client, service, node or None, max_items, item_ids,
-client,
+extra.rsm_request, extra.extra)
-service,
+d.addCallback(self._mbGetSerialise)
-node or None,
+return d
-max_items,
-item_ids,
-extra.rsm_request,
-extra.extra,
-)
 @defer.inlineCallbacks
 def mbGet(self, client, service=None, node=None, max_items=10, item_ids=None,
 rsm_request=None, extra=None):
 """Get some microblogs
 max_items=max_items,
 item_ids=item_ids,
 rsm_request=rsm_request,
 extra=extra,
 )
-serialised = yield self._p.serItemsDataD(items_data, self.item2mbdata)
+mb_data = yield self._p.transItemsDataD(items_data, self.item2mbdata)
-defer.returnValue(serialised)
+defer.returnValue(mb_data)
 def parseCommentUrl(self, node_url):
 """Parse a XMPP URI
 Determine the fields comments_service and comments_node of a microblog data
 @param publishers_type: type of the list of publishers, one of:
 C.ALL: get all jids from roster, publishers is not used
 C.GROUP: get jids from groups
 C.JID: use publishers directly as list of jids
-@param publishers: list of publishers, according to "publishers_type" (None, list of groups or list of jids)
+@param publishers: list of publishers, according to "publishers_type" (None,
+list of groups or list of jids)
 @param profile_key: %(doc_profile_key)s
 """
 client = self.host.getClient(profile_key)
 if publishers_type == C.JID:
 jids_set = set(publishers)
 else:
 jids_set = client.roster.getJidsSet(publishers_type, publishers)
 if publishers_type == C.ALL:
-try:  # display messages from salut-a-toi@libervia.org or other PEP services
+try:
+# display messages from salut-a-toi@libervia.org or other PEP services
 services = self.host.plugins["EXTRA-PEP"].getFollowedEntities(
 profile_key
 )
 except KeyError:
 pass  # plugin is not loaded
 @param publishers_type: type of the list of publishers, one of:
 C.ALL: get all jids from roster, publishers is not used
 C.GROUP: get jids from groups
 C.JID: use publishers directly as list of jids
-@param publishers: list of publishers, according to "publishers_type" (None, list of groups or list of jids)
+@param publishers: list of publishers, according to "publishers_type" (None, list
+of groups or list of jids)
 @param profile: %(doc_profile)s
 @return (str): session id
 """
 client, node_data = self._getClientAndNodeData(
 publishers_type, publishers, profile_key
 @param profile_key: %(doc_profile_key)s
 """
 def onSuccess(items_data):
 """convert items elements to list of microblog data in items_data"""
-d = self._p.serItemsDataD(items_data, self.item2mbdata)
+d = self._p.transItemsDataD(items_data, self.item2mbdata, serialise=True)
 d.addCallback(lambda serialised: ("", serialised))
 return d
 profile = self.host.getClient(profile_key).profile
 d = self._p.getRTResults(
 ],
 )
 )
 return d
-def _mbGetFromMany(
+def _mbGetFromMany(self, publishers_type, publishers, max_items=10, extra_dict=None,
-self,
+profile_key=C.PROF_KEY_NONE):
-publishers_type,
-publishers,
-max_items=10,
-extra_dict=None,
-profile_key=C.PROF_KEY_NONE,
-):
 """
 @param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
 """
 max_items = None if max_items == C.NO_LIMIT else max_items
 publishers_type, publishers = self._checkPublishers(publishers_type, publishers)
 extra.rsm_request,
 extra.extra,
 profile_key,
 )
-def mbGetFromMany(
+def mbGetFromMany(self, publishers_type, publishers, max_items=None, rsm_request=None,
-self,
+extra=None, profile_key=C.PROF_KEY_NONE):
-publishers_type,
-publishers,
-max_items=None,
-rsm_request=None,
-extra=None,
-profile_key=C.PROF_KEY_NONE,
-):
 """Get the 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_type (str): type of the list of publishers (one of "GROUP" or
-@param publishers (list): list of publishers, according to publishers_type (list of groups or list of jids)
+"JID" or "ALL")
+@param publishers (list): list of publishers, according to publishers_type (list
+of groups or list of jids)
 @param max_items (int): optional limit on the number of retrieved items.
 @param rsm_request (rsm.RSMRequest): RSM request data, common to all publishers
 @param extra (dict): Extra data
 @param profile_key: profile key
 @return (str): RT Deferred session id
 node_data, max_items, rsm_request, profile_key=profile_key
 )
 # comments #
-def _mbGetFromManyWithCommentsRTResult(
+def _mbGetFromManyWithCommentsRTResultSerialise(self, data):
-self, session_id, profile_key=C.PROF_KEY_DEFAULT
+"""Serialisation of result
-):
+This is probably the longest method name of whole SàT ecosystem ^^
+@param data(dict): data as received by rt_sessions
+@return (tuple): see [_mbGetFromManyWithCommentsRTResult]
+"""
+ret = []
+data_iter = data[1].iteritems()
+for (service, node), (success, (failure_, (items_data, metadata))) in data_iter:
+items = []
+for item, item_metadata in items_data:
+item = data_format.serialise(item)
+items.append((item, item_metadata))
+ret.append((
+service.full(),
+node,
+failure_,
+items,
+metadata))
+return data[0], ret
+def _mbGetFromManyWithCommentsRTResult(self, session_id,
+profile_key=C.PROF_KEY_DEFAULT):
 """Get real-time results for [mbGetFromManyWithComments] session
 @param session_id: id of the real-time deferred session
 @param return (tuple): (remaining, results) where:
 - remaining is the number of still expected results
 - metadata(dict): original node metadata
 @param profile_key: %(doc_profile_key)s
 """
 profile = self.host.getClient(profile_key).profile
 d = self.rt_sessions.getResults(session_id, profile=profile)
-d.addCallback(
+d.addCallback(self._mbGetFromManyWithCommentsRTResultSerialise)
-lambda ret: (
-ret[0],
-[
-(service.full(), node, failure, items, metadata)
-for (service, node), (success, (failure, (items, metadata))) in ret[
-1
-].iteritems()
-],
-)
-)
 return d
-def _mbGetFromManyWithComments(
+def _mbGetFromManyWithComments(self, publishers_type, publishers, max_items=10,
-self,
+max_comments=C.NO_LIMIT, extra_dict=None,
-publishers_type,
+extra_comments_dict=None, profile_key=C.PROF_KEY_NONE):
-publishers,
-max_items=10,
-max_comments=C.NO_LIMIT,
-extra_dict=None,
-extra_comments_dict=None,
-profile_key=C.PROF_KEY_NONE,
-):
 """
 @param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
-@param max_comments(int): maximum number of comments to get, C.NO_LIMIT for no limit
+@param max_comments(int): maximum number of comments to get, C.NO_LIMIT for no
+limit
 """
 max_items = None if max_items == C.NO_LIMIT else max_items
 max_comments = None if max_comments == C.NO_LIMIT else max_comments
 publishers_type, publishers = self._checkPublishers(publishers_type, publishers)
 extra = self._p.parseExtra(extra_dict)
 extra_comments.rsm_request,
 extra_comments.extra,
 profile_key,
 )
-def mbGetFromManyWithComments(
+def mbGetFromManyWithComments(self, publishers_type, publishers, max_items=None,
-self,
+max_comments=None, rsm_request=None, extra=None,
-publishers_type,
+rsm_comments=None, extra_comments=None,
-publishers,
+profile_key=C.PROF_KEY_NONE):
-max_items=None,
-max_comments=None,
-rsm_request=None,
-extra=None,
-rsm_comments=None,
-extra_comments=None,
-profile_key=C.PROF_KEY_NONE,
-):
 """Helper method to get the microblogs and their comments in one shot
-@param publishers_type (str): type of the list of publishers (one of "GROUP" or "JID" or "ALL")
+@param publishers_type (str): type of the list of publishers (one of "GROUP" or
-@param publishers (list): list of publishers, according to publishers_type (list of groups or list of jids)
+"JID" or "ALL")
+@param publishers (list): list of publishers, according to publishers_type (list
+of groups or list of jids)
 @param max_items (int): optional limit on the number of retrieved items.
 @param max_comments (int): maximum number of comments to retrieve
 @param rsm_request (rsm.RSMRequest): RSM request for initial items only
 @param extra (dict): extra configuration for initial items only
 @param rsm_comments (rsm.RSMRequest): RSM request for comments only
 rsm_request=rsm_comments,
 extra=extra_comments,
 )
 # then serialise
 d.addCallback(
-lambda items_data: self._p.serItemsDataD(
+lambda items_data: self._p.transItemsDataD(
-items_data, self.item2mbdata
+items_data, self.item2mbdata, serialise=True
 )
 )
 # with failure handling
 d.addCallback(
 lambda serialised_items_data: ("",) + serialised_items_data
 )
 d.addErrback(lambda failure: (unicode(failure.value), [], {}))
-# and associate with service/node (needed if there are several comments nodes)
+# and associate with service/node (needed if there are several
+# comments nodes)
 d.addCallback(
 lambda serialised, service_s=service_s, node=node: (
 service_s,
 node,
 )
 for service, node in node_data:
 d = deferreds[(service, node)] = self._p.getItems(
 client, service, node, max_items, rsm_request=rsm_request, extra=extra
 )
 d.addCallback(
-lambda items_data: self._p.serItemsDataD(items_data, self.item2mbdata)
+lambda items_data: self._p.transItemsDataD(items_data, self.item2mbdata)
 )
 d.addCallback(getComments)
 d.addCallback(lambda items_comments_data: ("", items_comments_data))
 d.addErrback(lambda failure: (unicode(failure.value), ([], {})))

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0277.py @ 2807:0b7ce5daee9b