rework thread for bookgrabbing

remove unneccessary while loop in run()
fix data application

src/logic/thread_bookgrabber.py

@@ -1,47 +1,48 @@
 import sqlite3
-import time
 
 from PyQt6.QtCore import QThread
 from PyQt6.QtCore import pyqtSignal as Signal
-
+from omegaconf import OmegaConf
 from src.backend.database import Database
 from src.logic.log import MyLogger
 from src.logic.webrequest import BibTextTransformer, WebRequest
 
-# from src.transformers import RDS_AVAIL_DATA
+config = OmegaConf.load("config.yaml")
 
 
 class BookGrabber(QThread):
     updateSignal = Signal(int, int)
     done = Signal()
 
-    def __init__(self, app_id, prof_id, mode, data, parent=None):
+    def __init__(self):
         super(BookGrabber, self).__init__(parent=None)
         self.is_Running = True
         self.logger = MyLogger("Worker")
         self.logger.log_info("Starting worker thread")
-        self.data = data
+        self.data = None
+        self.app_id = None
+        self.prof_id = None
+        self.mode = None
+        self.book_id = None
+        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
+
+    def add_values(self, app_id, prof_id, mode, data):
         self.app_id = app_id
         self.prof_id = prof_id
         self.mode = mode
-        self.book_id = None
+        self.data = data
-        self.state = (self.app_id, self.prof_id, self.mode, self.data)
+        self.logger.log_info(f"Working on {len(self.data)} entries")
-        time.sleep(2)
+        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
-
+        self.logger.log_debug("State: " + str(self.tstate))
-    # def resetValues(self):
+        print(self.tstate)
-    #     self.app_id = None
-    #     self.prof_id = None
-    #     self.mode = None
-    #     self.data = None
-    #     self.book_id = None
 
     def run(self):
-        while self.is_Running:
         self.db = Database()
         item = 0
         iterdata = self.data
         print(iterdata)
         for entry in iterdata:
+            print(entry)
             signature = str(entry)
             self.logger.log_info("Processing entry: " + signature)
 
@@ -49,37 +50,24 @@ class BookGrabber(QThread):
             if webdata == "error":
                 continue
             bd = BibTextTransformer(self.mode).get_data(webdata).return_data()
-                transformer = BibTextTransformer("RDS")
-                rds = transformer.get_data(webdata).return_data("rds_availability")
             bd.signature = entry
+            transformer = (
+                BibTextTransformer("RDS").get_data(webdata).return_data("rds_data")
+            )
             # 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 result in transformer.RDS_DATA:
-                for rds_item in rds.items:
+                print(result.RDS_LOCATION)
-                    sign = rds_item.superlocation
+                if str(self.app_id) in result.RDS_LOCATION:
-                    loc = rds_item.location
-                    # ic(sign, loc)
-                    # ic(rds_item)
-                    if self.app_id in sign or self.app_id in loc:
                     state = 1
                     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}")
-                print(
+            print("updating availability of " + str(self.book_id) + " to " + str(state))
-                    "updating availability of "
-                    + str(self.book_id)
-                    + " to "
-                    + str(state)
-                )
             try:
                 self.db.setAvailability(self.book_id, state)
             except sqlite3.OperationalError as e:
@@ -90,9 +78,92 @@ class BookGrabber(QThread):
             self.updateSignal.emit(item, len(self.data))
         self.logger.log_info("Worker thread finished")
         # self.done.emit()
-            self.stop()
+        self.quit()
-            if not self.is_Running:
-                break
 
     def stop(self):
         self.is_Running = False
+
+# class BookGrabber(object):
+#     updateSignal = Signal(int, int)
+#     done = Signal()
+
+#     def __init__(self, app_id, prof_id, mode, data, parent=None):
+#         super(BookGrabber, self).__init__(parent=None)
+#         self.is_Running = True
+#         self.logger = MyLogger("Worker")
+#         self.logger.log_info("Starting worker thread")
+#         self.data = data
+#         self.logger.log_info(f"Working on {len(self.data)} entries")
+#         self.app_id = app_id
+#         self.prof_id = prof_id
+#         self.mode = mode
+#         self.book_id = None
+#         self.state = (self.app_id, self.prof_id, self.mode, self.data)
+#         print(self.state)
+#         self.logger.log_info("state: " + str(self.state))
+#         # time.sleep(2)
+
+#     def resetValues(self):
+#         self.app_id = None
+#         self.prof_id = None
+#         self.mode = None
+#         self.data = None
+#         self.book_id = None
+
+#     def run(self):
+#         while self.is_Running:
+#             self.db = Database()
+#             item = 0
+#             iterdata = self.data
+#             print(iterdata)
+#             for entry in iterdata:
+#                 print(entry)
+#                 signature = str(entry)
+#                 self.logger.log_info("Processing entry: " + signature)
+
+#                 webdata = WebRequest().get_ppn(entry).get_data()
+#                 if webdata == "error":
+#                     continue
+#                 bd = BibTextTransformer(self.mode).get_data(webdata).return_data()
+#                 transformer = BibTextTransformer("RDS")
+#                 rds = transformer.get_data(webdata).return_data("rds_availability")
+#                 bd.signature = entry
+#                 # confirm lock is acquired
+#                 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:
+#                     sign = rds_item.superlocation
+#                     loc = rds_item.location
+#                     # ic(sign, loc)
+#                     # ic(rds_item)
+#                     if self.app_id in sign or self.app_id in loc:
+#                         state = 1
+#                         break
+
+#                 self.logger.log_info(f"State of {signature}: {state}")
+#                 print(
+#                     "updating availability of "
+#                     + str(self.book_id)
+#                     + " to "
+#                     + str(state)
+#                 )
+#                 try:
+#                     self.db.setAvailability(self.book_id, state)
+#                 except sqlite3.OperationalError as e:
+#                     self.logger.log_error(f"Failed to update availability: {e}")
+
+#                 # time.sleep(5)
+#                 item += 1
+#                 self.updateSignal.emit(item, len(self.data))
+#             self.logger.log_info("Worker thread finished")
+#             # self.done.emit()
+#             self.stop()
+#             if not self.is_Running:
+#                 break
+
+#     def stop(self):
+#         self.is_Running = False