Filter tags for archived/unarchived (#46)

bookmarks/queries.py

@@ -17,6 +17,16 @@ class Concat(Aggregate):
             **extra)
 
 
+def query_bookmarks(user: User, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, query_string) \
+        .filter(is_archived=False)
+
+
+def query_archived_bookmarks(user: User, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, query_string) \
+        .filter(is_archived=True)
+
+
 def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
     # Add aggregated tag info to bookmark instances
     query_set = Bookmark.objects \
@@ -51,17 +61,19 @@ def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
     return query_set
 
 
-def query_bookmarks(user: User, query_string: str) -> QuerySet:
+def query_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
+    return _base_bookmark_tags_query(user, query_string) \
-        .filter(is_archived=False)
+        .filter(bookmark__is_archived=False) \
+        .distinct()
 
 
-def query_archived_bookmarks(user: User, query_string: str) -> QuerySet:
+def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    return _base_bookmarks_query(user, query_string) \
+    return _base_bookmark_tags_query(user, query_string) \
-        .filter(is_archived=True)
+        .filter(bookmark__is_archived=True) \
+        .distinct()
 
 
-def query_tags(user: User, query_string: str):
+def _base_bookmark_tags_query(user: User, query_string: str) -> QuerySet:
     query_set = Tag.objects
 
     # Filter for user

bookmarks/tests/test_queries.py

@@ -2,8 +2,8 @@ from django.contrib.auth import get_user_model
 from django.test import TestCase
 from django.utils import timezone
 from django.utils.crypto import get_random_string
-from bookmarks.models import Bookmark
+from bookmarks.models import Bookmark, Tag
-from bookmarks.queries import query_bookmarks, query_archived_bookmarks
+from bookmarks import queries
 
 User = get_user_model()
 
@@ -13,7 +13,7 @@ class QueriesTestCase(TestCase):
     def setUp(self) -> None:
         self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
 
-    def setup_bookmark(self, is_archived: bool = False):
+    def setup_bookmark(self, is_archived: bool = False, tags: [Tag] = []):
         unique_id = get_random_string(length=32)
         bookmark = Bookmark(
             url='https://example.com/' + unique_id,
@@ -23,8 +23,17 @@ class QueriesTestCase(TestCase):
             is_archived=is_archived
         )
         bookmark.save()
+        for tag in tags:
+            bookmark.tags.add(tag)
+        bookmark.save()
         return bookmark
 
+    def setup_tag(self):
+        name = get_random_string(length=32)
+        tag = Tag(name=name, date_added=timezone.now(), owner=self.user)
+        tag.save()
+        return tag
+
     def test_query_bookmarks_should_not_return_archived_bookmarks(self):
         bookmark1 = self.setup_bookmark()
         bookmark2 = self.setup_bookmark()
@@ -32,7 +41,7 @@ class QueriesTestCase(TestCase):
         self.setup_bookmark(is_archived=True)
         self.setup_bookmark(is_archived=True)
 
-        query = query_bookmarks(self.user, '')
+        query = queries.query_bookmarks(self.user, '')
 
         self.assertCountEqual([bookmark1, bookmark2], list(query))
 
@@ -43,6 +52,48 @@ class QueriesTestCase(TestCase):
         self.setup_bookmark()
         self.setup_bookmark()
 
-        query = query_archived_bookmarks(self.user, '')
+        query = queries.query_archived_bookmarks(self.user, '')
 
         self.assertCountEqual([bookmark1, bookmark2], list(query))
+
+    def test_query_bookmark_tags_should_return_tags_for_unarchived_bookmarks_only(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        self.setup_bookmark(tags=[tag1])
+        self.setup_bookmark()
+        self.setup_bookmark(is_archived=True, tags=[tag2])
+
+        query = queries.query_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag1], list(query))
+
+    def test_query_bookmark_tags_should_return_distinct_tags(self):
+        tag = self.setup_tag()
+        self.setup_bookmark(tags=[tag])
+        self.setup_bookmark(tags=[tag])
+        self.setup_bookmark(tags=[tag])
+
+        query = queries.query_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag], list(query))
+
+    def test_query_archived_bookmark_tags_should_return_tags_for_archived_bookmarks_only(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        self.setup_bookmark(tags=[tag1])
+        self.setup_bookmark()
+        self.setup_bookmark(is_archived=True, tags=[tag2])
+
+        query = queries.query_archived_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag2], list(query))
+
+    def test_query_archived_bookmark_tags_should_return_distinct_tags(self):
+        tag = self.setup_tag()
+        self.setup_bookmark(is_archived=True, tags=[tag])
+        self.setup_bookmark(is_archived=True, tags=[tag])
+        self.setup_bookmark(is_archived=True, tags=[tag])
+
+        query = queries.query_archived_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag], list(query))

bookmarks/views/bookmarks.py

@@ -9,7 +9,6 @@ from django.urls import reverse
 from bookmarks import queries
 from bookmarks.models import Bookmark, BookmarkForm, build_tag_string
 from bookmarks.services.bookmarks import create_bookmark, update_bookmark, archive_bookmark, unarchive_bookmark
-from bookmarks.queries import get_user_tags
 
 _default_page_size = 30
 
@@ -18,8 +17,9 @@ _default_page_size = 30
 def index(request):
     query_string = request.GET.get('q')
     query_set = queries.query_bookmarks(request.user, query_string)
+    tags = queries.query_bookmark_tags(request.user, query_string)
     base_url = reverse('bookmarks:index')
-    context = get_bookmark_view_context(request, query_set, base_url)
+    context = get_bookmark_view_context(request, query_set, tags, base_url)
     return render(request, 'bookmarks/index.html', context)
 
 
@@ -27,17 +27,17 @@ def index(request):
 def archived(request):
     query_string = request.GET.get('q')
     query_set = queries.query_archived_bookmarks(request.user, query_string)
+    tags = queries.query_archived_bookmark_tags(request.user, query_string)
     base_url = reverse('bookmarks:archived')
-    context = get_bookmark_view_context(request, query_set, base_url)
+    context = get_bookmark_view_context(request, query_set, tags, base_url)
     return render(request, 'bookmarks/archive.html', context)
 
 
-def get_bookmark_view_context(request, query_set, base_url):
+def get_bookmark_view_context(request, query_set, tags, base_url):
     page = request.GET.get('page')
     query_string = request.GET.get('q')
     paginator = Paginator(query_set, _default_page_size)
     bookmarks = paginator.get_page(page)
-    tags = queries.query_tags(request.user, query_string)
     tag_names = [tag.name for tag in tags]
     tags_string = build_tag_string(tag_names, ' ')
     return_url = generate_return_url(base_url, page, query_string)
@@ -90,7 +90,7 @@ def new(request):
         if initial_auto_close:
             form.initial['auto_close'] = 'true'
 
-    all_tags = get_user_tags(request.user)
+    all_tags = queries.get_user_tags(request.user)
     context = {
         'form': form,
         'auto_close': initial_auto_close,
@@ -119,7 +119,7 @@ def edit(request, bookmark_id: int):
 
     form.initial['tag_string'] = build_tag_string(bookmark.tag_names, ' ')
     form.initial['return_url'] = return_url
-    all_tags = get_user_tags(request.user)
+    all_tags = queries.get_user_tags(request.user)
 
     context = {
         'form': form,