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

binalyze_air/apis/triage.py

@@ -0,0 +1,197 @@
+"""
+Triage API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any, Union
+from ..http_client import HTTPClient
+from ..models.triage import (
+    TriageRule, TriageTag, TriageFilter,
+    CreateTriageRuleRequest, UpdateTriageRuleRequest, CreateTriageTagRequest
+)
+from ..queries.triage import (
+    ListTriageRulesQuery,
+    GetTriageRuleQuery,
+    ListTriageTagsQuery,
+)
+from ..commands.triage import (
+    CreateTriageRuleCommand,
+    UpdateTriageRuleCommand,
+    DeleteTriageRuleCommand,
+    CreateTriageTagCommand,
+)
+
+
+class TriageAPI:
+    """Triage API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def list_rules(self, filter_params: Optional[TriageFilter] = None, organization_ids: Optional[List[int]] = None) -> List[TriageRule]:
+        """List triage rules with optional filtering."""
+        query = ListTriageRulesQuery(self.http_client, filter_params, organization_ids)
+        return query.execute()
+    
+    def get_rule(self, rule_id: str) -> TriageRule:
+        """Get a specific triage rule by ID."""
+        query = GetTriageRuleQuery(self.http_client, rule_id)
+        return query.execute()
+    
+    def get_rule_by_id(self, rule_id: str) -> TriageRule:
+        """Get a specific triage rule by ID - alias for get_rule."""
+        return self.get_rule(rule_id)
+    
+    def list_tags(self, organization_id: Optional[int] = None) -> List[TriageTag]:
+        """List triage tags."""
+        query = ListTriageTagsQuery(self.http_client, organization_id)
+        return query.execute()
+    
+    def validate_rule(self, rule_content: str, engine: str = "yara") -> Dict[str, Any]:
+        """Validate triage rule syntax."""
+        try:
+            # Prepare validation data
+            validation_data = {
+                "rule": rule_content,
+                "engine": engine
+            }
+            
+            # Call the API validation endpoint
+            response = self.http_client.post("triages/rules/validate", json_data=validation_data)
+            return response
+            
+        except Exception as e:
+            # Return error response format matching API
+            return {
+                "success": False,
+                "result": None,
+                "statusCode": 500,
+                "errors": [str(e)]
+            }
+    
+    # COMMANDS (Write operations)
+    def create_rule(self, request: Union[CreateTriageRuleRequest, Dict[str, Any]]) -> TriageRule:
+        """Create a new triage rule."""
+        command = CreateTriageRuleCommand(self.http_client, request)
+        return command.execute()
+    
+    def update_rule(self, rule_id_or_data: Union[str, Dict[str, Any]], request: Optional[Union[UpdateTriageRuleRequest, Dict[str, Any]]] = None) -> TriageRule:
+        """Update an existing triage rule."""
+        # Handle both signatures: update_rule(rule_id, request) and update_rule(data_dict)
+        if isinstance(rule_id_or_data, str) and request is not None:
+            # Traditional signature: update_rule(rule_id, request)
+            command = UpdateTriageRuleCommand(self.http_client, rule_id_or_data, request)
+        elif isinstance(rule_id_or_data, dict):
+            # Dict signature: update_rule(data_dict) where data_dict contains 'id'
+            rule_id = rule_id_or_data.get('id')
+            if not rule_id:
+                raise ValueError("Rule ID must be provided in data dict or as separate parameter")
+            command = UpdateTriageRuleCommand(self.http_client, rule_id, rule_id_or_data)
+        else:
+            raise ValueError("Invalid arguments for update_rule")
+        
+        return command.execute()
+    
+    def delete_rule(self, rule_id: str) -> Dict[str, Any]:
+        """Delete a triage rule."""
+        command = DeleteTriageRuleCommand(self.http_client, rule_id)
+        return command.execute()
+    
+    def create_tag(self, request: Union[CreateTriageTagRequest, Dict[str, Any]]) -> TriageTag:
+        """Create a new triage tag."""
+        command = CreateTriageTagCommand(self.http_client, request)
+        return command.execute()
+    
+    def assign_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Assign a triage task to endpoints."""
+        try:
+            # Call the correct API endpoint for triage task assignment
+            response = self.http_client.post("triages/triage", json_data=task_data)
+            return response
+        except Exception as e:
+            # Import specific exception types
+            from ..exceptions import AuthorizationError, AuthenticationError, ValidationError, AIRAPIError
+            
+            # Handle specific API errors and preserve status codes
+            if isinstance(e, (AuthorizationError, AuthenticationError, ValidationError, AIRAPIError)):
+                # Return the actual API error response if available
+                if hasattr(e, 'response_data') and e.response_data:
+                    return e.response_data
+                else:
+                    # Create response matching API format with actual status code
+                    return {
+                        "success": False,
+                        "result": None,
+                        "statusCode": getattr(e, 'status_code', 500),
+                        "errors": [str(e)]
+                    }
+            else:
+                # For unexpected errors, use 500
+                return {
+                    "success": False,
+                    "result": None,
+                    "statusCode": 500,
+                    "errors": [str(e)]
+                }
+    
+    def update_scheduled_triage(self, triage_id: str, update_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update a scheduled triage task."""
+        try:
+            response = self.http_client.put(f"triages/schedule/triage/{triage_id}", json_data=update_data)
+            return response
+        except Exception as e:
+            # Import specific exception types
+            from ..exceptions import AuthorizationError, AuthenticationError, ValidationError, AIRAPIError
+            
+            # Handle specific API errors and preserve status codes
+            if isinstance(e, (AuthorizationError, AuthenticationError, ValidationError, AIRAPIError)):
+                # Return the actual API error response if available
+                if hasattr(e, 'response_data') and e.response_data:
+                    return e.response_data
+                else:
+                    # Create response matching API format with actual status code
+                    return {
+                        "success": False,
+                        "result": None,
+                        "statusCode": getattr(e, 'status_code', 500),
+                        "errors": [str(e)]
+                    }
+            else:
+                # For unexpected errors, use 500
+                return {
+                    "success": False,
+                    "result": None,
+                    "statusCode": 500,
+                    "errors": [str(e)]
+                }
+    
+    def create_off_network_triage_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create an off-network triage task file."""
+        try:
+            response = self.http_client.post("triages/triage/off-network", json_data=task_data)
+            return response
+        except Exception as e:
+            # Import specific exception types
+            from ..exceptions import AuthorizationError, AuthenticationError, ValidationError, AIRAPIError
+            
+            # Handle specific API errors and preserve status codes
+            if isinstance(e, (AuthorizationError, AuthenticationError, ValidationError, AIRAPIError)):
+                # Return the actual API error response if available
+                if hasattr(e, 'response_data') and e.response_data:
+                    return e.response_data
+                else:
+                    # Create response matching API format with actual status code
+                    return {
+                        "success": False,
+                        "result": None,
+                        "statusCode": getattr(e, 'status_code', 500),
+                        "errors": [str(e)]
+                    }
+            else:
+                # For unexpected errors, use 500
+                return {
+                    "success": False,
+                    "result": None,
+                    "statusCode": 500,
+                    "errors": [str(e)]
+                } 

binalyze_air/apis/user_management.py

@@ -1,74 +1,183 @@
-"""
-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() 
+"""
+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,
+    ChangePasswordRequest, SetAPIUserPasswordRequest, ResetPasswordRequest,
+    Role, CreateRoleRequest, UpdateRoleRequest, Privilege,
+    UserGroup, CreateUserGroupRequest, UpdateUserGroupRequest, UserGroupFilter
+)
+from ..queries.user_management import (
+    ListUsersQuery, GetUserQuery, GetAIUserQuery, GetAPIUserQuery,
+    GetPrivilegesQuery, ListRolesQuery, GetRoleQuery,
+    ListUserGroupsQuery, GetUserGroupQuery
+)
+from ..commands.user_management import (
+    CreateUserCommand, UpdateUserCommand, DeleteUserCommand,
+    CreateAIUserCommand, CreateAPIUserCommand,
+    ChangeCurrentUserPasswordCommand, SetAPIUserPasswordCommand, 
+    ResetPasswordCommand, ResetTFACommand,
+    CreateRoleCommand, UpdateRoleCommand, DeleteRoleCommand,
+    CreateUserGroupCommand, UpdateUserGroupCommand, DeleteUserGroupCommand
+)
+
+
+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()
+    
+    # PASSWORD MANAGEMENT COMMANDS
+    def change_current_user_password(self, request: ChangePasswordRequest) -> Dict[str, Any]:
+        """Change current user password."""
+        command = ChangeCurrentUserPasswordCommand(self.http_client, request)
+        return command.execute()
+    
+    def set_current_api_user_password_by_id(self, request: SetAPIUserPasswordRequest) -> Dict[str, Any]:
+        """Set current API user password by ID."""
+        command = SetAPIUserPasswordCommand(self.http_client, request)
+        return command.execute()
+    
+    def reset_password_by_id(self, user_id: str, request: ResetPasswordRequest) -> Dict[str, Any]:
+        """Reset password by user ID."""
+        command = ResetPasswordCommand(self.http_client, user_id, request)
+        return command.execute()
+    
+    def reset_tfa(self, user_id: str) -> Dict[str, Any]:
+        """Reset TFA for user."""
+        command = ResetTFACommand(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()
+    
+    # PRIVILEGE MANAGEMENT
+    def get_privileges(self) -> List[Privilege]:
+        """Get all privileges."""
+        query = GetPrivilegesQuery(self.http_client)
+        return query.execute()
+    
+    # ROLE MANAGEMENT OPERATIONS
+    def get_roles(self) -> List[Role]:
+        """Get all roles."""
+        query = ListRolesQuery(self.http_client)
+        return query.execute()
+    
+    def create_role(self, request: CreateRoleRequest) -> Role:
+        """Create a new role."""
+        command = CreateRoleCommand(self.http_client, request)
+        return command.execute()
+    
+    def get_role_by_id(self, role_id: str) -> Role:
+        """Get a specific role by ID."""
+        query = GetRoleQuery(self.http_client, role_id)
+        return query.execute()
+    
+    def update_role_by_id(self, role_id: str, request: UpdateRoleRequest) -> Role:
+        """Update an existing role."""
+        command = UpdateRoleCommand(self.http_client, role_id, request)
+        return command.execute()
+    
+    def delete_role_by_id(self, role_id: str) -> Dict[str, Any]:
+        """Delete a role."""
+        command = DeleteRoleCommand(self.http_client, role_id)
+        return command.execute()
+    
+    # USER GROUP MANAGEMENT OPERATIONS
+    def get_user_groups(self, filter_params: Optional[UserGroupFilter] = None) -> List[UserGroup]:
+        """Get all user groups with optional filtering."""
+        query = ListUserGroupsQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def create_user_group(self, request: CreateUserGroupRequest) -> UserGroup:
+        """Create a new user group."""
+        command = CreateUserGroupCommand(self.http_client, request)
+        return command.execute()
+    
+    def get_user_group_by_id(self, group_id: str) -> UserGroup:
+        """Get a specific user group by ID."""
+        query = GetUserGroupQuery(self.http_client, group_id)
+        return query.execute()
+    
+    def delete_user_group_by_id(self, group_id: str) -> Dict[str, Any]:
+        """Delete a user group."""
+        command = DeleteUserGroupCommand(self.http_client, group_id)
+        return command.execute()
+    
+    def update_user_group_by_id(self, group_id: str, request: UpdateUserGroupRequest) -> UserGroup:
+        """Update an existing user group."""
+        command = UpdateUserGroupCommand(self.http_client, group_id, request)
+        return command.execute()
+    
+    # CONVENIENCE ALIASES
+    def list(self, filter_params: Optional[UserFilter] = None) -> List[UserManagementUser]:
+        """Alias for list_users."""
+        return self.list_users(filter_params)
+    
+    def get(self, user_id: str) -> UserManagementUser:
+        """Alias for get_user."""
+        return self.get_user(user_id)
+    
+    def create(self, request: CreateUserRequest) -> UserManagementUser:
+        """Alias for create_user."""
+        return self.create_user(request)
+    
+    def update(self, user_id: str, request: UpdateUserRequest) -> UserManagementUser:
+        """Alias for update_user."""
+        return self.update_user(user_id, request)
+    
+    def delete(self, user_id: str) -> Dict[str, Any]:
+        """Alias for delete_user."""
+        return self.delete_user(user_id) 

binalyze_air/apis/webhook_executions.py

@@ -0,0 +1,50 @@
+"""
+Webhook Executions API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.webhook_executions import WebhookExecutionResponse, WebhookPostRequest, TaskDetailsData
+from ..queries.webhook_executions import GetTaskDetailsQuery
+from ..commands.webhook_executions import ExecuteWebhookGetCommand, ExecuteWebhookPostCommand, RetryWebhookExecutionCommand
+
+
+class WebhookExecutionsAPI:
+    """Webhook Executions API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def get_task_details(self, slug: str, task_id: str, token: str) -> TaskDetailsData:
+        """Get task details data for a webhook execution."""
+        query = GetTaskDetailsQuery(self.http_client, slug, task_id, token)
+        return query.execute()
+    
+    # COMMANDS (Write operations)
+    def execute_webhook_get(self, slug: str, data: str, token: str) -> WebhookExecutionResponse:
+        """Execute webhook via GET request."""
+        command = ExecuteWebhookGetCommand(self.http_client, slug, data, token)
+        return command.execute()
+    
+    def execute_webhook_post(self, slug: str, token: str, request_data: WebhookPostRequest) -> WebhookExecutionResponse:
+        """Execute webhook via POST request."""
+        command = ExecuteWebhookPostCommand(self.http_client, slug, token, request_data)
+        return command.execute()
+    
+    def retry_execution(self, execution_id: str) -> Dict[str, Any]:
+        """Retry a failed webhook execution."""
+        command = RetryWebhookExecutionCommand(self.http_client, execution_id)
+        return command.execute()
+    
+    # Convenience methods
+    def execute_webhook_with_hostnames(self, slug: str, hostnames: list, token: str) -> WebhookExecutionResponse:
+        """Execute webhook with comma-separated hostnames."""
+        data = ",".join(hostnames)
+        return self.execute_webhook_get(slug, data, token)
+    
+    def execute_webhook_with_ips(self, slug: str, ip_addresses: list, token: str) -> WebhookExecutionResponse:
+        """Execute webhook with comma-separated IP addresses."""
+        data = ",".join(ip_addresses)
+        return self.execute_webhook_get(slug, data, token)