libervia-backend: sat/plugins/plugin_comp_ap_gateway/__init_

comparison sat/plugins/plugin_comp_ap_gateway/init.py @ 4023:78b5f356900c

component AP gateway: handle attachments

author	Goffi <goffi@goffi.org>
date	Thu, 23 Mar 2023 15:42:21 +0100
parents	4a2c261646b6
children	44abce96ac6b

comparison

equal deleted inserted replaced

-:cdb7de398c85
+:78b5f356900c
 C.PI_TYPE: C.PLUG_TYPE_ENTRY_POINT,
 C.PI_PROTOCOLS: [],
 C.PI_DEPENDENCIES: [
 "XEP-0050", "XEP-0054", "XEP-0060", "XEP-0084", "XEP-0106", "XEP-0277",
 "XEP-0292", "XEP-0329", "XEP-0372", "XEP-0424", "XEP-0465", "XEP-0470",
-"PUBSUB_CACHE", "TEXT_SYNTAXES", "IDENTITY", "EVENTS"
+"XEP-0447", "PUBSUB_CACHE", "TEXT_SYNTAXES", "IDENTITY", "EVENTS"
 ],
 C.PI_RECOMMENDATIONS: [],
 C.PI_MAIN: "APGateway",
 C.PI_HANDLER: C.BOOL_TRUE,
 C.PI_DESCRIPTION: _(
 IMPORT_NAME = IMPORT_NAME
 # show data send or received through HTTP, used for debugging
 # 1: log POST objects
 # 2: log POST and GET objects
 # 3: log POST and GET objects with HTTP headers for GET requests
-verbose = 0
+verbose = 3
 def __init__(self, host):
 self.host = host
 self.initialised = False
 self.client = None
 self._e = host.plugins["XEP-0106"]
 self._m = host.plugins["XEP-0277"]
 self._v = host.plugins["XEP-0292"]
 self._refs = host.plugins["XEP-0372"]
 self._r = host.plugins["XEP-0424"]
+self._sfs = host.plugins["XEP-0447"]
 self._pps = host.plugins["XEP-0465"]
+self._pa = host.plugins["XEP-0470"]
 self._c = host.plugins["PUBSUB_CACHE"]
 self._t = host.plugins["TEXT_SYNTAXES"]
 self._i = host.plugins["IDENTITY"]
-self._pa = host.plugins["XEP-0470"]
 self._events = host.plugins["EVENTS"]
 self._p.addManagedNode(
 "",
 items_cb=self._itemsReceived,
 # we want to be sure that the callbacks are launched before pubsub cache's
 # the URL must return the object and not the activity
 ap_item["object"]["@context"] = ap_item["@context"]
 return ap_item["object"]
 else:
 # this is a blog item
-mb_data = await self._m.item2mbdata(
+mb_data = await self._m.item_2_mb_data(
 self.client, found_item, author_jid, node
 )
 ap_item = await self.mb_data_2_ap_item(self.client, mb_data)
 # the URL must return the object and not the activity
 return ap_item["object"]
 owner = pub_key_data["owner"]
 pub_key_pem = pub_key_data["publicKeyPem"]
 pub_key = serialization.load_pem_public_key(pub_key_pem.encode())
 return key_id, owner, pub_key
-def createActivity(
+def create_activity(
 self,
 activity: str,
 actor_id: str,
 object_: Optional[Union[str, dict]] = None,
 target: Optional[Union[str, dict]] = None,
 ap_item = await self.ap_events.event_data_2_ap_item(
 event_data, author_jid, is_new=is_new
 )
 else:
 # blog item
-mb_data = await self._m.item2mbdata(client, item, service, node)
+mb_data = await self._m.item_2_mb_data(client, item, service, node)
 author_jid = jid.JID(mb_data["author_jid"])
 if subscribe_extra_nodes and not self.isVirtualJID(author_jid):
 # we subscribe automatically to comment nodes if any
 recipient_jid = self.getLocalJIDFromAccount(ap_account)
 recipient_client = self.client.getVirtualClient(recipient_jid)
 # noticed
 if "noticed" in attachments:
 if not "noticed" in old_attachment:
 # new "noticed" attachment, we translate to "Like" activity
 activity_id = self.buildAPURL("like", item_account, item_id)
-activity = self.createActivity(
+activity = self.create_activity(
 TYPE_LIKE, publisher_actor_id, item_url, activity_id=activity_id
 )
 activity["to"] = [ap_account]
 activity["cc"] = [NS_AP_PUBLIC]
 await self.signAndPost(inbox, publisher_actor_id, activity)
 else:
 if "noticed" in old_attachment:
 # "noticed" attachment has been removed, we undo the "Like" activity
 activity_id = self.buildAPURL("like", item_account, item_id)
-activity = self.createActivity(
+activity = self.create_activity(
 TYPE_LIKE, publisher_actor_id, item_url, activity_id=activity_id
 )
 activity["to"] = [ap_account]
 activity["cc"] = [NS_AP_PUBLIC]
-undo = self.createActivity("Undo", publisher_actor_id, activity)
+undo = self.create_activity("Undo", publisher_actor_id, activity)
 await self.signAndPost(inbox, publisher_actor_id, undo)
 # reactions
 new_reactions = set(attachments.get("reactions", {}).get("reactions", []))
 old_reactions = set(old_attachment.get("reactions", {}).get("reactions", []))
 for reactions, undo in ((reactions_remove, True), (reactions_add, False)):
 for reaction in reactions:
 activity_id = self.buildAPURL(
 "reaction", item_account, item_id, reaction.encode().hex()
 )
-reaction_activity = self.createActivity(
+reaction_activity = self.create_activity(
 TYPE_REACTION, publisher_actor_id, item_url,
 activity_id=activity_id
 )
 reaction_activity["content"] = reaction
 reaction_activity["to"] = [ap_account]
 reaction_activity["cc"] = [NS_AP_PUBLIC]
 if undo:
-activy = self.createActivity(
+activy = self.create_activity(
 "Undo", publisher_actor_id, reaction_activity
 )
 else:
 activy = reaction_activity
 await self.signAndPost(inbox, publisher_actor_id, activy)
 attending = attachments["rsvp"].get("attending", "no")
 old_attending = old_attachment.get("rsvp", {}).get("attending", "no")
 if attending != old_attending:
 activity_type = TYPE_JOIN if attending == "yes" else TYPE_LEAVE
 activity_id = self.buildAPURL(activity_type.lower(), item_account, item_id)
-activity = self.createActivity(
+activity = self.create_activity(
 activity_type, publisher_actor_id, item_url, activity_id=activity_id
 )
 activity["to"] = [ap_account]
 activity["cc"] = [NS_AP_PUBLIC]
 await self.signAndPost(inbox, publisher_actor_id, activity)
 else:
 if "rsvp" in old_attachment:
 old_attending = old_attachment.get("rsvp", {}).get("attending", "no")
 if old_attending == "yes":
 activity_id = self.buildAPURL(TYPE_LEAVE.lower(), item_account, item_id)
-activity = self.createActivity(
+activity = self.create_activity(
 TYPE_LEAVE, publisher_actor_id, item_url, activity_id=activity_id
 )
 activity["to"] = [ap_account]
 activity["cc"] = [NS_AP_PUBLIC]
 await self.signAndPost(inbox, publisher_actor_id, activity)
 return items, rsm.RSMResponse(**rsm_resp)
 async def ap_item_2_mb_data_and_elt(self, ap_item: dict) -> Tuple[dict, domish.Element]:
 """Convert AP item to parsed microblog data and corresponding item element"""
-mb_data = await self.apItem2MBdata(ap_item)
+mb_data = await self.ap_item_2_mb_data(ap_item)
-item_elt = await self._m.data2entry(
+item_elt = await self._m.mb_data_2_entry_elt(
 self.client, mb_data, mb_data["id"], None, self._m.namespace
 )
 if "repeated" in mb_data["extra"]:
 item_elt["publisher"] = mb_data["extra"]["repeated"]["by"]
 else:
 return (
 self._m.getCommentsNode(last_level_item["id"]),
 None
 )
-async def apItem2MBdata(self, ap_item: dict) -> dict:
+async def ap_item_2_mb_data(self, ap_item: dict) -> dict:
 """Convert AP activity or object to microblog data
 @param ap_item: ActivityPub item to convert
 Can be either an activity of an object
 @return: AP Item's Object and microblog data
 mb_data["content_xhtml"],
 self._t.SYNTAX_XHTML,
 self._t.SYNTAX_TEXT,
 False,
 )
+if "attachment" in ap_object:
+attachments = mb_data["extra"][C.KEY_ATTACHMENTS] = []
+for ap_attachment in ap_object["attachment"]:
+try:
+url = ap_attachment["url"]
+except KeyError:
+log.warning(
+f'"url" missing in AP attachment, ignoring: {ap_attachment}'
+)
+continue
+if not url.startswith("http"):
+log.warning(f"non HTTP URL in attachment, ignoring: {ap_attachment}")
+continue
+attachment = {"url": url}
+for ap_key, key in (
+("mediaType", "media_type"),
+# XXX: as weird as it seems, "name" is actually used for description
+#   in AP world
+("name", "desc"),
+):
+value = ap_attachment.get(ap_key)
+if value:
+attachment[key] = value
+attachments.append(attachment)
 # author
 if is_activity:
 authors = await self.apGetActors(ap_item, "actor")
 else:
 return self.buildAPURL(
 TYPE_ITEM, parent_ap_account, parent_item
 )
-async def repeatedMB2APItem(
+async def repeated_mb_2_ap_item(
 self,
 mb_data: dict
 ) -> dict:
 """Convert repeated blog item to suitable AP Announce activity
 repeated_account = await self.getAPAccountFromJidAndNode(
 rep_service, rep_node
 )
 announced_uri = self.buildAPURL("item", repeated_account, rep_item)
-announce = self.createActivity(
+announce = self.create_activity(
 "Announce", repeater_id, announced_uri, activity_id=activity_id
 )
 announce["to"] = [NS_AP_PUBLIC]
 announce["cc"] = [
 self.buildAPURL(TYPE_FOLLOWERS, repeater_account),
 be.
 @return: Activity item
 """
 extra = mb_data.get("extra", {})
 if "repeated" in extra:
-return await self.repeatedMB2APItem(mb_data)
+return await self.repeated_mb_2_ap_item(mb_data)
 if not mb_data.get("id"):
 mb_data["id"] = shortuuid.uuid()
 if not mb_data.get("author_jid"):
 mb_data["author_jid"] = client.jid.userhost()
 ap_account = await self.getAPAccountFromJidAndNode(
 }
 language = mb_data.get("language")
 if language:
 ap_object["contentMap"] = {language: ap_object["content"]}
+attachments = extra.get(C.KEY_ATTACHMENTS)
+if attachments:
+ap_attachments = ap_object["attachment"] = []
+for attachment in attachments:
+try:
+url = next(
+s['url'] for s in attachment["sources"] if 'url' in s
+)
+except (StopIteration, KeyError):
+log.warning(
+f"Ignoring attachment without URL: {attachment}"
+)
+continue
+ap_attachment = {
+"url": url
+}
+for key, ap_key in (
+("media_type", "mediaType"),
+# XXX: yes "name", cf. [ap_item_2_mb_data]
+("desc", "name"),
+):
+value = attachment.get(key)
+if value:
+ap_attachment[ap_key] = value
+ap_attachments.append(ap_attachment)
 if public:
 ap_object["to"] = [NS_AP_PUBLIC]
 if self.auto_mentions:
 for m in RE_MENTION.finditer(ap_object["content"]):
 ap_account,
 parent_item,
 mb_data
 )
-return self.createActivity(
+return self.create_activity(
 "Create" if is_new else "Update", url_actor, ap_object, activity_id=url_item
 )
 async def publishMessage(
 self,
 f"Deleting an unknown item at service {jid_}, node {node} and id "
 f"{item_id}"
 )
 else:
 try:
-mb_data = await self._m.item2mbdata(self.client, items[0].data, jid_, node)
+mb_data = await self._m.item_2_mb_data(self.client, items[0].data, jid_, node)
 if "repeated" in mb_data["extra"]:
 # we are deleting a repeated item, we must translate this to an
 # "Undo" of the "Announce" activity instead of a "Delete" one
-announce = await self.repeatedMB2APItem(mb_data)
+announce = await self.repeated_mb_2_ap_item(mb_data)
-undo = self.createActivity("Undo", author_actor_id, announce)
+undo = self.create_activity("Undo", author_actor_id, announce)
 return author_actor_id, undo
 except Exception as e:
 log.debug(
 f"Can't parse item, maybe it's not a blog item: {e}\n"
 f"{items[0].toXml()}"
 )
 url_item = self.buildAPURL(TYPE_ITEM, author_account, item_id)
-ap_item = self.createActivity(
+ap_item = self.create_activity(
 "Delete",
 author_actor_id,
 {
 "id": url_item,
 "type": TYPE_TOMBSTONE
 mb_data["language"] = language
 origin_id = mess_data["extra"].get("origin_id")
 if origin_id:
 # we need to use origin ID when present to be able to retract the message
 mb_data["id"] = origin_id
+attachments = mess_data["extra"].get(C.KEY_ATTACHMENTS)
+if attachments:
+mb_data["extra"] = {
+C.KEY_ATTACHMENTS: attachments
+}
 client = self.client.getVirtualClient(mess_data["from"])
 ap_item = await self.mb_data_2_ap_item(client, mb_data, public=False)
 ap_object = ap_item["object"]
 ap_object["to"] = ap_item["to"] = [actor_id]
 # we add a mention to direct message, otherwise peer is not notified in some AP
 )
 return False
 cached_item = cached_items[0]
-mb_data = await self._m.item2mbdata(
+mb_data = await self._m.item_2_mb_data(
 client, cached_item.data, pubsub_service, pubsub_node
 )
 ap_item = await self.mb_data_2_ap_item(client, mb_data)
 ap_object = ap_item["object"]
 ap_object["to"] = [actor_id]
 except IndexError:
 log.warning(
 f"Can't find parent item at {parent_item_service} (node "
 f"{parent_item_node!r})\n{pformat(ap_item)}")
 return
-parent_item_parsed = await self._m.item2mbdata(
+parent_item_parsed = await self._m.item_2_mb_data(
 client, parent_item_elt, parent_item_service, parent_item_node
 )
 try:
 comment_service = jid.JID(parent_item_parsed["comments"][0]["service"])
 comment_node = parent_item_parsed["comments"][0]["node"]
 @param item: AP object payload
 """
 is_public, targets, mentions = self.getAPItemTargets(item)
 if not is_public and targets.keys() == {TYPE_ACTOR}:
 # this is a direct message
-await self.handleMessageAPItem(
+await self.handle_message_ap_item(
 client, targets, mentions, destinee, item
 )
 else:
 await self.handlePubsubAPItem(
 client, targets, mentions, destinee, node, item, is_public
 )
-async def handleMessageAPItem(
+async def handle_message_ap_item(
 self,
 client: SatXMPPEntity,
 targets: Dict[str, Set[str]],
 mentions: List[Dict[str, str]],
 destinee: Optional[jid.JID],
 for t_set in targets.values()
 for t in t_set
 }
 if destinee is not None:
 targets_jids.add(destinee)
-mb_data = await self.apItem2MBdata(item)
+mb_data = await self.ap_item_2_mb_data(item)
+extra = {
+"origin_id": mb_data["id"]
+}
+attachments = mb_data["extra"].get(C.KEY_ATTACHMENTS)
+if attachments:
+extra[C.KEY_ATTACHMENTS] = attachments
 defer_l = []
 for target_jid in targets_jids:
 defer_l.append(
 client.sendMessage(
 target_jid,
 {'': mb_data.get("content", "")},
 mb_data.get("title"),
-extra={"origin_id": mb_data["id"]}
+extra=extra
 )
 )
 await defer.DeferredList(defer_l)
 async def notifyMentions(

Mercurial > libervia-backend

comparison sat/plugins/plugin_comp_ap_gateway/__init__.py @ 4023:78b5f356900c

comparison sat/plugins/plugin_comp_ap_gateway/init.py @ 4023:78b5f356900c