regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/asset_mapping.py

@@ -0,0 +1,190 @@
+import logging
+from typing import Optional, List, Dict
+
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.search import Search
+from regscale.models.regscale_models import Asset
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from regscale.models.regscale_models.regscale_model import T
+from regscale.models.regscale_models.mixins.parent_cache import PlanCacheMixin
+
+logger = logging.getLogger(__name__)
+
+
+class AssetMapping(RegScaleModel, PlanCacheMixin["AssetMapping"]):
+    """
+    AssetMapping model class.
+    """
+
+    _module_slug = "assetmapping"
+    _unique_fields = [
+        ["componentId", "assetId"],
+    ]
+    _parent_id_field = "componentId"
+
+    # New class attributes
+    _graph_query_name = "assetMappings"
+    _graph_plan_id_path = "component.securityPlansId"
+
+    id: Optional[int] = 0
+    uuid: Optional[str] = None
+    assetId: int
+    componentId: int
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = Field(default_factory=get_current_datetime)
+    lastUpdatedById: Optional[str] = None
+    isPublic: Optional[bool] = True
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    tenantsId: Optional[int] = 1
+
+    @staticmethod
+    def get_assets(component_id: int) -> List[T]:
+        """
+        Get assets for a given component ID.
+
+        :param int component_id: The ID of the component
+        :return: A list of assets
+        :rtype: List[T]
+        """
+        asset_mappings = AssetMapping.find_mappings(component_id=component_id)
+        assets = []
+        for asset_mapping in asset_mappings:
+            assets.append(Asset.get_object(object_id=asset_mapping.assetId))
+        return assets
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the AssetMapping model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_all_by_parent="/api/{model_slug}/getMappingsAsComponents/{intParentID}",
+            filter_asset_mappings="/api/{model_slug}/filterAssetMappings/{intAsset}/{intComp}/{strSearch}/{intPage}/{intPageSize}",
+            find_mappings="/api/{model_slug}/findMappings/{intId}",
+            get_mappings_as_components="/api/{model_slug}/getMappingsAsComponents/{intId}",
+            get_mappings_as_assets="/api/{model_slug}/getMappingsAsAssets/{intId}/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+        )
+
+    @classmethod
+    def cast_list_object(
+        cls,
+        item: Dict,
+        parent_id: Optional[int] = None,
+        parent_module: Optional[str] = None,
+    ) -> "AssetMapping":
+        """
+        Cast list of items to class instances.
+
+        :param Dict item: item to cast
+        :param Optional[int] parent_id: Parent ID, defaults to None
+        :param Optional[str] parent_module: Parent module, defaults to None
+        :return: Class instance created from the item
+        :rtype: "AssetMapping"
+        """
+        item["assetId"] = parent_id or item.get("assetId")
+        return cls(**item)
+
+    @classmethod
+    def get_all_by_parent(
+        cls,
+        parent_id: int,
+        parent_module: Optional[str] = None,
+        search: Optional[Search] = None,
+    ) -> List[T]:
+        """
+        Retrieves all asset mappings for a given parent ID and ONLY Components.
+
+        :param int parent_id: The ID of the parent
+        :param Optional[str] parent_module: The module of the parent
+        :param Optional[Search] search: The search object, defaults to None
+        :return: A list of asset mappings
+        :rtype: List[T]
+        :returns: A list of asset mappings for the given parent ID
+        """
+        return cls.find_mappings(parent_id)
+
+    @classmethod
+    def find_mappings(cls, component_id: int) -> List[T]:
+        """
+        Retrieves all component mappings for a given component ID.
+
+        :param int component_id: The ID of the component
+        :return: A list of component mappings
+        :rtype: List[T]
+        """
+        cache_key = f"{component_id}:{cls.__name__}"
+
+        # Get the lock for this cache_key
+        lock = cls._get_lock(cache_key)
+
+        with lock:
+            # Check the cache
+            cached_mappings = cls._parent_cache.get(cache_key)
+            if cached_mappings is not None:
+                return cached_mappings
+
+            # Not cached, make the API call
+            response = cls._get_api_handler().get(
+                endpoint=cls.get_endpoint("find_mappings").format(model_slug=cls.get_module_slug(), intId=component_id)
+            )
+            mappings = cls._handle_list_response(response)
+
+            # Cache the mappings
+            cls.cache_list_objects(cache_key=cache_key, objects=mappings)
+
+        return mappings
+
+    @classmethod
+    def get_mappings_as_components(cls, asset_id: int) -> Optional[List[T]]:
+        """
+        Retrieves all component mappings for a given asset ID.
+
+        :param int asset_id: The ID of the asset
+        :return: A list of component mappings or None
+        :rtype: Optional[List[T]]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_mappings_as_components").format(
+                model_slug=cls.get_module_slug(), intId=asset_id
+            )
+        )
+        if not response or response.status_code in [204, 404]:
+            return None
+        if response.ok:
+            return [cls(**item) for item in response.json()]
+        return None
+
+    def get_mappings_as_assets(
+        self, component_id: int, sort_by: str, direction: str, page: int, page_size: int
+    ) -> Optional[List["AssetMapping"]]:
+        """
+        Retrieves all asset mappings for a given component ID.
+
+        :param int component_id: The ID of the component
+        :param str sort_by: The field to sort by
+        :param str direction: The direction of sorting ('asc' or 'desc')
+        :param int page: The page number for pagination
+        :param int page_size: The number of items per page
+        :return: A list of asset mappings or None
+        :rtype: Optional[List[AssetMapping]]
+        """
+        response = self._get_api_handler().get(
+            endpoint=self.get_endpoint("get_mappings_as_assets").format(
+                model_slug=self._module_slug,
+                intId=component_id,
+                strSortBy=sort_by,
+                strDirection=direction,
+                intPage=page,
+                intPageSize=page_size,
+            )
+        )
+        if not response or response.status_code in [204, 404]:
+            return None
+        if response.ok:
+            return [self.__class__(**item) for item in response.json()]
+        return None

regscale/models/regscale_models/case.py

@@ -0,0 +1,42 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import Field
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class CaseStatus(str, Enum):
+    """
+    Enum for the CaseStatus field in the Case model.
+    """
+
+    in_progress = "In Progress"
+    closed = "Closed"
+    pending = "Pending"
+    resolved = "Resolved"
+    complete = "Complete"
+    cancelled = "Cancelled"
+    on_hold = "On Hold"
+
+
+class Case(RegScaleModel):
+    _module_slug = "cases"
+    _module_id = 28
+
+    id: Optional[int] = None
+    title: str
+    uuid: Optional[str] = None
+    description: Optional[str] = None
+    status: str = CaseStatus.pending
+    caseNumber: Optional[str] = None
+    caseWorkerId: str = Field(default_factory=RegScaleModel.get_user_id)
+    dateReported: str = Field(default_factory=get_current_datetime)
+    dateResolved: Optional[str] = None
+    notes: Optional[str] = None
+    reportedBy: str = Field(default_factory=RegScaleModel.get_user_id)
+    facilityId: Optional[int] = None
+    orgId: Optional[int] = None
+    parentId: Optional[int] = None
+    parentModule: Optional[str] = None

regscale/models/regscale_models/catalog.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Model for Catalog in the application"""
+from __future__ import annotations
+
+import io
+import json
+import warnings
+from typing import List, Optional, Union
+from urllib.parse import urljoin
+
+from pydantic import ConfigDict
+from requests import Response
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.utils.api_handler import APIRetrieveError
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from regscale.models.regscale_models.security_control import SecurityControl
+
+
+class Catalog(RegScaleModel):
+    """Catalog class"""
+
+    _module_slug = "catalogues"
+
+    id: int = 0
+    abstract: Optional[str] = None
+    datePublished: Optional[str] = None
+    description: Optional[str] = None
+    keywords: Optional[str] = None
+    lastRevisionDate: Optional[str] = None
+    title: str = ""
+    url: Optional[str] = None
+    tenantsId: Optional[int] = None
+    uuid: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    dateLastUpdated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    master: bool = False
+    sourceOscalURL: Optional[str] = None
+    archived: bool = False
+    isPublic: bool = True
+    securityControls: List[SecurityControl] = []
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Catalogues model
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_count="/api/{model_slug}/getCount",
+            get_list="/api/{model_slug}/getList",
+            get_catalog_with_all_details="/api/{model_slug}/getCatalogWithAllDetails/{intID}",
+            filter_catalogues="/api/{model_slug}/filterCatalogues",
+            graph="/api/{model_slug}/graph",
+            convert_mappings="/api/{model_slug}/convertMappings/{intID}",
+            find_by_guid="/api/{model_slug}/findByGUID/{strID}",
+            get_titles="/api/{model_slug}/getTitles",
+            get_nist="/api/{model_slug}/getNIST",
+            get_updatable="/api/{model_slug}/getUpdatableCatalogs",
+            compare_and_update="/api/{model_slug}/compareAndUpdate/{intID}",
+            update_regscale_catalog="/api/{model_slug}/updateRegScaleCatalog/{intID}",
+            get_update_report_for_catalog="/api/{model_slug}/getUpdateReportForCatalog/{intID}",
+        )
+
+    @classmethod
+    def get_list(cls) -> List["Catalog"]:
+        """
+        Use the get_list method instead.
+
+        Get all catalogs from database
+
+        :return: list of catalogs
+        :rtype: List["Catalog"]
+        """
+        return cls._handle_list_response(cls._get_api_handler().get(cls.get_endpoint("get_list")))
+
+    def insert_catalog(self, app: Application) -> "Catalog":  # noqa
+        """
+        DEPRECATED: This method is deprecated and will be removed in a future version.
+        Use the create method instead.
+
+        Insert catalog into database
+
+        :param Application app: Application
+        :return: Newly created catalog object
+        :rtype: Catalog
+        """
+        warnings.warn(
+            "insert_catalog is deprecated and will be removed in a future version. Use create method instead.",
+            DeprecationWarning,
+        )
+        # Convert the model to a dictionary
+        return self.create()
+
+    @staticmethod
+    def get_catalogs(app: Application) -> list:
+        """
+        DEPRECATED: This method is deprecated and will be removed in a future version.
+        Use the get_list method instead.
+
+        Get all catalogs from database
+
+        :param Application app: Application
+        :raises APIRetrieveError: API request failed
+        :return: list of catalogs
+        :rtype: list
+        """
+        warnings.warn(
+            "get_catalogs is deprecated and will be removed in a future version. Use get_list method instead.",
+            DeprecationWarning,
+        )
+        api = Api()
+        api_url = urljoin(app.config["domain"], "/api/catalogues")
+        response = api.get(api_url)
+        if not response.ok:
+            api.logger.debug(
+                f"API request failed with status: {response.status_code}: {response.reason} {response.text}"
+            )
+            raise APIRetrieveError(f"API request failed with status {response.status_code}")
+        return response.json()
+
+    @classmethod
+    def get_with_all_details(cls, catalog_id: int) -> Optional[dict]:
+        """
+        Retrieves a catalog with all details by its ID.
+
+        :param int catalog_id: The ID of the catalog
+        :return: The response from the API or None
+        :rtype: Optional[dict]
+        """
+        endpoint = cls.get_endpoint("get_catalog_with_all_details").format(
+            model_slug=cls.get_module_slug(), intID=catalog_id
+        )
+        response = cls._get_api_handler().get(endpoint)
+
+        if response and response.ok and response.status_code not in [204, 404]:
+            return response.json()
+        return {}
+
+    @classmethod
+    def get_update_report_for_catalog(
+        cls,
+        catalog_id: int,
+    ) -> Response:
+        """ """
+        endpoint = cls.get_endpoint("get_update_report_for_catalog").format(
+            model_slug=cls.get_module_slug(),
+            intID=catalog_id,
+        )
+        response = cls._get_api_handler().get(endpoint)
+
+        return response
+
+    @classmethod
+    def get_updatable_catalogs(cls) -> Optional[list]:
+        """
+        Get updatable catalogues
+
+        :return: List of updatable catalogues
+        :rtype: Optional[list]
+        """
+
+        endpoint = cls.get_endpoint("get_updatable").format(model_slug=cls.get_module_slug())
+        response = cls._get_api_handler().get(endpoint)
+        if (
+            response
+            and response.ok
+            and response.status_code
+            not in [
+                204,
+                404,
+            ]
+        ):
+            return response.json()
+        return None
+
+    @classmethod
+    def update_regscale_catalog(
+        cls,
+        catalog_id: int,
+    ) -> Union[Response | list]:
+        """
+        Update a regscale catalog
+
+        :param int catalog_id: The ID of the catalog
+        :return: A Response object
+        :rtype: Union[Response | list]
+        """
+
+        endpoint = cls.get_endpoint("update_regscale_catalog").format(
+            model_slug=cls.get_module_slug(),
+            intID=catalog_id,
+        )
+        response = cls._get_api_handler().put(endpoint=endpoint)  # data is optional here, not needed for this.
+        if (
+            response
+            and response.ok
+            and response.status_code
+            not in [
+                204,
+                404,
+            ]
+        ):
+            return response.json()
+        return response
+
+    @classmethod
+    def compare_and_update(
+        cls,
+        new_catalog: dict,
+        catalog_id: int,
+        format: str = "json",
+        structure: str = "flatReport",
+        apply_updates: bool = False,
+    ) -> Response:
+        """
+        Get updatable catalogues
+
+        :param dict new_catalog: The new catalog to compare
+        :param int catalog_id: The ID of the catalog
+        :param str format: The format of the catalog
+        :param str structure: The structure of the catalog
+        :param bool apply_updates: Whether to apply updates
+        :return: List of updatable catalogues
+        :rtype: Response
+        """
+        bytes_object = json.dumps(new_catalog).encode("utf-8")
+        files = {"newCatalogFile": io.BytesIO(bytes_object)}
+        # convert files to bytes like object
+        endpoint = cls.get_endpoint("compare_and_update").format(
+            model_slug=cls.get_module_slug(),
+            intID=catalog_id,
+            format=format,
+            structure=structure,
+            apply_updates=apply_updates,
+        )
+        params = {
+            "format": format.lower(),
+            "structure": structure,
+            "applyUpdates": apply_updates,
+        }
+        response = cls._get_api_handler().post(endpoint=endpoint, files=files, params=params)
+
+        if (
+            response
+            and response.ok
+            and response.status_code
+            not in [
+                204,
+                404,
+            ]
+        ):
+            return response
+        cls.log_response_error(response, suppress_error=True)
+        return response

regscale/models/regscale_models/cci.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Control Parameter in the application"""
+from typing import Optional
+
+from pydantic import ConfigDict
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class CCI(RegScaleModel):
+    """
+    CCI class
+    """
+
+    _module_slug = "cci"
+    _unique_fields = [
+        ["parameterId", "securityControlId"],
+    ]
+
+    id: Optional[int] = 0
+    uuid: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    controlType: Optional[str] = None
+    publishDate: Optional[str] = None
+    securityControlId: Optional[int] = None
+    archived: bool = False
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    dateLastUpdated: Optional[str] = None
+    tenantsId: Optional[int] = None
+    isPublic: bool = True
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the ControlParameter
+
+        :return: Additional endpoints for the ControlParameter
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getByControl/{intParentID}",
+        )

regscale/models/regscale_models/change.py

@@ -0,0 +1,167 @@
+"""
+This module contains the Change model for RegScale.
+"""
+
+import logging
+from enum import Enum
+from typing import Optional, List, Dict
+
+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
+
+logger = logging.getLogger(__name__)
+
+
+class ChangeType(str, Enum):
+    """
+    Enum for the ChangeType field in the Change model.
+    """
+
+    emergency = "Emergency"
+    normal = "Normal"
+    standard = "Standard"
+
+
+class ChangePriority(str, Enum):
+    """
+    Enum for the ChangePriority field in the Change model.
+    """
+
+    critical = "Critical"
+    low = "Low"
+    moderate = "Moderate"
+    high = "High"
+    security = "Security"
+
+
+class ChangeStatus(str, Enum):
+    """
+    Enum for the ChangeStatus field in the Change model.
+    """
+
+    draft = "Draft"
+    assess = "Assess"
+    pending_approval = "Pending Approval"
+    approved = "Approved"
+    schedule = "Schedule"
+    implement = "Implement"
+    review = "Review"
+    complete = "Complete"
+    cancelled = "Cancelled"
+
+
+class ChangeOutageRequired(str, Enum):
+    """
+    Enum for the ChangeOutageRequired field in the Change model.
+    """
+
+    yes = "Yes"
+    no = "No"
+
+
+class Change(RegScaleModel):
+    """
+    A class to represent the Change model in RegScale.
+    """
+
+    _module_id = 31
+    _module_slug = "changes"
+    _parent_id_field = "parentId"
+
+    id: Optional[int] = 0
+    isPublic: bool = True
+    uuid: Optional[str] = None
+    title: str
+    changeReason: str
+    description: Optional[str] = None
+    changeOwnerId: str = Field(default_factory=RegScaleModel.get_user_id)
+    dateRequested: str = Field(default_factory=get_current_datetime)
+    startChangeWindow: Optional[str] = None
+    endChangeWindow: Optional[str] = None
+    outageRequired: str = ChangeOutageRequired.no.value
+    outageSummary: Optional[str] = None
+    status: str = ChangeStatus.draft.value
+    dateChangeApproved: Optional[str] = None
+    dateWorkCompleted: Optional[str] = None
+    changeType: str = ChangeType.standard.value
+    priority: str = ChangePriority.moderate.value
+    securityImpactAssessment: Optional[str] = None
+    changePlan: Optional[str] = None
+    riskAssessment: Optional[str] = None
+    rollbackPlan: Optional[str] = None
+    communicationsPlan: Optional[str] = None
+    notes: Optional[str] = None
+    leadTesterId: Optional[str] = None
+    testPlan: Optional[str] = None
+    testResults: Optional[str] = None
+    dateTested: Optional[str] = None
+    facilityId: Optional[int] = None
+    orgId: Optional[int] = None
+    parentId: Optional[int] = None
+    parentModule: Optional[str] = None
+    dateLastUpdated: str = Field(default_factory=get_current_datetime)
+
+    # now create the _get_additional_endpoints method from this list of endpoints
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Changes model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_count="/api/{model_slug}/getCount",
+            schedule="/api/{model_slug}/schedule/{year}/{strDateField}",
+            report="/api/{model_slug}/report/{strReport}",
+            filter_changes="/api/{model_slug}/filterChanges",
+            query_by_custom_field="/api/{model_slug}/queryByCustomField/{strFieldName}/{strValue}",
+        )
+
+    @classmethod
+    def filter_change(cls, payload: Dict) -> List["Change"]:
+        """
+        Filter change based on query parameters.
+
+        :param dict payload: Query parameters
+        :return: A list of changes
+        """
+        response = cls._get_api_handler().post(
+            endpoint=cls.get_endpoint("filter_changes").format(model_slug=cls._module_slug), data=payload
+        )
+        if response and response.ok:
+            return [cls(**ci) for ci in response.json().get("items", [])]
+        return []
+
+    @staticmethod
+    def fetch_all_changes() -> List["Change"]:
+        """
+        Fetch all changes in RegScale
+
+        :return: List of Changes from RegScale
+        :rtype: List[Change]
+        """
+        from regscale.core.app.api import Api
+        from requests import JSONDecodeError
+
+        api = Api()
+        body = f"""
+        query {{
+            changes(take: 50, skip: 0) {{
+            items {{
+                {Change.build_graphql_fields()}
+            }}
+            pageInfo {{
+                hasNextPage
+            }}
+            ,totalCount}}
+        }}"""
+        try:
+            api.logger.info("Retrieving all changes from RegScale...")
+            existing_changes = api.graph(query=body)["changes"]["items"]
+            api.logger.info("Retrieved %i change(s) from RegScale.", len(existing_changes))
+        except (JSONDecodeError, KeyError):
+            existing_changes = []
+        return [Change(**change) for change in existing_changes]