Merge pull request #181 from DakaraProject/feature/search

Expand searching possibilities

Author: Neraste

CHANGELOG.md

@@ -37,6 +37,8 @@ Any important notes regarding the update.
 ### Added
 
 - Allow to fetch full lyrics of a song at URL `api/library/songs/lyrics/<id>/`.
+- Allow to search playlist entries, player errors, users, and song tags.
+- Allow to search songs, playlist entries, player errors and users by ID.
 
 ## 1.9.2 - 2025-03-22
 

dakara_server/dakara_server/urls.py

@@ -48,7 +48,7 @@
     ),
     path(
         "api/playlist/player/errors/",
-        playlist_views.PlayerErrorView.as_view(),
+        playlist_views.PlayerErrorListView.as_view(),
         name="playlist-player-errors",
     ),
     path(

dakara_server/internal/query.py

@@ -0,0 +1,78 @@
+from django.db.models import Q
+
+
+def q(prefix, name, value):
+    """Shorthand to make a query with the Q object and a prefix.
+
+    Args:
+        prefix (str or None): If truthy, prepended to `name`.
+        name (str): Name of the field.
+        value (str): Value for the field in the query.
+
+    Returns:
+        django.db.models.Q: Query.
+    """
+    if prefix:
+        return Q(**{prefix + name: value})
+
+    return Q(**{name: value})
+
+
+def gather_query(query_set, query_list):
+    """Filter a query set by conjunction of elements of a query list.
+
+    Args:
+        query_set: Initial query set.
+        query_list (list of django.db.models.Q): List of queries. They will be
+            chained using the conjunction (`&=`) operator.
+
+    Returns:
+        New firtered query set.
+    """
+    # now, gather the query objects
+    filter_query = Q()
+    for item in query_list:
+        filter_query &= item
+
+    # gather the query objects for usual relations
+    return query_set.filter(filter_query)
+
+
+def gather_query_remain(query_set, query_list_remain):
+    """Filter a query set by disjunction of elements of a query list.
+
+    Args:
+        query_set: Initial query set.
+        query_list (list of django.db.models.Q): List of queries. They will be
+            chained using the disjunction (`|=`) operator.
+
+    Returns:
+        New firtered query set.
+    """
+    # now, gather the query objects
+    filter_query = Q()
+    for item in query_list_remain:
+        filter_query |= item
+
+    # gather the query objects for usual relations
+    return query_set.filter(filter_query)
+
+
+def gather_query_many(query_set, query_list_many):
+    """Chain filter a query set by elements of a query list.
+
+    Args:
+        query_set: Initial query set.
+        query_list (list of django.db.models.Q): List of queries. They will be
+            chained to the initial query set by the `filter` method.
+
+    Returns:
+        New firtered query set.
+    """
+    query_set_filtered = query_set
+
+    # gather the query objects for custom many to many relation
+    for item in query_list_many:
+        query_set_filtered = query_set_filtered.filter(item)
+
+    return query_set_filtered

dakara_server/library/query_language.py dakara_server/internal/query_language.pydakara_server/library/query_language.py renamed to dakara_server/internal/query_language.py

@@ -1,19 +1,16 @@
 import re
 
-from library.models import WorkType
-
-KEYWORDS = ["artist", "work", "title"]
-
 
 class QueryLanguageParser:
-    """Parser for search query mini language used to search song."""
+    """Parser for search query mini language.
 
-    def __init__(self):
-        self.keywords_work_type = [
-            work_type.query_name for work_type in WorkType.objects.all()
-        ]
+    Args:
+        keywords (list of str): List of keywords to use
+        for parsing.
+    """
 
-        self.keywords = KEYWORDS + self.keywords_work_type
+    def __init__(self, keywords):
+        self.keywords = keywords
 
         regex = r"""
         \b(?P<keyword>{keywords_regex}) # keyword
@@ -86,33 +83,24 @@ def parse(self, query):
                 with spaces.
 
         Returns:
-            dict: Query terms arranged among the following keys:
-                `artist`:
-                    `contains`: List of list of artists names to match
-                        partially.
-                    `exact`: List of list of artists names to match exactly.
-                `work`:
-                    `contains`: List of works names to match partially.
-                    `exact`: List of works names to match exactly.
-                `title:
-                    `contains`: Titles to match partially
-                    `exact`: Titles to match exactly.
+            dict: Query terms parsed according to the
+            provided keywords. Each item is a dict
+            containing two lists:
+                `contains`: List of partial matches.
+                `exact`: List of exact matches.
+            In addition, two extra items are present in
+            the dict:
                 `tag`: List of tags to match in uppercase.
-                `work_type`: Dict with queryname as key and a dict as value
-                    with the keys `contains` and `exact`.
-
                 `remaining`: Unparsed text.
         """
         # create results structure
-        # work_type will be filled only if necessary
-        result = {
-            "artist": {"contains": [], "exact": []},
-            "work": {"contains": [], "exact": []},
-            "title": {"contains": [], "exact": []},
-            "work_type": {},
-            "remaining": [],
-            "tag": [],
-        }
+        result = {kw: {"contains": [], "exact": []} for kw in self.keywords}
+        result.update(
+            {
+                "remaining": [],
+                "tag": [],
+            }
+        )
 
         for match in self.language_matcher.finditer(query):
             group_index = match.groupdict()
@@ -126,21 +114,11 @@ def parse(self, query):
                 .strip()
             )
 
-            if target in self.keywords_work_type:
-                # create worktype if not exists
-                if target not in result["work_type"]:
-                    result["work_type"][target] = {"contains": [], "exact": []}
-
-                result_target = result["work_type"][target]
-
-            else:
-                result_target = result[target]
-
             if value_contains and not value_exact:
-                result_target["contains"].append(value_contains)
+                result[target]["contains"].append(value_contains)
 
             elif value_exact and not value_contains:
-                result_target["exact"].append(value_exact)
+                result[target]["exact"].append(value_exact)
 
             else:
                 raise ValueError("Inconsistency")
@@ -158,3 +136,23 @@ def parse(self, query):
                     result["tag"].append(item_clean.upper())
 
         return result
+
+
+def regroup(res, key, keys):
+    """Regroup non empty keys in a specific key.
+
+    Args:
+        res (dict): Dictionary where to regroup keys.
+        key (str): Key where to regroup `keys`.
+        keys (list of str): Keys to regroup in `key`.
+            Any key with no items in `exact` and
+            `contains` will just be removed.
+    """
+    res_copy = res.copy()
+    res_copy[key] = {}
+    for k in keys:
+        val = res_copy.pop(k)
+        if len(val["exact"]) or len(val["contains"]):
+            res_copy[key][k] = val
+
+    return res_copy

dakara_server/internal/tests/base_test.py

@@ -1,5 +1,6 @@
 from django.contrib.auth import get_user_model
 from django.utils import timezone
+from rest_framework import status
 from rest_framework.authtoken.models import Token
 from rest_framework.test import APITestCase
 
@@ -66,6 +67,32 @@ def create_user(
         user.save()
         return user
 
+    def check_query(self, query, expected, remaining=None):
+        """Method to check a query.
+
+        Returned entries should be the same as `expected`, in the same order.
+
+        Args:
+            query (str): Terms of the query, to be parsed.
+            expected_items (list): List of expected objects, that must have an
+            `id`.
+
+        Returns:
+            Response of the client, for furthur analysis.
+        """
+        response = self.client.get(self.url, {"query": query})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data["count"], len(expected))
+        results = response.data["results"]
+        self.assertEqual(len(results), len(expected))
+        for item, expected_item in zip(results, expected, strict=False):
+            self.assertEqual(item["id"], expected_item.id)
+
+        if remaining is not None:
+            self.assertEqual(response.data["query"]["remaining"], remaining)
+
+        return response
+
 
 class BaseAPITestCase(APITestCase, BaseProvider):
     """Base test class for Unittest."""