microblog.pub/activitypub.py

604 lines
21 KiB
Python
Raw Normal View History

2018-05-27 07:21:06 -05:00
import logging
2018-06-24 12:51:09 -05:00
import os
2018-05-18 13:41:41 -05:00
from datetime import datetime
2018-06-29 15:16:26 -05:00
from enum import Enum
2018-06-16 15:02:10 -05:00
from typing import Any
from typing import Dict
from typing import List
from typing import Optional
2018-05-18 13:41:41 -05:00
from bson.objectid import ObjectId
from feedgen.feed import FeedGenerator
2018-06-16 15:02:10 -05:00
from html2text import html2text
2018-05-18 13:41:41 -05:00
2018-06-16 15:02:10 -05:00
import tasks
from config import BASE_URL
from config import DB
from config import EXTRA_INBOXES
2018-06-16 15:02:10 -05:00
from config import ID
from config import ME
from config import MEDIA_CACHE
2018-06-16 15:02:10 -05:00
from config import USER_AGENT
from config import USERNAME
2018-06-16 14:24:53 -05:00
from little_boxes import activitypub as ap
2018-06-29 15:16:26 -05:00
from little_boxes import strtobool
from little_boxes.activitypub import _to_list
2018-06-16 14:24:53 -05:00
from little_boxes.backend import Backend
from little_boxes.collection import parse_collection as ap_parse_collection
2018-06-16 15:33:51 -05:00
from little_boxes.errors import Error
from utils.media import Kind
2018-06-16 15:33:51 -05:00
2018-05-27 07:21:06 -05:00
logger = logging.getLogger(__name__)
2018-05-18 13:41:41 -05:00
2018-06-16 14:24:53 -05:00
def _remove_id(doc: ap.ObjectType) -> ap.ObjectType:
2018-05-27 15:30:43 -05:00
"""Helper for removing MongoDB's `_id` field."""
2018-05-18 13:41:41 -05:00
doc = doc.copy()
2018-06-16 14:24:53 -05:00
if "_id" in doc:
del (doc["_id"])
2018-05-18 13:41:41 -05:00
return doc
2018-06-16 15:33:51 -05:00
def ensure_it_is_me(f):
"""Method decorator used to track the events fired during tests."""
2018-06-17 12:21:59 -05:00
2018-06-16 15:33:51 -05:00
def wrapper(*args, **kwargs):
2018-06-17 13:51:23 -05:00
if args[1].id != ME["id"]:
2018-06-17 12:21:59 -05:00
raise Error("unexpected actor")
2018-06-16 15:33:51 -05:00
return f(*args, **kwargs)
2018-06-17 12:21:59 -05:00
2018-06-16 15:33:51 -05:00
return wrapper
2018-06-29 15:16:26 -05:00
class Box(Enum):
INBOX = "inbox"
OUTBOX = "outbox"
REPLIES = "replies"
2018-06-16 14:24:53 -05:00
class MicroblogPubBackend(Backend):
2018-06-21 17:55:50 -05:00
"""Implements a Little Boxes backend, backed by MongoDB."""
2018-06-24 12:51:09 -05:00
def debug_mode(self) -> bool:
return strtobool(os.getenv("MICROBLOGPUB_DEBUG", "false"))
2018-06-16 15:02:10 -05:00
def user_agent(self) -> str:
2018-06-21 17:55:50 -05:00
"""Setup a custom user agent."""
2018-06-16 15:02:10 -05:00
return USER_AGENT
def extra_inboxes(self) -> List[str]:
return EXTRA_INBOXES
2018-06-16 14:24:53 -05:00
def base_url(self) -> str:
2018-06-21 17:55:50 -05:00
"""Base URL config."""
2018-06-16 14:24:53 -05:00
return BASE_URL
2018-05-18 13:41:41 -05:00
2018-06-16 14:24:53 -05:00
def activity_url(self, obj_id):
2018-06-21 17:55:50 -05:00
"""URL for activity link."""
2018-06-16 14:24:53 -05:00
return f"{BASE_URL}/outbox/{obj_id}"
2018-06-22 18:14:35 -05:00
def note_url(self, obj_id):
"""URL for activity link."""
return f"{BASE_URL}/note/{obj_id}"
2018-06-29 15:16:26 -05:00
def save(self, box: Box, activity: ap.BaseActivity) -> None:
"""Custom helper for saving an activity to the DB."""
DB.activities.insert_one(
2018-06-16 14:24:53 -05:00
{
2018-06-29 15:16:26 -05:00
"box": box.value,
2018-06-16 14:24:53 -05:00
"activity": activity.to_dict(),
2018-06-27 17:37:18 -05:00
"type": _to_list(activity.type),
2018-06-16 14:24:53 -05:00
"remote_id": activity.id,
"meta": {"undo": False, "deleted": False},
}
2018-05-18 13:41:41 -05:00
)
2018-07-07 05:53:32 -05:00
# Generates thumbnails for the actor's icon and the attachments if any
actor = activity.get_actor()
if actor.icon:
MEDIA_CACHE.cache(actor.icon["url"], Kind.ACTOR_ICON)
if activity.type == ap.ActivityType.CREATE.value:
for attachment in activity.get_object()._data.get("attachment", []):
MEDIA_CACHE.cache(attachment["url"], Kind.ATTACHMENT)
2018-06-29 15:16:26 -05:00
@ensure_it_is_me
def outbox_new(self, as_actor: ap.Person, activity: ap.BaseActivity) -> None:
self.save(Box.OUTBOX, activity)
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def outbox_is_blocked(self, as_actor: ap.Person, actor_id: str) -> bool:
return bool(
2018-06-29 15:16:26 -05:00
DB.activities.find_one(
2018-06-16 14:24:53 -05:00
{
2018-06-29 15:16:26 -05:00
"box": Box.OUTBOX.value,
2018-06-16 14:24:53 -05:00
"type": ap.ActivityType.BLOCK.value,
2018-06-17 14:54:16 -05:00
"activity.object": actor_id,
2018-06-16 14:24:53 -05:00
"meta.undo": False,
}
2018-05-18 13:41:41 -05:00
)
2018-06-16 14:24:53 -05:00
)
2018-05-18 13:41:41 -05:00
2018-06-16 14:24:53 -05:00
def fetch_iri(self, iri: str) -> ap.ObjectType:
2018-06-17 13:51:23 -05:00
if iri == ME["id"]:
return ME
# Check if the activity is owned by this server
if iri.startswith(BASE_URL):
2018-06-17 15:05:38 -05:00
is_a_note = False
2018-06-18 15:01:21 -05:00
if iri.endswith("/activity"):
iri = iri.replace("/activity", "")
2018-06-17 15:05:38 -05:00
is_a_note = True
2018-06-29 15:16:26 -05:00
data = DB.activities.find_one({"box": Box.OUTBOX.value, "remote_id": iri})
if data and is_a_note:
return data["activity"]["object"]
elif data:
2018-06-17 14:54:16 -05:00
return data["activity"]
else:
# Check if the activity is stored in the inbox
2018-06-29 15:16:26 -05:00
data = DB.activities.find_one({"remote_id": iri})
2018-06-17 14:54:16 -05:00
if data:
return data["activity"]
2018-06-17 13:51:23 -05:00
# Fetch the URL via HTTP
2018-06-16 15:33:51 -05:00
return super().fetch_iri(iri)
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_check_duplicate(self, as_actor: ap.Person, iri: str) -> bool:
2018-06-29 15:16:26 -05:00
return bool(DB.activities.find_one({"box": Box.INBOX.value, "remote_id": iri}))
2018-06-16 14:24:53 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_new(self, as_actor: ap.Person, activity: ap.BaseActivity) -> None:
2018-06-29 15:16:26 -05:00
self.save(Box.INBOX, activity)
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def post_to_remote_inbox(self, as_actor: ap.Person, payload: str, to: str) -> None:
tasks.post_to_inbox.delay(payload, to)
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def new_follower(self, as_actor: ap.Person, follow: ap.Follow) -> None:
remote_actor = follow.get_actor().id
2018-05-18 13:41:41 -05:00
2018-06-16 14:24:53 -05:00
if DB.followers.find({"remote_actor": remote_actor}).count() == 0:
DB.followers.insert_one({"remote_actor": remote_actor})
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def undo_new_follower(self, as_actor: ap.Person, follow: ap.Follow) -> None:
# TODO(tsileo): update the follow to set undo
DB.followers.delete_one({"remote_actor": follow.get_actor().id})
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def undo_new_following(self, as_actor: ap.Person, follow: ap.Follow) -> None:
# TODO(tsileo): update the follow to set undo
DB.following.delete_one({"remote_actor": follow.get_object().id})
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def new_following(self, as_actor: ap.Person, follow: ap.Follow) -> None:
2018-06-17 14:54:16 -05:00
remote_actor = follow.get_object().id
2018-06-16 14:24:53 -05:00
if DB.following.find({"remote_actor": remote_actor}).count() == 0:
DB.following.insert_one({"remote_actor": remote_actor})
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_like(self, as_actor: ap.Person, like: ap.Like) -> None:
obj = like.get_object()
2018-05-18 13:41:41 -05:00
# Update the meta counter if the object is published by the server
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"box": Box.OUTBOX.value, "activity.object.id": obj.id},
{"$inc": {"meta.count_like": 1}},
2018-06-16 14:24:53 -05:00
)
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_undo_like(self, as_actor: ap.Person, like: ap.Like) -> None:
obj = like.get_object()
2018-05-18 13:41:41 -05:00
# Update the meta counter if the object is published by the server
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"box": Box.OUTBOX.value, "activity.object.id": obj.id},
{"$inc": {"meta.count_like": -1}},
2018-06-16 14:24:53 -05:00
)
2018-07-07 05:10:25 -05:00
DB.activities.update_one({"remote_id": like.id}, {"$set": {"meta.undo": True}})
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-17 13:51:23 -05:00
def outbox_like(self, as_actor: ap.Person, like: ap.Like) -> None:
2018-06-16 14:24:53 -05:00
obj = like.get_object()
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"activity.object.id": obj.id},
{"$inc": {"meta.count_like": 1}, "$set": {"meta.liked": like.id}},
2018-06-16 14:24:53 -05:00
)
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"remote_id": like.id}, {"$set": {"meta.object": obj.to_dict(embed=True)}}
2018-06-16 14:24:53 -05:00
)
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def outbox_undo_like(self, as_actor: ap.Person, like: ap.Like) -> None:
obj = like.get_object()
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"activity.object.id": obj.id},
{"$inc": {"meta.count_like": -1}, "$set": {"meta.liked": False}},
2018-06-16 14:24:53 -05:00
)
2018-07-07 05:10:25 -05:00
DB.activities.update_one({"remote_id": like.id}, {"$set": {"meta.undo": True}})
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_announce(self, as_actor: ap.Person, announce: ap.Announce) -> None:
if isinstance(announce._data["object"], str) and not announce._data[
"object"
].startswith("http"):
2018-05-18 13:41:41 -05:00
# TODO(tsileo): actually drop it without storing it and better logging, also move the check somewhere else
2018-06-29 15:16:26 -05:00
# or remote it?
2018-05-28 12:46:23 -05:00
logger.warn(
2018-06-16 14:24:53 -05:00
f'received an Annouce referencing an OStatus notice ({announce._data["object"]}), dropping the message'
2018-05-28 12:46:23 -05:00
)
2018-05-18 13:41:41 -05:00
return
2018-06-29 15:16:26 -05:00
obj = announce.get_object()
DB.activities.update_one(
{"remote_id": announce.id},
{"$set": {"meta.object": obj.to_dict(embed=True)}},
)
DB.activities.update_one(
{"activity.object.id": obj.id}, {"$inc": {"meta.count_boost": 1}}
2018-06-16 14:24:53 -05:00
)
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_undo_announce(self, as_actor: ap.Person, announce: ap.Announce) -> None:
obj = announce.get_object()
2018-05-28 12:46:23 -05:00
# Update the meta counter if the object is published by the server
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
2018-06-16 14:24:53 -05:00
{"activity.object.id": obj.id}, {"$inc": {"meta.count_boost": -1}}
)
2018-07-07 05:10:25 -05:00
DB.activities.update_one(
{"remote_id": announce.id}, {"$set": {"meta.undo": True}}
)
2018-05-29 11:59:37 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def outbox_announce(self, as_actor: ap.Person, announce: ap.Announce) -> None:
obj = announce.get_object()
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"remote_id": announce.id},
{"$set": {"meta.object": obj.to_dict(embed=True)}},
)
DB.activities.update_one(
2018-06-16 14:24:53 -05:00
{"activity.object.id": obj.id}, {"$set": {"meta.boosted": announce.id}}
)
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def outbox_undo_announce(self, as_actor: ap.Person, announce: ap.Announce) -> None:
obj = announce.get_object()
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
2018-06-16 14:24:53 -05:00
{"activity.object.id": obj.id}, {"$set": {"meta.boosted": False}}
)
2018-07-07 05:10:25 -05:00
DB.activities.update_one(
{"remote_id": announce.id}, {"$set": {"meta.undo": True}}
)
2018-06-02 02:07:57 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_delete(self, as_actor: ap.Person, delete: ap.Delete) -> None:
2018-06-18 15:01:21 -05:00
obj = delete.get_object()
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"activity.object.id": obj.id}, {"$set": {"meta.deleted": True}}
)
2018-06-18 15:04:24 -05:00
if obj.ACTIVITY_TYPE != ap.ActivityType.NOTE:
2018-06-18 16:57:53 -05:00
obj = ap.parse_activity(
2018-06-29 15:16:26 -05:00
DB.activities.find_one(
2018-06-18 16:57:53 -05:00
{
"activity.object.id": delete.get_object().id,
"type": ap.ActivityType.CREATE.value,
}
)["activity"]
).get_object()
2018-06-18 16:34:07 -05:00
logger.info(f"inbox_delete handle_replies obj={obj!r}")
if obj:
self._handle_replies_delete(as_actor, obj)
2018-06-18 15:01:21 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def outbox_delete(self, as_actor: ap.Person, delete: ap.Delete) -> None:
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
2018-06-16 14:24:53 -05:00
{"activity.object.id": delete.get_object().id},
{"$set": {"meta.deleted": True}},
)
2018-06-18 16:34:07 -05:00
obj = delete.get_object()
if delete.get_object().ACTIVITY_TYPE != ap.ActivityType.NOTE:
obj = ap.parse_activity(
2018-06-29 15:16:26 -05:00
DB.activities.find_one(
2018-06-18 16:34:07 -05:00
{
"activity.object.id": delete.get_object().id,
"type": ap.ActivityType.CREATE.value,
}
2018-06-18 16:57:53 -05:00
)["activity"]
2018-06-18 16:34:07 -05:00
).get_object()
self._handle_replies_delete(as_actor, obj)
2018-05-18 13:41:41 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-16 14:24:53 -05:00
def inbox_update(self, as_actor: ap.Person, update: ap.Update) -> None:
obj = update.get_object()
if obj.ACTIVITY_TYPE == ap.ActivityType.NOTE:
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
2018-06-16 14:24:53 -05:00
{"activity.object.id": obj.id},
{"$set": {"activity.object": obj.to_dict()}},
2018-06-29 15:16:26 -05:00
)
2018-06-16 14:24:53 -05:00
# FIXME(tsileo): handle update actor amd inbox_update_note/inbox_update_actor
2018-06-02 02:07:57 -05:00
2018-06-16 15:33:51 -05:00
@ensure_it_is_me
2018-06-17 12:21:59 -05:00
def outbox_update(self, as_actor: ap.Person, _update: ap.Update) -> None:
obj = _update._data["object"]
2018-05-18 13:41:41 -05:00
2018-06-16 14:24:53 -05:00
update_prefix = "activity.object."
update: Dict[str, Any] = {"$set": dict(), "$unset": dict()}
update["$set"][f"{update_prefix}updated"] = (
datetime.utcnow().replace(microsecond=0).isoformat() + "Z"
)
2018-06-01 13:59:32 -05:00
for k, v in obj.items():
2018-06-16 14:24:53 -05:00
if k in ["id", "type"]:
2018-05-18 13:41:41 -05:00
continue
if v is None:
2018-06-16 14:24:53 -05:00
update["$unset"][f"{update_prefix}{k}"] = ""
2018-05-18 13:41:41 -05:00
else:
2018-06-16 14:24:53 -05:00
update["$set"][f"{update_prefix}{k}"] = v
2018-05-18 13:41:41 -05:00
2018-06-16 14:24:53 -05:00
if len(update["$unset"]) == 0:
del (update["$unset"])
2018-05-18 13:41:41 -05:00
2018-06-16 14:24:53 -05:00
print(f"updating note from outbox {obj!r} {update}")
logger.info(f"updating note from outbox {obj!r} {update}")
2018-06-29 15:16:26 -05:00
DB.activities.update_one({"activity.object.id": obj["id"]}, update)
2018-05-18 13:41:41 -05:00
# FIXME(tsileo): should send an Update (but not a partial one, to all the note's recipients
# (create a new Update with the result of the update, and send it without saving it?)
2018-06-18 15:01:21 -05:00
@ensure_it_is_me
2018-06-17 13:51:23 -05:00
def outbox_create(self, as_actor: ap.Person, create: ap.Create) -> None:
2018-06-18 15:01:21 -05:00
self._handle_replies(as_actor, create)
2018-06-17 13:51:23 -05:00
2018-06-18 15:01:21 -05:00
@ensure_it_is_me
2018-06-17 13:51:23 -05:00
def inbox_create(self, as_actor: ap.Person, create: ap.Create) -> None:
2018-06-18 15:01:21 -05:00
self._handle_replies(as_actor, create)
@ensure_it_is_me
2018-06-18 16:34:07 -05:00
def _handle_replies_delete(self, as_actor: ap.Person, note: ap.Note) -> None:
2018-06-18 15:01:21 -05:00
in_reply_to = note.inReplyTo
if not in_reply_to:
pass
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
2018-06-18 15:01:21 -05:00
{"activity.object.id": in_reply_to},
{"$inc": {"meta.count_reply": -1, "meta.count_direct_reply": -1}},
2018-06-29 15:16:26 -05:00
)
2018-06-18 15:01:21 -05:00
@ensure_it_is_me
def _handle_replies(self, as_actor: ap.Person, create: ap.Create) -> None:
2018-06-22 17:29:06 -05:00
"""Go up to the root reply, store unknown replies in the `threads` DB and set the "meta.thread_root_parent"
key to make it easy to query a whole thread."""
2018-06-18 15:01:21 -05:00
in_reply_to = create.get_object().inReplyTo
if not in_reply_to:
2018-06-22 18:04:58 -05:00
return
2018-06-18 15:01:21 -05:00
2018-06-22 17:29:06 -05:00
new_threads = []
root_reply = in_reply_to
reply = ap.fetch_remote_activity(root_reply, expected=ap.ActivityType.NOTE)
2018-06-29 15:16:26 -05:00
creply = DB.activities.find_one_and_update(
2018-06-18 15:01:21 -05:00
{"activity.object.id": in_reply_to},
{"$inc": {"meta.count_reply": 1, "meta.count_direct_reply": 1}},
2018-06-29 15:16:26 -05:00
)
if not creply:
# It means the activity is not in the inbox, and not in the outbox, we want to save it
self.save(Box.REPLIES, reply)
new_threads.append(reply.id)
2018-06-22 17:29:06 -05:00
while reply is not None:
in_reply_to = reply.inReplyTo
if not in_reply_to:
break
root_reply = in_reply_to
reply = ap.fetch_remote_activity(root_reply, expected=ap.ActivityType.NOTE)
q = {"activity.object.id": root_reply}
2018-06-29 15:16:26 -05:00
if not DB.activities.count(q):
self.save(Box.REPLIES, reply)
2018-06-22 17:29:06 -05:00
new_threads.append(reply.id)
2018-06-29 15:16:26 -05:00
DB.activities.update_one(
{"remote_id": create.id}, {"$set": {"meta.thread_root_parent": root_reply}}
)
DB.activities.update(
{"box": Box.REPLIES.value, "remote_id": {"$in": new_threads}},
2018-06-22 17:29:06 -05:00
{"$set": {"meta.thread_root_parent": root_reply}},
)
2018-06-17 13:51:23 -05:00
2018-05-18 13:41:41 -05:00
def gen_feed():
fg = FeedGenerator()
2018-06-16 14:24:53 -05:00
fg.id(f"{ID}")
fg.title(f"{USERNAME} notes")
fg.author({"name": USERNAME, "email": "t@a4.io"})
fg.link(href=ID, rel="alternate")
fg.description(f"{USERNAME} notes")
fg.logo(ME.get("icon", {}).get("url"))
fg.language("en")
2018-06-29 15:16:26 -05:00
for item in DB.activities.find(
{"box": Box.OUTBOX.value, "type": "Create"}, limit=50
):
2018-05-18 13:41:41 -05:00
fe = fg.add_entry()
2018-06-16 14:24:53 -05:00
fe.id(item["activity"]["object"].get("url"))
fe.link(href=item["activity"]["object"].get("url"))
fe.title(item["activity"]["object"]["content"])
fe.description(item["activity"]["object"]["content"])
2018-05-18 13:41:41 -05:00
return fg
def json_feed(path: str) -> Dict[str, Any]:
"""JSON Feed (https://jsonfeed.org/) document."""
data = []
2018-06-29 15:16:26 -05:00
for item in DB.activities.find(
{"box": Box.OUTBOX.value, "type": "Create"}, limit=50
):
2018-06-16 14:24:53 -05:00
data.append(
{
"id": item["id"],
"url": item["activity"]["object"].get("url"),
"content_html": item["activity"]["object"]["content"],
"content_text": html2text(item["activity"]["object"]["content"]),
"date_published": item["activity"]["object"].get("published"),
}
)
2018-05-18 13:41:41 -05:00
return {
"version": "https://jsonfeed.org/version/1",
2018-06-16 14:24:53 -05:00
"user_comment": (
"This is a microblog feed. You can add this to your feed reader using the following URL: "
+ ID
+ path
),
2018-05-18 13:41:41 -05:00
"title": USERNAME,
"home_page_url": ID,
"feed_url": ID + path,
"author": {
"name": USERNAME,
"url": ID,
2018-06-16 14:24:53 -05:00
"avatar": ME.get("icon", {}).get("url"),
2018-05-18 13:41:41 -05:00
},
"items": data,
}
2018-06-16 14:24:53 -05:00
def build_inbox_json_feed(
path: str, request_cursor: Optional[str] = None
) -> Dict[str, Any]:
2018-06-21 17:55:50 -05:00
"""Build a JSON feed from the inbox activities."""
2018-05-18 13:41:41 -05:00
data = []
cursor = None
2018-06-29 15:16:26 -05:00
q: Dict[str, Any] = {
"type": "Create",
"meta.deleted": False,
"box": Box.INBOX.value,
}
2018-05-18 13:41:41 -05:00
if request_cursor:
2018-06-16 14:24:53 -05:00
q["_id"] = {"$lt": request_cursor}
2018-06-29 15:16:26 -05:00
for item in DB.activities.find(q, limit=50).sort("_id", -1):
2018-06-16 14:24:53 -05:00
actor = ap.get_backend().fetch_iri(item["activity"]["actor"])
data.append(
{
"id": item["activity"]["id"],
"url": item["activity"]["object"].get("url"),
"content_html": item["activity"]["object"]["content"],
"content_text": html2text(item["activity"]["object"]["content"]),
"date_published": item["activity"]["object"].get("published"),
"author": {
"name": actor.get("name", actor.get("preferredUsername")),
"url": actor.get("url"),
"avatar": actor.get("icon", {}).get("url"),
},
}
)
cursor = str(item["_id"])
2018-05-18 13:41:41 -05:00
resp = {
"version": "https://jsonfeed.org/version/1",
2018-06-16 14:24:53 -05:00
"title": f"{USERNAME}'s stream",
2018-05-18 13:41:41 -05:00
"home_page_url": ID,
"feed_url": ID + path,
"items": data,
}
if cursor and len(data) == 50:
2018-06-16 14:24:53 -05:00
resp["next_url"] = ID + path + "?cursor=" + cursor
2018-05-18 13:41:41 -05:00
return resp
2018-06-16 14:24:53 -05:00
def parse_collection(
payload: Optional[Dict[str, Any]] = None, url: Optional[str] = None
) -> List[str]:
2018-05-18 13:41:41 -05:00
"""Resolve/fetch a `Collection`/`OrderedCollection`."""
# Resolve internal collections via MongoDB directly
2018-06-16 14:24:53 -05:00
if url == ID + "/followers":
return [doc["remote_actor"] for doc in DB.followers.find()]
elif url == ID + "/following":
return [doc["remote_actor"] for doc in DB.following.find()]
2018-05-18 13:41:41 -05:00
# Go through all the pages
2018-06-16 14:24:53 -05:00
return ap_parse_collection(payload, url)
2018-05-18 13:41:41 -05:00
def embed_collection(total_items, first_page_id):
2018-06-21 17:55:50 -05:00
"""Helper creating a root OrderedCollection with a link to the first page."""
2018-05-28 12:46:23 -05:00
return {
2018-06-16 14:24:53 -05:00
"type": ap.ActivityType.ORDERED_COLLECTION.value,
"totalItems": total_items,
2018-06-16 14:24:53 -05:00
"first": f"{first_page_id}?page=first",
2018-06-01 13:29:44 -05:00
"id": first_page_id,
2018-05-28 12:46:23 -05:00
}
2018-06-16 14:24:53 -05:00
def build_ordered_collection(
col, q=None, cursor=None, map_func=None, limit=50, col_name=None, first_page=False
):
2018-06-21 17:55:50 -05:00
"""Helper for building an OrderedCollection from a MongoDB query (with pagination support)."""
2018-05-18 13:41:41 -05:00
col_name = col_name or col.name
if q is None:
q = {}
if cursor:
2018-06-16 14:24:53 -05:00
q["_id"] = {"$lt": ObjectId(cursor)}
data = list(col.find(q, limit=limit).sort("_id", -1))
2018-05-18 13:41:41 -05:00
if not data:
return {
2018-06-16 14:24:53 -05:00
"id": BASE_URL + "/" + col_name,
"totalItems": 0,
"type": ap.ActivityType.ORDERED_COLLECTION.value,
"orederedItems": [],
2018-05-18 13:41:41 -05:00
}
2018-06-16 14:24:53 -05:00
start_cursor = str(data[0]["_id"])
next_page_cursor = str(data[-1]["_id"])
2018-05-18 13:41:41 -05:00
total_items = col.find(q).count()
data = [_remove_id(doc) for doc in data]
if map_func:
data = [map_func(doc) for doc in data]
2018-06-04 12:13:04 -05:00
2018-05-18 13:41:41 -05:00
# No cursor, this is the first page and we return an OrderedCollection
if not cursor:
resp = {
2018-06-16 14:24:53 -05:00
"@context": ap.COLLECTION_CTX,
"id": f"{BASE_URL}/{col_name}",
"totalItems": total_items,
"type": ap.ActivityType.ORDERED_COLLECTION.value,
"first": {
"id": f"{BASE_URL}/{col_name}?cursor={start_cursor}",
"orderedItems": data,
"partOf": f"{BASE_URL}/{col_name}",
"totalItems": total_items,
"type": ap.ActivityType.ORDERED_COLLECTION_PAGE.value,
},
2018-05-18 13:41:41 -05:00
}
if len(data) == limit:
2018-06-16 14:24:53 -05:00
resp["first"]["next"] = (
BASE_URL + "/" + col_name + "?cursor=" + next_page_cursor
)
2018-05-18 13:41:41 -05:00
2018-06-01 13:29:44 -05:00
if first_page:
2018-06-16 14:24:53 -05:00
return resp["first"]
2018-06-01 13:29:44 -05:00
2018-05-18 13:41:41 -05:00
return resp
# If there's a cursor, then we return an OrderedCollectionPage
resp = {
2018-06-16 14:24:53 -05:00
"@context": ap.COLLECTION_CTX,
"type": ap.ActivityType.ORDERED_COLLECTION_PAGE.value,
"id": BASE_URL + "/" + col_name + "?cursor=" + start_cursor,
"totalItems": total_items,
"partOf": BASE_URL + "/" + col_name,
"orderedItems": data,
2018-05-18 13:41:41 -05:00
}
if len(data) == limit:
2018-06-16 14:24:53 -05:00
resp["next"] = BASE_URL + "/" + col_name + "?cursor=" + next_page_cursor
2018-05-18 13:41:41 -05:00
2018-06-01 13:29:44 -05:00
if first_page:
2018-06-16 14:24:53 -05:00
return resp["first"]
2018-06-01 13:29:44 -05:00
# XXX(tsileo): implements prev with prev=<first item cursor>?
2018-05-18 13:41:41 -05:00
return resp