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

binalyze_air/commands/assets.py

@@ -0,0 +1,363 @@
+"""
+Asset-related commands for the Binalyze AIR SDK.
+Fixed to match API documentation exactly.
+"""
+
+from typing import List, Union, Optional, Dict, Any
+
+from ..base import Command
+from ..models.assets import AssetFilter
+from ..http_client import HTTPClient
+
+
+class RebootAssetsCommand(Command[Dict[str, Any]]):
+    """Command to reboot assets by filter - FIXED to match API documentation."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the reboot command with correct payload structure."""
+        # Use the correct payload structure as per API documentation
+        payload = {
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # FIXED: Correct endpoint URL (confirmed from API docs)
+        return self.http_client.post("assets/tasks/reboot", json_data=payload)
+
+
+class ShutdownAssetsCommand(Command[Dict[str, Any]]):
+    """Command to shutdown assets by filter - FIXED to match API documentation."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the shutdown command with correct payload structure."""
+        payload = {
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # FIXED: Correct endpoint URL (following same pattern as reboot)
+        return self.http_client.post("assets/tasks/shutdown", json_data=payload)
+
+
+class IsolateAssetsCommand(Command[Dict[str, Any]]):
+    """Command to isolate assets by filter - FIXED to match API documentation."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter,
+        isolation_settings: Optional[Dict[str, Any]] = None
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+        self.isolation_settings = isolation_settings or {}
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the isolation command with correct payload structure."""
+        payload = {
+            "enabled": True,  # Required field for isolation
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # Add isolation settings if provided
+        if self.isolation_settings:
+            payload.update(self.isolation_settings)
+        
+        # FIXED: Correct endpoint URL and payload
+        return self.http_client.post("assets/tasks/isolation", json_data=payload)
+
+
+class UnisolateAssetsCommand(Command[Dict[str, Any]]):
+    """Command to unisolate (remove isolation from) assets - FIXED to match API documentation."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the unisolate command with correct payload structure."""
+        payload = {
+            "enabled": False,  # Disable isolation for unisolate
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # FIXED: Correct endpoint URL and payload
+        return self.http_client.post("assets/tasks/isolation", json_data=payload)
+
+
+class LogRetrievalCommand(Command[Dict[str, Any]]):
+    """Command to retrieve logs from assets - FIXED endpoint URL and payload structure."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter,
+        log_settings: Optional[Dict[str, Any]] = None
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+        self.log_settings = log_settings or {}
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the log retrieval command with correct endpoint and payload."""
+        payload = {
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # Add log retrieval settings if provided
+        if self.log_settings:
+            payload.update(self.log_settings)
+        
+        # FIXED: Correct endpoint URL to match API specification
+        return self.http_client.post("assets/tasks/retrieve-logs", json_data=payload)
+
+
+class VersionUpdateCommand(Command[Dict[str, Any]]):
+    """Command to update version on assets - FIXED to match API documentation."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter,
+        update_settings: Optional[Dict[str, Any]] = None
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+        self.update_settings = update_settings or {}
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the version update command with correct payload structure."""
+        payload = {
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # Add version update settings if provided
+        if self.update_settings:
+            payload.update(self.update_settings)
+        
+        # FIXED: Correct endpoint URL (following tasks pattern)
+        return self.http_client.post("assets/tasks/version-update", json_data=payload)
+
+
+class UninstallAssetsCommand(Command[Dict[str, Any]]):
+    """Command to uninstall assets without purging data - FIXED endpoint URL and HTTP method."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the uninstall command with correct endpoint, HTTP method and payload structure."""
+        payload = {
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # FIXED: Correct endpoint URL and HTTP method (DELETE, not POST)
+        return self.http_client.delete("assets/uninstall-without-purge", json_data=payload)
+
+
+class PurgeAndUninstallAssetsCommand(Command[Dict[str, Any]]):
+    """Command to purge and uninstall assets - FIXED endpoint URL and HTTP method."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the purge and uninstall command with correct endpoint, HTTP method and payload."""
+        payload = {
+            "filter": self.asset_filter.to_filter_dict()
+        }
+        
+        # FIXED: Correct endpoint URL and HTTP method (DELETE, not POST)
+        return self.http_client.delete("assets/purge-and-uninstall", json_data=payload)
+
+
+class AddTagsToAssetsCommand(Command[Dict[str, Any]]):
+    """Command to add tags to assets - FIXED endpoint URL and payload structure."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter,
+        tags: List[str]
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+        self.tags = tags
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the add tags command with correct endpoint and payload structure."""
+        payload = {
+            "filter": self.asset_filter.to_filter_dict(),
+            "tags": self.tags
+        }
+        
+        # FIXED: Correct endpoint URL (from API documentation) 
+        return self.http_client.post("assets/tags", json_data=payload)
+
+
+class RemoveTagsFromAssetsCommand(Command[Dict[str, Any]]):
+    """Command to remove tags from assets - FIXED endpoint URL and HTTP method."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        asset_filter: AssetFilter,
+        tags: List[str]
+    ):
+        self.http_client = http_client
+        self.asset_filter = asset_filter
+        self.tags = tags
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the remove tags command with correct endpoint, HTTP method and payload structure."""
+        payload = {
+            "filter": self.asset_filter.to_filter_dict(),
+            "tags": self.tags
+        }
+        
+        # FIXED: Correct endpoint URL and HTTP method (DELETE, not POST)
+        return self.http_client.delete("assets/tags", json_data=payload)
+
+
+# Convenience functions for backward compatibility
+def create_asset_filter_from_endpoint_ids(
+    endpoint_ids: Union[str, List[str]], 
+    organization_ids: Optional[List[Union[int, str]]] = None
+) -> AssetFilter:
+    """Create an AssetFilter from endpoint IDs for backward compatibility."""
+    if isinstance(endpoint_ids, str):
+        endpoint_ids = [endpoint_ids]
+    
+    org_ids = [int(org_id) for org_id in (organization_ids or [0])]
+    
+    return AssetFilter(
+        included_endpoint_ids=endpoint_ids,
+        organization_ids=org_ids,
+        managed_status=["managed"]  # Default to managed assets
+    )
+
+
+# Backward compatibility command classes that use endpoint IDs directly
+class IsolateAssetsByIdCommand(Command[Dict[str, Any]]):
+    """Legacy command to isolate assets by endpoint IDs - uses correct API structure."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        endpoint_ids: Union[str, List[str]], 
+        organization_ids: Optional[List[Union[int, str]]] = None
+    ):
+        self.http_client = http_client
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        self.command = IsolateAssetsCommand(http_client, asset_filter)
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute through the correct filter-based command."""
+        return self.command.execute()
+
+
+class UnisolateAssetsByIdCommand(Command[Dict[str, Any]]):
+    """Legacy command to unisolate assets by endpoint IDs - uses correct API structure."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        endpoint_ids: Union[str, List[str]], 
+        organization_ids: Optional[List[Union[int, str]]] = None
+    ):
+        self.http_client = http_client
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        self.command = UnisolateAssetsCommand(http_client, asset_filter)
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute through the correct filter-based command."""
+        return self.command.execute()
+
+
+class RebootAssetsByIdCommand(Command[Dict[str, Any]]):
+    """Legacy command to reboot assets by endpoint IDs - uses correct API structure."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        endpoint_ids: Union[str, List[str]], 
+        organization_ids: Optional[List[Union[int, str]]] = None
+    ):
+        self.http_client = http_client
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        self.command = RebootAssetsCommand(http_client, asset_filter)
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute through the correct filter-based command."""
+        return self.command.execute()
+
+
+class ShutdownAssetsByIdCommand(Command[Dict[str, Any]]):
+    """Legacy command to shutdown assets by endpoint IDs - uses correct API structure."""
+    
+    def __init__(
+        self, 
+        http_client: HTTPClient, 
+        endpoint_ids: Union[str, List[str]], 
+        organization_ids: Optional[List[Union[int, str]]] = None
+    ):
+        self.http_client = http_client
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        self.command = ShutdownAssetsCommand(http_client, asset_filter) 
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute through the correct filter-based command."""
+        return self.command.execute()
+
+
+# Export the main corrected classes
+__all__ = [
+    # Main corrected commands
+    'RebootAssetsCommand',
+    'ShutdownAssetsCommand', 
+    'IsolateAssetsCommand',
+    'UnisolateAssetsCommand',
+    'LogRetrievalCommand',
+    'VersionUpdateCommand',
+    'UninstallAssetsCommand',
+    'PurgeAndUninstallAssetsCommand',
+    'AddTagsToAssetsCommand',
+    'RemoveTagsFromAssetsCommand',
+    
+    # Legacy compatibility commands
+    'IsolateAssetsByIdCommand',
+    'UnisolateAssetsByIdCommand', 
+    'RebootAssetsByIdCommand',
+    'ShutdownAssetsByIdCommand',
+    
+    # Utility functions
+    'create_asset_filter_from_endpoint_ids'
+] 

binalyze_air/commands/authentication.py

@@ -0,0 +1,37 @@
+"""
+Authentication-related commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, Union
+
+from ..base import Command
+from ..models.authentication import LoginRequest, LoginResponse
+from ..http_client import HTTPClient
+
+
+class LoginCommand(Command[LoginResponse]):
+    """Command to login user."""
+    
+    def __init__(self, http_client: HTTPClient, request: Union[LoginRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> LoginResponse:
+        """Execute the login command."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            payload = self.request
+        else:
+            payload = {
+                "username": self.request.username,
+                "password": self.request.password
+            }
+        
+        response = self.http_client.post("auth/login", json_data=payload)
+        
+        if response.get("success"):
+            result = response.get("result", {})
+            return LoginResponse(**result)
+        else:
+            # This will typically raise an exception via http_client error handling
+            raise Exception(f"Login failed: {response.get('error', 'Unknown error')}") 

binalyze_air/commands/auto_asset_tags.py

@@ -0,0 +1,231 @@
+"""
+Auto Asset Tags-related commands for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, Union
+
+from ..base import Command
+from ..models.auto_asset_tags import (
+    AutoAssetTag, CreateAutoAssetTagRequest, UpdateAutoAssetTagRequest,
+    StartTaggingRequest, TaggingResult, TaggingResponse
+)
+from ..http_client import HTTPClient
+from ..exceptions import ServerError, ValidationError
+from ..queries.auto_asset_tags import GetAutoAssetTagQuery
+
+
+class CreateAutoAssetTagCommand(Command[AutoAssetTag]):
+    """Command to create auto asset tag."""
+    
+    def __init__(self, http_client: HTTPClient, request: Union[CreateAutoAssetTagRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> AutoAssetTag:
+        """Execute the create auto asset tag command."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            payload = self.request
+        else:
+            payload = self.request.model_dump(by_alias=True, exclude_none=False)
+        
+        # Validate payload format before sending to API
+        self._validate_payload_format(payload)
+        
+        try:
+            response = self.http_client.post("auto-asset-tag", json_data=payload)
+            
+            if response.get("success"):
+                tag_data = response.get("result", {})
+                return AutoAssetTag(**tag_data)
+            
+            raise Exception(f"Failed to create auto asset tag: {response.get('error', 'Unknown error')}")
+            
+        except ServerError as e:
+            if e.status_code == 500:
+                # Provide better error message for format issues
+                raise ValidationError(
+                    f"Auto asset tag creation failed due to invalid format. "
+                    f"Please ensure all conditions follow the required nested structure:\n"
+                    f"- Each condition group must have 'operator' (and/or) and 'conditions' array\n"
+                    f"- Individual conditions must have 'field', 'operator', and 'value'\n"
+                    f"- Required fields: linuxConditions, windowsConditions, macosConditions\n"
+                    f"Example format: {{\n"
+                    f"  'linuxConditions': {{\n"
+                    f"    'operator': 'and',\n"
+                    f"    'conditions': [{{\n"
+                    f"      'operator': 'or',\n"
+                    f"      'conditions': [{{\n"
+                    f"        'field': 'hostname',\n"
+                    f"        'operator': 'contains',\n"
+                    f"        'value': 'test'\n"
+                    f"      }}]\n"
+                    f"    }}]\n"
+                    f"  }}\n"
+                    f"}}\n"
+                    f"Original error: {str(e)}"
+                )
+            else:
+                # Re-raise other server errors
+                raise
+    
+    def _validate_payload_format(self, payload: Dict[str, Any]) -> None:
+        """Validate the payload format before sending to API."""
+        required_fields = ["tag"]
+        condition_fields = ["linuxConditions", "windowsConditions", "macosConditions"]
+        
+        # Check required fields
+        for field in required_fields:
+            if field not in payload:
+                raise ValidationError(f"Missing required field: {field}")
+        
+        # Validate at least one condition is provided
+        has_conditions = any(field in payload for field in condition_fields)
+        if not has_conditions:
+            raise ValidationError(
+                f"At least one condition type must be provided: {', '.join(condition_fields)}"
+            )
+        
+        # Validate condition structure for provided conditions
+        for condition_type in condition_fields:
+            if condition_type in payload:
+                self._validate_condition_structure(payload[condition_type], condition_type)
+    
+    def _validate_condition_structure(self, condition: Dict[str, Any], condition_type: str) -> None:
+        """Validate the structure of a condition group."""
+        if not isinstance(condition, dict):
+            raise ValidationError(f"{condition_type} must be an object")
+        
+        # Check for required fields in condition group
+        if "operator" not in condition:
+            raise ValidationError(f"{condition_type}.operator is required")
+        
+        if condition["operator"] not in ["and", "or"]:
+            raise ValidationError(f"{condition_type}.operator must be 'and' or 'or'")
+        
+        if "conditions" not in condition:
+            raise ValidationError(f"{condition_type}.conditions array is required")
+        
+        if not isinstance(condition["conditions"], list):
+            raise ValidationError(f"{condition_type}.conditions must be an array")
+        
+        # Validate each nested condition
+        for i, nested_condition in enumerate(condition["conditions"]):
+            if not isinstance(nested_condition, dict):
+                raise ValidationError(f"{condition_type}.conditions[{i}] must be an object")
+            
+            # Check if it's a group condition or individual condition
+            if "conditions" in nested_condition:
+                # It's a nested group - validate recursively
+                self._validate_condition_structure(nested_condition, f"{condition_type}.conditions[{i}]")
+            else:
+                # It's an individual condition - validate fields
+                required_condition_fields = ["field", "operator", "value"]
+                for field in required_condition_fields:
+                    if field not in nested_condition:
+                        raise ValidationError(
+                            f"{condition_type}.conditions[{i}].{field} is required"
+                        )
+
+
+class UpdateAutoAssetTagCommand(Command[AutoAssetTag]):
+    """Command to update auto asset tag."""
+    
+    def __init__(self, http_client: HTTPClient, tag_id: str, request: Union[UpdateAutoAssetTagRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.tag_id = tag_id
+        self.request = request
+    
+    def execute(self) -> AutoAssetTag:
+        """Execute the update auto asset tag command."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            payload = self.request
+        else:
+            payload = self.request.model_dump(by_alias=True, exclude_none=True)
+        
+        try:
+            response = self.http_client.put(f"auto-asset-tag/{self.tag_id}", json_data=payload)
+            
+            if response.get("success"):
+                tag_data = response.get("result", {})
+                return AutoAssetTag(**tag_data)
+            
+            raise Exception(f"Failed to update auto asset tag: {response.get('error', 'Unknown error')}")
+            
+        except ServerError as e:
+            # API-002 Workaround: If update fails with server error, provide helpful message
+            # with alternative approach (delete + recreate)
+            if "Auto asset tag update is currently unavailable" in str(e):
+                # Get the current tag data for reference
+                try:
+                    get_query = GetAutoAssetTagQuery(self.http_client, self.tag_id)
+                    current_tag = get_query.execute()
+                    
+                    # Merge current data with updates
+                    updated_data = current_tag.model_dump()
+                    updated_data.update(payload)
+                    
+                    raise ValidationError(
+                        f"Auto asset tag update is currently unavailable due to a server bug. "
+                        f"WORKAROUND: To update this tag, please:\n"
+                        f"1. Delete the existing tag (ID: {self.tag_id})\n"
+                        f"2. Create a new tag with the updated data:\n"
+                        f"   Tag: {updated_data.get('tag', current_tag.tag)}\n"
+                        f"   Organization IDs: {updated_data.get('organizationIds', current_tag.organization_ids)}\n"
+                        f"   Linux Conditions: {updated_data.get('linuxConditions', current_tag.linux_conditions)}\n"
+                        f"   Windows Conditions: {updated_data.get('windowsConditions', current_tag.windows_conditions)}\n"
+                        f"   macOS Conditions: {updated_data.get('macosConditions', current_tag.macos_conditions)}\n"
+                        f"\nUse client.auto_asset_tags.delete('{self.tag_id}') then client.auto_asset_tags.create(new_data)"
+                    )
+                except Exception:
+                    # If we can't get current data, provide generic workaround message
+                    raise ValidationError(
+                        f"Auto asset tag update is currently unavailable due to a server bug. "
+                        f"WORKAROUND: Delete the existing tag (ID: {self.tag_id}) and create a new one with updated values."
+                    )
+            else:
+                # Re-raise if it's a different server error
+                raise
+
+
+class DeleteAutoAssetTagCommand(Command[Dict[str, Any]]):
+    """Command to delete auto asset tag."""
+    
+    def __init__(self, http_client: HTTPClient, tag_id: str):
+        self.http_client = http_client
+        self.tag_id = tag_id
+    
+    def execute(self) -> Dict[str, Any]:
+        """Execute the delete auto asset tag command."""
+        response = self.http_client.delete(f"auto-asset-tag/{self.tag_id}")
+        
+        if response.get("success"):
+            return response
+        
+        raise Exception(f"Failed to delete auto asset tag: {response.get('error', 'Unknown error')}")
+
+
+class StartTaggingCommand(Command[TaggingResponse]):
+    """Command to start tagging process."""
+    
+    def __init__(self, http_client: HTTPClient, request: Union[StartTaggingRequest, Dict[str, Any]]):
+        self.http_client = http_client
+        self.request = request
+    
+    def execute(self) -> TaggingResponse:
+        """Execute the start tagging command."""
+        # Handle both dict and model objects
+        if isinstance(self.request, dict):
+            payload = self.request
+        else:
+            payload = self.request.model_dump(by_alias=True, exclude_none=True)
+        
+        response = self.http_client.post("auto-asset-tag/start-tagging", json_data=payload)
+        
+        if response.get("success"):
+            result_data = response.get("result", [])
+            # Handle the list response from the API
+            return TaggingResponse.from_api_result(result_data)
+        
+        raise Exception(f"Failed to start tagging process: {response.get('error', 'Unknown error')}")