api/funkwhale_api/contrib/maloja/funkwhale_ready.py

+import json
+
+from config import plugins
+
+from .funkwhale_startup import PLUGIN
+
+
+class MalojaException(Exception):
+    pass
+
+
+@plugins.register_hook(plugins.LISTENING_CREATED, PLUGIN)
+def submit_listen(listening, conf, **kwargs):
+    server_url = conf["server_url"]
+    api_key = conf["api_key"]
+    if not server_url or not api_key:
+        return
+
+    logger = PLUGIN["logger"]
+    logger.info("Submitting listening to Maloja at %s", server_url)
+    payload = get_payload(listening, api_key, conf)
+    logger.debug("Maloja payload: %r", payload)
+    url = server_url.rstrip("/") + "/apis/mlj_1/newscrobble"
+    session = plugins.get_session()
+    response = session.post(url, json=payload)
+    response.raise_for_status()
+    details = json.loads(response.text)
+    if details["status"] == "success":
+        logger.info("Maloja listening submitted successfully")
+    else:
+        raise MalojaException(response.text)
+
+
+def get_payload(listening, api_key, conf):
+    track = listening.track
+
+    # See https://github.com/krateng/maloja/blob/master/API.md
+    payload = {
+        "key": api_key,
+        "artists": [artist.name for artist in track.artist_credit.get_artists_list()],
+        "title": track.title,
+        "time": int(listening.creation_date.timestamp()),
+        "nofix": bool(conf.get("nofix")),
+    }
+
+    if track.album:
+        if track.album.title:
+            payload["album"] = track.album.title
+        if track.album.artist_credit.all():
+            payload["albumartists"] = [
+                artist.name for artist in track.album.artist_credit.get_artists_list()
+            ]
+
+    upload = track.uploads.filter(duration__gte=0).first()
+    if upload:
+        payload["length"] = upload.duration
+
+    return payload

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,
     }
@@ -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/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")
+    privacy_level = "everyone"
 
     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/migrations/0004_alter_trackfavorite_privacy_level.py

+# Generated by Django 5.1.6 on 2025-09-12 08:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("favorites", "0003_trackfavorite_actor_trackfavorite_fid_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="trackfavorite",
+            name="privacy_level",
+            field=models.CharField(
+                choices=[
+                    ("me", "Only me"),
+                    ("followers", "Me and my followers"),
+                    ("instance", "Everyone on my instance, and my followers"),
+                    ("everyone", "Everyone, including people on other instances"),
+                ],
+                max_length=30,
+                default="me",
+            ),
+        ),
+    ]

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
 
 
-class TrackFavorite(models.Model):
+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(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,
     )
+    privacy_level = fields.get_privacy_field()
     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()
+        if not self.privacy_level:
+            self.privacy_level = self.actor.user.privacy_level
+        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, "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):