Fix #906: Inconsistent tag visibility in category views and shelves

Fixed an issue where books displayed tags in their detail view that users
couldn't access due to "allowed tags" content restrictions. When users
clicked these tags, no books would appear because the category view properly
applied the tag restrictions, creating an inconsistent experience.

Changes:
- Filter displayed tags in book detail view based on user's allowed/denied tags
- Add viewing_tag_id parameter to common_filters() to temporarily allow the
  viewed tag when filtering a specific tag category
- Update fill_indexpage() and fill_indexpage_with_archived_books() to pass
  viewing_tag_id through the query chain

Files modified:
- cps/web.py: Modified show_book() and render_category_books()
- cps/db.py: Modified common_filters(), fill_indexpage(), and
  fill_indexpage_with_archived_books()

Added:
- tests/unit/test_tag_filter_issue_906.py: Unit tests (all passing)
- scripts/diagnose_tag_issue_906.py: Diagnostic tool for troubleshooting
- docs/fix_issue_906.md: Comprehensive fix documentation

This ensures users only see tags they have permission to access, while still
allowing books to appear when viewing specific tag categories, providing a
consistent and intuitive user experience.

Author: crocodilestick

cps/db.py

@@ -862,7 +862,7 @@ def delete_dirty_metadata(self, book_id):
             log.error("Database error: {}".format(e))
 
     # Language and content filters for displaying in the UI
-    def common_filters(self, allow_show_archived=False, return_all_languages=False):
+    def common_filters(self, allow_show_archived=False, return_all_languages=False, viewing_tag_id=None):
         if not allow_show_archived:
             archived_books = (ub.session.query(ub.ArchivedBook)
                               .filter(ub.ArchivedBook.user_id==int(current_user.id))
@@ -880,6 +880,15 @@ def common_filters(self, allow_show_archived=False, return_all_languages=False):
         negtags_list = current_user.list_denied_tags()
         postags_list = current_user.list_allowed_tags()
         neg_content_tags_filter = false() if negtags_list == [''] else Books.tags.any(Tags.name.in_(negtags_list))
+        
+        # Issue #906: When viewing a specific tag category, include that tag in allowed tags
+        if viewing_tag_id is not None and postags_list != ['']:
+            # Get the tag name for the viewing_tag_id
+            viewing_tag = self.session.query(Tags).filter(Tags.id == viewing_tag_id).first()
+            if viewing_tag and viewing_tag.name not in postags_list:
+                # Temporarily add the viewed tag to the allowed list for this query
+                postags_list = postags_list + [viewing_tag.name]
+        
         pos_content_tags_filter = true() if postags_list == [''] else Books.tags.any(Tags.name.in_(postags_list))
         if self.config.config_restricted_column:
             try:
@@ -948,21 +957,22 @@ def get_checkbox_sorted(inputlist, state, offset, limit, order, combo=False):
 
     # Fill indexpage with all requested data from database
     def fill_indexpage(self, page, pagesize, database, db_filter, order,
-                       join_archive_read=False, config_read_column=0, *join):
+                       join_archive_read=False, config_read_column=0, *join, **kwargs):
         self.ensure_session()
         return self.fill_indexpage_with_archived_books(page, database, pagesize, db_filter, order, False,
-                                                       join_archive_read, config_read_column, *join)
+                                                       join_archive_read, config_read_column, *join, **kwargs)
 
     def fill_indexpage_with_archived_books(self, page, database, pagesize, db_filter, order, allow_show_archived,
-                                           join_archive_read, config_read_column, *join):
+                                           join_archive_read, config_read_column, *join, **kwargs):
         self.ensure_session()
+        viewing_tag_id = kwargs.get('viewing_tag_id')
         pagesize = pagesize or self.config.config_books_per_page
         if current_user.show_detail_random():
             random_query = self.generate_linked_query(config_read_column, database)
             # Eagerly load the data relationship for random books to prevent session errors
             if database == Books:
                 random_query = random_query.options(joinedload(Books.data))
-            randm = (random_query.filter(self.common_filters(allow_show_archived))
+            randm = (random_query.filter(self.common_filters(allow_show_archived, viewing_tag_id=viewing_tag_id))
                      .order_by(func.random())
                      .limit(self.config.config_random_books).all())
         else:
@@ -994,7 +1004,7 @@ def fill_indexpage_with_archived_books(self, page, database, pagesize, db_filter
                 indx -= 1
                 element += 1
         query = query.filter(db_filter)\
-            .filter(self.common_filters(allow_show_archived))
+            .filter(self.common_filters(allow_show_archived, viewing_tag_id=viewing_tag_id))
         entries = list()
         pagination = list()
         try:

cps/web.py

@@ -760,6 +760,7 @@ def render_category_books(page, book_id, order):
     else:
         tagsname = calibre_db.session.query(db.Tags).filter(db.Tags.id == book_id).first()
         if tagsname:
+            # Issue #906: Pass viewing_tag_id to allow this tag even if not in allowed tags
             entries, random, pagination = calibre_db.fill_indexpage(page, 0,
                                                                     db.Books,
                                                                     db.Books.tags.any(db.Tags.id == book_id),
@@ -768,7 +769,8 @@ def render_category_books(page, book_id, order):
                                                                     True, config.config_read_column,
                                                                     db.books_series_link,
                                                                     db.Books.id == db.books_series_link.c.book,
-                                                                    db.Series)
+                                                                    db.Series,
+                                                                    viewing_tag_id=book_id)
             tagsname = tagsname.name
         else:
             abort(404)
@@ -2612,6 +2614,19 @@ def show_book(book_id):
             book_in_shelves.append(sh.shelf)
 
         entry.tags = sort(entry.tags, key=lambda tag: tag.name)
+        
+        # Filter tags based on user's allowed/denied tags (Issue #906)
+        if current_user.is_authenticated:
+            allowed_tags = current_user.list_allowed_tags()
+            denied_tags = current_user.list_denied_tags()
+            
+            # If allowed tags are configured (not empty), filter to only show allowed tags
+            if allowed_tags and allowed_tags != ['']:
+                entry.tags = [tag for tag in entry.tags if tag.name in allowed_tags]
+            
+            # Remove denied tags
+            if denied_tags and denied_tags != ['']:
+                entry.tags = [tag for tag in entry.tags if tag.name not in denied_tags]
 
         entry.ordered_authors = calibre_db.order_authors([entry])