regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/questionnaire.py

@@ -0,0 +1,87 @@
+"""
+This module contains the Questionnaires model in RegScale.
+"""
+
+import logging
+from typing import Optional, List, Dict
+
+from pydantic import ConfigDict
+
+from regscale.models.regscale_models.questionnaire_instance import QuestionnaireInstance
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+logger = logging.getLogger(__name__)
+
+
+class Questionnaires(RegScaleModel):
+    """
+    A class to represent the Questionnaires model in RegScale.
+    """
+
+    _module_slug = "questionnaires"
+
+    id: Optional[int] = 0
+    uuid: Optional[str] = None
+    title: str
+    ownerId: str
+    description: Optional[str] = None
+    instructions: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    dateLastUpdated: Optional[str] = None
+    tenantsId: Optional[int] = 1
+    active: bool = True
+    isPublic: bool = True
+    sections: Optional[List[int]] = [0]  # Adjust the type if it's not a string
+    rules: Optional[str] = None  # Adjust the type if it's not a string
+    loginRequired: Optional[bool] = True
+    allowPublicUrl: Optional[bool] = True
+    enableScoring: Optional[bool] = False
+    questionnaireIds: Optional[List[int]] = None
+    parentQuestionnaireId: Optional[int] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get endpoints for the Questionnaire model.
+
+        :return: A dictionary of endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_count="/api/{model_slug}/getCount",
+            graph_post="/api/{model_slug}/graph",
+            filter_post="/api/{model_slug}/filterQuestionnaires",
+            create_with_data_post="/api/{model_slug}/createWithData",
+            insert="/api/{model_slug}/create",
+            create_instances_from_questionnaires_post="/api/{model_slug}/createInstancesFromQuestionnaires",
+            create_instances_from_questionnaires_return_instance="/api/{model_slug}/createInstancesFromQuestionnairesReturnInstances",
+            upload_post="/api/{model_slug}/upload",
+            upload_bulk_email_assignment_post="/api/{model_slug}/uploadBulkEmailAssignment/{questionnaireId}",
+            get_updatable_instances_get="/api/{model_slug}/getUpdatableInstances/{questionnaireId}",
+            update_assigned_instances_put="/api/{model_slug}/updateAssignedInstances",
+            export_get="/api/{model_slug}/exportQuestionnaire/{questionnaireId}",
+            export_example_get="/api/{model_slug}/exportQuestionnaireExample",
+            export_responses_post="/api/{model_slug}/exportQuestionnaireResponses",
+        )
+
+    @classmethod
+    def create_instances_from_questionnaires(cls, payload: dict) -> Optional[List[QuestionnaireInstance]]:
+        """
+        Creates instances from questionnaires.
+        :param payload: The payload to send to the API.
+        :return: The response from the API or None
+        :rtype: Optional[List[QuestionnaireInstance]]
+        """
+        endpoint = cls.get_endpoint("create_instances_from_questionnaires_return_instance")
+        response = cls._get_api_handler().post(endpoint.format(model_slug=cls._module_slug), data=payload)
+
+        if not response or response.status_code in [204, 404]:
+            return None
+        if response.ok:
+            response_json = response.json()
+            return [QuestionnaireInstance(**instance) for instance in response_json.get("createdInstances", [])]
+        else:
+            logger.info(f"Failed to create instances from questionnaires {response.status_code} - {response.text}")
+        return None

regscale/models/regscale_models/questionnaire_instance.py

@@ -0,0 +1,177 @@
+"""
+This module contains the QuestionnaireInstances model.
+"""
+
+from enum import Enum
+from typing import Optional, List, Dict, Any
+
+from pydantic import Field, ConfigDict
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class QuestionnaireInstanceState(str, Enum):
+    """
+    Enum for the QuestionnaireInstanceState field in the QuestionnaireInstances model.
+    """
+
+    Open = 0
+    Submitted = 10
+    Accepted = 20
+    RequestChanges = 30
+    Closed = 40
+
+
+class QuestionnaireInstance(RegScaleModel):
+    """
+    A class to represent the QuestionnaireInstances model in RegScale.
+    """
+
+    _module_slug = "questionnaireInstances"
+
+    id: int = 0
+    parentId: int = 0
+    parentModule: Optional[str] = None
+    token: Optional[int] = 0
+    title: Optional[str] = None
+    parentQuestionnaireId: int
+    activeStatus: bool = True
+    passingStatus: int = 0
+    instanceState: int = 0
+    uuid: Optional[str] = None
+    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)
+    tenantsId: Optional[int] = 1
+    isPublic: bool = True
+    jsonData: Optional[str] = None  # Adjust the type if it's not a string
+    assigneeId: Optional[str] = None
+    recurrence: Optional[str] = None  # Adjust the type if it's not a string
+    dueDate: Optional[str] = None
+    sections: Optional[List[int]] = Field(default_factory=list)  # Adjust the type if it's not a string
+    rules: Optional[str] = None  # Adjust the type if it's not a string
+    emailList: Optional[str] = None  # Adjust the type if it's not a string
+    loginRequired: bool = True
+    accessCode: Optional[str] = None
+    questionnaireIds: Optional[List[int]] = None
+    percentComplete: Optional[int] = None
+    questions: Optional[List[Dict]] = None  # Adjust the type if it's not a string
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the QuestionnaireInstances model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_count="/api/{model_slug}/getCount",
+            graph="/api/{model_slug}/graph",
+            filter_questionnaire_instances="/api/{model_slug}/filterQuestionnaireInstances",
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{parentQuestionnaireId}",
+            link_questionnaire_instance_post="/api/{model_slug}/link",
+            link_feedback="/api/{model_slug}/linkFeedback/{id}",
+            is_login_required="/api/{model_slug}/isLoginRequired/{uuid}",
+            update_responses="/api/{model_slug}/updateResponses/{uuid}",
+            update_feedback="/api/{model_slug}/updateFeedback/{uuid}",
+            change_state_accepted="/api/{model_slug}/changeStateAccepted/{uuid}",
+            change_state_rejected="/api/{model_slug}/changeStateRejected/{uuid}",
+            submit_for_feedback="/api/{model_slug}/submitForFeedback/{uuid}",
+            reopen_instance="/api/{model_slug}/reopenInstance/{uuid}",
+            export_questionnaire_instance="/api/{model_slug}/exportQuestionnaireInstance/{questionnaireInstanceId}",
+            create_instances_from_questionnaires_post="/api/questionnaires/createInstancesFromQuestionnaires",
+        )
+
+    def create_instances_from_questionnaires(self) -> Optional[Dict]:
+        """
+        Creates instances from questionnaires.
+
+        :return: The response from the API or None
+        :rtype: Optional[Dict]
+        """
+        endpoint = self.get_endpoint("create_instances_from_questionnaires_post")
+        headers = {
+            "Content-Type": "application/json-patch+json",
+            "Authorization": self._get_api_handler().config.get("token"),
+            "accept": "*/*",
+            "origin": self._get_api_handler().config.get("domain"),
+        }
+        response = self._get_api_handler().post(endpoint, headers=headers, data=self.dict())
+
+        if not response or response.status_code in [204, 404]:
+            return None
+        if response.ok:
+            return response.json()
+        else:
+            logger.info(f"Failed to create instances from questionnaires {response.status_code} - {response.text}")
+        return None
+
+    @classmethod
+    def link_feedback(cls, id: int) -> Optional[Dict[str, Any]]:
+        """
+        Retrieves a questionnaire based on its ID for feedback purposes.
+
+        :param int id: The ID of the questionnaire
+        :return: The response from the API or None
+        :rtype: Optional[Dict[str, Any]]
+        """
+        endpoint = cls.get_endpoint("link_feedback").format(model_slug=cls._module_slug, id=id)
+        response = cls._get_api_handler().get(endpoint)
+
+        if not response or response.status_code in [204, 404]:
+            return None
+        if response.ok:
+            try:
+                return response.json()
+            except Exception:
+                return None
+        return None
+
+    @classmethod
+    def get_all_by_parent(cls, parent_questionnaire_id: int) -> List["QuestionnaireInstance"]:
+        """
+        Retrieves all questionnaire instances of a parent questionnaire.
+
+        :param int parent_questionnaire_id: The ID of the parent questionnaire
+        :return: A list of questionnaire instances or None
+        :rtype: List[QuestionnaireInstance]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_parent").format(
+                model_slug=cls._module_slug,
+                parentQuestionnaireId=parent_questionnaire_id,
+            )
+        )
+        if not response or response.status_code in [204, 404]:
+            return []
+        if response and response.ok:
+            return [cls(**item) for item in response.json()]
+        return []
+
+    @classmethod
+    def filter(cls, payload: Dict) -> Optional[List["QuestionnaireInstance"]]:
+        """
+        Filters questionnaire instances based on the payload.
+
+        :param Dict payload: The data to be sent in the request body
+        :return: A list of questionnaire instances or None
+        :rtype: Optional[List[QuestionnaireInstance]]
+        """
+        endpoint = cls.get_endpoint("filter_questionnaire_instances").format(model_slug=cls._module_slug)
+        response = cls._get_api_handler().post(endpoint, data=payload)
+
+        if not response or response.status_code in [204, 404]:
+            return None
+        if response.ok:
+            data = response.json()
+            items = data.get("items")
+            total = data.get("totalItems")
+            logger.info(f"Found Total Change Questionnaires accepted: {total}")
+            return [cls(**item) for item in items]
+        return None

regscale/models/regscale_models/rbac.py

@@ -0,0 +1,132 @@
+from typing import Optional
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from pydantic import Field, ConfigDict
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class RBAC(RegScaleModel):
+
+    _module_slug = "rbac"
+    id: Optional[int] = Field(alias="rbacId")
+    moduleId: Optional[int] = None
+    parentId: Optional[int] = None
+    groupId: Optional[int] = None
+    permissionType: Optional[int] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the RBAC model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_all_by_parent="/api/{model_slug}/{moduleId}/{parentId}",
+            add="/api/{model_slug}/add/{moduleId}/{parentId}/{groupId}/{permissionType}",
+            public="/api/{model_slug}/public/{moduleId}/{parentId}/{public}",
+            none_standard_delete="/api/{model_slug}/{moduleId}/{parentId}/{rbacId}",
+        )
+
+    @classmethod
+    def delete(cls, module_id: int, parent_id: int, rbac_id: int) -> bool:
+        """
+        Delete a RBAC entry.
+
+        :param int module_id: The ID of the module
+        :param int parent_id: The ID of the parent
+        :param int rbac_id: The ID of the RBAC entry
+        :return: True if the RBAC entry was deleted, False otherwise
+        :rtype: bool
+        """
+        response = cls._get_api_handler().delete(
+            endpoint=cls.get_endpoint("none_standard_delete").format(
+                model_slug=cls._module_slug,
+                moduleId=module_id,
+                parentId=parent_id,
+                rbacId=rbac_id,
+            )
+        )
+        if response and response.ok:
+            return True
+        else:
+            cls.log_response_error(response=response)
+
+    @classmethod
+    def get_all_by_parent(cls, module_id: int, parent_id: int) -> list:
+        """
+        Get all RBAC entries by parent. Override from regscaleModel due to different endpoint params on api call.
+
+        :param int module_id: The ID of the module
+        :param int parent_id: The ID of the parent
+        :return: A list of RBAC entries
+        :rtype: list
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_parent").format(
+                model_slug=cls._module_slug,
+                moduleId=module_id,
+                parentId=parent_id,
+            )
+        )
+        if response and response.ok:
+            logger.info(f"Response: {response.json()}")
+            return [cls(**o) for o in response.json()]
+        else:
+            cls.log_response_error(response=response)
+            return []
+
+    @classmethod
+    def add(cls, module_id: int, parent_id: int, group_id: int, permission_type: int) -> bool:
+        """
+        Add a new RBAC entry.
+
+        :param int module_id: The ID of the module
+        :param int parent_id: The ID of the parent
+        :param int group_id: The ID of the group
+        :param int permission_type: The permission type
+        :return: True if the RBAC entry was added, False otherwise
+        :rtype: bool
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("add").format(
+                model_slug=cls._module_slug,
+                moduleId=module_id,
+                parentId=parent_id,
+                groupId=group_id,
+                permissionType=permission_type,
+            )
+        )
+        if response and response.ok:
+            return True
+        else:
+            cls.log_response_error(response=response)
+            return False
+
+    @classmethod
+    def public(cls, module_id: int, parent_id: int, is_public: int = 0) -> bool:
+        """
+        Add a new RBAC entry.
+
+        :param int module_id: The ID of the module
+        :param int parent_id: The ID of the parent
+        :param int is_public: The public flag 0 is public and 1 is private
+        :return: True if the RBAC entry was added, False otherwise
+        :rtype: bool
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("public").format(
+                model_slug=cls._module_slug,
+                moduleId=module_id,
+                parentId=parent_id,
+                public=is_public,
+            )
+        )
+        if response and response.ok:
+            return True
+        else:
+            cls.log_response_error(response=response)
+            return False

regscale/models/regscale_models/reference.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Provide References models."""
+import warnings
+from typing import List, Union, Optional
+
+from pydantic import Field
+
+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 Reference(RegScaleModel):
+    """References model"""
+
+    _module_slug = "references"
+
+    id: int = 0
+    createdById: str = ""  # this should be userID
+    dateCreated: str = Field(default_factory=get_current_datetime)
+    lastUpdatedById: str = ""  # this should be userID
+    isPublic: bool = True
+    identificationNumber: str = ""
+    title: str = ""
+    version: str = ""
+    datePublished: str = Field(default_factory=get_current_datetime)
+    referenceType: str = ""
+    link: str = ""
+    parentId: int = 0
+    parentModule: str = ""
+    dateLastUpdated: str = Field(default_factory=get_current_datetime)
+
+    @staticmethod
+    def create_references_from_list(
+        parent_id: Union[str, int],
+        references_list: List[dict],
+        parent_module: Optional[str] = "securityplans",
+    ) -> List[Union["Reference", bool]]:
+        """
+        Create a list of References objects from a list of dicts
+
+        :param Union[str, int] parent_id: ID of the SSP to create the References objects for
+        :param List[dict] references_list: List of dicts to create objects from
+        :param Optional[str] parent_module: Parent module of the References objects, defaults to "securityplans"
+        :return: List of References objects or False if unsuccessful
+        :rtype: List[Union[Reference, bool]]
+        """
+        references = [
+            Reference(parentId=int(parent_id), parentModule=parent_module, **references)
+            for references in references_list
+        ]
+        response = []
+        for reference in references:
+            response.append(reference.create_new_references(return_object=True))
+        return response
+
+    def create_new_references(self, return_object: Optional[bool] = False) -> Union[bool, "Reference"]:
+        """
+        Create a new References object in RegScale
+
+        :param Optional[bool] return_object: Return the References object if successful, defaults to False
+        :return: True if successful, False otherwise
+        :rtype: Union[bool, "Reference"]
+        """
+        warnings.warn(
+            "The 'create_new_references' method is deprecated, use 'create' method instead",
+            DeprecationWarning,
+        )
+        api = Api()
+        data = self.dict()
+        data["createdById"] = api.config["userId"]
+        data["lastUpdatedById"] = api.config["userId"]
+        references_response = api.post(
+            f'{api.config["domain"]}/api/references/',
+            json=data,
+        )
+        logger = create_logger()
+        if references_response.ok:
+            logger.info(f'Created References: {references_response.json()["id"]}')
+            if return_object:
+                return Reference(**references_response.json())
+            return True
+        logger.error(f"Error creating References: {references_response.text}")
+        return False