Refactor worker threads and add mock availability check

src/logic/threads.py

@@ -8,6 +8,7 @@ from src.logic.log import MyLogger
 from src.transformers import RDS_AVAIL_DATA
 from src.logic.webrequest import BibTextTransformer, WebRequest
 import sqlite3
+from icecream import ic
 
 class BookGrabber(QThread):
     updateSignal = pyqtSignal(int, int)
@@ -23,13 +24,14 @@ class BookGrabber(QThread):
         super().__init__(parent)
         self.logger = MyLogger("Worker")
         self.logger.log_info("Starting worker thread")
-        self.logger.log_info("Worker thread started")
         self.app_id = app_id
         self.prof_id = prof_id
         self.mode = mode
         self.data = data
         self.book_id = None
-
+        self.logger.log_info(f"Worker thread started, using mode:{self.mode} and app_id:{self.app_id} and prof_id:{self.prof_id}")
+        ic(self.app_id)
+        time.sleep(2)
     def run(self):
         self.db = Database()
         item = 0
@@ -44,42 +46,48 @@ class BookGrabber(QThread):
             transformer = BibTextTransformer("RDS")
             rds = transformer.get_data(webdata).return_data("rds_availability")
             bd.signature = entry
-                #confirm lock is acquired 
+            # confirm lock is acquired
             print("lock acquired, adding book to database")
             self.db.addBookToDatabase(bd, self.app_id, self.prof_id)
             # get latest book id
             self.book_id = self.db.getLastBookId()
             self.logger.log_info("Added book to database")
             state = 0
+            print(len(rds.items))
             for rds_item in rds.items:
+                ic(rds_item)
                 sign = rds_item.superlocation
                 loc = rds_item.location
                 # print(item.location)
                 if self.app_id in sign or self.app_id in loc:
                     state = 1
-                book_id = None
+                    break
+
                 # for book in self.books:
                 #     if book["bookdata"].signature == entry:
                 #         book_id = book["id"]
                 #         break
-                self.logger.log_info(f"State of {signature}: {state}")
+            self.logger.log_info(f"State of {signature}: {state}")
-                print(
+            print(
-                    "lock acquired, updating availability of "
+                "lock acquired, updating availability of "
-                    + str(book_id)
+                + str(self.book_id)
-                    + " to "
+                + " to "
-                    + str(state)
+                + str(state)
-                )
+            )
-                try:
+            try:
-                    self.db.setAvailability(self.book_id, state)
+                self.db.setAvailability(self.book_id, state)
-                except sqlite3.OperationalError as e:
+            except sqlite3.OperationalError as e:
-                    self.logger.log_error(f"Failed to update availability: {e}")
+                self.logger.log_error(f"Failed to update availability: {e}")
-                break
 
             # time.sleep(5)
             item += 1
             self.updateSignal.emit(item, len(self.data))
         self.logger.log_info("Worker thread finished")
         # teminate thread
+        self.app_id = None
+        self.prof_id = None
+        self.mode = None
+        self.data = None
 
         self.quit()
 
@@ -105,7 +113,9 @@ class AvailChecker(QThread):
         self.links = links
         self.appnumber = appnumber
         self.books = books
-
+        self.logger.log_info(f"Started worker with appnumber: {self.appnumber} and links: {self.links} and {len(self.books)} books...")
+        ic(self.appnumber)
+        time.sleep(2)
     def run(self):
         self.db = Database()
         state = 0
@@ -115,26 +125,27 @@ class AvailChecker(QThread):
             data = WebRequest().get_ppn(link).get_data()
             transformer = BibTextTransformer("RDS")
             rds = transformer.get_data(data).return_data("rds_availability")
-            print(rds)
+
+            book_id = None
             for item in rds.items:
                 sign = item.superlocation
                 loc = item.location
                 # print(item.location)
                 if self.appnumber in sign or self.appnumber in loc:
                     state = 1
-                book_id = None
+                    break
-                for book in self.books:
+            for book in self.books:
-                    if book["bookdata"].signature == link:
+                if book["bookdata"].signature == link:
-                        book_id = book["id"]
+                    book_id = book["id"]
-                        break
+                    break
-                self.logger.log_info(f"State of {link}: " + str(state))
+            self.logger.log_info(f"State of {link}: " + str(state))
-                print(
+            print(
-                    "lock acquired, updating availability of "
+                "Updating availability of "
-                    + str(book_id)
+                + str(book_id)
-                    + " to "
+                + " to "
-                    + str(state)
+                + str(state)
-                )
+            )
-                self.db.setAvailability(book_id, state)
+            self.db.setAvailability(book_id, state)
             count += 1
             self.updateProgress.emit(count, len(self.links))
             self.updateSignal.emit(item.callnumber, state)
@@ -189,3 +200,62 @@ class AutoAdder(QThread):
             self.logger.log_info("Worker thread finished")
             # teminate thread
             self.finished.emit()
+
+
+class MockAvailCheck:
+
+    def __init__(
+        self, links: list = [], appnumber: int = None, parent=None, books=list[dict]
+    ):
+        if links is None:
+            links = []
+        super().__init__(parent)
+        self.logger = MyLogger("MockAvailChecker")
+        self.logger.log_info("Starting worker thread")
+        self.logger.log_info(
+            "Checking availability for "
+            + str(links)
+            + " with appnumber "
+            + str(appnumber)
+            + "..."
+        )
+        self.links = links
+        self.appnumber = appnumber
+        self.books = books
+
+    def run(self):
+        self.db = Database()
+        state = 0
+        count = 0
+        result = []
+        for link in self.links:
+            self.logger.log_info("Processing entry: " + str(link))
+            data = WebRequest().get_ppn(link).get_data()
+            transformer = BibTextTransformer("RDS")
+            rds = transformer.get_data(data).return_data("rds_availability")
+
+            for item in rds.items:
+                sign = item.superlocation
+                loc = item.location
+                ic(item.location, item.superlocation)
+                if self.appnumber in sign or self.appnumber in loc:
+                    state = 1
+                book_id = None
+                for book in self.books:
+                    if book["bookdata"].signature == link:
+                        book_id = book["id"]
+                        break
+                self.logger.log_info(f"State of {link}: " + str(state))
+                print(
+                    "lock acquired, updating availability of "
+                    + str(book_id)
+                    + " to "
+                    + str(state)
+                )
+                result.append((item.callnumber, state))
+            count += 1
+        return result
+            
+
+        self.logger.log_info("Worker thread finished")
+        # teminate thread