binalyze-air-sdk 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

binalyze_air/apis/policies.py

@@ -0,0 +1,186 @@
+"""
+Policies API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any, Union
+from ..http_client import HTTPClient
+from ..models.policies import (
+    Policy, PolicyFilter, PolicyAssignment, PolicyExecution,
+    CreatePolicyRequest, UpdatePolicyRequest, AssignPolicyRequest
+)
+from ..queries.policies import (
+    ListPoliciesQuery,
+    GetPolicyQuery,
+    GetPolicyAssignmentsQuery,
+    GetPolicyExecutionsQuery,
+)
+from ..commands.policies import (
+    CreatePolicyCommand,
+    UpdatePolicyCommand,
+    DeletePolicyCommand,
+    ActivatePolicyCommand,
+    DeactivatePolicyCommand,
+    AssignPolicyCommand,
+    UnassignPolicyCommand,
+    ExecutePolicyCommand,
+)
+
+
+class PoliciesAPI:
+    """Policies API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def list(self, filter_params: Optional[PolicyFilter] = None, organization_ids: Optional[List[int]] = None) -> List[Policy]:
+        """List policies with optional filtering."""
+        query = ListPoliciesQuery(self.http_client, filter_params, organization_ids)
+        result = query.execute()
+        # Extract the policies list from the paginated response
+        if hasattr(result, 'entities'):
+            return result.entities
+        elif isinstance(result, list):
+            return result
+        else:
+            return []
+    
+    def get(self, policy_id: str) -> Policy:
+        """Get a specific policy by ID."""
+        query = GetPolicyQuery(self.http_client, policy_id)
+        return query.execute()
+    
+    def get_assignments(self, policy_id: str) -> List[PolicyAssignment]:
+        """Get policy assignments."""
+        query = GetPolicyAssignmentsQuery(self.http_client, policy_id)
+        return query.execute()
+    
+    def get_executions(self, policy_id: str) -> List[PolicyExecution]:
+        """Get policy executions."""
+        query = GetPolicyExecutionsQuery(self.http_client, policy_id)
+        return query.execute()
+    
+    def get_match_stats(self, filter_params: Optional[Dict[str, Any]] = None, organization_ids: Optional[List[int]] = None) -> Dict[str, Any]:
+        """Get policy match statistics with filtering.
+        
+        Args:
+            filter_params: Optional filter parameters (name, platform, tags, etc.)
+            organization_ids: List of organization IDs (defaults to [0])
+        
+        Returns:
+            Dictionary containing policy match statistics
+        """
+        try:
+            # Fix API-001: Ensure organizationIds are provided to prevent errors
+            if organization_ids is None or len(organization_ids) == 0:
+                organization_ids = [0]  # Default to organization 0
+            
+            # Build payload with default filter structure
+            payload = {
+                "name": "",
+                "searchTerm": "",
+                "ipAddress": "",
+                "groupId": "",
+                "groupFullPath": "",
+                "managedStatus": [],
+                "isolationStatus": [],
+                "platform": [],
+                "issue": "",
+                "onlineStatus": [],
+                "tags": [],
+                "version": "",
+                "policy": "",
+                "includedEndpointIds": [],
+                "excludedEndpointIds": [],
+                "organizationIds": organization_ids
+            }
+            
+            # Apply custom filter parameters if provided
+            if filter_params:
+                for key, value in filter_params.items():
+                    if key in payload:
+                        payload[key] = value
+            
+            # Use correct API endpoint: POST policies/match-stats (not GET policies/stats)
+            response = self.http_client.post("policies/match-stats", json_data=payload)
+            return response
+            
+        except Exception as e:
+            # Return a simulated response for testing
+            return {
+                "success": False,
+                "error": str(e),
+                "result": []
+            }
+    
+    # COMMANDS (Write operations)
+    def create(self, policy_data: Union[CreatePolicyRequest, Dict[str, Any]]) -> Policy:
+        """Create a new policy."""
+        command = CreatePolicyCommand(self.http_client, policy_data)
+        return command.execute()
+    
+    def update(self, policy_id: str, update_data: Union[UpdatePolicyRequest, Dict[str, Any]]) -> Policy:
+        """Update an existing policy."""
+        command = UpdatePolicyCommand(self.http_client, policy_id, update_data)
+        return command.execute()
+    
+    def delete(self, policy_id: str) -> Dict[str, Any]:
+        """Delete a policy."""
+        command = DeletePolicyCommand(self.http_client, policy_id)
+        return command.execute()
+    
+    def activate(self, policy_id: str) -> Policy:
+        """Activate a policy."""
+        command = ActivatePolicyCommand(self.http_client, policy_id)
+        return command.execute()
+    
+    def deactivate(self, policy_id: str) -> Policy:
+        """Deactivate a policy."""
+        command = DeactivatePolicyCommand(self.http_client, policy_id)
+        return command.execute()
+    
+    def assign(self, assignment_data: Union[AssignPolicyRequest, Dict[str, Any]]) -> Dict[str, Any]:
+        """Assign policy to endpoints."""
+        command = AssignPolicyCommand(self.http_client, assignment_data)
+        return command.execute()
+    
+    def unassign(self, policy_id: str, endpoint_ids: List[str]) -> Dict[str, Any]:
+        """Unassign policy from endpoints."""
+        command = UnassignPolicyCommand(self.http_client, policy_id, endpoint_ids)
+        return command.execute()
+    
+    def execute(self, policy_id: str, endpoint_ids: Optional[List[str]] = None) -> Dict[str, Any]:
+        """Execute a policy on assigned endpoints."""
+        command = ExecutePolicyCommand(self.http_client, policy_id, endpoint_ids)
+        return command.execute()
+    
+    def update_priorities(self, policy_ids: List[str], organization_ids: Optional[List[int]] = None) -> Dict[str, Any]:
+        """Update policy priorities.
+        
+        Args:
+            policy_ids: List of policy IDs in priority order (System policy must be first)
+            organization_ids: List of organization IDs (defaults to [0])
+        
+        Returns:
+            Response dictionary with success status
+        """
+        try:
+            # Fix API-001: Ensure organizationIds are provided to prevent issues
+            if organization_ids is None or len(organization_ids) == 0:
+                organization_ids = [0]  # Default to organization 0
+            
+            # Use correct API parameter names according to specification
+            payload = {
+                "ids": policy_ids,  # API expects 'ids', not 'policyIds'
+                "organizationIds": organization_ids  # Required parameter
+            }
+            
+            response = self.http_client.put("policies/priorities", json_data=payload)
+            return response
+        except Exception as e:
+            # Return a simulated response for testing
+            return {
+                "success": False,
+                "error": str(e),
+                "updated_policies": []
+            } 

binalyze_air/apis/preset_filters.py

@@ -0,0 +1,79 @@
+"""
+Preset Filters API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Union, Dict, Any, List
+
+from ..http_client import HTTPClient
+from ..models.preset_filters import (
+    PresetFilter, PresetFiltersList, PresetFiltersFilter, CreatePresetFilterRequest, UpdatePresetFilterRequest
+)
+from ..queries.preset_filters import GetPresetFiltersQuery, GetPresetFilterByIdQuery
+from ..commands.preset_filters import CreatePresetFilterCommand, UpdatePresetFilterCommand, DeletePresetFilterCommand
+
+
+class PresetFiltersAPI:
+    """Preset Filters API with CQRS pattern - separated queries and commands."""
+
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+
+    # QUERIES (Read operations)
+    def get_preset_filters(self, filter_params: Optional[PresetFiltersFilter] = None) -> PresetFiltersList:
+        """Get preset filters with optional filtering."""
+        query = GetPresetFiltersQuery(self.http_client, filter_params)
+        return query.execute()
+
+    def get_preset_filter_by_id(self, filter_id: Union[int, str]) -> Optional[PresetFilter]:
+        """Get a specific preset filter by ID."""
+        query = GetPresetFilterByIdQuery(self.http_client, str(filter_id))
+        return query.execute()
+
+    # Convenience methods for common queries
+    def get_preset_filters_by_organization(self, organization_id: Union[int, str]) -> PresetFiltersList:
+        """Get preset filters by organization ID."""
+        filter_params = PresetFiltersFilter()
+        filter_params.organization_id = int(organization_id)
+        return self.get_preset_filters(filter_params)
+
+    def get_preset_filters_by_type(self, filter_type: str, organization_id: Optional[Union[int, str]] = None) -> PresetFiltersList:
+        """Get preset filters by type (e.g., 'ENDPOINT')."""
+        filter_params = PresetFiltersFilter()
+        filter_params.type = filter_type
+        if organization_id is not None:
+            filter_params.organization_id = int(organization_id)
+        return self.get_preset_filters(filter_params)
+
+    # COMMANDS (Write operations)
+    def create_preset_filter(self, preset_filter_data: CreatePresetFilterRequest) -> PresetFilter:
+        """Create a new preset filter."""
+        command = CreatePresetFilterCommand(self.http_client, preset_filter_data)
+        return command.execute()
+
+    def update_preset_filter(self, filter_id: Union[int, str], preset_filter_data: UpdatePresetFilterRequest) -> PresetFilter:
+        """Update an existing preset filter."""
+        command = UpdatePresetFilterCommand(self.http_client, str(filter_id), preset_filter_data)
+        return command.execute()
+
+    def delete_preset_filter(self, filter_id: Union[int, str]) -> Dict[str, Any]:
+        """Delete a preset filter by ID."""
+        command = DeletePresetFilterCommand(self.http_client, str(filter_id))
+        return command.execute()
+
+    # Convenience methods
+    def create_endpoint_filter(
+        self, name: str, organization_id: Union[int, str], filter_criteria: List[Dict[str, Any]], created_by: str
+    ) -> PresetFilter:
+        """Create an endpoint preset filter."""
+        preset_filter_data = CreatePresetFilterRequest(
+            name=name,
+            organizationId=int(organization_id),
+            type="ENDPOINT",
+            filter=filter_criteria,
+            createdBy=created_by
+        )
+        return self.create_preset_filter(preset_filter_data)
+
+    def get_endpoint_filters(self, organization_id: Optional[Union[int, str]] = None) -> PresetFiltersList:
+        """Get all endpoint preset filters."""
+        return self.get_preset_filters_by_type("ENDPOINT", organization_id)

binalyze_air/apis/recent_activities.py

@@ -0,0 +1,71 @@
+"""
+Recent Activities API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Union, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.recent_activities import RecentActivity, RecentActivitiesList, RecentActivitiesFilter, CreateRecentActivityRequest
+from ..queries.recent_activities import GetRecentActivitiesQuery
+from ..commands.recent_activities import CreateRecentActivityCommand
+
+
+class RecentActivitiesAPI:
+    """Recent Activities API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def get_recent_activities(self, filter_params: Optional[RecentActivitiesFilter] = None) -> RecentActivitiesList:
+        """Get recent activities with optional filtering."""
+        query = GetRecentActivitiesQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    # Convenience methods for common queries
+    def get_recent_activities_by_organization(self, organization_id: Union[int, str]) -> RecentActivitiesList:
+        """Get recent activities by organization ID."""
+        filter_params = RecentActivitiesFilter()
+        filter_params.organization_id = int(organization_id)
+        return self.get_recent_activities(filter_params)
+    
+    def get_recent_activities_by_type(self, activity_type: str, organization_id: Optional[Union[int, str]] = None) -> RecentActivitiesList:
+        """Get recent activities by type (e.g., 'asset', 'case', 'task', 'report')."""
+        filter_params = RecentActivitiesFilter()
+        filter_params.type = activity_type
+        if organization_id is not None:
+            filter_params.organization_id = int(organization_id)
+        return self.get_recent_activities(filter_params)
+    
+    def get_recent_activities_by_user(self, username: str, organization_id: Optional[Union[int, str]] = None) -> RecentActivitiesList:
+        """Get recent activities by username."""
+        filter_params = RecentActivitiesFilter()
+        filter_params.username = username
+        if organization_id is not None:
+            filter_params.organization_id = int(organization_id)
+        return self.get_recent_activities(filter_params)
+    
+    def search_recent_activities(self, search_term: str, organization_id: Optional[Union[int, str]] = None) -> RecentActivitiesList:
+        """Search recent activities by search term."""
+        filter_params = RecentActivitiesFilter()
+        filter_params.search_term = search_term
+        if organization_id is not None:
+            filter_params.organization_id = int(organization_id)
+        return self.get_recent_activities(filter_params)
+    
+    # COMMANDS (Write operations)
+    def create_recent_activity(self, activity_data: CreateRecentActivityRequest) -> Dict[str, Any]:
+        """Create a new recent activity."""
+        command = CreateRecentActivityCommand(self.http_client, activity_data)
+        return command.execute()
+    
+    # Convenience methods
+    def get_recent_activities_count(self, organization_id: Optional[Union[int, str]] = None) -> int:
+        """Get total recent activities count."""
+        filter_params = RecentActivitiesFilter()
+        if organization_id is not None:
+            filter_params.organization_id = int(organization_id)
+        filter_params.page_size = 1  # We only need the count
+        
+        result = self.get_recent_activities(filter_params)
+        return result.total_entity_count or 0 

binalyze_air/apis/relay_server.py

@@ -0,0 +1,104 @@
+"""
+Relay Server API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Union, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.relay_server import (
+    RelayServer, RelayServersList, RelayServersFilter,
+    RebootTaskRequest, ShutdownTaskRequest, LogRetrievalTaskRequest, VersionUpdateTaskRequest,
+    UpdateTagsRequest, UpdateLabelRequest, UpdateAddressRequest
+)
+from ..queries.relay_server import GetRelayServersQuery, GetRelayServerByIdQuery
+from ..commands.relay_server import (
+    AssignRebootTaskCommand, AssignShutdownTaskCommand, AssignLogRetrievalTaskCommand,
+    AssignVersionUpdateTaskCommand, DeleteRelayServerCommand, UpdateTagsCommand,
+    UpdateLabelCommand, UpdateAddressCommand
+)
+
+
+class RelayServerAPI:
+    """Relay Server API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def get_relay_servers(self, filter_params: Optional[RelayServersFilter] = None) -> RelayServersList:
+        """Get relay servers with optional filtering."""
+        query = GetRelayServersQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get_relay_server_by_id(self, server_id: Union[int, str]) -> Optional[RelayServer]:
+        """Get a specific relay server by ID."""
+        query = GetRelayServerByIdQuery(self.http_client, str(server_id))
+        return query.execute()
+    
+    # Convenience methods for common queries
+    def get_relay_servers_by_organization(self, organization_id: Union[int, str]) -> RelayServersList:
+        """Get relay servers by organization ID."""
+        filter_params = RelayServersFilter()
+        filter_params.organization_id = int(organization_id)
+        return self.get_relay_servers(filter_params)
+    
+    def get_online_relay_servers(self, organization_id: Optional[Union[int, str]] = None) -> RelayServersList:
+        """Get online relay servers."""
+        filter_params = RelayServersFilter()
+        filter_params.online_status = "online"
+        if organization_id is not None:
+            filter_params.organization_id = int(organization_id)
+        return self.get_relay_servers(filter_params)
+    
+    # COMMANDS (Write operations - Task assignments)
+    def assign_reboot_task(self, relay_server_id: Union[int, str], task_request: RebootTaskRequest) -> Dict[str, Any]:
+        """Assign reboot task to relay server."""
+        command = AssignRebootTaskCommand(self.http_client, str(relay_server_id), task_request)
+        return command.execute()
+    
+    def assign_shutdown_task(self, relay_server_id: Union[int, str], task_request: ShutdownTaskRequest) -> Dict[str, Any]:
+        """Assign shutdown task to relay server."""
+        command = AssignShutdownTaskCommand(self.http_client, str(relay_server_id), task_request)
+        return command.execute()
+    
+    def assign_log_retrieval_task(self, relay_server_id: Union[int, str], task_request: LogRetrievalTaskRequest) -> Dict[str, Any]:
+        """Assign log retrieval task to relay server."""
+        command = AssignLogRetrievalTaskCommand(self.http_client, str(relay_server_id), task_request)
+        return command.execute()
+    
+    def assign_version_update_task(self, relay_server_id: Union[int, str], task_request: VersionUpdateTaskRequest) -> Dict[str, Any]:
+        """Assign version update task to relay server."""
+        command = AssignVersionUpdateTaskCommand(self.http_client, str(relay_server_id), task_request)
+        return command.execute()
+    
+    # COMMANDS (Write operations - Server management)
+    def delete_relay_server(self, server_id: Union[int, str]) -> Dict[str, Any]:
+        """Delete a relay server by ID."""
+        command = DeleteRelayServerCommand(self.http_client, str(server_id))
+        return command.execute()
+    
+    def update_tags(self, relay_server_id: Union[int, str], tags_request: UpdateTagsRequest) -> Dict[str, Any]:
+        """Update tags for a relay server."""
+        command = UpdateTagsCommand(self.http_client, str(relay_server_id), tags_request)
+        return command.execute()
+    
+    def update_label(self, relay_server_id: Union[int, str], label_request: UpdateLabelRequest) -> Dict[str, Any]:
+        """Update label for a relay server."""
+        command = UpdateLabelCommand(self.http_client, str(relay_server_id), label_request)
+        return command.execute()
+    
+    def update_address(self, relay_server_id: Union[int, str], address_request: UpdateAddressRequest) -> Dict[str, Any]:
+        """Update address for a relay server."""
+        command = UpdateAddressCommand(self.http_client, str(relay_server_id), address_request)
+        return command.execute()
+    
+    # Convenience methods
+    def get_relay_servers_count(self, organization_id: Optional[Union[int, str]] = None) -> int:
+        """Get total relay servers count."""
+        filter_params = RelayServersFilter()
+        if organization_id is not None:
+            filter_params.organization_id = int(organization_id)
+        filter_params.page_size = 1  # We only need the count
+        
+        result = self.get_relay_servers(filter_params)
+        return result.total_entity_count or 0