regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/module.py

@@ -0,0 +1,224 @@
+import logging
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+logger = logging.getLogger(__name__)
+
+
+class Choice(BaseModel):
+    id: Optional[int] = None
+    isActive: Optional[bool] = None
+    value: Optional[str] = None
+    label: Optional[str] = None
+    regScaleLabel: Optional[str] = None
+    sequence: Optional[int] = None
+
+
+class FormField(BaseModel):
+    id: Optional[int] = None
+    createdBy: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[datetime] = None
+    dateLastUpdated: Optional[datetime] = None
+    isPublic: Optional[bool] = None
+    lastUpdatedBy: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    displayName: Optional[str] = None
+    regScaleId: Optional[str] = None
+    regScaleName: Optional[str] = None
+    isActive: Optional[bool] = None
+    isRequired: Optional[bool] = None
+    isCustom: Optional[bool] = None
+    fieldType: Optional[str] = None
+    selectType: Optional[str] = None
+    pattern: Optional[str] = None
+    sequence: Optional[int] = None
+    helpText: Optional[str] = None
+    choices: Optional[List[Choice]] = None
+
+
+class FormTab(BaseModel):
+    id: Optional[int] = None
+    createdBy: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[datetime] = None
+    dateLastUpdated: Optional[datetime] = None
+    isPublic: Optional[bool] = None
+    lastUpdatedBy: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    displayName: Optional[str] = None
+    regScaleName: Optional[str] = None
+    regScaleId: Optional[str] = None
+    regScaleLink: Optional[str] = None
+    isActive: Optional[bool] = None
+    isDefault: Optional[bool] = None
+    isCustom: Optional[bool] = None
+    sequence: Optional[int] = None
+    helpText: Optional[str] = None
+    formFields: Optional[List[FormField]] = None
+
+
+class Status(BaseModel):
+    regScaleTitle: Optional[str] = None
+    displayTitle: Optional[str] = None
+    iconName: Optional[str] = None
+    color: Optional[str] = None
+
+
+class Report(BaseModel):
+    name: Optional[str] = None
+    path: Optional[str] = None
+
+
+class HelpTextDetail(BaseModel):
+    summary: Optional[str] = None
+    bulletList: Optional[List[str]] = None
+
+
+class HelpText(BaseModel):
+    whyUseIt: Optional[HelpTextDetail] = None
+    whatIsIt: Optional[HelpTextDetail] = None
+
+
+class ChildModule(BaseModel):
+    moduleName: Optional[str] = None
+    moduleInformalName: Optional[str] = None
+    helpText: Optional[HelpText] = None
+
+
+class Module(RegScaleModel):
+    _module_slug = "modules"
+    id: Optional[int] = None
+    displayName: Optional[str] = None
+    displayPluralizedName: Optional[str] = None
+    regScaleName: Optional[str] = None
+    regScalePluralizedName: Optional[str] = None
+    regScaleId: Optional[int] = None
+    regScaleInformalName: Optional[str] = None
+    route: Optional[str] = None
+    newFormRoute: Optional[str] = None
+    documentation: Optional[str] = None
+    workbench: Optional[bool] = None
+    atlasModule: Optional[str] = None
+    formTabs: Optional[List[FormTab]] = None
+    status: Optional[List[Status]] = None
+    reports: Optional[List[Report]] = None
+    children: Optional[List[ChildModule]] = None
+    helpText: Optional[HelpText] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Module model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_modules="/api/{model_slug}",
+            get_module_by_id="/api/{model_slug}/{id}",
+        )
+
+    @classmethod
+    def get_modules(cls) -> List["Module"]:
+        """
+        Get all modules.
+
+        :return: A list of modules
+        :rtype: List["Module"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_modules").format(model_slug=cls.get_module_slug())
+        )
+        if response and response.ok:
+            return [cls(**o) for o in response.json()]
+        else:
+            cls.log_response_error(response=response)
+            return []
+
+    @classmethod
+    def get_module_by_id(cls, id: int) -> Optional["Module"]:
+        """
+        Get a module by ID. provides more data that get_modules
+
+        :param int id: The ID of the module to get
+        :return: The module
+        :rtype: Optional["Module"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_module_by_id").format(model_slug=cls._module_slug, id=id)
+        )
+        if response and response.ok:
+            return cls(**response.json())
+        else:
+            cls.log_response_error(response=response)
+            return None
+
+    @classmethod
+    def get_module_by_name(cls, regscale_name: str) -> Optional["Module"]:
+        """
+        Get a module by name.
+
+        :param str regscale_name: The name of the module to get
+        :return: The module
+        :rtype: Optional["Module"]
+        """
+        for module in cls.get_modules():
+            if module.regScaleInformalName == regscale_name:
+                return module
+        return None
+
+    @classmethod
+    def get_tab_by_name(cls, regscale_module_name: str, regscale_tab_name: str) -> Optional[FormTab]:
+        """
+        Get a tab by name.
+
+        :param str regscale_module_name: The name of the module
+        :param str regscale_tab_name: The regscale_name of the tab to get
+        :return: The tab
+        :rtype: Optional[FormTab]
+        """
+        module = cls.get_module_by_name(regscale_name=regscale_module_name)
+        if module:
+            module_metadata = cls.get_module_by_id(id=module.id)
+            if not module_metadata:
+                return None
+            for form_tab in module_metadata.formTabs:
+                if form_tab.regScaleName == regscale_tab_name:
+                    return form_tab
+        return None
+
+    @classmethod
+    def get_new_custom_form_tab_id(cls, module_name="cases", tab_name: str = "Migrated Custom Fields") -> Optional[int]:
+        """
+        Get the id of the new custom form tab. this is needed to update the custom field data
+
+        :param str module_name: The name of the module
+        :param str tab_name: The name of the tab
+        :return: The id of the new custom form tab
+        :rtype: Optional[int]
+        """
+        form_tab = cls.get_tab_by_name(regscale_module_name=module_name, regscale_tab_name=tab_name)
+        if form_tab:
+            return form_tab.id
+        return None
+
+    @classmethod
+    def get_form_fields_by_tab_id(
+        cls, module_name: str = "cases", tab_name: str = "Migrated Custom Fields"
+    ) -> Optional[List[FormField]]:
+        """
+        Get the form fields by tab id.
+        :param str module_name: The name of the module
+        :param str tab_name: The name of the tab
+        :return: A list of form fields
+        :rtype: Optional[List[FormField]]
+        """
+        form_tab = cls.get_tab_by_name(regscale_module_name=module_name, regscale_tab_name=tab_name)
+        if form_tab:
+            return form_tab.formFields
+        return None

regscale/models/regscale_models/modules.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Class of all RegScale modules"""
+
+# standard python imports
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from regscale.core.app.utils.app_utils import uncamel_case
+
+
+# pylint: disable=C0103
+@dataclass
+class Modules:
+    """Class for all RegScale Modules"""
+
+    assessment: str = "assessments"
+    asset: str = "assets"
+    case: str = "cases"
+    catalogue: str = "catalogues"
+    causalAnalysis: str = "causalanalysis"
+    controlObjective: str = "controlobjectives"
+    component: str = "components"
+    dataCall: str = "datacalls"
+    exception: str = "exceptions"
+    incident: str = "incidents"
+    interconnect: str = "interconnects"
+    # using _ to replace with ( and will later put POAM in parentheses
+    issue_POAM: str = "issues"
+    policy: str = "policies"
+    project: str = "projects"
+    questionnaire: str = "questionnaires"
+    requirement: str = "requirements"
+    risk: str = "risks"
+    securityControl: str = "securitycontrols"
+    securityControlImplementation: str = "controls"
+    securityPlan: str = "securityplans"
+    securityProfile: str = "profiles"
+    # using _ to replace with ( and will later put Contract in parentheses
+    supplyChain_Contract: str = "supplychain"
+    task: str = "tasks"
+    threat: str = "threats"
+
+    def __getitem__(self, key: Any) -> Any:
+        """
+        Get attribute from Pipeline
+
+        :param Any key: Key to get value from
+        :return: value of provided key
+        :rtype: Any
+        """
+        return getattr(self, key)
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        """
+        Set attribute in Pipeline with provided key
+
+        :param Any key: Key to change to provided value
+        :param Any value: New value for provided Key
+        :rtype: None
+        """
+        return setattr(self, key, value)
+
+    def dict(self) -> dict:
+        """
+        Create a dictionary from the Asset dataclass
+
+        :return: Dictionary of Asset
+        :rtype: dict
+        """
+        return dict(asdict(self).items())
+
+    def module_names(self) -> list:
+        """
+        Function to clean the keys and display them as they are in the application
+
+        :return: list of module names
+        :rtype: list
+        """
+        # create list variable for the cleaned up keys
+        clean_keys = []
+
+        # convert the class to a dictionary
+        data = self.dict()
+
+        # iterate through the keys
+        for key in data.keys():
+            # see if there is an _ in the key name, so we can replace it with ()
+            if "_" in key:
+                # find location of _
+                index = key.find("_")
+
+                # use the location to concatenate the key and () value
+                clean_key = f"{uncamel_case(key[:index])}({key[index + 1:]})"
+            else:
+                # uncamel case the key and append
+                clean_key = uncamel_case(key)
+            # append the clean key to the list
+            clean_keys.append(clean_key)
+        # return the list of clean keys
+        return clean_keys
+
+    def api_names(self) -> list:
+        """
+        Function to get the values from the class, used for RegScale API calls
+
+        :return: List of modules used for RegScale API calls
+        :rtype: list
+        """
+        # convert the class to dictionary
+        modules = self.dict()
+
+        # return the values from the dictionary as a list
+        return list(modules.values())
+
+    @staticmethod
+    def graphql_names() -> dict:
+        """
+        Function to get graphQL friend names mapped to regscale modules
+
+        :return: A mapping of modules used for RegScale GraphQL calls
+        :rtype: dict
+        """
+        return {
+            "assessment": "assessments",
+            "case": "cases",
+            "components": "components",
+            "causalanalysis": "causalAnalyses",
+            "catalogue": "catalogues",
+            "causalAnalysis": "CausalAnalysis",
+            "component": "components",
+            "datacalls": "dataCalls",
+            "issues": "issues",
+            "interconnect": "interconnections",
+            "policy": "policies",
+            "project": "projects",
+            "questionnaire": "questionnaires",
+            "requirement": "requirements",
+            "profile": "profiles",
+            "securityplans": "securityPlans",
+            "scanHistory": "scanHistories",
+            "securitycontrols": "securityControls",
+            "controlimplementation": "controlImplementations",
+            "supplychain": "supplyChain",
+            "task": "tasks",
+            "threat": "threats",
+        }
+
+    def to_table(self) -> None:
+        """
+        Displays the customer facing RegScale modules and the API equivalent as a table
+        in the console
+        """
+        # create console and table objects
+        console = Console()
+        table = Table("RegScale Module", "Accepted Value", title="RegScale Modules", safe_box=True)
+
+        # get list for clean columns and the api names
+        columns = self.module_names()
+        data = self.api_names()
+
+        # iterate through items and add them to table object
+        for i in range(len(columns)):
+            table.add_row(columns[i], data[i])
+
+        # print the table object in console
+        console.print(table)
+
+    def to_str_table(self) -> str:
+        """
+        Creates a string table of the data to display in console for click help command
+
+        :return: string table of customer facing RegScale modules and the API equivalent
+        :rtype: str
+        """
+        # create string to store the table
+        output = "{:<25} {:<25}\n".format("RegScale Module", "Accepted Value")
+
+        # get list for clean columns and the api names
+        columns = self.module_names()
+        data = self.api_names()
+
+        # iterate through items and add it to the output string
+        for i in range(len(columns)):
+            output += "\b{:<25} | {:<25}\n".format(columns[i], data[i])
+
+        # return the string
+        return output

regscale/models/regscale_models/objective.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Dataclass for Objective in the application"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Objective:
+    """RegScale Base Objective"""
+
+    securityControlId: int
+    id: int
+    uuid: str

regscale/models/regscale_models/parameter.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Regscale Model for Implementation Parameter in the application"""
+
+from enum import Enum
+from typing import Optional, List
+
+from pydantic import ConfigDict
+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 ParameterDataTypes(Enum):
+    STRING = "string"
+    INTEGER = "integer"
+    DATE = "date"
+    BOOLEAN = "boolean"
+    ARRAY = "array"
+
+
+class Parameter(RegScaleModel):
+    """
+    RegScale Implementation Parameter
+    Represents a row in the Parameter table in the database.
+
+    Relationships:
+    - ControlImplementationId -> ControlImplementation (1:1)
+    - CreatedById, LastUpdatedById -> AspNetUsers (1:1) [FKs]
+    - ParentParameterId -> ControlParameter (0..1:1) [optional]
+    - TenantsId -> Tenants (1:1) [inherited]
+    """
+
+    _module_slug = "parameters"
+
+    id: Optional[int] = None
+    uuid: Optional[str] = None
+    name: str
+    value: str
+    controlImplementationId: int  # Required, FK to ControlImplementation
+    createdById: str = Field(default_factory=RegScaleModel.get_user_id)  # FK to AspNetUsers
+    dateCreated: str = Field(default_factory=get_current_datetime)  # Required
+    lastUpdatedById: str = Field(default_factory=RegScaleModel.get_user_id)  # FK to AspNetUsers
+    dateLastUpdated: str = Field(default_factory=get_current_datetime)  # Required
+    tenantsId: Optional[int] = None  # Optional, FK to Tenants
+    dataType: Optional[str] = None  # Optional
+    externalPropertyName: Optional[str] = None  # Optional
+    parentParameterId: Optional[int] = None  # Optional, FK to ControlParameter
+    isPublic: bool = False  # Required, default to False
+
+    oscalNamespaceMapping: Optional[List[str]] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Parameter model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}",
+            get_count="/api/{model_slug}/getCount",
+            create="/api/{model_slug}",
+            update="/api/{model_slug}/{id}",
+            delete="/api/{model_slug}/{id}",
+            get="/api/{model_slug}/find/{id}",
+            find_by_guid="/api/{model_slug}/findByGUID/{strGUID}",
+            merge="/api/{model_slug}/merge/{implementationID}/{securityControlID}",
+        )
+
+    @classmethod
+    def get_by_parent_id(cls, parent_id: int) -> List["Parameter"]:
+        """
+        Get all Parameters by Parent ID.
+
+        :param int parent_id: The Parent ID
+        :return: A list of Parameters
+        :rtype: List[Parameter]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_parent").format(intParentID=parent_id)
+        )
+        if response and response.ok:
+            return [Parameter(**param) for param in response.json()]
+        return []

regscale/models/regscale_models/ports_protocol.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Class for a RegScale Ports and Protocols"""
+from typing import Optional
+
+from pydantic import ConfigDict
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class PortsProtocol(RegScaleModel):
+    """Ports And Protocols"""
+
+    _module_slug = "portsprotocols"
+    _unique_fields = [
+        [
+            "parentId",
+            "parentModule",
+            "startPort",
+            "endPort",
+            "protocol",
+            "service",
+        ],
+    ]
+
+    startPort: Optional[int] = 0
+    endPort: Optional[int] = 0
+    parentId: Optional[int] = 0
+    parentModule: Optional[str] = ""
+    protocol: Optional[str] = None
+    service: Optional[str] = None
+    purpose: Optional[str] = None
+    usedBy: Optional[str] = None
+    createdById: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    isPublic: Optional[bool] = True
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the PortsProtocols model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}/{strModule}",
+            find="/api/{model_slug}/find/{id}",
+        )
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Compare two PortsProtocols objects
+
+        :param object other: PortsProtocols object
+        :return: True if PortsProtocols are equal
+        :rtype: bool
+        """
+        if isinstance(other, PortsProtocol):
+            return self.dict() == other.dict()
+        return False
+
+    def __hash__(self) -> hash:
+        """
+        Return hash of PortsProtocols
+
+        :return: hash of PortsProtocols
+        :rtype: hash
+        """
+        return hash(
+            (
+                self.parentId,
+                self.parentModule,
+                self.startPort,
+                self.endPort,
+                self.protocol,
+                self.service,
+                self.purpose,
+                self.usedBy,
+            )
+        )

regscale/models/regscale_models/privacy.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Regscale Model for Privacy in the application"""
+
+from enum import Enum
+from typing import Optional, List
+
+from pydantic import ConfigDict
+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 PrivacyDataTypes(Enum):
+    STRING = "string"
+    INTEGER = "integer"
+    DATE = "date"
+    BOOLEAN = "boolean"
+    ARRAY = "array"
+
+
+class Privacy(RegScaleModel):
+    """
+    RegScale Privacy record
+    Represents a row in the Policy table in the database.
+
+    Relationships:
+    - securityPlanId -> Security Plan (1:1)
+    - CreatedById, LastUpdatedById -> AspNetUsers (1:1) [FKs]
+    - TenantsId -> Tenants (1:1) [inherited]
+    """
+
+    _module_slug = "privacy"
+
+    id: Optional[int] = 0
+    isPublic: Optional[bool] = True
+    uuid: Optional[str] = None
+    uniqueIdentifier: Optional[str] = None
+    piiCollection: str = Field(default="No", alias="piiCollection")
+    piiPublicCollection: str = Field(default="No", alias="piiPublicCollection")
+    piaConducted: str = Field(default="No", alias="piaConducted")
+    sornExists: str = Field(default="No", alias="sornExists")
+    sornId: Optional[str] = None
+    ombControlId: Optional[str] = None
+    infoCollected: Optional[str] = None
+    justification: Optional[str] = None
+    businessUse: Optional[str] = None
+    pointOfContactId: Optional[str] = None
+    privacyOfficerId: Optional[str] = None
+    informationSharing: Optional[str] = None
+    consent: Optional[str] = None
+    security: Optional[str] = None
+    privacyActSystem: Optional[str] = None
+    recordsSchedule: Optional[str] = None
+    securityPlanId: Optional[int] = 0
+    status: Optional[str] = None
+    dateApproved: Optional[str] = None
+    notes: Optional[str] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Policy model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intSPID}",
+            create="/api/{model_slug}",
+            update="/api/{model_slug}/{ID}",
+            delete="/api/{model_slug}/{ID}",
+            get="/api/{model_slug}/{intID}",
+        )
+
+    @classmethod
+    def get_all_by_parent(cls, security_plan_id: int) -> List["Privacy"]:
+        """
+        Get all privacy records by security plan ID.
+
+        :param int security_plan_id: The ID of the security plan
+        :return: A list of Privacy records
+        :rtype: List["Privacy"]
+        """
+        res = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_parent").format(intSPID=security_plan_id)
+        )
+        return cls._handle_list_response(res)