toggle favorite tag via badge

Author: yedpodtrzitko

tagstudio/src/core/library/alchemy/library.py

@@ -23,7 +23,7 @@
     TagBoxTypes,
     TextField,
 )
-from .joins import TagField, TagSubtag
+from .joins import TagSubtag, TagField
 from .models import Entry, Preferences, Tag, TagAlias
 from ...constants import PREFS, TS_FOLDER_NAME, TAG_ARCHIVED, TAG_FAVORITE
 
@@ -118,25 +118,44 @@ def open_library(self, library_dir: Path | str) -> None:
 
     def delete_item(self, item):
         logger.info("deleting item", item=item)
-        with Session(self.engine) as session, session.begin():
+        with Session(self.engine) as session:
             session.delete(item)
             session.commit()
 
-    def remove_field_tag(self, field: TagBoxField, tag_id: int):
-        with Session(self.engine) as session, session.begin():
-            # remove instance of TagField matching combination of `field` and `tag_id`
-            session.delete(
-                session.scalar(
+    def remove_field_tag(self, entry: Entry, tag_id: int, field_type: TagBoxTypes):
+        with Session(self.engine) as session:
+            # find field matching entry and field_type
+            field = session.scalars(
+                select(TagBoxField).where(
+                    and_(
+                        TagBoxField.entry_id == entry.id,
+                        TagBoxField.type == field_type,
+                    )
+                )
+            ).first()
+
+            if not field:
+                logger.error("no field found", entry=entry, field=field)
+                return False
+
+            try:
+                # find the record in `TagField` table and delete it
+                tag_field = session.scalars(
                     select(TagField).where(
                         and_(
-                            TagField.field_id == field.id,
                             TagField.tag_id == tag_id,
+                            TagField.field_id == field.id,
                         )
                     )
-                )
-            )
-
-            session.commit()
+                ).first()
+                if tag_field:
+                    session.delete(tag_field)
+                    session.commit()
+                    return True
+            except IntegrityError as e:
+                logger.exception(e)
+                session.rollback()
+                return False
 
     def get_entry(self, entry_id: int) -> Entry | None:
         """Load entry without joins."""
@@ -153,7 +172,7 @@ def entries(self) -> list[Entry]:
         """Load all entries with joins.
         Debugging purposes only.
         """
-        with Session(self.engine) as session, session.begin():
+        with Session(self.engine) as session:
             stmt = (
                 select(Entry)
                 .outerjoin(Entry.text_fields)
@@ -469,7 +488,7 @@ def remove_field(
         field: Field,
         entry_ids: list[int],
     ) -> None:
-        with Session(self.engine) as session, session.begin():
+        with Session(self.engine) as session:
             fields = session.scalars(
                 select(field.__class__).where(
                     and_(
@@ -489,7 +508,7 @@ def update_field(
         entry_ids: list[int],
         mode: Literal["replace", "append", "remove"],
     ):
-        with Session(self.engine) as session, session.begin():
+        with Session(self.engine) as session:
             fields = session.scalars(
                 select(field.__class__).where(
                     and_(
@@ -571,7 +590,7 @@ def add_tag(self, tag: Tag, subtag_ids: list[int] | None = None) -> Tag | None:
                 return None
 
     def add_field_tag(self, entry: Entry, tag: Tag, field_type: TagBoxTypes) -> bool:
-        with Session(self.engine) as session, session.begin():
+        with Session(self.engine) as session:
             # find field matching entry and field_type
             field = session.scalars(
                 select(TagBoxField).where(
@@ -596,48 +615,6 @@ def add_field_tag(self, entry: Entry, tag: Tag, field_type: TagBoxTypes) -> bool
                 session.rollback()
                 return False
 
-    def add_tag_to_entry_meta_tags(self, tag: int | Tag, entry_id: int) -> None:
-        if isinstance(tag, Tag):
-            tag = tag.id
-
-        with Session(self.engine) as session, session.begin():
-            meta_tag_box = session.scalars(
-                select(TagBoxField).where(
-                    and_(
-                        TagBoxField.entry_id == entry_id,
-                        TagBoxField.type == TagBoxTypes.meta_tag_box,
-                    )
-                )
-            ).one()
-            tag = session.scalars(select(Tag).where(Tag.id == tag)).one()
-
-            meta_tag_box.tags.add(tag)
-
-    def remove_tag_from_entry_meta_tags(self, tag: int | Tag, entry_id: int) -> None:
-        if isinstance(tag, Tag):
-            tag = tag.id
-
-        with Session(self.engine) as session, session.begin():
-            meta_tag_box = session.scalars(
-                select(TagBoxField).where(
-                    and_(
-                        TagBoxField.entry_id == entry_id,
-                        TagBoxField.type == TagBoxTypes.meta_tag_box,
-                    )
-                )
-            ).one()
-            tag = session.scalars(select(Tag).where(Tag.id == tag)).one()
-
-            meta_tag_box.tags.remove(tag)
-
-    def entry_archived_favorited_status(self, entry: int | Entry) -> tuple[bool, bool]:
-        if isinstance(entry, Entry):
-            entry = entry.id
-        with Session(self.engine) as session, session.begin():
-            entry_ = session.scalars(select(Entry).where(Entry.id == entry)).one()
-
-            return (entry_.archived, entry_.favorited)
-
     def save_library_backup_to_disk(self, *args, **kwargs):
         logger.error("save_library_backup_to_disk to be implemented")
 

tagstudio/src/core/library/alchemy/models.py

@@ -129,7 +129,7 @@ def tags(self) -> set[Tag]:
         return tag_set
 
     @property
-    def favorited(self) -> bool:
+    def is_favorited(self) -> bool:
         for tag_box_field in self.tag_box_fields:
             for tag in tag_box_field.tags:
                 if tag.name == "Favorite":

tagstudio/src/qt/ts_qt.py

@@ -937,7 +937,7 @@ def _init_thumb_grid(self):
 
         for _ in range(self.filter.page_size):
             item_thumb = ItemThumb(
-                None, self.lib, self.preview_panel, (self.thumb_size, self.thumb_size)
+                None, self.lib, self, (self.thumb_size, self.thumb_size)
             )
             layout.addWidget(item_thumb)
             self.item_thumbs.append(item_thumb)

tagstudio/src/qt/widgets/item_thumb.py

@@ -4,7 +4,7 @@
 import time
 import typing
 from pathlib import Path
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
 import structlog
 from PIL import Image, ImageQt
@@ -26,19 +26,15 @@
     TAG_FAVORITE,
     TAG_ARCHIVED,
 )
-from src.core.library import ItemType, Entry
+from src.core.library import ItemType, Entry, Library
 from src.core.library.alchemy.fields import TagBoxTypes
 from src.qt.flowlayout import FlowWidget
 from src.qt.helpers.file_opener import FileOpenerHelper
 from src.qt.widgets.thumb_renderer import ThumbRenderer
 from src.qt.widgets.thumb_button import ThumbButton
 
-if typing.TYPE_CHECKING:
-    from src.qt.widgets.preview_panel import PreviewPanel
-
-ERROR = "[ERROR]"
-WARNING = "[WARNING]"
-INFO = "[INFO]"
+if TYPE_CHECKING:
+    from src.qt.ts_qt import QtDriver
 
 logger = structlog.get_logger(__name__)
 
@@ -86,16 +82,16 @@ class ItemThumb(FlowWidget):
 
     def __init__(
         self,
-        mode,
-        library,
-        panel: "PreviewPanel",
+        mode: ItemType,
+        library: Library,
+        driver: "QtDriver",
         thumb_size: tuple[int, int],
     ):
         """Modes: entry, collation, tag_group"""
         super().__init__()
         self.lib = library
-        self.panel = panel
         self.mode = mode
+        self.driver = driver
         self.item_id: int = -1
         self.is_favorite: bool = False
         self.is_archived: bool = False
@@ -451,27 +447,41 @@ def leaveEvent(self, event: QEvent) -> None:
         return super().leaveEvent(event)
 
     def on_archived_check(self, toggle_value: bool):
-        # if self.mode == ItemType.ENTRY:
         self.is_archived = toggle_value
-        self.toggle_item_tag(toggle_value, TAG_ARCHIVED)
+        for idx in self.driver.selected:
+            entry = self.driver.frame_content[idx]
+            self.toggle_item_tag(
+                entry, toggle_value, TAG_ARCHIVED, TagBoxTypes.meta_tag_box
+            )
 
     def on_favorite_check(self, toggle_value: bool):
-        # if self.mode == ItemType.ENTRY:
         self.is_favorite = toggle_value
-        self.toggle_item_tag(toggle_value, TAG_FAVORITE)
+        for idx in self.driver.selected:
+            entry = self.driver.frame_content[idx]
+            self.toggle_item_tag(
+                entry, toggle_value, TAG_FAVORITE, TagBoxTypes.meta_tag_box
+            )
 
-    def toggle_item_tag(self, toggle_value: bool, tag_id: int):
-        entry = self.panel.driver.frame_content[self.item_id]
+    def toggle_item_tag(
+        self, entry: Entry, toggle_value: bool, tag_id: int, field_type: TagBoxTypes
+    ):
+        logger.info(
+            "toggle_item_tag",
+            entry_id=entry.id,
+            toggle_value=toggle_value,
+            tag_id=tag_id,
+            field_type=field_type,
+        )
 
         tag = self.lib.get_tag(tag_id)
 
         if toggle_value:
             self.favorite_badge.setHidden(False)
-            self.lib.add_field_tag(entry, tag, TagBoxTypes.meta_tag_box)
+            self.lib.add_field_tag(entry, tag, field_type)
         else:
-            self.lib.remove_field_tag(entry, tag, TagBoxTypes.meta_tag_box)
+            self.lib.remove_field_tag(entry, tag.id, field_type)
 
-        if self.panel.is_open:
-            self.panel.update_widgets()
+        if self.driver.preview_panel.is_open:
+            self.driver.preview_panel.update_widgets()
 
-        self.panel.driver.update_badges()
+        self.driver.update_badges()

tagstudio/src/qt/widgets/preview_panel.py

@@ -837,7 +837,7 @@ def write_container(
                     window_title=f"Edit {field.name}",
                     save_callback=(
                         lambda content: (
-                            self.update_field(field, content),
+                            self.update_field(field, content),  # type: ignore
                             self.update_widgets(),
                         )
                     ),
@@ -999,15 +999,14 @@ def remove_field(self, field):
                     "Tried to remove field from Entry that never had it", entry=entry
                 )
 
-    def update_field(self, field, content):
+    def update_field(self, field, content) -> None:
         """Remove a field from all selected Entries, given a field object."""
         field = dict(field)
         for grid_idx in self.selected:
             entry = self.driver.frame_content[grid_idx]
             try:
-                logger.info(field)
                 index = entry.fields.index(field)
-                self.lib.update_entry_field(entry.id, index, content, "replace")
+                self.lib.update_field(index, content, [entry.id], "replace")
             except ValueError:
                 logger.exception(
                     "Tried to update field from Entry that never had it", entry=entry

tagstudio/src/qt/widgets/tag_box.py

@@ -13,7 +13,7 @@
 from src.core.constants import TAG_FAVORITE, TAG_ARCHIVED
 from src.core.library import Entry, Tag
 from src.core.library.alchemy.enums import FilterState
-from src.core.library.alchemy.fields import TagBoxField
+from src.core.library.alchemy.fields import TagBoxField, TagBoxTypes
 from src.qt.flowlayout import FlowLayout
 from src.qt.widgets.fields import FieldWidget
 from src.qt.widgets.tag import TagWidget
@@ -170,11 +170,9 @@ def remove_tag(self, tag_id: int):
 
         for grid_idx in self.driver.selected:
             entry = self.driver.frame_content[grid_idx]
-            # TODO - remove tag from correct field
             assert entry.fields
-            tag_field = entry.fields[0]
-
-            self.driver.lib.remove_field_tag(tag_field, tag_id)
+            # TODO - remove tag from correct field
+            self.driver.lib.remove_field_tag(entry, tag_id, TagBoxTypes.tag_box)
 
             self.updated.emit()
 

tagstudio/tests/qt/test_item_thumb.py

@@ -0,0 +1,26 @@
+import pytest
+
+from src.core.library import ItemType
+from src.qt.widgets.item_thumb import ItemThumb
+
+
+@pytest.mark.parametrize("toggle_value", (True, False))
+def test_toggle_favorite(qtbot, qt_driver, toggle_value):
+    # panel = PreviewPanel(qt_driver.lib, qt_driver)
+
+    entry = qt_driver.lib.entries[0]
+
+    qt_driver.frame_content = [entry]
+    qt_driver.selected = [0]
+
+    thumb = ItemThumb(ItemType.ENTRY, qt_driver.lib, qt_driver, (100, 100))
+
+    qtbot.addWidget(thumb)
+
+    thumb.on_favorite_check(toggle_value)
+
+    # reload entry
+    entry = qt_driver.lib.entries[0]
+
+    # check entry has favorite tag in meta tags field
+    assert entry.is_favorited == toggle_value