regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/group.py

@@ -0,0 +1,169 @@
+"""
+This module contains the Group model class that represents a group in the RegScale application.
+"""
+
+import logging
+from typing import Optional, List, Tuple, cast
+
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models import RegScaleModel, User, T, deprecated
+from regscale.models.regscale_models.user_group import UserGroup
+
+logger = logging.getLogger(__name__)
+
+
+class Group(RegScaleModel):
+    _module_slug = "groups"
+
+    id: Optional[int] = None
+    name: Optional[str] = None
+    userGroups: Optional[List[UserGroup]] = None
+    activated: Optional[bool] = True
+    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: Optional[bool] = True
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    tenantsId: Optional[int] = 1
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Group model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_groups="/api/{model_slug}",
+            change_group_status="/api/{model_slug}/changeGroupStatus/{id}/{strActivated}",
+            find_groups_by_user="/api/{model_slug}/findGroupsByUser/{strUser}",
+            filter_groups="/api/{model_slug}/filterGroups/{strName}/{strActivated}/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+            find_users_by_group="/api/{model_slug}/findUsersByGroup/{intGroupId}",
+        )
+
+    @classmethod
+    @deprecated("Use UserGroup.get_users_by_group instead")
+    def get_users_in_group(cls, name: str) -> Tuple[List[User], int]:
+        """
+        Get a list of users in a group.
+
+        :param str name: The name of the group
+        :return: A list of users
+        :rtype: Tuple[List[User], int]
+        """
+        group_list_resp = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_groups").format(model_slug=cls._module_slug)
+        )
+        group_id = 0
+        if group_list_resp and group_list_resp.ok:
+            group_list = group_list_resp.json()
+            for group in group_list:
+                if group.get("name") == name:
+                    group_id = group.get("id")
+                    break
+
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("find_users_by_group").format(model_slug=cls._module_slug, intGroupId=group_id)
+        )
+        if response and response.ok:
+            users = [User(**user) for user in response.json()]
+            for user in users:
+                # add delegates to users list
+                users.extend(user.get_delegates(user.id))
+            return users, group_id
+        else:
+            logger.error(f"Failed to get users in group {name}")
+            return [], group_id
+
+    @classmethod
+    def get_group_by_name(cls, name: str) -> Optional["Group"]:
+        """
+        Get a group by name
+        :param name: The name of the group
+        :return: The group
+        :rtype: Optional[Group]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_groups").format(model_slug=cls._module_slug)
+        )
+        if response and response.ok:
+            group_list = response.json()
+            for group in group_list:
+                if group.get("name") == name:
+                    return cls(**group)
+        else:
+            cls.log_response_error(response=response)
+        return None
+
+    @classmethod
+    def get_group_list(cls) -> List["Group"]:
+        """
+        Get a list of groups
+        :return: A list of groups
+        :rtype: List[Group]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_groups").format(model_slug=cls._module_slug)
+        )
+        return cast(List[T], cls._handle_list_response(response))
+
+    @classmethod
+    def find_groups_by_user(cls, user: str) -> List["Group"]:
+        """
+        Find groups by user
+        :param user: The user ID
+        :return: A list of groups
+        :rtype: List[Group]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("find_groups_by_user").format(model_slug=cls._module_slug, strUser=user)
+        )
+        return cast(List[T], cls._handle_list_response(response))
+
+    @classmethod
+    def filter_groups(
+        cls, name: str, activated: str, sort_by: str, direction: str, page: int, page_size: int
+    ) -> List["Group"]:
+        """
+        Filter groups
+        :param name: The name of the group
+        :param activated: The activation status
+        :param sort_by: The field to sort by
+        :param direction: The sort direction
+        :param page: The page number
+        :param page_size: The page size
+        :return: A list of groups
+        :rtype: List[Group]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("filter_groups").format(
+                model_slug=cls._module_slug,
+                strName=name,
+                strActivated=activated,
+                strSortBy=sort_by,
+                strDirection=direction,
+                intPage=page,
+                intPageSize=page_size,
+            )
+        )
+        return cast(List[T], cls._handle_list_response(response))
+
+    @classmethod
+    def find_users_by_group(cls, group_id: int) -> List[User]:
+        """
+        Find users by group
+        :param group_id: The group ID
+        :return: A list of users
+        :rtype: List[User]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("find_users_by_group").format(model_slug=cls._module_slug, intGroupId=group_id)
+        )
+        if response and response.ok:
+            return [User(**o) for o in response.json()]
+        else:
+            cls.log_response_error(response=response)
+        return []

regscale/models/regscale_models/implementation_objective.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Dataclass for Implementation Objective in the application"""
+import logging
+import uuid
+from dataclasses import asdict
+from enum import Enum
+from logging import Logger
+from typing import Any, Optional, Union, Dict
+
+import requests
+from pydantic import Field, ConfigDict
+from requests import Response
+
+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.regscale_model import RegScaleModel
+
+
+logger = logging.getLogger("regscale")
+
+
+class ImplementationStatus(str, Enum):
+    """
+    Implementation Status
+    :param Enum: Enum
+    """
+
+    FULLY_IMPLEMENTED = "Fully Implemented"
+    PARTIALLY_IMPLEMENTED = "Partially Implemented"
+    NOT_IMPLEMENTED = "Not Implemented"
+
+
+class ImplementationObjectiveResponsibility(str, Enum):
+    """
+    Responsibility Enum
+    :param Enum: Enum
+    """
+
+    PROVIDER = "Provider"
+    PROVIDER_SYSTEM_SPECIFIC = "Provider (System Specific)"
+    HYBRID = "Hybrid"
+    CUSTOMER = "Customer"
+    CUSTOMER_CONFIGURED = "Customer Configured"
+    SHARED = "Shared"
+    INHERITED = "Inherited"
+    NOT_APPLICABLE = "Not Applicable"
+
+
+class ImplementationObjective(RegScaleModel):
+    """
+    RegScale Implementation Objective
+    Represents a row in the ImplementationObjectives table in the database.
+
+    Relationships:
+    - ImplementationId -> ControlImplementation (1:1)
+    - ObjectiveId -> ControlObjective (0..1:1) [optional]
+    - OptionId -> ImplementationOption (1:1)
+    - SecurityControlId -> SecurityControls (0..1:1) [optional]
+    - CreatedBy, LastUpdatedBy -> AspNetUsers (1:1) [FKs]
+    - TenantsId -> Tenants (1:1) [inherited]
+    - AuthorizationId -> LeveragedAuthorizations (0..1:1) [optional]
+    """
+
+    _module_slug = "implementationObjectives"
+    _get_objects_for_list = True  # TODO: Fix API to return securityControlId
+    _unique_fields = [
+        ["implementationId", "objectiveId"],
+    ]
+    _parent_id_field = "implementationId"
+
+    id: int = 0
+    securityControlId: int
+    uuid: str = Field(default_factory=lambda: str(uuid.uuid4()))  # Required
+    notes: Optional[str] = None
+    implementationId: int  # Required, FK to ControlImplementation
+    optionId: Optional[int] = None  # no longer Required, FK to ImplementationOption
+    inherited: Optional[bool] = False
+    status: Optional[Union[str, ImplementationStatus]] = ImplementationStatus.NOT_IMPLEMENTED  # Not Required
+    objectiveId: Optional[int] = None  # Optional, FK to ControlObjective
+    createdById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    # statement Should be required, represents the implementation statement
+    statement: Optional[str] = None
+    dateLastAssessed: str = Field(default_factory=get_current_datetime)  # Required
+    dateCreated: str = Field(default_factory=get_current_datetime)  # Required
+    dateLastUpdated: str = Field(default_factory=get_current_datetime)  # Required
+    isPublic: bool = True  # Required
+    parentObjectiveId: Optional[int] = None
+    authorizationId: Optional[int] = None
+    responsibility: Optional[str] = None
+    cloudResponsibility: Optional[str] = None
+    customerResponsibility: Optional[str] = None
+
+    def __init__(self, **data: Any):
+        # returned by bad api values for securityControlId corrected with validator
+        # Map 'controlId' to 'securityControlId' internally
+        if "controlId" in data:
+            data["securityControlId"] = data.pop("controlId")
+        super().__init__(**data)
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the ImplementationObjectives model, using {model_slug} as a placeholder for the model slug.
+
+        :return: Additional endpoints for the ImplementationObjective
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getByControl/{intParentID}",
+            get_by_control="/api/{model_slug}/getByControl/{intControl}",
+            get_assessment="/api/{model_slug}/getAssessment/{intControl}/{intObjective}",
+            batch_create="/api/{model_slug}/batchCreate",
+            merge="/api/{model_slug}/merge/{implementationID}/{securityControlID}",
+        )
+
+    @classmethod
+    def merge_objectives(cls, implementationId: int, securityControlId: int) -> Dict:
+        """
+        Merge objectives for a given implementation and security control
+
+        :param int implementationId: Implementation ID
+        :param int securityControlId: Security Control ID
+        :return: Merged objectives
+        :rtype: Dict
+        """
+
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("merge").format(
+                implementationID=implementationId, securityControlID=securityControlId
+            )
+        )
+        if response and response.ok:
+            return response.json()
+
+    # pydantic provides __eq__ method
+    def __eq__(self, other: "ImplementationObjective") -> bool:
+        """
+        Check if two ImplementationObjective objects are equal
+
+        :param ImplementationObjective other: ImplementationObjective object to compare to
+        :return: True if equal, False if not equal
+        :rtype: bool
+        """
+        if isinstance(other, ImplementationObjective):
+            return (
+                getattr(self, "notes", None) == getattr(other, "notes", None)
+                and getattr(self, "implementationId", None) == getattr(other, "implementationId", None)
+                and getattr(self, "objectiveId", None) == getattr(other, "objectiveId", None)
+                and getattr(self, "optionId", None) == getattr(other, "optionId", None)
+                and getattr(self, "statement", None) == getattr(other, "statement", None)
+            )
+        return False
+
+    def __hash__(self) -> hash:
+        """
+        Hash a ImplementationObjective object
+
+        :return: Hash of ImplementationObjective object
+        :rtype: hash
+        """
+        return hash((self.implementationId, self.objectiveId))
+
+    @classmethod
+    def get_by_control(
+        cls,
+        implementation_id: int,
+    ) -> list["ImplementationObjective"]:
+        """
+        Get a list of implementation options by control id and security plan id
+
+        :param int implementation_id: Implementation Control ID
+        :return: A list of implementation options
+        :rtype: list[ImplementationObjective]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_by_control").format(intControl=implementation_id),
+        )
+        if response and response.ok:
+            return [cls(**obj) for obj in response.json()]
+        return []
+
+    @property
+    def logger(self) -> Logger:
+        """
+        Logger implementation for a dataclass
+
+        :return: logger object
+        :rtype: Logger
+        """
+        logger = create_logger()
+        return logger
+
+    @staticmethod
+    def fetch_by_security_control(
+        app: Application,
+        security_control_id: int,
+    ) -> list["ImplementationObjective"]:
+        """
+        Fetch list of all implementation objectives in RegScale via API
+
+        :param Application app: Application Instance
+        :param int security_control_id: Security Control ID # in RegScale
+        :return: List of security controls from RegScale
+        :rtype: list[ImplementationObjective]
+        """
+        api = Api()
+        logger = create_logger()
+        query = """
+                    query {
+            implementationObjectives  (
+                take: 50,
+                skip: 0,
+                where: { securityControlId:  {eq: placeholder }, })
+                {
+                items {
+                    id,
+                    uuid,
+                    notes,
+                    optionId,
+                    implementationId,
+                    securityControlId,
+                    objectiveId,
+                    status
+                    }
+                totalCount
+                pageInfo {
+                    hasNextPage
+                }
+            }
+                }
+            """.replace(
+            "placeholder", str(security_control_id)
+        )
+        results = []
+        data = api.graph(query=query)
+        if "implementationObjectives" in data.keys():
+            try:
+                results.extend(data["implementationObjectives"]["items"])
+            except requests.exceptions.JSONDecodeError:
+                logger.warning(
+                    "Unable to find control implementation objectives for control %i.",
+                    security_control_id,
+                )
+        return [ImplementationObjective(**obj) for obj in results]
+
+    @staticmethod
+    def update_objective(
+        app: Application,
+        obj: Any,
+    ) -> Response:
+        """
+        Update a single implementation objective
+
+        :param Application app: Application Instance
+        :param Any obj: Implementation Objective
+        :return: Response from RegScale API
+        :rtype: Response
+        """
+        if isinstance(obj, ImplementationObjective):
+            obj = asdict(obj)
+        api = Api(retry=10)
+        return api.put(
+            url=app.config["domain"] + f"/api/implementationObjectives/{obj['id']}",
+            json=obj,
+        )
+
+    @staticmethod
+    def insert_objective(
+        app: Application,
+        obj: Any,
+    ) -> Response:
+        """
+        Update a single implementation objective
+
+        :param Application app: Application Instance
+        :param Any obj: Implementation Objective
+        :return: Response from RegScale API
+        :rtype: Response
+        """
+        if isinstance(obj, ImplementationObjective):
+            obj = asdict(obj)
+        api = Api(retry=10)
+        res = api.post(url=app.config["domain"] + "/api/implementationObjectives", json=obj)
+        return res
+
+    @classmethod
+    def fetch_implementation_objectives(
+        cls, app: Application, control_id: int, query_type: Optional[str] = "implementation"
+    ) -> list[dict]:
+        """
+        Fetch list of implementation objectives by control id
+
+        :param Application app: Application Instance
+        :param int control_id: Implementation Control ID
+        :param Optional[str] query_type: Query Type for GraphQL query
+        :return: A list of Implementation Objectives as a dictionary
+        :rtype: list[dict]
+        """
+        graph_query = """
+                        query {
+                        implementationObjectives (skip: 0, take: 50,  where: {securityControlId: {eq: placeholder}}) {
+                            items {
+                                    id
+                                    notes
+                                    optionId
+                                    objectiveId
+                                    implementationId
+                                    securityControlId
+                                    status
+                            }
+                            totalCount
+                                pageInfo {
+                                    hasNextPage
+                                }
+                        }
+                    }
+                        """.replace(
+            "placeholder", str(control_id)
+        )
+        results: list[Any] = []
+        api = Api()
+        if query_type != "implementation":
+            results = cls._get_api_handler().graph(graph_query)
+        else:
+            res = api.get(url=app.config["domain"] + f"/api/implementationObjectives/getByControl/{control_id}")
+            if res.ok:
+                try:
+                    results = res.json()
+                except requests.exceptions.JSONDecodeError:
+                    logger.warning("Unable to find control implementation objectives.")
+        return results