class UploadActionSerializer(common_serializers.ActionSerializer):
actions = [
common_serializers.Action("delete", allow_all=True),
common_serializers.Action("relaunch_import", allow_all=True),
]
filterset_class = filters.UploadFilter
pk_field = "uuid"
@transaction.atomic
def handle_delete(self, objects):
libraries = sorted(set(objects.values_list("library", flat=True)))
for id in libraries:
# we group deletes by library for easier federation
uploads = objects.filter(
library__pk=id).select_related("library__actor")
for chunk in common_utils.chunk_queryset(uploads, 100):
routes.outbox.dispatch(
{
"type": "Delete",
"object": {
"type": "Audio"
}
},
context={"uploads": chunk},
)
return objects.delete()
@transaction.atomic
def handle_relaunch_import(self, objects):
qs = objects.exclude(import_status="finished")
pks = list(qs.values_list("id", flat=True))
qs.update(import_status="pending")
for pk in pks:
common_utils.on_commit(tasks.process_upload.delay, upload_id=pk)
class TestDangerousSerializer(serializers.ActionSerializer):
actions = [
serializers.Action("test", allow_all=True),
serializers.Action("test_dangerous"),
]
def handle_test(self, objects):
pass
def handle_test_dangerous(self, objects):
pass
class ManageUploadActionSerializer(common_serializers.ActionSerializer):
actions = [common_serializers.Action("delete", allow_all=False)]
filterset_class = filters.ManageUploadFilterSet
@transaction.atomic
def handle_delete(self, objects):
return objects.delete()
class ManageActorActionSerializer(common_serializers.ActionSerializer):
actions = [common_serializers.Action("purge", allow_all=False)]
filterset_class = filters.ManageActorFilterSet
@transaction.atomic
def handle_purge(self, objects):
ids = objects.values_list("id", flat=True)
common_utils.on_commit(federation_tasks.purge_actors.delay,
ids=list(ids))
class TestDeleteOnlyInactiveSerializer(serializers.ActionSerializer):
actions = [
serializers.Action("test",
allow_all=True,
qs_filter=lambda qs: qs.filter(is_active=False))
]
filterset_class = TestActionFilterSet
def handle_test(self, objects):
pass
class ManageInvitationActionSerializer(common_serializers.ActionSerializer):
actions = [
common_serializers.Action("delete",
allow_all=False,
qs_filter=lambda qs: qs.open())
]
filterset_class = filters.ManageInvitationFilterSet
@transaction.atomic
def handle_delete(self, objects):
return objects.delete()
class ManageDomainActionSerializer(common_serializers.ActionSerializer):
actions = [
common_serializers.Action("purge", allow_all=False),
common_serializers.Action("allow_list_add", allow_all=True),
common_serializers.Action("allow_list_remove", allow_all=True),
]
filterset_class = filters.ManageDomainFilterSet
pk_field = "name"
@transaction.atomic
def handle_purge(self, objects):
ids = objects.values_list("pk", flat=True).order_by("pk")
common_utils.on_commit(federation_tasks.purge_actors.delay,
domains=list(ids))
@transaction.atomic
def handle_allow_list_add(self, objects):
objects.update(allowed=True)
@transaction.atomic
def handle_allow_list_remove(self, objects):
objects.update(allowed=False)
class TestSerializer(serializers.ActionSerializer):
actions = [serializers.Action("test", allow_all=True)]
filterset_class = TestActionFilterSet
def handle_test(self, objects):
return {"hello": "world"}
class InboxItemActionSerializer(common_serializers.ActionSerializer):
actions = [common_serializers.Action("read", allow_all=True)]
filterset_class = filters.InboxItemFilter
def handle_read(self, objects):
return objects.update(is_read=True)
