regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/supply_chain.py

@@ -0,0 +1,152 @@
+"""Supply Chain model class"""
+
+import logging
+from enum import Enum
+from typing import Optional, Union
+
+from pydantic import ConfigDict, Field
+
+from .regscale_model import RegScaleModel
+
+logger = logging.getLogger("regscale")
+
+
+class SupplyChainStatus(str, Enum):
+    """Supply Chain Status"""
+
+    Pending = "Pending"
+    Active = "Active"
+    Closed = "Closed"
+
+    def __str__(self) -> str:
+        """
+        Return the string representation of the Supply Chain Status
+
+        :return: The string representation of the Supply Chain Status
+        :rtype: str
+        """
+        return self.value
+
+
+class SupplyChainTier(str, Enum):
+    """Supply Chain Tier"""
+
+    Tier1 = "Tier 1 - Organizational"
+    Tier2 = "Tier 2 - Mission"
+    Tier3 = "Tier 3 - Information System"
+    Tier4 = "Tier 4 - Administrative/Other"
+
+    def __str__(self) -> str:
+        """
+        Return the string representation of the Supply Chain Tier
+
+        :return: The string representation of the Supply Chain Tier
+        :rtype: str
+        """
+        return self.value
+
+
+class SupplyChainFipsImpact(str, Enum):
+    """Supply Chain Fips Impact Level"""
+
+    Low = "Low"
+    Moderate = "Moderate"
+    High = "High"
+
+    def __str__(self) -> str:
+        """
+        Return the string representation of the Supply Chain Fips Impact Level
+
+        :return: The string representation of the Supply Chain Fips Impact Level
+        :rtype: str
+        """
+        return self.value
+
+
+class SupplyChainContractType(str, Enum):
+    """Supply Chain Contract Type"""
+
+    FirmFixedPrice = "Firm Fixed Price (FFP)"
+    TimeAndMaterials = "Time and Materials (T&M)"
+    CostPlus = "Cost Plus"
+    Subcontractor = "Subcontractor"
+
+    def __str__(self) -> str:
+        """
+        Return the string representation of the Supply Chain Contract Type
+
+        :return: The string representation of the Supply Chain Contract Type
+        :rtype: str
+        """
+        return self.value
+
+
+class SupplyChain(RegScaleModel):
+    """Supply Chain model class"""
+
+    _parent_id_field = "parentId"
+    _unique_fields = [
+        ["parentId", "parentModule", "contractNumber"],
+    ]
+    _module_slug = "supplychain"
+
+    title: str
+    id: Optional[int] = 0
+    status: Union[SupplyChainStatus, str] = SupplyChainStatus.Pending
+    uuid: Optional[str] = None
+    fips: Optional[Union[SupplyChainFipsImpact, str]] = None
+    contractNumber: Optional[str] = None
+    isPublic: bool = True
+    parentId: int = 0
+    parentModule: Optional[str] = None
+    orgId: Optional[int] = 0
+    facilityId: Optional[int] = 0
+    contractValue: Optional[int] = 0
+    fundedAmount: Optional[int] = 0
+    actualCosts: Optional[int] = 0
+    strategicTier: Optional[Union[SupplyChainTier, str]] = None
+    contractType: Optional[Union[SupplyChainContractType, str]] = None
+    scope: Optional[str] = (None,)
+    startDate: Optional[str] = None
+    endDate: Optional[str] = None
+    violationURL: Optional[str] = None
+    stockURL: Optional[str] = None
+    duns: Optional[str] = None
+    ein: Optional[str] = None
+    cageCodes: Optional[str] = None
+    naics: Optional[str] = None
+    stockSymbol: Optional[str] = None
+    aribaNetworkId: Optional[str] = None
+    contractOwnerId: str = Field(default_factory=RegScaleModel._get_api_handler().get_user_id)
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the SupplyChain model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_list="/api/{model_slug}/list",
+            get_count="/api/{model_slug}/getCount",
+            get_all_by_parent="/api/{model_slug}/getAllByParent/intParentId/{strModule}",
+            graph="/api/{model_slug}/graph",
+            graph_contrat_amount="/api/{model_slug}/graphContractAmount/{year}",
+            graph_status_by_month="/api/{model_slug}/graphStatusByMonth/{year}",
+            graph_by_date="/api/{model_slug}/graphByDate/{strGroupBy}/{year}",
+            filter_supplychain="/api/{model_slug}/filterSupplyChain",
+            query_by_custom_field="/api/{model_slug}/queryByCustomField/{strFieldName}/{strValue}",
+            statusboard="/api/{model_slug}/statusboard/{strSearch}/{strStatus}/{strType}/{strOwner}/{facilityId}/{intPage}/{intPageSize}",
+            find_by_uuid="/api/{model_slug}/findByUUID/{strUUID}",
+            find_by_ariba_id="/api/{model_slug}/findByAribaId/{strAriba}",
+            find_by_stock_symbol="/api/{model_slug}/findByStockSymbol/{strStock}",
+            find_by_naic="/api/{model_slug}/findByNAIC/{strNAIC}",
+            find_by_cage_code="/api/{model_slug}/findByCageCode/{strCAGE}",
+            find_by_ein="/api/{model_slug}/findByEIN/{strEIN}",
+            find_by_duns="/api/{model_slug}/findByDUNS/{strDUNS}",
+            main_dashboard="/api/{model_slug}/mainDashboard/{intYear}",
+            dashboard="/api/{model_slug}/dashboard/{strGroupBy}",
+            report="/api/{model_slug}/report/{strReport}",
+            schedule="/api/{model_slug}/schedule/{year}/{dvar}",
+        )

regscale/models/regscale_models/system_role.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Class for a RegScale SystemRoles"""
+import copy
+import logging
+from typing import List, Optional
+from typing import cast
+from urllib.parse import urljoin
+
+import requests
+from pydantic import Field, ConfigDict
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+logger = logging.getLogger("regscale")
+
+
+class SystemRole(RegScaleModel):
+    """Class for a RegScale SystemRoles"""
+
+    _module_slug = "systemRoles"
+
+    roleName: str  # Required Field
+    roleType: str  # Required Field
+    accessLevel: str  # Required Field
+    sensitivityLevel: str  # Required field
+    privilegeDescription: str  # Required Field
+    securityPlanId: int  # Required Field
+    functions: str  # Required Field
+    createdById: str = Field(default_factory=RegScaleModel.get_user_id)
+    id: int = 0
+    uuid: str = ""
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    isPublic: bool = True
+    dateCreated: Optional[str] = None
+    dateLastUpdated: Optional[str] = None
+    assignedUserId: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    fedrampRoleId: Optional[str] = None
+    tenantsId: int = 1
+    externalUserId: Optional[str] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the SystemRole
+
+        :return: Additional endpoints for the SystemRole
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}",
+        )
+
+    @staticmethod
+    def from_dict(obj: dict) -> "SystemRole":  # type: ignore
+        """
+        Create a SystemRoles object from a dictionary
+
+        :param dict obj: The dictionary to convert to a SystemRoles object
+        :return: A SystemRoles object
+        :rtype: SystemRole
+        """
+        copy_obj = copy.copy(obj)
+        if "id" in copy_obj:
+            del copy_obj["id"]
+        if isinstance(copy_obj["functions"], list):
+            copy_obj["functions"] = ", ".join(copy_obj["functions"])
+        return SystemRole(**copy_obj)
+
+    def __eq__(self, other: "SystemRole") -> bool:
+        """
+        Compare two SystemRoles objects
+
+        :param SystemRole other: The object to compare to
+        :return: True if the SystemRoles objects are equal
+        :rtype: bool
+        """
+        if not isinstance(other, SystemRole):
+            return NotImplemented
+        return self.dict() == other.dict()
+
+    def __hash__(self) -> hash:
+        """
+        Hash a SystemRoles object
+
+        :return: The hash of the SystemRoles object
+        :rtype: hash
+        """
+        return hash(
+            (
+                self.roleName,
+                self.roleType,
+                self.accessLevel,
+                self.sensitivityLevel,
+                self.privilegeDescription,
+                tuple(self.functions),
+                self.securityPlanId,
+                self.isPublic,
+                self.assignedUserId,
+                self.fedrampRoleId,
+            )
+        )
+
+    def insert_systemrole(self, app: Application) -> dict:
+        """
+        Insert a SystemRoles object into the database
+
+        :param Application app: The application object
+        :return: The dict of the SystemRoles object
+        :rtype: dict
+        """
+        # Convert the object to a dictionary
+        api = Api()
+        url = urljoin(app.config.get("domain", ""), "/api/systemRoles/")
+        if hasattr(self, "id"):
+            del self.id
+        if hasattr(self, "uuid"):
+            del self.uuid
+        if hasattr(self, "dateCreated"):
+            del self.dateCreated
+        data = self.dict()
+        # Make the API call
+        try:
+            response = api.post(url, json=data)
+            if response.ok:
+                # Parse the response to a SystemRoles object
+                logger.info(
+                    "Successfully saved System Role %s to RegScale Security" + " Plan %i",
+                    data["roleName"],
+                    data["securityPlanId"],
+                )
+                return response.json()
+        except requests.exceptions.RequestException as err:
+            logger.warning(
+                "Unable to post System Role to RegScale Security Plan #%i, \n%s",
+                self.securityPlanId,
+                err,
+            )
+        return {}
+
+    @classmethod
+    def get_or_create(cls, app: Application, role_name: str, ssp_id: int, **kwargs) -> dict:
+        """
+        Get or create a SystemRoles object for a given SSP ID
+
+        :param Application app: The application object
+        :param str role_name: The name of the role
+        :param int ssp_id: The SSP ID
+        :param **kwargs: Additional keyword arguments
+        :return: The SystemRoles dict object
+        :rtype: dict
+        """
+
+        # Check if a role with the same name already exists
+        if "all_roles" not in kwargs:
+            all_roles = cls.get_all_by_ssp_id(app, ssp_id)
+        else:
+            all_roles = kwargs["all_roles"]
+
+        existing_role = next(
+            (role for role in all_roles if role["roleName"].lower().strip() == role_name.lower().strip()),
+            None,
+        )
+        if existing_role:
+            logger.debug("Role: %s already exists in RegScale, skipping insert..", role_name.strip())
+            return existing_role
+        else:
+            # If it doesn't exist, create a new one
+            new_role = cls(roleName=role_name.strip(), **kwargs)
+            return new_role.insert_systemrole(app=app)
+
+    @staticmethod
+    def get_all_by_ssp_id(app: Application, ssp_id: int) -> List["SystemRole"]:
+        """
+        Get a list of SystemRoles objects for a given SSP ID
+
+        :param Application app: The application object
+        :param int ssp_id: The SSP ID
+        :return: A list of SystemRoles objects
+        :rtype: List[SystemRole]
+        """
+        api = Api()
+        url = urljoin(app.config.get("domain", ""), f"/api/systemRoles/getAllByParent/{ssp_id}")
+        response = api.get(url)
+        # Parse the response to a list of SystemRoles objects
+        return cast(List[SystemRole], [role for role in response.json()] if response.json() else [])

regscale/models/regscale_models/system_role_external_assignment.py

@@ -0,0 +1,40 @@
+"""Provide a SystemRoleExternalAssignments model."""
+
+import warnings
+from typing import Optional
+from urllib.parse import urljoin
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class SystemRoleExternalAssignment(RegScaleModel):
+    """SystemRoleExternalAssignments model"""
+
+    _module_slug = "systemRoleExternalAssignments"
+
+    id: int = 0
+    uuid: str = ""
+    stakeholderId: int = 0
+    roleId: int = 0
+
+    def post(self, app: Application) -> Optional["SystemRoleExternalAssignment"]:
+        """
+        Post a SystemRoleExternalAssignments to RegScale
+
+        This method is deprecated, use 'create' method instead
+
+        :param Application app: The application instance
+        :return: The response from the API or None
+        :rtype: Optional[SystemRoleExternalAssignment]
+        """
+        warnings.warn(
+            "The 'post' method is deprecated, use 'create' method instead",
+            DeprecationWarning,
+        )
+        api = Api()
+        url = urljoin(app.config.get("domain", ""), "/api/systemRoleExternalAssignments")
+        data = self.dict()
+        response = api.post(url, json=data)
+        return SystemRoleExternalAssignment(**response.json()) if response.ok else None

regscale/models/regscale_models/tag.py

@@ -0,0 +1,37 @@
+from enum import Enum
+from typing import Optional
+
+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 TagTypeEnum(Enum):
+    """
+    TagTypeEnum class
+    """
+
+    SYSTEM = "System"
+    EXPORT = "Export"
+    IMPORT = "Import"
+    DATA = "Data"
+    USER = "User"
+
+
+class Tag(RegScaleModel):
+    _module_slug = "tags"
+
+    id: int = 0
+    uuid: Optional[str] = None
+    title: str = ""  # required
+    tagType: TagTypeEnum = TagTypeEnum.USER.value  # default to user. Use System for Export or Import
+    isPublic: bool = True
+    OscalRequired: bool = False
+    tagColor: Optional[str] = None  # not currently implemented yet
+    tagTextColor: Optional[str] = None  # not currently implemented yet
+    tenantsId: int = 1
+    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)

regscale/models/regscale_models/tag_mapping.py

@@ -0,0 +1,19 @@
+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 TagMapping(RegScaleModel):
+    _module_slug = "tagMappings"
+
+    id: int = 0
+    parentId: str = ""
+    parentModule: str = ""
+    tagId: int = 0
+    isPublic: bool = True
+    tenantsId: int = 1
+    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)

regscale/models/regscale_models/task.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Task in the application"""
+
+from typing import Optional, List
+
+from pydantic import ConfigDict, Field, field_validator
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.core.utils.date import date_str
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class Task(RegScaleModel):
+    """
+    Task model class
+    """
+
+    _module_slug = "tasks"
+    _unique_fields = [
+        ["title", "description", "parentID", "parentModule"],
+    ]
+    status: str  # Required
+    title: str  # Required
+    dueDate: str  # Required
+    id: int = 0  # Required
+    uuid: Optional[str] = None
+    otherIdentifier: Optional[str] = None
+    taskType: Optional[str] = None
+    assignedToId: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    description: Optional[str] = None
+    results: Optional[str] = None
+    originalDueDate: Optional[str] = None
+    dateSlide: Optional[int] = None
+    dateClosed: Optional[str] = None
+    percentComplete: Optional[int] = None
+    statusUpdate: Optional[str] = None
+    orgId: Optional[int] = None
+    levelOfEffort: Optional[int] = None
+    parentId: Optional[int] = None
+    parentModule: Optional[str] = None
+    isPublic: bool = True
+    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
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Task model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}/{strModule}",
+            create="/api/{model_slug}",
+            other_identifier_starts_with="/api/{model_slug}/otherIdentifierStartsWith/{strId}",
+            query_by_custom_field="/api/{model_slug}/queryByCustomField/{strFieldName}/{strValue}",
+            get_by_date_range="/api/{model_slug}/getByDateRangeAll/{dtStart}/{dtEnd}",
+        )
+
+    @classmethod
+    def query_by_custom_field(cls, field_name: str, field_value: str) -> List["Task"]:
+        """
+        Query tasks by a custom field.
+
+        :param str field_name: The name of the custom field to query
+        :param str field_value: The value of the custom field to match
+        :return: A list of Task instances matching the query
+        :rtype: List[Task]
+        """
+        endpoint = cls.get_endpoint("query_by_custom_field").format(strFieldName=field_name, strValue=field_value)
+        response = cls._get_api_handler().get(endpoint=endpoint)
+        return cls._handle_list_response(response)
+
+    @classmethod
+    def get_by_date_range(cls, start_date: str, end_date: str) -> List["Task"]:
+        """
+        Query tasks within a specified date range.
+
+        :param str start_date: The start date of the range
+        :param str end_date: The end date of the range
+        :return: A list of Task instances within the specified date range
+        :rtype: List[Task]
+        """
+
+        endpoint = cls.get_endpoint("get_by_date_range").format(dtStart=date_str(start_date), dtEnd=date_str(end_date))
+        response = cls._get_api_handler().get(endpoint=endpoint)
+        return cls._handle_list_response(response)
+
+    def __eq__(self, other: "Task") -> bool:
+        """
+        Equality of items in Task class
+
+        :param Task other: Task object to compare to
+        :return: Whether the two tasks are equal
+        :rtype: bool
+        """
+        return (
+            self.title == other.title
+            and self.otherIdentifier == other.otherIdentifier
+            and self.description == other.description
+            and self.parentId == other.parentId
+            and self.parentModule == other.parentModule
+        )
+
+    def __hash__(self) -> int:
+        """
+        Hash function for Task class
+
+        :return: Hash of the Task object
+        :rtype: int
+        """
+
+        return hash((self.title, self.description, self.parentId, self.parentModule, self.otherIdentifier))
+
+    @field_validator("status", mode="before")
+    @classmethod
+    def validate_status(cls, v: str) -> str:
+        """
+        Validate the status of the task
+
+        :param str v: The status of the task
+        :raises ValueError: If the status is not one of the allowed values
+        :return: The status of the task
+        :rtype: str
+
+        """
+        if v not in ["Backlog", "Open", "Closed", "Cancelled"]:
+            raise ValueError("Task status must be either 'Backlog', 'Open', 'Closed', or 'Cancelled'")
+        return v