regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/implementation_option.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""RegScale Implementation Option Model"""
+import warnings
+from typing import Optional, List
+from urllib.parse import urljoin
+
+import requests
+from pydantic import Field, ConfigDict, model_validator, BaseModel
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.logz import create_logger
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.implementation_objective import ImplementationStatus
+from regscale.models.regscale_models.objective import Objective
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from regscale.models.regscale_models.search import Search
+
+
+class ImplementationOption(RegScaleModel):
+    """RegScale Implementation Option Model"""
+
+    _module_slug = "implementationOptions"
+    _unique_fields = [
+        ["securityControlId", "name"],
+    ]
+    _parent_id_field = "securityControlId"
+
+    id: int = Field(default=0)
+    uuid: str = Field(default="")
+    name: str = Field(..., description="Name of the implementation option")
+    description: str = Field(..., description="Description of the implementation option")
+    acceptability: str = Field(
+        ImplementationStatus.NOT_IMPLEMENTED, description="Acceptability status of the implementation option"
+    )
+    otherId: Optional[str] = Field(default=None, description="An optional other identifier")
+    securityControlId: Optional[int] = Field(default=None, description="Foreign Key SecurityControls.id")
+    objectiveId: Optional[int] = Field(default=None, description="Foreign Key ControlObjective.id")
+    archived: bool = Field(default=False, description="Archival status of the implementation option")
+    createdById: Optional[str] = Field(default=None, description="Foreign Key AspNetUsers.id")
+    dateCreated: str = Field(
+        default_factory=get_current_datetime, description="Creation date of the implementation option"
+    )
+    lastUpdatedById: Optional[str] = Field(default=None, description="Foreign Key AspNetUsers.id")
+    dateLastUpdated: str = Field(
+        default_factory=get_current_datetime, description="Last update date of the implementation option"
+    )
+    tenantsId: Optional[int] = Field(default=None, description="Foreign Key Tenants.id")
+    isPublic: bool = Field(default=False, description="Public visibility of the implementation option")
+    restricted: bool = Field(default=False, description="Restriction status of the implementation option")
+    restrictedSecurityPlanId: Optional[int] = Field(
+        default=None, description="Associated restricted security plan ID if any"
+    )
+    responsibility: Optional[str] = Field(default=None, description="Who is responsible for the implementation option")
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the ImplementationOption model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getByControl/{intParentID}/{securityPlanId}",
+            get_by_control="/api/{model_slug}/getByControl/{intControl}/{securityPlanId}",
+            batch_create="/api/{model_slug}/batchCreate",
+        )
+
+    @classmethod
+    def get_all_by_parent(
+        cls,
+        parent_id: int,
+        parent_module: Optional[str] = None,
+        search: Optional[Search] = None,
+        plan_id: Optional[int] = None,
+    ) -> List["ImplementationOption"]:
+        """
+        Get a list of objects by parent.
+
+        :param int parent_id: The ID of the parent
+        :param Optional[str] parent_module: The parent module
+        :param Optional[Search] search: The search object
+        :param Optional[int] plan_id: The ID of the security plan
+        :return: A list of objects
+        :rtype: List["ImplementationOption"]
+        """
+        return cls._handle_list_response(
+            cls._get_api_handler().get(
+                endpoint=cls.get_endpoint("get_all_by_parent").format(
+                    intParentID=parent_id,
+                    securityPlanId=plan_id,
+                )
+            )
+        )
+
+    @classmethod
+    def get_by_control(cls, security_control_id: int, security_plan_id: int) -> list["ImplementationOption"]:
+        """
+        Get a list of implementation options by control id and security plan id
+
+        :param int security_control_id: Security Control ID
+        :param int security_plan_id: Security Plan ID
+        :return: A list of Implementation Options as a dictionary from RegScale via API
+        :rtype: list[ImplementationOption]
+        """
+        return cls._handle_list_response(
+            cls._get_api_handler().get(
+                endpoint=cls.get_endpoint("get_by_control").format(
+                    intControl=security_control_id, securityPlanId=security_plan_id
+                ),
+            )
+        )
+
+
+class ImplementationOptionDeprecated(BaseModel, Objective):
+    """RegScale Implementation Option"""
+
+    _module_slug = "implementationoptions"
+
+    id: int = 0
+    uuid: str = ""
+    name: str  # Required
+    description: str  # Required
+    status: Optional[str] = None
+    acceptability: Optional[str] = (
+        None  # Required for create but not returned on get by control ??? api is inconsistent
+    )
+    otherId: Optional[str] = None
+    securityControlId: Optional[int] = None
+    objectiveId: Optional[int] = None
+    restricted: bool = False
+    restrictedSecurityPlanId: Optional[int] = None
+    createdById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateCreated: str = Field(default_factory=get_current_datetime)
+    dateLastUpdated: str = Field(default_factory=get_current_datetime)
+    archived: bool = False
+    isPublic: bool = True
+
+    def __getitem__(
+        self, other: "ImplementationOptionDeprecated"
+    ) -> str:  # this allows getting an element (overrided method)
+        return self.name and self.description and self.objectiveId and self.securityControlId
+
+    @model_validator(mode="after")
+    def correct_control_id(self):
+        """
+        Correct the acceptability value for the implementation option as it is not returned
+        by the API on get by control but is return in field status which is not a valid field for the model
+        """
+        if self.acceptability is None and self.status is not None:
+            self.acceptability = self.status
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the ImplementationOptions model, using {model_slug} as a placeholder for the model slug.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_by_control="/api/{model_slug}/getByControl/{intControl}/{securityPlanId}",
+            batch_create="/api/{model_slug}/batchCreate",
+        )
+
+    def __eq__(self, other: "ImplementationOptionDeprecated") -> bool:
+        """
+        Check if two ImplementationOption objects are equal
+
+        :param ImplementationOptionDeprecated other: ImplementationOption object to compare
+        :return: True if equal, False if not
+        :rtype: bool
+        """
+        return (
+            self.name == other.name
+            and self.description == other.description
+            and self.objectiveId == other.objectiveId
+            and self.securityControlId == other.securityControlId
+        )
+
+    def __hash__(self) -> hash:
+        """
+        Hash a ImplementationOption object
+
+        :return: Hashed ImplementationOption object
+        :rtype: hash
+        """
+        return hash((self.name, self.description, self.objectiveId, self.securityControlId))
+
+    @classmethod
+    def get_by_control(cls, security_control_id: int, security_plan_id: int) -> list["ImplementationOption"]:
+        """
+        Get a list of implementation options by control id and security plan id
+
+        :param int security_control_id: Security Control ID
+        :param int security_plan_id: Security Plan ID
+        :return: A list of Implementation Options as a dictionary from RegScale via API
+        :rtype: list[ImplementationOption]
+        """
+        return cls._handle_list_response(
+            cls._get_api_handler().get(
+                endpoint=cls.get_endpoint("get_by_control").format(
+                    intControl=security_control_id, securityPlanId=security_plan_id
+                ),
+            )
+        )
+
+    @staticmethod
+    def fetch_implementation_options(app: Application, control_id: int) -> list["ImplementationOptionDeprecated"]:
+        """
+        Fetch list of implementation objectives by control id
+
+        :param Application app: Application Instance
+        :param int control_id: Security Control ID
+        :return: A list of Implementation Objectives as a dictionary from RegScale via API
+        :rtype: list[ImplementationOptionDeprecated]
+        """
+        warnings.warn(
+            "The 'fetch_implemetation_options method is deprecated, use 'get_by_control' method instead",
+            DeprecationWarning,
+        )
+        results = []
+        logger = create_logger()
+        api = Api()
+        res = api.get(url=app.config["domain"] + f"/api/implementationoptions/getByControl/{control_id}")
+        if res.ok:
+            try:
+                results = [ImplementationOptionDeprecated(**opt) for opt in res.json()]
+            except requests.RequestException.JSONDecodeError:
+                logger.warning("Unable to find control implementation objectives.")
+        return results
+
+    def insert(self, api: Api) -> requests.Response:
+        """
+        Insert implementation option into RegScale
+
+        :param Api api: The API instance
+        :return: API Response
+        :rtype: requests.Response
+        """
+        warnings.warn(
+            "The 'insert_parameter' method is deprecated, use 'create' method instead",
+            DeprecationWarning,
+        )
+        response = api.post(
+            url=urljoin(api.config["domain"], "/api/implementationOptions"),
+            json=self.dict(),
+        )
+        api.logger.debug(
+            "ImplementationOption insertion Response: %s=%s",
+            response.status_code,
+            response.text,
+        )
+        if response.status_code == 400 and "Duplicate" in response.text:
+            #  rev 5 contains multiple parts for each control with implemention options
+            #  there will be duplicates (which is ok)
+            #  do not log a message.
+            return response
+        if response.status_code == 422 and "Duplicate" in response.text:
+            #  rev 5 contains multiple parts for each control with implemention options
+            #  there will be duplicates (which is ok)
+            #  do not log a message.
+            return response
+
+        if not response.ok or response.status_code != 200:
+            api.logger.error(
+                "Unable to insert Implementation Option into RegScale.\n%s:%s %s",
+                response.status_code,
+                response.reason,
+                response.text,
+            )
+        return response

regscale/models/regscale_models/implementation_role.py

@@ -0,0 +1,33 @@
+import logging
+from typing import Optional
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+logger = logging.getLogger("regscale")
+
+
+class ImplementationRole(RegScaleModel):
+    """Class for a RegScale SystemRoles"""
+
+    _module_slug = "implementingRoles"
+
+    id: Optional[int] = None
+    uuid: Optional[str] = None
+    parentId: int  # Required Field
+    parentModule: str  # Required Field
+    roleId: int  # Required Field
+    isPublic: bool = True
+
+    @staticmethod
+    def add_role(role_id: int, control_implementation_id: int, parent_module: str) -> "ImplementationRole":
+        """
+        Add a role to a control implementation
+
+        :param int role_id: The ID of the role to add
+        :param int control_implementation_id: The ID of the control implementation to add the role to
+        :param str parent_module: The parent module of the role
+        :return: The new role
+        :rtype: ImplementationRole
+        """
+        role = ImplementationRole(roleId=role_id, parentId=control_implementation_id, parentModule=parent_module)
+        return role.create()

regscale/models/regscale_models/incident.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""RegScale Incident Model"""
+
+from typing import Optional, Any
+
+import requests
+from pydantic import ConfigDict, field_validator
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.utils.app_utils import camel_case, snake_case
+from .regscale_model import RegScaleModel
+
+
+class Incident(RegScaleModel):
+    """RegScale Incident
+
+    :raises ValueError: Validation Error
+    :return: RegScale Incident
+    """
+
+    _module_slug = "incidents"
+
+    category: str  # Required
+    detectionMethod: str  # Required
+    dateDetected: str  # Required
+    phase: str  # Required
+    title: str  # Required
+    incidentPOCId: str  # Required
+    id: int = 0
+    attackVector: Optional[str] = None
+    compromiseDate: Optional[str] = None
+    cost: float = 0
+    dateResolved: Optional[str] = None
+    description: Optional[str] = None
+    ioc: Optional[str] = None
+    impact: Optional[str] = None
+    parentId: Optional[int] = None
+    responseActions: Optional[str] = None
+    sourceCause: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    dateLastUpdated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    parentModule: Optional[str] = None
+    tenantsId: Optional[int] = None
+    facilityId: Optional[int] = None
+    # post_incident: Optional[str]
+    uuid: Optional[str] = None
+    isPublic: bool = True
+    orgId: Optional[int] = None
+    containmentSteps: Optional[str] = None
+    eradicationSteps: Optional[str] = None
+    recoverySteps: Optional[str] = None
+    severity: Optional[str] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Incidents model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_count="/api/{model_slug}/getCount",
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}/{strModule}",
+            get_filtered_list="/api/{model_slug}/getFilteredList/{strFind}",
+            graph="/api/{model_slug}/graph",
+            graph_by_date="/api/{model_slug}/graphByDate/{strGroupBy}/{year}",
+            main_dashboard="/api/{model_slug}/mainDashboard/{intYear}",
+            main_dashboard_chart="/api/{model_slug}/mainDashboardChart/{year}",
+            filter_incidents="/api/{model_slug}/filterIncidents",
+            query_by_custom_field="/api/{model_slug}/queryByCustomField/{strFieldName}/{strValue}",
+            report="/api/{model_slug}/report/{strReport}",
+            schedule="/api/{model_slug}/schedule/{year}/{dvar}",
+            graph_due_date="/api/{model_slug}/graphDueDate/{year}",
+            dashboard="/api/{model_slug}/dashboard/{strGroupBy}",
+            dashboard_by_parent="/api/{model_slug}/dashboardByParent/{strGroupBy}/{intId}/{strModule}",
+        )
+
+    @classmethod
+    @field_validator("category")
+    def check_category(cls, value: Any) -> str:
+        """
+        Validate Category
+
+        :param Any value: An incident category
+        :raises ValueError: Validation Error if category is not in list
+        :return: An incident category
+        :rtype: str
+        """
+        categories = [
+            "CAT 0 - Exercise/Network Defense Testing",
+            "CAT 1 - Unauthorized Access",
+            "CAT 2 - Denial of Service (DoS)",
+            "CAT 3 - Malicious Code",
+            "CAT 4 - Improper Usage",
+            "CAT 5 - Scans/Probes/Attempted Access",
+            "CAT 6 - Investigation",
+        ]
+        if value not in categories:
+            cats = "\n".join(categories)
+            raise ValueError(f"Category must be one of the following:\n{cats}")
+        return value
+
+    @classmethod
+    @field_validator("phase")
+    def check_phases(cls, value: str) -> str:
+        """Validate Phases
+
+        :raises ValueError: Validation Error for Incident Phase
+        :param str value: An incident phase
+        :return: An incident phase
+        :rtype: str
+        """
+        phases = [
+            "Analysis",
+            "Closed",
+            "Containment",
+            "Detection",
+            "Eradication",
+            "Recovery",
+        ]
+        if value not in phases:
+            phas = "\n".join(phases)
+            raise ValueError(f"Phase must be one of the following:\n{phas}")
+        return value
+
+    @staticmethod
+    def post_incident(incident: "Incident") -> requests.Response:
+        """
+        Post Incident to RegScale via API
+
+        :param Incident incident: An instance of Incident
+        :return: Response object from API post to RegScale
+        :rtype: requests.Response
+        """
+        app = Application()
+        config = app.config
+        api = Api()
+        url = config["domain"] + "/api/incidents"
+        incident.id = 0  # ID must be 0 for POST
+        incident_d = incident.dict()
+        response = api.post(url=url, json=incident_d)
+        return response
+
+    @staticmethod
+    def get_incident(incident_id: int) -> "Incident":
+        """
+        Get Incident from RegScale with provided ID
+
+        :param int incident_id: An Incident ID
+        :return: RegScale incident object
+        :rtype: Incident
+        """
+        app = Application()
+        config = app.config
+        api = Api()
+        url = config["domain"] + "/api/incidents/" + str(incident_id)
+        response = api.get(url=url)
+        dat = response.json()
+        convert = {
+            snake_case(camel_case(key)).lower().replace("pocid", "poc_id"): value for (key, value) in dat.items()
+        }
+        return Incident(**convert)
+
+    def to_dict(self) -> dict:
+        """
+        Convert Incident object RegScale friendly dict, used in flask_api application
+
+        :return: RegScale friendly dict for posting to API
+        :rtype: dict
+        """
+        dat = self.dict()
+        return {camel_case(key): value for (key, value) in dat.items()}

regscale/models/regscale_models/interconnection.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Interconnect in the application"""
+
+from typing import Optional
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class InterConnection(RegScaleModel):
+    """RegScale Interconnects model"""
+
+    _module_slug = "interconnections"
+
+    id: int = 0
+    authorizationType: str
+    categorization: str
+    connectionType: str
+    name: str
+    organization: str
+    status: str
+    aOId: str
+    interconnectOwnerId: str
+    parentId: int = 0
+    parentModule: Optional[str] = None
+    isPublic: bool = True
+    agreementDate: Optional[str] = None
+    expirationDate: Optional[str] = None
+    description: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    dateLastUpdated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    tenantsId: Optional[int] = None
+    uuid: Optional[str] = None
+    dataDirection: Optional[str] = None
+    externalEmail: Optional[str] = None
+    externalFQDN: Optional[str] = None
+    externalIpAddress: Optional[str] = None
+    externalPOC: Optional[str] = None
+    externalPhone: Optional[str] = None
+    sourceFQDN: Optional[str] = None
+    sourceIpAddress: Optional[str] = None