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

binalyze_air/apis/auto_asset_tags.py

@@ -1,75 +1,79 @@
-"""
-Auto Asset Tags API for the Binalyze AIR SDK.
-"""
-
-from typing import List, Optional, Dict, Any, Union
-
-from ..http_client import HTTPClient
-from ..models.auto_asset_tags import (
-    AutoAssetTag, AutoAssetTagFilter, CreateAutoAssetTagRequest, UpdateAutoAssetTagRequest,
-    StartTaggingRequest, TaggingResponse
-)
-from ..queries.auto_asset_tags import ListAutoAssetTagsQuery, GetAutoAssetTagQuery
-from ..commands.auto_asset_tags import (
-    CreateAutoAssetTagCommand, UpdateAutoAssetTagCommand, DeleteAutoAssetTagCommand,
-    StartTaggingCommand
-)
-
-
-class AutoAssetTagsAPI:
-    """Auto Asset Tags 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[AutoAssetTagFilter] = None) -> List[AutoAssetTag]:
-        """List auto asset tags with optional filtering."""
-        query = ListAutoAssetTagsQuery(self.http_client, filter_params)
-        return query.execute()
-    
-    def get(self, tag_id: str) -> AutoAssetTag:
-        """Get a specific auto asset tag by ID."""
-        query = GetAutoAssetTagQuery(self.http_client, tag_id)
-        return query.execute()
-    
-    def get_by_id(self, tag_id: str) -> AutoAssetTag:
-        """Get a specific auto asset tag by ID - alias for get."""
-        return self.get(tag_id)
-    
-    # COMMANDS (Write operations)
-    def create(self, request: Union[CreateAutoAssetTagRequest, Dict[str, Any]]) -> AutoAssetTag:
-        """Create a new auto asset tag."""
-        command = CreateAutoAssetTagCommand(self.http_client, request)
-        return command.execute()
-    
-    def update(self, tag_id_or_data: Union[str, Dict[str, Any]], request: Optional[Union[UpdateAutoAssetTagRequest, Dict[str, Any]]] = None) -> AutoAssetTag:
-        """Update an existing auto asset tag."""
-        # Handle both signatures: update(tag_id, request) and update(data_dict)
-        if isinstance(tag_id_or_data, str) and request is not None:
-            # Traditional signature: update(tag_id, request)
-            command = UpdateAutoAssetTagCommand(self.http_client, tag_id_or_data, request)
-        elif isinstance(tag_id_or_data, dict):
-            # Dict signature: update(data_dict) where data_dict contains 'id'
-            tag_id = tag_id_or_data.get('id')
-            if not tag_id:
-                raise ValueError("Tag ID must be provided in data dict or as separate parameter")
-            command = UpdateAutoAssetTagCommand(self.http_client, tag_id, tag_id_or_data)
-        else:
-            raise ValueError("Invalid arguments for update")
-        
-        return command.execute()
-    
-    def delete(self, tag_id: str) -> Dict[str, Any]:
-        """Delete an auto asset tag."""
-        command = DeleteAutoAssetTagCommand(self.http_client, tag_id)
-        return command.execute()
-    
-    def delete_by_id(self, tag_id: str) -> Dict[str, Any]:
-        """Delete an auto asset tag by ID - alias for delete."""
-        return self.delete(tag_id)
-    
-    def start_tagging(self, request: Union[StartTaggingRequest, Dict[str, Any]]) -> TaggingResponse:
-        """Start the tagging process for auto asset tags."""
-        command = StartTaggingCommand(self.http_client, request)
-        return command.execute() 
+"""
+Auto Asset Tags API for the Binalyze AIR SDK.
+"""
+
+from typing import List, Optional, Dict, Any, Union
+
+from ..http_client import HTTPClient
+from ..models.auto_asset_tags import (
+    AutoAssetTag, AutoAssetTagFilter, CreateAutoAssetTagRequest, UpdateAutoAssetTagRequest,
+    StartTaggingRequest, TaggingResponse
+)
+from ..queries.auto_asset_tags import ListAutoAssetTagsQuery, GetAutoAssetTagQuery
+from ..commands.auto_asset_tags import (
+    CreateAutoAssetTagCommand, UpdateAutoAssetTagCommand, DeleteAutoAssetTagCommand,
+    StartTaggingCommand
+)
+
+
+class AutoAssetTagsAPI:
+    """Auto Asset Tags 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[AutoAssetTagFilter] = None) -> List[AutoAssetTag]:
+        """List auto asset tags with optional filtering."""
+        query = ListAutoAssetTagsQuery(self.http_client, filter_params)
+        return query.execute()
+
+    def get(self, tag_id: str) -> AutoAssetTag:
+        """Get a specific auto asset tag by ID."""
+        query = GetAutoAssetTagQuery(self.http_client, tag_id)
+        return query.execute()
+
+    def get_by_id(self, tag_id: str) -> AutoAssetTag:
+        """Get a specific auto asset tag by ID - alias for get."""
+        return self.get(tag_id)
+
+    # COMMANDS (Write operations)
+    def create(self, request: Union[CreateAutoAssetTagRequest, Dict[str, Any]]) -> AutoAssetTag:
+        """Create a new auto asset tag."""
+        command = CreateAutoAssetTagCommand(self.http_client, request)
+        return command.execute()
+
+    def update(
+        self,
+        tag_id_or_data: Union[str, Dict[str, Any]],
+        request: Optional[Union[UpdateAutoAssetTagRequest, Dict[str, Any]]] = None
+    ) -> AutoAssetTag:
+        """Update an existing auto asset tag."""
+        # Handle both signatures: update(tag_id, request) and update(data_dict)
+        if isinstance(tag_id_or_data, str) and request is not None:
+            # Traditional signature: update(tag_id, request)
+            command = UpdateAutoAssetTagCommand(self.http_client, tag_id_or_data, request)
+        elif isinstance(tag_id_or_data, dict):
+            # Dict signature: update(data_dict) where data_dict contains 'id'
+            tag_id = tag_id_or_data.get('id')
+            if not tag_id:
+                raise ValueError("Tag ID must be provided in data dict or as separate parameter")
+            command = UpdateAutoAssetTagCommand(self.http_client, tag_id, tag_id_or_data)
+        else:
+            raise ValueError("Invalid arguments for update")
+
+        return command.execute()
+
+    def delete(self, tag_id: str) -> Dict[str, Any]:
+        """Delete an auto asset tag."""
+        command = DeleteAutoAssetTagCommand(self.http_client, tag_id)
+        return command.execute()
+
+    def delete_by_id(self, tag_id: str) -> Dict[str, Any]:
+        """Delete an auto asset tag by ID - alias for delete."""
+        return self.delete(tag_id)
+
+    def start_tagging(self, request: Union[StartTaggingRequest, Dict[str, Any]]) -> TaggingResponse:
+        """Start the tagging process for auto asset tags."""
+        command = StartTaggingCommand(self.http_client, request)
+        return command.execute()

binalyze_air/apis/backup.py

@@ -0,0 +1,177 @@
+"""
+Backup API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+
+from ..http_client import HTTPClient
+from ..models.backup import (
+    BackupHistoryResponse, BackupFilter, BackupNowRequest, 
+    BackupStatus, BackupSource, BackupLocation, BackupStats
+)
+from ..queries.backup import (
+    GetBackupHistoryQuery, GetBackupDownloadQuery
+)
+from ..commands.backup import (
+    BackupNowCommand, DeleteBackupCommand
+)
+
+
+class BackupAPI:
+    """Backup API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def get_history(self, filter_params: Optional[BackupFilter] = None) -> BackupHistoryResponse:
+        """Get backup history with optional filtering."""
+        query = GetBackupHistoryQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def download_backup(self, backup_id: str) -> Dict[str, Any]:
+        """Download a backup by ID."""
+        query = GetBackupDownloadQuery(self.http_client, backup_id)
+        return query.execute()
+    
+    # COMMANDS (Write operations)
+    def backup_now(self, request: BackupNowRequest) -> Dict[str, Any]:
+        """Create an immediate backup."""
+        command = BackupNowCommand(self.http_client, request)
+        return command.execute()
+    
+    def delete_backup(self, backup_id: str) -> Dict[str, Any]:
+        """Delete a backup by ID."""
+        command = DeleteBackupCommand(self.http_client, backup_id)
+        return command.execute()
+    
+    # Convenience methods
+    def backup_all_endpoints(self, organization_ids: Optional[List[int]] = None) -> Dict[str, Any]:
+        """Create a backup of all endpoints."""
+        request = BackupNowRequest(organizationIds=organization_ids)
+        return self.backup_now(request)
+    
+    def backup_specific_endpoints(self, endpoint_ids: List[str], 
+                                 organization_ids: Optional[List[int]] = None) -> Dict[str, Any]:
+        """Create a backup of specific endpoints."""
+        request = BackupNowRequest(
+            includedEndpointIds=endpoint_ids,
+            organizationIds=organization_ids
+        )
+        return self.backup_now(request)
+    
+    def get_recent_backups(self, days: int = 7) -> BackupHistoryResponse:
+        """Get recent backups from the last N days."""
+        end_date = datetime.utcnow()
+        start_date = datetime.utcnow().replace(day=end_date.day - days)
+        
+        filter_params = BackupFilter(
+            startDate=start_date,
+            endDate=end_date,
+            sortBy="startDate",
+            sortType="DESC"
+        )
+        return self.get_history(filter_params)
+    
+    def get_failed_backups(self) -> BackupHistoryResponse:
+        """Get all failed backups."""
+        filter_params = BackupFilter(
+            status=BackupStatus.FAILED,
+            sortBy="startDate",
+            sortType="DESC"
+        )
+        return self.get_history(filter_params)
+    
+    def get_in_progress_backups(self) -> BackupHistoryResponse:
+        """Get all in-progress backups."""
+        filter_params = BackupFilter(
+            status=BackupStatus.IN_PROGRESS,
+            sortBy="startDate",
+            sortType="DESC"
+        )
+        return self.get_history(filter_params)
+    
+    def get_user_backups(self, username: str) -> BackupHistoryResponse:
+        """Get backups created by a specific user."""
+        filter_params = BackupFilter(
+            username=username,
+            source=BackupSource.USER,
+            sortBy="startDate",
+            sortType="DESC"
+        )
+        return self.get_history(filter_params)
+    
+    def get_scheduled_backups(self) -> BackupHistoryResponse:
+        """Get backups created by scheduler."""
+        filter_params = BackupFilter(
+            source=BackupSource.SCHEDULER,
+            sortBy="startDate",
+            sortType="DESC"
+        )
+        return self.get_history(filter_params)
+    
+    def get_backup_stats(self) -> BackupStats:
+        """Get backup statistics summary."""
+        # Get all backup history to calculate stats
+        all_backups = self.get_history(BackupFilter(pageSize=1000))
+        
+        stats = BackupStats()
+        stats.total_backups = len(all_backups.entities)
+        
+        total_duration = 0
+        backup_count_with_duration = 0
+        
+        for backup in all_backups.entities:
+            # Count by status
+            if backup.status == BackupStatus.SUCCEEDED:
+                stats.successful_backups += 1
+            elif backup.status == BackupStatus.FAILED:
+                stats.failed_backups += 1
+            elif backup.status == BackupStatus.IN_PROGRESS:
+                stats.in_progress_backups += 1
+            
+            # Sum total size
+            if backup.size:
+                stats.total_size_bytes += backup.size
+            
+            # Calculate average backup time
+            if backup.start_date and backup.end_date:
+                duration = (backup.end_date - backup.start_date).total_seconds() / 60
+                total_duration += duration
+                backup_count_with_duration += 1
+            
+            # Track last backup date
+            if not stats.last_backup_date or backup.start_date > stats.last_backup_date:
+                stats.last_backup_date = backup.start_date
+        
+        # Calculate average backup time
+        if backup_count_with_duration > 0:
+            stats.average_backup_time_minutes = total_duration / backup_count_with_duration
+        
+        return stats
+    
+    def cleanup_old_backups(self, days_to_keep: int = 30) -> List[str]:
+        """Delete backups older than specified days and return deleted backup IDs."""
+        cutoff_date = datetime.utcnow().replace(day=datetime.utcnow().day - days_to_keep)
+        
+        filter_params = BackupFilter(
+            endDate=cutoff_date,
+            status=BackupStatus.SUCCEEDED,
+            sortBy="startDate",
+            sortType="ASC",
+            pageSize=1000
+        )
+        
+        old_backups = self.get_history(filter_params)
+        deleted_ids = []
+        
+        for backup in old_backups.entities:
+            try:
+                self.delete_backup(backup.id)
+                deleted_ids.append(backup.id)
+            except Exception:
+                # Continue with other backups if one fails
+                continue
+        
+        return deleted_ids 

binalyze_air/apis/baseline.py

@@ -0,0 +1,46 @@
+"""
+Baseline API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any
+from ..http_client import HTTPClient
+from ..commands.baseline import (
+    AcquireBaselineByFilterCommand,
+    CompareBaselineByEndpointCommand,
+)
+from ..queries.baseline import (
+    GetBaselineComparisonReportQuery,
+)
+
+
+class BaselineAPI:
+    """Baseline API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # COMMANDS (Write operations)
+    def acquire_by_filter(self, filter_data: Dict[str, Any], case_id: Optional[str] = None) -> Dict[str, Any]:
+        """Acquire baselines by asset filter criteria."""
+        payload = {
+            "filter": filter_data,
+            "caseId": case_id
+        }
+        
+        command = AcquireBaselineByFilterCommand(self.http_client, payload)
+        return command.execute()
+
+    def compare_by_endpoint(self, endpoint_id: str, baseline_task_ids: List[str]) -> Dict[str, Any]:
+        """Compare baseline acquisition tasks by endpoint ID."""
+        payload = {
+            "endpointId": endpoint_id,
+            "taskIds": baseline_task_ids
+        }
+        
+        command = CompareBaselineByEndpointCommand(self.http_client, payload)
+        return command.execute()
+
+    def get_comparison_report(self, endpoint_id: str, task_id: str) -> Dict[str, Any]:
+        """Get comparison report by endpoint ID and task ID."""
+        query = GetBaselineComparisonReportQuery(self.http_client, endpoint_id, task_id)
+        return query.execute() 

binalyze_air/apis/cases.py

@@ -0,0 +1,225 @@
+"""
+Cases API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any
+from ..http_client import HTTPClient
+from ..models.cases import (
+    Case, CaseActivity, CaseEndpoint, CaseTask, User, CaseFilter, CaseActivityFilter,
+    CreateCaseRequest, UpdateCaseRequest, CaseNote, CaseEndpointFilter, CaseTaskFilter, CaseUserFilter
+)
+from ..models.assets import AssetFilter
+from ..queries.cases import (
+    ListCasesQuery,
+    GetCaseQuery,
+    GetCaseActivitiesQuery,
+    GetCaseEndpointsQuery,
+    GetCaseTasksQuery,
+    GetCaseUsersQuery,
+    CheckCaseNameQuery,
+)
+from ..commands.cases import (
+    CreateCaseCommand,
+    UpdateCaseCommand,
+    CloseCaseCommand,
+    OpenCaseCommand,
+    ArchiveCaseCommand,
+    ChangeCaseOwnerCommand,
+    RemoveEndpointsFromCaseCommand,
+    RemoveTaskAssignmentFromCaseCommand,
+    ImportTaskAssignmentsToCaseCommand,
+    AddNoteToCaseCommand,
+    UpdateNoteToCaseCommand,
+    DeleteNoteToCaseCommand,
+    ExportCaseNotesCommand,
+    ExportCasesCommand,
+    ExportCaseEndpointsCommand,
+    ExportCaseActivitiesCommand,
+)
+
+
+class CasesAPI:
+    """Cases 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[CaseFilter] = None, organization_ids: Optional[List[int]] = None) -> List[Case]:
+        """List cases with optional filtering."""
+        query = ListCasesQuery(self.http_client, filter_params, organization_ids)
+        return query.execute()
+
+    def get(self, case_id: str) -> Case:
+        """Get a specific case by ID."""
+        query = GetCaseQuery(self.http_client, case_id)
+        return query.execute()
+
+    def get_activities(self, case_id: str, filter_params: Optional[CaseActivityFilter] = None) -> List[CaseActivity]:
+        """Get activities for a specific case with optional filtering, pagination, and sorting."""
+        query = GetCaseActivitiesQuery(self.http_client, case_id, filter_params)
+        return query.execute()
+
+    def get_endpoints(
+        self, case_id: str, filter_params: Optional[CaseEndpointFilter] = None, organization_ids: Optional[List[int]] = None
+    ) -> List[CaseEndpoint]:
+        """Get endpoints for a specific case with comprehensive filtering support.
+
+        Args:
+            case_id: The case ID to get endpoints for
+            filter_params: Optional CaseEndpointFilter with comprehensive filtering options
+            organization_ids: Optional list of organization IDs (for backward compatibility)
+
+        Returns:
+            List of CaseEndpoint objects
+
+        Note: If both filter_params and organization_ids are provided, organization_ids in filter_params takes precedence.
+        """
+        # Handle backward compatibility
+        if filter_params is None:
+            filter_params = CaseEndpointFilter()
+
+        # If organization_ids is provided and not set in filter_params, use it
+        if organization_ids is not None and filter_params.organization_ids is None:
+            filter_params.organization_ids = organization_ids
+
+        query = GetCaseEndpointsQuery(self.http_client, case_id, filter_params)
+        return query.execute()
+
+    def get_tasks(
+        self, case_id: str, filter_params: Optional[CaseTaskFilter] = None, organization_ids: Optional[List[int]] = None
+    ) -> List[CaseTask]:
+        """Get tasks for a specific case with comprehensive filtering support.
+
+        Args:
+            case_id: The case ID to get tasks for
+            filter_params: Optional CaseTaskFilter with comprehensive filtering options
+            organization_ids: Optional list of organization IDs (for backward compatibility)
+
+        Returns:
+            List of CaseTask objects
+
+        Note: If both filter_params and organization_ids are provided, organization_ids in filter_params takes precedence.
+        """
+        # Handle backward compatibility
+        if filter_params is None:
+            filter_params = CaseTaskFilter()
+
+        # If organization_ids is provided and not set in filter_params, use it
+        if organization_ids is not None and filter_params.organization_ids is None:
+            filter_params.organization_ids = organization_ids
+
+        query = GetCaseTasksQuery(self.http_client, case_id, filter_params)
+        return query.execute()
+
+    def get_users(
+        self, case_id: str, filter_params: Optional[CaseUserFilter] = None, organization_ids: Optional[List[int]] = None
+    ) -> List[User]:
+        """Get users for a specific case with comprehensive filtering support.
+
+        Args:
+            case_id: The case ID to get users for
+            filter_params: Optional CaseUserFilter with comprehensive filtering options
+            organization_ids: Optional list of organization IDs (for backward compatibility)
+
+        Returns:
+            List of User objects
+
+        Note: If both filter_params and organization_ids are provided, organization_ids in filter_params takes precedence.
+        """
+        # Handle backward compatibility
+        if filter_params is None:
+            filter_params = CaseUserFilter()
+
+        # If organization_ids is provided and not set in filter_params, use it
+        if organization_ids is not None and filter_params.organization_ids is None:
+            filter_params.organization_ids = organization_ids
+
+        query = GetCaseUsersQuery(self.http_client, case_id, filter_params)
+        return query.execute()
+
+    def check_name(self, name: str) -> bool:
+        """Check if a case name is available."""
+        query = CheckCaseNameQuery(self.http_client, name)
+        return query.execute()
+
+    # COMMANDS (Write operations)
+    def create(self, case_data: CreateCaseRequest) -> Case:
+        """Create a new case."""
+        command = CreateCaseCommand(self.http_client, case_data)
+        return command.execute()
+
+    def update(self, case_id: str, update_data: UpdateCaseRequest) -> Case:
+        """Update an existing case."""
+        command = UpdateCaseCommand(self.http_client, case_id, update_data)
+        return command.execute()
+
+    def close(self, case_id: str) -> Case:
+        """Close a case."""
+        command = CloseCaseCommand(self.http_client, case_id)
+        return command.execute()
+
+    def open(self, case_id: str) -> Case:
+        """Open a case."""
+        command = OpenCaseCommand(self.http_client, case_id)
+        return command.execute()
+
+    def archive(self, case_id: str) -> Case:
+        """Archive a case."""
+        command = ArchiveCaseCommand(self.http_client, case_id)
+        return command.execute()
+
+    def change_owner(self, case_id: str, new_owner_id: str) -> Case:
+        """Change case owner."""
+        command = ChangeCaseOwnerCommand(self.http_client, case_id, new_owner_id)
+        return command.execute()
+
+    def remove_endpoints(self, case_id: str, filter_params: AssetFilter) -> Dict[str, Any]:
+        """Remove endpoints from a case."""
+        command = RemoveEndpointsFromCaseCommand(self.http_client, case_id, filter_params)
+        return command.execute()
+
+    def remove_task_assignment(self, case_id: str, task_assignment_id: str) -> Dict[str, Any]:
+        """Remove task assignment from a case."""
+        command = RemoveTaskAssignmentFromCaseCommand(self.http_client, case_id, task_assignment_id)
+        return command.execute()
+
+    def import_task_assignments(self, case_id: str, task_assignment_ids: List[str]) -> Dict[str, Any]:
+        """Import task assignments to a case."""
+        command = ImportTaskAssignmentsToCaseCommand(self.http_client, case_id, task_assignment_ids)
+        return command.execute()
+
+    def add_note(self, case_id: str, note_value: str) -> CaseNote:
+        """Add a note to a case."""
+        command = AddNoteToCaseCommand(self.http_client, case_id, note_value)
+        return command.execute()
+
+    def update_note(self, case_id: str, note_id: str, note_value: str) -> CaseNote:
+        """Update a note in a case."""
+        command = UpdateNoteToCaseCommand(self.http_client, case_id, note_id, note_value)
+        return command.execute()
+
+    def delete_note(self, case_id: str, note_id: str) -> Dict[str, Any]:
+        """Delete a note from a case."""
+        command = DeleteNoteToCaseCommand(self.http_client, case_id, note_id)
+        return command.execute()
+
+    def export_notes(self, case_id: str) -> Dict[str, Any]:
+        """Export case notes as a file download (ZIP/CSV format)."""
+        command = ExportCaseNotesCommand(self.http_client, case_id)
+        return command.execute()
+
+    def export_cases(self, filter_params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Export cases as a CSV file download."""
+        command = ExportCasesCommand(self.http_client, filter_params)
+        return command.execute()
+
+    def export_endpoints(self, case_id: str, filter_params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Export case endpoints as a CSV file download with optional filtering."""
+        command = ExportCaseEndpointsCommand(self.http_client, case_id, filter_params)
+        return command.execute()
+
+    def export_activities(self, case_id: str, filter_params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Export case activities as a CSV file download with optional filtering and pagination."""
+        command = ExportCaseActivitiesCommand(self.http_client, case_id, filter_params)
+        return command.execute()