regscale-cli 6.16.4.1__py3-none-any.whl → 6.17.0.0__py3-none-any.whl

regscale/models/integration_models/synqly_models/connectors/__init__.py

@@ -3,5 +3,6 @@ File that contains all connectors for the Synqly API.
 """
 
 from .assets import Assets
+from .edr import Edr
 from .ticketing import Ticketing
 from .vulnerabilities import Vulnerabilities

regscale/models/integration_models/synqly_models/connectors/edr.py

@@ -0,0 +1,137 @@
+"""Vulnerabilities Connector Model"""
+
+from typing import Iterator, Optional
+
+from pydantic import ConfigDict
+
+from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding, ScannerIntegration
+from regscale.models.integration_models.synqly_models.synqly_model import SynqlyModel
+from regscale.models.regscale_models import IssueSeverity
+
+
+class EDRIntegration(ScannerIntegration):
+    title = "EDR Connector Integration"
+    # Required fields from ScannerIntegration
+    asset_identifier_field = "otherTrackingNumber"
+    finding_severity_map = {
+        "Critical": IssueSeverity.Critical,
+        "High": IssueSeverity.High,
+        "Medium": IssueSeverity.Moderate,
+        "Low": IssueSeverity.Low,
+    }
+
+    def fetch_assets(self, *args, **kwargs) -> Iterator[IntegrationAsset]:
+        """
+        Fetches assets from Synqly
+
+        :yields: Iterator[IntegrationAsset]
+        """
+        integration_assets = kwargs.get("integration_assets")
+        for asset in integration_assets:
+            yield asset
+
+    def fetch_findings(self, *args, **kwargs) -> Iterator[IntegrationFinding]:
+        """
+        Fetches findings from the Synqly
+
+        :yields: Iterator[IntegrationFinding]
+        """
+        integration_findings = kwargs.get("integration_findings")
+        for finding in integration_findings:
+            yield finding
+
+
+class Edr(SynqlyModel):
+    """Edr Connector Model"""
+
+    model_config = ConfigDict(populate_by_name=True, use_enum_values=True, arbitrary_types_allowed=True)
+
+    integration_id: str = ""
+    scanner_integration: Optional["EDRIntegration"] = None
+    provider: str = ""
+    can_fetch_apps: bool = False
+    can_fetch_alerts: bool = False
+    can_fetch_endpoints: bool = False
+
+    def __init__(self, integration: str, **kwargs):
+        SynqlyModel.__init__(self, connector_type=self.__class__.__name__, integration=integration, **kwargs)
+        self.integration_id = f"{self._connector_type.lower()}_{self.integration.lower()}"
+        integration_company = self.integration.split("_")[0] if "_" in self.integration else self.integration  # noqa
+        self.provider = integration_company
+        self.can_fetch_apps = "query_applications" in self.capabilities
+        self.can_fetch_alerts = "query_alerts" in self.capabilities
+        self.can_fetch_endpoints = "query_endpoints" in self.capabilities
+
+    def integration_sync(self, regscale_ssp_id: int, **kwargs) -> None:
+        """
+        Runs the integration sync process
+
+        :param int regscale_ssp_id: The RegScale SSP ID
+        :rtype: None
+        """
+        self.logger.info(f"Fetching alert data from {self.integration_name}...")
+        alerts = (
+            self.fetch_integration_data(
+                func=self.tenant.engine_client.edr.query_alerts,
+                **kwargs,
+            )
+            if self.can_fetch_alerts
+            else []
+        )
+        self.logger.info(f"Fetching application data from {self.integration_name}...")
+        apps = (
+            self.fetch_integration_data(func=self.tenant.engine_client.edr.query_applications, **kwargs)
+            if self.can_fetch_apps
+            else []
+        )
+        endpoints = (
+            self.fetch_integration_data(func=self.tenant.engine_client.edr.query_endpoints, **kwargs)
+            if self.can_fetch_endpoints
+            else []
+        )
+
+        edr_data = {"alert(s)": alerts, "app(s)": apps, "endpoint(s)": endpoints}
+        integration_assets: list[IntegrationAsset] = []
+        integration_findings: list[IntegrationFinding] = []
+
+        for name, data in edr_data.items():
+            if data:
+                self.logger.info(f"Mapping {len(data)} {self.provider} {name} to RegScale data...")
+                self.app.thread_manager.submit_tasks_from_list(
+                    func=self.mapper.to_regscale,
+                    items=data,
+                    args=None,
+                    connector=self,
+                    regscale_ssp_id=regscale_ssp_id,
+                    **kwargs,
+                )
+                if mapped_data := self.app.thread_manager.execute_and_verify(return_passed=True):
+                    if isinstance(mapped_data[0], IntegrationFinding):
+                        self.logger.info(f"Mapped {len(mapped_data)} {self.provider} {name} to RegScale finding(s).")
+                        integration_findings.extend(mapped_data)
+                    elif isinstance(mapped_data[0], IntegrationAsset):
+                        self.logger.info(f"Mapped {len(mapped_data)} {self.provider} {name} to RegScale asset(s).")
+                        integration_assets.extend(mapped_data)
+
+        self.scanner_integration = EDRIntegration(plan_id=regscale_ssp_id)
+        self.scanner_integration.sync_assets(
+            title=f"{self.integration_name} EDR",
+            plan_id=regscale_ssp_id,
+            integration_assets=integration_assets,
+            asset_count=len(integration_assets),
+        )
+        self.scanner_integration.sync_findings(
+            title=f"{self.integration_name} EDR",
+            plan_id=regscale_ssp_id,
+            integration_findings=integration_findings,
+            finding_count=len(integration_findings),
+        )
+        self.logger.info(f"[green]Sync from {self.integration_name} to RegScale completed.")
+
+    def run_sync(self, *args, **kwargs) -> None:
+        """
+        Syncs RegScale issues with Vulnerability connector using Synqly
+
+        :rtype: None
+        """
+        self.run_integration_sync(*args, **kwargs)

regscale/models/integration_models/synqly_models/ocsf_mapper.py

@@ -4,7 +4,7 @@ from datetime import datetime
 from typing import Any, Union, TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
-    from regscale.models.integration_models.synqly_models.connectors import Ticketing, Vulnerabilities
+    from regscale.models.integration_models.synqly_models.connectors import Edr, Ticketing, Vulnerabilities
     from synqly.engine.resources.ocsf.resources.v_1_1_0.resources.securityfinding import ResourceDetails, Vulnerability
 
 from synqly import engine
@@ -17,6 +17,9 @@ from regscale.core.app.utils.app_utils import (
 )
 from synqly.engine.resources.ticketing.types.ticket import Ticket
 from synqly.engine.resources.vulnerabilities.types import Asset as OCSFAsset, SecurityFinding
+from synqly.engine.resources.events.types import Event_DetectionFinding as Alerts
+from synqly.engine.resources.ocsf.resources.v_1_3_0.resources.softwareinfo import SoftwareInfo
+from synqly.engine.resources.ocsf.resources.v_1_3_0.resources.inventoryinfo import InventoryInfo
 from regscale.models.regscale_models import Issue
 from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding
 
@@ -39,21 +42,27 @@ class Mapper:
         else:
             error_and_exit(f"Unsupported object type {type(regscale_object)}")
 
-    def to_regscale(self, ocsf_object: Any, connector: Union["Ticketing", "Vulnerabilities"], **kwargs) -> Any:
+    def to_regscale(self, ocsf_object: Any, connector: Union["Edr", "Ticketing", "Vulnerabilities"], **kwargs) -> Any:
         """
         Convert OCSF object to RegScale object
 
         :param Any ocsf_object: OCSF object to convert to a RegScale object
-        :param Union["Ticketing", "Vulnerabilities"] connector: Connector class object
+        :param Union["Edr", "Ticketing", "Vulnerabilities"] connector: Connector class object
         :return: The comparable RegScale object
         :rtype: Any
         """
         if isinstance(ocsf_object, Ticket):
             return self._ticket_to_regscale(connector, ocsf_object, **kwargs)
-        elif isinstance(ocsf_object, OCSFAsset):
+        elif (
+            isinstance(ocsf_object, OCSFAsset)
+            or isinstance(ocsf_object, SoftwareInfo)
+            or isinstance(ocsf_object, InventoryInfo)
+        ):
             return self._ocsf_asset_to_regscale(connector, ocsf_object, **kwargs)
         elif isinstance(ocsf_object, SecurityFinding):
             return self._security_finding_to_regscale(connector, ocsf_object, **kwargs)
+        elif isinstance(ocsf_object, Alerts):
+            return self._security_alert_to_regscale(connector, ocsf_object, **kwargs)
         else:
             error_and_exit(f"Unsupported object type {type(ocsf_object)}")
 
@@ -94,12 +103,14 @@ class Mapper:
         return regscale_issue
 
     @staticmethod
-    def _ocsf_asset_to_regscale(connector: "Vulnerabilities", asset: OCSFAsset, **kwargs) -> IntegrationAsset:
+    def _ocsf_asset_to_regscale(
+        connector: Union["Edr", "Vulnerabilities"], asset: Union[InventoryInfo, OCSFAsset, SoftwareInfo], **kwargs
+    ) -> IntegrationAsset:
         """
         Convert OCSF Asset to RegScale Asset
 
-        :param Vulnerabilities connector: Vulnerabilities connector class object
-        :param OCSFAsset asset: OCSF Asset to convert to an IntegrationAsset
+        :param Union["Edr", "Vulnerabilities"] connector: Edr or Vulnerabilities connector class object
+        :param Union[InventoryInfo, OCSFAsset, SoftwareInfo] asset: OCSF Asset data to convert to an IntegrationAsset
         :return: The comparable IntegrationAsset object
         :rtype: IntegrationAsset
         """
@@ -113,11 +124,17 @@ class Mapper:
             ]
         else:
             software_inventory = []
+        if isinstance(asset, OCSFAsset):  # this is a hardware asset
+            name = device_data.name or device_data.hostname or f"{connector.provider} Asset: {device_data.instance_uid}"
+            category = AssetCategory.Hardware
+        else:
+            name = device_data.name or device_data.hostname or f"{connector.provider} Asset: {device_data.uid}"
+            category = AssetCategory.Software
         return IntegrationAsset(
-            name=device_data.name or device_data.hostname or f"{connector.provider} Asset: {device_data.instance_uid}",
+            name=name,
             identifier=device_data.uid,
-            asset_type=device_data.type,
-            asset_category=AssetCategory.Hardware,
+            asset_type=device_data.type or "Other",
+            asset_category=category,
             parent_id=kwargs.pop("regscale_ssp_id"),
             parent_module=SecurityPlan.get_module_string(),
             mac_address=device_data.mac,
@@ -129,7 +146,7 @@ class Mapper:
             serial_number=device_data.hw_info.serial_number if device_data.hw_info else None,
             cpu=device_data.hw_info.cpu_cores if device_data.hw_info else None,
             ram=device_data.hw_info.ram_size if device_data.hw_info else None,
-            operating_system=os_data.name if os_data else None,
+            operating_system=os_data.name or os_data.type if os_data else None,
             os_version=os_data.version if os_data else None,
             software_inventory=software_inventory,
         )
@@ -252,6 +269,39 @@ class Mapper:
 
         return findings
 
+    def _security_alert_to_regscale(self, connector: "Edr", finding: Alerts, **_) -> IntegrationFinding:
+        """
+        Converts an OCSF Event_DetectionFinding (Alerts) to a RegScale IntegrationFinding
+
+        :param "Edr" connector: Edr connector class object
+        :param Alerts finding: OCSF Event_DetectionFinding (Alerts) to convert to an IntegrationFinding
+        :return: Comparable IntegrationFinding object
+        :rtype: IntegrationFinding
+        """
+        from regscale.models.regscale_models.issue import IssueStatus
+
+        asset = finding.device
+        vuln = finding.finding_info
+
+        return IntegrationFinding(
+            control_labels=[],
+            category=f"{connector.integration_name} Vulnerability",
+            title=vuln.title,
+            plugin_name=connector.integration_name,
+            severity=Issue.assign_severity(finding.severity),  # type: ignore
+            description=vuln.desc or finding.comment,
+            status=IssueStatus.Open,
+            first_seen=self._datetime_to_str(vuln.first_seen_time_dt),
+            last_seen=self._datetime_to_str(vuln.last_seen_time_dt),
+            ip_address=asset.ip,
+            plugin_id=vuln.product_uid,
+            dns=asset.hostname,
+            issue_title=vuln.title,
+            impact=finding.impact,
+            asset_identifier=asset.uid,
+            source_report=connector.integration_name,
+        )
+
     def _datetime_to_str(self, date_time: Optional[datetime] = None) -> str:
         """
         Convert a datetime object to a string

regscale/models/integration_models/synqly_models/synqly_model.py

@@ -41,7 +41,7 @@ class SynqlyModel(BaseModel, ABC):
     terminated: Optional[bool] = False
     app: Application = Field(default_factory=Application, alias="app")
     api: Api = Field(default_factory=Api, alias="api")
-    logger: logging.Logger = Field(default=logging.getLogger("rich"), alias="logger")
+    logger: logging.Logger = Field(default=logging.getLogger("regscale"), alias="logger")
     job_progress: Optional[Progress] = None
     integration: str = ""
     integration_name: str = Field(default="", description="This stores the proper name of the integration for logging.")
@@ -176,8 +176,8 @@ class SynqlyModel(BaseModel, ABC):
             raise ModuleNotFoundError(f"Unable to find the config object for {self._connector_type}_{self.integration}")
         check_attributes = [self.required_secrets, self.required_params]
         for attribute in check_attributes:
-            for secret in attribute:
-                if secret != "optional":
+            for secret, param in attribute.items():
+                if not param.optional:
                     kwargs.update(
                         self._update_config_and_kwargs(
                             attribute=attribute,  # type: ignore
@@ -196,8 +196,8 @@ class SynqlyModel(BaseModel, ABC):
             error_and_exit("Please provide the required secrets mentioned above.")
         self.integration_config = config_object(
             type=f"{self._connector_type.lower()}_{self.integration.lower()}",
-            url=kwargs.get("url"),
             credential=self._get_auth_method(**kwargs),
+            **kwargs,
         )
 
     def _get_auth_method(self, **kwargs) -> Any:
@@ -236,7 +236,10 @@ class SynqlyModel(BaseModel, ABC):
         :rtype: dict
         """
         if key not in kwargs and not config.get(f"{self._connector_type}_{self.integration}_{key}"):
-            if not skip_prompts:
+            if attribute[key].default:
+                kwargs[key] = attribute[key].default
+                config[f"{self._connector_type}_{self.integration}_{key}"] = attribute[key].default
+            elif not skip_prompts:
                 self.logger.info(f"Enter the {key} for {self.integration}. Description: {attribute[key].description}")
                 provided_secret = input(f"{key}: ")
                 kwargs[key] = provided_secret

regscale/models/regscale_models/file.py

@@ -11,7 +11,7 @@ import os
 import sys
 from io import BytesIO
 from pathlib import Path
-from typing import Optional, Union, Tuple
+from typing import Optional, Tuple, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 from requests import JSONDecodeError
@@ -375,6 +375,8 @@ class File(BaseModel):
                 file_type_header = "text/xml"
             elif file_type == ".gz":
                 file_type_header = "application/gzip"
+            elif file_type == ".msg":
+                file_type_header = "application/vnd.ms-outlook"
             else:
                 logger = logging.getLogger("regscale")
                 logger.warning(f"Unacceptable file type for upload: {file_type}")

regscale/models/regscale_models/master_assessment.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for a RegScale Assessment"""
+from typing import List, Optional
+
+from pydantic import ConfigDict, Field
+
+from regscale.models.regscale_models.assessment import Assessment
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class MasterAssessment(RegScaleModel):
+    """
+    Model for a RegScale Assessment
+    """
+
+    _module_slug = "masterassessments"
+    _unique_fields = [["title", "parentId", "parentModule"]]
+
+    id: int = Field(default=0, description="Internal identifier for the assessment")
+    # Relationship and metadata fields
+    parentId: int = Field(description="ID of the parent record")
+    parentModule: str = Field(description="Module of the parent record")
+
+    leadAssessorId: str = Field(default="", description="Identifier for the lead assessor")
+    title: str = Field(default=None, description="Title of the assessment")
+    instructions: str = Field(default=None, description="Instructions for the assessment")
+    plannedFinish: str = Field(default=None, description="Planned finish date of the assessment")
+    status: str = Field(default=None, description="Current status of the assessment")
+    actualFinish: Optional[str] = Field(default=None, description="Actual finish date of the assessment")
+    dateAdjustedForCorrections: bool = Field(
+        default=False, description="Flag indicating if dates were adjusted for corrections"
+    )
+    percentComplete: float = Field(default=0.0, description="Percentage of assessment completed", ge=0, le=100)
+    complianceScore: Optional[int] = Field(default=None, description="Compliance score of the assessment")
+
+    # Assessment documentation
+    assessmentPlan: Optional[str] = Field(default=None, description="The assessment plan document")
+    methodology: Optional[str] = Field(default=None, description="Methodology used for the assessment")
+    rulesOfEngagement: Optional[str] = Field(default=None, description="Rules of engagement for the assessment")
+    disclosures: Optional[str] = Field(default=None, description="Disclosures related to the assessment")
+    scopeIncludes: Optional[str] = Field(default=None, description="What is included in the assessment scope")
+    scopeExcludes: Optional[str] = Field(default=None, description="What is excluded from the assessment scope")
+    limitationsOfLiability: Optional[str] = Field(
+        default=None, description="Limitations of liability for the assessment"
+    )
+    documentsReviewed: Optional[str] = Field(default=None, description="Documents reviewed during the assessment")
+    activitiesObserved: Optional[str] = Field(default=None, description="Activities observed during the assessment")
+    fixedDuringAssessment: Optional[str] = Field(default=None, description="Issues fixed during the assessment")
+    summaryOfResults: Optional[str] = Field(default=None, description="Summary of assessment results")
+    assessmentReport: Optional[str] = Field(default=None, description="Full assessment report")
+
+    # FedRAMP specific fields
+    fedrampAssessmentType: Optional[str] = Field(default=None, description="Type of FedRAMP assessment")
+    fedrampSignificantChanges: Optional[str] = Field(default=None, description="Significant changes for FedRAMP")
+    fedrampSubmitter: Optional[str] = Field(default=None, description="FedRAMP submitter information")
+    fedrampScope: Optional[str] = Field(default=None, description="FedRAMP assessment scope")
+    fedrampVulnerabilitySampling: Optional[str] = Field(
+        default=None, description="FedRAMP vulnerability sampling methodology"
+    )
+    fedrampTestingSampling: Optional[str] = Field(default=None, description="FedRAMP testing sampling methodology")
+    fedrampTestingNotification: Optional[str] = Field(default=None, description="FedRAMP testing notification details")
+    fedrampTestingDays: Optional[int] = Field(default=None, description="Number of FedRAMP testing days")
+    fedrampDatabaseDiscrepanicies: Optional[str] = Field(default=None, description="FedRAMP database discrepancies")
+    fedrampDatabaseDiscrepaniciesDescription: Optional[str] = Field(
+        default=None, description="Description of FedRAMP database discrepancies"
+    )
+    fedrampWebDiscrepanicies: Optional[str] = Field(default=None, description="FedRAMP web discrepancies")
+    fedrampWebDiscrepaniciesDescription: Optional[str] = Field(
+        default=None, description="Description of FedRAMP web discrepancies"
+    )
+    fedrampContainerDiscrepanicies: Optional[str] = Field(default=None, description="FedRAMP container discrepancies")
+    fedrampContainerDiscrepaniciesDescription: Optional[str] = Field(
+        default=None, description="Description of FedRAMP container discrepancies"
+    )
+
+    @staticmethod
+    def _get_additional_endpoints() -> dict[str, str]:
+        """
+        Get additional endpoints for the Assessments model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: dict[str, str]
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_master="/api/{model_slug}/getAllByMaster/{masterAssessmentId}",
+            get_history="/api/{model_slug}/getHistory/{parentId}/{parentModuleName}",
+        )
+
+    @classmethod
+    def get_history(cls, parent_id: int, parent_module: str) -> List[Assessment]:
+        """
+        Get a list of master assessments ordered by planned finish date.
+
+        :param int parent_id: The ID of the parent record
+        :param str parent_module: The module of the parent record
+        :return: A list of assessments
+        :rtype: List[Assessment]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_history").format(parentId=parent_id, parentModuleName=parent_module)
+        )
+        master_assessments = []
+        if response and response.ok:
+            for ci in response.json():
+                if ci := cls.get_object(object_id=ci["id"]):
+                    master_assessments.append(ci)
+        return master_assessments
+
+    @classmethod
+    def get_all_by_master(cls, master_assessment_id: int) -> List["Assessment"]:
+        """
+        Get a list of assessments by id.
+
+        :param int master_assessment_id: The ID of the master assessment
+        :return: A list of assessments
+        :rtype: List[Assessment]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_master").format(masterAssessmentId=master_assessment_id)
+        )
+        assessments = []
+        if response and response.ok:
+            for ci in response.json():
+                if ci := cls.get_object(object_id=ci["id"]):
+                    assessments.append(ci)
+        return assessments

regscale/models/regscale_models/regscale_model.py

@@ -1315,8 +1315,7 @@ class RegScaleModel(BaseModel, ABC):
             :param Optional[Progress] progress: Optional progress context for tracking
             :param Optional[bool] remove_progress_bar: Whether to remove the progress bar after completion, defaults to False
             """
-            # noqa: F824
-            nonlocal results
+            nonlocal results  # noqa: F824
             create_job = None
             if progress:
                 create_job = progress.add_task(
@@ -1373,8 +1372,7 @@ class RegScaleModel(BaseModel, ABC):
             :param Optional[Progress] progress: Optional progress context for tracking
             :param Optional[bool] remove_progress_bar: Whether to remove the progress bar after completion, defaults to False
             """
-            # noqa: F824
-            nonlocal results
+            nonlocal results  # noqa: F824
             update_job = None
             if progress:
                 update_job = progress.add_task(

regscale/models/regscale_models/risk.py

@@ -9,7 +9,6 @@ from regscale.core.app.api import Api
 from regscale.core.app.application import Application
 from regscale.models.regscale_models.regscale_model import RegScaleModel
 
-
 logger = logging.getLogger("regscale")
 
 
@@ -52,7 +51,6 @@ class Risk(RegScaleModel):
     comments: Optional[str] = None
     riskTier: Optional[str] = None
     title: Optional[str] = None
-    recommendations: Optional[str] = None
     impactDescription: Optional[str] = None
     inherentRiskScore: Optional[float] = None
     residualRiskScore: Optional[float] = None
@@ -79,11 +77,10 @@ class Risk(RegScaleModel):
     parentRiskModelId: Optional[int] = None
 
     @staticmethod
-    def fetch_all_risks(app: Application) -> list["Risk"]:
+    def fetch_all_risks() -> list["Risk"]:
         """
         Fetches all risks from RegScale
 
-        :param Application app: Application object
         :return: List of Risks from RegScale
         :rtype: list[Risk]
         """
@@ -113,7 +110,6 @@ class Risk(RegScaleModel):
     def get_sort_position_dict(cls) -> dict:
         """
         Overrides the base method.
-
         :return: dict The sort position in the list of properties
         :rtype: dict
         """
@@ -153,31 +149,30 @@ class Risk(RegScaleModel):
             "comments": 30,
             "riskTier": 31,
             "title": 32,
-            "recommendations": 33,
-            "impactDescription": 34,
-            "inherentRiskScore": 35,
-            "residualRiskScore": 36,
-            "targetRiskScore": 37,
-            "difference": 38,
-            "futureCosts": 39,
-            "costToMitigate": 40,
-            "controlId": 41,
-            "assessmentId": 42,
-            "requirementId": 43,
-            "securityPlanId": 44,
-            "projectId": 45,
-            "supplyChainId": 46,
-            "policyId": 47,
-            "componentId": 48,
-            "incidentId": 49,
-            "riskAssessmentFrequency": 50,
-            "dateLastAssessed": 51,
-            "nextAssessmentDueDate": 52,
-            "riskOwnerId": 53,
+            "impactDescription": 33,
+            "inherentRiskScore": 34,
+            "residualRiskScore": 35,
+            "targetRiskScore": 36,
+            "difference": 37,
+            "futureCosts": 38,
+            "costToMitigate": 39,
+            "controlId": 40,
+            "assessmentId": 41,
+            "requirementId": 42,
+            "securityPlanId": 43,
+            "projectId": 44,
+            "supplyChainId": 45,
+            "policyId": 46,
+            "componentId": 47,
+            "incidentId": 48,
+            "riskAssessmentFrequency": 49,
+            "dateLastAssessed": 50,
+            "nextAssessmentDueDate": 51,
+            "riskOwnerId": 52,
             "isPublic": -1,
-            "averageRiskScore": 54,
-            "weightedRiskScore": 55,
-            "parentRiskModelId": 56,
+            "averageRiskScore": 53,
+            "weightedRiskScore": 54,
+            "parentRiskModelId": 55,
         }
 
     # pylint: disable=W0613
@@ -215,7 +210,7 @@ class Risk(RegScaleModel):
             "componentId": "",
             "incidentId": "",
         }
-        if field_name in lookup_fields.keys():
+        if field_name in lookup_fields:
             return lookup_fields[field_name]
         return ""
 
@@ -247,7 +242,7 @@ class Risk(RegScaleModel):
         :rtype: list
         """
         # This query returns all risks and doesn't use the parent ID or module provided.
-        return cls.fetch_all_risks(app)
+        return cls.fetch_all_risks()
 
     @classmethod
     def use_query(cls) -> bool:

regscale/models/regscale_models/supply_chain.py

@@ -91,21 +91,21 @@ class SupplyChain(RegScaleModel):
     _module_slug = "supplychain"
 
     title: str
+    contractType: Union[SupplyChainContractType, str]  # Required
+    strategicTier: Union[SupplyChainTier, str]  # Required
+    fips: Union[SupplyChainFipsImpact, str]  # Required
     id: Optional[int] = 0
     status: Union[SupplyChainStatus, str] = SupplyChainStatus.Pending
     uuid: Optional[str] = None
-    fips: Optional[Union[SupplyChainFipsImpact, str]] = None
     contractNumber: Optional[str] = None
     isPublic: bool = True
     parentId: int = 0
     parentModule: Optional[str] = None
-    orgId: Optional[int] = 0
-    facilityId: Optional[int] = 0
+    orgId: Optional[int] = None
+    facilityId: Optional[int] = None
     contractValue: Optional[int] = 0
     fundedAmount: Optional[int] = 0
     actualCosts: Optional[int] = 0
-    strategicTier: Optional[Union[SupplyChainTier, str]] = None
-    contractType: Optional[Union[SupplyChainContractType, str]] = None
     scope: Optional[str] = None
     startDate: Optional[str] = None
     endDate: Optional[str] = None

regscale/regscale.py

@@ -149,6 +149,7 @@ aqua = import_command_with_timing(COMMERCIAL, "aqua")
 awsv2 = import_command_with_timing(COMMERCIAL, "aws")
 azure = import_command_with_timing(COMMERCIAL, "azure")
 burp = import_command_with_timing(COMMERCIAL, "burp")
+edr = import_command_with_timing("regscale.integrations.commercial.synqly.edr", "edr")
 assets = import_command_with_timing("regscale.integrations.commercial.synqly.assets", "assets")
 vulnerabilities = import_command_with_timing(
     "regscale.integrations.commercial.synqly.vulnerabilities", "vulnerabilities"
@@ -766,6 +767,7 @@ cli.add_command(aqua)  # Add Aqua ECR support
 cli.add_command(awsv2)  # add AWS support
 cli.add_command(azure)  # add Azure Integration
 cli.add_command(burp)  # add Burp File Integration
+cli.add_command(edr)  # add Edr connector
 cli.add_command(assets)  # add Assets connector
 cli.add_command(vulnerabilities)  # add Vulnerabilities connector
 cli.add_command(ticketing)  # add Ticketing connector

{regscale_cli-6.16.4.1.dist-info → regscale_cli-6.17.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: regscale-cli
-Version: 6.16.4.1
+Version: 6.17.0.0
 Summary: Command Line Interface (CLI) for bulk processing/loading data into RegScale
 Home-page: https://github.com/RegScale/regscale-cli
 Author: Travis Howerton