regscale-cli 6.21.2.0__py3-none-any.whl → 6.28.2.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()
@@ -98,6 +97,18 @@ def jira():
     is_flag=True,
     help="Use token authentication for Jira API instead of basic auth, defaults to False.",
 )
+@click.option(
+    "--jql",
+    type=click.STRING,
+    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,
@@ -105,6 +116,8 @@ def issues(
     jira_issue_type: str,
     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(
@@ -114,6 +127,8 @@ def issues(
         jira_issue_type=jira_issue_type,
         sync_attachments=sync_attachments,
         token_auth=token_auth,
+        jql=jql,
+        use_poams=poams,
     )
 
 
@@ -143,12 +158,19 @@ def issues(
     is_flag=True,
     help="Use token authentication for Jira API instead of basic auth, defaults to False.",
 )
+@click.option(
+    "--jql",
+    type=click.STRING,
+    help="Custom JQL query for filtering Jira tasks.",
+    required=False,
+)
 def tasks(
     regscale_id: int,
     regscale_module: str,
     jira_project: str,
     sync_attachments: bool = True,
     token_auth: bool = False,
+    jql: Optional[str] = None,
 ):
     """Sync tasks from Jira into RegScale."""
     sync_regscale_and_jira(
@@ -159,6 +181,7 @@ def tasks(
         sync_attachments=sync_attachments,
         sync_tasks_only=True,
         token_auth=token_auth,
+        jql=jql,
     )
 
 
@@ -202,6 +225,8 @@ def sync_regscale_and_jira(
     sync_attachments: bool = True,
     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
@@ -213,23 +238,35 @@ def sync_regscale_and_jira(
     :param bool sync_attachments: Whether to sync attachments in RegScale & Jira, defaults to True
     :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)
 
     # create Jira client
     jira_client = create_jira_client(config, token_auth)
 
-    jql_str = (
-        f"project = {jira_project} AND issueType = {jira_issue_type}"
-        if sync_tasks_only
-        else f"project = {jira_project}"
-    )
+    # Use custom JQL if provided, otherwise build default JQL
+    if jql:
+        jql_str = jql
+    else:
+        jql_str = (
+            f"project = '{jira_project}' AND issueType = '{jira_issue_type}'"
+            if sync_tasks_only
+            else f"project = '{jira_project}'"
+        )
     regscale_objects, regscale_attachments = get_regscale_data_and_attachments(
         parent_id=parent_id,
         parent_module=parent_module,
@@ -274,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)
 
@@ -315,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
@@ -326,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:
@@ -347,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),
@@ -387,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"]
@@ -399,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
@@ -472,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,
@@ -485,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]:
     """
@@ -545,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"
@@ -659,67 +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.insert_issue(
-                app=app,
-                issue=issue,
-            ):
-                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(
@@ -730,17 +756,19 @@ 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
 
-    :param list[Union[Issue, Task]] regscale_issues: list of RegScale issues or tasks to sync to Jira
+    :param list[Union[Issue, Task]] regscale_objects: list of RegScale issues or tasks to sync to Jira
     :param JIRA jira_client: Jira client to use for issue creation in Jira
     :param str jira_project: Jira Project to create the issues in
     :param str jira_issue_type: Type of issue to create in 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]]
     """
@@ -768,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
@@ -790,7 +819,7 @@ def fetch_jira_objects(
     jira_client: JIRA, jira_project: str, jira_issue_type: str, jql_str: str = None, sync_tasks_only: bool = False
 ) -> list[jiraIssue]:
     """
-    Fetch all issues from Jira for the provided project
+    Fetch all issues from Jira for the provided project using the enhanced search API.
 
     :param JIRA jira_client: Jira client to use for the request
     :param str jira_project: Name of the project in Jira
@@ -800,15 +829,77 @@ def fetch_jira_objects(
     :return: List of Jira issues
     :rtype: list[jiraIssue]
     """
-    start_pointer = 0
-    page_size = 100
-    jira_objects = []
     if sync_tasks_only:
         validate_issue_type(jira_client, jira_issue_type)
         output_str = "task"
     else:
         output_str = "issue"
     logger.info("Fetching %s(s) from Jira...", output_str.lower())
+    try:
+        max_results = 100  # 100 is the max allowed by Jira
+        jira_issues = []
+        issue_response = jira_client.enhanced_search_issues(
+            jql_str=jql_str or f"project = '{jira_project}'",
+            maxResults=max_results,
+        )
+        jira_issues.extend(issue_response)
+        logger.info(
+            "%i Jira %s(s) retrieved.",
+            len(jira_issues),
+            output_str.lower(),
+        )
+        # Handle pagination if there are more issues to fetch
+        while issue_response.nextPageToken:
+            issue_response = jira_client.enhanced_search_issues(
+                jql_str=jql_str, maxResults=max_results, nextPageToken=issue_response.nextPageToken
+            )
+            jira_issues.extend(issue_response)
+            logger.info(
+                "%i Jira %s(s) retrieved.",
+                len(jira_issues),
+                output_str.lower(),
+            )
+        # Save artifacts file and log final result if we have issues
+        if jira_issues:
+            save_jira_issues(jira_issues, jira_project, jira_issue_type)
+        logger.info("%i %s(s) retrieved from Jira.", len(jira_issues), output_str.lower())
+        return jira_issues
+    except Exception as e:
+        logger.warning(
+            "An error occurred while fetching Jira issues using the enhanced_search_issues method: %s", str(e)
+        )
+        logger.info("Falling back to the deprecated fetch method...")
+
+    try:
+        return deprecated_fetch_jira_objects(
+            jira_client=jira_client,
+            jira_project=jira_project,
+            jira_issue_type=jira_issue_type,
+            jql_str=jql_str,
+            output_str=output_str,
+        )
+    except JIRAError as e:
+        error_and_exit(f"Unable to fetch issues from Jira: {e}")
+
+
+def deprecated_fetch_jira_objects(
+    jira_client: JIRA, jira_project: str, jira_issue_type: str, jql_str: str = None, output_str: str = "issue"
+) -> list[jiraIssue]:
+    """
+    Fetch all issues from Jira for the provided project using the old API method, used as a fallback method.
+
+    :param JIRA jira_client: Jira client to use for the request
+    :param str jira_project: Name of the project in Jira
+    :param str jira_issue_type: Type of issue to fetch from Jira
+    :param str jql_str: JQL string to use for the request, default None
+    :param str output_str: String to use for logging, either "issue" or "task"
+    :return: List of Jira issues
+    :rtype: list[jiraIssue]
+    """
+    start_pointer = 0
+    page_size = 100
+    jira_objects = []
+    logger.info("Fetching %s(s) from Jira...", output_str.lower())
     # get all issues for the Jira project
     while True:
         start = start_pointer * page_size
@@ -829,25 +920,39 @@ def fetch_jira_objects(
             output_str.lower(),
         )
     if jira_objects:
-        check_file_path("artifacts")
-        file_name = f"{jira_project.lower()}_existingJira{jira_issue_type}.json"
-        file_path = Path(f"./artifacts/{file_name}")
-        save_data_to(
-            file=file_path,
-            data=[issue.raw for issue in jira_objects],
-            output_log=False,
-        )
-        logger.info(
-            "Saved %i Jira %s(s), see %s",
-            len(jira_objects),
-            jira_issue_type.lower(),
-            str(file_path.absolute()),
-        )
+        save_jira_issues(jira_objects, jira_project, jira_issue_type)
     logger.info("%i %s(s) retrieved from Jira.", len(jira_objects), output_str.lower())
     return jira_objects
 
 
-def map_jira_to_regscale_issue(jira_issue: jiraIssue, config: dict, parent_id: int, parent_module: str) -> Issue:
+def save_jira_issues(jira_issues: list[jiraIssue], jira_project: str, jira_issue_type: str) -> None:
+    """
+    Save Jira issues to a JSON file in the artifacts directory
+
+    :param list[jiraIssue] jira_issues: List of Jira issues to save
+    :param str jira_project: Name of the project in Jira
+    :param str jira_issue_type: Type of issue to fetch from Jira
+    :rtype: None
+    """
+    check_file_path("artifacts")
+    file_name = f"{jira_project.lower()}_existingJira{jira_issue_type}.json"
+    file_path = Path(f"./artifacts/{file_name}")
+    save_data_to(
+        file=file_path,
+        data=[issue.raw for issue in jira_issues],
+        output_log=False,
+    )
+    logger.info(
+        "Saved %i Jira %s(s), see %s",
+        len(jira_issues),
+        jira_issue_type.lower(),
+        str(file_path.absolute()),
+    )
+
+
+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
 
@@ -855,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
     """
@@ -871,11 +977,20 @@ def map_jira_to_regscale_issue(jira_issue: jiraIssue, config: dict, parent_id: i
         ),
         status=("Closed" if jira_issue.fields.status.name.lower() == "done" else config["issues"]["jira"]["status"]),
         jiraId=jira_issue.key,
+        identification="Jira Sync",
+        sourceReport="Jira",
         parentId=parent_id,
         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
 
 
@@ -929,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
@@ -940,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
     """
@@ -955,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(
@@ -1214,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),
+        )