folio-data-import 0.2.8rc12__py3-none-any.whl → 0.3.1__py3-none-any.whl

folio_data_import/UserImport.py

@@ -8,7 +8,7 @@ import time
 import uuid
 from datetime import datetime as dt
 from pathlib import Path
-from typing import Tuple
+from typing import Tuple, List
 
 import aiofiles
 import folioclient
@@ -51,6 +51,7 @@ class UserImporter:  # noqa: R0902
         user_match_key: str = "externalSystemId",
         only_update_present_fields: bool = False,
         default_preferred_contact_type: str = "002",
+        fields_to_protect: List[str] =[],
     ) -> None:
         self.limit_simultaneous_requests = limit_simultaneous_requests
         self.batch_size = batch_size
@@ -77,6 +78,7 @@ class UserImporter:  # noqa: R0902
         self.match_key = user_match_key
         self.lock: asyncio.Lock = asyncio.Lock()
         self.logs: dict = {"created": 0, "updated": 0, "failed": 0}
+        self.fields_to_protect = set(fields_to_protect)
 
     @staticmethod
     def build_ref_data_id_map(
@@ -137,7 +139,7 @@ class UserImporter:  # noqa: R0902
         match_key = "id" if ("id" in user_obj) else self.match_key
         try:
             existing_user = await self.http_client.get(
-                self.folio_client.okapi_url + "/users",
+                self.folio_client.gateway_url + "/users",
                 headers=self.folio_client.okapi_headers,
                 params={"query": f"{match_key}=={user_obj[match_key]}"},
             )
@@ -161,7 +163,7 @@ class UserImporter:  # noqa: R0902
         """
         try:
             existing_rp = await self.http_client.get(
-                self.folio_client.okapi_url
+                self.folio_client.gateway_url
                 + "/request-preference-storage/request-preference",
                 headers=self.folio_client.okapi_headers,
                 params={
@@ -188,7 +190,7 @@ class UserImporter:  # noqa: R0902
         """
         try:
             existing_pu = await self.http_client.get(
-                self.folio_client.okapi_url + "/perms/users",
+                self.folio_client.gateway_url + "/perms/users",
                 headers=self.folio_client.okapi_headers,
                 params={
                     "query": f"userId=={existing_user.get('id', user_obj.get('id', ''))}"
@@ -334,6 +336,7 @@ class UserImporter:  # noqa: R0902
             None
 
         """
+
         await self.set_preferred_contact_type(user_obj, existing_user)
         preferred_contact_type = {"preferredContactTypeId": existing_user.get("personal", {}).pop("preferredContactTypeId")}
         if self.only_update_present_fields:
@@ -369,7 +372,7 @@ class UserImporter:  # noqa: R0902
             else:
                 existing_user[key] = value
         create_update_user = await self.http_client.put(
-            self.folio_client.okapi_url + f"/users/{existing_user['id']}",
+            self.folio_client.gateway_url + f"/users/{existing_user['id']}",
             headers=self.folio_client.okapi_headers,
             json=existing_user,
         )
@@ -389,7 +392,7 @@ class UserImporter:  # noqa: R0902
             HTTPError: If the HTTP request to create the user fails.
         """
         response = await self.http_client.post(
-            self.folio_client.okapi_url + "/users",
+            self.folio_client.gateway_url + "/users",
             headers=self.folio_client.okapi_headers,
             json=user_obj,
         )
@@ -502,7 +505,9 @@ class UserImporter:  # noqa: R0902
 
     async def get_protected_fields(self, existing_user) -> dict:
         """
-        Retrieves the protected fields from the existing user object.
+        Retrieves the protected fields from the existing user object,
+        combining both the customFields.protectedFields list *and*
+        any fields_to_protect passed on the CLI.
 
         Args:
             existing_user (dict): The existing user object.
@@ -512,18 +517,19 @@ class UserImporter:  # noqa: R0902
         """
         protected_fields = {}
         protected_fields_list = existing_user.get("customFields", {}).get("protectedFields", "").split(",")
-        for field in protected_fields_list:
-            if len(field.split(".")) > 1:
-                field, subfield = field.split(".")
-                if field not in protected_fields:
-                    protected_fields[field] = {}
-                protected_fields[field][subfield] = existing_user.get(field, {}).pop(subfield, None)
-                if protected_fields[field][subfield] is None:
-                    protected_fields[field].pop(subfield)
+        cli_fields = list(self.fields_to_protect)
+        # combine and dedupe:
+        all_fields = list(dict.fromkeys(protected_fields_list + cli_fields))
+        for field in all_fields:
+            if "." in field:
+                fld, subfld = field.split(".", 1)
+                val = existing_user.get(fld, {}).pop(subfld, None)
+                if val is not None:
+                    protected_fields.setdefault(fld, {})[subfld] = val
             else:
-                protected_fields[field] = existing_user.pop(field, None)
-                if protected_fields[field] is None:
-                    protected_fields.pop(field)
+                val = existing_user.pop(field, None)
+                if val is not None:
+                    protected_fields[field] = val
         return protected_fields
 
     async def process_existing_user(self, user_obj) -> Tuple[dict, dict, dict, dict]:
@@ -589,7 +595,7 @@ class UserImporter:  # noqa: R0902
         rp_obj["userId"] = new_user_obj["id"]
         # print(rp_obj)
         response = await self.http_client.post(
-            self.folio_client.okapi_url
+            self.folio_client.gateway_url
             + "/request-preference-storage/request-preference",
             headers=self.folio_client.okapi_headers,
             json=rp_obj,
@@ -613,7 +619,7 @@ class UserImporter:  # noqa: R0902
         existing_rp.update(rp_obj)
         # print(existing_rp)
         response = await self.http_client.put(
-            self.folio_client.okapi_url
+            self.folio_client.gateway_url
             + f"/request-preference-storage/request-preference/{existing_rp['id']}",
             headers=self.folio_client.okapi_headers,
             json=existing_rp,
@@ -635,7 +641,7 @@ class UserImporter:  # noqa: R0902
         """
         perms_user_obj = {"userId": new_user_obj["id"], "permissions": []}
         response = await self.http_client.post(
-            self.folio_client.okapi_url + "/perms/users",
+            self.folio_client.gateway_url + "/perms/users",
             headers=self.folio_client.okapi_headers,
             json=perms_user_obj,
         )
@@ -788,7 +794,7 @@ class UserImporter:  # noqa: R0902
         """
         try:
             existing_spu = await self.http_client.get(
-                self.folio_client.okapi_url + "/service-points-users",
+                self.folio_client.gateway_url + "/service-points-users",
                 headers=self.folio_client.okapi_headers,
                 params={"query": f"userId=={existing_user['id']}"},
             )
@@ -812,7 +818,7 @@ class UserImporter:  # noqa: R0902
         """
         spu_obj["userId"] = existing_user["id"]
         response = await self.http_client.post(
-            self.folio_client.okapi_url + "/service-points-users",
+            self.folio_client.gateway_url + "/service-points-users",
             headers=self.folio_client.okapi_headers,
             json=spu_obj,
         )
@@ -831,7 +837,7 @@ class UserImporter:  # noqa: R0902
         """
         existing_spu.update(spu_obj)
         response = await self.http_client.put(
-            self.folio_client.okapi_url + f"/service-points-users/{existing_spu['id']}",
+            self.folio_client.gateway_url + f"/service-points-users/{existing_spu['id']}",
             headers=self.folio_client.okapi_headers,
             json=existing_spu,
         )
@@ -896,6 +902,7 @@ async def main() -> None:
         --update_only_present_fields (bool): Only update fields that are present in the new user object.
         --default_preferred_contact_type (str): The default preferred contact type to use if the provided \
             value is not valid or not present. Default "002".
+        --fields_to_protect (str): Comma-separated list of top-level or nested (dot-notation) fields to protect.
 
     Raises:
         Exception: If an unknown error occurs during the import process.
@@ -953,7 +960,20 @@ async def main() -> None:
         choices=list(PREFERRED_CONTACT_TYPES_MAP.keys()) + list(PREFERRED_CONTACT_TYPES_MAP.values()),
         default="002",
     )
+    parser.add_argument(
+        "--fields-to-protect",  # new flag name
+        dest="fields_to_protect",  # sets args.fields_to_protect
+        help=(
+            "Comma-separated list of top-level user fields to protect "
+            "(e.g. type,expirationDate)"
+        ),
+        default="",
+    )
     args = parser.parse_args()
+    protect_fields = [
+        f.strip() for f in args.fields_to_protect.split(",")
+        if f.strip()
+    ]
 
     library_name = args.library_name
 
@@ -1005,6 +1025,7 @@ async def main() -> None:
                 args.user_match_key,
                 args.update_only_present_fields,
                 args.default_preferred_contact_type,
+                fields_to_protect=protect_fields,
             )
             await importer.do_import()
         except Exception as ee:

folio_data_import/custom_exceptions.py

@@ -0,0 +1,29 @@
+"""Custom exceptions for the Folio Data Import module."""
+
+class FolioDataImportError(Exception):
+    """Base class for all exceptions in the Folio Data Import module."""
+    pass
+
+class FolioDataImportBatchError(FolioDataImportError):
+    """Exception raised for errors in the Folio Data Import batch process.
+    
+    Attributes:
+        batch_id -- ID of the batch that caused the error
+        message -- explanation of the error
+    """
+    def __init__(self, batch_id, message, exception=None):
+        self.batch_id = batch_id
+        self.message = message
+        super().__init__(f"Unhandled error posting batch {batch_id}: {message}")
+
+class FolioDataImportJobError(FolioDataImportError):
+    """Exception raised for errors in the Folio Data Import job process.
+
+    Attributes:
+        job_id -- ID of the job that caused the error
+        message -- explanation of the error
+    """
+    def __init__(self, job_id, message, exception=None):
+        self.job_id = job_id
+        self.message = message
+        super().__init__(f"Unhandled error processing job {job_id}: {message}")

folio_data_import/marc_preprocessors/_preprocessors.py

@@ -1,69 +1,171 @@
+import importlib
+import sys
+from typing import Callable, Dict, List, Tuple, Union
 import pymarc
 import logging
 
+from pymarc.record import Record
+
 logger = logging.getLogger("folio_data_import.MARCDataImport")
 
+class MARCPreprocessor:
+    """
+    A class to preprocess MARC records for data import into FOLIO.
+    """
+
+    def __init__(self, preprocessors: Union[str,List[Callable]], **kwargs):
+        """
+        Initialize the MARCPreprocessor with a list of preprocessors.
+
+        Args:
+            preprocessors (Union[str, List[Callable]]): A string of comma-separated function names or a list of callable preprocessor functions to apply.
+        """
+        self.preprocessor_args: Dict[str, Dict] = kwargs
+        self.preprocessors: List[Tuple[Callable, Dict]] = self._get_preprocessor_functions(
+            preprocessors
+        )
+        self.proc_kwargs = kwargs
+        self.record = None
+
+    def _get_preprocessor_args(self, func: Callable) -> Dict:
+        """
+        Get the arguments for the preprocessor function.
+
+        Args:
+            func (Callable): The preprocessor function.
+
+        Returns:
+            Dict: A dictionary of arguments for the preprocessor function.
+        """
+        func_path = f"{func.__module__}.{func.__name__}"
+        path_args: Dict = self.preprocessor_args.get("default", {})
+        path_args.update(self.preprocessor_args.get(func.__name__, {}))
+        path_args.update(self.preprocessor_args.get(func_path, {}))
+        return path_args
+
+    def _get_preprocessor_functions(self, func_list: Union[str, List[Callable]]) -> List[Callable]:
+        """
+        Get the preprocessor functions based on the provided names.
+
+        Args:
+            func_list (Union[str, List[Callable]]): A string of comma-separated function names or a list of callable preprocessor functions.
+
+        Returns:
+            List[callable]: A list of preprocessor functions.
+        """
+        preprocessors = []
+        if isinstance(func_list, str):
+            func_list = func_list.split(",")
+        else:
+            for f in func_list:
+                if not callable(f):
+                    logger.warning(
+                        f"Preprocessing function {f} is not callable. Skipping."
+                    )
+                else:
+                    preprocessors.append((f, self._get_preprocessor_args(f)))
+            return preprocessors
+        for f_path in func_list:
+            f_import = f_path.rsplit(".", 1)
+            if len(f_import) == 1:
+                # If the function is not a full path, assume it's in the current module
+                if func := getattr(sys.modules[__name__], f_import[0], None):
+                    if callable(func):
+                        preprocessors.append((func, self._get_preprocessor_args(func)))
+                    else:
+                        logger.warning(
+                            f"Preprocessing function {f_path} is not callable. Skipping."
+                        )
+                else:
+                    logger.warning(
+                        f"Preprocessing function {f_path} not found in current module. Skipping."
+                    )
+            elif len(f_import) == 2:
+                # If the function is a full path, import it
+                module_path, func_name = f_import
+                try:
+                    module = importlib.import_module(module_path)
+                    func = getattr(module, func_name)
+                    preprocessors.append((func, self._get_preprocessor_args(func)))
+                except ImportError as e:
+                    logger.warning(
+                        f"Error importing preprocessing function {f_path}: {e}. Skipping."
+                    )
+        return preprocessors
+
+    def do_work(self, record: Record) -> Record:
+        """
+        Preprocess the MARC record.
+        """
+        for proc, kwargs in self.preprocessors:
+            record = proc(record, **kwargs)
+        return record
 
-def prepend_prefix_001(record: pymarc.Record, prefix: str) -> pymarc.Record:
+
+
+def prepend_prefix_001(record: Record, prefix: str) -> Record:
     """
     Prepend a prefix to the record's 001 field.
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
         prefix (str): The prefix to prepend to the 001 field.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
-    record["001"].data = f"({prefix})" + record["001"].data
+    if "001" in record:
+        record["001"].data = f"({prefix})" + record["001"].data
+    else:
+        logger.warning("Field '001' not found in record. Skipping prefix prepend.")
     return record
 
 
-def prepend_ppn_prefix_001(record: pymarc.Record) -> pymarc.Record:
+def prepend_ppn_prefix_001(record: Record, **kwargs) -> Record:
     """
     Prepend the PPN prefix to the record's 001 field. Useful when
     importing records from the ABES SUDOC catalog
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
     return prepend_prefix_001(record, "PPN")
 
 
-def prepend_abes_prefix_001(record: pymarc.Record) -> pymarc.Record:
+def prepend_abes_prefix_001(record: Record, **kwargs) -> Record:
     """
     Prepend the ABES prefix to the record's 001 field. Useful when
     importing records from the ABES SUDOC catalog
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
     return prepend_prefix_001(record, "ABES")
 
 
-def strip_999_ff_fields(record: pymarc.Record) -> pymarc.Record:
+def strip_999_ff_fields(record: Record, **kwargs) -> Record:
     """
     Strip all 999 fields with ff indicators from the record.
     Useful when importing records exported from another FOLIO system
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
     for field in record.get_fields("999"):
         if field.indicators == pymarc.Indicators(*["f", "f"]):
             record.remove_field(field)
     return record
 
-def clean_999_fields(record: pymarc.Record) -> pymarc.Record:
+def clean_999_fields(record: Record, **kwargs) -> Record:
     """
     The presence of 999 fields, with or without ff indicators, can cause
     issues with data import mapping in FOLIO. This function calls strip_999_ff_fields
@@ -71,10 +173,10 @@ def clean_999_fields(record: pymarc.Record) -> pymarc.Record:
     to 945 fields.
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
     record = strip_999_ff_fields(record)
     for field in record.get_fields("999"):
@@ -87,7 +189,31 @@ def clean_999_fields(record: pymarc.Record) -> pymarc.Record:
         record.remove_field(field)
     return record
 
-def sudoc_supercede_prep(record: pymarc.Record) -> pymarc.Record:
+def clean_non_ff_999_fields(record: Record, **kwargs) -> Record:
+    """
+    When loading migrated MARC records from folio_migration_tools, the presence of other 999 fields
+    than those set by the migration process can cause the record to fail to load properly. This preprocessor
+    function moves all 999 fields with non-ff indicators to 945 fields with 99 indicators.
+    """
+    for field in record.get_fields("999"):
+        if field.indicators != pymarc.Indicators(*["f", "f"]):
+            logger.log(
+                26,
+                "DATA ISSUE\t%s\t%s\t%s",
+                record["001"].value(),
+                "Record contains a 999 field with non-ff indicators: Moving field to a 945 with indicators \"99\"",
+                field,
+            )
+            _945 = pymarc.Field(
+                tag="945",
+                indicators=pymarc.Indicators("9","9"),
+                subfields=field.subfields,
+            )
+            record.add_ordered_field(_945)
+            record.remove_field(field)
+    return record
+
+def sudoc_supercede_prep(record: Record, **kwargs) -> Record:
     """
     Preprocesses a record from the ABES SUDOC catalog to copy 035 fields
     with a $9 subfield value of 'sudoc' to 935 fields with a $a subfield
@@ -96,10 +222,10 @@ def sudoc_supercede_prep(record: pymarc.Record) -> pymarc.Record:
     in FOLIO. This also applyes the prepend_ppn_prefix_001 function to the record.
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
     record = prepend_abes_prefix_001(record)
     for field in record.get_fields("035"):
@@ -113,7 +239,7 @@ def sudoc_supercede_prep(record: pymarc.Record) -> pymarc.Record:
     return record
 
 
-def clean_empty_fields(record: pymarc.Record) -> pymarc.Record:
+def clean_empty_fields(record: Record, **kwargs) -> Record:
     """
     Remove empty fields and subfields from the record. These can cause
     data import mapping issues in FOLIO. Removals are logged at custom
@@ -121,10 +247,10 @@ def clean_empty_fields(record: pymarc.Record) -> pymarc.Record:
     data issues report.
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
     MAPPED_FIELDS = {
         "010": ["a", "z"],
@@ -233,73 +359,72 @@ def clean_empty_fields(record: pymarc.Record) -> pymarc.Record:
         "856": ["u", "y", "z"],
     }
 
-    for field in list(record.get_fields()):
+    for field in record.get_fields(*MAPPED_FIELDS.keys()):
         len_subs = len(field.subfields)
-        subfield_value = bool(field.subfields[0].value) if len_subs > 0 else False
-        if not int(field.tag) >= 900 and field.tag in MAPPED_FIELDS:
-            if int(field.tag) > 9 and len_subs == 0:
+        subfield_value = bool(field.subfields[0].value) if len_subs else False
+        if int(field.tag) > 9 and len_subs == 0:
+            logger.log(
+                26,
+                "DATA ISSUE\t%s\t%s\t%s",
+                record["001"].value(),
+                f"{field.tag} is empty, removing field",
+                field,
+            )
+            record.remove_field(field)
+        elif len_subs == 1 and not subfield_value:
+            logger.log(
+                26,
+                "DATA ISSUE\t%s\t%s\t%s",
+                record["001"].value(),
+                f"{field.tag}${field.subfields[0].code} is empty, no other subfields present, removing field",
+                field,
+            )
+            record.remove_field(field)
+        else:
+            if len_subs > 1 and "a" in field and not field["a"].strip():
                 logger.log(
                     26,
                     "DATA ISSUE\t%s\t%s\t%s",
                     record["001"].value(),
-                    f"{field.tag} is empty, removing field",
+                    f"{field.tag}$a is empty, removing subfield",
                     field,
                 )
-                record.remove_field(field)
-            elif len_subs == 1 and not subfield_value:
+                field.delete_subfield("a")
+            for idx, subfield in enumerate(list(field.subfields), start=1):
+                if (
+                    subfield.code in MAPPED_FIELDS.get(field.tag, [])
+                    and not subfield.value
+                ):
+                    logger.log(
+                        26,
+                        "DATA ISSUE\t%s\t%s\t%s",
+                        record["001"].value(),
+                        f"{field.tag}${subfield.code} ({ordinal(idx)} subfield) is empty, but other subfields have values, removing subfield",
+                        field,
+                    )
+                    field.delete_subfield(subfield.code)
+            if len(field.subfields) == 0:
                 logger.log(
                     26,
                     "DATA ISSUE\t%s\t%s\t%s",
                     record["001"].value(),
-                    f"{field.tag}${field.subfields[0].code} is empty, no other subfields present, removing field",
+                    f"{field.tag} has no non-empty subfields after cleaning, removing field",
                     field,
                 )
                 record.remove_field(field)
-            else:
-                if len_subs > 1 and "a" in field and not field["a"].strip():
-                    logger.log(
-                        26,
-                        "DATA ISSUE\t%s\t%s\t%s",
-                        record["001"].value(),
-                        f"{field.tag}$a is empty, removing subfield",
-                        field,
-                    )
-                    field.delete_subfield("a")
-                for idx, subfield in enumerate(list(field.subfields), start=1):
-                    if (
-                        subfield.code in MAPPED_FIELDS.get(field.tag, [])
-                        and not subfield.value
-                    ):
-                        logger.log(
-                            26,
-                            "DATA ISSUE\t%s\t%s\t%s",
-                            record["001"].value(),
-                            f"{field.tag}${subfield.code} ({ordinal(idx)} subfield) is empty, but other subfields have values, removing subfield",
-                            field,
-                        )
-                        field.delete_subfield(subfield.code)
-                if len(field.subfields) == 0:
-                    logger.log(
-                        26,
-                        "DATA ISSUE\t%s\t%s\t%s",
-                        record["001"].value(),
-                        f"{field.tag} has no non-empty subfields after cleaning, removing field",
-                        field,
-                    )
-                    record.remove_field(field)
     return record
 
 
-def fix_leader(record: pymarc.Record) -> pymarc.Record:
+def fix_leader(record: Record, **kwargs) -> Record:
     """
     Fixes the leader of the record by setting the record status to 'c' (modified
     record) and the type of record to 'a' (language material).
 
     Args:
-        record (pymarc.Record): The MARC record to preprocess.
+        record (Record): The MARC record to preprocess.
 
     Returns:
-        pymarc.Record: The preprocessed MARC record.
+        Record: The preprocessed MARC record.
     """
     VALID_STATUSES = ["a", "c", "d", "n", "p"]
     VALID_TYPES = ["a", "c", "d", "e", "f", "g", "i", "j", "k", "m", "o", "p", "r", "t"]
@@ -309,7 +434,7 @@ def fix_leader(record: pymarc.Record) -> pymarc.Record:
             "DATA ISSUE\t%s\t%s\t%s",
             record["001"].value(),
             f"Invalid record status: {record.leader[5]}, setting to 'c'",
-            record,
+            record.leader,
         )
         record.leader = pymarc.Leader(record.leader[:5] + "c" + record.leader[6:])
     if record.leader[6] not in VALID_TYPES:
@@ -318,11 +443,40 @@ def fix_leader(record: pymarc.Record) -> pymarc.Record:
             "DATA ISSUE\t%s\t%s\t%s",
             record["001"].value(),
             f"Invalid record type: {record.leader[6]}, setting to 'a'",
-            record,
+            record.leader,
         )
         record.leader = pymarc.Leader(record.leader[:6] + "a" + record.leader[7:])
     return record
 
+def move_authority_subfield_9_to_0_all_controllable_fields(record: Record, **kwargs) -> Record:
+    """
+    Move subfield 9 from authority fields to subfield 0. This is useful when
+    importing records from the ABES SUDOC catalog.
+
+    Args:
+        record (Record): The MARC record to preprocess.
+
+    Returns:
+        Record: The preprocessed MARC record.
+    """
+    controlled_fields = [
+            "100", "110", "111", "130",
+            "600", "610", "611", "630", "650", "651", "655",
+            "700", "710", "711", "730",
+            "800", "810", "811", "830"
+        ]
+    for field in record.get_fields(*controlled_fields):
+        for subfield in list(field.get_subfields("9")):
+            field.add_subfield("0", subfield)
+            field.delete_subfield("9", subfield)
+            logger.log(
+                26,
+                "DATA ISSUE\t%s\t%s\t%s",
+                record["001"].value(),
+                f"Subfield 9 moved to subfield 0 in {field.tag}",
+                field,
+            )
+    return record
 
 def ordinal(n):
     s = ("th", "st", "nd", "rd") + ("th",) * 10