regscale-cli 6.26.0.0__py3-none-any.whl → 6.27.0.1__py3-none-any.whl

regscale/integrations/commercial/jira.py

@@ -8,11 +8,10 @@ import tempfile
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timedelta
 from io import BytesIO
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional, Tuple, Union, Literal
 from urllib.parse import urljoin
 
-from pathlib import Path
-
 if TYPE_CHECKING:
     from regscale.core.app.application import Application
 
@@ -40,7 +39,7 @@ from regscale.models import regscale_id, regscale_module
 from regscale.models.regscale_models.file import File
 from regscale.models.regscale_models.issue import Issue
 from regscale.models.regscale_models.task import Task
-from regscale.utils.threading.threadhandler import create_threads, thread_assignment
+from regscale.integrations.variables import ScannerVariables
 
 job_progress = create_progress_object()
 logger = create_logger()
@@ -104,6 +103,12 @@ def jira():
     help="Custom JQL query for filtering Jira issues.",
     required=False,
 )
+@click.option(
+    "--poams",
+    "-p",
+    is_flag=True,
+    help="Whether to create/update the incoming issues from Jira as POAMs in RegScale.",
+)
 def issues(
     regscale_id: int,
     regscale_module: str,
@@ -112,6 +117,7 @@ def issues(
     sync_attachments: bool = True,
     token_auth: bool = False,
     jql: Optional[str] = None,
+    poams: bool = False,
 ):
     """Sync issues from Jira into RegScale."""
     sync_regscale_and_jira(
@@ -122,6 +128,7 @@ def issues(
         sync_attachments=sync_attachments,
         token_auth=token_auth,
         jql=jql,
+        use_poams=poams,
     )
 
 
@@ -219,6 +226,7 @@ def sync_regscale_and_jira(
     sync_tasks_only: bool = False,
     token_auth: bool = False,
     jql: Optional[str] = None,
+    use_poams: Optional[bool] = False,
 ) -> None:
     """
     Sync issues, bidirectionally, from Jira into RegScale as issues
@@ -231,12 +239,19 @@ def sync_regscale_and_jira(
     :param bool sync_tasks_only: Whether to sync only tasks from Jira, defaults to False
     :param bool token_auth: Use token authentication for Jira API, defaults to False
     :param Optional[str] jql: Custom JQL query for filtering Jira issues/tasks, defaults to None
+    :param Optional[bool] use_poams: Whether to mark the incoming issues as POAMs in RegScale, defaults to False
     :rtype: None
     """
     app = check_license()
     api = Api()
     config = app.config
 
+    # Load custom fields configuration from init.yaml
+    if custom_fields := config.get("jiraCustomFields", {}):
+        logger.info("Custom field mappings loaded from config: %s", custom_fields)
+    else:
+        logger.debug("No custom field mappings found in configuration")
+
     # see if provided RegScale Module is an accepted option
     verify_provided_module(parent_module)
 
@@ -296,35 +311,20 @@ def sync_regscale_and_jira(
             api=api,
             sync_attachments=sync_attachments,
             attachments=regscale_attachments,
+            custom_fields=custom_fields,
         ):
-            with job_progress:
-                # create task to update RegScale issues
-                updating_issues = job_progress.add_task(
-                    f"[#f8b737]Updating {len(regscale_objects_to_update)} RegScale {output_str}(s) from Jira...",
-                    total=len(regscale_objects_to_update),
-                )
-                # create threads to analyze Jira issues and RegScale issues
-                create_threads(
-                    process=update_regscale_issues,
-                    args=(
-                        regscale_objects_to_update,
-                        updating_issues,
-                    ),
-                    thread_count=len(regscale_objects_to_update),
-                )
-                # output the final result
-                logger.info(
-                    "%i/%i %s(s) updated in RegScale.",
-                    len(regscale_objects_to_update),
-                    len(update_counter),
-                    output_str,
-                )
+            for regscale_object in regscale_objects_to_update:
+                regscale_object.save(bulk=True)
+            if isinstance(regscale_objects[0], Issue):
+                Issue.bulk_save()
+            elif isinstance(regscale_objects[0], Task):
+                Task.bulk_save()
     else:
         logger.info("No %s(s) need to be updated in RegScale.", output_str)
 
     if jira_objects:
         return sync_regscale_objects_to_jira(
-            jira_objects, regscale_objects, sync_attachments, app, parent_id, parent_module, sync_tasks_only
+            jira_objects, regscale_objects, sync_attachments, app, parent_id, parent_module, sync_tasks_only, use_poams
         )
     logger.info("No %s need to be analyzed from Jira.", output_str)
 
@@ -337,6 +337,7 @@ def sync_regscale_objects_to_jira(
     parent_id: int,
     parent_module: str,
     sync_tasks_only: bool,
+    use_poams: Optional[bool] = False,
 ):
     """
     Sync issues from Jira to RegScale
@@ -348,6 +349,7 @@ def sync_regscale_objects_to_jira(
     :param int parent_id: Parent record ID in RegScale
     :param str parent_module: Parent record module in RegScale
     :param bool sync_tasks_only: Whether to sync only tasks from Jira
+    :param bool use_poams: Whether to create/update the incoming issues as POAMs in RegScale, defaults to False
     """
     issues_closed = []
     with job_progress:
@@ -369,21 +371,20 @@ def sync_regscale_objects_to_jira(
                 progress_task=creating_issues,
             )
         else:
-            create_threads(
-                process=create_and_update_regscale_issues,
-                args=(
-                    jira_issues,
-                    regscale_objects,
-                    sync_attachments,
-                    jira_client,
-                    app,
-                    parent_id,
-                    parent_module,
-                    creating_issues,
-                    job_progress,
-                ),
-                thread_count=len(jira_issues),
+            app.thread_manager.submit_tasks_from_list(
+                create_and_update_regscale_issues,
+                jira_issues,
+                regscale_objects,
+                use_poams,
+                sync_attachments,
+                jira_client,
+                app,
+                parent_id,
+                parent_module,
+                creating_issues,
+                job_progress,
             )
+            app.thread_manager.execute_and_verify(timeout=ScannerVariables.timeout)
         logger.info(
             "Analyzed %i Jira %s(s), created %i %s(s), updated %i %s(s), and closed %i %s(s) in RegScale.",
             len(jira_issues),
@@ -409,8 +410,6 @@ def create_jira_client(
     :return: JIRA Client
     :rtype: JIRA
     """
-    from regscale.integrations.variables import ScannerVariables
-
     url = config["jiraUrl"]
     token = config["jiraApiToken"]
     jira_user = config["jiraUserName"]
@@ -421,36 +420,6 @@ def create_jira_client(
     return JIRA(basic_auth=(jira_user, token), options={"server": url})
 
 
-def update_regscale_issues(args: Tuple, thread: int) -> None:
-    """
-    Function to compare Jira issues and RegScale issues
-
-    :param Tuple args: Tuple of args to use during the process
-    :param int thread: Thread number of current thread
-    :rtype: None
-    """
-    # set up local variables from the passed args
-    (
-        regscale_issues,
-        task,
-    ) = args
-    # find which records should be executed by the current thread
-    threads = thread_assignment(thread=thread, total_items=len(regscale_issues))
-    # iterate through the thread assignment items and process them
-    for i in range(len(threads)):
-        # set the issue for the thread for later use in the function
-        issue = regscale_issues[threads[i]]
-        # update the issue in RegScale
-        issue.save()
-        logger.debug(
-            "RegScale Issue %i was updated with the Jira link.",
-            issue.id,
-        )
-        update_counter.append(issue)
-        # update progress bar
-        job_progress.update(task, advance=1)
-
-
 def convert_task_status(name: str) -> str:
     """
     Convert the task status from Jira to RegScale
@@ -494,7 +463,7 @@ def create_regscale_task_from_jira(config: dict, jira_issue: jiraIssue, parent_i
         date_closed = status_change_date
         percent_complete = 100
 
-    return Task(
+    task = Task(
         title=title,
         status=status,
         description=description,
@@ -507,6 +476,13 @@ def create_regscale_task_from_jira(config: dict, jira_issue: jiraIssue, parent_i
         extra_data={"jiraIssue": jira_issue},  # type: ignore
     )
 
+    # Apply custom field mappings from Jira to RegScale
+    custom_fields = config.get("jiraCustomFields", {})
+    if custom_fields:
+        apply_custom_fields_to_regscale_object(task, custom_fields, jira_issue)
+
+    return task
+
 
 def check_and_close_tasks(existing_tasks: list[Task], all_jira_titles: set[str]) -> list[Task]:
     """
@@ -567,9 +543,11 @@ def process_tasks_for_sync(
         jira_task = create_regscale_task_from_jira(config, jira_issue, parent_id, parent_module)
 
         # Check if we have a matching task in RegScale
-        existing_task = existing_task_map.get(jira_issue.key)
+        if existing_task := existing_task_map.get(jira_issue.key):
+            # Apply custom field mappings from Jira to RegScale for existing tasks
+            if custom_fields := config.get("jiraCustomFields", {}):
+                apply_custom_fields_to_regscale_object(existing_task, custom_fields, jira_issue)
 
-        if existing_task:
             # Check if task is closed in Jira and needs to be closed in regscale
             if jira_task.status in closed_statuses and existing_task.status not in closed_statuses:
                 existing_task.status = "Closed"
@@ -681,64 +659,93 @@ def task_and_attachments_sync(
         )
 
 
-def create_and_update_regscale_issues(args: Tuple, thread: int) -> None:
+def _create_new_regscale_issue(
+    jira_issue: jiraIssue, app: "Application", parent_id: int, parent_module: str, is_poam: Optional[bool] = False
+) -> Optional[Issue]:
+    """
+    Create a new RegScale issue from a Jira issue
+
+    :param jiraIssue jira_issue: The Jira issue to create from
+    :param Application app: RegScale application object
+    :param int parent_id: Parent record ID in RegScale
+    :param str parent_module: Parent record module in RegScale
+    :param bool is_poam: Whether to create the issue as a POAM in RegScale, defaults to False
+    :return: The created RegScale issue or None if creation failed
+    :rtype: Optional[Issue]
+    """
+    issue = map_jira_to_regscale_issue(
+        jira_issue=jira_issue,
+        config=app.config,
+        parent_id=parent_id,
+        parent_module=parent_module,
+        is_poam=is_poam,
+    )
+
+    if regscale_issue := issue.create():
+        logger.debug(
+            "Created issue #%i-%s in RegScale.",
+            regscale_issue.id,
+            regscale_issue.title,
+        )
+        return regscale_issue
+    else:
+        logger.warning("Unable to create issue in RegScale.\nIssue: %s", issue.dict())
+        return None
+
+
+def _apply_custom_fields_and_update_issue(regscale_issue: Issue, app: "Application", jira_issue: jiraIssue) -> None:
+    """
+    Apply custom field mappings and update a RegScale issue
+
+    :param Issue regscale_issue: The RegScale issue to update
+    :param Application app: RegScale application object
+    :param jiraIssue jira_issue: The Jira issue to get data from
+    :rtype: None
+    """
+    if custom_fields := app.config.get("jiraCustomFields", {}):
+        apply_custom_fields_to_regscale_object(regscale_issue, custom_fields, jira_issue)
+    updated_regscale_issues.append(regscale_issue.save())
+
+
+def create_and_update_regscale_issues(jira_issue: jiraIssue, *args, **_) -> None:
     """
     Function to create or update issues in RegScale from Jira
 
-    :param Tuple args: Tuple of args to use during the process
-    :param int thread: Thread number of current thread
+    :param jiraIssue jira_issue: Jira issue to create or update in RegScale
+    :param args: Additional arguments
     :rtype: None
     """
-    # set up local variables from the passed args
-    (jira_issues, regscale_issues, add_attachments, jira_client, app, parent_id, parent_module, task, progress) = args
+    # set up local variables from the passed args Tuple
+    (regscale_issues, use_poams, add_attachments, jira_client, app, parent_id, parent_module, task, progress) = args
     # find which records should be executed by the current thread
-    threads = thread_assignment(thread=thread, total_items=len(jira_issues))
 
-    # iterate through the thread assignment items and process them
-    for i in range(len(threads)):
-        jira_issue: jiraIssue = jira_issues[threads[i]]
-        regscale_issue: Optional[Issue] = next(
-            (issue for issue in regscale_issues if issue.jiraId == jira_issue.key), None
+    regscale_issue: Optional[Issue] = next((issue for issue in regscale_issues if issue.jiraId == jira_issue.key), None)
+    if regscale_issue:
+        regscale_issue.isPoam = use_poams
+
+    # Process the Jira issue based on its status and existing RegScale issue
+    if jira_issue.fields.status.name.lower() == "done" and regscale_issue:
+        regscale_issue.status = "Closed"
+        regscale_issue.dateCompleted = get_current_datetime()
+        _apply_custom_fields_and_update_issue(regscale_issue, app, jira_issue)
+    elif regscale_issue:
+        _apply_custom_fields_and_update_issue(regscale_issue, app, jira_issue)
+    else:
+        regscale_issue = _create_new_regscale_issue(jira_issue, app, parent_id, parent_module, use_poams)
+        if regscale_issue:
+            new_regscale_issues.append(regscale_issue)
+
+    # Handle attachments if needed
+    if add_attachments and regscale_issue and jira_issue.fields.attachment:
+        compare_files_for_dupes_and_upload(
+            jira_issue=jira_issue,
+            regscale_object=regscale_issue,
+            jira_client=jira_client,
+            api=Api(),
         )
-        # see if the Jira issue needs to be created in RegScale
-        if jira_issue.fields.status.name.lower() == "done" and regscale_issue:
-            # update the status and date completed of the RegScale issue
-            regscale_issue.status = "Closed"
-            regscale_issue.dateCompleted = get_current_datetime()
-            # update the issue in RegScale
-            updated_regscale_issues.append(Issue.update_issue(app=app, issue=regscale_issue))
-        elif regscale_issue:
-            # update the issue in RegScale
-            updated_regscale_issues.append(Issue.update_issue(app=app, issue=regscale_issue))
-        else:
-            # map the jira issue to a RegScale issue object
-            issue = map_jira_to_regscale_issue(
-                jira_issue=jira_issue,
-                config=app.config,
-                parent_id=parent_id,
-                parent_module=parent_module,
-            )
-            # create the issue in RegScale
-            if regscale_issue := issue.create():
-                logger.debug(
-                    "Created issue #%i-%s in RegScale.",
-                    regscale_issue.id,
-                    regscale_issue.title,
-                )
-                new_regscale_issues.append(regscale_issue)
-            else:
-                logger.warning("Unable to create issue in RegScale.\nIssue: %s", issue.dict())
-        if add_attachments and regscale_issue and jira_issue.fields.attachment:
-            # determine which attachments need to be uploaded to prevent duplicates by
-            # getting the hashes of all Jira & RegScale attachments
-            compare_files_for_dupes_and_upload(
-                jira_issue=jira_issue,
-                regscale_object=regscale_issue,
-                jira_client=jira_client,
-                api=Api(),
-            )
-        # update progress bar
-        progress.update(task, advance=1)
+
+    # update progress bar
+    progress.update(task, advance=1)
 
 
 def sync_regscale_to_jira(
@@ -749,6 +756,7 @@ def sync_regscale_to_jira(
     sync_attachments: bool = True,
     attachments: Optional[dict] = None,
     api: Optional[Api] = None,
+    custom_fields: Optional[dict] = None,
 ) -> list[Union[Issue, Task]]:
     """
     Sync issues or tasks from RegScale to Jira
@@ -760,6 +768,7 @@ def sync_regscale_to_jira(
     :param bool sync_attachments: Sync attachments from RegScale to Jira, defaults to True
     :param Optional[dict] attachments: Dict of attachments to sync from RegScale to Jira, defaults to None
     :param Optional[Api] api: API object to download attachments, defaults to None
+    :param Optional[dict] custom_fields: Custom field mappings from Jira custom fields to RegScale issue fields, defaults to None
     :return: list of RegScale issues or tasks that need to be updated
     :rtype: list[Union[Issue, Task]]
     """
@@ -787,6 +796,7 @@ def sync_regscale_to_jira(
                     add_attachments=sync_attachments,
                     attachments=attachments,
                     api=api,
+                    custom_fields=custom_fields,
                 )
                 # log progress
                 new_issue_counter += 1
@@ -940,7 +950,9 @@ def save_jira_issues(jira_issues: list[jiraIssue], jira_project: str, jira_issue
     )
 
 
-def map_jira_to_regscale_issue(jira_issue: jiraIssue, config: dict, parent_id: int, parent_module: str) -> Issue:
+def map_jira_to_regscale_issue(
+    jira_issue: jiraIssue, config: dict, parent_id: int, parent_module: str, is_poam: Optional[bool] = False
+) -> Issue:
     """
     Map Jira issues to RegScale issues
 
@@ -948,6 +960,7 @@ def map_jira_to_regscale_issue(jira_issue: jiraIssue, config: dict, parent_id: i
     :param dict config: Application config
     :param int parent_id: Parent record ID in RegScale
     :param str parent_module: Parent record module in RegScale
+    :param bool is_poam: Whether to create the issue as a POAM in RegScale
     :return: Issue object of the newly created issue in RegScale
     :rtype: Issue
     """
@@ -970,7 +983,14 @@ def map_jira_to_regscale_issue(jira_issue: jiraIssue, config: dict, parent_id: i
         parentModule=parent_module,
         dateCreated=get_current_datetime(),
         dateCompleted=(get_current_datetime() if jira_issue.fields.status.name.lower() == "done" else None),
+        isPoam=is_poam,
     )
+
+    # Apply custom field mappings from Jira to RegScale
+    custom_fields = config.get("jiraCustomFields", {})
+    if custom_fields:
+        apply_custom_fields_to_regscale_object(issue, custom_fields, jira_issue)
+
     return issue
 
 
@@ -1024,6 +1044,7 @@ def create_issue_in_jira(
     add_attachments: Optional[bool] = True,
     attachments: Optional[dict] = None,
     api: Optional[Api] = None,
+    custom_fields: Optional[dict] = None,
 ) -> jiraIssue:
     """
     Create a new issue in Jira
@@ -1035,6 +1056,7 @@ def create_issue_in_jira(
     :param Optional[bool] add_attachments: Whether to add attachments to new issue, defaults to true
     :param Optional[dict] attachments: Dictionary containing attachments, defaults to None
     :param Optional[Api] api: API object to download attachments, defaults to None
+    :param Optional[dict] custom_fields: Custom field mappings from Jira custom fields to RegScale issue fields, defaults to None
     :return: Newly created issue in Jira
     :rtype: jiraIssue
     """
@@ -1050,6 +1072,11 @@ def create_issue_in_jira(
             issuetype=issue_type,
         )
         logger.debug("Jira issue created: %s", new_issue.key)
+
+        # Apply custom field mappings if provided
+        if custom_fields:
+            apply_custom_fields_to_jira_issue(new_issue, custom_fields, regscale_object)
+
         # add a comment to the new Jira issue
         logger.debug("Adding comment to Jira issue: %s", new_issue.key)
         _ = jira_client.add_comment(
@@ -1309,3 +1336,217 @@ def download_regscale_attachments_to_directory(
                 )
             )
     return jira_dir, regscale_dir
+
+
+def apply_custom_fields_to_jira_issue(
+    jira_issue: jiraIssue, custom_fields: dict, regscale_object: Union[Issue, Task]
+) -> None:
+    """
+    Apply custom field mappings to a Jira issue based on RegScale object attributes (RegScale -> Jira)
+
+    :param jiraIssue jira_issue: Jira issue to apply custom fields to
+    :param dict custom_fields: Dictionary mapping Jira custom field names to RegScale attribute names
+    :param Union[Issue, Task] regscale_object: RegScale object to get attribute values from
+    :rtype: None
+    """
+    if not custom_fields:
+        return
+
+    try:
+        # Convert RegScale object to dictionary for easier attribute access
+        if hasattr(regscale_object, "model_dump"):
+            regscale_dict = regscale_object.model_dump()
+        elif hasattr(regscale_object, "dict"):
+            regscale_dict = regscale_object.dict()
+        else:
+            regscale_dict = regscale_object.__dict__
+
+        # Build custom fields dictionary for Jira update
+        jira_custom_fields = {}
+
+        for jira_field_name, regscale_field_name in custom_fields.items():
+            try:
+                # Get the value from RegScale object
+                field_value = regscale_dict.get(regscale_field_name)
+
+                if field_value is not None:
+                    jira_custom_fields[jira_field_name] = field_value
+                    logger.debug(
+                        "Mapped custom field %s (RegScale: %s) = %s for Jira issue %s",
+                        jira_field_name,
+                        regscale_field_name,
+                        field_value,
+                        jira_issue.key,
+                    )
+                else:
+                    logger.debug(
+                        "Custom field %s (RegScale: %s) has no value, skipping for Jira issue %s",
+                        jira_field_name,
+                        regscale_field_name,
+                        jira_issue.key,
+                    )
+            except Exception as e:
+                logger.warning(
+                    "Unable to set custom field %s (RegScale: %s) for Jira issue %s: %s",
+                    jira_field_name,
+                    regscale_field_name,
+                    jira_issue.key,
+                    str(e),
+                )
+
+        # Update the Jira issue with custom fields if any were found
+        if jira_custom_fields:
+            jira_issue.update(fields=jira_custom_fields)
+            logger.info(
+                "Applied %d custom fields to Jira issue %s: %s",
+                len(jira_custom_fields),
+                jira_issue.key,
+                list(jira_custom_fields.keys()),
+            )
+        else:
+            logger.debug("No custom field values found for Jira issue %s", jira_issue.key)
+
+    except Exception as e:
+        logger.warning(
+            "Error applying custom fields to Jira issue %s: %s",
+            jira_issue.key,
+            str(e),
+        )
+
+
+def _get_jira_field_value(jira_issue: jiraIssue, jira_field_name: str) -> Optional[Any]:
+    """
+    Get a custom field value from a Jira issue
+
+    :param jiraIssue jira_issue: The Jira issue to get the field value from
+    :param str jira_field_name: The name of the field to retrieve
+    :return: The field value or None if not found
+    :rtype: Optional[Any]
+    """
+    # Try to access the custom field from the Jira issue
+    if hasattr(jira_issue.fields, jira_field_name):
+        return getattr(jira_issue.fields, jira_field_name)
+
+    # Try accessing through raw fields (for custom fields)
+    if hasattr(jira_issue.fields, "raw") and jira_field_name in jira_issue.fields.raw:
+        return jira_issue.fields.raw[jira_field_name]
+
+    return None
+
+
+def _set_regscale_field_value(
+    regscale_object: Union[Issue, Task],
+    regscale_field_name: str,
+    jira_field_value: Any,
+    jira_field_name: str,
+    jira_issue: jiraIssue,
+) -> bool:
+    """
+    Set a field value on a RegScale object
+
+    :param Union[Issue, Task] regscale_object: The RegScale object to set the field on
+    :param str regscale_field_name: The name of the field to set
+    :param Any jira_field_value: The value to set
+    :param str jira_field_name: The Jira field name for logging
+    :param jiraIssue jira_issue: The Jira issue for logging
+    :return: True if the field was set successfully, False otherwise
+    :rtype: bool
+    """
+    if hasattr(regscale_object, regscale_field_name):
+        setattr(regscale_object, regscale_field_name, jira_field_value)
+        logger.debug(
+            "Mapped custom field %s (Jira: %s) = %s for RegScale %s #%s from Jira issue %s",
+            regscale_field_name,
+            jira_field_name,
+            jira_field_value,
+            regscale_object.get_module_string().title(),
+            regscale_object.id,
+            jira_issue.key,
+        )
+        return True
+    else:
+        logger.debug(
+            "RegScale object does not have field %s, skipping custom field %s from Jira issue %s",
+            regscale_field_name,
+            jira_field_name,
+            jira_issue.key,
+        )
+        return False
+
+
+def _process_single_custom_field(
+    jira_field_name: str, regscale_field_name: str, regscale_object: Union[Issue, Task], jira_issue: jiraIssue
+) -> bool:
+    """
+    Process a single custom field mapping from Jira to RegScale
+
+    :param str jira_field_name: The Jira field name
+    :param str regscale_field_name: The RegScale field name
+    :param Union[Issue, Task] regscale_object: The RegScale object to update
+    :param jiraIssue jira_issue: The Jira issue to get data from
+    :return: True if the field was processed successfully, False otherwise
+    :rtype: bool
+    """
+    try:
+        jira_field_value = _get_jira_field_value(jira_issue, jira_field_name)
+
+        if jira_field_value is not None:
+            return _set_regscale_field_value(
+                regscale_object, regscale_field_name, jira_field_value, jira_field_name, jira_issue
+            )
+        else:
+            logger.debug(
+                "Custom field %s has no value in Jira issue %s, skipping",
+                jira_field_name,
+                jira_issue.key,
+            )
+            return False
+    except Exception as e:
+        logger.warning(
+            "Unable to set custom field %s (Jira: %s) for RegScale %s #%s: %s",
+            regscale_field_name,
+            jira_field_name,
+            regscale_object.get_module_string().title(),
+            regscale_object.id,
+            str(e),
+        )
+        return False
+
+
+def apply_custom_fields_to_regscale_object(
+    regscale_object: Union[Issue, Task], custom_fields: dict, jira_issue: jiraIssue
+) -> None:
+    """
+    Apply custom field mappings to a RegScale object based on Jira issue custom fields (Jira -> RegScale)
+
+    :param Union[Issue, Task] regscale_object: RegScale object to apply custom fields to
+    :param dict custom_fields: Dictionary mapping Jira custom field names to RegScale attribute names
+    :param jiraIssue jira_issue: Jira issue to get custom field values from
+    :rtype: None
+    """
+    if not custom_fields:
+        return
+
+    try:
+        fields_updated = False
+
+        for jira_field_name, regscale_field_name in custom_fields.items():
+            if _process_single_custom_field(jira_field_name, regscale_field_name, regscale_object, jira_issue):
+                fields_updated = True
+
+        if fields_updated:
+            logger.info(
+                "Applied custom fields from Jira issue %s to RegScale %s #%s",
+                jira_issue.key,
+                regscale_object.get_module_string().title(),
+                regscale_object.id,
+            )
+
+    except Exception as e:
+        logger.warning(
+            "Error applying custom fields from Jira issue %s to RegScale %s #%s: %s",
+            jira_issue.key,
+            regscale_object.get_module_string().title(),
+            regscale_object.id,
+            str(e),
+        )