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

regscale/models/integration_models/tenable_models/integration.py

@@ -9,7 +9,12 @@ from typing import Any, Iterator, List, Optional, Tuple
 from regscale.core.app.utils.app_utils import epoch_to_datetime
 from regscale.integrations.commercial.tenablev2.utils import get_filtered_severities
 from regscale.integrations.integration_override import IntegrationOverride
-from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding, ScannerIntegration
+from regscale.integrations.scanner_integration import (
+    IntegrationAsset,
+    IntegrationFinding,
+    ScannerIntegration,
+    issue_due_date,
+)
 from regscale.models import regscale_models
 from regscale.models.integration_models.tenable_models.models import TenableAsset
 
@@ -32,6 +37,16 @@ class SCIntegration(ScannerIntegration):
     title = "Tenable SC"
     asset_identifier_field = "tenableId"
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Initializes the SCIntegration class
+
+        :param Tuple args: Additional arguments
+        :param dict kwargs: Additional keyword arguments
+        """
+        super().__init__(*args, **kwargs)
+        self.scan_date = kwargs.get("scan_date")
+
     def fetch_assets(self, *args: Any, **kwargs: Any) -> Iterator[IntegrationAsset]:
         """
         Fetches assets from SCIntegration
@@ -138,6 +153,7 @@ class SCIntegration(ScannerIntegration):
             fixed_versions = re.findall(r"Fixed version\s*:\s*(.+)", vuln.pluginText)
             fixed_versions_str = ", ".join(fixed_versions)
 
+        first_seen = epoch_to_datetime(vuln.firstSeen) if vuln.firstSeen else self.scan_date
         return IntegrationFinding(
             control_labels=[],  # Add an empty list for control_labels
             category="Tenable SC Vulnerability",  # Add a default category
@@ -148,9 +164,9 @@ class SCIntegration(ScannerIntegration):
             status=regscale_models.IssueStatus.Open,  # Findings of > Low are considered as FAIL
             asset_identifier=asset_identifier,
             external_id=vuln.pluginID,  # Weakness Source Identifier
-            first_seen=epoch_to_datetime(vuln.firstSeen),
+            first_seen=first_seen,
             last_seen=epoch_to_datetime(vuln.lastSeen),
-            date_created=epoch_to_datetime(vuln.firstSeen),
+            date_created=first_seen,
             date_last_updated=epoch_to_datetime(vuln.lastSeen),
             recommendation_for_mitigation=vuln.solution,
             cve=cve,
@@ -175,6 +191,10 @@ class SCIntegration(ScannerIntegration):
             installed_versions=installed_versions_str,
             fixed_versions=fixed_versions_str,
             fix_status="",
+            scan_date=self.scan_date,
+            due_date=issue_due_date(
+                severity=severity, created_date=first_seen, title="tenable", config=self.app.config
+            ),
         )
 
     def get_cvss_scores(self, vuln: TenableAsset) -> dict:

regscale/models/regscale_models/control_implementation.py

@@ -212,8 +212,26 @@ class ControlImplementation(RegScaleModel):
             get_all_asset_controls_by_component="/api/{model_slug}/getAllAssetControlsByComponent/{int_id}",
             drilldown_asset_controls_by_component="/api/{model_slug}/drilldownAssetControlsByComponent/{component_id}/{str_field}/{str_value}",  # noqa: E501
             get_control_context="/api/{model_slug}/getControlContext/{int_control_id}/{int_parent_id}/{str_module}",
+            get_control_with_all_child_details="/api/{model_slug}/getControlWithAllChildDetails/{intId}",
         )
 
+    @classmethod
+    def get_with_child_details(cls, implementation_id: int) -> Optional[list[dict]]:
+        """
+        Get control implementation with all child details.
+
+        Retrieve a control implementation with all supporting data in a single call.
+
+        :param int implementation_id: The ID of the control implementation
+        :return: A list of control implementation details or None
+        :rtype: Optional[list[dict]]
+        """
+        endpoint = cls.get_endpoint("get_control_with_all_child_details").format(intId=implementation_id)
+        response = cls._get_api_handler().get(endpoint)
+        if response and response.ok:
+            return response.json()
+        return None
+
     def find_by_unique(self, **kwargs: dict) -> Optional["ControlImplementation"]:
         """
         Find an object by unique query.

regscale/models/regscale_models/control_objective.py

@@ -4,7 +4,7 @@
 from collections import defaultdict
 from typing import Any, Optional
 
-from pydantic import Field, ConfigDict
+from pydantic import ConfigDict, Field
 
 from regscale.core.app.utils.app_utils import get_current_datetime
 from regscale.models.regscale_models.regscale_model import RegScaleModel
@@ -25,6 +25,7 @@ class ControlObjective(RegScaleModel):
     otherId: str = ""  # API does not return if None
     archived: bool = False
     securityControlId: int
+    parentObjectiveId: Optional[int] = None
     dateCreated: str = Field(default_factory=get_current_datetime)
     dateLastUpdated: str = Field(default_factory=get_current_datetime)
     objectiveType: str = "objective"

regscale/models/regscale_models/facility.py

@@ -1,11 +1,9 @@
 """Facility model for RegScale."""
 
-import warnings
 from typing import Optional
-from urllib.parse import urljoin
 
-from regscale.core.app.api import Api
-from regscale.core.app.application import Application
+from pydantic import ConfigDict
+
 from regscale.models.regscale_models.regscale_model import RegScaleModel
 
 
@@ -32,28 +30,14 @@ class Facility(RegScaleModel):
     isPublic: bool = True
     dateLastUpdated: Optional[str] = None
 
-    def post(self, app: Application) -> Optional[dict]:
-        """Post a Facility to RegScale
+    @staticmethod
+    def _get_additional_endpoints() -> dict:
+        """
+        Get additional endpoints for the Facility model.
 
-        :param Application app: The application instance
-        :return: The response from the API or None
-        :rtype: Optional[dict]
+        :return: A dictionary of additional endpoints
+        :rtype: dict
         """
-        warnings.warn(
-            "The 'post' method is deprecated, use 'create' method instead",
-            DeprecationWarning,
-        )
-        api = Api()
-        url = urljoin(app.config.get("domain", ""), "/api/facilities")
-        data = self.dict()
-        response = api.post(url, json=data)
-        return response.json() if response.ok else None
-
-
-class Facilities(Facility):
-    def __init__(self, *args, **kwargs):
-        warnings.warn(
-            "The 'Facilities' class is deprecated, use 'Facility' instead",
-            DeprecationWarning,
+        return ConfigDict(
+            get_list="/api/{model_slug}/get_list",
         )
-        super().__init__(*args, **kwargs)

regscale/models/regscale_models/functional_roles.py

@@ -0,0 +1,38 @@
+from typing import List
+
+from pydantic import ConfigDict
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class FunctionalRole(RegScaleModel):
+    """
+    Functional Role Model
+    """
+
+    _module_slug = "functionalroles"
+
+    id: int = 0
+    role: str
+
+    @classmethod
+    def get_list(cls) -> List["FunctionalRole"]:
+        """
+        Get list of Functional Roles
+
+        :return: list of Functional Roles
+        :rtype: List["FunctionalRole"]
+        """
+        return cls._handle_list_response(cls._get_api_handler().get(cls.get_endpoint("get_list")))
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the FunctionalRole
+
+        :return: Additional endpoints for the FunctionalRole
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_list="/api/{model_slug}/getList",
+        )

regscale/models/regscale_models/issue.py

@@ -788,7 +788,9 @@ class Issue(RegScaleModel):
         take = 50
         skip = 0
         control_issues: Dict[int, List[OpenIssueDict]] = defaultdict(list)
-        logger.info("Fetching open issues for controls and for security plan %i...", plan_id)
+        logger.info(
+            f"Fetching open issues for controls and for security plan {plan_id}...",
+        )
         supports_multiple_controls: bool = cls.is_multiple_controls_supported()
 
         # Define fields based on version

regscale/models/regscale_models/parameter.py

@@ -3,10 +3,9 @@
 """Regscale Model for Implementation Parameter in the application"""
 
 from enum import Enum
-from typing import Optional, List
+from typing import List, Optional
 
-from pydantic import ConfigDict
-from pydantic import Field
+from pydantic import ConfigDict, Field
 
 from regscale.core.app.utils.app_utils import get_current_datetime
 from regscale.models.regscale_models.regscale_model import RegScaleModel
@@ -85,3 +84,22 @@ class Parameter(RegScaleModel):
         if response and response.ok:
             return [Parameter(**param) for param in response.json()]
         return []
+
+    @classmethod
+    def merge_parameters(cls, implementation_id: int, security_control_id: int) -> List["Parameter"]:
+        """
+        Get a list of parameters by implementation ID and security control ID.
+
+        :param int implementation_id: The ID of the controlImplementation
+        :param int security_control_id: The ID of the security control
+        :return: A list of parameters
+        :rtype: List["Parameter"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("merge").format(
+                implementationID=implementation_id, securityControlID=security_control_id
+            )
+        )
+        if response and response.ok:
+            return [cls(**ci) for ci in response.json()]
+        return []

regscale/models/regscale_models/profile.py

@@ -30,6 +30,28 @@ class Profile(RegScaleModel):
     confidentiality: Optional[str] = None
     integrity: Optional[str] = None
 
+    @classmethod
+    def apply_profile(cls, module_id: int, module_name: str, profile_id: int, is_public: bool) -> bool:
+        """
+        Apply a profile to a module.
+
+        :param int module_id: The module ID
+        :param str module_name: The module name
+        :param int profile_id: The profile ID
+        :param bool is_public: Whether the profile is public
+        :return: True if the profile was applied
+        :rtype: bool
+        """
+        endpoint = cls.get_endpoint("apply_profile").format(
+            model_slug=cls._module_slug,
+            moduleId=module_id,
+            moduleName=module_name,
+            profileId=profile_id,
+            isPublic=is_public,
+        )
+        response = cls._get_api_handler().post(endpoint)
+        return response.ok
+
     @staticmethod
     def _get_additional_endpoints() -> ConfigDict:
         """

regscale/models/regscale_models/profile_mapping.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """Model for Profile Mapping in the application"""
-from typing import List, Optional
+import importlib
+from typing import TYPE_CHECKING, List, Optional
 from urllib.parse import urljoin
 
 from pydantic import ConfigDict, Field
@@ -11,6 +12,9 @@ from regscale.core.app.application import Application
 from regscale.models.regscale_models.regscale_model import RegScaleModel
 from regscale.models.regscale_models.security_control import SecurityControl
 
+if TYPE_CHECKING:
+    from regscale.models import ControlImplementation, ControlImplementationStatus
+
 
 class ProfileMapping(RegScaleModel):
     """
@@ -33,6 +37,41 @@ class ProfileMapping(RegScaleModel):
     isPublic: bool = True
     lastUpdatedById: Optional[str] = None
 
+    def __init__(self, **data):
+        super().__init__(**data)
+
+    # Create a lazily loaded reference to avoid circular imports
+    def _get_control_implementation_classes(self):
+        """
+        Get the control implementation classes in a lazy manner
+
+        :return: The control implementation classes
+        :rtype: Tuple[ControlImplementation, ControlImplementationStatus]
+        :raises ImportError: If the module cannot be imported
+        """
+        module = importlib.import_module("regscale.models")
+        return (module.ControlImplementation, module.ControlImplementationStatus)
+
+    def to_implementation(self, security_plan_id: int):
+        """
+        Convert a profile mapping to a control implementation.
+
+        :param int security_plan_id: The parent Security Plan ID
+        :rtype: ControlImplementation
+        :return: The control implementation
+        """
+        # Create a lazily loaded reference to avoid circular imports, will only import once, and subsequent calls will
+        # use the already imported classes
+        ControlImplementation, ControlImplementationStatus = self._get_control_implementation_classes()
+
+        return ControlImplementation(
+            status=ControlImplementationStatus.NotImplemented.value,
+            controlID=self.controlID,
+            assessmentFrequency=365,
+            parentId=security_plan_id,
+            parentModule="securityplans",
+        )
+
     @staticmethod
     def _get_additional_endpoints() -> ConfigDict:
         """
@@ -62,14 +101,20 @@ class ProfileMapping(RegScaleModel):
         :return: List of profile mappings
         :rtype: List[ProfileMapping]
         """
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
         response = cls._get_api_handler().get(
             endpoint=cls.get_endpoint("get_by_profile").format(intProfileID=profile_id)
         )
         mappings = []
         if response and response.ok:
             mappings = [cls(**map) for map in response.json()]
-            for mapping in mappings:
-                if control := SecurityControl.get_object(object_id=mapping.controlID):
+            with ThreadPoolExecutor() as executor:
+                futures = [
+                    executor.submit(SecurityControl.get_object, object_id=mapping.controlID) for mapping in mappings
+                ]
+            for future, mapping in zip(as_completed(futures), mappings):
+                if control := future.result():
                     mapping.control = control
         return mappings
 

regscale/models/regscale_models/regscale_model.py

@@ -1315,6 +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
             create_job = None
             if progress:
@@ -1372,6 +1373,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
             update_job = None
             if progress:

regscale/models/regscale_models/risk.py

@@ -48,17 +48,18 @@ class Risk(RegScaleModel):
     dateClosed: Optional[str] = None
     facilityId: Optional[int] = None
     orgId: Optional[int] = None
+    scenarioId: Optional[int] = None
     comments: Optional[str] = None
     riskTier: Optional[str] = None
     title: Optional[str] = None
     recommendations: Optional[str] = None
     impactDescription: Optional[str] = None
-    inherentRiskScore: Optional[int] = None
-    residualRiskScore: Optional[int] = None
-    targetRiskScore: Optional[int] = None
-    difference: Optional[int] = None
-    futureCosts: Optional[int] = None
-    costToMitigate: Optional[int] = None
+    inherentRiskScore: Optional[float] = None
+    residualRiskScore: Optional[float] = None
+    targetRiskScore: Optional[float] = None
+    difference: Optional[float] = None
+    futureCosts: Optional[float] = None
+    costToMitigate: Optional[float] = None
     controlId: Optional[int] = None
     assessmentId: Optional[int] = None
     requirementId: Optional[int] = None
@@ -73,6 +74,9 @@ class Risk(RegScaleModel):
     nextAssessmentDueDate: Optional[str] = None
     riskOwnerId: Optional[str] = None
     isPublic: bool = True
+    averageRiskScore: Optional[float] = None
+    weightedRiskScore: Optional[float] = None
+    parentRiskModelId: Optional[int] = None
 
     @staticmethod
     def fetch_all_risks(app: Application) -> list["Risk"]:
@@ -145,31 +149,35 @@ class Risk(RegScaleModel):
             "dateClosed": 26,
             "facilityId": 27,
             "orgId": 28,
-            "comments": 29,
-            "riskTier": 30,
-            "title": 31,
-            "recommendations": 32,
-            "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,
+            "scenarioId": 29,
+            "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,
             "isPublic": -1,
+            "averageRiskScore": 54,
+            "weightedRiskScore": 55,
+            "parentRiskModelId": 56,
         }
 
     # pylint: disable=W0613

regscale/models/regscale_models/security_plan.py

@@ -18,6 +18,7 @@ class SecurityPlan(RegScaleModel):
     """
 
     _module_slug = "securityplans"
+    _unique_fields = ["systemName", "tenantsId"]
 
     id: int = 0
     uuid: str = ""

regscale/models/regscale_models/supply_chain.py

@@ -106,7 +106,7 @@ class SupplyChain(RegScaleModel):
     actualCosts: Optional[int] = 0
     strategicTier: Optional[Union[SupplyChainTier, str]] = None
     contractType: Optional[Union[SupplyChainContractType, str]] = None
-    scope: Optional[str] = (None,)
+    scope: Optional[str] = None
     startDate: Optional[str] = None
     endDate: Optional[str] = None
     violationURL: Optional[str] = None

regscale/models/regscale_models/user.py

@@ -5,11 +5,12 @@
 # standard python imports
 import random
 import string
-from typing import cast, Optional, List
+from typing import List, Optional, cast
 
-from pydantic import Field, ConfigDict, field_validator
+from pydantic import ConfigDict, Field, field_validator
 
 from regscale.core.app.utils.app_utils import get_current_datetime
+
 from .regscale_model import RegScaleModel, T
 
 
@@ -122,6 +123,19 @@ class User(RegScaleModel):
             change_avatar="/api/{model_slug}/changeAvatar/{strUsername}",
         )
 
+    @classmethod
+    def get_roles(cls) -> List[dict]:
+        """
+        Get all roles from RegScale
+
+        :return: List of RegScale roles
+        :rtype: List[dict]
+        """
+        response = cls._get_api_handler().get(endpoint=cls.get_endpoint("get_roles"))
+        if response and response.ok:
+            return response.json()
+        return []
+
     @classmethod
     def get_tenant_id_for_user_id(cls, user_id: str) -> Optional[int]:
         """

regscale/utils/threading/__init__.py

@@ -6,3 +6,4 @@ from .threadhandler import ThreadManager
 from .threadsafe_counter import ThreadSafeCounter
 from .threadsafe_dict import ThreadSafeDict
 from .threadsafe_list import ThreadSafeList
+from .threadsafe_set import ThreadSafeSet

regscale/utils/threading/threadsafe_list.py

@@ -63,6 +63,16 @@ class ThreadSafeList(Generic[T]):
         with self._lock:
             return iter(self._list.copy())
 
+    def __list__(self) -> List[T]:
+        """
+        Convert ThreadSafeList to a regular list when list() is called
+
+        :return: A copy of the internal list
+        :rtype: List[T]
+        """
+        with self._lock:
+            return self._list.copy()
+
     def remove(self, item: T) -> None:
         """
         Remove an item from the list

regscale/utils/threading/threadsafe_set.py

@@ -0,0 +1,116 @@
+"""
+This module contains the ThreadSafeSet class, which is a thread-safe set.
+"""
+
+from threading import RLock
+from typing import Generic, Iterator, Optional, Set, TypeVar
+
+T = TypeVar("T")  # Declare type variable
+
+
+class ThreadSafeSet(Generic[T]):
+    """
+    ThreadSafeSet class to create a thread-safe set.
+    """
+
+    def __init__(self, initial_set: Optional[Set[T]] = None):
+        """
+        Initialize a new ThreadSafeSet
+
+        :param Set[T]|None initial_set: Optional initial set to populate the ThreadSafeSet
+        """
+        self._set: Set[T] = set(initial_set) if initial_set is not None else set()
+        self._lock = RLock()
+
+    def add(self, item: T) -> None:
+        """
+        Add an item to the set
+
+        :param T item: Item to add to the set
+        :rtype: None
+        """
+        with self._lock:
+            self._set.add(item)
+
+    def remove(self, item: T) -> None:
+        """
+        Remove an item from the set
+
+        :param T item: Item to remove from the set
+        :raises KeyError: If the item is not found
+        :rtype: None
+        """
+        with self._lock:
+            self._set.remove(item)
+
+    def discard(self, item: T) -> None:
+        """
+        Remove an item from the set if it exists
+
+        :param T item: Item to remove from the set
+        :rtype: None
+        """
+        with self._lock:
+            self._set.discard(item)
+
+    def __len__(self) -> int:
+        """
+        Get the length of the set
+
+        :return: The length of the set
+        :rtype: int
+        """
+        with self._lock:
+            return len(self._set)
+
+    def __iter__(self) -> Iterator[T]:
+        """
+        Return an iterator over the set
+
+        :return: An iterator over the set
+        :rtype: Iterator[T]
+        """
+        with self._lock:
+            return iter(self._set.copy())
+
+    def __contains__(self, item: T) -> bool:
+        """
+        Check if an item is in the set
+
+        :param T item: Item to check
+        :return: True if the item is in the set, False otherwise
+        :rtype: bool
+        """
+        with self._lock:
+            return item in self._set
+
+    def clear(self) -> None:
+        """
+        Clear the set
+
+        :rtype: None
+        """
+        with self._lock:
+            self._set.clear()
+
+    def union(self, other: Set[T]) -> Set[T]:
+        """
+        Return the union of this set and another
+
+        :param Set[T] other: Other set to union with
+        :return: A new set containing the union
+        :rtype: Set[T]
+        """
+        with self._lock:
+            return self._set.union(other)
+
+    def intersection(self, other: Set[T]) -> Set[T]:
+        """
+        Return the intersection of this set and another
+
+        :param Set[T] other: Other set to intersect with
+        :return: A new set containing the intersection
+        :rtype: Set[T]
+        """
+        with self._lock:
+            return self._set.intersection(other)

{regscale_cli-6.16.3.0.dist-info → regscale_cli-6.16.4.0.dist-info}/METADATA

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