regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/profile.py

@@ -0,0 +1,50 @@
+"""This module contains the Profile model."""
+
+from typing import Optional
+
+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
+
+
+class Profile(RegScaleModel):
+    """
+    Represents a security profile with various attributes.
+    """
+
+    _module_slug = "profiles"
+
+    id: Optional[int] = None
+    category: Optional[str] = None
+    name: Optional[str]
+    createdById: str = Field(default_factory=RegScaleModel.get_user_id)
+    dateCreated: str = Field(default_factory=get_current_datetime)
+    lastUpdatedById: str = Field(default_factory=RegScaleModel.get_user_id)
+    dateLastUpdated: str = Field(default_factory=get_current_datetime)
+    profileOwnerId: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    tenantsId: Optional[int] = 1
+    uuid: Optional[str] = None
+    isPublic: Optional[bool] = True
+    availability: Optional[str] = None
+    confidentiality: Optional[str] = None
+    integrity: Optional[str] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Profile model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_list="/api/{model_slug}/getList",
+            get_list_with_controls="/api/{model_slug}/getListWithControls",
+            get_count="/api/{model_slug}/getCount",
+            graph="/api/{model_slug}/graph",
+            apply_profile="/api/{model_slug}/applyProfile/{moduleId}/{moduleName}/{profileId}/{isPublic}",
+            filter_profiles="/api/{model_slug}/filterProfiles",
+            query_by_custom_field="/api/{model_slug}/queryByCustomField/{strFieldName}/{strValue}",
+            find_by_name="/api/{model_slug}/findByName/{strName}/{intID}",
+        )

regscale/models/regscale_models/profile_link.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Profile Link in the application"""
+
+from typing import Optional, List
+
+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
+
+
+class ProfileLink(RegScaleModel):
+    """
+    Profile Mapping Model
+    """
+
+    _module_slug = "profileLinks"
+
+    id: int
+    profileId: int
+    linkDate: Optional[str] = Field(default_factory=get_current_datetime)
+    parentId: int
+    parentModule: Optional[str] = None
+    tenantsId: Optional[int] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = Field(default_factory=get_current_datetime)
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    isPublic: bool = False
+    lastUpdatedById: Optional[str] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the ProfileMapping model, using {model_slug} as a placeholder for the model slug.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getProfiles/{strModule}/{intParentID}",
+        )
+
+    @classmethod
+    def get_all_by_parent(cls, parent_id: int, parent_module: str) -> List["ProfileLink"]:
+        """
+        Get a list of objects by parent.
+        # TODO: Update API to return needed data
+
+        :param int parent_id: The ID of the parent
+        :param str parent_module: The module of the parent
+        :return: A list of profile links
+        :rtype: List["ProfileLink]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_parent").format(
+                intParentID=parent_id,
+                strModule=parent_module,
+            )
+        )
+        records = []
+        for obj in response.json():
+            obj["parentModule"] = parent_module
+            obj["parentId"] = parent_id
+            obj["profileId"] = obj["profile"]["id"]
+            records.append(cls(**obj))
+        return records

regscale/models/regscale_models/profile_mapping.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Profile Mapping in the application"""
+from typing import List, Optional
+from urllib.parse import urljoin
+
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.api import Api
+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
+
+
+class ProfileMapping(RegScaleModel):
+    """
+    Profile Mapping Model
+    """
+
+    _module_slug = "profileMapping"
+
+    id: int = 0
+    profileID: int
+    controlID: int  # the int id of the security control
+    controlId: Optional[str] = Field(alias="control_id", default=None)  # the control id string i.e. AC-1
+    title: Optional[str] = None
+    family: Optional[str] = None
+    control: Optional[SecurityControl] = None
+    tenantsId: Optional[int] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    dateLastUpdated: Optional[str] = None
+    isPublic: bool = True
+    lastUpdatedById: Optional[str] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the ProfileMapping model, using {model_slug} as a placeholder for the model slug.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getByProfile/{intParentID}",
+            lookup="/api/{model_slug}/lookup/{intProfileID}/{intControlID}",
+            get_by_profile="/api/{model_slug}/getByProfile/{intProfileID}",
+            oscal_prep="/api/{model_slug}/oscalPrep/{intProfileID}",
+            create_profile_mapping="/api/{model_slug}",
+            batch_create="/api/{model_slug}/batchCreate",
+            batch_delete="/api/{model_slug}/batchDelete",
+            delete_mapping="/api/{model_slug}/deleteMapping/{intProfileID}/{intControlID}",
+        )
+
+    @classmethod
+    def get_by_profile(cls, profile_id: int) -> List["ProfileMapping"]:
+        """
+        Get profile mappings by profile ID
+
+        :param int profile_id: Profile ID
+        :return: List of profile mappings
+        :rtype: List[ProfileMapping]
+        """
+        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):
+                    mapping.control = control
+        return mappings
+
+    def insert_profile_mapping(self, app: Application) -> dict:
+        """
+        Insert a new profile mapping
+
+        :param Application app: Application
+        :raises Exception: API request failed
+        :return: dict of profile mapping
+        :rtype: dict
+        """
+        api = Api()
+        # Convert the model to a dictionary
+        data = self.dict()
+        api_url = urljoin(app.config["domain"], "/api/profileMapping")
+
+        # Make the API call
+        response = api.post(url=api_url, json=data)
+
+        # Check the response
+        if not response.ok:
+            api.logger.debug(
+                f"API Call failed to: {api_url}\n{response.status_code}: {response.reason} {response.text}"
+            )
+            raise response.raise_for_status()
+
+        return response.json()
+
+    @staticmethod
+    def insert_batch(app: Application, mappings: List["ProfileMapping"]) -> list[dict]:
+        """
+        Insert a new list of profile mappings as a batch
+
+        :param Application app: Application
+        :param List[ProfileMapping] mappings: List of profile mappings
+        :return: list[dict] of profile mappings
+        :rtype: list[dict]
+        """
+        api = Api()
+        # Convert the model to a dictionary
+
+        data = [item.dict() for item in mappings]
+        for d in data:
+            d["isPublic"] = "true"
+        api_url = urljoin(app.config["domain"], "/api/profileMapping/batchCreate")
+
+        # Make the API call
+        response = api.post(url=api_url, json=data)
+
+        # Check the response
+        return response.json() if response.ok else response.raise_for_status()

regscale/models/regscale_models/project.py

@@ -0,0 +1,63 @@
+"""Model for a RegScale Link"""
+
+from typing import Optional
+
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from .regscale_model import RegScaleModel
+
+
+class Project(RegScaleModel):
+    _module_slug = "projects"
+
+    title: Optional[str] = ""  # Required
+    phase: Optional[str] = ""  # Required
+    projectManagerId: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)  # Required
+    id: Optional[int] = 0
+    uuid: Optional[str] = ""
+    otherID: Optional[str] = ""
+    description: Optional[str] = ""
+    benefits: Optional[str] = ""
+    startDate: Optional[str] = Field(default_factory=get_current_datetime)
+    endDate: Optional[str] = ""
+    actualFinish: Optional[str] = ""
+    percentComplete: Optional[int] = 0
+    budget: Optional[float] = 0.0
+    actualCosts: Optional[float] = 0.0
+    legislativeMandate: Optional[bool] = True
+    auditFinding: Optional[bool] = True
+    strategicPlan: Optional[bool] = True
+    costSavings: Optional[bool] = True
+    newRequirement: Optional[bool] = True
+    riskReduction: Optional[bool] = True
+    revenue: Optional[bool] = True
+    facilityId: Optional[int] = 0
+    orgId: Optional[int] = 0
+    parentId: Optional[int] = 0
+    parentModule: Optional[str] = ""
+    isPublic: Optional[bool] = True
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Links model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_list="/api/{model_slug}/getList",
+            calendar_projects="/api/{model_slug}/calendarProjects/{dtDate}/{fId}/{orgId}/{userId}",
+            gantt_chart="/api/{model_slug}/ganttChart/{intId}",
+            status_board="/api/{model_slug}/statusboard/{strSearch}/{strPhase}/{strOwner}/{intPage}/{pageSize}",
+            graph="/api/{model_slug}/graph",
+            graph_by_date="/api/{model_slug}/graphByDate/{strGroupBy}/{year}",
+            filter_projects="/api/{model_slug}/filterProjects",
+            query_by_custom_field="/api/{model_slug}/queryByCustomField/{strFieldName}/{strValue}",
+            report="/api/{model_slug}/report/{strReport}",
+            schedule="/api/{model_slug}/schedule/{year}/{dvar}",
+            dashboard="/api/{model_slug}/dashboard/{strGroupBy}",
+            main_dashboard="/api/{model_slug}/mainDashboard/{intYear}",
+            main_dashboard_chart="/api/{model_slug}/mainDashboardChart/{year}",
+        )

regscale/models/regscale_models/property.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Create Properties model."""
+import json
+import logging
+import math
+from typing import Any, List, Optional, Union
+
+from pydantic import ConfigDict, Field, field_validator
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.internal.model_editor import get_all_by_parent
+from regscale.core.app.utils.app_utils import get_current_datetime, recursive_items
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from regscale.utils import flatten_dict
+
+logger = logging.getLogger("regscale")
+
+
+class Property(RegScaleModel):
+    """Properties plan model"""
+
+    _module_slug = "properties"
+    _unique_fields = [
+        ["key", "parentId", "parentModule"],
+    ]
+    _parent_id_field = "parentId"
+
+    id: int = 0
+    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)
+    isPublic: bool = True
+    key: Optional[str] = ""
+    value: Optional[Union[str, int, float]] = ""
+    label: Optional[str] = ""
+    otherAttributes: Optional[str] = ""
+    parentId: Optional[int] = 0
+    parentModule: Optional[str] = ""
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    alt_id: Optional[str] = None
+
+    @field_validator("value", mode="before")
+    def validate_value(cls, value: Any) -> Any:
+        """
+        Validate the value field and convert it to a string if it is a boolean or list
+
+        :param Any value: Value to validate
+        :return: Value if valid
+        :rtype: Any
+        """
+        import math
+
+        if isinstance(value, bool):
+            return "True" if value else "False"
+        if isinstance(value, list):
+            return ", ".join(value)
+        if isinstance(value, float) and math.isnan(value):
+            return "NULL"
+        if isinstance(value, str) and value.strip() == "":
+            return "NULL"
+        if isinstance(value, dict):
+            return json.dumps(value)
+        return value or "NULL"
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Properties model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            batch_create="/api/{model_slug}/batchCreate",
+            batch_update="/api/{model_slug}/batchUpdate",
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}/{strModule}",
+        )
+
+    @staticmethod
+    def create_properties_from_list(
+        parent_id: Union[str, int],
+        parent_module: str,
+        properties_list: List[dict],
+    ) -> List["Property"]:
+        """
+        Create a list of Properties objects from a list of dicts
+
+        :param Union[str, int] parent_id: ID of the SSP to create the Properties objects for
+        :param str parent_module: Parent module of the Properties objects
+        :param Union[str, int] properties_list: List of dicts to create objects from
+        :return: List[dict] of Properties objects
+        :rtype: List[Property]
+        """
+        properties = [
+            Property(parentId=int(parent_id), parentModule=parent_module, **properties)
+            for properties in properties_list
+        ]
+        return [property_.create_new_properties(return_object=True) for property_ in properties]
+
+    def create_new_properties(self, return_object: Optional[bool] = False) -> Union[bool, "Property"]:
+        """
+        Create a new Properties object in RegScale
+
+        :param Optional[bool] return_object: Whether to return the object if successful
+                                            , defaults to False
+        :return: True or the Properties created if successful, False otherwise
+        :rtype: Union[bool, Property]
+        """
+        api = Api()
+        data = self.dict()
+        data["id"] = None
+        data["createdById"] = api.config["userId"]
+        data["lastUpdatedById"] = api.config["userId"]
+        properties_response = api.post(
+            f'{api.config["domain"]}/api/properties/',
+            json=data,
+        )
+        if properties_response.ok:
+            logger.info("Created Properties: %s", properties_response.json()["id"])
+            if return_object:
+                return Property(**properties_response.json())
+            return True
+        logger.error("Error creating Properties: %s", properties_response.text)
+        return False
+
+    def __eq__(self, other: "Property") -> bool:
+        """
+        Test equality of two Property objects
+
+        :param Property other: Other Property object to compare to
+        :return: Equality of two Property objects
+        :rtype: bool
+        """
+        return (
+            self.key == other.key
+            and self.value == other.value
+            and self.parentId == other.parentId
+            and self.parentModule == other.parentModule
+        )
+
+    @staticmethod
+    def generate_property_list_from_dict(dat: dict) -> list["Property"]:
+        """
+        Generate Property List from Dict
+
+        :param dict dat: Data to generate Property list from
+        :return: List of Properties
+        :rtype: list["Property"]
+        """
+        kvs = recursive_items(dat)
+        return [Property(key=k, value=v, createdById="", parentModule="") for k, v in kvs]
+
+    @staticmethod
+    def update_properties(app: Application, prop_list: list["Property"]) -> None:
+        """
+        Post a list of properties to RegScale
+
+        :param Application app: Application object
+        :param list[Property] prop_list: List of properties to post to RegScale
+        :rtype: None
+        """
+        api = Api()
+        props = [prop.dict() for prop in prop_list]
+        res = api.put(
+            url=app.config["domain"] + "/api/properties/batchupdate",
+            json=props,
+        )
+        if res.status_code == 200:
+            if len(prop_list) > 0:
+                logger.info("Successfully updated %i properties to RegScale", len(prop_list))
+        else:
+            logger.error("Failed to update properties to RegScale\n%s", res.text)
+
+    @staticmethod
+    def existing_properties(app: Application, existing_assets: list[dict]) -> list["Property"]:
+        """
+        Return a list of existing properties in RegScale
+
+        :param Application app: Application object
+        :param list[dict] existing_assets: List of assets from RegScale
+        :return: List of properties for the provided assets
+        :rtype: list["Property"]
+        """
+        properties = []
+        api = Api()
+        for asset in existing_assets:
+            res = api.get(url=app.config["domain"] + f"/api/properties/getAllByParent/{asset['id']}/assets")
+            if res.status_code == 200:
+                for prop in res.json():
+                    prop["alt_id"] = asset["wizId"]
+                    properties.append(Property(**prop))
+        return properties
+
+    @staticmethod
+    def insert_properties(app: Application, prop_list: list["Property"]) -> list["Property"]:
+        """
+        Post a list of properties to RegScale
+
+        :param Application app: Application instance
+        :param list[Property] prop_list: List of properties to post
+        :return: List of created properties in RegScale
+        :rtype: list["Property"]
+        """
+        properties = []
+        api = Api()
+        res = api.post(
+            url=app.config["domain"] + "/api/properties/batchcreate",
+            json=[prop.dict() for prop in prop_list],
+        )
+        if res.status_code == 200:
+            if len(prop_list) > 0:
+                api.logger.info("Successfully posted %i properties to RegScale", len(prop_list))
+            properties = [Property(**prop) for prop in res.json()]
+        else:
+            logger.error("Failed to post properties to RegScale\n%s", res.text)
+        return properties
+
+    @staticmethod
+    def get_properties(wiz_data: str, wiz_id: str) -> List["Property"]:
+        """
+        Convert Wiz properties data into a list of Property objects.
+
+        :param str wiz_data: JSON string containing Wiz information
+        :param str wiz_id: Identifier for a Wiz issue
+        :return: A list of Property objects derived from Wiz data
+        :rtype: List[Property]
+        """
+        app = Application()
+        wiz_dict = json.loads(wiz_data)
+        flattened = flatten_dict(wiz_dict)
+        properties = []
+
+        current_datetime = get_current_datetime()
+        user_id = app.config["userId"]
+
+        for key, value in flattened:
+            # Skip empty values or empty dictionaries converted to strings
+            if not value or value == "{}":
+                continue
+            value = _value_checks(value)
+            # Create and add Property object if there's a meaningful value
+            if value:
+                prop = Property(
+                    createdById=user_id,
+                    dateCreated=current_datetime,
+                    lastUpdatedById=user_id,
+                    isPublic=True,
+                    alt_id=wiz_id,
+                    key=key,
+                    value=value,
+                    parentId=0,
+                    parentModule="assets",
+                    dateLastUpdated=current_datetime,
+                )
+                properties.append(prop)
+
+        return properties
+
+
+def _value_checks(value: Any) -> Any:
+    """
+    Check if the value is a boolean or list and convert it to a string if needed
+    :param Any value: Value to check
+    :return: Converted value
+    :rtype: Any
+    """
+    # Simplify handling of list and dict values
+    if isinstance(value, list):
+        value = value[0] if value else None  # Get first item of the list if not empty
+    if isinstance(value, dict):
+        value = next((v for _, v in flatten_dict(value)), None)
+
+    # Replace NaN values with an empty string
+    if isinstance(value, (int, float)) and math.isnan(value):
+        value = ""
+    return value

regscale/models/regscale_models/question.py

@@ -0,0 +1,85 @@
+"""
+This module contains the Questions model for RegScale.
+"""
+
+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_model import RegScaleModel
+
+
+class QuestionType(str, Enum):
+    """
+    Enum for the QuestionType field in the Questions model.
+    """
+
+    ShortAnswer = 0
+    LongAnswer = 1
+    Instructional = 2
+    Date = 3
+    PhoneNumber = 4
+    Email = 5
+    DigitalSignature = 6
+    MultipleChoice = 10
+    CheckBoxes = 20
+    Dropdown = 30
+    FileAccess = 50
+
+
+class AnswerOptions(RegScaleModel):
+    answerOption: Optional[str]
+    answerScore: Optional[int] = 0
+
+
+class Questions(RegScaleModel):
+    """
+    A class to represent the Questions model in RegScale.
+    """
+
+    _module_slug = "questions"
+
+    id: Optional[int] = None
+    parentQuestionnaireId: int = 0
+    uuid: Optional[str] = None
+    questionType: int = 0
+    name: Optional[str] = None
+    label: Optional[str] = None
+    prompt: Optional[str] = None
+    tenantsId: Optional[int] = 1
+    createdById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateCreated: Optional[str] = Field(default_factory=get_current_datetime)
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    isPublic: bool = True
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    controlNumber: Optional[str] = None
+    section: int = 0
+    staticAnswerOptions: Optional[List[Dict]] = None  # Adjust the type if it's not a string
+    askQuestion: bool = True
+    quid: Optional[str] = None
+    required: bool = True
+    sectionIndex: int = 1
+    uploadEnabled: bool = False
+    response: Optional[str] = None  # Adjust the type if it's not a string
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get endpoints for the Question model.
+
+        :return: A dictionary of endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_all_by_parent_get="/api/{model_slug}/getAllByParent",
+            get="/api/{model_slug}/find/{id}",
+            insert="/api/{model_slug}/create",
+            update="/api/{model_slug}/update",
+            delete="/api/{model_slug}/delete/{id}",
+            get_new_section_index_post="/api/{model_slug}/getNewSectionIndex",
+            update_origin_section_put="/api/{model_slug}/updateOriginSection",
+            section_update_from_insert_put="/api/{model_slug}/sectionUpdateFromInsert",
+            section_update_from_cancel_put="/api/{model_slug}/sectionUpdateFromCancel",
+            index_up_put="/api/{model_slug}/indexUp",
+            index_down_put="/api/{model_slug}/indexDown",
+        )