regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/custom_field.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Custom Fields in the application"""
+
+import logging
+from typing import Any, List, Optional
+
+from pydantic import ConfigDict
+
+from regscale.core.app.utils.app_utils import update_keys_to_lowercase_first_letter
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+logger = logging.getLogger("regscale")
+
+
+class CustomField(RegScaleModel):
+    _module_slug = "customFields"
+
+    id: Optional[int] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    isPublic: Optional[bool] = None
+    moduleId: Optional[int] = None
+    fieldName: Optional[str] = None
+    fieldDataType: Optional[str] = None
+    active: Optional[bool] = None
+    fieldRequired: Optional[bool] = None
+    disabled: Optional[bool] = None
+    order: Optional[int] = None
+    tenantId: int = 1
+    dateLastUpdated: Optional[str] = None
+    data: Optional[List[Any]] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the CustomField model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            insert="/api/{model_slug}/1",
+            get_module_with_tenant="/api/{model_slug}/module/{tenantId}/{moduleId}",
+            get_module="/api/{model_slug}/module/{moduleId}",
+            get_module_required="/api/{model_slug}/moduleRequired/{moduleId}",
+            get_custom_field="/api/{model_slug}/{customFieldId}",
+            filter_custom_fields="/api/{model_slug}/{tenantId}/{moduleId}/{strSort}/{strDirection}/{intPage}/{intPageSize}",
+            update_batch_post="/api/{model_slug}/update/{tenantId}",
+            create_custom_field_post="/api/{model_slug}/{tenantId}",
+            update_custom_field_put="/api/{model_slug}/{tenantId}",
+            update_sort_order_post="/api/{model_slug}/sortOrder/{moduleId}",
+            enable_custom_field_put="/api/{model_slug}/enable/{tenantId}/{customFieldId}/{enabled}",
+            require_custom_field_put="/api/{model_slug}/require/{tenantId}/{customFieldId}/{required}",
+            get_by_parent="/api/{model_slug}/module/{strModule}",
+        )
+
+    @classmethod
+    def get_list_by_module_id(cls, module_id: int) -> List["CustomField"]:
+        """
+        Get a list of custom fields by module ID
+
+        :param int module_id: The ID of the module
+        :return: A list of custom fields
+        :rtype: List[CustomField]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_module").format(model_slug=cls._module_slug, moduleId=module_id)
+        )
+        custom_fields = []
+        if response and response.ok:
+            for custom_field in response.json():
+                custom_fields.append(CustomField(**custom_field))
+        return custom_fields
+
+    @classmethod
+    def get_custom_fields_by_module_id(cls, parent_module_id: int) -> List["CustomField"]:
+        """
+        Get a list of custom fields by module ID
+
+        :param int parent_module_id: The ID of the module
+        :return: List of CustomField objects
+        :rtype: List[CustomField]
+        """
+        custom_fields = CustomField.get_list_by_module_id(module_id=cls.get_module_id())
+        for field in custom_fields:
+            data_field_list = CustomFieldsData.get_list_by_parent_id_and_module_id(
+                parent_id=parent_module_id, module_id=field.moduleId
+            )
+            for data in data_field_list:
+                if data.fieldId == field.id:
+                    field.data = data
+            if field.data:
+                field.data = update_keys_to_lowercase_first_letter(field.data)
+        return custom_fields
+
+
+class CustomFieldsData(RegScaleModel):
+    _module_slug = "customFieldsData"
+    id: Optional[int] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    isPublic: Optional[bool] = None
+    moduleId: Optional[int] = None
+    parentId: Optional[int] = None
+    field: Optional[CustomField] = None
+    fieldId: Optional[int] = None
+    fieldName: Optional[str] = None
+    fieldValue: Optional[str] = None
+    fieldDataType: Optional[str] = None
+    fieldRequired: Optional[bool] = None
+    disabled: Optional[bool] = None
+    tenantsId: Optional[int] = None
+    dateLastUpdated: Optional[str] = None
+
+    @classmethod
+    def get_by_module_id(cls, parent_id: int, module_id: int) -> Optional[List["CustomFieldsData"]]:
+        """
+        Get a list of custom fields by module ID.
+
+        :param int parent_id: The ID of the module parent id field
+        :param int module_id: The ID of the module
+        :return: A list of custom fields, None if no custom fields are found
+        :rtype: Optional[List[CustomFieldsData]]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_custom_fields_data_get").format(
+                model_slug=cls._module_slug, parentId=parent_id, moduleId=module_id
+            )
+        )
+        if response and response.ok:
+            return [CustomFieldsData(**data) for data in response.json()]
+        return None
+
+    @classmethod
+    def get_by_id(cls, cid: int, module_id: int) -> Optional["CustomFieldsData"]:
+        """
+        Get a list of custom fields by module ID.
+
+        :param int cid: The ID of the custom field
+        :param int module_id: The ID of the module
+        :return: A list of custom fields, None if no custom fields are found
+        :rtype: Optional[CustomFieldsData]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_custom_fields_data").format(
+                model_slug=cls._module_slug, id=cid, moduleId=module_id
+            )
+        )
+        if response and response.ok:
+            # print(response.json())
+            return CustomFieldsData(**response.json())
+        return None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the CustomFieldData model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_custom_fields_data="/api/{model_slug}/{id}/{moduleId}",
+            update_batch_post="/api/{model_slug}/update",
+            create_custom_field_data_post="/api/{model_slug}",
+            get_custom_fields_data_get="/api/{model_slug}/createCustomFieldsData/{parentId}/{moduleId}",
+            get_by_parent="/api/{model_slug}/{intParentID}/{strModule}",
+        )
+
+    @classmethod
+    def get_list_by_parent_id_and_module_id(cls, parent_id: int, module_id: int) -> List["CustomFieldsData"]:
+        """
+        Get a list of custom fields by module ID.
+
+        :param int parent_id: The ID of the parent
+        :param int module_id: The ID of the module
+        :return: A list of custom field datas
+        :rtype: List["CustomFieldsData"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_custom_fields_data_get").format(
+                model_slug=cls._module_slug, parentID=parent_id, moduleID=module_id
+            )
+        )
+        custom_fields = []
+        if response and response.ok:
+            for custom_field_data in response.json():
+                custom_fields.append(CustomFieldsData(**custom_field_data))
+        return custom_fields
+
+    @classmethod
+    def batch_update(cls, custom_data_fields: List["CustomFieldsData"]) -> bool:
+        """
+        Batch update custom fields data.
+
+        :param List[CustomFieldsData] custom_data_fields: The list of custom fields data
+        :return: Whether the batch update was successful
+        :rtype: bool
+        """
+        response = cls._get_api_handler().post(
+            endpoint=cls.get_endpoint("update_batch_post").format(model_slug=cls._module_slug),
+            data=[custom_data_field.dict() for custom_data_field in custom_data_fields],
+        )
+        if response and response.ok:
+            return True
+        else:
+            logger.error("Failed to batch update custom fields data")
+            return False
+
+
+class CustomFieldsSelectItem(RegScaleModel):
+    _module_slug = "customFieldsSelectItems"
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the CustomFieldSelectItem model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            create_items_post="/api/{model_slug}/items/{tenantId}",
+            update_items_put="/api/{model_slug}/items/{tenantId}",
+            get_items="/api/{model_slug}/items/{parentId}",
+            get_items_for_request="/api/{model_slug}/items/{parentId}/{moduleId}/{requestId}",
+            enable_item_put="/api/{model_slug}/enable/{tenantId}/{customFieldSelectItemId}/{enabled}",
+        )
+
+    id: Optional[int] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    isPublic: Optional[bool] = None
+    moduleId: Optional[int] = None
+    parentId: Optional[int] = None
+    fieldKey: Optional[str] = None
+    fieldValue: Optional[str] = None
+    tenantsId: Optional[int] = None
+    dateLastUpdated: Optional[str] = None
+    disabled: Optional[bool] = None
+    itemOrder: Optional[int] = None

regscale/models/regscale_models/data.py

@@ -0,0 +1,109 @@
+"""Data model class"""
+
+from enum import Enum
+from typing import List, Optional, cast
+
+from pydantic import Field, ConfigDict
+from requests import Response
+
+from regscale.core.app.utils.app_utils import (
+    get_current_datetime,
+    create_progress_object,
+)
+from .regscale_model import RegScaleModel, T
+from ...core.app.internal.model_editor import get_all_by_parent
+
+
+class DataListItem(RegScaleModel):
+    """
+    Data list item model class
+    """
+
+    id: int
+    dateCreated: str
+    dataType: str
+    dataSource: str
+
+
+class DataDataType(str, Enum):
+    """
+    Data data type enum
+    """
+
+    JSON = "JSON"
+    XML = "XML"
+    YAML = "YAML"
+
+    def __str__(self):
+        return self.value
+
+
+class Data(RegScaleModel):
+    """
+    Data model class
+    """
+
+    _module_slug = "data"
+    _unique_fields = [
+        ["parentId", "parentModule", "dataSource", "dataType"],
+    ]
+
+    id: Optional[int] = 0
+    createdById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateCreated: str = Field(default_factory=get_current_datetime)
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    isPublic: bool = True
+    dataSource: str
+    dataType: Optional[str] = None
+    rawData: Optional[str] = None
+    parentId: int
+    parentModule: str
+    tenantsId: int = 1
+    dateLastUpdated: str = Field(default_factory=get_current_datetime)
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Data model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            batch_create="/api/{model_slug}/batchCreate",
+            batch_update="/api/{model_slug}/batchUpdate",
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}/{strModule}",
+        )
+
+    @classmethod
+    def get_map(cls, plan_id: int, key_field: str = "parentId") -> dict[str, "Data"]:
+        """
+        Get the asset map for the asset and cache it in Redis.
+
+        :param int plan_id: Security Plan ID
+        :param str key_field: Key field to use, defaults to "identifier"
+        :return: Data Map
+        :rtype: dict[str, "Data"]
+
+        # TODO: Implement filter by plan_id in RegScale API
+        """
+        search_data = f"""query {{
+            data(skip: 0, take: 50) {{
+                items {{
+                    {cls.build_graphql_fields()}
+                }}
+                totalCount
+                pageInfo {{
+                    hasNextPage
+                }}
+            }}
+        }}"""
+        response = cls._get_api_handler().graph(query=search_data)
+        objects = cast(List["Data"], cls._handle_graph_response(response))
+        return_assets = {}
+        for obj in objects:
+            identifier = getattr(obj, key_field, None)
+            if identifier:
+                return_assets[identifier] = obj
+
+        return {k: v.model_dump_json() for k, v in return_assets.items()}

regscale/models/regscale_models/data_center.py

@@ -0,0 +1,40 @@
+"""DataCenter model for RegScale."""
+
+import warnings
+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 DataCenter(RegScaleModel):
+    """DataCenter pydantic BaseModel."""
+
+    _module_slug = "datacenters"
+
+    id: int = 0
+    uuid: str = ""
+    facilityId: int
+    parentId: int
+    parentModule: str
+    isPublic: bool = True
+    facility: str = ""
+
+    def post(self, app: Application) -> dict:
+        """
+        Post a DataCenter to RegScale
+
+        :param Application app: The application instance
+        :return: The response from the API
+        :rtype: dict
+        """
+        warnings.warn(
+            "The 'post' method is deprecated, use 'create' method instead",
+            DeprecationWarning,
+        )
+        api = Api()
+        url = urljoin(app.config.get("domain", ""), "/api/datacenters")
+        data = self.dict()
+        response = api.post(url, json=data)
+        return response.json()

regscale/models/regscale_models/deviation.py

@@ -0,0 +1,203 @@
+import concurrent.futures
+import logging
+from typing import List, Optional
+
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+
+from .. import Property
+from .regscale_model import RegScaleModel
+
+logger = logging.getLogger("regscale")
+
+
+class Deviation(RegScaleModel):
+    """
+    Deviation model class
+    """
+
+    _module_slug = "deviations"
+    _unique_fields = [
+        ["parentIssueId", "deviationType", "rationale", "requestedImpactRating", "vulnerabilityId"],
+    ]
+    _parent_id_field = "parentIssueId"
+
+    parentIssueId: int  # Required
+    requestedImpactRating: str  # Required
+    deviationType: str  # Required
+    rationale: str  # Required
+
+    id: int = 0
+    otherIdentifier: Optional[str] = None
+    isPublic: bool = True
+    uuid: Optional[str] = None
+    dateSubmitted: Optional[str] = None
+    evidenceDescription: Optional[str] = None
+    operationalImpacts: Optional[str] = None
+    riskJustification: Optional[str] = None
+    tmpExploitCodeMaturity: Optional[str] = None
+    tmpRemediationLevel: Optional[str] = None
+    tmpReportConfidence: Optional[str] = None
+    envConfidentiality: Optional[str] = None
+    envIntegrity: Optional[str] = None
+    envAvailability: Optional[str] = None
+    envAttackVector: Optional[str] = None
+    envAttackComplexity: Optional[str] = None
+    envPrivilegesRequired: Optional[str] = None
+    envUserInteraction: Optional[str] = None
+    envScope: Optional[str] = None
+    envModConfidentiality: Optional[str] = None
+    envModIntegrity: Optional[str] = None
+    envModAvailability: Optional[str] = None
+    vulnerabilityId: Optional[str] = None
+    baseScore: Optional[float] = None
+    temporalScore: Optional[float] = None
+    environmentalScore: Optional[float] = None
+    envAttackVectorExplanation: Optional[str] = None
+    envAttackComplexityExplanation: Optional[str] = None
+    envPrivilegesRequiredExplanation: Optional[str] = None
+    envUserInteractionExplanation: Optional[str] = None
+    envConfidentialityExplanation: Optional[str] = None
+    envIntegrityExplanation: Optional[str] = None
+    envAvailabilityExplanation: Optional[str] = None
+    tmpExploitCodeMaturityExplanation: Optional[str] = None
+    tmpRemediationLevelExplanation: Optional[str] = None
+    tmpReportConfidenceExplanation: Optional[str] = None
+    baseSeverity: Optional[str] = None
+    temporalSeverity: Optional[str] = None
+    environmentalSeverity: Optional[str] = None
+    finalVectorString: Optional[str] = None
+    overallRiskReductionExplanation: Optional[str] = None
+    additionalInformation: Optional[str] = None
+    drNumber: Optional[str] = None
+    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)
+
+    @classmethod
+    def mapping(cls) -> dict:
+        """
+        Get the mapping for the Deviation model.
+
+        :return: A dictionary of mappings
+        :rtype: dict
+        """
+        return {
+            "FP": "False Positive (FP)",
+            "FP_RA": "False Positive (FP)",
+            "OR": "Operational Requirements (OR)",
+            "OR_RA": "RA & OR",
+            "OR RA": "RA & OR",
+            "RA": "Risk Adjustment (RA)",
+        }
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Deviations model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_by_issue="/api/{model_slug}/getbyIssue/{intParentID}/{includeDrNumber}",
+            get_all_by_security_plan="/api/{model_slug}/getAllBySecurityPlan/{sspId}/{includeDrNumber}",
+            export_deviation_by_ssp="/api/{model_slug}/getAllByPart/{intParentID}/{strModule}/{strType}/{strPart}",
+        )
+
+    @classmethod
+    def get_by_issue(cls, issue_id: int, include_dr_number: bool = True) -> Optional["Deviation"]:
+        """
+        Get a deviation by issue id
+
+        :param int issue_id: Ths issue to search for
+        :param bool include_dr_number: Include DR number in the response
+        :return: A list of deviations
+        :rtype: Optional["Deviation"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_by_issue").format(intParentID=issue_id, includeDrNumber=include_dr_number)
+        )
+        if response and response.status_code == 200:
+            return cls(**response.json())
+        return None
+
+    @classmethod
+    def get_by_security_plan(cls, ssp_id: int, include_dr_number: bool = True) -> List["Deviation"]:
+        """
+        Get a list of deviations by ssp id
+
+        :param int ssp_id: Ths ssp to search for
+        :return: A list of deviations
+        :rtype: Optional["Deviation"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_security_plan").format(
+                sspId=ssp_id, includeDrNumber=include_dr_number
+            )
+        )
+        if response and response.status_code == 200:
+            return [cls(**res) for res in response.json()]
+        return []
+
+    @classmethod
+    def get_dr_ids(cls, issue_id: int) -> Optional[Property]:
+        """
+        Get a list of control implementations by plan ID.
+
+        :param int issue_id: Issue Id
+        :return: A single Property object with the DR number if it exists or None
+        :rtype: Optional[Property]
+        """
+        properties = [
+            prop
+            for prop in Property.get_all_by_parent(parent_id=issue_id, parent_module="issues")
+            if prop.key == "dr_number"
+        ]
+        if properties:
+            return properties.pop()
+        return None
+
+    @classmethod
+    def get_existing_deviations_by_ssp(
+        cls, ssp_id: int, issue_ids: List[int], poam_map: dict = None
+    ) -> List["Deviation"]:
+        """
+        Get existing deviations by SSP
+
+        :param int ssp_id: Security Plan ID
+        :param List[int] issue_ids: List of issue IDs
+        :param dict poam_map: POAM map, optional
+        :return: list of deviations
+        :rtype: List["Deviation"]
+        """
+        # poam_map description:
+        # The main dict key of `id_other_identifier_map` are the `otherIdentifier` of each issue.
+        # The values of `id_other_identifier_map` are dictionaries themselves, with the following structure:
+        # The values are dictionaries with the following keys
+        # - `id`: The ID of the issue in RegScale
+        # - `dr_number`: The DR number of the issue
+
+        # CAUTION: This needs to be moved to platform specific code (see REG-9998)
+        logger.info("Looking up existing RegScale deviations for SSP# %i.. ", ssp_id)
+        with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
+            properties = (
+                [prop for prop in list(executor.map(cls.get_dr_ids, issue_ids)) if prop] if not poam_map else []
+            )
+            deviations = [dev for dev in list(executor.map(cls.get_by_issue, issue_ids)) if dev]
+
+        for deviation in deviations:
+            if not poam_map:
+                prop = [prop for prop in properties if prop.parentId == deviation.parentIssueId]
+                if prop:
+                    deviation.extra_data = {"dr_number": prop.pop().value}
+                else:
+                    deviation.extra_data = {"dr_number": None}
+            else:
+                match = [val for val in poam_map.values() if val.get("id") == deviation.parentIssueId]
+                if match:
+                    deviation.extra_data = {"dr_number": match.pop().get("dr_number")}
+
+        return deviations

regscale/models/regscale_models/email.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Class for emails to send emails in RegScale platform"""
+
+from typing import Optional
+
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.utils.app_utils import create_logger
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class Email(RegScaleModel):
+    """Class for email capabilities via RegScale platform"""
+
+    _module_slug = "email"
+    _exclude_graphql_fields = ["tenantsId"]
+
+    to: str
+    subject: str
+    id: Optional[int] = 0
+    fromEmail: str = Field(description="Cannot use from since it is a reserved word in Python", alias="from")
+    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
+    cc: Optional[str] = ""
+    body: Optional[str] = ""
+    dateSent: Optional[str] = Field(default_factory=get_current_datetime)
+    tenantsId: Optional[int] = 1
+    emailSenderId: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Issues model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_domain="/api/{model_slug}/getDomain",
+            get_admin_email="/api/{model_slug}/getAdminEmail",
+            filter_my_email="/api/{model_slug}/filterMyEmail/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+            filter_email="/api/{model_slug}/filterEmail/{strUser}/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+            find_my_email="/api/{model_slug}/findMyEmail/{intID}",
+        )
+
+    def send(self) -> bool:
+        """
+        Send the email
+
+        :return: Whether the email was sent successfully
+        :rtype: bool
+        """
+        logger = create_logger()
+        endpoint = self.get_endpoint("insert")
+        response = self._get_api_handler().post(endpoint=endpoint, data=self.dict())
+        if response and response.ok:
+            return True
+        import json
+
+        logger.error(
+            f"Failed to create {self.__class__.__name__}\n Endpoint: {endpoint}\n Payload: "
+            f"{json.dumps(self.dict(), indent=2)}",
+            exc_info=True,
+        )
+        if response and not response.ok:
+            logger.error(f"Response Error: Code #{response.status_code}: {response.reason}\n{response.text}")
+            return False
+        if response is None:
+            error_msg = "Response was None"
+            logger.error(error_msg)
+            return False
+        error_msg = f"Response Code: {response.status_code}:{response.reason} - {response.text}"
+        logger.error(error_msg)
+        return False
+
+    def create(self, _=False) -> bool:
+        """
+        Create the email
+
+        :return: Email object
+        :rtype: Email
+        """
+        return self.send()
+
+    def delete(self) -> bool:
+        """
+        Delete is not supported for emails, returns False
+
+        :return: False because it is not supported
+        :rtype: bool
+        """
+        return False