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

folio_migration_tools/migration_tasks/loans_migrator.py

@@ -1,30 +1,34 @@
 import copy
 import csv
-from datetime import datetime, timedelta
 import json
-import sys
-from dateutil import parser as du_parser
-import requests
 import logging
+import sys
 import time
 import traceback
+from datetime import datetime, timedelta
+from typing import Annotated, List, Literal, Optional
 from urllib.error import HTTPError
-from datetime import timezone
-from pydantic import BaseModel
-from folio_migration_tools.helper import Helper
+from zoneinfo import ZoneInfo
+from pydantic import Field
+
+import i18n
+from dateutil import parser as du_parser
 from folio_uuid.folio_namespaces import FOLIONamespaces
+from art import tprint
+
 from folio_migration_tools.circulation_helper import CirculationHelper
-from folio_migration_tools.custom_dict import InsensitiveDictReader
+from folio_migration_tools.custom_exceptions import TransformationRecordFailedError
+from folio_migration_tools.helper import Helper
 from folio_migration_tools.library_configuration import (
     FileDefinition,
     LibraryConfiguration,
 )
+from folio_migration_tools.mapping_file_transformation.mapping_file_mapper_base import (
+    MappingFileMapperBase,
+)
 from folio_migration_tools.migration_report import MigrationReport
 from folio_migration_tools.migration_tasks.migration_task_base import MigrationTaskBase
-
-from typing import Optional
-from folio_migration_tools.report_blurbs import Blurbs
-
+from folio_migration_tools.task_configuration import AbstractTaskConfiguration
 from folio_migration_tools.transaction_migration.legacy_loan import LegacyLoan
 from folio_migration_tools.transaction_migration.transaction_result import (
     TransactionResult,
@@ -32,15 +36,60 @@ from folio_migration_tools.transaction_migration.transaction_result import (
 
 
 class LoansMigrator(MigrationTaskBase):
-    class TaskConfiguration(BaseModel):
-        name: str
-        utc_difference: int
-        migration_task_type: str
-        open_loans_file: FileDefinition
-        fallback_service_point_id: str
-        starting_row: Optional[int] = 1
-        item_files: Optional[list[FileDefinition]] = []
-        patron_files: Optional[list[FileDefinition]] = []
+    class TaskConfiguration(AbstractTaskConfiguration):
+        name: Annotated[
+            str,
+            Field(
+                title="Task name",
+                description="The name of the task.",
+            ),
+        ]
+        migration_task_type: Annotated[
+            str,
+            Field(
+                title="Migration task type",
+                description="The type of the migration task.",
+            ),
+        ]
+        open_loans_files: Annotated[
+            Optional[list[FileDefinition]],
+            Field(
+                title="Open loans files",
+                description="List of files containing open loan data.",
+            ),
+        ]
+        fallback_service_point_id: Annotated[
+            str,
+            Field(
+                title="Fallback service point ID",
+                description="Identifier of the fallback service point.",
+            ),
+        ]
+        starting_row: Annotated[
+            Optional[int],
+            Field(
+                title="Starting row",
+                description=("The starting row for data processing. By default is 1."),
+            ),
+        ] = 1
+        item_files: Annotated[
+            Optional[list[FileDefinition]],
+            Field(
+                title="Item files",
+                description=(
+                    "List of files containing item data. By default is empty list."
+                ),
+            ),
+        ] = []
+        patron_files: Annotated[
+            Optional[list[FileDefinition]],
+            Field(
+                title="Patron files",
+                description=(
+                    "List of files containing patron data. By default is empty list."
+                ),
+            ),
+        ] = []
 
     @staticmethod
     def get_object_type() -> FOLIONamespaces:
@@ -50,31 +99,79 @@ class LoansMigrator(MigrationTaskBase):
         self,
         task_configuration: TaskConfiguration,
         library_config: LibraryConfiguration,
+        folio_client,
     ):
         csv.register_dialect("tsv", delimiter="\t")
+        self.patron_item_combos: set = set()
+        self.t0 = time.time()
+        self.num_duplicate_loans = 0
+        self.skipped_since_already_added = 0
+        self.processed_items: set = set()
+        self.failed: dict = {}
+        self.failed_and_not_dupe: dict = {}
         self.migration_report = MigrationReport()
-        self.valid_legacy_loans = []
-        super().__init__(library_config, task_configuration)
+        self.valid_legacy_loans: List[LegacyLoan] = []
+        super().__init__(library_config, task_configuration, folio_client)
         self.circulation_helper = CirculationHelper(
             self.folio_client,
             task_configuration.fallback_service_point_id,
             self.migration_report,
         )
-        with open(
-            self.folder_structure.legacy_records_folder
-            / task_configuration.open_loans_file.file_name,
-            "r",
-            encoding="utf-8",
-        ) as loans_file:
-            self.semi_valid_legacy_loans = list(
-                self.load_and_validate_legacy_loans(
-                    InsensitiveDictReader(loans_file, dialect="tsv")
-                )
-            )
-            logging.info(
-                "Loaded and validated %s loans in file",
-                len(self.semi_valid_legacy_loans),
+        logging.info("Check that SMTP is disabled before migrating loans")
+        self.check_smtp_config()
+        logging.info("Proceeding with loans migration")
+        logging.info("Attempting to retrieve tenant timezone configuration...")
+        my_path = "/configurations/entries?query=(module==ORG%20and%20configName==localeSettings)"
+        try:
+            self.tenant_timezone_str = json.loads(
+                self.folio_client.folio_get_single_object(my_path)["configs"][0][
+                    "value"
+                ]
+            )["timezone"]
+            logging.info("Tenant timezone is: %s", self.tenant_timezone_str)
+        except Exception:
+            logging.info('Tenant locale settings not available. Using "UTC".')
+            self.tenant_timezone_str = "UTC"
+        self.tenant_timezone = ZoneInfo(self.tenant_timezone_str)
+        self.semi_valid_legacy_loans = []
+        for file_def in task_configuration.open_loans_files:
+            loans_file_path = (
+                self.folder_structure.legacy_records_folder / file_def.file_name
             )
+            with open(loans_file_path, "r", encoding="utf-8") as loans_file:
+                total_rows, empty_rows, reader = (
+                    MappingFileMapperBase._get_delimited_file_reader(
+                        loans_file, loans_file_path
+                    )
+                )
+                logging.info("Source data file contains %d rows", total_rows)
+                logging.info("Source data file contains %d empty rows", empty_rows)
+                self.migration_report.set(
+                    "GeneralStatistics",
+                    f"Total rows in {loans_file_path.name}",
+                    total_rows,
+                )
+                self.migration_report.set(
+                    "GeneralStatistics",
+                    f"Empty rows in {loans_file_path.name}",
+                    empty_rows,
+                )
+                self.semi_valid_legacy_loans.extend(
+                    self.load_and_validate_legacy_loans(
+                        reader,
+                        file_def.service_point_id
+                        or task_configuration.fallback_service_point_id,
+                    )
+                )
+
+                logging.info(
+                    "Loaded and validated %s loans in file from %s",
+                    len(self.semi_valid_legacy_loans),
+                    file_def.file_name,
+                )
+        logging.info(
+            "Loaded and validated %s loans in total", len(self.semi_valid_legacy_loans)
+        )
         if any(self.task_configuration.item_files) or any(
             self.task_configuration.patron_files
         ):
@@ -89,34 +186,62 @@ class LoansMigrator(MigrationTaskBase):
                 "previously migrated objects"
             )
             self.valid_legacy_loans = self.semi_valid_legacy_loans
-        self.patron_item_combos = set()
-        self.t0 = time.time()
-        self.num_duplicate_loans = 0
-        self.skipped_since_already_added = 0
-        self.processed_items = set()
-        self.failed = {}
-        self.num_legacy_loans_processed = 0
-        self.failed_and_not_dupe = {}
-        logging.info("Starting row is %s", task_configuration.starting_row)
+        logging.info("Starting row number is %s", task_configuration.starting_row)
         logging.info("Init completed")
 
+    def check_smtp_config(self):
+        try:
+            smtp_config = self.folio_client.folio_get_single_object(
+                "/smtp-configuration"
+            )["smtpConfigurations"][0]
+            smtp_config_disabled = "disabled" in smtp_config["host"].lower()
+        except IndexError:
+            smtp_config_disabled = True
+        print_smtp_warning()
+        if not smtp_config_disabled:
+            logging.warn("SMTP connection not disabled...")
+            for i in range(10, 0, -1):
+                sys.stdout.write(
+                    "Pausing for {:02d} seconds. Press Ctrl+C to exit...\r".format(i)
+                )
+                time.sleep(1)
+        else:
+            logging.info("SMTP connection is disabled...")
+
     def do_work(self):
-        logging.info("Starting")
-        if self.task_configuration.starting_row > 1:
-            logging.info(f"Skipping {(self.task_configuration.starting_row-1)} records")
-        for num_loans, legacy_loan in enumerate(
-            self.valid_legacy_loans[self.task_configuration.starting_row :], start=1
-        ):
-            t0_migration = time.time()
-            self.migration_report.add_general_statistics("Processed loans")
-            try:
-                self.checkout_single_loan(legacy_loan)
-            except Exception as ee:
-                logging.exception(
-                    f"Error in row {num_loans}  Item barcode: {legacy_loan.item_barcode} Patron barcode: {legacy_loan.patron_barcode} {ee}"
+        with self.folio_client.get_folio_http_client() as self.http_client:
+            logging.info("Starting")
+            starting_index = (
+                self.task_configuration.starting_row - 1
+                if self.task_configuration.starting_row > 0
+                else 0
+            )
+            if self.task_configuration.starting_row > 1:
+                logging.info(f"Skipping {(starting_index)} records")
+            for num_loans, legacy_loan in enumerate(
+                self.valid_legacy_loans[starting_index:], start=1
+            ):
+                t0_migration = time.time()
+                self.migration_report.add_general_statistics(
+                    i18n.t("Processed pre-validated loans")
                 )
-            if num_loans % 25 == 0:
-                logging.info(f"{timings(self.t0, t0_migration, num_loans)} {num_loans}")
+                try:
+                    self.checkout_single_loan(legacy_loan)
+                except TransformationRecordFailedError as ee:
+                    logging.error(
+                        f"Transformation failed in row {num_loans}  Item barcode: {legacy_loan.item_barcode} "
+                        f"Patron barcode: {legacy_loan.patron_barcode}"
+                    )
+                    ee.log_it()
+                except Exception as ee:
+                    logging.exception(
+                        f"Error in row {num_loans}  Item barcode: {legacy_loan.item_barcode} "
+                        f"Patron barcode: {legacy_loan.patron_barcode} {ee}"
+                    )
+                if num_loans % 25 == 0:
+                    logging.info(
+                        f"{timings(self.t0, t0_migration, num_loans)} {num_loans}"
+                    )
 
     def checkout_single_loan(self, legacy_loan: LegacyLoan):
         """Checks a legacy loan out. Retries once if it fails.
@@ -127,30 +252,65 @@ class LoansMigrator(MigrationTaskBase):
         res_checkout = self.circulation_helper.check_out_by_barcode(legacy_loan)
 
         if res_checkout.was_successful:
-            self.migration_report.add(Blurbs.Details, "Checked out on first try")
+            self.migration_report.add("Details", i18n.t("Checked out on first try"))
+            self.migration_report.add_general_statistics(
+                i18n.t("Successfully checked out")
+            )
             self.set_renewal_count(legacy_loan, res_checkout)
             self.set_new_status(legacy_loan, res_checkout)
         elif res_checkout.should_be_retried:
             res_checkout2 = self.handle_checkout_failure(legacy_loan, res_checkout)
             if res_checkout2.was_successful and res_checkout2.folio_loan:
-                self.migration_report.add(Blurbs.Details, "Checked out on second try")
+                self.migration_report.add(
+                    "Details", i18n.t("Checked out on second try")
+                )
+                self.migration_report.add_general_statistics(
+                    i18n.t("Successfully checked out")
+                )
                 logging.info("Checked out on second try")
                 self.set_renewal_count(legacy_loan, res_checkout2)
                 self.set_new_status(legacy_loan, res_checkout2)
             elif legacy_loan.item_barcode not in self.failed:
-                self.failed[legacy_loan.item_barcode] = legacy_loan
-                logging.error("Failed on second try: %s", res_checkout2.error_message)
-                self.migration_report.add(
-                    Blurbs.Details,
-                    f"Second failure: {res_checkout2.migration_report_message}",
-                )
+                if res_checkout2.error_message == "Aged to lost and checked out":
+                    self.migration_report.add(
+                        "Details",
+                        i18n.t("Second failure")
+                        + f": {res_checkout2.migration_report_message}",
+                    )
+                    logging.error(
+                        f"{res_checkout2.error_message}. Item barcode: {legacy_loan.item_barcode}"
+                    )
+                else:
+                    self.failed[legacy_loan.item_barcode] = legacy_loan
+                    self.migration_report.add_general_statistics(i18n.t("Failed loans"))
+                    logging.error(
+                        "Failed on second try: %s", res_checkout2.error_message
+                    )
+                    self.migration_report.add(
+                        "Details",
+                        i18n.t("Second failure")
+                        + f": {res_checkout2.migration_report_message}",
+                    )
+                    raise TransformationRecordFailedError(
+                        f"Row {legacy_loan.row}",
+                        i18n.t("Loans failing during checkout, second try"),
+                        json.dumps(legacy_loan.to_dict()),
+                    )
         elif not res_checkout.should_be_retried:
             logging.error(
                 "Failed first time. No retries: %s", res_checkout.error_message
             )
+            self.migration_report.add_general_statistics(i18n.t("Failed loans"))
             self.migration_report.add(
-                Blurbs.Details,
-                f"Failed 1st time. No retries: {res_checkout.migration_report_message}",
+                "Details",
+                i18n.t("Failed 1st time. No retries")
+                + f": {res_checkout.migration_report_message}",
+            )
+            self.failed[legacy_loan.item_barcode] = legacy_loan
+            raise TransformationRecordFailedError(
+                f"Row {legacy_loan.row}",
+                i18n.t("Loans failing during checkout"),
+                json.dumps(legacy_loan.to_dict()),
             )
 
     def set_new_status(self, legacy_loan: LegacyLoan, res_checkout: TransactionResult):
@@ -174,45 +334,39 @@ class LoansMigrator(MigrationTaskBase):
         if legacy_loan.renewal_count > 0:
             self.update_open_loan(res_checkout.folio_loan, legacy_loan)
             self.migration_report.add_general_statistics(
-                "Updated renewal count for loan"
+                i18n.t("Updated renewal count for loan")
             )
 
     def wrap_up(self):
         for k, v in self.failed.items():
-            self.failed_and_not_dupe[k] = [v.to_dict()]
-        self.migration_report.set(
-            Blurbs.GeneralStatistics, "Failed loans", len(self.failed_and_not_dupe)
-        )
-        self.migration_report.set(
-            Blurbs.GeneralStatistics,
-            "Total Rows in file",
-            self.num_legacy_loans_processed,
-        )
+            self.failed_and_not_dupe[k] = [v if isinstance(v, dict) else v.to_dict()]
+        print(f"Wrapping up. Unique loans in failed:{len(self.failed_and_not_dupe)}")
 
         self.write_failed_loans_to_file()
 
         with open(self.folder_structure.migration_reports_file, "w+") as report_file:
-            report_file.write("# Loans migration results   \n")
-            report_file.write(
-                f"Time Finished: {datetime.isoformat(datetime.now(timezone.utc))}\n"
+            self.migration_report.write_migration_report(
+                i18n.t("Loans migration report"), report_file, self.start_datetime
             )
-            self.migration_report.write_migration_report(report_file)
+        self.clean_out_empty_logs()
 
     def write_failed_loans_to_file(self):
         csv_columns = [
-            "due_date",
+            "patron_barcode",
+            "proxy_patron_barcode",
             "item_barcode",
-            "next_item_status",
+            "due_date",
             "out_date",
-            "patron_barcode",
+            "next_item_status",
             "renewal_count",
+            "service_point_id",
         ]
         with open(self.folder_structure.failed_recs_path, "w+") as failed_loans_file:
             writer = csv.DictWriter(
                 failed_loans_file, fieldnames=csv_columns, dialect="tsv"
             )
             writer.writeheader()
-            for k, failed_loan in self.failed_and_not_dupe.items():
+            for _k, failed_loan in self.failed_and_not_dupe.items():
                 writer.writerow(failed_loan[0])
 
     def check_barcodes(self):
@@ -225,21 +379,36 @@ class LoansMigrator(MigrationTaskBase):
             user_barcodes, self.task_configuration.patron_files, self.folder_structure
         )
         for loan in self.semi_valid_legacy_loans:
-            has_item_barcode = loan.item_barcode in item_barcodes
-            has_patron_barcode = loan.patron_barcode in user_barcodes
-            if has_item_barcode and has_patron_barcode:
+            has_item_barcode = loan.item_barcode in item_barcodes or not any(
+                item_barcodes
+            )
+            has_patron_barcode = loan.patron_barcode in user_barcodes or not any(
+                user_barcodes
+            )
+            has_proxy_barcode = True
+            if loan.proxy_patron_barcode:
+                has_proxy_barcode = (
+                    loan.proxy_patron_barcode in user_barcodes or not any(user_barcodes)
+                )
+            if has_item_barcode and has_patron_barcode and has_proxy_barcode:
                 self.migration_report.add_general_statistics(
-                    "Loans verified against migrated user and item"
+                    i18n.t("Loans verified against migrated user and item")
                 )
                 yield loan
             else:
+                # Add this loan to failed loans for later correction and re-run.
+                self.failed[loan.item_barcode] = loan
+                self.migration_report.add_general_statistics(i18n.t("Failed loans"))
                 self.migration_report.add(
-                    Blurbs.DiscardedLoans,
-                    f"Loans discarded. Had migrated item barcode: {has_item_barcode}. "
-                    f"Had migrated user barcode: {has_patron_barcode}",
+                    "DiscardedLoans",
+                    i18n.t("Loans discarded. Had migrated item barcode")
+                    + f": {has_item_barcode}. "
+                    + i18n.t("Had migrated user barcode")
+                    + f": {has_patron_barcode}"
+                    + f": {has_proxy_barcode}",
                 )
             if not has_item_barcode:
-                Helper.log_data_issue(
+                Helper.log_data_issue_failed(
                     "", "Loan without matched item barcode", json.dumps(loan.to_dict())
                 )
             if not has_patron_barcode:
@@ -248,38 +417,72 @@ class LoansMigrator(MigrationTaskBase):
                     "Loan without matched patron barcode",
                     json.dumps(loan.to_dict()),
                 )
+            if not has_proxy_barcode:
+                Helper.log_data_issue_failed(
+                    "",
+                    "Loan without matched proxy patron barcode",
+                    json.dumps(loan.to_dict()),
+                )
 
-    def load_and_validate_legacy_loans(self, loans_reader):
+    def load_and_validate_legacy_loans(
+        self, loans_reader, service_point_id: str
+    ) -> list:
+        results = []
         num_bad = 0
         logging.info("Validating legacy loans in file...")
         for legacy_loan_count, legacy_loan_dict in enumerate(loans_reader):
             try:
                 legacy_loan = LegacyLoan(
                     legacy_loan_dict,
-                    self.task_configuration.utc_difference,
+                    service_point_id,
+                    self.migration_report,
+                    self.tenant_timezone,
                     legacy_loan_count,
                 )
                 if any(legacy_loan.errors):
                     num_bad += 1
-                    self.migration_report.add_general_statistics("Discarded Loans")
+                    self.migration_report.add_general_statistics(
+                        i18n.t("Loans failed pre-validation")
+                    )
+                    self.migration_report.add_general_statistics(i18n.t("Failed loans"))
                     for error in legacy_loan.errors:
                         self.migration_report.add(
-                            Blurbs.DiscardedLoans, f"{error[0]} - {error[1]}"
+                            "DiscardedLoans", f"{error[0]} - {error[1]}"
                         )
+                    # Add this loan to failed loans for later correction and re-run.
+                    self.failed[
+                        legacy_loan.item_barcode or f"no_barcode_{legacy_loan_count}"
+                    ] = legacy_loan
                 else:
-                    yield legacy_loan
+                    results.append(legacy_loan)
+            except TransformationRecordFailedError as trfe:
+                num_bad += 1
+                self.migration_report.add_general_statistics(
+                    i18n.t("Loans failed pre-validation")
+                )
+                self.migration_report.add(
+                    "DiscardedLoans",
+                    f"{trfe.message} - see data issues log",
+                )
+                trfe.log_it()
+                self.failed[
+                    legacy_loan_dict.get(
+                        "item_barcode", f"no_barcode_{legacy_loan_count}"
+                    )
+                ] = legacy_loan_dict
             except ValueError as ve:
                 logging.exception(ve)
         logging.info(
-            f"Done validating {legacy_loan_count} "
-            f"legacy loans with {num_bad} rotten apples"
+            f"Done validating {legacy_loan_count + 1} legacy loans out of which "
+            f"{num_bad} where discarded."
         )
-        if num_bad / legacy_loan_count > 0.5:
-            q = num_bad / legacy_loan_count
+        if num_bad / (legacy_loan_count + 1) > 0.5:
+            q = num_bad / (legacy_loan_count + 1)
             logging.error("%s percent of loans failed to validate.", (q * 100))
             self.migration_report.log_me()
             logging.critical("Halting...")
             sys.exit(1)
+        return results
 
     def handle_checkout_failure(
         self, legacy_loan, folio_checkout: TransactionResult
@@ -306,27 +509,38 @@ class LoansMigrator(MigrationTaskBase):
         elif folio_checkout.error_message.startswith(
             "Cannot check out item that already has an open loan"
         ):
-            return folio_checkout
-        elif folio_checkout.error_message.startswith("Aged to lost for item"):
-            return self.handle_aged_to_lost_item(legacy_loan)
+            return self.handle_checked_out_item(legacy_loan)
+        elif "Item is already checked out" in folio_checkout.error_message:
+            return self.handle_checked_out_item(legacy_loan)
+        elif "Aged to lost" in folio_checkout.error_message:
+            return self.handle_lost_item(legacy_loan, "Aged to lost")
         elif folio_checkout.error_message == "Declared lost":
-            return folio_checkout
+            return self.handle_lost_item(legacy_loan, "Declared lost")
         elif folio_checkout.error_message.startswith(
             "Cannot check out to inactive user"
         ):
-            return self.checkout_to_inactice_user(legacy_loan)
+            return self.checkout_to_inactive_user(legacy_loan)
+        elif (
+            "has the item status Claimed returned and cannot be checked out"
+            in folio_checkout.error_message
+        ):
+            return self.handle_claimed_returned_item(legacy_loan)
         else:
             self.migration_report.add(
-                Blurbs.Details,
-                f"Other checkout failure: {folio_checkout.error_message}",
+                "Details",
+                i18n.t("Other checkout failure") + f": {folio_checkout.error_message}",
             )
             # First failure. Add to list of failed loans
             if legacy_loan.item_barcode not in self.failed:
                 self.failed[legacy_loan.item_barcode] = legacy_loan
             else:
-                logging.debug(
-                    f"Loan already in failed. item barcode {legacy_loan.item_barcode} "
-                    f"Patron barcode: {legacy_loan.patron_barcode}"
+                logging.info(
+                    i18n.t("Loan already in failed.")
+                    + " "
+                    + i18n.t("item barcode")
+                    + f": {legacy_loan.item_barcode}"
+                    + i18n.t("Patron barcode")
+                    + f": {legacy_loan.patron_barcode}",
                 )
                 self.failed_and_not_dupe[legacy_loan.item_barcode] = [
                     legacy_loan,
@@ -337,12 +551,12 @@ class LoansMigrator(MigrationTaskBase):
                     f"{legacy_loan.item_barcode} Patron barcode: {legacy_loan.patron_barcode}"
                 )
                 self.migration_report.add(
-                    Blurbs.Details, "Duplicate loans (or failed twice)"
+                    "Details", i18n.t("Duplicate loans (or failed twice)")
                 )
                 del self.failed[legacy_loan.item_barcode]
             return TransactionResult(False, False, "", "", "")
 
-    def checkout_to_inactice_user(self, legacy_loan) -> TransactionResult:
+    def checkout_to_inactive_user(self, legacy_loan) -> TransactionResult:
         logging.info("Cannot check out to inactive user. Activating and trying again")
         user = self.get_user_by_barcode(legacy_loan.patron_barcode)
         expiration_date = user.get("expirationDate", datetime.isoformat(datetime.now()))
@@ -352,57 +566,135 @@ class LoansMigrator(MigrationTaskBase):
         res = self.circulation_helper.check_out_by_barcode(
             legacy_loan
         )  # checkout_and_update
-        self.migration_report.add(Blurbs.Details, res.migration_report_message)
+        if res.should_be_retried:
+            res = self.handle_checkout_failure(legacy_loan, res)
+        self.migration_report.add("Details", res.migration_report_message)
         self.deactivate_user(user, expiration_date)
         logging.debug("Successfully Deactivated user again")
-        self.migration_report.add(Blurbs.Details, "Handled inactive users")
+        self.migration_report.add("Details", i18n.t("Handled inactive users"))
         return res
 
-    def handle_aged_to_lost_item(self, legacy_loan) -> TransactionResult:
-        logging.debug("Setting Available")
-        legacy_loan.next_item_status = "Available"
-        self.set_item_status(legacy_loan)
-        res_checkout = self.circulation_helper.check_out_by_barcode(legacy_loan)
-        legacy_loan.next_item_status = "Aged to lost"
-        self.set_item_status(legacy_loan)
-        s = "Successfully Checked out Aged to lost item and put the status back"
-        logging.info(s)
-        self.migration_report.add(Blurbs.Details, s)
-        return res_checkout
+    def handle_checked_out_item(self, legacy_loan: LegacyLoan) -> TransactionResult:
+        if self.circulation_helper.is_checked_out(legacy_loan):
+            return TransactionResult(
+                False,
+                False,
+                legacy_loan,
+                i18n.t(
+                    "Loan already exists for %{item_barcode}",
+                    item_barcode=legacy_loan.item_barcode,
+                ),
+                i18n.t(
+                    "Loan already exists for %{item_barcode}",
+                    item_barcode=legacy_loan.item_barcode,
+                ),
+            )
+        else:
+            logging.debug(
+                i18n.t(
+                    'Setting item %{item_barcode} to status "Available"',
+                    item_barcode=legacy_loan.item_barcode,
+                )
+            )
+            legacy_loan.next_item_status = "Available"
+            self.set_item_status(legacy_loan)
+            res_checkout = self.circulation_helper.check_out_by_barcode(legacy_loan)
+            legacy_loan.next_item_status = "Checked out"
+            return res_checkout
+
+    def handle_lost_item(
+        self,
+        legacy_loan: LegacyLoan,
+        lost_type: Literal["Aged to lost", "Declared lost"],
+    ) -> TransactionResult:
+        if self.circulation_helper.is_checked_out(legacy_loan):
+            return TransactionResult(
+                False,
+                False,
+                legacy_loan,
+                i18n.t("%{lost_type} and checked out", lost_type=lost_type),
+                i18n.t("%{lost_type} and checked out", lost_type=lost_type),
+            )
+
+        else:
+            logging.debug(
+                'Setting item %{item_barcode} to status "Available"',
+                item_barcode=legacy_loan.item_barcode,
+            )
+            legacy_loan.next_item_status = "Available"
+            self.set_item_status(legacy_loan)
+            res_checkout = self.circulation_helper.check_out_by_barcode(legacy_loan)
+            legacy_loan.next_item_status = lost_type
+            if lost_type == "Aged to lost":
+                self.set_item_status(legacy_loan)
+                s = i18n.t(
+                    "Successfully Checked out %{lost_type} item and put the status back",
+                    lost_type=lost_type,
+                )
+            else:
+                s = i18n.t(
+                    "Successfully Checked out %{lost_type} item. Item will be declared lost.",
+                    lost_type=lost_type,
+                )
+            logging.info(s)
+            self.migration_report.add("Details", s)
+            return res_checkout
+
+    def handle_claimed_returned_item(self, legacy_loan: LegacyLoan):
+        if self.circulation_helper.is_checked_out(legacy_loan):
+            return TransactionResult(
+                False,
+                False,
+                legacy_loan,
+                i18n.t("Claimed returned and checked out"),
+                i18n.t("Claimed returned and checked out"),
+            )
+        else:
+            logging.debug(
+                'Setting item %{item_barcode} to status "Available"',
+                item_barcode=legacy_loan.item_barcode,
+            )
+            legacy_loan.next_item_status = "Available"
+            self.set_item_status(legacy_loan)
+            res_checkout = self.circulation_helper.check_out_by_barcode(legacy_loan)
+            legacy_loan.next_item_status = "Claimed returned"
+            return res_checkout
 
     def update_open_loan(self, folio_loan: dict, legacy_loan: LegacyLoan):
         due_date = du_parser.isoparse(str(legacy_loan.due_date))
         out_date = du_parser.isoparse(str(legacy_loan.out_date))
         renewal_count = legacy_loan.renewal_count
-        # TODO: add logging instead of print out
         try:
             loan_to_put = copy.deepcopy(folio_loan)
             del loan_to_put["metadata"]
             loan_to_put["dueDate"] = due_date.isoformat()
             loan_to_put["loanDate"] = out_date.isoformat()
             loan_to_put["renewalCount"] = renewal_count
-            url = f"{self.folio_client.okapi_url}/circulation/loans/{loan_to_put['id']}"
-            req = requests.put(
+            url = (
+                f"{self.folio_client.gateway_url}/circulation/loans/{loan_to_put['id']}"
+            )
+            req = self.http_client.put(
                 url,
                 headers=self.folio_client.okapi_headers,
-                data=json.dumps(loan_to_put),
+                json=loan_to_put,
             )
             if req.status_code == 422:
                 error_message = json.loads(req.text)["errors"][0]["message"]
                 s = f"Update open loan error: {error_message} {req.status_code}"
-                self.migration_report.add(Blurbs.Details, s)
+                self.migration_report.add("Details", s)
                 logging.error(s)
                 return False
             elif req.status_code in [201, 204]:
                 self.migration_report.add(
-                    Blurbs.Details,
-                    f"Successfully updated open loan ({req.status_code})",
+                    "Details",
+                    i18n.t("Successfully updated open loan") + f" ({req.status_code})",
                 )
                 return True
             else:
                 self.migration_report.add(
-                    Blurbs.Details,
-                    f"Update open loan error http status: {req.status_code}",
+                    "Details",
+                    i18n.t("Update open loan error http status")
+                    + f": {req.status_code}",
                 )
                 req.raise_for_status()
             logging.debug("Updating open loan was successful")
@@ -432,16 +724,17 @@ class LoansMigrator(MigrationTaskBase):
             "servicePointId": str(self.task_configuration.fallback_service_point_id),
         }
         logging.debug(f"Declare lost data: {json.dumps(data, indent=4)}")
-        if self.folio_put_post(declare_lost_url, data, "POST", "Declare item as lost"):
+        if self.folio_put_post(
+            declare_lost_url, data, "POST", i18n.t("Declare item as lost")
+        ):
             self.migration_report.add(
-                Blurbs.Details, "Successfully declared loan as lost"
+                "Details", i18n.t("Successfully declared loan as lost")
             )
         else:
             logging.error(f"Unsuccessfully declared loan {folio_loan} as lost")
             self.migration_report.add(
-                Blurbs.Details, "Unsuccessfully declared loan as lost"
+                "Details", i18n.t("Unsuccessfully declared loan as lost")
             )
-        # TODO: Exception handling
 
     def claim_returned(self, folio_loan):
         claim_returned_url = (
@@ -457,34 +750,44 @@ class LoansMigrator(MigrationTaskBase):
         }
         logging.debug(f"Claim returned data:\t{json.dumps(data)}")
         if self.folio_put_post(
-            claim_returned_url, data, "POST", "Declare item as lost"
+            claim_returned_url, data, "POST", i18n.t("Claim item returned")
         ):
             self.migration_report.add(
-                Blurbs.Details, "Successfully declared loan as Claimed returned"
+                "Details", i18n.t("Successfully declared loan as Claimed returned")
             )
         else:
             logging.error(
                 f"Unsuccessfully declared loan {folio_loan} as Claimed returned"
             )
             self.migration_report.add(
-                Blurbs.Details,
-                f"Unsuccessfully declared loan {folio_loan} as Claimed returned",
+                "Details",
+                i18n.t(
+                    "Unsuccessfully declared loan %{loan} as Claimed returned",
+                    loan=folio_loan,
+                ),
             )
-        # TODO: Exception handling
 
     def set_item_status(self, legacy_loan: LegacyLoan):
         try:
             # Get Item by barcode, update status.
-            item_url = f'{self.folio_client.okapi_url}/item-storage/items?query=(barcode=="{legacy_loan.item_barcode}")'
-            resp = requests.get(item_url, headers=self.folio_client.okapi_headers)
+            item_path = (
+                f'item-storage/items?query=(barcode=="{legacy_loan.item_barcode}")'
+            )
+            item_url = f"{self.folio_client.gateway_url}/{item_path}"
+            resp = self.http_client.get(
+                item_url, headers=self.folio_client.okapi_headers
+            )
             resp.raise_for_status()
             data = resp.json()
             folio_item = data["items"][0]
             folio_item["status"]["name"] = legacy_loan.next_item_status
             if self.update_item(folio_item):
                 self.migration_report.add(
-                    Blurbs.Details,
-                    f"Successfully set item status to {legacy_loan.next_item_status}",
+                    "Details",
+                    i18n.t(
+                        "Successfully set item status to %{status}",
+                        status=legacy_loan.next_item_status,
+                    ),
                 )
                 logging.debug(
                     f"Successfully set item with barcode "
@@ -498,8 +801,11 @@ class LoansMigrator(MigrationTaskBase):
                     f"{legacy_loan.item_barcode} to {legacy_loan.next_item_status}"
                 )
                 self.migration_report.add(
-                    Blurbs.Details,
-                    f"Error setting item status to {legacy_loan.next_item_status}",
+                    "Details",
+                    i18n.t(
+                        "Error setting item status to %{status}",
+                        status=legacy_loan.next_item_status,
+                    ),
                 )
         except Exception as ee:
             logging.error(
@@ -511,43 +817,43 @@ class LoansMigrator(MigrationTaskBase):
     def activate_user(self, user):
         user["active"] = True
         self.update_user(user)
-        self.migration_report.add(Blurbs.Details, "Successfully activated user")
+        self.migration_report.add("Details", i18n.t("Successfully activated user"))
 
     def deactivate_user(self, user, expiration_date):
         user["expirationDate"] = expiration_date
         user["active"] = False
         self.update_user(user)
-        self.migration_report.add(Blurbs.Details, "Successfully deactivated user")
+        self.migration_report.add("Details", i18n.t("Successfully deactivated user"))
 
     def update_item(self, item):
-        url = f'/item-storage/items/{item["id"]}'
-        return self.folio_put_post(url, item, "PUT", "Update item")
+        url = f"/item-storage/items/{item['id']}"
+        return self.folio_put_post(url, item, "PUT", i18n.t("Update item"))
 
     def update_user(self, user):
-        url = f'/users/{user["id"]}'
-        self.folio_put_post(url, user, "PUT", "Update user")
+        url = f"/users/{user['id']}"
+        self.folio_put_post(url, user, "PUT", i18n.t("Update user"))
 
     def get_user_by_barcode(self, barcode):
-        url = f'{self.folio_client.okapi_url}/users?query=(barcode=="{barcode}")'
-        resp = requests.get(url, headers=self.folio_client.okapi_headers)
+        url = f'{self.folio_client.gateway_url}/users?query=(barcode=="{barcode}")'
+        resp = self.http_client.get(url, headers=self.folio_client.okapi_headers)
         resp.raise_for_status()
         data = resp.json()
         return data["users"][0]
 
     def folio_put_post(self, url, data_dict, verb, action_description=""):
-        full_url = f"{self.folio_client.okapi_url}{url}"
+        full_url = f"{self.folio_client.gateway_url}{url}"
         try:
             if verb == "PUT":
-                resp = requests.put(
+                resp = self.http_client.put(
                     full_url,
                     headers=self.folio_client.okapi_headers,
-                    data=json.dumps(data_dict),
+                    json=data_dict,
                 )
             elif verb == "POST":
-                resp = requests.post(
+                resp = self.http_client.post(
                     full_url,
                     headers=self.folio_client.okapi_headers,
-                    data=json.dumps(data_dict),
+                    json=data_dict,
                 )
             else:
                 raise Exception("Bad verb")
@@ -555,18 +861,28 @@ class LoansMigrator(MigrationTaskBase):
                 error_message = json.loads(resp.text)["errors"][0]["message"]
                 logging.error(error_message)
                 self.migration_report.add(
-                    Blurbs.Details, f"{action_description} error: {error_message}"
+                    "Details",
+                    i18n.t(
+                        "%{action} error: %{message}",
+                        action=action_description,
+                        message=error_message,
+                    ),
                 )
                 resp.raise_for_status()
             elif resp.status_code in [201, 204]:
                 self.migration_report.add(
-                    Blurbs.Details,
-                    f"Successfully {action_description} ({resp.status_code})",
+                    "Details",
+                    i18n.t("Successfully %{action}", action=action_description)
+                    + f" ({resp.status_code})",
                 )
             else:
                 self.migration_report.add(
-                    Blurbs.Details,
-                    f"{action_description} error. http status: {resp.status_code}",
+                    "Details",
+                    i18n.t(
+                        "%{action} error. http status: %{status}",
+                        action=action_description,
+                        status=resp.status_code,
+                    ),
                 )
 
                 resp.raise_for_status()
@@ -579,38 +895,41 @@ class LoansMigrator(MigrationTaskBase):
 
     def change_due_date(self, folio_loan, legacy_loan):
         try:
-            t0_function = time.time()
-            api_url = f"{self.folio_client.okapi_url}/circulation/loans/{folio_loan['id']}/change-due-date"
+            api_path = f"{folio_loan['id']}/change-due-date"
+            api_url = f"{self.folio_client.gateway_url}/circulation/loans/{api_path}"
             body = {
                 "dueDate": du_parser.isoparse(str(legacy_loan.due_date)).isoformat()
             }
-            req = requests.post(
-                api_url, headers=self.folio_client.okapi_headers, data=json.dumps(body)
+            req = self.http_client.post(
+                api_url, headers=self.folio_client.okapi_headers, json=body
             )
             if req.status_code == 422:
                 error_message = json.loads(req.text)["errors"][0]["message"]
                 self.migration_report.add(
-                    Blurbs.Details, f"Change due date error: {error_message}"
+                    "Details", i18n.t("Change due date error") + f": {error_message}"
                 )
                 logging.info(
                     f"{error_message}\t",
                 )
-                self.migration_report.add(Blurbs.Details, error_message)
+                self.migration_report.add("Details", error_message)
                 return False
             elif req.status_code == 201:
                 self.migration_report.add(
-                    Blurbs.Details, f"Successfully changed due date ({req.status_code})"
+                    "Details",
+                    i18n.t("Successfully changed due date") + f" ({req.status_code})",
                 )
                 return True, json.loads(req.text), None
             elif req.status_code == 204:
                 self.migration_report.add(
-                    Blurbs.Details, f"Successfully changed due date ({req.status_code})"
+                    "Details",
+                    i18n.t("Successfully changed due date") + f" ({req.status_code})",
                 )
                 return True, None, None
             else:
                 self.migration_report.add(
-                    Blurbs.Details,
-                    f"Update open loan error http status: {req.status_code}",
+                    "Details",
+                    i18n.t("Update open loan error http status"),
+                    f": {req.status_code}",
                 )
                 req.raise_for_status()
         except HTTPError as exception:
@@ -621,18 +940,6 @@ class LoansMigrator(MigrationTaskBase):
             logging.info(exception)
             return False, None, None
 
-    def make_loan_utc(self, legacy_loan: LegacyLoan):
-        if self.task_configuration.utc_difference != 0:
-            legacy_loan.due_date = legacy_loan.due_date + timedelta(
-                hours=self.task_configuration.utc_difference
-            )
-            legacy_loan.out_date = legacy_loan.out_date + timedelta(
-                hours=self.task_configuration.utc_difference
-            )
-            self.migration_report.add_general_statistics(
-                "Adjusted out and due dates to UTC"
-            )
-
 
 def timings(t0, t0func, num_objects):
     avg = num_objects / (time.time() - t0)
@@ -642,3 +949,7 @@ def timings(t0, t0func, num_objects):
         f"Total objects: {num_objects}\tTotal elapsed: {elapsed:.2f}\t"
         f"Average per object: {avg:.2f}\tElapsed this time: {elapsed_func:.2f}"
     )
+
+
+def print_smtp_warning():
+    tprint("\nSMTP?\n", space=2)