kopia lustrzana https://dev.funkwhale.audio/funkwhale/funkwhale
209 wiersze
5.7 KiB
Python
209 wiersze
5.7 KiB
Python
import uuid
|
|
|
|
from funkwhale_api.common import utils as funkwhale_utils
|
|
|
|
PUBLIC_ADDRESS = "https://www.w3.org/ns/activitystreams#Public"
|
|
|
|
ACTIVITY_TYPES = [
|
|
"Accept",
|
|
"Add",
|
|
"Announce",
|
|
"Arrive",
|
|
"Block",
|
|
"Create",
|
|
"Delete",
|
|
"Dislike",
|
|
"Flag",
|
|
"Follow",
|
|
"Ignore",
|
|
"Invite",
|
|
"Join",
|
|
"Leave",
|
|
"Like",
|
|
"Listen",
|
|
"Move",
|
|
"Offer",
|
|
"Question",
|
|
"Reject",
|
|
"Read",
|
|
"Remove",
|
|
"TentativeReject",
|
|
"TentativeAccept",
|
|
"Travel",
|
|
"Undo",
|
|
"Update",
|
|
"View",
|
|
]
|
|
|
|
|
|
OBJECT_TYPES = [
|
|
"Article",
|
|
"Audio",
|
|
"Collection",
|
|
"Document",
|
|
"Event",
|
|
"Image",
|
|
"Note",
|
|
"OrderedCollection",
|
|
"Page",
|
|
"Place",
|
|
"Profile",
|
|
"Relationship",
|
|
"Tombstone",
|
|
"Video",
|
|
] + ACTIVITY_TYPES
|
|
|
|
|
|
def deliver(activity, on_behalf_of, to=[]):
|
|
from . import tasks
|
|
|
|
return tasks.send.delay(activity=activity, actor_id=on_behalf_of.pk, to=to)
|
|
|
|
|
|
def accept_follow(follow):
|
|
from . import serializers
|
|
|
|
serializer = serializers.AcceptFollowSerializer(follow)
|
|
return deliver(serializer.data, to=[follow.actor.fid], on_behalf_of=follow.target)
|
|
|
|
|
|
def receive(activity, on_behalf_of):
|
|
from . import models
|
|
from . import serializers
|
|
from . import tasks
|
|
|
|
# we ensure the activity has the bare minimum structure before storing
|
|
# it in our database
|
|
serializer = serializers.BaseActivitySerializer(
|
|
data=activity, context={"actor": on_behalf_of, "local_recipients": True}
|
|
)
|
|
serializer.is_valid(raise_exception=True)
|
|
copy = serializer.save()
|
|
# we create inbox items for further delivery
|
|
items = [
|
|
models.InboxItem(activity=copy, actor=r, type="to")
|
|
for r in serializer.validated_data["recipients"]["to"]
|
|
if hasattr(r, "fid")
|
|
]
|
|
items += [
|
|
models.InboxItem(activity=copy, actor=r, type="cc")
|
|
for r in serializer.validated_data["recipients"]["cc"]
|
|
if hasattr(r, "fid")
|
|
]
|
|
models.InboxItem.objects.bulk_create(items)
|
|
# at this point, we have the activity in database. Even if we crash, it's
|
|
# okay, as we can retry later
|
|
tasks.dispatch_inbox.delay(activity_id=copy.pk)
|
|
return copy
|
|
|
|
|
|
class Router:
|
|
def __init__(self):
|
|
self.routes = []
|
|
|
|
def connect(self, route, handler):
|
|
self.routes.append((route, handler))
|
|
|
|
def register(self, route):
|
|
def decorator(handler):
|
|
self.connect(route, handler)
|
|
return handler
|
|
|
|
return decorator
|
|
|
|
|
|
class InboxRouter(Router):
|
|
def dispatch(self, payload, context):
|
|
"""
|
|
Receives an Activity payload and some context and trigger our
|
|
business logic
|
|
"""
|
|
for route, handler in self.routes:
|
|
if match_route(route, payload):
|
|
return handler(payload, context=context)
|
|
|
|
|
|
class OutboxRouter(Router):
|
|
def dispatch(self, routing, context):
|
|
"""
|
|
Receives a routing payload and some business objects in the context
|
|
and may yield data that should be persisted in the Activity model
|
|
for further delivery.
|
|
"""
|
|
from . import models
|
|
from . import tasks
|
|
|
|
for route, handler in self.routes:
|
|
if match_route(route, routing):
|
|
activities_data = []
|
|
for e in handler(context):
|
|
# a route can yield zero, one or more activity payloads
|
|
if e:
|
|
activities_data.append(e)
|
|
|
|
inbox_items_by_activity_uuid = {}
|
|
prepared_activities = []
|
|
for activity_data in activities_data:
|
|
to = activity_data.pop("to", [])
|
|
cc = activity_data.pop("cc", [])
|
|
a = models.Activity(**activity_data)
|
|
a.uuid = uuid.uuid4()
|
|
to_items, new_to = prepare_inbox_items(to, "to")
|
|
cc_items, new_cc = prepare_inbox_items(cc, "cc")
|
|
if not to_items and not cc_items:
|
|
continue
|
|
inbox_items_by_activity_uuid[str(a.uuid)] = to_items + cc_items
|
|
if new_to:
|
|
a.payload["to"] = new_to
|
|
if new_cc:
|
|
a.payload["cc"] = new_cc
|
|
prepared_activities.append(a)
|
|
|
|
activities = models.Activity.objects.bulk_create(prepared_activities)
|
|
activities = [a for a in activities if a]
|
|
|
|
final_inbox_items = []
|
|
for a in activities:
|
|
try:
|
|
prepared_inbox_items = inbox_items_by_activity_uuid[str(a.uuid)]
|
|
except KeyError:
|
|
continue
|
|
|
|
for ii in prepared_inbox_items:
|
|
ii.activity = a
|
|
final_inbox_items.append(ii)
|
|
|
|
# create all inbox items, in bulk
|
|
models.InboxItem.objects.bulk_create(final_inbox_items)
|
|
|
|
for a in activities:
|
|
funkwhale_utils.on_commit(
|
|
tasks.dispatch_outbox.delay, activity_id=a.pk
|
|
)
|
|
return activities
|
|
|
|
|
|
def match_route(route, payload):
|
|
for key, value in route.items():
|
|
if payload.get(key) != value:
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
def prepare_inbox_items(recipient_list, type):
|
|
from . import models
|
|
|
|
items = []
|
|
new_list = [] # we return a list of actors url instead
|
|
|
|
for r in recipient_list:
|
|
if r != PUBLIC_ADDRESS:
|
|
item = models.InboxItem(actor=r, type=type)
|
|
items.append(item)
|
|
new_list.append(r.fid)
|
|
else:
|
|
new_list.append(r)
|
|
|
|
return items, new_list
|