regscale-cli 6.16.2.0__py3-none-any.whl → 6.16.4.0__py3-none-any.whl

regscale/integrations/commercial/qualys.py

@@ -27,9 +27,9 @@ from regscale.core.app.utils.app_utils import (
     save_data_to,
 )
 from regscale.core.app.utils.file_utils import download_from_s3
-from regscale.models.app_models.click import regscale_ssp_id
 from regscale.models import Asset, Issue, Search, regscale_models
 from regscale.models.app_models.click import NotRequiredIf, save_output_to
+from regscale.models.app_models.click import regscale_ssp_id
 from regscale.models.integration_models.flat_file_importer import FlatFileImporter
 from regscale.models.integration_models.qualys import (
     Qualys,
@@ -611,11 +611,7 @@ def get_scan_results(scans: Any, task: TaskID) -> dict:
     :return: dictionary of detailed Qualys scans
     :rtype: dict
     """
-    app = check_license()
-    config = app.config
-
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
+    qualys_url, QUALYS_API = _get_qualys_api()
 
     scan_data = {}
     # check number of scans requested
@@ -636,7 +632,7 @@ def get_scan_results(scans: Any, task: TaskID) -> dict:
             }
             # get the scan data via API
             res = QUALYS_API.get(
-                url=urljoin(config["qualysUrl"], "/api/2.0/fo/scan/"),
+                url=urljoin(qualys_url, "/api/2.0/fo/scan/"),
                 headers=HEADERS,
                 params=params,
             )
@@ -664,11 +660,7 @@ def get_detailed_scans(days: int) -> list:
     :return: list of results from Qualys API
     :rtype: list
     """
-    app = check_license()
-    config = app.config
-
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
+    qualys_url, QUALYS_API = _get_qualys_api()
 
     today = datetime.now()
     scan_date = today - timedelta(days=days)
@@ -684,12 +676,12 @@ def get_detailed_scans(days: int) -> list:
         "scan_datetime_since": scan_date.strftime("%Y-%m-%dT%H:%I:%S%ZZ"),
     }
     res = QUALYS_API.get(
-        url=urljoin(config["qualysUrl"], "/api/2.0/fo/scan/summary/"),
+        url=urljoin(qualys_url, "/api/2.0/fo/scan/summary/"),
         headers=HEADERS,
         params=params,
     )
     response = QUALYS_API.get(
-        url=urljoin(config["qualysUrl"], "/api/2.0/fo/scan/vm/summary/"),
+        url=urljoin(qualys_url, "/api/2.0/fo/scan/vm/summary/"),
         headers=HEADERS,
         params=params2,
     )
@@ -708,6 +700,34 @@ def get_detailed_scans(days: int) -> list:
     return res_data
 
 
+def _get_config():
+    """
+    Get the Qualys configuration
+
+    :return: Qualys configuration
+    :rtype: dict
+    """
+    app = check_license()
+    config = app.config
+    return config
+
+
+def _get_qualys_api():
+    """
+    Get the Qualys API session
+
+    :return: Qualys API session
+    :rtype: Session
+    """
+    config = _get_config()
+
+    # set the auth for the QUALYS_API session
+    QUALYS_API.auth = (config.get("qualysUserName"), config.get("qualysPassword"))
+    QUALYS_API.verify = config.get("sslVerify", True)
+    qualys_url = config.get("qualysUrl")
+    return qualys_url, QUALYS_API
+
+
 def import_total_cloud_data_from_qualys_api(security_plan_id: int, include_tags: str, exclude_tags: str):
     """
     Function to get the total cloud data from Qualys API
@@ -717,10 +737,7 @@ def import_total_cloud_data_from_qualys_api(security_plan_id: int, include_tags:
     """
     try:
 
-        app = check_license()
-        config = app.config
-        # set the auth for the QUALYS_API session
-        QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
+        qualys_url, QUALYS_API = _get_qualys_api()
         params = {
             "action": "list",
             "show_asset_id": "1",
@@ -732,12 +749,14 @@ def import_total_cloud_data_from_qualys_api(security_plan_id: int, include_tags:
                 params["tag_set_exclude"] = exclude_tags
             if include_tags:
                 params["tag_set_include"] = include_tags
+        logger.info("Fetching Qualys Total Cloud data...")
         response = QUALYS_API.get(
-            url=urljoin(config["qualysUrl"], "/api/2.0/fo/asset/host/vm/detection/"),
+            url=urljoin(qualys_url, "/api/2.0/fo/asset/host/vm/detection/"),
             headers=HEADERS,
             params=params,
         )
         if response and response.ok:
+            logger.info("Total cloud data fetched. processing...")
             response_data = xmltodict.parse(response.text)
             qt = QualysTotalCloudIntegration(plan_id=security_plan_id, xml_data=response_data)
             qt.fetch_assets()
@@ -761,17 +780,13 @@ def get_scans_summary(scan_choice: str) -> dict:
     :return: Detailed summary of scans from Qualys API as a dictionary
     :rtype: dict
     """
-    app = check_license()
-    config = app.config
+    qualys_url, QUALYS_API = _get_qualys_api()
     urls = []
 
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
-
     # set up variables for function
     scan_data = {}
     responses = []
-    scan_url = urljoin(config["qualysUrl"], "/api/2.0/fo/scan/")
+    scan_url = urljoin(qualys_url, "/api/2.0/fo/scan/")
 
     # set up parameters for the scans query
     params = {"action": "list"}
@@ -812,11 +827,7 @@ def get_scan_details(days: int) -> list:
     :return: Detailed summary of scans from Qualys API as a dictionary
     :rtype: list
     """
-    app = check_license()
-    config = app.config
-
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
+    qualys_url, QUALYS_API = _get_qualys_api()
     # get since date for API call
     since_date = datetime.now() - timedelta(days=days)
     # set up data and parameters for the scans query
@@ -835,12 +846,12 @@ def get_scan_details(days: int) -> list:
         "scan_datetime_since": since_date.strftime("%Y-%m-%dT%H:%M:%SZ"),
     }
     res = QUALYS_API.get(
-        url=urljoin(config["qualysUrl"], "/api/2.0/fo/scan/summary/"),
+        url=urljoin(qualys_url, "/api/2.0/fo/scan/summary/"),
         headers=headers,
         params=params,
     )
     response = QUALYS_API.get(
-        url=urljoin(config["qualysUrl"], "/api/2.0/fo/scan/vm/summary/"),
+        url=urljoin(qualys_url, "/api/2.0/fo/scan/vm/summary/"),
         headers=headers,
         params=params2,
     )
@@ -874,11 +885,7 @@ def sync_qualys_assets_and_vulns(
     :param Optional[Union[int, str]] asset_group_filter: Filter the Qualys assets by an asset group ID or name, if any
     :rtype: None
     """
-    app = check_license()
-    config = app.config
-
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
+    config = _get_config()
 
     # Get the assets from RegScale with the provided SSP ID
     logger.info("Getting assets from RegScale for SSP #%s...", ssp_id)
@@ -1086,14 +1093,10 @@ def get_qualys_assets_and_scan_results(
     :return: list of dictionaries containing asset data
     :rtype: list
     """
-    app = check_license()
-    config = app.config
-
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
+    qualys_url, QUALYS_API = _get_qualys_api()
     # set url
     if not url:
-        url = urljoin(config["qualysUrl"], "api/2.0/fo/asset/host/vm/detection?action=list&show_asset_id=1")
+        url = urljoin(qualys_url, "api/2.0/fo/asset/host/vm/detection?action=list&show_asset_id=1")
 
     # check if an asset group filter was provided and append it to the url
     if asset_group_filter:
@@ -1143,12 +1146,7 @@ def get_issue_data_for_assets(asset_list: list) -> Tuple[list[dict], int]:
     :return:  Updated asset list of Qualys assets and their associated vulnerabilities, total number of vulnerabilities
     :rtype: Tuple[list[dict], int]
     """
-    app = check_license()
-    config = app.config
-
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
-
+    config = _get_config()
     with job_progress:
         issues = {}
         for asset in asset_list:
@@ -1285,9 +1283,9 @@ def lookup_asset(asset_list: list, asset_id: str = None) -> list[Asset]:
     :rtype: list[Asset]
     """
     if asset_id:
-        results = [Asset(**asset) for asset in asset_list if getattr(asset, "qualysId", None) == asset_id]
+        results = [asset for asset in asset_list if getattr(asset, "qualysId", None) == asset_id]
     else:
-        results = [Asset(**asset) for asset in asset_list]
+        results = [asset for asset in asset_list]
     # Return unique list
     return list(set(results)) or []
 
@@ -1322,11 +1320,7 @@ def create_regscale_issue_from_vuln(
     :return: list of RegScale issues to update, and a list of issues to be created
     :rtype: Tuple[list[Issue], list[Issue]]
     """
-    app = check_license()
-    config = app.config
-
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
+    config = _get_config()
     default_status = config["issues"]["qualys"]["status"]
     regscale_issues = []
     regscale_existing_issues = Issue.get_all_by_parent(parent_id=regscale_ssp_id, parent_module="securityplans")
@@ -1441,13 +1435,10 @@ def get_asset_groups_from_qualys() -> list:
     :return: list of assets from Qualys
     :rtype: list
     """
-    app = check_license()
-    config = app.config
     asset_groups = []
 
-    # set the auth for the QUALYS_API session
-    QUALYS_API.auth = (config["qualysUserName"], config["qualysPassword"])
-    response = QUALYS_API.get(url=urljoin(config["qualysUrl"], "api/2.0/fo/asset/group?action=list"), headers=HEADERS)
+    qualys_url, QUALYS_API = _get_qualys_api()
+    response = QUALYS_API.get(url=urljoin(qualys_url, "api/2.0/fo/asset/group?action=list"), headers=HEADERS)
     if response.ok:
         logger.debug(response.text)
         try:

regscale/integrations/commercial/servicenow.py

@@ -741,6 +741,7 @@ def create_snow_tag(snow_config: ServiceNowConfig, tag_name: str) -> Optional[di
         "active": True,
         "sys_class_name": "tag",
         "type": "Standard",
+        "viewable_by": "everyone",
     }
     url = urljoin(snow_config.url, "api/now/table/label")
     response = snow_api.post(

regscale/integrations/commercial/sicura/commands.py

@@ -5,11 +5,10 @@ This module contains the Click command group for Sicura.
 import logging
 
 import click
-from rich.console import Console
+
 from regscale.models import regscale_id
 
 logger = logging.getLogger("regscale")
-console = Console()
 
 
 @click.group()
@@ -23,7 +22,7 @@ def sicura():
 
 @sicura.command(name="sync_assets")
 @regscale_id(help="RegScale will create and update assets as children of this record.")
-def sync_assets(regscale_id):
+def sync_assets(regscale_id: int):
     """
     Sync Sicura assets to RegScale.
 
@@ -36,20 +35,18 @@ def sync_assets(regscale_id):
             plan_id=regscale_id,
         )
 
-        with console.status("[bold green]Syncing assets from Sicura to RegScale..."):
-            # Using import_assets method which handles the synchronization
-            integration.sync_assets(plan_id=regscale_id)
+        # Using import_assets method which handles the synchronization
+        integration.sync_assets(plan_id=regscale_id)
 
-        console.print("[bold green]Asset synchronization complete.")
+        logger.info("[bold green]Sicura asset synchronization complete.")
 
     except Exception as e:
         logger.error(f"Error syncing assets: {e}", exc_info=True)
-        console.print(f"[bold red]Error syncing assets: {e}")
 
 
 @sicura.command(name="sync_findings")
 @regscale_id(help="RegScale will create and update findings as children of this record.")
-def sync_findings(regscale_id):
+def sync_findings(regscale_id: int):
     """
     Sync Sicura findings to RegScale.
 
@@ -62,12 +59,10 @@ def sync_findings(regscale_id):
             plan_id=regscale_id,
         )
 
-        with console.status("[bold green]Syncing findings from Sicura to RegScale..."):
-            # Using import_findings method which handles the synchronization
-            integration.sync_findings(plan_id=regscale_id)
+        # Using import_findings method which handles the synchronization
+        integration.sync_findings(plan_id=regscale_id)
 
-        console.print("[bold green]Finding synchronization complete.")
+        logger.info("[bold green]Finding synchronization complete.")
 
     except Exception as e:
         logger.error(f"Error syncing findings: {e}", exc_info=True)
-        console.print(f"[bold red]Error syncing findings: {e}")

regscale/integrations/commercial/snyk.py

@@ -18,7 +18,7 @@ def snyk():
 
 @snyk.command(name="import_snyk")
 @FlatFileImporter.common_scanner_options(
-    message="File path to the folder containing Snyk .xlsx files to process to RegScale.",
+    message="File path to the folder containing Snyk .xlsx or .json files to process to RegScale.",
     prompt="File path for Snyk files",
     import_name="snyk",
 )
@@ -77,7 +77,7 @@ def import_synk_files(
     FlatFileImporter.import_files(
         import_type=Snyk,
         import_name="Snyk",
-        file_types=".xlsx",
+        file_types=[".xlsx", ".json"],
         folder_path=folder_path,
         regscale_ssp_id=regscale_ssp_id,
         scan_date=scan_date,

regscale/integrations/commercial/synqly/ticketing.py

@@ -13,6 +13,17 @@ def ticketing() -> None:
     pass
 
 
+@ticketing.command(name="sync_autotask")
+@regscale_id()
+@regscale_module()
+def sync_autotask(regscale_id: int, regscale_module: str) -> None:
+    """Sync Ticketing data between Autotask and RegScale."""
+    from regscale.models.integration_models.synqly_models.connectors import Ticketing
+
+    ticketing_autotask = Ticketing("autotask")
+    ticketing_autotask.run_sync(regscale_id=regscale_id, regscale_module=regscale_module)
+
+
 @ticketing.command(name="sync_jira")
 @regscale_id()
 @regscale_module()
@@ -111,6 +122,24 @@ def sync_servicenow(regscale_id: int, regscale_module: str, issue_type: str, def
     )
 
 
+@ticketing.command(name="sync_servicenow_sir")
+@regscale_id()
+@regscale_module()
+@click.option(
+    "--issue_type",
+    type=click.STRING,
+    help="servicenow_sir issue type",
+    required=True,
+    prompt="servicenow_sir issue type",
+)
+def sync_servicenow_sir(regscale_id: int, regscale_module: str, issue_type: str) -> None:
+    """Sync Ticketing data between Servicenow Sir and RegScale."""
+    from regscale.models.integration_models.synqly_models.connectors import Ticketing
+
+    ticketing_servicenow_sir = Ticketing("servicenow_sir")
+    ticketing_servicenow_sir.run_sync(regscale_id=regscale_id, regscale_module=regscale_module, issue_type=issue_type)
+
+
 @ticketing.command(name="sync_torq")
 @regscale_id()
 @regscale_module()

regscale/integrations/commercial/tenablev2/click.py

@@ -4,7 +4,7 @@
 
 import queue
 from concurrent.futures import wait
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from regscale.integrations.integration_override import IntegrationOverride
 
@@ -262,13 +262,17 @@ def get_queries() -> list:
     required=True,
 )
 @regscale_ssp_id()
+@click.option(
+    "--scan_date",
+    "-sd",
+    type=click.DateTime(formats=["%Y-%m-%d"]),
+    help="The scan date of the file.",
+    required=False,
+)
 # Add Prompt for RegScale SSP name
-def query_vuln(query_id: int, regscale_ssp_id: int):
+def query_vuln(query_id: int, regscale_ssp_id: int, scan_date: datetime = None):
     """Query Tenable vulnerabilities and sync assets to RegScale."""
-    q_vuln(
-        query_id=query_id,
-        ssp_id=regscale_ssp_id,
-    )
+    q_vuln(query_id=query_id, ssp_id=regscale_ssp_id, scan_date=scan_date)
 
 
 @io.command(name="sync_assets")
@@ -300,14 +304,20 @@ def query_assets(regscale_ssp_id: int, tags: Optional[List[Tuple[str, str]]] = N
     required=False,
     callback=validate_tags,
 )
-# Add Prompt for RegScale SSP name
-def query_vulns(regscale_ssp_id: int, tags: Optional[List[Tuple[str, str]]] = None):
+@click.option(
+    "--scan_date",
+    "-sd",
+    type=click.DateTime(formats=["%Y-%m-%d"]),
+    help="The scan date of the file.",
+    required=False,
+)
+def query_vulns(regscale_ssp_id: int, tags: Optional[List[Tuple[str, str]]] = None, scan_date: datetime = None):
     """
     Query Tenable vulnerabilities and sync assets, vulnerabilities and issues to RegScale.
     """
     from regscale.integrations.commercial.tenablev2.scanner import TenableIntegration
 
-    TenableIntegration.sync_findings(plan_id=regscale_ssp_id, tags=tags)
+    TenableIntegration.sync_findings(plan_id=regscale_ssp_id, tags=tags, scan_date=scan_date)
 
 
 def validate_regscale_security_plan(parent_id: int) -> bool:
@@ -409,18 +419,19 @@ def process_vulnerabilities(counts: collections.Counter, reg_assets: list, ssp_i
     return update_assets
 
 
-def q_vuln(query_id: int, ssp_id: int) -> list:
+def q_vuln(query_id: int, ssp_id: int, scan_date: datetime = None) -> list:
     """
     Query Tenable vulnerabilities
 
     :param int query_id: Tenable query ID
     :param int ssp_id: RegScale System Security Plan ID
+    :param datetime scan_date: Scan date, defaults to None
     :return: List of queries from Tenable
     :rtype: list
     """
     check_license()
     # At SSP level, provide a list of vulnerabilities and the counts of each
-    fetch_vulns(query_id=query_id, regscale_ssp_id=ssp_id)
+    fetch_vulns(query_id=query_id, regscale_ssp_id=ssp_id, scan_date=scan_date)
 
 
 def process_vuln(counts: collections.Counter, reg_assets: list, ssp_id: int, vuln: TenableAsset) -> list:
@@ -708,18 +719,19 @@ def fetch_assets(ssp_id: int) -> list[TenableIOAsset]:
     return assets
 
 
-def fetch_vulns(query_id: int = 0, regscale_ssp_id: int = 0):
+def fetch_vulns(query_id: int = 0, regscale_ssp_id: int = 0, scan_date: datetime = None):
     """
     Fetch vulnerabilities from Tenable by query ID
 
     :param int query_id: Tenable query ID, defaults to 0
     :param int regscale_ssp_id: RegScale System Security Plan ID, defaults to 0
+    :param datetime scan_date: Scan date, defaults to None
     """
 
     client = gen_client()
     if query_id and client._env_base == "TSC":
         vulns = client.analysis.vulns(query_id=query_id)
-        sc = SCIntegration(plan_id=regscale_ssp_id)
+        sc = SCIntegration(plan_id=regscale_ssp_id, scan_date=scan_date)
         # Create pickle file to cache data
         # make sure folder exists
         with tempfile.TemporaryDirectory() as temp_dir:

regscale/integrations/commercial/tenablev2/scanner.py

@@ -6,9 +6,9 @@ import datetime
 import json
 import linecache
 import logging
-from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Tuple
 
+from pathlib import Path
 from tenable.errors import TioExportsError
 
 from regscale.core.app.utils.app_utils import get_current_datetime
@@ -18,7 +18,12 @@ from regscale.integrations.commercial.tenablev2.authenticate import gen_tio
 from regscale.integrations.commercial.tenablev2.stig_parsers import parse_stig_output
 from regscale.integrations.commercial.tenablev2.utils import get_last_pull_epoch
 from regscale.integrations.commercial.tenablev2.variables import TenableVariables
-from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding, ScannerIntegration
+from regscale.integrations.scanner_integration import (
+    IntegrationAsset,
+    IntegrationFinding,
+    ScannerIntegration,
+    issue_due_date,
+)
 from regscale.integrations.variables import ScannerVariables
 from regscale.models import regscale_models
 
@@ -44,9 +49,10 @@ class TenableIntegration(ScannerIntegration):
         :param int plan_id: The ID of the security plan
         :param int tenant_id: The ID of the tenant, defaults to 1
         """
-        super().__init__(plan_id, tenant_id)
+        super().__init__(plan_id, tenant_id, **kwargs)
         self.client = None
         self.tags = tags or []
+        self.scan_date = kwargs.get("scan_date", get_current_datetime())
 
     def authenticate(self) -> None:
         """Authenticate to Tenable."""
@@ -482,6 +488,9 @@ class TenableIntegration(ScannerIntegration):
                 poam_comments=None,
                 vulnerable_asset=asset_id,
                 source_rule_id=str(plugin.get("id", "")),
+                due_date=issue_due_date(
+                    severity=severity, created_date=self.scan_date, title="tenable", config=self.app.config
+                ),
             )
             if is_stig:
                 integration_finding = parse_stig_output(output=plugin_output, finding=integration_finding)

regscale/integrations/commercial/trivy/scanner.py

@@ -13,7 +13,7 @@ from pathlib import Path
 
 from regscale.core.app.utils.parser_utils import safe_datetime_str
 from regscale.integrations.jsonl_scanner_integration import JSONLScannerIntegration
-from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding
+from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding, issue_due_date
 from regscale.models import IssueSeverity, AssetStatus, IssueStatus
 
 logger = logging.getLogger("regscale")
@@ -50,6 +50,9 @@ class TrivyIntegration(JSONLScannerIntegration):
         kwargs["read_files_only"] = True
         kwargs["file_pattern"] = "*.json"
         self.disable_mapping = kwargs["disable_mapping"] = True
+        self.scan_date = kwargs.get("scan_date") if "scan_date" in kwargs else None
+        if self.scan_date:
+            self.scan_date = self.clean_scan_date(self.scan_date)
         super().__init__(*args, **kwargs)
 
     def is_valid_file(self, data: Any, file_path: Union[Path, str]) -> Tuple[bool, Optional[Dict[str, Any]]]:
@@ -167,8 +170,10 @@ class TrivyIntegration(JSONLScannerIntegration):
         :return: IntegrationFinding object
         :rtype: IntegrationFinding
         """
+        created_date = safe_datetime_str(data.get("CreatedAt"))
         # Get scan date from the finding or use current time
-        scan_date = safe_datetime_str(data.get("CreatedAt"))
+        if self.scan_date is None:
+            self.scan_date = created_date
 
         # Process severity
         severity_str = item.get("Severity", "UNKNOWN")
@@ -220,10 +225,10 @@ class TrivyIntegration(JSONLScannerIntegration):
             plugin_id=plugin_id,
             asset_identifier=asset_identifier,
             cve=cve,
-            first_seen=scan_date,
-            last_seen=scan_date,
-            scan_date=scan_date,
-            date_created=scan_date,
+            first_seen=safe_datetime_str(data.get("CreatedAt")),
+            last_seen=self.scan_date,
+            scan_date=self.scan_date,
+            date_created=item.get("CreatedAt"),
             category="Software",
             control_labels=[],
             installed_versions=item.get("InstalledVersion", ""),
@@ -234,6 +239,9 @@ class TrivyIntegration(JSONLScannerIntegration):
             build_version=build_version,
             fixed_versions=item.get("FixedVersion", ""),
             fix_status=item.get("Status", ""),
+            due_date=issue_due_date(
+                severity=severity, created_date=created_date, title="trivy", config=self.app.config
+            ),
         )
 
     @staticmethod

regscale/integrations/commercial/veracode.py

@@ -83,7 +83,7 @@ def import_veracode_data(
     FlatFileImporter.import_files(
         import_type=Veracode,
         import_name="Veracode",
-        file_types=[".xml", ".xlsx"],
+        file_types=[".xml", ".xlsx", ".json"],
         folder_path=folder_path,
         regscale_ssp_id=regscale_ssp_id,
         scan_date=scan_date,