class AlbumFilter(
ChannelFilterSet,
LibraryFilterSet,
audio_filters.IncludeChannelsFilterSet,
moderation_filters.HiddenContentFilterSet,
):
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
q = fields.SearchFilter(
search_fields=["title", "artist__name"],
fts_search_fields=["body_text", "artist__body_text"],
)
tag = TAG_FILTER
scope = common_filters.ActorScopeFilter(
actor_field="tracks__uploads__library__actor", distinct=True
)
class Meta:
model = models.Album
fields = ["playable", "q", "artist", "scope", "mbid"]
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG["ALBUM"]
include_channels_field = "artist__channel"
channel_filter_field = "track__album"
library_filter_field = "track__album"
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value)
class ArtistFilter(
LibraryFilterSet,
audio_filters.IncludeChannelsFilterSet,
moderation_filters.HiddenContentFilterSet,
):
q = fields.SearchFilter(search_fields=["name"], fts_search_fields=["body_text"])
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
tag = TAG_FILTER
scope = common_filters.ActorScopeFilter(
actor_field="tracks__uploads__library__actor", distinct=True
)
class Meta:
model = models.Artist
fields = {
"name": ["exact", "iexact", "startswith", "icontains"],
"playable": ["exact"],
"scope": ["exact"],
"mbid": ["exact"],
}
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG["ARTIST"]
include_channels_field = "channel"
library_filter_field = "track__artist"
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value).distinct()
class UploadFilter(audio_filters.IncludeChannelsFilterSet):
library = filters.CharFilter("library__uuid")
channel = filters.CharFilter("library__channel__uuid")
track = filters.UUIDFilter("track__uuid")
track_artist = filters.UUIDFilter("track__artist__uuid")
album_artist = filters.UUIDFilter("track__album__artist__uuid")
library = filters.UUIDFilter("library__uuid")
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
scope = common_filters.ActorScopeFilter(
actor_field="library__actor",
distinct=True,
library_field="library",
)
import_status = common_filters.MultipleQueryFilter(coerce=str)
q = fields.SmartSearchFilter(config=search.SearchConfig(
search_fields={
"track_artist": {
"to": "track__artist__name"
},
"album_artist": {
"to": "track__album__artist__name"
},
"album": {
"to": "track__album__title"
},
"title": {
"to": "track__title"
},
},
filter_fields={
"artist": {
"to": "track__artist__name__iexact"
},
"mimetype": {
"to": "mimetype"
},
"album": {
"to": "track__album__title__iexact"
},
"title": {
"to": "track__title__iexact"
},
"status": {
"to": "import_status"
},
},
))
class Meta:
model = models.Upload
fields = [
"import_status",
"mimetype",
"import_reference",
]
include_channels_field = "track__artist__channel"
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value)
class TrackFilter(
RelatedFilterSet,
ChannelFilterSet,
LibraryFilterSet,
audio_filters.IncludeChannelsFilterSet,
moderation_filters.HiddenContentFilterSet,
):
q = fields.SearchFilter(
search_fields=["title", "album__title", "artist__name"],
fts_search_fields=[
"body_text", "artist__body_text", "album__body_text"
],
)
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
tag = TAG_FILTER
id = common_filters.MultipleQueryFilter(coerce=int)
scope = common_filters.ActorScopeFilter(
actor_field="uploads__library__actor",
library_field="uploads__library",
distinct=True,
)
artist = filters.ModelChoiceFilter(field_name="_",
method="filter_artist",
queryset=models.Artist.objects.all())
ordering = django_filters.OrderingFilter(fields=(
("creation_date", "creation_date"),
("title", "title"),
("album__title", "album__title"),
("album__release_date", "album__release_date"),
("size", "size"),
("position", "position"),
("disc_number", "disc_number"),
("artist__name", "artist__name"),
("artist__modification_date", "artist__modification_date"),
("?", "random"),
("tag_matches", "related"),
))
class Meta:
model = models.Track
fields = {
"title": ["exact", "iexact", "startswith", "icontains"],
"id": ["exact"],
"album": ["exact"],
"license": ["exact"],
"mbid": ["exact"],
}
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG[
"TRACK"]
include_channels_field = "artist__channel"
channel_filter_field = "track"
library_filter_field = "track"
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value).distinct()
def filter_artist(self, queryset, name, value):
return queryset.filter(Q(artist=value) | Q(album__artist=value))
class FS(filters.filters.FilterSet):
scope = filters.ActorScopeFilter(
actor_field="uploads__library__actor", distinct=True
)
class Meta:
model = tracks[0].__class__
fields = ["scope"]
class RadioFilter(django_filters.FilterSet):
scope = common_filters.ActorScopeFilter(actor_field="user__actor", distinct=True)
class Meta:
model = models.Radio
fields = {
"name": ["exact", "iexact", "startswith", "icontains"],
"scope": "exact",
}
class ListeningFilter(moderation_filters.HiddenContentFilterSet):
username = django_filters.CharFilter("user__username")
domain = django_filters.CharFilter("user__actor__domain_id")
scope = common_filters.ActorScopeFilter(actor_field="user__actor",
distinct=True)
class Meta:
model = models.Listening
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG[
"LISTENING"]
fields = ["hidden", "scope"]
class LibraryFilter(filters.FilterSet):
q = fields.SearchFilter(search_fields=["name"], )
scope = common_filters.ActorScopeFilter(
actor_field="actor",
distinct=True,
library_field="pk",
)
class Meta:
model = models.Library
fields = ["privacy_level"]
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)
class Meta:
model = models.TrackFavorite
fields = ["user", "q", "scope"]
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG[
"TRACK_FAVORITE"
]
class RadioFilter(django_filters.FilterSet):
scope = common_filters.ActorScopeFilter(actor_field="user__actor",
distinct=True)
q = filters.CharFilter(field_name="_", method="filter_q")
class Meta:
model = models.Radio
fields = {
"name": ["exact", "iexact", "startswith", "icontains"],
}
def filter_q(self, queryset, name, value):
query = utils.get_query(value, ["name", "user__username"])
return queryset.filter(query)
class ChannelFilter(moderation_filters.HiddenContentFilterSet):
q = fields.SearchFilter(search_fields=[
"artist__name", "actor__summary", "actor__preferred_username"
])
tag = TAG_FILTER
scope = common_filters.ActorScopeFilter(actor_field="attributed_to",
distinct=True)
subscribed = django_filters.BooleanFilter(field_name="_",
method="filter_subscribed")
external = django_filters.BooleanFilter(field_name="_",
method="filter_external")
ordering = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
("creation_date", "creation_date"),
("artist__modification_date", "modification_date"),
("?", "random"),
))
class Meta:
model = models.Channel
fields = []
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG[
"CHANNEL"]
def filter_subscribed(self, queryset, name, value):
if not self.request.user.is_authenticated:
return queryset.none()
emitted_follows = self.request.user.actor.emitted_follows.exclude(
target__channel__isnull=True)
query = Q(actor__in=emitted_follows.values_list("target", flat=True))
if value is True:
return queryset.filter(query)
else:
return queryset.exclude(query)
def filter_external(self, queryset, name, value):
query = Q(
attributed_to=actors.get_service_actor(),
actor__preferred_username__startswith="rssfeed-",
)
if value is True:
queryset = queryset.filter(query)
if value is False:
queryset = queryset.exclude(query)
return queryset
class ArtistFilter(
RelatedFilterSet,
LibraryFilterSet,
audio_filters.IncludeChannelsFilterSet,
moderation_filters.HiddenContentFilterSet,
):
q = fields.SearchFilter(search_fields=["name"],
fts_search_fields=["body_text"])
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
has_albums = filters.BooleanFilter(field_name="_",
method="filter_has_albums")
tag = TAG_FILTER
scope = common_filters.ActorScopeFilter(
actor_field="tracks__uploads__library__actor",
distinct=True,
library_field="tracks__uploads__library",
)
ordering = django_filters.OrderingFilter(fields=(
("id", "id"),
("name", "name"),
("creation_date", "creation_date"),
("modification_date", "modification_date"),
("?", "random"),
("tag_matches", "related"),
))
class Meta:
model = models.Artist
fields = {
"name": ["exact", "iexact", "startswith", "icontains"],
"mbid": ["exact"],
}
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG[
"ARTIST"]
include_channels_field = "channel"
library_filter_field = "track__artist"
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value).distinct()
def filter_has_albums(self, queryset, name, value):
if value is True:
return queryset.filter(albums__isnull=False)
else:
return queryset.filter(albums__isnull=True)
class PlaylistFilter(filters.FilterSet):
q = filters.CharFilter(field_name="_", method="filter_q")
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
track = filters.ModelChoiceFilter(
"playlist_tracks__track",
queryset=music_models.Track.objects.all(),
distinct=True,
)
album = filters.ModelChoiceFilter(
"playlist_tracks__track__album",
queryset=music_models.Album.objects.all(),
distinct=True,
)
artist = filters.ModelChoiceFilter(
"playlist_tracks__track__artist",
queryset=music_models.Artist.objects.all(),
distinct=True,
)
scope = common_filters.ActorScopeFilter(actor_field="user__actor",
distinct=True)
class Meta:
model = models.Playlist
fields = {
"user": ["exact"],
"name": ["exact", "icontains"],
"q": "exact",
"playable": "exact",
"scope": "exact",
}
def filter_playable(self, queryset, name, value):
queryset = queryset.annotate(plts_count=Count("playlist_tracks"))
if value:
return queryset.filter(plts_count__gt=0)
else:
return queryset.filter(plts_count=0)
def filter_q(self, queryset, name, value):
query = utils.get_query(value, ["name", "user__username"])
return queryset.filter(query)
class TrackFilter(
ChannelFilterSet,
LibraryFilterSet,
audio_filters.IncludeChannelsFilterSet,
moderation_filters.HiddenContentFilterSet,
):
q = fields.SearchFilter(
search_fields=["title", "album__title", "artist__name"],
fts_search_fields=["body_text", "artist__body_text", "album__body_text"],
)
playable = filters.BooleanFilter(field_name="_", method="filter_playable")
tag = TAG_FILTER
id = common_filters.MultipleQueryFilter(coerce=int)
scope = common_filters.ActorScopeFilter(
actor_field="uploads__library__actor", distinct=True
)
class Meta:
model = models.Track
fields = {
"title": ["exact", "iexact", "startswith", "icontains"],
"playable": ["exact"],
"id": ["exact"],
"artist": ["exact"],
"album": ["exact"],
"license": ["exact"],
"scope": ["exact"],
"mbid": ["exact"],
}
hidden_content_fields_mapping = moderation_filters.USER_FILTER_CONFIG["TRACK"]
include_channels_field = "artist__channel"
channel_filter_field = "track"
library_filter_field = "track"
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value).distinct()