regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/security_plan.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Security Plan in the application"""
+
+from typing import Optional, Union
+
+from pydantic import ConfigDict, Field, field_validator
+
+from regscale.core.app.api import Api
+from regscale.core.app.logz import create_logger
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class SecurityPlan(RegScaleModel):
+    """
+    Security Plan model
+    """
+
+    _module_slug = "securityplans"
+
+    id: int = 0
+    uuid: str = ""
+    systemName: str
+    systemType: str = "Major Application"
+    defaultAssessmentDays: int = 0
+    planInformationSystemSecurityOfficerId: Optional[str] = None
+    planAuthorizingOfficialId: Optional[str] = None
+    systemOwnerId: Optional[str] = None  # this could be userID
+    otherIdentifier: Optional[str] = ""
+    confidentiality: str = ""
+    integrity: str = ""
+    availability: str = ""
+    status: Optional[str] = "Operational"
+    description: Optional[str] = ""
+    dateSubmitted: Optional[str] = ""
+    approvalDate: Optional[str] = ""
+    expirationDate: Optional[str] = ""
+    purpose: Optional[str] = ""
+    conditionsOfApproval: Optional[str] = ""
+    environment: Optional[str] = ""
+    lawsAndRegulations: Optional[str] = ""
+    authorizationBoundary: Optional[str] = ""
+    networkArchitecture: Optional[str] = ""
+    dataFlow: Optional[str] = ""
+    overallCategorization: Optional[str] = ""
+    maturityTier: Optional[str] = ""
+    wizProjectId: Optional[str] = ""
+    serviceNowAssignmentGroup: Optional[str] = ""
+    jiraProject: Optional[str] = ""
+    tenableGroup: Optional[str] = ""
+    facilityId: Optional[int] = None
+    orgId: Optional[int] = None
+    parentId: int = 0
+    parentModule: str = ""
+    createdById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateCreated: Optional[str] = Field(default_factory=get_current_datetime)
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    users: int = 0
+    privilegedUsers: int = 0
+    usersMFA: int = 0
+    privilegedUsersMFA: int = 0
+    hva: bool = False
+    practiceLevel: Optional[str] = ""
+    processLevel: Optional[str] = ""
+    cmmcLevel: Optional[str] = ""
+    cmmcStatus: Optional[str] = ""
+    isPublic: bool = True
+    executiveSummary: Optional[str] = ""
+    recommendations: Optional[str] = ""
+    bDeployGov: bool = False
+    bDeployHybrid: bool = False
+    bDeployPrivate: bool = False
+    bDeployPublic: bool = False
+    bDeployOther: bool = False
+    deployOtherRemarks: Optional[str] = ""
+    bModelIaaS: bool = False
+    bModelOther: bool = False
+    bModelPaaS: bool = False
+    bModelSaaS: bool = False
+    otherModelRemarks: Optional[str] = ""
+    explanationForNonOperational: Optional[str] = ""
+    version: Optional[str] = ""
+    categorizationJustification: Optional[str] = ""
+    internalUsers: int = 0
+    externalUsers: int = 0
+    externalUsersFuture: int = 0
+    internalUsersFuture: int = 0
+    prepOrgName: Optional[str] = ""
+    prepAddress: Optional[str] = ""
+    prepOffice: Optional[str] = ""
+    prepCityState: Optional[str] = ""
+    cspOrgName: Optional[str] = ""
+    cspAddress: Optional[str] = ""
+    cspOffice: Optional[str] = ""
+    cspCityState: Optional[str] = ""
+    authenticationLevel: Optional[str] = ""
+    identityAssuranceLevel: Optional[str] = ""
+    authenticatorAssuranceLevel: Optional[str] = ""
+    federationAssuranceLevel: Optional[str] = ""
+    fedrampAuthorizationType: Optional[str] = ""
+    fedrampAuthorizationLevel: Optional[str] = ""
+    fedrampAuthorizationStatus: Optional[str] = ""
+    fedrampDateSubmitted: Optional[str] = ""
+    fedrampDateAuthorized: Optional[str] = ""
+    fedrampId: Optional[str] = ""
+    complianceSettingsId: Optional[int] = 1
+    tenantsId: int = 1
+
+    @field_validator("complianceSettingsId")
+    def validate_regscale_version_and_compliance_settings(cls, v: int) -> Optional[int]:
+        """
+        Validate the RegScale version and if it is compatible with ComplianceSettings ID, has to be >=6.13
+
+        :param int v: ComplianceSettings ID
+        :return: The ComplianceSettings ID if the RegScale version is compatible, None otherwise
+        :rtype: Optional[int]
+        """
+        from packaging.version import Version
+
+        regscale_version = cls._get_api_handler().regscale_version
+
+        if len(regscale_version) >= 10 or Version(regscale_version) >= Version("6.13.0.0"):
+            return v
+        else:
+            return None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the SecurityPlan model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_control_implementations="/api/controlImplementation/getAllByPlan/{plan_id}",
+            mega_api="/api/{module_slug}/megaAPI/{intId}",
+        )
+
+    @classmethod
+    def fetch_mega_api_data(cls, ssp_id: int) -> dict:
+        """
+        Fetch the Mega API data for the given SSP ID
+
+        :param int ssp_id: RegScale SSP ID
+        :return: Mega API data
+        :rtype: dict
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("mega_api").format(module_slug=cls._module_slug, intId=ssp_id)
+        )
+        if not response.raise_for_status():
+            return response.json()
+        return {}
+
+    # Legacy code
+    def create_new_ssp(self, api: Api, return_id: Optional[bool] = False) -> Union[int, None, "SecurityPlan"]:
+        """
+        Create a new SSP in RegScale
+
+        :param Api api: The API object to use to create the SSP in RegScale
+        :param Optional[bool] return_id: Return the SSP ID only
+        :return: The SSP or the SSP ID upon success, None otherwise.
+        :rtype: Union[int, None, SecurityPlan]
+        """
+        # create the ssp in RegScale
+        data = self.dict()
+        ssp_response = api.post(
+            f'{api.config["domain"]}/api/securityplans',
+            json=data,
+        )
+        if ssp_response.ok:
+            if return_id:
+                return ssp_response.json()["id"]
+            return SecurityPlan(**ssp_response.json())
+        logger = create_logger()
+        logger.error(f"Failed to upload SSP: {ssp_response.status_code} - {ssp_response.text}")
+        return None
+
+    def update_ssp(self, api: Api, return_id: Optional[bool] = False) -> Union[int, None, "SecurityPlan"]:
+        """
+        Update an SSP in RegScale
+
+        :param Api api: The API object to use to create the SSP in RegScale
+        :param Optional[bool] return_id: Return the SSP ID only
+        :return: The SSP or the SSP ID upon success, None otherwise.
+        :rtype: Union[int, None, SecurityPlan]
+        """
+        # create the ssp in RegScale
+        data = self.dict()
+        assert self.id is not None or self.id != 0
+        ssp_response = api.put(
+            f'{api.config["domain"]}/api/securityplans/{self.id}',
+            json=data,
+        )
+        if ssp_response.ok:
+            if return_id:
+                return ssp_response.json()["id"]
+            return SecurityPlan(**ssp_response.json())
+        logger = create_logger()
+        logger.error(f"Failed to update SSP: {ssp_response.status_code} - {ssp_response.text}")
+        return None

regscale/models/regscale_models/software_inventory.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for SoftwareInventory in the application"""
+
+from typing import List, Optional, cast
+
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models import RegScaleModel
+
+
+class SoftwareInventory(RegScaleModel):
+    """
+    SoftwareInventory
+    """
+
+    _module_slug = "softwareInventory"
+    _unique_fields = [
+        ["name", "version", "parentHardwareAssetId"],
+    ]
+    _parent_id_field = "parentHardwareAssetId"
+
+    # UUID: Optional[str] = None
+    name: str
+    version: Optional[str] = None
+    function: Optional[str] = None
+    patchLevel: Optional[str] = None
+    parentHardwareAssetId: Optional[int] = None
+    parentSoftwareAssetId: Optional[int] = None
+    # parentSoftwareInventoryId: Optional[int] = None
+    dateCreated: Optional[str] = Field(default_factory=get_current_datetime)
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    createdById: str = Field(default_factory=RegScaleModel.get_user_id)
+    lastUpdatedById: str = Field(default_factory=RegScaleModel.get_user_id)
+    isPublic: bool = True
+    # references: Optional[List[str]] = []
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        return ConfigDict(
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}",
+            batch_create="/api/{model_slug}/batchCreate",
+            batch_update="/api/{model_slug}/batchUpdate",
+        )
+
+    def __eq__(self, other: "SoftwareInventory") -> bool:
+        """
+        Override the default Equals behavior
+
+        :param SoftwareInventory other: SoftwareInventory to compare
+        :return: True if equal, False otherwise
+        :rtype: bool
+        """
+        if isinstance(other, SoftwareInventory):
+            return (
+                self.name == other.name
+                and self.version == other.version
+                and self.parentHardwareAssetId == other.parentHardwareAssetId
+            )
+        return False
+
+    def __hash__(self) -> hash:
+        """
+        Override the default hash behavior
+
+        :return: hash of the SoftwareInventory
+        :rtype: hash
+        """
+        return hash((self.name, self.version, self.parentHardwareAssetId))
+
+    @classmethod
+    def insert(cls, app: Application, obj: "SoftwareInventory") -> "SoftwareInventory":
+        """
+        Insert a new SoftwareInventory into RegScale
+
+        :param Application app: application
+        :param SoftwareInventory obj: SoftwareInventory to insert
+        :return: SoftwareInventory object
+        :rtype: SoftwareInventory
+        """
+        api = Api()
+        result = {}
+        res = api.post(url=app.config["domain"] + "/api/softwareinventory", json=obj.dict())
+        if res.status_code == 200 and res.ok:
+            result = SoftwareInventory(**res.json())
+        return result
+
+    @classmethod
+    def update(cls, app: Application, obj: "SoftwareInventory") -> "SoftwareInventory":
+        """
+        Update an existing SoftwareInventory in RegScale
+
+        :param Application app: application
+        :param SoftwareInventory obj: SoftwareInventory to update
+        :return: SoftwareInventory object
+        :rtype: SoftwareInventory
+        """
+        api = Api()
+        result = {}
+        res = api.put(
+            url=app.config["domain"] + f"/api/softwareinventory/{obj.id}",
+            json=obj.dict(),
+        )
+        if res.status_code == 200 and res.ok:
+            result = SoftwareInventory(**res.json())
+        return result
+
+    @classmethod
+    def fetch_by_asset(cls, app: Application, asset_id: int) -> List["SoftwareInventory"]:
+        """
+        Fetch all SoftwareInventory for a given asset
+
+        :param Application app: application
+        :param int asset_id: The asset id
+        :return: A list of SoftwareInventory objects
+        :rtype: List[SoftwareInventory]
+        """
+        api = Api()
+        result = []
+        res = api.get(url=app.config["domain"] + f"/api/softwareinventory/getAllByParent/{asset_id}")
+        if res.status_code == 200 and res.ok:
+            result = [SoftwareInventory(**inv) for inv in res.json()]
+        return result
+
+    @classmethod
+    def get_map(cls, plan_id: int, key_field: str = "parentId") -> dict[str, "SoftwareInventory"]:
+        """
+        Get the asset map for the asset and cache it in Redis.
+
+        :param int plan_id: Security Plan ID
+        :param str key_field: Key field to use, defaults to "identifier"
+        :return: Data Map
+        :rtype: dict[str, "Data"]
+
+        # TODO: Implement filter by plan_id in RegScale API
+        """
+        search_data = f"""query {{
+            {cls.get_module_string()}(skip: 0, take: 50) {{
+                items {{
+                    {cls.build_graphql_fields()}
+                }}
+                totalCount
+                pageInfo {{
+                    hasNextPage
+                }}
+            }}
+        }}"""
+        response = cls._get_api_handler().graph(query=search_data)
+        objects = cast(List["SoftwareInventory"], cls._handle_graph_response(response))
+        return_assets = {}
+        for obj in objects:
+            identifier = getattr(obj, key_field, None)
+            if identifier:
+                return_assets[identifier] = obj
+
+        return {k: v.model_dump_json() for k, v in return_assets.items()}

regscale/models/regscale_models/stake_holder.py

@@ -0,0 +1,64 @@
+"""StakeHolders pydantic BaseModel."""
+
+import logging
+import warnings
+from typing import Optional
+from urllib.parse import urljoin
+
+from pydantic import field_validator
+
+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")
+
+
+class StakeHolder(RegScaleModel):
+    """StakeHolders model"""
+
+    _module_slug = "stakeholders"
+
+    id: int = 0
+    parentId: int  # Required
+    parentModule: str  # Required
+    name: Optional[str] = ""
+    shortname: Optional[str] = ""
+    title: Optional[str] = ""
+    phone: Optional[str] = ""
+    email: Optional[str] = ""
+    address: Optional[str] = ""
+    otherID: Optional[str] = ""
+    notes: Optional[str] = ""
+
+    @classmethod
+    @field_validator("email", "shortname", "notes", mode="before", check_fields=True)
+    def convert_email_none_to_empty_str(cls, value: Optional[str]) -> str:
+        """
+        Convert a none value for email, shortname adn notes to an empty string.
+
+        :param Optional[str] value: The value for the field
+        :return: The email value or an empty string
+        :rtype: str
+        """
+        return value if value is not None else ""
+
+    def post(self, app: Application) -> Optional[dict]:
+        """
+        Post a StakeHolders to RegScale
+
+        This method is deprecated, use 'create' method instead
+
+        :param Application app: The application instance
+        :return: The response from the API or None
+        :rtype: Optional[dict]
+        """
+        warnings.warn(
+            "The 'post' method is deprecated, use 'create' method instead",
+            DeprecationWarning,
+        )
+        api = Api()
+        url = urljoin(app.config.get("domain", ""), "/api/stakeholders")
+        data = self.dict()
+        response = api.post(url, json=data)
+        return response.json() if response.ok else None