class ManageAlbumFilterSet(filters.FilterSet):
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={
"title": {"to": "title"},
"fid": {"to": "fid"},
"artist": {"to": "artist__name"},
"mbid": {"to": "mbid"},
},
filter_fields={
"uuid": {"to": "uuid"},
"artist_id": {"to": "artist_id", "field": forms.IntegerField()},
"domain": {
"handler": lambda v: federation_utils.get_domain_query_from_url(v)
},
"library_id": {
"to": "tracks__uploads__library_id",
"field": forms.IntegerField(),
"distinct": True,
},
"tag": {"to": "tagged_items__tag__name", "distinct": True},
},
)
)
class Meta:
model = music_models.Album
fields = ["q", "title", "mbid", "fid", "artist"]
class ManageChannelFilterSet(filters.FilterSet):
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={
"name": {"to": "artist__name"},
"username": {"to": "artist__name"},
"fid": {"to": "artist__fid"},
"rss": {"to": "rss_url"},
},
filter_fields={
"uuid": {"to": "uuid"},
"category": {"to": "artist__content_category"},
"domain": {
"handler": lambda v: federation_utils.get_domain_query_from_url(
v, url_field="attributed_to__fid"
)
},
"tag": {"to": "artist__tagged_items__tag__name", "distinct": True},
"account": get_actor_filter("attributed_to"),
},
)
)
class Meta:
model = audio_models.Channel
fields = ["q"]
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 ManageActorFilterSet(filters.FilterSet):
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={
"name": {"to": "name"},
"username": {"to": "preferred_username"},
"email": {"to": "user__email"},
"bio": {"to": "summary"},
"type": {"to": "type"},
},
filter_fields={
"uuid": {"to": "uuid"},
"domain": {"to": "domain__name__iexact"},
"username": {"to": "preferred_username__iexact"},
"email": {"to": "user__email__iexact"},
},
)
)
local = filters.BooleanFilter(field_name="_", method="filter_local")
class Meta:
model = federation_models.Actor
fields = ["q", "domain", "type", "manually_approves_followers", "local"]
def filter_local(self, queryset, name, value):
return queryset.local(value)
def test_search_config_query_filter_field_handler():
s = search.SearchConfig(
filter_fields={"account": {
"handler": lambda v: Q(hello="world")
}})
cleaned = s.clean("account:noop")
assert cleaned["filter_query"] == Q(hello="world")
class UploadFilter(filters.FilterSet):
library = filters.CharFilter("library__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(name="_", method="filter_playable")
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 = [
"playable",
"import_status",
"mimetype",
"track",
"track_artist",
"album_artist",
"library",
"import_reference",
]
def filter_playable(self, queryset, name, value):
actor = utils.get_actor_from_request(self.request)
return queryset.playable_by(actor, value)
def test_search_config_query_filter_field():
s = search.SearchConfig(filter_fields={
"account": {
"to": "noop",
"field": forms.BooleanField()
}
})
cleaned = s.clean("account:true")
assert cleaned["filter_query"] == Q(noop=True)
def test_search_config_filter(query, expected):
s = search.SearchConfig(filter_fields={
"user": {
"to": "user__username__iexact"
},
"status": {
"to": "status"
},
})
cleaned = s.clean(query)
assert cleaned["filter_query"] == expected
class ManageUploadFilterSet(filters.FilterSet):
ordering = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
("creation_date", "creation_date"),
("modification_date", "modification_date"),
("accessed_date", "accessed_date"),
("size", "size"),
("bitrate", "bitrate"),
("duration", "duration"),
)
)
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={
"source": {"to": "source"},
"fid": {"to": "fid"},
"track": {"to": "track__title"},
"album": {"to": "track__album__title"},
"artist": {"to": "track__artist__name"},
},
filter_fields={
"uuid": {"to": "uuid"},
"library_id": {"to": "library_id", "field": forms.IntegerField()},
"artist_id": {"to": "track__artist_id", "field": forms.IntegerField()},
"album_id": {"to": "track__album_id", "field": forms.IntegerField()},
"track_id": {"to": "track__id", "field": forms.IntegerField()},
"domain": {"to": "library__actor__domain_id"},
"import_reference": {"to": "import_reference"},
"type": {"to": "mimetype"},
"status": {"to": "import_status"},
"account": get_actor_filter("library__actor"),
"privacy_level": {"to": "library__privacy_level"},
},
)
)
domain = filters.CharFilter("library__actor__domain_id")
privacy_level = filters.CharFilter("library__privacy_level")
class Meta:
model = music_models.Upload
fields = [
"q",
"fid",
"privacy_level",
"domain",
"mimetype",
"import_reference",
"import_status",
]
def test_search_config_query(query, expected):
s = search.SearchConfig(search_fields={
"field1": {
"to": "f1"
},
"field2": {
"to": "f2"
},
"field3": {
"to": "f3"
},
})
cleaned = s.clean(query)
assert cleaned["search_query"] == expected
class ManageNoteFilterSet(filters.FilterSet):
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={"summary": {"to": "summary"}},
filter_fields={
"uuid": {"to": "uuid"},
"author": get_actor_filter("author"),
"target": common_filters.get_generic_relation_filter(
"target", moderation_utils.NOTE_TARGET_FIELDS
),
},
)
)
class Meta:
model = moderation_models.Note
fields = ["q"]
class ManageLibraryFilterSet(filters.FilterSet):
ordering = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
("creation_date", "creation_date"),
("_uploads_count", "uploads_count"),
("followers_count", "followers_count"),
)
)
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={
"name": {"to": "name"},
"description": {"to": "description"},
"fid": {"to": "fid"},
},
filter_fields={
"uuid": {"to": "uuid"},
"artist_id": {
"to": "uploads__track__artist_id",
"field": forms.IntegerField(),
"distinct": True,
},
"album_id": {
"to": "uploads__track__album_id",
"field": forms.IntegerField(),
"distinct": True,
},
"track_id": {
"to": "uploads__track__id",
"field": forms.IntegerField(),
"distinct": True,
},
"domain": {"to": "actor__domain_id"},
"account": get_actor_filter("actor"),
"privacy_level": {"to": "privacy_level"},
},
)
)
domain = filters.CharFilter("actor__domain_id")
class Meta:
model = music_models.Library
fields = ["q", "name", "fid", "privacy_level", "domain"]
class ManageUserRequestFilterSet(filters.FilterSet):
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={
"username": {"to": "submitter__preferred_username"},
"uuid": {"to": "uuid"},
},
filter_fields={
"uuid": {"to": "uuid"},
"id": {"to": "id"},
"status": {"to": "status"},
"category": {"to": "type"},
"submitter": get_actor_filter("submitter"),
"assigned_to": get_actor_filter("assigned_to"),
},
)
)
class Meta:
model = moderation_models.UserRequest
fields = ["q", "status", "type"]
class ManageUserFilterSet(filters.FilterSet):
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={
"name": {"to": "name"},
"username": {"to": "username"},
"email": {"to": "email"},
}
)
)
class Meta:
model = users_models.User
fields = [
"is_active",
"privacy_level",
"is_staff",
"is_superuser",
"permission_library",
"permission_settings",
"permission_moderation",
]
class ManageReportFilterSet(filters.FilterSet):
q = fields.SmartSearchFilter(
config=search.SearchConfig(
search_fields={"summary": {"to": "summary"}},
filter_fields={
"uuid": {"to": "uuid"},
"id": {"to": "id"},
"resolved": common_filters.get_boolean_filter("is_handled"),
"domain": {"to": "target_owner__domain_id"},
"category": {"to": "type"},
"submitter": get_actor_filter("submitter"),
"assigned_to": get_actor_filter("assigned_to"),
"target_owner": get_actor_filter("target_owner"),
"submitter_email": {"to": "submitter_email"},
"target": common_filters.get_generic_relation_filter(
"target", moderation_serializers.TARGET_CONFIG
),
},
)
)
class Meta:
model = moderation_models.Report
fields = ["q", "is_handled", "type", "submitter_email"]
def test_search_config_is(query, expected):
s = search.SearchConfig(
types=[("album", music_models.Album), ("artist", music_models.Artist)])
cleaned = s.clean(query)
assert cleaned["types"] == expected
