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

binalyze_air/apis/multipart_upload.py

@@ -0,0 +1,201 @@
+"""Multipart Upload API client for Binalyze AIR SDK."""
+
+from typing import Optional, Dict, Any, Callable
+from ..http_client import HTTPClient
+from ..models.multipart_upload import (
+    UploadInitializeResponse, UploadPartResponse, UploadStatusResponse, 
+    UploadFinalizeResponse, MultipartUploadSession
+)
+from ..queries.multipart_upload import (
+    InitializeUploadQuery, UploadPartQuery, CheckUploadStatusQuery, FinalizeUploadQuery
+)
+from ..commands.multipart_upload import (
+    InitializeUploadCommand, UploadPartCommand, CheckUploadStatusCommand, 
+    FinalizeUploadCommand, CompleteFileUploadCommand, AbortUploadCommand
+)
+
+
+class MultipartUploadAPI:
+    """Multipart Upload API with CQRS pattern - separated queries and commands.
+    
+    This class provides methods for uploading large files using multipart upload,
+    which allows for resumable uploads and better handling of large files.
+    """
+    
+    def __init__(self, http_client: HTTPClient):
+        """Initialize Multipart Upload API client.
+        
+        Args:
+            http_client: HTTP client for making API requests
+        """
+        self.http_client = http_client
+
+    # QUERIES (Read operations)
+    def check_upload_status(self, file_id: str) -> UploadStatusResponse:
+        """Check if upload is ready to be finalized.
+        
+        Args:
+            file_id: Upload session identifier
+            
+        Returns:
+            UploadStatusResponse with ready status
+            
+        Raises:
+            APIError: If the request fails
+        """
+        command = CheckUploadStatusCommand(self, file_id)
+        return command.execute()
+
+    # COMMANDS (Write operations)
+    def initialize_upload(self) -> UploadInitializeResponse:
+        """Initialize a new multipart upload session.
+        
+        Returns:
+            UploadInitializeResponse with file ID for the session
+            
+        Raises:
+            APIError: If the request fails
+        """
+        command = InitializeUploadCommand(self)
+        return command.execute()
+
+    def upload_part(self, file_id: str, part_number: int, file_data: bytes, filename: Optional[str] = None) -> UploadPartResponse:
+        """Upload a file part in a multipart upload.
+        
+        Args:
+            file_id: Upload session identifier
+            part_number: Sequential part number (starting from 1)
+            file_data: Binary file data for this part
+            filename: Optional filename for the part
+            
+        Returns:
+            UploadPartResponse indicating success/failure
+            
+        Raises:
+            APIError: If the request fails
+        """
+        command = UploadPartCommand(self, file_id, part_number, file_data, filename)
+        return command.execute()
+
+    def finalize_upload(self, file_id: str) -> UploadFinalizeResponse:
+        """Finalize a multipart upload session.
+        
+        Args:
+            file_id: Upload session identifier to finalize
+            
+        Returns:
+            UploadFinalizeResponse indicating success/failure
+            
+        Raises:
+            APIError: If the request fails
+        """
+        command = FinalizeUploadCommand(self, file_id)
+        return command.execute()
+
+    def abort_upload(self, file_id: str) -> Dict[str, Any]:
+        """Abort a multipart upload session and discard all uploaded parts.
+
+        Args:
+            file_id: Upload session identifier to abort
+
+        Returns:
+            Dictionary with API response
+        """
+        command = AbortUploadCommand(self, file_id)
+        return command.execute()
+
+    def upload_file(
+        self, 
+        file_path: str, 
+        chunk_size: int = 5 * 1024 * 1024,
+        progress_callback: Optional[Callable[[float, int, int], None]] = None
+    ) -> Dict[str, Any]:
+        """Upload a complete file using multipart upload.
+        
+        This method handles the entire upload process automatically:
+        1. Initialize upload session
+        2. Upload all file parts
+        3. Check upload status
+        4. Finalize upload
+        
+        Args:
+            file_path: Path to the file to upload
+            chunk_size: Size of each chunk in bytes (default 5MB)
+            progress_callback: Optional callback for progress updates (percentage, current_part, total_parts)
+            
+        Returns:
+            Dictionary with upload results and session information
+            
+        Raises:
+            APIError: If any step of the upload fails
+            FileNotFoundError: If the file doesn't exist
+        """
+        command = CompleteFileUploadCommand(self, file_path, chunk_size, progress_callback)
+        return command.execute()
+
+    # Low-level query methods (for internal use by commands)
+    def _initialize_upload_query(self, query: InitializeUploadQuery) -> Dict[str, Any]:
+        """Execute initialize upload query (internal use).
+        
+        Args:
+            query: InitializeUploadQuery instance
+            
+        Returns:
+            API response dictionary
+        """
+        body = query.build_body()
+        return self.http_client.post('multipart-upload/initialize', json_data=body)
+
+    def _upload_part_query(self, query: UploadPartQuery) -> Dict[str, Any]:
+        """Execute upload part query (internal use).
+        
+        Args:
+            query: UploadPartQuery instance
+            
+        Returns:
+            API response dictionary
+        """
+        form_data = query.build_form_data()
+        
+        # Prepare files and data for multipart upload
+        # Use the filename from the request, or default to 'part.bin'
+        filename = getattr(query._request, 'filename', None) or 'part.bin'
+        files = {
+            'file': (filename, form_data['file'], 'application/octet-stream')
+        }
+        
+        data = {
+            'fileId': form_data['fileId'],
+            'partNumber': form_data['partNumber']
+        }
+        
+        return self.http_client.upload_multipart(
+            'multipart-upload/upload-part',
+            files=files,
+            data=data,
+            method='PUT'
+        )
+
+    def _check_upload_status_query(self, query: CheckUploadStatusQuery) -> Dict[str, Any]:
+        """Execute check upload status query (internal use).
+        
+        Args:
+            query: CheckUploadStatusQuery instance
+            
+        Returns:
+            API response dictionary
+        """
+        params = query.build_params()
+        return self.http_client.get('multipart-upload/is-ready', params=params)
+
+    def _finalize_upload_query(self, query: FinalizeUploadQuery) -> Dict[str, Any]:
+        """Execute finalize upload query (internal use).
+        
+        Args:
+            query: FinalizeUploadQuery instance
+            
+        Returns:
+            API response dictionary
+        """
+        body = query.build_body()
+        return self.http_client.post('multipart-upload/finalize', json_data=body) 

binalyze_air/apis/notifications.py

@@ -0,0 +1,115 @@
+"""
+Notifications API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Union, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.notifications import Notification, NotificationsList, NotificationsFilter, NotificationType, NotificationLevel
+from ..queries.notifications import GetNotificationsQuery, GetNotificationByIdQuery
+from ..commands.notifications import DeleteAllNotificationsCommand, MarkAllAsReadCommand, MarkAsReadByIdCommand
+
+
+class NotificationsAPI:
+    """Notifications API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def get_notifications(self, filter_params: Optional[NotificationsFilter] = None) -> NotificationsList:
+        """Get notifications with optional filtering."""
+        query = GetNotificationsQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get_notification_by_id(self, notification_id: Union[int, str]) -> Optional[Notification]:
+        """Get a specific notification by ID."""
+        query = GetNotificationByIdQuery(self.http_client, str(notification_id))
+        return query.execute()
+    
+    # Convenience methods for common queries
+    def get_unread_notifications(self, organization_ids: Union[int, list] = 0) -> NotificationsList:
+        """Get unread notifications."""
+        # Create filter with explicit field values
+        filter_params = NotificationsFilter()
+        filter_params.is_read = False
+        if isinstance(organization_ids, list):
+            filter_params.organization_ids = organization_ids
+        else:
+            filter_params.organization_ids = organization_ids
+        
+        return self.get_notifications(filter_params)
+    
+    def get_notifications_by_type(self, notification_type: Union[str, NotificationType], organization_ids: Union[int, list] = 0) -> NotificationsList:
+        """Get notifications by type."""
+        # Create filter with explicit field values
+        filter_params = NotificationsFilter()
+        if isinstance(notification_type, str):
+            filter_params.type = NotificationType(notification_type)
+        else:
+            filter_params.type = notification_type
+        if isinstance(organization_ids, list):
+            filter_params.organization_ids = organization_ids
+        else:
+            filter_params.organization_ids = organization_ids
+        
+        return self.get_notifications(filter_params)
+    
+    def get_notifications_by_level(self, level: Union[str, NotificationLevel], organization_ids: Union[int, list] = 0) -> NotificationsList:
+        """Get notifications by level."""
+        # Create filter with explicit field values  
+        filter_params = NotificationsFilter()
+        if isinstance(level, str):
+            filter_params.level = NotificationLevel(level)
+        else:
+            filter_params.level = level
+        if isinstance(organization_ids, list):
+            filter_params.organization_ids = organization_ids
+        else:
+            filter_params.organization_ids = organization_ids
+        
+        return self.get_notifications(filter_params)
+    
+    # COMMANDS (Write operations)
+    def delete_all_notifications(self) -> Dict[str, Any]:
+        """Delete all notifications for the current user."""
+        command = DeleteAllNotificationsCommand(self.http_client)
+        return command.execute()
+    
+    def mark_all_as_read(self) -> Dict[str, Any]:
+        """Mark all notifications as read."""
+        command = MarkAllAsReadCommand(self.http_client)
+        return command.execute()
+    
+    def mark_as_read_by_id(self, notification_id: Union[int, str]) -> Dict[str, Any]:
+        """Mark a specific notification as read by ID."""
+        command = MarkAsReadByIdCommand(self.http_client, notification_id)
+        return command.execute()
+    
+    # Convenience methods
+    def get_notification_count(self, organization_ids: Union[int, list] = 0) -> int:
+        """Get total notification count."""
+        # Create filter with explicit field values
+        filter_params = NotificationsFilter()
+        if isinstance(organization_ids, list):
+            filter_params.organization_ids = organization_ids
+        else:
+            filter_params.organization_ids = organization_ids
+        filter_params.page_size = 1  # We only need the count
+        
+        result = self.get_notifications(filter_params)
+        return result.total_entity_count
+    
+    def get_unread_count(self, organization_ids: Union[int, list] = 0) -> int:
+        """Get unread notification count."""
+        # Create filter with explicit field values
+        filter_params = NotificationsFilter()
+        filter_params.is_read = False
+        if isinstance(organization_ids, list):
+            filter_params.organization_ids = organization_ids
+        else:
+            filter_params.organization_ids = organization_ids
+        filter_params.page_size = 1  # We only need the count
+        
+        result = self.get_notifications(filter_params)
+        return result.total_entity_count 

binalyze_air/apis/organizations.py

@@ -0,0 +1,267 @@
+"""
+Organizations API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any
+from ..http_client import HTTPClient
+from ..models.organizations import (
+    Organization, OrganizationsPaginatedResponse, OrganizationUsersPaginatedResponse,
+    OrganizationUser, OrganizationSettings, CreateOrganizationRequest, UpdateOrganizationRequest,
+    AddUserToOrganizationRequest, AssignUsersToOrganizationRequest
+)
+from ..queries.organizations import (
+    ListOrganizationsQuery,
+    GetOrganizationQuery,
+    GetOrganizationUsersQuery,
+)
+from ..commands.organizations import (
+    CreateOrganizationCommand,
+    UpdateOrganizationCommand,
+    AssignUsersToOrganizationCommand,
+    RemoveUserFromOrganizationCommand,
+    UpdateOrganizationSettingsCommand,
+)
+
+
+class OrganizationsAPI:
+    """Organizations 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, page: int = 1, page_size: int = 10, 
+             sort_by: str = "name", order: str = "asc") -> OrganizationsPaginatedResponse:
+        """List organizations with pagination and sorting."""
+        query = ListOrganizationsQuery(self.http_client, page, page_size, sort_by, order, None)
+        return query.execute()
+    
+    def get(self, organization_id: str) -> Organization:
+        """Get organization by ID."""
+        query = GetOrganizationQuery(self.http_client, organization_id)
+        return query.execute()
+    
+    def get_users(self, organization_id: str, page: int = 1, page_size: int = 10) -> OrganizationUsersPaginatedResponse:
+        """Get users in organization."""
+        query = GetOrganizationUsersQuery(self.http_client, organization_id, page, page_size)
+        return query.execute()
+    
+    def check_name(self, name: str) -> bool:
+        """Check if organization name exists."""
+        try:
+            params = {"name": name}
+            response = self.http_client.get("organizations/check", params=params)
+            return response.get("result", False)
+        except Exception:
+            return False
+    
+    def get_shareable_deployment_info(self, deployment_token: str) -> Dict[str, Any]:
+        """Get shareable deployment information by token."""
+        try:
+            response = self.http_client.get(f"organizations/shareable-deployment-info/{deployment_token}")
+            
+            if response.get("success"):
+                return response.get("result", {})
+            else:
+                # Return error information
+                return {
+                    "error": True,
+                    "errors": response.get("errors", []),
+                    "statusCode": response.get("statusCode", 500)
+                }
+        except Exception as e:
+            return {
+                "error": True,
+                "errors": [str(e)],
+                "statusCode": 500
+            }
+    
+    # COMMANDS (Write operations)
+    def create(self, request: CreateOrganizationRequest) -> Organization:
+        """Create organization."""
+        command = CreateOrganizationCommand(self.http_client, request)
+        return command.execute()
+    
+    def update(self, organization_id: str, request: UpdateOrganizationRequest) -> Organization:
+        """Update organization."""
+        command = UpdateOrganizationCommand(self.http_client, organization_id, request)
+        return command.execute()
+    
+    def add_user(self, organization_id: str, user_ids: List[str]) -> bool:
+        """Add users to organization using the modern assign users endpoint."""
+        return self.assign_users(organization_id, user_ids)
+    
+    def assign_users(self, organization_id: str, user_ids: List[str]) -> bool:
+        """Assign users to organization using the /assign-users endpoint."""
+        # Create the proper request object with correct field name
+        request = AssignUsersToOrganizationRequest(userIds=user_ids)
+        command = AssignUsersToOrganizationCommand(self.http_client, organization_id, request)
+        return command.execute()
+    
+    def remove_user(self, organization_id: str, user_id: str) -> Dict[str, Any]:
+        """Remove user from organization using the /remove-user endpoint."""
+        command = RemoveUserFromOrganizationCommand(self.http_client, organization_id, user_id)
+        return command.execute()
+    
+    def update_settings(self, organization_id: str, settings: Dict[str, Any]) -> OrganizationSettings:
+        """Update organization settings."""
+        command = UpdateOrganizationSettingsCommand(self.http_client, organization_id, settings)
+        return command.execute()
+    
+    def update_shareable_deployment_settings(self, organization_id: int, status: bool) -> Dict[str, Any]:
+        """Update organization shareable deployment settings."""
+        try:
+            # Prepare the payload according to API specification
+            payload = {"status": status}
+            
+            # Make the API call
+            response = self.http_client.post(f"organizations/{organization_id}/shareable-deployment", json_data=payload)
+            return response
+            
+        except Exception as e:
+            # Check if it's a 409 conflict (expected behavior when setting to same state)
+            error_msg = str(e)
+            if "409" in error_msg or "already" in error_msg.lower():
+                # Return success for 409 conflicts (expected behavior)
+                return {
+                    "success": True,
+                    "result": None,
+                    "statusCode": 409,
+                    "message": "Shareable deployment setting already in desired state"
+                }
+            
+            # Return error response format matching API
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)]
+            }
+    
+    def update_deployment_token(self, organization_id: int, deployment_token: str) -> Dict[str, Any]:
+        """Update organization deployment token."""
+        try:
+            # Prepare the payload according to API specification
+            payload = {"deploymentToken": deployment_token}
+            
+            # Make the API call
+            response = self.http_client.post(f"organizations/{organization_id}/deployment-token", json_data=payload)
+            return response
+            
+        except Exception as e:
+            # Check if it's a 409 conflict (expected behavior when setting to same token)
+            error_msg = str(e)
+            if "409" in error_msg or "same token" in error_msg.lower() or "cannot be updated with same" in error_msg.lower():
+                # Return success for 409 conflicts (expected behavior)
+                return {
+                    "success": True,
+                    "result": None,
+                    "statusCode": 409,
+                    "message": "Deployment token already set to this value"
+                }
+            
+            # Return error response format matching API
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)]
+            }
+    
+    def delete(self, organization_id: int) -> Dict[str, Any]:
+        """Delete organization by ID."""
+        try:
+            # Make the API call
+            response = self.http_client.delete(f"organizations/{organization_id}")
+            return response
+            
+        except Exception as e:
+            # Return error response format matching API
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)]
+            }
+    
+    def add_tags(self, organization_id: int, tags: List[str]) -> Dict[str, Any]:
+        """Add tags to organization."""
+        try:
+            # Prepare the payload according to API specification
+            payload = {"tags": tags}
+            
+            # Make the API call using PATCH method
+            response = self.http_client.patch(f"organizations/{organization_id}/tags", json_data=payload)
+            return response
+            
+        except Exception as e:
+            # Return error response format matching API
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)]
+            }
+    
+    def delete_tags(self, organization_id: int, tags: List[str]) -> Dict[str, Any]:
+        """Delete tags from organization."""
+        try:
+            # Prepare the payload according to API specification
+            payload = {"tags": tags}
+            
+            # Make the API call using DELETE method
+            response = self.http_client.delete(f"organizations/{organization_id}/tags", json_data=payload)
+            return response
+            
+        except Exception as e:
+            # Return error response format matching API
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)]
+            }
+    
+    def remove_tags(self, organization_id: int, tags: List[str]) -> Dict[str, Any]:
+        """Remove tags from organization (alias for delete_tags)."""
+        return self.delete_tags(organization_id, tags)
+
+    # ------------------------------------------------------------------
+    # New endpoints: user invitation & activation toggles
+    # ------------------------------------------------------------------
+
+    def resend_invitation(self, organization_id: int, user_id: str) -> Dict[str, Any]:
+        """Resend organization invitation email to a user.
+
+        Mirrors POST /organizations/{orgId}/resend-invitation/{userId}
+        """
+        try:
+            return self.http_client.post(
+                f"organizations/{organization_id}/resend-invitation/{user_id}",
+                json_data={},
+            )
+        except Exception as e:
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)],
+            }
+
+    def toggle_user_activation(self, organization_id: int, user_id: str) -> Dict[str, Any]:
+        """Toggle active / inactive status for a user in the organization.
+
+        Endpoint: POST /organizations/{orgId}/toggle-user-activation/{userId}
+        """
+        try:
+            return self.http_client.post(
+                f"organizations/{organization_id}/toggle-user-activation/{user_id}",
+                json_data={},
+            )
+        except Exception as e:
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)],
+            } 

binalyze_air/apis/params.py

@@ -1,40 +1,45 @@
-"""
-Params API for the Binalyze AIR SDK.
-"""
-
-from typing import List
-
-from ..http_client import HTTPClient
-from ..models.params import AcquisitionArtifact, EDiscoveryPattern, AcquisitionEvidence, DroneAnalyzer
-from ..queries.params import (
-    GetAcquisitionArtifactsQuery, GetEDiscoveryPatternsQuery, 
-    GetAcquisitionEvidencesQuery, GetDroneAnalyzersQuery
-)
-
-
-class ParamsAPI:
-    """Params API with CQRS pattern - read-only operations for parameters."""
-    
-    def __init__(self, http_client: HTTPClient):
-        self.http_client = http_client
-    
-    # QUERIES (Read operations only - params are read-only)
-    def get_acquisition_artifacts(self) -> List[AcquisitionArtifact]:
-        """Get available acquisition artifacts."""
-        query = GetAcquisitionArtifactsQuery(self.http_client)
-        return query.execute()
-    
-    def get_ediscovery_patterns(self) -> List[EDiscoveryPattern]:
-        """Get available e-discovery patterns."""
-        query = GetEDiscoveryPatternsQuery(self.http_client)
-        return query.execute()
-    
-    def get_acquisition_evidences(self) -> List[AcquisitionEvidence]:
-        """Get available acquisition evidence types."""
-        query = GetAcquisitionEvidencesQuery(self.http_client)
-        return query.execute()
-    
-    def get_drone_analyzers(self) -> List[DroneAnalyzer]:
-        """Get available drone analyzers."""
-        query = GetDroneAnalyzersQuery(self.http_client)
+"""
+Params API for the Binalyze AIR SDK.
+"""
+
+from typing import List
+
+from ..http_client import HTTPClient
+from ..models.params import AcquisitionArtifact, EDiscoveryPattern, AcquisitionEvidence, DroneAnalyzer, MitreAttackTactic
+from ..queries.params import (
+    GetAcquisitionArtifactsQuery, GetEDiscoveryPatternsQuery, 
+    GetAcquisitionEvidencesQuery, GetDroneAnalyzersQuery, GetMitreAttackTacticsQuery
+)
+
+
+class ParamsAPI:
+    """Params API with CQRS pattern - read-only operations for parameters."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations only - params are read-only)
+    def get_acquisition_artifacts(self) -> List[AcquisitionArtifact]:
+        """Get available acquisition artifacts."""
+        query = GetAcquisitionArtifactsQuery(self.http_client)
+        return query.execute()
+    
+    def get_ediscovery_patterns(self) -> List[EDiscoveryPattern]:
+        """Get available e-discovery patterns."""
+        query = GetEDiscoveryPatternsQuery(self.http_client)
+        return query.execute()
+    
+    def get_acquisition_evidences(self) -> List[AcquisitionEvidence]:
+        """Get available acquisition evidence types."""
+        query = GetAcquisitionEvidencesQuery(self.http_client)
+        return query.execute()
+    
+    def get_drone_analyzers(self) -> List[DroneAnalyzer]:
+        """Get available drone analyzers."""
+        query = GetDroneAnalyzersQuery(self.http_client)
+        return query.execute()
+    
+    def get_mitre_attack_tactics(self) -> List[MitreAttackTactic]:
+        """Get available MITRE ATT&CK tactics."""
+        query = GetMitreAttackTacticsQuery(self.http_client)
         return query.execute()