regscale-cli 6.20.1.1__py3-none-any.whl → 6.20.3.0__py3-none-any.whl

regscale/integrations/commercial/jira.py

@@ -8,10 +8,11 @@ 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
+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
 
@@ -21,6 +22,7 @@ from jira import Issue as jiraIssue
 from jira import JIRAError
 from rich.progress import Progress
 
+from regscale.core.app.utils.parser_utils import safe_datetime_str
 from regscale.core.app.api import Api
 from regscale.core.app.logz import create_logger
 from regscale.core.app.utils.app_utils import (
@@ -125,6 +127,16 @@ def issues(
     prompt="Enter the name of the project in Jira",
     required=True,
 )
+@click.option(
+    "--sync_attachments",
+    type=click.BOOL,
+    help=(
+        "Whether RegScale will sync the attachments for the issue "
+        "in the provided Jira project and vice versa. Defaults to True."
+    ),
+    required=False,
+    default=True,
+)
 @click.option(
     "--token_auth",
     "-t",
@@ -135,6 +147,7 @@ def tasks(
     regscale_id: int,
     regscale_module: str,
     jira_project: str,
+    sync_attachments: bool = True,
     token_auth: bool = False,
 ):
     """Sync tasks from Jira into RegScale."""
@@ -143,12 +156,44 @@ def tasks(
         parent_module=regscale_module,
         jira_project=jira_project,
         jira_issue_type="Task",
-        sync_attachments=False,
+        sync_attachments=sync_attachments,
         sync_tasks_only=True,
         token_auth=token_auth,
     )
 
 
+def get_regscale_data_and_attachments(
+    parent_id: int, parent_module: str, sync_attachments: bool = True, sync_tasks_only: bool = False
+) -> Tuple[list[Union[Issue, Task]], dict[int, list[File]]]:
+    """
+    Get the RegScale data and attachments for the given parent ID and module
+
+    :param int parent_id: The ID of the parent
+    :param str parent_module: The module of the parent
+    :param bool sync_attachments: Whether to sync attachments
+    :param bool sync_tasks_only: Whether to sync tasks only
+    :return: Tuple of RegScale issues, RegScale attachments
+    :rtype: Tuple[list[Union[Issue, Task]], dict[int, list[File]]]
+    """
+    if sync_tasks_only and sync_attachments:
+        regscale_issues, regscale_attachments = Task.get_objects_and_attachments_by_parent(
+            parent_id=parent_id,
+            parent_module=parent_module,
+        )
+    elif sync_tasks_only and not sync_attachments:
+        regscale_issues = Task.get_all_by_parent(parent_id, parent_module)
+        regscale_attachments = []
+    elif sync_attachments:
+        regscale_issues, regscale_attachments = Issue.get_objects_and_attachments_by_parent(
+            parent_id=parent_id,
+            parent_module=parent_module,
+        )
+    else:
+        regscale_issues = Issue.get_all_by_parent(parent_id, parent_module)
+        regscale_attachments = []
+    return regscale_issues, regscale_attachments
+
+
 def sync_regscale_and_jira(
     parent_id: int,
     parent_module: str,
@@ -180,20 +225,36 @@ def sync_regscale_and_jira(
     # create Jira client
     jira_client = create_jira_client(config, token_auth)
 
-    if sync_tasks_only:
-        jql_str = f"project = {jira_project} AND issueType = {jira_issue_type}"
-        regscale_issues = Task.get_all_by_parent(parent_id, parent_module)
-        regscale_attachments = []
-    else:
-        jql_str = f"project = {jira_project}"
-        (
-            regscale_issues,
-            regscale_attachments,
-        ) = Issue.fetch_issues_and_attachments_by_parent(
-            parent_id=parent_id,
-            parent_module=parent_module,
-            fetch_attachments=sync_attachments,
-        )
+    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,
+        sync_attachments=sync_attachments,
+        sync_tasks_only=sync_tasks_only,
+    )
+
+    output_str = "task" if sync_tasks_only else "issue"
+
+    # write regscale data to a json file
+    check_file_path("artifacts")
+    file_name = f"existingRegScale{output_str}s.json"
+    file_path = Path("./artifacts") / file_name
+    save_data_to(
+        file=file_path,
+        data=[issue.dict() for issue in regscale_objects],
+        output_log=False,
+    )
+    logger.info(
+        "Saved RegScale %s(s) for %s #%i, see %s",
+        output_str,
+        parent_module,
+        parent_id,
+        str(file_path.absolute()),
+    )
 
     jira_objects = fetch_jira_objects(
         jira_client=jira_client,
@@ -203,10 +264,10 @@ def sync_regscale_and_jira(
         sync_tasks_only=sync_tasks_only,
     )
 
-    if regscale_issues and not sync_tasks_only:
+    if regscale_objects:
         # sync RegScale issues to Jira
-        if issues_to_update := sync_regscale_to_jira(
-            regscale_issues=regscale_issues,
+        if regscale_objects_to_update := sync_regscale_to_jira(
+            regscale_objects=regscale_objects,
             jira_client=jira_client,
             jira_project=jira_project,
             jira_issue_type=jira_issue_type,
@@ -217,34 +278,33 @@ def sync_regscale_and_jira(
             with job_progress:
                 # create task to update RegScale issues
                 updating_issues = job_progress.add_task(
-                    f"[#f8b737]Updating {len(issues_to_update)} RegScale {jira_issue_type.lower()}(s) from Jira...",
-                    total=len(issues_to_update),
+                    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=(
-                        issues_to_update,
-                        api,
+                        regscale_objects_to_update,
                         updating_issues,
                     ),
-                    thread_count=len(issues_to_update),
+                    thread_count=len(regscale_objects_to_update),
                 )
                 # output the final result
                 logger.info(
-                    "%i/%i issue(s) updated in RegScale.",
-                    len(issues_to_update),
+                    "%i/%i %s(s) updated in RegScale.",
+                    len(regscale_objects_to_update),
                     len(update_counter),
+                    output_str,
                 )
-    elif not sync_tasks_only:
-        logger.info("No issues need to be updated in RegScale.")
+    else:
+        logger.info("No %s(s) need to be updated in RegScale.", output_str)
 
     if jira_objects:
-        sync_regscale_objects_to_jira(
-            jira_objects, regscale_issues, sync_attachments, app, parent_id, parent_module, sync_tasks_only
+        return sync_regscale_objects_to_jira(
+            jira_objects, regscale_objects, sync_attachments, app, parent_id, parent_module, sync_tasks_only
         )
-    else:
-        logger.info(f"No {'tasks' if sync_tasks_only else 'issues'} need to be analyzed from Jira.")
+    logger.info("No %s need to be analyzed from Jira.", output_str)
 
 
 def sync_regscale_objects_to_jira(
@@ -280,6 +340,7 @@ def sync_regscale_objects_to_jira(
             tasks_inserted, tasks_updated, tasks_closed = create_and_update_regscale_tasks(
                 jira_issues=jira_issues,
                 existing_tasks=regscale_objects,
+                jira_client=jira_client,
                 parent_id=parent_id,
                 parent_module=parent_module,
                 progress=job_progress,
@@ -349,7 +410,6 @@ def update_regscale_issues(args: Tuple, thread: int) -> None:
     # set up local variables from the passed args
     (
         regscale_issues,
-        app,
         task,
     ) = args
     # find which records should be executed by the current thread
@@ -425,6 +485,7 @@ def create_regscale_task_from_jira(config: dict, jira_issue: jiraIssue, parent_i
         dateClosed=date_closed,
         percentComplete=percent_complete,
         otherIdentifier=jira_issue.key,
+        extra_data={"jiraIssue": jira_issue},  # type: ignore
     )
 
 
@@ -447,72 +508,136 @@ def check_and_close_tasks(existing_tasks: list[Task], all_jira_titles: set[str])
     return close_tasks
 
 
-def create_and_update_regscale_tasks(
+def process_tasks_for_sync(
+    config: dict,
     jira_issues: list[jiraIssue],
     existing_tasks: list[Task],
     parent_id: int,
     parent_module: str,
     progress: Progress,
     progress_task: Any,
-) -> tuple[int, int, int]:
+) -> tuple[list[Task], list[Task], list[Task]]:
     """
-    Function to create or update Tasks in RegScale from Jira
+    Function to create lists of Tasks that need to be created, updated, and closed in RegScale from Jira
 
+    :param dict config: Application config
     :param list[jiraIssue] jira_issues: List of Jira issues to create or update in RegScale
     :param list[Task] existing_tasks: List of existing tasks in RegScale
     :param int parent_id: Parent record ID in RegScale
     :param str parent_module: Parent record module in RegScale
     :param Progress progress: Job progress object to use for updating the progress bar
     :param Any progress_task: Task object to update the progress bar
-    :return: A tuple of counts
-    :rtype: tuple[int, int, int]
+    :return: A tuple of lists of Tasks to create, update, and close
+    :rtype: tuple[list[Task], list[Task], list[Task]]
     """
-    from regscale.core.app.application import Application
-
-    app = Application()
-    config = app.config
+    closed_statuses = ["Closed", "Cancelled"]
     insert_tasks = []
     update_tasks = []
-    all_jira_titles = {jira_issue.fields.summary for jira_issue in jira_issues}
+    close_tasks = []
     for jira_issue in jira_issues:
         task = create_regscale_task_from_jira(config, jira_issue, parent_id, parent_module)
-        if task not in existing_tasks:
-            # set due date to today if not provided
-            insert_tasks.append(task)
-        else:
-            existing_task = next((t for t in existing_tasks if t == task), None)
+        existing_task = next((t for t in existing_tasks if t == task and not t.extra_data.get("updated", False)), None)
+        if existing_task:
             task.id = existing_task.id
-            update_tasks.append(task)
+            if (jira_issue.fields.status.name.lower() == "done" and existing_task.status not in closed_statuses) or (
+                task.status in closed_statuses and task != existing_task
+            ):
+                task.status = "Closed"
+                task.percentComplete = 100
+                task.dateClosed = safe_datetime_str(jira_issue.fields.statuscategorychangedate)
+                close_tasks.append(task)
+            elif task != existing_task:
+                update_tasks.append(task)
+        else:
+            insert_tasks.append(task)
         progress.update(progress_task, advance=1)
-    close_tasks = check_and_close_tasks(existing_tasks, all_jira_titles)
+    return insert_tasks, update_tasks, close_tasks
+
+
+def create_and_update_regscale_tasks(
+    jira_issues: list[jiraIssue],
+    existing_tasks: list[Task],
+    jira_client: JIRA,
+    parent_id: int,
+    parent_module: str,
+    progress: Progress,
+    progress_task: Any,
+) -> tuple[int, int, int]:
+    """
+    Function to create or update Tasks in RegScale from Jira
 
+    :param list[jiraIssue] jira_issues: List of Jira issues to create or update in RegScale
+    :param list[Task] existing_tasks: List of existing tasks in RegScale
+    :param JIRA jira_client: Jira client to use for the request
+    :param int parent_id: Parent record ID in RegScale
+    :param str parent_module: Parent record module in RegScale
+    :param Progress progress: Job progress object to use for updating the progress bar
+    :param Any progress_task: Task object to update the progress bar
+    :return: A tuple of counts
+    :rtype: tuple[int, int, int]
+    """
+    from regscale.core.app.api import Api
+    from regscale.models.integration_models.jira_task_sync import TaskSync
+
+    api = Api()
+    insert_tasks, update_tasks, close_tasks = process_tasks_for_sync(
+        config=api.app.config,
+        jira_issues=jira_issues,
+        existing_tasks=existing_tasks,
+        parent_id=parent_id,
+        parent_module=parent_module,
+        progress=progress,
+        progress_task=progress_task,
+    )
+
+    task_sync_operations: list[TaskSync] = []
+    if insert_tasks:
+        task_sync_operations.append(TaskSync(insert_tasks, "create"))
+    if update_tasks:
+        task_sync_operations.append(TaskSync(update_tasks, "update"))
+    if close_tasks:
+        task_sync_operations.append(TaskSync(close_tasks, "close"))
     with progress:
         with ThreadPoolExecutor(max_workers=10) as executor:
-            if insert_tasks:
-                creating_tasks = progress.add_task(
-                    f"[#f8b737]Creating {len(insert_tasks)} task(s) in RegScale...",
-                    total=len(insert_tasks),
+            for task_sync_operation in task_sync_operations:
+                progress_task = progress.add_task(
+                    task_sync_operation.progress_message, total=len(task_sync_operation.tasks)
                 )
-                create_futures = {executor.submit(task.create) for task in insert_tasks}
-                for _ in as_completed(create_futures):
-                    progress.update(creating_tasks, advance=1)
-            if update_tasks:
-                update_task = progress.add_task(
-                    f"[#f8b737]Updating {len(update_tasks)} task(s) in RegScale...",
-                    total=len(update_tasks),
-                )
-                update_futures = {executor.submit(task.save) for task in update_tasks}
-                for _ in as_completed(update_futures):
-                    progress.update(update_task, advance=1)
-            if close_tasks:
-                closing_tasks = progress.add_task(
-                    f"[#f8b737]Closing {len(close_tasks)} task(s) in RegScale...",
-                    total=len(close_tasks),
-                )
-                close_futures = {executor.submit(task.save) for task in close_tasks}
-                for _ in as_completed(close_futures):
-                    progress.update(closing_tasks, advance=1)
-    return len(insert_tasks), len(update_tasks), len(close_tasks)
+                task_futures = {
+                    executor.submit(
+                        task_and_attachments_sync, operation=task_sync_operation.operation, task=task, jira_client=jira_client, api=api  # type: ignore
+                    )
+                    for task in task_sync_operation.tasks
+                }
+                for _ in as_completed(task_futures):
+                    progress.update(progress_task, advance=1)
+    return len(insert_tasks), len(update_tasks) + len(update_counter), len(close_tasks)
+
+
+def task_and_attachments_sync(
+    operation: Literal["create", "update", "close"], task: Task, jira_client: JIRA, api: Api
+) -> None:
+    """
+    Function to create, update and close tasks as well as attachments between RegScale and Jira
+
+    :param Literal["create", "update", "close"] operation: Operation to perform on the tasks
+    :param Task task: Task to perform the operation on
+    :param JIRA jira_client: Jira client to use for the request
+    :param Api api: API object to use for the request
+    :rtype: None
+    """
+    task_to_sync = None
+    if operation == "create":
+        task_to_sync = task.create()
+    elif operation in ["update", "close"]:
+        task_to_sync = task.save()
+    if task_to_sync:
+        compare_files_for_dupes_and_upload(
+            jira_issue=task.extra_data["jiraIssue"],
+            regscale_object=task_to_sync,
+            jira_client=jira_client,
+            api=api,
+        )
 
 
 def create_and_update_regscale_issues(args: Tuple, thread: int) -> None:
@@ -570,7 +695,7 @@ def create_and_update_regscale_issues(args: Tuple, thread: int) -> None:
             # getting the hashes of all Jira & RegScale attachments
             compare_files_for_dupes_and_upload(
                 jira_issue=jira_issue,
-                regscale_issue=regscale_issue,
+                regscale_object=regscale_issue,
                 jira_client=jira_client,
                 api=Api(),
             )
@@ -579,40 +704,45 @@ def create_and_update_regscale_issues(args: Tuple, thread: int) -> None:
 
 
 def sync_regscale_to_jira(
-    regscale_issues: list[Issue],
+    regscale_objects: list[Union[Issue, Task]],
     jira_client: JIRA,
     jira_project: str,
     jira_issue_type: str,
     sync_attachments: bool = True,
     attachments: Optional[dict] = None,
     api: Optional[Api] = None,
-) -> list[Issue]:
+) -> list[Union[Issue, Task]]:
     """
-    Sync issues from RegScale to Jira
+    Sync issues or tasks from RegScale to Jira
 
-    :param list[Issue] regscale_issues: list of RegScale issues to sync to Jira
+    :param list[Union[Issue, Task]] regscale_issues: 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
-    :return: list of RegScale issues that need to be updated
-    :rtype: list[Issue]
+    :return: list of RegScale issues or tasks that need to be updated
+    :rtype: list[Union[Issue, Task]]
     """
     new_issue_counter = 0
-    issuess_to_update = []
+    regscale_objects_to_update = []
     with job_progress:
+        output_str = "issue" if jira_issue_type.lower() != "task" else "task"
         # create task to create Jira issues
         creating_issues = job_progress.add_task(
-            f"[#f8b737]Verifying {len(regscale_issues)} RegScale issue(s) exist in Jira...",
-            total=len(regscale_issues),
+            f"[#f8b737]Verifying {len(regscale_objects)} RegScale {output_str}(s) exist in Jira...",
+            total=len(regscale_objects),
         )
-        for issue in regscale_issues:
-            # see if Jira issue already exists
-            if not issue.jiraId or issue.jiraId == "":
+        for regscale_object in regscale_objects:
+            if (
+                isinstance(regscale_object, Issue) and (not regscale_object.jiraId or regscale_object.jiraId == "")
+            ) or (
+                isinstance(regscale_object, Task)
+                and (not regscale_object.otherIdentifier or regscale_object.otherIdentifier == "")
+            ):
                 new_issue = create_issue_in_jira(
-                    issue=issue,
+                    regscale_object=regscale_object,
                     jira_client=jira_client,
                     jira_project=jira_project,
                     issue_type=jira_issue_type,
@@ -625,13 +755,16 @@ def sync_regscale_to_jira(
                 # get the Jira ID
                 jira_id = new_issue.key
                 # update the RegScale issue for the Jira link
-                issue.jiraId = jira_id
+                if isinstance(regscale_object, Issue):
+                    regscale_object.jiraId = jira_id
+                elif isinstance(regscale_object, Task):
+                    regscale_object.otherIdentifier = jira_id
                 # add the issue to the update_issues global list
-                issuess_to_update.append(issue)
+                regscale_objects_to_update.append(regscale_object)
             job_progress.update(creating_issues, advance=1)
     # output the final result
-    logger.info("%i new issue(s) opened in Jira.", new_issue_counter)
-    return issuess_to_update
+    logger.info("%i new %s(s) opened in Jira.", new_issue_counter, output_str)
+    return regscale_objects_to_update
 
 
 def fetch_jira_objects(
@@ -747,24 +880,30 @@ def map_jira_due_date(jira_issue: Optional[jiraIssue], config: dict) -> str:
     return due_date
 
 
-def _generate_jira_comment(issue: Issue) -> str:
+def _generate_jira_comment(regscale_object: Union[Issue, Task]) -> str:
     """
     Generate a Jira comment from a RegScale issue and it's populated fields
 
-    :param Issue issue: RegScale issue to generate a Jira comment from
+    :param Union[Issue, Task] regscale_object: RegScale issue or task to generate a Jira comment from
     :return: Jira comment
     :rtype: str
     """
+    exclude_fields = [
+        "createdById",
+        "lastUpdatedById",
+        "issueOwnerId",
+        "assignedToId",
+        "uuid",
+    ] + regscale_object._exclude_graphql_fields
     comment = ""
-    exclude_fields = ["createdById", "lastUpdatedById", "issueOwnerId", "uuid"] + issue._exclude_graphql_fields
-    for field_name, field_value in issue.__dict__.items():
+    for field_name, field_value in regscale_object.__dict__.items():
         if field_value and field_name not in exclude_fields:
             comment += f"**{field_name}:** {field_value}\n"
     return comment
 
 
 def create_issue_in_jira(
-    issue: Issue,
+    regscale_object: Union[Issue, Task],
     jira_client: JIRA,
     jira_project: str,
     issue_type: str,
@@ -775,7 +914,7 @@ def create_issue_in_jira(
     """
     Create a new issue in Jira
 
-    :param Issue issue: RegScale issue object
+    :param Union[Issue, Task] regscale_object: RegScale issue or task object
     :param JIRA jira_client: Jira client to use for issue creation in Jira
     :param str jira_project: Project name in Jira to create the issue in
     :param str issue_type: The type of issue to create in Jira
@@ -788,12 +927,12 @@ def create_issue_in_jira(
     if not api:
         api = Api()
     try:
-        reg_issue_url = f"RegScale Issue #{issue.id}: {urljoin(api.config['domain'], f'/form/issues/{issue.id}')}\n\n"
-        logger.debug("Creating Jira issue: %s", issue.title)
+        regscale_object_url = f"RegScale {regscale_object.get_module_string().title()} #{regscale_object.id}: {urljoin(api.config['domain'], f'/form/{regscale_object.get_module_string()}/{regscale_object.id}')}\n\n"
+        logger.debug("Creating Jira issue: %s", regscale_object.title)
         new_issue = jira_client.create_issue(
             project=jira_project,
-            summary=issue.title,
-            description=reg_issue_url + issue.description,
+            summary=regscale_object.title,
+            description=regscale_object_url + regscale_object.description,
             issuetype=issue_type,
         )
         logger.debug("Jira issue created: %s", new_issue.key)
@@ -801,7 +940,7 @@ def create_issue_in_jira(
         logger.debug("Adding comment to Jira issue: %s", new_issue.key)
         _ = jira_client.add_comment(
             issue=new_issue,
-            body=reg_issue_url + _generate_jira_comment(issue),
+            body=regscale_object_url + _generate_jira_comment(regscale_object),
         )
         logger.debug("Comment added to Jira issue: %s", new_issue.key)
     except JIRAError as ex:
@@ -810,7 +949,7 @@ def create_issue_in_jira(
     if add_attachments and attachments:
         compare_files_for_dupes_and_upload(
             jira_issue=new_issue,
-            regscale_issue=issue,
+            regscale_object=regscale_object,
             jira_client=jira_client,
             api=api,
         )
@@ -818,13 +957,13 @@ def create_issue_in_jira(
 
 
 def compare_files_for_dupes_and_upload(
-    jira_issue: jiraIssue, regscale_issue: Issue, jira_client: JIRA, api: Api
+    jira_issue: jiraIssue, regscale_object: Union[Issue, Task], jira_client: JIRA, api: Api
 ) -> None:
     """
     Compare files for duplicates and upload them to Jira and RegScale
 
     :param jiraIssue jira_issue: Jira issue to upload the attachments to
-    :param Issue regscale_issue: RegScale issue to upload the attachments from
+    :param Union[Issue, Task] regscale_object: RegScale issue or task to upload the attachments from
     :param JIRA jira_client: Jira client to use for uploading the attachments
     :param Api api: Api object to use for interacting with RegScale
     :rtype: None
@@ -833,10 +972,10 @@ def compare_files_for_dupes_and_upload(
     jira_uploaded_attachments = []
     regscale_uploaded_attachments = []
     with tempfile.TemporaryDirectory() as temp_dir:
-        jira_dir, regscale_dir = download_issue_attachments_to_directory(
+        jira_dir, regscale_dir = download_regscale_attachments_to_directory(
             directory=temp_dir,
             jira_issue=jira_issue,
-            regscale_issue=regscale_issue,
+            regscale_object=regscale_object,
             api=api,
         )
         jira_attachment_hashes = compute_hashes_in_directory(jira_dir)
@@ -846,22 +985,22 @@ def compare_files_for_dupes_and_upload(
             jira_attachment_hashes,
             regscale_attachment_hashes,
             jira_issue,
-            regscale_issue,
+            regscale_object,
             jira_client,
             jira_uploaded_attachments,
         )
         upload_files_to_regscale(
-            jira_attachment_hashes, regscale_attachment_hashes, regscale_issue, api, regscale_uploaded_attachments
+            jira_attachment_hashes, regscale_attachment_hashes, regscale_object, api, regscale_uploaded_attachments
         )
 
-    log_upload_results(regscale_uploaded_attachments, jira_uploaded_attachments, regscale_issue, jira_issue)
+    log_upload_results(regscale_uploaded_attachments, jira_uploaded_attachments, regscale_object, jira_issue)
 
 
 def upload_files_to_jira(
     jira_attachment_hashes: dict,
     regscale_attachment_hashes: dict,
     jira_issue: jiraIssue,
-    regscale_issue: Issue,
+    regscale_object: Union[Issue, Task],
     jira_client: JIRA,
     jira_uploaded_attachments: list,
 ) -> None:
@@ -871,7 +1010,7 @@ def upload_files_to_jira(
     :param dict jira_attachment_hashes: Dictionary of Jira attachment hashes
     :param dict regscale_attachment_hashes: Dictionary of RegScale attachment hashes
     :param jiraIssue jira_issue: Jira issue to upload the attachments to
-    :param Issue regscale_issue: RegScale issue to upload the attachments from
+    :param Union[Issue, Task] regscale_object: RegScale issue or task to upload the attachments from
     :param JIRA jira_client: Jira client to use for uploading the attachments
     :param list jira_uploaded_attachments: List of Jira attachments that were uploaded
     :rtype: None
@@ -884,7 +1023,10 @@ def upload_files_to_jira(
                     jira_client.add_attachment(
                         issue=jira_issue.id,
                         attachment=BytesIO(in_file.read()),  # type: ignore
-                        filename=f"RegScale_Issue_{regscale_issue.id}_{Path(file).name}",
+                        filename=(
+                            f"RegScale_{regscale_object.get_module_string().title()}_{regscale_object.id}_"
+                            f"{Path(file).name}"
+                        ),
                     )
                     jira_uploaded_attachments.append(file)
             except JIRAError as ex:
@@ -906,7 +1048,7 @@ def upload_files_to_jira(
 def upload_files_to_regscale(
     jira_attachment_hashes: dict,
     regscale_attachment_hashes: dict,
-    regscale_issue: Issue,
+    regscale_object: Union[Issue, Task],
     api: Api,
     regscale_uploaded_attachments: list,
 ) -> None:
@@ -915,7 +1057,7 @@ def upload_files_to_regscale(
 
     :param dict jira_attachment_hashes: Dictionary of Jira attachment hashes
     :param dict regscale_attachment_hashes: Dictionary of RegScale attachment hashes
-    :param Issue regscale_issue: RegScale issue to upload the attachments to
+    :param Union[Issue, Task] regscale_object: RegScale issue or task to upload the attachments to
     :param Api api: Api object to use for interacting with RegScale
     :param list regscale_uploaded_attachments: List of RegScale attachments that were uploaded
     :rtype: None
@@ -926,57 +1068,66 @@ def upload_files_to_regscale(
             with open(file, "rb") as in_file:
                 if File.upload_file_to_regscale(
                     file_name=f"Jira_attachment_{Path(file).name}",
-                    parent_id=regscale_issue.id,
-                    parent_module="issues",
+                    parent_id=regscale_object.id,
+                    parent_module=regscale_object.get_module_string(),
                     api=api,
                     file_data=in_file.read(),
                 ):
                     regscale_uploaded_attachments.append(file)
                     logger.debug(
-                        "Uploaded %s to RegScale issue #%i.",
+                        "Uploaded %s to RegScale %s #%i.",
                         Path(file).name,
-                        regscale_issue.id,
+                        regscale_object.get_module_string().title(),
+                        regscale_object.id,
                     )
                 else:
                     logger.warning(
-                        "Unable to upload %s to RegScale issue #%i.",
+                        "Unable to upload %s to RegScale %s #%i.",
                         Path(file).name,
-                        regscale_issue.id,
+                        regscale_object.get_module_string().title(),
+                        regscale_object.id,
                     )
 
 
 def log_upload_results(
-    regscale_uploaded_attachments: list, jira_uploaded_attachments: list, regscale_issue: Issue, jira_issue: jiraIssue
+    regscale_uploaded_attachments: list,
+    jira_uploaded_attachments: list,
+    regscale_object: Union[Issue, Task],
+    jira_issue: jiraIssue,
 ) -> None:
     """
     Log the results of the upload process
 
     :param list regscale_uploaded_attachments: List of RegScale attachments that were uploaded
     :param list jira_uploaded_attachments: List of Jira attachments that were uploaded
-    :param Issue regscale_issue: RegScale issue that the attachments were uploaded to
+    :param Union[Issue, Task] regscale_object: RegScale issue or task that the attachments were uploaded to
     :param jiraIssue jira_issue: Jira issue that the attachments were uploaded to
     :rtype: None
     :return: None
     """
     if regscale_uploaded_attachments and jira_uploaded_attachments:
         logger.info(
-            "%i file(s) uploaded to RegScale issue #%i and %i file(s) uploaded to Jira issue %s.",
+            "%i file(s) uploaded to RegScale %s #%i and %i file(s) uploaded to Jira %s %s.",
             len(regscale_uploaded_attachments),
-            regscale_issue.id,
+            regscale_object.get_module_string().title(),
+            regscale_object.id,
             len(jira_uploaded_attachments),
+            jira_issue.fields.issuetype.name,
             jira_issue.key,
         )
     elif jira_uploaded_attachments:
         logger.info(
-            "%i file(s) uploaded to Jira issue %s.",
+            "%i file(s) uploaded to Jira %s %s.",
             len(jira_uploaded_attachments),
+            jira_issue.fields.issuetype.name,
             jira_issue.key,
         )
     elif regscale_uploaded_attachments:
         logger.info(
-            "%i file(s) uploaded to RegScale issue #%i.",
+            "%i file(s) uploaded to RegScale %s #%i.",
             len(regscale_uploaded_attachments),
-            regscale_issue.id,
+            regscale_object.get_module_string().title(),
+            regscale_object.id,
         )
 
 
@@ -999,10 +1150,10 @@ def validate_issue_type(jira_client: JIRA, issue_type: str) -> Any:
     error_and_exit(error_desc=message)
 
 
-def download_issue_attachments_to_directory(
+def download_regscale_attachments_to_directory(
     directory: str,
     jira_issue: jiraIssue,
-    regscale_issue: Issue,
+    regscale_object: Union[Issue, Task],
     api: Api,
 ) -> tuple[str, str]:
     """
@@ -1010,7 +1161,7 @@ def download_issue_attachments_to_directory(
 
     :param str directory: Directory to store the files in
     :param jiraIssue jira_issue: Jira issue to download the attachments for
-    :param Issue regscale_issue: RegScale issue to download the attachments for
+    :param Union[Issue, Task] regscale_object: RegScale issue or task to download the attachments for
     :param Api api: Api object to use for interacting with RegScale
     :return: Tuple of strings containing the Jira and RegScale directories
     :rtype: tuple[str, str]
@@ -1025,8 +1176,8 @@ def download_issue_attachments_to_directory(
     # get the regscale issue attachments
     regscale_issue_attachments = File.get_files_for_parent_from_regscale(
         api=api,
-        parent_id=regscale_issue.id,
-        parent_module="issues",
+        parent_id=regscale_object.id,
+        parent_module=regscale_object.get_module_string(),
     )
     # create a directory for the regscale attachments
     regscale_dir = os.path.join(directory, "regscale")
@@ -1037,8 +1188,8 @@ def download_issue_attachments_to_directory(
             file.write(
                 File.download_file_from_regscale_to_memory(
                     api=api,
-                    record_id=regscale_issue.id,
-                    module="issues",
+                    record_id=regscale_object.id,
+                    module=regscale_object.get_module_string(),
                     stored_name=attachment.trustedStorageName,
                     file_hash=(attachment.fileHash if attachment.fileHash else attachment.shaHash),
                 )