regscale-cli 6.16.0.0__py3-none-any.whl

regscale/models/regscale_models/vulnerability_mapping.py

@@ -0,0 +1,162 @@
+"""Module for defining the VulnerabilityMapping model."""
+
+from __future__ import annotations
+
+from typing import Optional, List, Dict, Any
+
+from pydantic import Field, ConfigDict
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from regscale.models.regscale_models.search import Search
+
+
+class VulnerabilityMapping(RegScaleModel):
+    """Represents a mapping between vulnerabilities and assets."""
+
+    _module_slug = "vulnerabilityMappings"
+    _unique_fields = [
+        ["vulnerabilityId", "assetId", "scanId"],
+    ]
+    _parent_id_field = "scanId"
+
+    uuid: Optional[str] = None
+    vulnerabilityId: int
+    assetId: int
+    scanId: Optional[int] = None
+    securityPlansId: Optional[int] = None
+    status: Optional[str] = Field(max_length=450)
+    firstSeen: str
+    lastSeen: str
+    dateClosed: Optional[str] = None
+    isPublic: bool = Field(default=False)
+    createdById: str = Field(default_factory=RegScaleModel.get_user_id)
+    lastUpdatedById: str = Field(default_factory=RegScaleModel.get_user_id)
+    dateCreated: str
+    dateLastUpdated: Optional[str] = None
+    tenantsId: int = Field(default=0)
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the API.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            find_by_vulnerability="/api/{model_slug}/findByVulnerability/{vulnerability_id}",
+            find_by_asset="/api/{model_slug}/findByAsset/{asset_id}",
+            find_by_issue="/api/{model_slug}/findByIssue/{issue_id}",
+            find_by_scan="/api/{model_slug}/findByScan/{scan_id}",
+        )
+
+    @classmethod
+    def find_by_vulnerability(cls, vulnerability_id: int, status: str = "all") -> List["VulnerabilityMapping"]:
+        """
+        Get vulnerability mappings by vulnerability ID.
+
+        :param int vulnerability_id: The vulnerability ID
+        :param str status: The status filter (default is "all")
+        :return: A list of vulnerability mappings with the given vulnerability ID
+        :rtype: List[VulnerabilityMapping]
+        """
+        endpoint = cls.get_endpoint("find_by_vulnerability").format(vulnerability_id=vulnerability_id)
+        params = {"status": status}
+        response = cls._get_api_handler().get(endpoint, params=params)
+        results = cls._handle_list_response(response)
+        for result in results:
+            cls.cache_object(result)
+        return results
+
+    @classmethod
+    def find_by_asset(cls, asset_id: int, status: str = "all") -> List["VulnerabilityMapping"]:
+        """
+        Get vulnerability mappings by asset ID.
+
+        :param int asset_id: The asset ID
+        :param str status: The status filter (default is "all")
+        :return: A list of vulnerability mappings with the given asset ID
+        :rtype: List[VulnerabilityMapping]
+        """
+        endpoint = cls.get_endpoint("find_by_asset").format(asset_id=asset_id)
+        params = {"status": status}
+        response = cls._get_api_handler().get(endpoint, params=params)
+        results = cls._handle_list_response(response)
+        for result in results:
+            cls.cache_object(result)
+        return results
+
+    @classmethod
+    def find_by_issue(cls, issue_id: int, status: str = "all") -> List["VulnerabilityMapping"]:
+        """
+        Get vulnerability mappings by issue ID.
+
+        :param int issue_id: The issue ID
+        :param str status: The status filter (default is "all")
+        :return: A list of vulnerability mappings with the given issue ID
+        :rtype: List[VulnerabilityMapping]
+        """
+        endpoint = cls.get_endpoint("find_by_issue").format(issue_id=issue_id)
+        params = {"status": status}
+        response = cls._get_api_handler().get(endpoint, params=params)
+        results = cls._handle_list_response(response)
+        for result in results:
+            cls.cache_object(result)
+        return results
+
+    @classmethod
+    def find_by_scan(cls, scan_id: int, status: str = "all") -> List["VulnerabilityMapping"]:
+        """
+        Get vulnerability mappings by scan ID.
+
+        :param int scan_id: The scan ID
+        :param str status: The status filter (default is "all")
+        :return: A list of vulnerability mappings with the given scan ID
+        :rtype: List[VulnerabilityMapping]
+        """
+        endpoint = cls.get_endpoint("find_by_scan").format(scan_id=scan_id)
+        params = {"status": status}
+        response = cls._get_api_handler().get(endpoint, params=params)
+        results = cls._handle_list_response(response)
+        for result in results:
+            cls.cache_object(result)
+        return results
+
+    def create_unique(self) -> "VulnerabilityMapping":
+        """
+        Create a VulnerabilityMapping object, using cache to check for existing records.
+
+        :return: The created or existing VulnerabilityMapping object
+        :rtype: VulnerabilityMapping
+        """
+        # Check if the object already exists in the cache
+        cache_key = self._get_cache_key(self)
+        with self._get_lock(cache_key):
+            cached_object = self.get_cached_object(cache_key)
+            if cached_object:
+                return cached_object
+
+            # If not found, create a new object
+            new_object = super().create()
+            self.cache_object(new_object)
+            return new_object
+
+    @classmethod
+    def get_all_by_parent(
+        cls,
+        parent_id: int,
+        parent_module: Optional[str] = None,
+        search: Optional[Search] = None,
+        **kwargs: Dict[str, Any],
+    ) -> List["VulnerabilityMapping"]:
+        """
+        Get all vulnerability mappings for a given parent.
+
+        :param int parent_id: The ID of the parent (scan ID in this case)
+        :param Optional[str] parent_module: The module of the parent (not used for VulnerabilityMapping)
+        :param Optional[Search] search: Search string (not used for VulnerabilityMapping)
+        :return: A list of vulnerability mappings for the given parent
+        :rtype: List[VulnerabilityMapping]
+        """
+        status = kwargs.get("status", "all")
+        return cls.find_by_scan(scan_id=parent_id, status=status)

regscale/models/regscale_models/workflow.py

@@ -0,0 +1,55 @@
+"""RegScale Workflow model"""
+
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+from requests import JSONDecodeError
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.utils.app_utils import create_logger
+
+
+class Workflow(BaseModel):
+    id: int = 0
+    name: Optional[str] = None
+    status: Optional[str] = None
+    startDate: Optional[str] = None
+    endDate: Optional[str] = None
+    currentStep: int = 0
+    comments: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = None
+    lastUpdatedById: Optional[str] = None
+    isPublic: bool = True
+    dateLastUpdated: Optional[str] = None
+    ownerId: Optional[str] = None
+    atlasModule: Optional[str] = None
+    parentId: Optional[int] = None
+    workflowInstanceSteps: List[str] = Field(default_factory=list)
+
+    def insert_workflow(self, app: Application, template_id: int) -> Optional["Workflow"]:
+        """
+        Insert a workflow into the database
+
+        :param Application app: Application instance
+        :param int template_id: Workflow template ID in RegScale
+        :return: Newly created Workflow object, or None if unsuccessful
+        :rtype: Optional[Workflow]
+        """
+        api = Api()
+        # Convert the model to a dictionary
+        data = self.dict()
+        url = f"{app.config['domain']}/api/workflowInstances/createFromTemplate/{template_id}"
+        # Make the API call
+        response = api.post(url=url, json=data)
+
+        # Check the response
+        if not response.ok:
+            response.raise_for_status()
+        try:
+            workflow = Workflow(**response.json())
+        except JSONDecodeError as jex:
+            logger = create_logger()
+            logger.error("Unable to read workflow:\n%s", jex)
+        return workflow or None

regscale/models/regscale_models/workflow_action.py

@@ -0,0 +1,34 @@
+"""
+This module contains the WorkflowAction model.
+"""
+
+from typing import Optional
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from pydantic import ConfigDict
+
+
+class WorkflowAction(RegScaleModel):
+    _module_slug = "workflowActions"
+
+    id: Optional[int] = None
+    value: Optional[str] = None
+    recordId: Optional[int] = None
+    recordModule: Optional[str] = None
+    days: Optional[int] = None
+    recordTitle: Optional[str] = None
+    workflowTemplateId: Optional[int] = None
+    workflowInstanceId: Optional[int] = None
+    isPublic = True
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the WorkflowAction model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_actions="/api/{model_slug}/getActions/{strModule}",
+        )

regscale/models/regscale_models/workflow_instance.py

@@ -0,0 +1,269 @@
+import logging
+from enum import Enum
+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
+from workflow_instance_step import WorkflowInstanceStep
+from workflow_template import WorkflowTemplate
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowInstanceStatus(Enum):
+    """
+    Enum for workflow instance status.
+    """
+
+    PENDING = "Pending"
+    APPROVED = "Approved"
+    REJECTED = "Rejected"
+    COMPLETE = "Complete"
+
+
+class WorkflowInstance(RegScaleModel):
+    _module_slug = "workflowInstances"
+
+    id: Optional[int] = None
+    name: Optional[str] = None
+    status: Optional[str] = Field(default=WorkflowInstanceStatus.PENDING.value)
+    startDate: Optional[str] = None
+    endDate: Optional[str] = None
+    currentStep: Optional[int] = None
+    comments: 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)
+    isPublic: Optional[bool] = True
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    ownerId: Optional[str] = None
+    parentId: Optional[int] = None
+    atlasModule: Optional[str] = None
+    workflowInstanceSteps: Optional[List[WorkflowInstanceStep]] = None
+    tenantsId: Optional[int] = 1
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the WorkflowInstance model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_by_parent="/api/{model_slug}/filterWorkflowInstanceByParentId/{intParentID}/{strModule}/id/descending/1/100",
+            get_count="/api/{model_slug}/getCount",
+            get_open="/api/{model_slug}/getOpen",
+            get_by_status="/api/{model_slug}/getByStatus",
+            user_open_items_days="/api/{model_slug}/userOpenItemsDays/{strOwner}/{intDays}",
+            filter_workflow_instances="/api/{model_slug}/filterWorkflowInstances/{strSearch}/{strStatus}/{strOwner}/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+            filter_workflow_instances_by_user="/api/{model_slug}/filterWorkflowInstancesByUser/{strUser}/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+            approve_step_put="/api/{model_slug}/approveStep/{strUserId}",
+            submit_put="/api/{model_slug}/submit/{userId}",
+            create_from_module_post="/api/{model_slug}/createFromModule/{intTemplateId}/{strUserId}",
+            create_custom_workflow_post="/api/{model_slug}/createCustomWorkflow/{strModule}/{intParentId}",
+            reject_step_put="/api/{model_slug}/rejectStep/{strUserId}",
+            create_from_template_post="/api/{model_slug}/createFromTemplate/{intTemplateId}",
+        )
+
+    @classmethod
+    def get_workflows_by_parent(cls, parent_id: int, parent_module: str) -> List["WorkflowInstance"]:
+        """
+        Get all workflows by parent.
+
+        :param int parent_id: The ID of the parent
+        :param str parent_module: The module of the parent
+        :return: A list of workflows
+        :rtype: List[WorkflowInstance]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_by_parent").format(intParentID=parent_id, strModule=parent_module)
+        )
+        if response and response.ok:
+            json_data = response.json()
+            items = json_data.get("items", [])
+            return [WorkflowInstance(**workflow) for workflow in items]
+        return []
+
+    @classmethod
+    def find_by_unique(cls, parent_id: int, parent_module: str, name: str) -> Optional["WorkflowInstance"]:
+        """
+        Find a object by unique query.
+        :param int parent_id: The ID of the parent
+        :param str parent_module: The module of the parent
+        :param str name: The name of the object
+        :return: The functional role
+        :rtype: FunctionalRole
+        """
+        for instance in cls.get_all_by_parent(parent_id=parent_id, parent_module=parent_module):
+            if instance.name == name:
+                return instance
+        return None
+
+    @classmethod
+    def create_from_template(cls, template_id: int) -> Optional[int]:
+        """
+        Create a workflow instance from a template.
+
+        :param int template_id: The ID of the template
+        :return: The created workflow instance id
+        :rtype: Optional[int]
+        """
+        workflow_template = WorkflowTemplate.get_object(object_id=template_id)
+        if not workflow_template:
+            logger.error(f"Failed to find workflow template {template_id}")
+            return None
+        response = cls._get_api_handler().post(
+            endpoint=cls.get_endpoint("create_from_template_post").format(
+                model_slug=cls._module_slug, intTemplateId=template_id
+            ),
+            data=workflow_template.model_dump(),
+        )
+        if response and response.ok:
+            return int(response.text)
+        else:
+            logger.error(f"Failed to create workflow instance from template {template_id}")
+            return None
+
+    @classmethod
+    def create_custom_workflow_from_template(
+        cls, template_id: int, parent_id: int, parent_module: str
+    ) -> Optional["WorkflowInstance"]:
+        """
+        Create a workflow instance from a template.
+
+        :param int template_id: The ID of the template
+        :param int parent_id: The ID of the parent
+        :param str parent_module: The module of the parent
+        :return: The created workflow instance id
+        :rtype: Optional[int]
+        """
+        workflow_template = WorkflowTemplate.get_object(object_id=template_id)
+        steps = workflow_template.workflowTemplateSteps
+        if not workflow_template:
+            logger.error(f"Failed to find workflow template {template_id}")
+            return None
+        response = cls._get_api_handler().post(
+            endpoint=cls.get_endpoint("create_custom_workflow_post").format(
+                model_slug=cls._module_slug, strModule=parent_module, intParentId=parent_id
+            ),
+            data=[step.model_dump() for step in steps],
+        )
+        if response and response.ok:
+            return WorkflowInstance(**response.json())
+        else:
+            logger.error(f"Failed to create workflow instance from template {template_id}")
+            return None
+
+    @classmethod
+    def create_custom_workflow_from_template_with_group(
+        cls, template_id: int, parent_id: int, parent_module: str, group_id: int, group_name: str
+    ) -> Optional["WorkflowInstance"]:
+        """
+        Create a workflow instance from a template.
+
+        :param int template_id: The ID of the template
+        :param int parent_id: The ID of the parent
+        :param str parent_module: The module of the parent
+        :param int group_id: The ID of the group
+        :param str group_name: The name of the group
+        :return: The created workflow instance id
+        :rtype: Optional[int]
+        """
+        workflow_template = WorkflowTemplate.get_object(object_id=template_id)
+        steps = workflow_template.workflowTemplateSteps
+        for step in steps:
+            if step.name == "Automated Conflict of Interest Check":
+                continue
+            step.name = f"{step.name} - {group_name}" if group_name else step.name
+            step.groupsId = group_id
+
+        if not workflow_template:
+            logger.error(f"Failed to find workflow template {template_id}")
+            return None
+        response = cls._get_api_handler().post(
+            endpoint=cls.get_endpoint("create_custom_workflow_post").format(
+                model_slug=cls._module_slug, strModule=parent_module, intParentId=parent_id
+            ),
+            data=[step.model_dump() for step in steps],
+        )
+        if response and response.ok:
+            return WorkflowInstance(**response.json())
+        else:
+            logger.error(f"Failed to create workflow instance from template {template_id}")
+            return None
+
+    def create_custom_workflow(self, module: str, parent_id: int) -> Optional[int]:
+        """
+        Create a custom workflow instance.
+
+        :param str module: The module of the parent
+        :param int parent_id: The ID of the parent
+        :return: The created workflow instance id
+        :rtype: Optional[int]
+        """
+        response = selfcls._get_api_handler().post(
+            endpoint=self.get_endpoint("create_custom_workflow_post").format(
+                model_slug=self._module_slug, strModule=module, intParentId=parent_id
+            ),
+            data=self.dict(),
+        )
+        if response and response.ok:
+            return int(response.text)
+        else:
+            logger.error(f"Failed to create custom workflow instance from module {module}. Error: {response.text}")
+            return None
+
+    def approve_step(self, user_id: str) -> bool:
+        """
+        Approve a step in a workflow instance.
+
+        :param str user_id: The ID of the user
+        :return: True if successful
+        :rtype: bool
+        """
+        response = selfcls._get_api_handler().put(
+            endpoint=self.get_endpoint("approve_step_put").format(model_slug=self._module_slug, strUserId=user_id),
+            data=self.dict(),
+        )
+        if getattr(response, "ok", False):
+            return True
+        else:
+            logger.error(f"Failed to approve step for {self.name}")
+            return False
+
+    def reject_step(self, user_id: str) -> bool:
+        """
+        Reject a step in a workflow instance.
+
+        :param str user_id: The ID of the user
+        :return: True if successful
+        :rtype: bool
+        """
+        response = selfcls._get_api_handler().put(
+            endpoint=self.get_endpoint("reject_step_put").format(model_slug=self._module_slug, strUserId=user_id),
+            data=self.dict(),
+        )
+        if getattr(response, "ok", False):
+            return True
+        else:
+            logger.error(f"Failed to reject step for {self.name}")
+            return False
+
+    def approve_all_steps(self, user_id: str) -> None:
+        """
+        Approve all steps in a workflow instance.
+
+        :param str user_id: The ID of the user
+        :rtype: None
+        """
+        for step in WorkflowInstanceStep.get_all_by_parent(
+            parent_id=self.id,
+            parent_module=self.get_module_slug(),
+        ):
+            if step.order not in [0, 1000]:
+                self.currentStep = step.order
+                self.comments = "<p>I Approve</p>"
+                self.approve_step(user_id=user_id)

regscale/models/regscale_models/workflow_instance_step.py

@@ -0,0 +1,114 @@
+"""
+This module contains the WorkflowInstanceStep model class that represents a workflow instance step in the RegScale application.
+"""
+
+from typing import Optional, Union
+
+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
+from enum import Enum
+
+
+class WorkflowInstanceStepType(str, Enum):
+    """
+    Enum for workflow instance step type.
+    """
+
+    MANAGER = "Manager"
+    GROUP = "Group"
+
+
+class WorkflowInstanceStepExecutionType(str, Enum):
+    """
+    Enum for workflow instance step execution type.
+    """
+
+    SEQUENTIAL = "Sequential"
+    PARALLEL = "Parallel"
+
+
+class WorkflowInstanceStepStatus(str, Enum):
+    """
+    Enum for workflow instance step status.
+    """
+
+    PENDING = "Pending"
+    APPROVED = "Approved"
+    REJECTED = "Rejected"
+    COMPLETE = "Complete"
+    SUBMITTED = "Submitted"
+
+
+class WorkflowInstanceStep(RegScaleModel):
+    _module_slug = "workflowInstanceSteps"
+
+    id: Optional[int] = None
+    workflowInstanceId: Optional[int] = None
+    name: Optional[str] = None
+    comments: Optional[str] = None
+    order: Optional[int] = 1
+    status: Optional[str] = None
+    startDate: Optional[str] = None
+    endDate: Optional[str] = None
+    actionType: Optional[str] = None
+    executionType: 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)
+    isPublic: Optional[bool] = True
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    groupsId: Optional[int] = None
+    tenantsId: Optional[int] = 1
+    stepType: Optional[str] = None
+    assignedToId: Optional[str] = None
+    functionalRoleId: Optional[int] = None
+    parentId: Optional[int] = None
+    parentModule: Optional[str] = None
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the WorkflowInstanceStep model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_by_parent="/api/{model_slug}/getByParent/{intParentID}",
+            filter_workflow_instance_steps_by_parent="/api/{model_slug}/filterWorkflowInstanceStepsByParent/{intWorkflowInstanceID}/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+            update_workflow_instance_step_put="/api/{model_slug}/{id}",
+            get_workflow_instance_step="/api/{model_slug}/{id}",
+        )
+
+    @classmethod
+    def find_by_unique(cls, workflow_instance_id: int, field_name: str, field_value: Union[str, int]):
+        """
+        Find a object by unique query.
+        :param workflow_instance_id: The workflow instance ID
+        :param field_name: The field name
+        :param field_value: The field value
+        :return: The functional role
+        :rtype: FunctionalRole
+        """
+        for instance in cls.get_all_by_parent(parent_id=workflow_instance_id, parent_module=None):
+            if getattr(instance, field_name) == field_value:
+                return instance
+        return None
+
+    @classmethod
+    def get_by_parent(cls, parent_id: int):
+        """
+        Get workflow instance steps by parent ID.
+
+        :param parent_id: The parent ID
+        :return: A list of workflow instance steps
+        :rtype: List[WorkflowInstanceStep]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_by_parent").format(model_slug=cls._module_slug, intParentID=parent_id)
+        )
+        if response and response.ok:
+            return [WorkflowInstanceStep(**step) for step in response.json()]
+        return []

regscale/models/regscale_models/workflow_template.py

@@ -0,0 +1,58 @@
+"""
+This module contains the WorkflowTemplate model.
+"""
+
+from typing import Optional, List
+
+from pydantic import ConfigDict, Field
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+from workflow_template_step import WorkflowTemplateStep
+
+
+class WorkflowTemplate(RegScaleModel):
+    _module_slug = "workflowTemplates"
+
+    id: Optional[int] = None
+    name: Optional[str] = None
+    status: Optional[str] = None
+    createdById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateCreated: Optional[str] = None
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    isPublic: Optional[bool] = None
+    dateLastUpdated: Optional[str] = None
+    atlasModule: Optional[str] = None
+    workflowTemplateSteps: Optional[List[WorkflowTemplateStep]] = None
+    tenantsId: int = 1
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the WorkflowTemplate model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_count="/api/{model_slug}/getCount",
+            get_by_atlas_module="/api/{model_slug}/getByAtlasModule/{strModule}",
+            filter_workflow_templates="/api/{model_slug}/filterWorkflowTemplates/{strSearch}/{strSortBy}/{strDirection}/{intPage}/{intPageSize}",
+        )
+
+    @classmethod
+    def get_by_module_slug(cls, module: str) -> List["WorkflowTemplate"]:
+        """
+        Get all workflow templates by atlas module.
+
+        :param str module: The module of the parent
+        :return: A list of workflow templates
+        :rtype: List["WorkflowTemplate"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_by_atlas_module").format(model_slug=cls._module_slug, strModule=module)
+        )
+        if response and response.ok:
+            return [cls(**o) for o in response.json()]
+        else:
+            cls.log_response_error(response=response)
+            return []