api/funkwhale_api/contrib/maloja/funkwhale_startup.py

+from config import plugins
+
+PLUGIN = plugins.get_plugin_config(
+    name="maloja",
+    label="Maloja",
+    description="A plugin that allows you to submit your listens to your Maloja server.",
+    homepage="https://docs.funkwhale.audio/users/builtinplugins.html#maloja-plugin",
+    version="0.2",
+    user=True,
+    conf=[
+        {"name": "server_url", "type": "text", "label": "Maloja server URL"},
+        {"name": "api_key", "type": "text", "label": "Your Maloja API key"},
+        {
+            "name": "nofix",
+            "type": "boolean",
+            "label": "Skip server-side metadata fixing",
+            "default": False,
+        },
+    ],
+)

api/funkwhale_api/contrib/scrobbler/funkwhale_ready.py

 import hashlib
 
 from config import plugins
-from .funkwhale_startup import PLUGIN
 
 from . import scrobbler
+from .funkwhale_startup import PLUGIN
 
 # https://listenbrainz.org/lastfm-proxy
 DEFAULT_SCROBBLER_URL = "http://post.audioscrobbler.com"
@@ -29,7 +29,7 @@ def forward_to_scrobblers(listening, conf, **kwargs):
                 (username + " " + password).encode("utf-8")
             ).hexdigest()
             cache_key = "lastfm:sessionkey:{}".format(
-                ":".join([str(listening.user.pk), hashed_auth])
+                ":".join([str(listening.actor.pk), hashed_auth])
             )
             PLUGIN["logger"].info("Forwarding scrobble to %s", LASTFM_SCROBBLER_URL)
             session_key = PLUGIN["cache"].get(cache_key)

api/funkwhale_api/contrib/scrobbler/funkwhale_startup.py

@@ -7,7 +7,7 @@ PLUGIN = plugins.get_plugin_config(
         "A plugin that enables scrobbling to ListenBrainz and Last.fm. "
         "It must be configured on the server if you use Last.fm."
     ),
-    homepage="https://dev.funkwhale.audio/funkwhale/funkwhale/-/blob/develop/api/funkwhale_api/contrib/scrobbler/README.rst",  # noqa
+    homepage="https://docs.funkwhale.audio/users/builtinplugins.html#scrobbler-plugin",  # noqa
     version="0.1",
     user=True,
     conf=[

api/funkwhale_api/contrib/scrobbler/scrobbler.py

 import hashlib
 import time
 
-
 # https://github.com/jlieth/legacy-scrobbler
 from .funkwhale_startup import PLUGIN
 
@@ -17,7 +16,7 @@ def handshake_v1(session, url, username, password):
     params = {
         "hs": "true",
         "p": "1.2",
-        "c": PLUGIN["name"],
+        "c": "fw",
         "v": PLUGIN["version"],
         "u": username,
         "t": timestamp,
@@ -60,7 +59,7 @@ def submit_scrobble_v1(session, scrobble_time, track, session_key, scrobble_url)
     else:
         raise ScrobblerException(response.text)
 
-    PLUGIN["logger"].debug("Scrobble successfull!")
+    PLUGIN["logger"].debug("Scrobble successful!")
 
 
 def submit_now_playing_v1(session, track, session_key, now_playing_url):
@@ -76,7 +75,7 @@ def submit_now_playing_v1(session, track, session_key, now_playing_url):
     else:
         raise ScrobblerException(response.text)
 
-    PLUGIN["logger"].debug("Now playing successfull!")
+    PLUGIN["logger"].debug("Now playing successful!")
 
 
 def get_scrobble_payload(track, date, suffix="[0]"):
@@ -85,16 +84,16 @@ def get_scrobble_payload(track, date, suffix="[0]"):
     """
     upload = track.uploads.filter(duration__gte=0).first()
     data = {
-        "a{}".format(suffix): track.artist.name,
-        "t{}".format(suffix): track.title,
-        "l{}".format(suffix): upload.duration if upload else 0,
-        "b{}".format(suffix): (track.album.title if track.album else "") or "",
-        "n{}".format(suffix): track.position or "",
-        "m{}".format(suffix): str(track.mbid) or "",
-        "o{}".format(suffix): "P",  # Source: P = chosen by user
+        f"a{suffix}": track.get_artist_credit_string,
+        f"t{suffix}": track.title,
+        f"l{suffix}": upload.duration if upload else 0,
+        f"b{suffix}": (track.album.title if track.album else "") or "",
+        f"n{suffix}": track.position or "",
+        f"m{suffix}": str(track.mbid or ""),
+        f"o{suffix}": "P",  # Source: P = chosen by user
     }
     if date:
-        data["i{}".format(suffix)] = int(date.timestamp())
+        data[f"i{suffix}"] = int(date.timestamp())
     return data
 
 
@@ -104,7 +103,7 @@ def get_scrobble2_payload(track, date, suffix="[0]"):
     """
     upload = track.uploads.filter(duration__gte=0).first()
     data = {
-        "artist": track.artist.name,
+        "artist": track.get_artist_credit_string,
         "track": track.title,
         "chosenByUser": 1,
     }
@@ -115,7 +114,7 @@ def get_scrobble2_payload(track, date, suffix="[0]"):
     if track.position:
         data["trackNumber"] = track.position
     if track.mbid:
-        data["mbid"] = str(track.mbid)
+        data["mbid"] = str(track.mbid or "")
     if date:
         offset = upload.duration / 2 if upload.duration else 0
         data["timestamp"] = int(int(date.timestamp()) - offset)
@@ -139,7 +138,13 @@ def handshake_v2(username, password, session, api_key, api_secret, scrobble_url)
 
 
 def submit_scrobble_v2(
-    session, track, scrobble_time, session_key, scrobble_url, api_key, api_secret,
+    session,
+    track,
+    scrobble_time,
+    session_key,
+    scrobble_url,
+    api_key,
+    api_secret,
 ):
     params = {
         "method": "track.scrobble",

api/funkwhale_api/contrib/sites/__init__.py

-# -*- coding: utf-8 -*-

api/funkwhale_api/contrib/sites/migrations/0004_alter_site_options.py

+# Generated by Django 3.2.4 on 2021-07-03 18:10
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sites', '0003_auto_20171214_2205'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='site',
+            options={'ordering': ['domain'], 'verbose_name': 'site', 'verbose_name_plural': 'sites'},
+        ),
+    ]

api/funkwhale_api/factories.py

+import random
 import uuid
+
 import factory
-import random
 import persisting_theory
-
 from django.conf import settings
-
 from faker.providers import internet as internet_provider
 
 
@@ -315,18 +314,21 @@ class FunkwhaleProvider(internet_provider.Provider):
     not random enough
     """
 
-    def federation_url(self, prefix="", local=False):
+    def federation_url(self, prefix="", obj_uuid=None, local=False):
+        if not obj_uuid:
+            obj_uuid = uuid.uuid4()
+
         def path_generator():
-            return "{}/{}".format(prefix, uuid.uuid4())
+            return f"{prefix}/{obj_uuid}"
 
         domain = settings.FEDERATION_HOSTNAME if local else self.domain_name()
         protocol = "https"
         path = path_generator()
-        return "{}://{}/{}".format(protocol, domain, path)
+        return f"{protocol}://{domain}/{path}"
 
     def user_name(self):
         u = super().user_name()
-        return "{}{}".format(u, random.randint(10, 999))
+        return f"{u}{random.randint(10, 999)}"
 
     def music_genre(self):
         return random.choice(TAGS_DATA["genre"])

api/funkwhale_api/favorites/activities.py

@@ -8,7 +8,7 @@ record.registry.register_serializer(serializers.TrackFavoriteActivitySerializer)
 
 @record.registry.register_consumer("favorites.TrackFavorite")
 def broadcast_track_favorite_to_instance_activity(data, obj):
-    if obj.user.privacy_level not in ["instance", "everyone"]:
+    if obj.actor.user.privacy_level not in ["instance", "everyone"]:
         return
 
     channels.group_send(

api/funkwhale_api/favorites/admin.py

@@ -5,5 +5,5 @@ from . import models
 
 @admin.register(models.TrackFavorite)
 class TrackFavoriteAdmin(admin.ModelAdmin):
-    list_display = ["user", "track", "creation_date"]
-    list_select_related = ["user", "track"]
+    list_display = ["actor", "track", "creation_date"]
+    list_select_related = ["actor", "track"]

api/funkwhale_api/favorites/factories.py

 import factory
+from django.conf import settings
 
-from funkwhale_api.factories import registry, NoUpdateOnCreate
+from funkwhale_api.factories import NoUpdateOnCreate, registry
+from funkwhale_api.federation import models
+from funkwhale_api.federation.factories import ActorFactory
 from funkwhale_api.music.factories import TrackFactory
-from funkwhale_api.users.factories import UserFactory
 
 
 @registry.register
 class TrackFavorite(NoUpdateOnCreate, factory.django.DjangoModelFactory):
     track = factory.SubFactory(TrackFactory)
-    user = factory.SubFactory(UserFactory)
+    actor = factory.SubFactory(ActorFactory)
+    fid = factory.Faker("federation_url")
+    uuid = factory.Faker("uuid4")
 
     class Meta:
         model = "favorites.TrackFavorite"
+
+    @factory.post_generation
+    def local(self, create, extracted, **kwargs):
+        if not extracted and not kwargs:
+            return
+        domain = models.Domain.objects.get_or_create(name=settings.FEDERATION_HOSTNAME)[
+            0
+        ]
+        self.fid = f"https://{domain}/federation/music/favorite/{self.uuid}"
+        self.save(update_fields=["fid"])

api/funkwhale_api/favorites/filters.py

@@ -9,7 +9,7 @@ class TrackFavoriteFilter(moderation_filters.HiddenContentFilterSet):
     q = fields.SearchFilter(
         search_fields=["track__title", "track__artist__name", "track__album__title"]
     )
-    scope = common_filters.ActorScopeFilter(actor_field="user__actor", distinct=True)
+    scope = common_filters.ActorScopeFilter(actor_field="actor", distinct=True)
 
     class Meta:
         model = models.TrackFavorite

api/funkwhale_api/favorites/migrations/0002_trackfavorite_source.py

+# Generated by Django 3.2.20 on 2023-12-09 14:25
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('favorites', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='trackfavorite',
+            name='source',
+            field=models.CharField(blank=True, max_length=100, null=True),
+        ),
+    ]

api/funkwhale_api/favorites/migrations/0003_trackfavorite_actor_trackfavorite_fid_and_more.py

+# Generated by Django 4.2.9 on 2024-03-28 23:32
+
+import uuid
+
+from django.db import migrations, models, transaction
+import django.db.models.deletion
+
+from django.conf import settings
+
+from funkwhale_api.federation import utils
+from django.urls import reverse
+
+
+def gen_uuid(apps, schema_editor):
+    MyModel = apps.get_model("favorites", "TrackFavorite")
+    for row in MyModel.objects.all():
+        unique_uuid = uuid.uuid4()
+        while MyModel.objects.filter(uuid=unique_uuid).exists():
+            unique_uuid = uuid.uuid4()
+
+        fid = utils.full_url(
+            reverse("federation:music:likes-detail", kwargs={"uuid": unique_uuid})
+        )
+        row.uuid = unique_uuid
+        row.fid = fid
+        row.save(update_fields=["uuid", "fid"])
+
+
+def get_user_actor(apps, schema_editor):
+    MyModel = apps.get_model("favorites", "TrackFavorite")
+    for row in MyModel.objects.all():
+        actor = row.user.actor
+        row.actor = actor
+        row.save(update_fields=["actor"])
+
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("favorites", "0002_trackfavorite_source"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="trackfavorite",
+            name="actor",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="track_favorites",
+                to="federation.actor",
+            ),
+        ),
+        migrations.AddField(
+            model_name="trackfavorite",
+            name="fid",
+            field=models.URLField(default="https://default.fid"),
+            preserve_default=False,
+        ),
+        migrations.AddField(
+            model_name="trackfavorite",
+            name="url",
+            field=models.URLField(blank=True, max_length=500, null=True),
+        ),
+        migrations.AddField(
+            model_name="trackfavorite",
+            name="uuid",
+            field=models.UUIDField(null=True),
+        ),
+        migrations.RunPython(gen_uuid, reverse_code=migrations.RunPython.noop),
+        migrations.AlterField(
+            model_name="trackfavorite",
+            name="uuid",
+            field=models.UUIDField(default=uuid.uuid4, unique=True, null=False),
+        ),
+        migrations.AlterField(
+            model_name="trackfavorite",
+            name="fid",
+            field=models.URLField(
+                db_index=True,
+                max_length=500,
+                unique=True,
+            ),
+        ),
+        migrations.RunPython(get_user_actor, reverse_code=migrations.RunPython.noop),
+        migrations.AlterField(
+            model_name="trackfavorite",
+            name="actor",
+            field=models.ForeignKey(
+                blank=False,
+                null=False,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="track_favorites",
+                to="federation.actor",
+            ),      ),
+        migrations.AlterUniqueTogether(
+            name="trackfavorite",
+            unique_together={("track", "actor")},
+        ),
+        migrations.RemoveField(
+            model_name="trackfavorite",
+            name="user",
+        ),
+
+    ]

api/funkwhale_api/favorites/models.py

+import uuid
+
 from django.db import models
+from django.urls import reverse
 from django.utils import timezone
 
+from funkwhale_api.common import fields
+from funkwhale_api.common import models as common_models
+from funkwhale_api.federation import models as federation_models
+from funkwhale_api.federation import utils as federation_utils
 from funkwhale_api.music.models import Track
 
+FAVORITE_PRIVACY_LEVEL_CHOICES = [
+    (k, l) for k, l in fields.PRIVACY_LEVEL_CHOICES if k != "followers"
+]
+
+
+class TrackFavoriteQuerySet(models.QuerySet, common_models.LocalFromFidQuerySet):
+    def viewable_by(self, actor):
+        if actor is None:
+            return self.filter(actor__user__privacy_level="everyone")
+
+        if hasattr(actor, "user"):
+            me_query = models.Q(actor__user__privacy_level="me", actor=actor)
+        me_query = models.Q(actor__user__privacy_level="me", actor=actor)
+
+        instance_query = models.Q(
+            actor__user__privacy_level="instance", actor__domain=actor.domain
+        )
+        instance_actor_query = models.Q(
+            actor__user__privacy_level="instance", actor__domain=actor.domain
+        )
+
+        return self.filter(
+            me_query
+            | instance_query
+            | instance_actor_query
+            | models.Q(actor__user__privacy_level="everyone")
+        )
+
 
-class TrackFavorite(models.Model):
+class TrackFavorite(federation_models.FederationMixin):
+    uuid = models.UUIDField(default=uuid.uuid4, unique=True)
     creation_date = models.DateTimeField(default=timezone.now)
-    user = models.ForeignKey(
-        "users.User", related_name="track_favorites", on_delete=models.CASCADE
+    actor = models.ForeignKey(
+        "federation.Actor",
+        related_name="track_favorites",
+        on_delete=models.CASCADE,
+        null=False,
+        blank=False,
     )
     track = models.ForeignKey(
         Track, related_name="track_favorites", on_delete=models.CASCADE
     )
+    source = models.CharField(max_length=100, null=True, blank=True)
+
+    federation_namespace = "likes"
+    objects = TrackFavoriteQuerySet.as_manager()
 
     class Meta:
-        unique_together = ("track", "user")
+        unique_together = ("track", "actor")
+
         ordering = ("-creation_date",)
 
     @classmethod
-    def add(cls, track, user):
-        favorite, created = cls.objects.get_or_create(user=user, track=track)
+    def add(cls, track, actor):
+        favorite, created = cls.objects.get_or_create(actor=actor, track=track)
         return favorite
 
     def get_activity_url(self):
-        return "{}/favorites/tracks/{}".format(self.user.get_activity_url(), self.pk)
+        return f"{self.actor.get_absolute_url()}/favorites/tracks/{self.pk}"
+
+    def get_absolute_url(self):
+        return f"/library/tracks/{self.track.pk}"
+
+    def get_federation_id(self):
+        if self.fid:
+            return self.fid
+
+        return federation_utils.full_url(
+            reverse(
+                f"federation:music:{self.federation_namespace}-detail",
+                kwargs={"uuid": self.uuid},
+            )
+        )
+
+    def save(self, **kwargs):
+        if not self.pk and not self.fid:
+            self.fid = self.get_federation_id()
+
+        return super().save(**kwargs)

api/funkwhale_api/favorites/serializers.py

@@ -3,7 +3,6 @@ from rest_framework import serializers
 from funkwhale_api.activity import serializers as activity_serializers
 from funkwhale_api.federation import serializers as federation_serializers
 from funkwhale_api.music.serializers import TrackActivitySerializer, TrackSerializer
-from funkwhale_api.users.serializers import UserActivitySerializer, UserBasicSerializer
 
 from . import models
 
@@ -11,37 +10,40 @@ from . import models
 class TrackFavoriteActivitySerializer(activity_serializers.ModelSerializer):
     type = serializers.SerializerMethodField()
     object = TrackActivitySerializer(source="track")
-    actor = UserActivitySerializer(source="user")
+    actor = federation_serializers.APIActorSerializer(read_only=True)
     published = serializers.DateTimeField(source="creation_date")
 
     class Meta:
         model = models.TrackFavorite
         fields = ["id", "local_id", "object", "type", "actor", "published"]
 
-    def get_actor(self, obj):
-        return UserActivitySerializer(obj.user).data
-
     def get_type(self, obj):
         return "Like"
 
 
 class UserTrackFavoriteSerializer(serializers.ModelSerializer):
     track = TrackSerializer(read_only=True)
-    user = UserBasicSerializer(read_only=True)
-    actor = serializers.SerializerMethodField()
+    actor = federation_serializers.APIActorSerializer(read_only=True)
 
     class Meta:
         model = models.TrackFavorite
-        fields = ("id", "user", "track", "creation_date", "actor")
-        actor = serializers.SerializerMethodField()
-
-    def get_actor(self, obj):
-        actor = obj.user.actor
-        if actor:
-            return federation_serializers.APIActorSerializer(actor).data
+        fields = ("id", "actor", "track", "creation_date", "actor")
 
 
 class UserTrackFavoriteWriteSerializer(serializers.ModelSerializer):
     class Meta:
         model = models.TrackFavorite
         fields = ("id", "track", "creation_date")
+
+
+class SimpleFavoriteSerializer(serializers.Serializer):
+    id = serializers.IntegerField()
+    track = serializers.IntegerField()
+
+
+class AllFavoriteSerializer(serializers.Serializer):
+    results = SimpleFavoriteSerializer(many=True, source="*")
+    count = serializers.SerializerMethodField()
+
+    def get_count(self, o) -> int:
+        return len(o)

api/funkwhale_api/favorites/views.py

+from django.db.models import Prefetch
+from drf_spectacular.utils import extend_schema
 from rest_framework import mixins, status, viewsets
 from rest_framework.decorators import action
 from rest_framework.response import Response
 
-from django.db.models import Prefetch
-
+from config import plugins
 from funkwhale_api.activity import record
 from funkwhale_api.common import fields, permissions
-from funkwhale_api.music.models import Track
+from funkwhale_api.federation import routes
 from funkwhale_api.music import utils as music_utils
+from funkwhale_api.music.models import Track
 from funkwhale_api.users.oauth import permissions as oauth_permissions
 
 from . import filters, models, serializers
@@ -19,11 +21,10 @@ class TrackFavoriteViewSet(
     mixins.ListModelMixin,
     viewsets.GenericViewSet,
 ):
-
     filterset_class = filters.TrackFavoriteFilter
     serializer_class = serializers.UserTrackFavoriteSerializer
     queryset = models.TrackFavorite.objects.all().select_related(
-        "user__actor__attachment_icon"
+        "actor__attachment_icon"
     )
     permission_classes = [
         oauth_permissions.ScopePermission,
@@ -32,19 +33,34 @@ class TrackFavoriteViewSet(
     required_scope = "favorites"
     anonymous_policy = "setting"
     owner_checks = ["write"]
+    owner_field = "actor.user"
 
     def get_serializer_class(self):
         if self.request.method.lower() in ["head", "get", "options"]:
             return serializers.UserTrackFavoriteSerializer
         return serializers.UserTrackFavoriteWriteSerializer
 
+    @extend_schema(operation_id="favorite_track")
     def create(self, request, *args, **kwargs):
         serializer = self.get_serializer(data=request.data)
         serializer.is_valid(raise_exception=True)
         instance = self.perform_create(serializer)
         serializer = self.get_serializer(instance=instance)
         headers = self.get_success_headers(serializer.data)
+        plugins.trigger_hook(
+            plugins.FAVORITE_CREATED,
+            track_favorite=serializer.instance,
+            confs=plugins.get_confs(self.request.user),
+        )
         record.send(instance)
+        routes.outbox.dispatch(
+            {"type": "Like", "object": {"type": "Track"}},
+            context={
+                "track": instance.track,
+                "actor": instance.actor,
+                "id": instance.fid,
+            },
+        )
         return Response(
             serializer.data, status=status.HTTP_201_CREATED, headers=headers
         )
@@ -52,31 +68,56 @@ class TrackFavoriteViewSet(
     def get_queryset(self):
         queryset = super().get_queryset()
         queryset = queryset.filter(
-            fields.privacy_level_query(self.request.user, "user__privacy_level")
+            fields.privacy_level_query(
+                self.request.user, "actor__user__privacy_level", "actor__user"
+            )
         )
-        tracks = Track.objects.with_playable_uploads(
+        tracks = (
+            Track.objects.with_playable_uploads(
                 music_utils.get_actor_from_request(self.request)
-        ).select_related(
-            "artist", "album__artist", "attributed_to", "album__attachment_cover"
             )
+            .prefetch_related(
+                "artist_credit__artist",
+                "album__artist_credit__artist",
+            )
+            .select_related(
+                "attributed_to",
+                "album__attachment_cover",
+            )
+        )
+
         queryset = queryset.prefetch_related(Prefetch("track", queryset=tracks))
         return queryset
 
     def perform_create(self, serializer):
         track = Track.objects.get(pk=serializer.data["track"])
-        favorite = models.TrackFavorite.add(track=track, user=self.request.user)
+        favorite = models.TrackFavorite.add(track=track, actor=self.request.user.actor)
         return favorite
 
+    @extend_schema(operation_id="unfavorite_track")
     @action(methods=["delete", "post"], detail=False)
     def remove(self, request, *args, **kwargs):
         try:
             pk = int(request.data["track"])
-            favorite = request.user.track_favorites.get(track__pk=pk)
+            favorite = request.user.actor.track_favorites.get(track__pk=pk)
         except (AttributeError, ValueError, models.TrackFavorite.DoesNotExist):
             return Response({}, status=400)
+        routes.outbox.dispatch(
+            {"type": "Dislike", "object": {"type": "Track"}},
+            context={"favorite": favorite},
+        )
         favorite.delete()
+        plugins.trigger_hook(
+            plugins.FAVORITE_DELETED,
+            track_favorite=favorite,
+            confs=plugins.get_confs(self.request.user),
+        )
         return Response([], status=status.HTTP_204_NO_CONTENT)
 
+    @extend_schema(
+        responses=serializers.AllFavoriteSerializer(),
+        operation_id="get_all_favorite_tracks",
+    )
     @action(methods=["get"], detail=False)
     def all(self, request, *args, **kwargs):
         """
@@ -85,10 +126,11 @@ class TrackFavoriteViewSet(
         favorites status in the UI
         """
         if not request.user.is_authenticated:
-            return Response({"results": [], "count": 0}, status=200)
+            return Response({"results": [], "count": 0}, status=401)
 
-        favorites = list(
-            request.user.track_favorites.values("id", "track").order_by("id")
+        favorites = request.user.actor.track_favorites.values("id", "track").order_by(
+            "id"
         )
-        payload = {"results": favorites, "count": len(favorites)}
+        payload = serializers.AllFavoriteSerializer(favorites).data
+
         return Response(payload, status=200)

api/funkwhale_api/federation/activity.py

-import uuid
 import logging
 import urllib.parse
+import uuid
 
-from django.core.cache import cache
 from django.conf import settings
-from django.db import transaction, IntegrityError
+from django.core.cache import cache
+from django.db import IntegrityError, transaction
 from django.db.models import Q
 
 from funkwhale_api.common import channels
@@ -119,12 +119,14 @@ def should_reject(fid, actor_id=None, payload={}):
 
 @transaction.atomic
 def receive(activity, on_behalf_of, inbox_actor=None):
-    from . import models
-    from . import serializers
-    from . import tasks
-    from .routes import inbox
+    """
+    Receive an activity, find his recipients and save it to the database before dispatching it
+    """
     from funkwhale_api.moderation import mrf
 
+    from . import models, serializers, tasks
+    from .routes import inbox
+
     logger.debug(
         "[federation] Received activity from %s : %s", on_behalf_of.fid, activity
     )
@@ -181,7 +183,6 @@ def receive(activity, on_behalf_of, inbox_actor=None):
 
     inbox_items = []
     for recipients, type in [(local_to_recipients, "to"), (local_cc_recipients, "cc")]:
-
         for r in recipients:
             inbox_items.append(models.InboxItem(actor_id=r, type=type, activity=copy))
 
@@ -223,9 +224,11 @@ class InboxRouter(Router):
         call_handlers should be False when are delivering a local activity, because
         we want only want to bind activities to their recipients, not reapply the changes.
         """
-        from . import api_serializers
-        from . import models
+        from . import api_serializers, models
 
+        logger.debug(
+            f"[federation] Inbox dispatch payload : {payload} with context : {context}"
+        )
         handlers = self.get_matching_handlers(payload)
         for handler in handlers:
             if call_handlers:
@@ -243,8 +246,8 @@ class InboxRouter(Router):
                 for k in r.keys():
                     if k in ["object", "target", "related_object"]:
                         update_fields += [
-                            "{}_id".format(k),
-                            "{}_content_type".format(k),
+                            f"{k}_id",
+                            f"{k}_content_type",
                         ]
                     else:
                         update_fields.append(k)
@@ -266,7 +269,7 @@ class InboxRouter(Router):
                 user = ii.actor.get_user()
                 if not user:
                     continue
-                group = "user.{}.inbox".format(user.pk)
+                group = f"user.{user.pk}.inbox"
                 channels.group_send(
                     group,
                     {
@@ -296,6 +299,69 @@ def schedule_key_rotation(actor_id, delay):
     tasks.rotate_actor_key.apply_async(kwargs={"actor_id": actor_id}, countdown=delay)
 
 
+def activity_pass_user_privacy_level(context, routing):
+    TYPE_FOLLOW_USER_PRIVACY_LEVEL = ["Listen", "Like", "Create"]
+    TYPE_IGNORE_USER_PRIVACY_LEVEL = ["Delete", "Accept", "Follow"]
+    MUSIC_OBJECT_TYPE = ["Audio", "Track", "Album", "Artist"]
+
+    actor = context.get("actor", False)
+    type = routing.get("type", False)
+    object_type = routing.get("object", {}).get("type", None)
+
+    if not actor:
+        logger.warning(
+            "No actor provided in activity context : \
+                we cannot follow actor.privacy_level, activity will be sent by default."
+        )
+
+    # We do not consider music metadata has private
+    if object_type in MUSIC_OBJECT_TYPE:
+        return True
+
+    if type:
+        if type in TYPE_IGNORE_USER_PRIVACY_LEVEL:
+            return True
+        if type in TYPE_FOLLOW_USER_PRIVACY_LEVEL and actor and actor.is_local:
+            if actor.user.privacy_level in [
+                "me",
+                "instance",
+            ]:
+                return False
+
+            return True
+
+    return True
+
+
+def activity_pass_object_privacy_level(context, routing):
+    MUSIC_OBJECT_TYPE = ["Audio", "Track", "Album", "Artist"]
+
+    # we only support playlist federation for now (other objects follow user.privacy_level)
+    object = context.get("playlist", False)
+
+    obj_privacy_level = object.privacy_level if object else None
+    object_type = routing.get("object", {}).get("type", None)
+
+    # We do not consider music metadata has private
+    if object_type in MUSIC_OBJECT_TYPE:
+        return True
+    if routing["type"] == "Delete":
+        return True
+
+    if routing["type"] == "Update" and obj_privacy_level in ["me", "instance"]:
+        # we send a delete request instead
+        logger.debug(
+            "[federation] Object privacy level is me or instance, sending delete instead of update"
+        )
+        routing["type"] = "Delete"
+        return True
+
+    if object and obj_privacy_level and obj_privacy_level in ["me", "instance"]:
+        return False
+
+    return True
+
+
 class OutboxRouter(Router):
     @transaction.atomic
     def dispatch(self, routing, context):
@@ -305,9 +371,12 @@ class OutboxRouter(Router):
         for further delivery.
         """
         from funkwhale_api.common import preferences
-        from . import models
-        from . import tasks
 
+        from . import models, tasks
+
+        logger.debug(
+            f"[federation] Outbox dispatch context : {context} and routing : {routing}"
+        )
         allow_list_enabled = preferences.get("moderation__allow_list_enabled")
         allowed_domains = None
         if allow_list_enabled:
@@ -317,6 +386,18 @@ class OutboxRouter(Router):
                 )
             )
 
+        if activity_pass_user_privacy_level(context, routing) is False:
+            logger.info(
+                "[federation] Discarding outbox dispatch due to user privacy_level"
+            )
+            return
+
+        if activity_pass_object_privacy_level(context, routing) is False:
+            logger.info(
+                "[federation] Discarding outbox dispatch due to object privacy_level"
+            )
+            return
+
         for route, handler in self.routes:
             if not match_route(route, routing):
                 continue
@@ -400,6 +481,7 @@ class OutboxRouter(Router):
             )
 
             for a in activities:
+                logger.info(f"[federation] OUtbox sending activity : {a.pk}")
                 funkwhale_utils.on_commit(tasks.dispatch_outbox.delay, activity_id=a.pk)
             return activities
 
@@ -426,7 +508,7 @@ def is_allowed_url(url, allowed_domains):
 def prepare_deliveries_and_inbox_items(recipient_list, type, allowed_domains=None):
     """
     Given a list of recipients (
-        either actor instances, public adresses, a dictionnary with a "type" and "target"
+        either actor instances, public addresses, a dictionary with a "type" and "target"
         keys for followers collections)
     returns a list of deliveries, alist of inbox_items and a list
     of urls to persist in the activity in place of the initial recipient list.
@@ -557,12 +639,6 @@ def get_actors_from_audience(urls):
             final_query, Q(pk__in=actor_follows.values_list("actor", flat=True))
         )
 
-        library_follows = models.LibraryFollow.objects.filter(
-            queries["followed"], approved=True
-        )
-        final_query = funkwhale_utils.join_queries_or(
-            final_query, Q(pk__in=library_follows.values_list("actor", flat=True))
-        )
     if not final_query:
         return models.Actor.objects.none()
     return models.Actor.objects.filter(final_query)

api/funkwhale_api/federation/actors.py

@@ -15,13 +15,14 @@ logger = logging.getLogger(__name__)
 def get_actor_data(actor_url):
     logger.debug("Fetching actor %s", actor_url)
     response = session.get_session().get(
-        actor_url, headers={"Accept": "application/activity+json"},
+        actor_url,
+        headers={"Accept": "application/activity+json"},
     )
     response.raise_for_status()
     try:
         return response.json()
     except Exception:
-        raise ValueError("Invalid actor payload: {}".format(response.text))
+        raise ValueError(f"Invalid actor payload: {response.text}")
 
 
 def get_actor(fid, skip_cache=False):

api/funkwhale_api/federation/admin.py

 from funkwhale_api.common import admin
 
-from . import models
-from . import tasks
+from . import models, tasks
 
 
 def redeliver_deliveries(modeladmin, request, queryset):

api/funkwhale_api/federation/api_serializers.py

 import datetime
+from urllib.parse import urlparse
 
 from django.conf import settings
-from django.core.exceptions import ObjectDoesNotExist
 from django.core import validators
+from django.core.exceptions import ObjectDoesNotExist
 from django.utils import timezone
-
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import extend_schema_field
 from rest_framework import serializers
 
 from funkwhale_api.audio import models as audio_models
-from funkwhale_api.common import fields as common_fields
+from funkwhale_api.audio import serializers as audio_serializers
 from funkwhale_api.common import serializers as common_serializers
 from funkwhale_api.music import models as music_models
+from funkwhale_api.playlists import models as playlists_models
 from funkwhale_api.users import serializers as users_serializers
 
-from . import filters
-from . import models
+from . import filters, models
 from . import serializers as federation_serializers
 
 
@@ -44,8 +46,9 @@ class DomainSerializer(serializers.Serializer):
 class LibrarySerializer(serializers.ModelSerializer):
     actor = federation_serializers.APIActorSerializer()
     uploads_count = serializers.SerializerMethodField()
-    latest_scan = serializers.SerializerMethodField()
-    follow = serializers.SerializerMethodField()
+    latest_scan = LibraryScanSerializer(required=False, allow_null=True)
+    # The follow field is likely broken, so I removed the test
+    follow = NestedLibraryFollowSerializer(required=False, allow_null=True)
 
     class Meta:
         model = music_models.Library
@@ -54,7 +57,6 @@ class LibrarySerializer(serializers.ModelSerializer):
             "uuid",
             "actor",
             "name",
-            "description",
             "creation_date",
             "uploads_count",
             "privacy_level",
@@ -62,20 +64,16 @@ class LibrarySerializer(serializers.ModelSerializer):
             "latest_scan",
         ]
 
-    def get_uploads_count(self, o):
+    def get_uploads_count(self, o) -> int:
         return max(getattr(o, "_uploads_count", 0), o.uploads_count)
 
+    @extend_schema_field(NestedLibraryFollowSerializer)
     def get_follow(self, o):
         try:
             return NestedLibraryFollowSerializer(o._follows[0]).data
         except (AttributeError, IndexError):
             return None
 
-    def get_latest_scan(self, o):
-        scan = o.scans.order_by("-creation_date").first()
-        if scan:
-            return LibraryScanSerializer(scan).data
-
 
 class LibraryFollowSerializer(serializers.ModelSerializer):
     target = common_serializers.RelatedField("uuid", LibrarySerializer(), required=True)
@@ -95,6 +93,31 @@ class LibraryFollowSerializer(serializers.ModelSerializer):
             raise serializers.ValidationError("You are already following this library")
         return v
 
+    @extend_schema_field(federation_serializers.APIActorSerializer)
+    def get_actor(self, o):
+        return federation_serializers.APIActorSerializer(o.actor).data
+
+
+class FollowSerializer(serializers.ModelSerializer):
+    target = common_serializers.RelatedField(
+        "fid", federation_serializers.APIActorSerializer(), required=True
+    )
+    actor = serializers.SerializerMethodField()
+
+    class Meta:
+        model = models.Follow
+        fields = ["creation_date", "actor", "uuid", "target", "approved"]
+        read_only_fields = ["uuid", "actor", "approved", "creation_date"]
+
+    def validate_target(self, v):
+        request_actor = self.context["actor"]
+        if v == request_actor:
+            raise serializers.ValidationError("You cannot follow yourself")
+        if v.received_follows.filter(actor=request_actor).exists():
+            raise serializers.ValidationError("You are already following this user")
+        return v
+
+    @extend_schema_field(federation_serializers.APIActorSerializer)
     def get_actor(self, o):
         return federation_serializers.APIActorSerializer(o.actor).data
 
@@ -108,16 +131,18 @@ def serialize_generic_relation(activity, obj):
 
     if data["type"] == "music.Library":
         data["name"] = obj.name
-    if data["type"] == "federation.LibraryFollow":
+    if (
+        data["type"] == "federation.LibraryFollow"
+        or data["type"] == "federation.Follow"
+    ):
         data["approved"] = obj.approved
-
     return data
 
 
 class ActivitySerializer(serializers.ModelSerializer):
     actor = federation_serializers.APIActorSerializer()
-    object = serializers.SerializerMethodField()
-    target = serializers.SerializerMethodField()
+    object = serializers.SerializerMethodField(allow_null=True)
+    target = serializers.SerializerMethodField(allow_null=True)
     related_object = serializers.SerializerMethodField()
 
     class Meta:
@@ -135,14 +160,17 @@ class ActivitySerializer(serializers.ModelSerializer):
             "type",
         ]
 
+    @extend_schema_field(OpenApiTypes.OBJECT, None)
     def get_object(self, o):
         if o.object:
             return serialize_generic_relation(o, o.object)
 
+    @extend_schema_field(OpenApiTypes.OBJECT)
     def get_related_object(self, o):
         if o.related_object:
             return serialize_generic_relation(o, o.related_object)
 
+    @extend_schema_field(OpenApiTypes.OBJECT)
     def get_target(self, o):
         if o.target:
             return serialize_generic_relation(o, o.target)
@@ -165,21 +193,32 @@ class InboxItemActionSerializer(common_serializers.ActionSerializer):
         return objects.update(is_read=True)
 
 
-FETCH_OBJECT_CONFIG = {
-    "artist": {"queryset": music_models.Artist.objects.all()},
-    "album": {"queryset": music_models.Album.objects.all()},
-    "track": {"queryset": music_models.Track.objects.all()},
-    "library": {"queryset": music_models.Library.objects.all(), "id_attr": "uuid"},
-    "upload": {"queryset": music_models.Upload.objects.all(), "id_attr": "uuid"},
-    "account": {"queryset": models.Actor.objects.all(), "id_attr": "full_username"},
-    "channel": {"queryset": audio_models.Channel.objects.all(), "id_attr": "uuid"},
+OBJECT_SERIALIZER_MAPPING = {
+    music_models.Artist: federation_serializers.ArtistSerializer,
+    music_models.Album: federation_serializers.AlbumSerializer,
+    music_models.Track: federation_serializers.TrackSerializer,
+    models.Actor: federation_serializers.APIActorSerializer,
+    audio_models.Channel: audio_serializers.ChannelSerializer,
+    playlists_models.Playlist: federation_serializers.PlaylistSerializer,
 }
-FETCH_OBJECT_FIELD = common_fields.GenericRelation(FETCH_OBJECT_CONFIG)
+
+
+def convert_url_to_webfinger(url):
+    parsed_url = urlparse(url)
+    domain = parsed_url.netloc  # e.g., "node1.funkwhale.test"
+    path_parts = parsed_url.path.strip("/").split("/")
+    # Ensure the path is in the expected format
+    if len(path_parts) > 0 and path_parts[0].startswith("@"):
+        username = path_parts[0][1:]  # Remove the '@'
+        return f"{username}@{domain}"
+    return None
 
 
 class FetchSerializer(serializers.ModelSerializer):
     actor = federation_serializers.APIActorSerializer(read_only=True)
-    object = serializers.CharField(write_only=True)
+    object_uri = serializers.CharField(required=True, write_only=True)
+    object = serializers.SerializerMethodField(read_only=True)
+    type = serializers.SerializerMethodField(read_only=True)
     force = serializers.BooleanField(default=False, required=False, write_only=True)
 
     class Meta:
@@ -192,8 +231,10 @@ class FetchSerializer(serializers.ModelSerializer):
             "detail",
             "creation_date",
             "fetch_date",
-            "object",
+            "object_uri",
             "force",
+            "type",
+            "object",
         ]
         read_only_fields = [
             "id",
@@ -203,10 +244,36 @@ class FetchSerializer(serializers.ModelSerializer):
             "detail",
             "creation_date",
             "fetch_date",
+            "type",
+            "object",
         ]
 
-    def validate_object(self, value):
-        # if value is a webginfer lookup, we craft a special url
+    def get_type(self, fetch):
+        obj = fetch.object
+        if obj is None:
+            return None
+
+        # Return the type as a string
+        if isinstance(obj, music_models.Artist):
+            return "artist"
+        elif isinstance(obj, music_models.Album):
+            return "album"
+        elif isinstance(obj, music_models.Track):
+            return "track"
+        elif isinstance(obj, models.Actor):
+            return "account"
+        elif isinstance(obj, audio_models.Channel):
+            return "channel"
+        elif isinstance(obj, playlists_models.Playlist):
+            return "playlist"
+        else:
+            return None
+
+    def validate_object_uri(self, value):
+        if value.startswith("https://"):
+            converted = convert_url_to_webfinger(value)
+            if converted:
+                value = converted
         if value.startswith("@"):
             value = value.lstrip("@")
         validator = validators.EmailValidator()
@@ -214,8 +281,29 @@ class FetchSerializer(serializers.ModelSerializer):
             validator(value)
         except validators.ValidationError:
             return value
+        return f"webfinger://{value}"
+
+    @extend_schema_field(
+        {
+            "oneOf": [
+                {"$ref": "#/components/schemas/Artist"},
+                {"$ref": "#/components/schemas/Album"},
+                {"$ref": "#/components/schemas/Track"},
+                {"$ref": "#/components/schemas/APIActor"},
+                {"$ref": "#/components/schemas/Channel"},
+                {"$ref": "#/components/schemas/Playlist"},
+            ]
+        }
+    )
+    def get_object(self, fetch):
+        obj = fetch.object
+        if obj is None:
+            return None
 
-        return "webfinger://{}".format(value)
+        serializer_class = OBJECT_SERIALIZER_MAPPING.get(type(obj))
+        if serializer_class:
+            return serializer_class(obj).data
+        return None
 
     def create(self, validated_data):
         check_duplicates = not validated_data.get("force", False)
@@ -225,7 +313,7 @@ class FetchSerializer(serializers.ModelSerializer):
                 validated_data["actor"]
                 .fetches.filter(
                     status="finished",
-                    url=validated_data["object"],
+                    url=validated_data["object_uri"],
                     creation_date__gte=timezone.now()
                     - datetime.timedelta(
                         seconds=settings.FEDERATION_DUPLICATE_FETCH_DELAY
@@ -238,18 +326,10 @@ class FetchSerializer(serializers.ModelSerializer):
                 return duplicate
 
         fetch = models.Fetch.objects.create(
-            actor=validated_data["actor"], url=validated_data["object"]
+            actor=validated_data["actor"], url=validated_data["object_uri"]
         )
         return fetch
 
-    def to_representation(self, obj):
-        repr = super().to_representation(obj)
-        object_data = None
-        if obj.object:
-            object_data = FETCH_OBJECT_FIELD.to_representation(obj.object)
-        repr["object"] = object_data
-        return repr
-
 
 class FullActorSerializer(serializers.Serializer):
     fid = serializers.URLField()
@@ -268,6 +348,7 @@ class FullActorSerializer(serializers.Serializer):
     summary = common_serializers.ContentSerializer(source="summary_obj")
     icon = common_serializers.AttachmentSerializer(source="attachment_icon")
 
+    @extend_schema_field(OpenApiTypes.BOOL)
     def get_is_channel(self, o):
         try:
             return bool(o.channel)