folio-migration-tools 1.2.1__py3-none-any.whl → 1.9.10__py3-none-any.whl

folio_migration_tools/transaction_migration/legacy_request.py

@@ -1,11 +1,18 @@
 import datetime
 import logging
 import uuid
+from zoneinfo import ZoneInfo
+
+from dateutil import tz
 from dateutil.parser import parse
 
+from folio_migration_tools.custom_exceptions import TransformationRecordFailedError
+
+utc = ZoneInfo("UTC")
+
 
 class LegacyRequest(object):
-    def __init__(self, legacy_request_dict, utc_difference=0, row=0):
+    def __init__(self, legacy_request_dict, tenant_timezone=utc, row=0):
         # validate
         correct_headers = [
             "item_barcode",
@@ -26,59 +33,70 @@ class LegacyRequest(object):
 
         self.item_barcode = legacy_request_dict["item_barcode"].strip()
         self.patron_id = ""
-        self.utc_difference = utc_difference
+        self.tenant_timezone = tenant_timezone
         self.item_id = ""
+        self.instance_id = ""
+        self.holdings_record_id = ""
         self.patron_barcode = legacy_request_dict["patron_barcode"].strip()
         self.comment = legacy_request_dict["comment"].strip()
         self.request_type = legacy_request_dict["request_type"].strip()
-        self.pickup_servicepoint_id = legacy_request_dict[
-            "pickup_servicepoint_id"
-        ].strip()
+        self.pickup_servicepoint_id = legacy_request_dict["pickup_servicepoint_id"].strip()
         self.fulfillment_preference = "Hold Shelf"
 
         if self.request_type not in ["Hold", "Recall", "Page"]:
             self.errors.append((f"{self.request_type} not allowd", "request_type"))
 
         try:
-            temp_request_date: datetime.datetime = parse(
-                legacy_request_dict["request_date"]
-            )
+            temp_request_date: datetime.datetime = parse(legacy_request_dict["request_date"])
+            if temp_request_date.tzinfo != tz.UTC:
+                temp_request_date = temp_request_date.replace(tzinfo=self.tenant_timezone)
         except Exception:
             self.errors.append(("Parse date failure. Setting UTC NOW", "request_date"))
-            temp_request_date = datetime.now(datetime.timezone.utc)
+            temp_request_date = datetime.now(ZoneInfo("UTC"))
         try:
             temp_expiration_date: datetime.datetime = parse(
                 legacy_request_dict["request_expiration_date"]
             )
+            if temp_expiration_date.tzinfo != tz.UTC:
+                temp_expiration_date = temp_expiration_date.replace(tzinfo=self.tenant_timezone)
         except Exception:
-            temp_expiration_date = datetime.now(datetime.timezone.utc)
-            self.errors.append(
-                ("Parse date failure. Setting UTC NOW", "request_expiration_date")
-            )
+            temp_expiration_date = datetime.now(ZoneInfo("UTC"))
+            self.errors.append(("Parse date failure. Setting UTC NOW", "request_expiration_date"))
+        if temp_expiration_date.hour == 0 and temp_expiration_date.minute == 0:
+            temp_expiration_date = temp_expiration_date.replace(hour=23, minute=59)
 
         self.request_date: datetime.datetime = temp_request_date
         self.request_expiration_date: datetime.datetime = temp_expiration_date
+        self.correct_for_1_day_requests()
+
+    def correct_for_1_day_requests(self):
         try:
-            self.make_request_utc()
-            if self.request_expiration_date <= self.request_date:
-                if self.request_expiration_date.hour == 0:
+            if self.request_expiration_date.date() <= self.request_date.date():
+                if (
+                    self.request_expiration_date.hour == 0
+                    and self.request_expiration_date.minute == 0
+                ):
                     self.request_expiration_date = self.request_expiration_date.replace(
                         hour=23, minute=59
                     )
-                if self.request_date.hour == 0:
+                if self.request_date.hour == 0 and self.request_date.minute == 0:
                     self.request_date = self.request_date.replace(hour=0, minute=1)
+            self.make_request_utc()
         except Exception as ee:
             logging.error(ee)
             self.errors.append(("Time alignment issues", "both dates"))
 
     def to_dict(self):
         return {
+            "requestLevel": "Item",
             "requestType": self.request_type,
             "fulfilmentPreference": self.fulfillment_preference,
             "requester": {"barcode": self.patron_barcode},
             "requesterId": self.patron_id,
             "item": {"barcode": self.item_barcode},
             "itemId": self.item_id,
+            "instanceId": self.instance_id,
+            "holdingsRecordId": self.holdings_record_id,
             "requestExpirationDate": self.request_expiration_date.isoformat(),
             "patronComments": self.comment,
             "pickupServicePointId": self.pickup_servicepoint_id,
@@ -86,6 +104,28 @@ class LegacyRequest(object):
             "id": str(uuid.uuid4()),
         }
 
+    def serialize(self):
+        req = self.to_dict()
+        required = [
+            "instanceId",
+            "requesterId",
+            "requestType",
+            "requestLevel",
+            "requestDate",
+            "holdingsRecordId",
+            "itemId",
+            "fulfilmentPreference",
+            "pickupServicePointId",
+        ]
+        if req["requestLevel"] == "Title":
+            required = [r for r in required if r not in ["itemId", "holdingsRecordId"]]
+        missing = [r for r in required if not req.get(r, "")]
+        if any(missing):
+            raise TransformationRecordFailedError(
+                "", "Required properties missing:" ", ".join(missing)
+            )
+        return req
+
     def to_source_dict(self):
         return {
             "item_barcode": self.item_barcode,
@@ -98,11 +138,11 @@ class LegacyRequest(object):
         }
 
     def make_request_utc(self):
-        if self.utc_difference != 0:
-            self.request_date = self.request_date + datetime.timedelta(
-                hours=self.utc_difference
-            )
-            self.request_expiration_date = (
-                self.request_expiration_date
-                + datetime.timedelta(hours=self.utc_difference)
-            )
+        try:
+            if self.tenant_timezone != ZoneInfo("UTC"):
+                self.request_date = self.request_date.astimezone(ZoneInfo("UTC"))
+                self.request_expiration_date = self.request_expiration_date.astimezone(
+                    ZoneInfo("UTC")
+                )
+        except Exception:
+            self.errors.append(("UTC correction issues", "both dates"))

folio_migration_tools/transaction_migration/legacy_reserve.py

@@ -0,0 +1,47 @@
+import uuid
+from typing import Dict, List, Tuple
+
+from folio_uuid.folio_namespaces import FOLIONamespaces
+from folio_uuid.folio_uuid import FolioUUID
+from folioclient import FolioClient
+
+from folio_migration_tools.custom_exceptions import TransformationProcessError
+
+
+class LegacyReserve(object):
+    def __init__(self, legacy_request_dict: Dict, folio_client: FolioClient, row: int = 0):
+        # validate
+        correct_headers = ["legacy_identifier", "item_barcode"]
+        for h in correct_headers:
+            if h not in legacy_request_dict:
+                raise TransformationProcessError(
+                    row,
+                    "Missing header in file. The following are required:",
+                    ", ".join(correct_headers),
+                )
+        self.errors: List[Tuple[str, str]] = [
+            ("Missing properties in legacy data", prop)
+            for prop in correct_headers
+            if prop not in legacy_request_dict
+        ]
+        self.id = str(uuid.uuid4())
+        self.item_barcode: str = legacy_request_dict["item_barcode"].strip()
+        if not self.item_barcode:
+            self.errors.append(("Missing data.", "item_barcode"))
+        self.legacy_identifier: str = legacy_request_dict["legacy_identifier"].strip()
+        if not self.legacy_identifier:
+            self.errors.append(("Missing data.", "legacy_identifier"))
+        self.course_listing_id: str = str(
+            FolioUUID(
+                folio_client.gateway_url,
+                FOLIONamespaces.course_listing,
+                legacy_request_dict["legacy_identifier"],
+            )
+        )
+
+    def to_dict(self):
+        return {
+            "courseListingId": self.course_listing_id,
+            "copiedItem": {"barcode": self.item_barcode},
+            "id": self.id,
+        }

folio_migration_tools/transaction_migration/transaction_result.py

@@ -1,9 +1,20 @@
+from typing import Any
+
+
 class TransactionResult(object):
+    __slots__ = [
+        "was_successful",
+        "folio_loan",
+        "should_be_retried",
+        "error_message",
+        "migration_report_message",
+    ]
+
     def __init__(
         self,
         was_successful: bool,
         should_be_retried: bool,
-        folio_loan: str,
+        folio_loan: Any,
         error_message: str,
         migration_report_message: str,
     ):