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

binalyze_air/apis/settings.py

@@ -0,0 +1,27 @@
+"""
+Settings API for the Binalyze AIR SDK.
+"""
+
+from ..http_client import HTTPClient
+from ..models.settings import BannerSettings, UpdateBannerSettingsRequest
+from ..queries.settings import GetBannerSettingsQuery
+from ..commands.settings import UpdateBannerSettingsCommand
+
+
+class SettingsAPI:
+    """Settings API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def get_banner_settings(self) -> BannerSettings:
+        """Get current banner settings."""
+        query = GetBannerSettingsQuery(self.http_client)
+        return query.execute()
+    
+    # COMMANDS (Write operations)
+    def update_banner_settings(self, request: UpdateBannerSettingsRequest) -> BannerSettings:
+        """Update banner settings."""
+        command = UpdateBannerSettingsCommand(self.http_client, request)
+        return command.execute() 

binalyze_air/apis/user_management.py

@@ -0,0 +1,74 @@
+"""
+User Management API for the Binalyze AIR SDK.
+"""
+
+from typing import List, Optional, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.user_management import (
+    UserManagementUser, UserFilter, CreateUserRequest, UpdateUserRequest,
+    AIUser, CreateAIUserRequest, APIUser, CreateAPIUserRequest
+)
+from ..queries.user_management import (
+    ListUsersQuery, GetUserQuery, GetAIUserQuery, GetAPIUserQuery
+)
+from ..commands.user_management import (
+    CreateUserCommand, UpdateUserCommand, DeleteUserCommand,
+    CreateAIUserCommand, CreateAPIUserCommand
+)
+
+
+class UserManagementAPI:
+    """User Management API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # USER QUERIES (Read operations)
+    def list_users(self, filter_params: Optional[UserFilter] = None) -> List[UserManagementUser]:
+        """List users with optional filtering."""
+        query = ListUsersQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get_user(self, user_id: str) -> UserManagementUser:
+        """Get a specific user by ID."""
+        query = GetUserQuery(self.http_client, user_id)
+        return query.execute()
+    
+    # USER COMMANDS (Write operations)
+    def create_user(self, request: CreateUserRequest) -> UserManagementUser:
+        """Create a new user."""
+        command = CreateUserCommand(self.http_client, request)
+        return command.execute()
+    
+    def update_user(self, user_id: str, request: UpdateUserRequest) -> UserManagementUser:
+        """Update an existing user."""
+        command = UpdateUserCommand(self.http_client, user_id, request)
+        return command.execute()
+    
+    def delete_user(self, user_id: str) -> Dict[str, Any]:
+        """Delete a user."""
+        command = DeleteUserCommand(self.http_client, user_id)
+        return command.execute()
+    
+    # AI USER OPERATIONS
+    def get_ai_user(self) -> AIUser:
+        """Get the AI user."""
+        query = GetAIUserQuery(self.http_client)
+        return query.execute()
+    
+    def create_ai_user(self, request: CreateAIUserRequest) -> AIUser:
+        """Create a new AI user."""
+        command = CreateAIUserCommand(self.http_client, request)
+        return command.execute()
+    
+    # API USER OPERATIONS
+    def get_api_user(self) -> APIUser:
+        """Get the API user."""
+        query = GetAPIUserQuery(self.http_client)
+        return query.execute()
+    
+    def create_api_user(self, request: CreateAPIUserRequest) -> APIUser:
+        """Create a new API user."""
+        command = CreateAPIUserCommand(self.http_client, request)
+        return command.execute() 

binalyze_air/apis/users.py

@@ -0,0 +1,68 @@
+"""
+Users API for the Binalyze AIR SDK.
+"""
+
+from typing import List, Optional, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.users import (
+    User, UserFilter, CreateUserRequest, UpdateUserRequest,
+    APIUser, CreateAPIUserRequest
+)
+from ..queries.users import (
+    ListUsersQuery, GetUserQuery
+)
+from ..commands.users import (
+    CreateUserCommand, UpdateUserCommand, DeleteUserCommand,
+    CreateAPIUserCommand
+)
+
+
+class UsersAPI:
+    """Users API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # USER QUERIES (Read operations)
+    def list(self, page_number: int = 1, page_size: int = 10, 
+             sort_by: str = "createdAt", sort_type: str = "ASC") -> List[User]:
+        """List users with pagination support."""
+        query = ListUsersQuery(self.http_client, page_number, page_size, sort_by, sort_type)
+        return query.execute()
+    
+    def get(self, user_id: str) -> User:
+        """Get a specific user by ID."""
+        query = GetUserQuery(self.http_client, user_id)
+        return query.execute()
+    
+    # USER COMMANDS (Write operations)
+    def create_user(self, request: CreateUserRequest) -> User:
+        """Create a new user."""
+        command = CreateUserCommand(self.http_client, request)
+        return command.execute()
+    
+    def update_user(self, user_id: str, request: UpdateUserRequest) -> User:
+        """Update an existing user."""
+        command = UpdateUserCommand(self.http_client, user_id, request)
+        return command.execute()
+    
+    def delete_user(self, user_id: str) -> Dict[str, Any]:
+        """Delete a user."""
+        command = DeleteUserCommand(self.http_client, user_id)
+        return command.execute()
+    
+    # API USER OPERATIONS
+    def create_api_user(self, username: str, email: str, organization_ids: List[int], 
+                       profile: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
+        """Create a new API user for programmatic access."""
+        request_data = {
+            "username": username,
+            "email": email,
+            "organizationIds": organization_ids
+        }
+        if profile:
+            request_data["profile"] = profile
+            
+        command = CreateAPIUserCommand(self.http_client, request_data)
+        return command.execute() 

binalyze_air/apis/webhooks.py

@@ -0,0 +1,231 @@
+"""
+Webhook API for the Binalyze AIR SDK.
+Provides webhook trigger functionality for programmatically calling webhook endpoints.
+"""
+
+from typing import Dict, Any, Optional, List, Union
+import json
+
+from ..http_client import HTTPClient
+
+
+class WebhookAPI:
+    """Webhook API for triggering webhook endpoints programmatically."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    def trigger_get(
+        self, 
+        slug: str, 
+        data: str, 
+        token: str,
+        use_webhook_endpoint: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Trigger a webhook via GET request.
+        
+        Args:
+            slug: Webhook slug/name
+            data: Comma-separated hostnames or IP addresses  
+            token: Webhook token
+            use_webhook_endpoint: If True, use webhook endpoint directly (no auth needed)
+                                If False, use authenticated API endpoint
+        
+        Returns:
+            Dict containing task details and URLs
+        """
+        if use_webhook_endpoint:
+            # Direct webhook call - no authentication needed, just token
+            endpoint = f"webhook/{slug}/{data}"
+            params = {"token": token}
+            
+            # Use raw HTTP client for webhook endpoints (they don't use standard API auth)
+            import requests
+            base_url = self.http_client.config.host
+            url = f"{base_url}/api/{endpoint}"
+            
+            response = requests.get(
+                url,
+                params=params,
+                verify=self.http_client.config.verify_ssl,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 403:
+                return {
+                    "success": False,
+                    "error": "Forbidden",
+                    "message": "Invalid webhook token",
+                    "statusCode": 403
+                }
+            elif response.status_code == 404:
+                return {
+                    "success": False,
+                    "error": "Not Found", 
+                    "message": "Webhook not found",
+                    "statusCode": 404
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"HTTP {response.status_code}",
+                    "message": response.text,
+                    "statusCode": response.status_code
+                }
+        else:
+            # Use authenticated API endpoint (if available)
+            endpoint = f"webhook/{slug}/{data}"
+            params = {"token": token}
+            return self.http_client.get(endpoint, params=params)
+    
+    def trigger_post(
+        self, 
+        slug: str, 
+        token: str,
+        payload: Optional[Dict[str, Any]] = None,
+        use_webhook_endpoint: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Trigger a webhook via POST request.
+        
+        Args:
+            slug: Webhook slug/name
+            token: Webhook token
+            payload: Optional POST data/payload
+            use_webhook_endpoint: If True, use webhook endpoint directly (no auth needed)
+                                If False, use authenticated API endpoint
+        
+        Returns:
+            Dict containing task details and URLs
+        """
+        if payload is None:
+            payload = {}
+            
+        if use_webhook_endpoint:
+            # Direct webhook call - no authentication needed, just token
+            endpoint = f"webhook/{slug}"
+            params = {"token": token}
+            
+            # Use raw HTTP client for webhook endpoints
+            import requests
+            base_url = self.http_client.config.host
+            url = f"{base_url}/api/{endpoint}"
+            
+            response = requests.post(
+                url,
+                params=params,
+                json=payload,
+                verify=self.http_client.config.verify_ssl,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 403:
+                return {
+                    "success": False,
+                    "error": "Forbidden",
+                    "message": "Invalid webhook token",
+                    "statusCode": 403
+                }
+            elif response.status_code == 404:
+                return {
+                    "success": False,
+                    "error": "Not Found",
+                    "message": "Webhook not found", 
+                    "statusCode": 404
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"HTTP {response.status_code}",
+                    "message": response.text,
+                    "statusCode": response.status_code
+                }
+        else:
+            # Use authenticated API endpoint (if available)
+            endpoint = f"webhook/{slug}"
+            params = {"token": token}
+            return self.http_client.post(endpoint, json_data=payload, params=params)
+    
+    def get_task_details(
+        self, 
+        slug: str, 
+        token: str, 
+        task_id: str,
+        use_webhook_endpoint: bool = True
+    ) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+        """
+        Get task assignment details from a webhook.
+        
+        Args:
+            slug: Webhook slug/name
+            token: Webhook token
+            task_id: Task ID returned from webhook trigger
+            use_webhook_endpoint: If True, use webhook endpoint directly (no auth needed)
+                                If False, use authenticated API endpoint
+        
+        Returns:
+            List of task assignment details or Dict with error info
+        """
+        if use_webhook_endpoint:
+            # Direct webhook call - no authentication needed, just token
+            endpoint = f"webhook/{slug}/assignments"
+            params = {"token": token, "taskId": task_id}
+            
+            # Use raw HTTP client for webhook endpoints
+            import requests
+            base_url = self.http_client.config.host
+            url = f"{base_url}/api/{endpoint}"
+            
+            response = requests.get(
+                url,
+                params=params,
+                verify=self.http_client.config.verify_ssl,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 403:
+                return {
+                    "success": False,
+                    "error": "Forbidden",
+                    "message": "Invalid webhook token",
+                    "statusCode": 403
+                }
+            elif response.status_code == 404:
+                return {
+                    "success": False,
+                    "error": "Not Found",
+                    "message": "Task not found",
+                    "statusCode": 404
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"HTTP {response.status_code}",
+                    "message": response.text,
+                    "statusCode": response.status_code
+                }
+        else:
+            # Use authenticated API endpoint (if available)
+            endpoint = f"webhook/{slug}/assignments"
+            params = {"token": token, "taskId": task_id}
+            return self.http_client.get(endpoint, params=params)
+    
+    # Convenience methods with better names
+    def call_webhook_get(self, slug: str, data: str, token: str) -> Dict[str, Any]:
+        """Convenience method to call a webhook via GET."""
+        return self.trigger_get(slug, data, token)
+    
+    def call_webhook_post(self, slug: str, token: str, payload: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Convenience method to call a webhook via POST."""
+        return self.trigger_post(slug, token, payload)
+    
+    def get_webhook_task_data(self, slug: str, token: str, task_id: str) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+        """Convenience method to get webhook task assignment data."""
+        return self.get_task_details(slug, token, task_id) 

binalyze_air/base.py

@@ -0,0 +1,133 @@
+"""
+Base classes for CQRS implementation in the AIR SDK.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, TypeVar, Generic
+from pydantic import BaseModel as PydanticBaseModel, ConfigDict
+
+T = TypeVar("T")
+
+
+class Query(Generic[T], ABC):
+    """Base class for all queries (read operations)."""
+    
+    @abstractmethod
+    def execute(self) -> T:
+        """Execute the query and return the result."""
+        pass
+
+
+class Command(Generic[T], ABC):
+    """Base class for all commands (write operations)."""
+    
+    @abstractmethod
+    def execute(self) -> T:
+        """Execute the command and return the result."""
+        pass
+
+
+class AIRBaseModel(PydanticBaseModel):
+    """Base Pydantic model with common configurations."""
+    
+    model_config = ConfigDict(
+        use_enum_values=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True
+    )
+
+
+class PaginatedResponse(AIRBaseModel, Generic[T]):
+    """Generic paginated response model."""
+    
+    entities: List[T]
+    total_entity_count: int
+    current_page: int
+    page_size: int
+    total_page_count: int
+    previous_page: Optional[int] = None
+    next_page: Optional[int] = None
+
+
+class APIResponse(AIRBaseModel, Generic[T]):
+    """Generic API response model."""
+    
+    success: bool
+    result: T
+    status_code: int
+    errors: List[str] = []
+
+
+class Filter(AIRBaseModel):
+    """Base filter model for queries with pagination and sorting support."""
+    
+    # Basic filter fields
+    search_term: Optional[str] = None
+    organization_ids: Optional[List[int]] = None
+    
+    # Pagination parameters (match API documentation exactly) - no defaults
+    page_number: Optional[int] = None
+    page_size: Optional[int] = None
+    
+    # Sorting parameters (match API documentation exactly) - no defaults
+    sort_by: Optional[str] = None
+    sort_type: Optional[str] = None
+    
+    def to_params(self) -> Dict[str, Any]:
+        """Convert filter to API parameters."""
+        params = {}
+        
+        # Pagination parameters (not in filter namespace) - only if set
+        if self.page_number is not None:
+            params["pageNumber"] = self.page_number
+        if self.page_size is not None:
+            params["pageSize"] = self.page_size
+        if self.sort_by is not None:
+            params["sortBy"] = self.sort_by
+        if self.sort_type is not None:
+            params["sortType"] = self.sort_type
+        
+        # Filter parameters (in filter namespace)
+        for field_name, field_value in self.model_dump(exclude_none=True).items():
+            # Skip pagination/sorting fields as they're handled above
+            if field_name in ["page_number", "page_size", "sort_by", "sort_type"]:
+                continue
+                
+            if field_value is not None:
+                if isinstance(field_value, list):
+                    params[f"filter[{field_name}]"] = ",".join(map(str, field_value))
+                else:
+                    params[f"filter[{field_name}]"] = str(field_value)
+        return params 
+
+
+class PaginatedList(list):
+    """List-like container that carries pagination metadata.
+    This allows SDK query methods to return a normal iterable while still
+    exposing additional pagination attributes such as total_entity_count.
+    The class simply subclasses ``list`` and adds attributes during
+    construction. All standard list operations remain intact.
+    """
+    def __init__(
+        self,
+        iterable=None,
+        *,
+        total_entity_count: int | None = None,
+        current_page: int | None = None,
+        page_size: int | None = None,
+        total_page_count: int | None = None,
+    ) -> None:
+        super().__init__(iterable or [])
+        # Store metadata for caller introspection
+        self.total_entity_count = total_entity_count
+        self.current_page = current_page
+        self.page_size = page_size
+        self.total_page_count = total_page_count
+
+    # Optional: pretty representation including meta for debugging
+    def __repr__(self) -> str:  # noqa: D401
+        meta = (
+            f" total={self.total_entity_count} page={self.current_page} "
+            f"size={self.page_size} pages={self.total_page_count}"
+        )
+        return f"PaginatedList({list.__repr__(self)},{meta})"