authix-python-sdk 1.0.0__py3-none-any.whl

authix/handlers.py

@@ -0,0 +1,570 @@
+"""
+Authix API Handlers
+Individual handlers for different Authix API endpoints
+"""
+
+from typing import Dict, Any, List, Optional
+from .client import APIClient
+
+
+class BaseHandler:
+    """Base class for all API handlers"""
+    
+    def __init__(self, client: APIClient):
+        """
+        Initialize handler with API client
+        
+        Args:
+            client: Authix API client
+        """
+        self.client = client
+
+
+class AuthHandler(BaseHandler):
+    """Handler for authentication endpoints"""
+    
+    async def register(self, 
+                      username: str, 
+                      password: str, 
+                      license_key: str, 
+                      hwid: str, 
+                      app_id: str, 
+                      app_name: str) -> Dict[str, Any]:
+        """
+        Register a new user
+        
+        Args:
+            username: Username for the new user
+            password: Password for the new user
+            license_key: License key for activation
+            hwid: Hardware ID for device binding
+            app_id: Application ID
+            app_name: Application name
+            
+        Returns:
+            Registration result with user data and tokens
+        """
+        data = {
+            'username': username,
+            'password': password,
+            'license_key': license_key,
+            'hwid': hwid,
+            'app_id': app_id,
+            'app_name': app_name
+        }
+        return await self.client.post('/auth/register', data)
+    
+    async def login(self, 
+                   username: str, 
+                   password: str, 
+                   hwid: str, 
+                   app_id: str, 
+                   app_name: str) -> Dict[str, Any]:
+        """
+        Login user
+        
+        Args:
+            username: User username
+            password: User password
+            hwid: Hardware ID for device verification
+            app_id: Application ID
+            app_name: Application name
+            
+        Returns:
+            Login result with authentication tokens
+        """
+        data = {
+            'username': username,
+            'password': password,
+            'hwid': hwid,
+            'app_id': app_id,
+            'app_name': app_name
+        }
+        return await self.client.post('/auth/login', data)
+    
+    async def logout(self, token: str) -> Dict[str, Any]:
+        """
+        Logout user and invalidate token
+        
+        Args:
+            token: Authentication token to invalidate
+            
+        Returns:
+            Logout result
+        """
+        data = {'token': token}
+        return await self.client.post('/auth/logout', data)
+    
+    async def refresh_token(self, refresh_token: str) -> Dict[str, Any]:
+        """
+        Refresh authentication token
+        
+        Args:
+            refresh_token: Refresh token
+            
+        Returns:
+            New authentication tokens
+        """
+        data = {'refresh_token': refresh_token}
+        return await self.client.post('/auth/refresh', data)
+    
+    async def verify_token(self, token: str) -> Dict[str, Any]:
+        """
+        Verify authentication token
+        
+        Args:
+            token: Authentication token to verify
+            
+        Returns:
+            Token verification result with user data
+        """
+        data = {'token': token}
+        return await self.client.post('/auth/verify', data)
+
+
+class AppsHandler(BaseHandler):
+    """Handler for application management endpoints"""
+    
+    async def get_apps(self) -> List[Dict[str, Any]]:
+        """
+        Get all applications
+        
+        Returns:
+            List of applications
+        """
+        result = await self.client.get('/apps')
+        return result.get('apps', [])
+    
+    async def create_app(self, name: str, description: str = None) -> Dict[str, Any]:
+        """
+        Create new application
+        
+        Args:
+            name: Application name
+            description: Application description
+            
+        Returns:
+            Created application data
+        """
+        data = {'name': name}
+        if description:
+            data['description'] = description
+        
+        return await self.client.post('/apps', data)
+    
+    async def get_app_details(self, app_id: str) -> Dict[str, Any]:
+        """
+        Get application details
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            Application details
+        """
+        return await self.client.get(f'/apps/{app_id}')
+    
+    async def update_app(self, app_id: str, name: str = None, description: str = None) -> Dict[str, Any]:
+        """
+        Update application
+        
+        Args:
+            app_id: Application ID
+            name: New application name
+            description: New application description
+            
+        Returns:
+            Updated application data
+        """
+        data = {}
+        if name:
+            data['name'] = name
+        if description:
+            data['description'] = description
+        
+        return await self.client.put(f'/apps/{app_id}', data)
+    
+    async def delete_app(self, app_id: str) -> Dict[str, Any]:
+        """
+        Delete application
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            Deletion result
+        """
+        return await self.client.delete(f'/apps/{app_id}')
+    
+    async def reset_hwid(self, app_id: str, username: str, password: str, license_key: str) -> Dict[str, Any]:
+        """
+        Reset user HWID
+        
+        Args:
+            app_id: Application ID
+            username: Username
+            password: User password
+            license_key: License key for verification
+            
+        Returns:
+            HWID reset result
+        """
+        data = {
+            'username': username,
+            'password': password,
+            'license_key': license_key
+        }
+        return await self.client.post(f'/apps/{app_id}/reset-hwid', data)
+
+
+class LicensesHandler(BaseHandler):
+    """Handler for license management endpoints"""
+    
+    async def create_license(self, app_id: str, days: int, max_hwids: int = 3) -> Dict[str, Any]:
+        """
+        Create new license
+        
+        Args:
+            app_id: Application ID
+            days: License validity in days
+            max_hwids: Maximum allowed hardware IDs
+            
+        Returns:
+            Created license data
+        """
+        data = {
+            'app_id': app_id,
+            'days': days,
+            'max_hwids': max_hwids
+        }
+        return await self.client.post('/licenses', data)
+    
+    async def get_licenses(self, app_id: str) -> List[Dict[str, Any]]:
+        """
+        Get all licenses for application
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            List of licenses
+        """
+        result = await self.client.get(f'/licenses/{app_id}')
+        return result.get('licenses', [])
+    
+    async def get_license_details(self, license_key: str) -> Dict[str, Any]:
+        """
+        Get license details
+        
+        Args:
+            license_key: License key
+            
+        Returns:
+            License details
+        """
+        return await self.client.get(f'/licenses/{license_key}')
+    
+    async def delete_unused(self, app_id: str) -> Dict[str, Any]:
+        """
+        Delete unused licenses
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            Deletion result
+        """
+        return await self.client.delete(f'/licenses/{app_id}/unused')
+    
+    async def revoke_license(self, license_key: str) -> Dict[str, Any]:
+        """
+        Revoke license
+        
+        Args:
+            license_key: License key to revoke
+            
+        Returns:
+            Revocation result
+        """
+        return await self.client.delete(f'/licenses/{license_key}')
+
+
+class UsersHandler(BaseHandler):
+    """Handler for user management endpoints"""
+    
+    async def get_users(self, app_id: str) -> List[Dict[str, Any]]:
+        """
+        Get all users for application
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            List of users
+        """
+        result = await self.client.get(f'/users/{app_id}')
+        return result.get('users', [])
+    
+    async def get_user_details(self, app_id: str, username: str) -> Dict[str, Any]:
+        """
+        Get user details
+        
+        Args:
+            app_id: Application ID
+            username: Username
+            
+        Returns:
+            User details
+        """
+        return await self.client.get(f'/users/{app_id}/{username}')
+    
+    async def disable_user(self, app_id: str, username: str) -> Dict[str, Any]:
+        """
+        Disable user
+        
+        Args:
+            app_id: Application ID
+            username: Username to disable
+            
+        Returns:
+            Disable result
+        """
+        return await self.client.post(f'/users/{app_id}/{username}/disable')
+    
+    async def enable_user(self, app_id: str, username: str) -> Dict[str, Any]:
+        """
+        Enable user
+        
+        Args:
+            app_id: Application ID
+            username: Username to enable
+            
+        Returns:
+            Enable result
+        """
+        return await self.client.post(f'/users/{app_id}/{username}/enable')
+    
+    async def delete_user(self, app_id: str, username: str) -> Dict[str, Any]:
+        """
+        Delete user
+        
+        Args:
+            app_id: Application ID
+            username: Username to delete
+            
+        Returns:
+            Deletion result
+        """
+        return await self.client.delete(f'/users/{app_id}/{username}')
+    
+    async def update_user_password(self, app_id: str, username: str, new_password: str) -> Dict[str, Any]:
+        """
+        Update user password
+        
+        Args:
+            app_id: Application ID
+            username: Username
+            new_password: New password
+            
+        Returns:
+            Update result
+        """
+        data = {'new_password': new_password}
+        return await self.client.put(f'/users/{app_id}/{username}/password', data)
+
+
+class SecurityHandler(BaseHandler):
+    """Handler for security management endpoints"""
+    
+    async def ban_hwid(self, app_id: str, hwid: str) -> Dict[str, Any]:
+        """
+        Ban hardware ID
+        
+        Args:
+            app_id: Application ID
+            hwid: Hardware ID to ban
+            
+        Returns:
+            Ban result
+        """
+        data = {'hwid': hwid}
+        return await self.client.post(f'/security/{app_id}/ban-hwid', data)
+    
+    async def unban_hwid(self, app_id: str, hwid: str) -> Dict[str, Any]:
+        """
+        Unban hardware ID
+        
+        Args:
+            app_id: Application ID
+            hwid: Hardware ID to unban
+            
+        Returns:
+            Unban result
+        """
+        data = {'hwid': hwid}
+        return await self.client.post(f'/security/{app_id}/unban-hwid', data)
+    
+    async def ban_ip(self, app_id: str, ip_address: str) -> Dict[str, Any]:
+        """
+        Ban IP address
+        
+        Args:
+            app_id: Application ID
+            ip_address: IP address to ban
+            
+        Returns:
+            Ban result
+        """
+        data = {'ip_address': ip_address}
+        return await self.client.post(f'/security/{app_id}/ban-ip', data)
+    
+    async def unban_ip(self, app_id: str, ip_address: str) -> Dict[str, Any]:
+        """
+        Unban IP address
+        
+        Args:
+            app_id: Application ID
+            ip_address: IP address to unban
+            
+        Returns:
+            Unban result
+        """
+        data = {'ip_address': ip_address}
+        return await self.client.post(f'/security/{app_id}/unban-ip', data)
+    
+    async def get_banned_hwids(self, app_id: str) -> List[Dict[str, Any]]:
+        """
+        Get banned hardware IDs
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            List of banned hardware IDs
+        """
+        result = await self.client.get(f'/security/{app_id}/banned-hwids')
+        return result.get('hwids', [])
+    
+    async def get_banned_ips(self, app_id: str) -> List[Dict[str, Any]]:
+        """
+        Get banned IP addresses
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            List of banned IP addresses
+        """
+        result = await self.client.get(f'/security/{app_id}/banned-ips')
+        return result.get('ips', [])
+
+
+class WebhooksHandler(BaseHandler):
+    """Handler for webhook management endpoints"""
+    
+    async def create_webhook(self, 
+                            app_id: str, 
+                            url: str, 
+                            events: List[str], 
+                            secret: str = None) -> Dict[str, Any]:
+        """
+        Create webhook
+        
+        Args:
+            app_id: Application ID
+            url: Webhook URL
+            events: List of events to subscribe to
+            secret: Webhook secret for signature verification
+            
+        Returns:
+            Created webhook data
+        """
+        data = {
+            'url': url,
+            'events': events
+        }
+        if secret:
+            data['secret'] = secret
+        
+        return await self.client.post(f'/webhooks/{app_id}', data)
+    
+    async def list_webhooks(self, app_id: str) -> List[Dict[str, Any]]:
+        """
+        List webhooks for application
+        
+        Args:
+            app_id: Application ID
+            
+        Returns:
+            List of webhooks
+        """
+        result = await self.client.get(f'/webhooks/{app_id}')
+        return result.get('webhooks', [])
+    
+    async def get_webhook_details(self, app_id: str, webhook_id: str) -> Dict[str, Any]:
+        """
+        Get webhook details
+        
+        Args:
+            app_id: Application ID
+            webhook_id: Webhook ID
+            
+        Returns:
+            Webhook details
+        """
+        return await self.client.get(f'/webhooks/{app_id}/{webhook_id}')
+    
+    async def update_webhook(self, 
+                           app_id: str, 
+                           webhook_id: str, 
+                           url: str = None, 
+                           events: List[str] = None, 
+                           secret: str = None) -> Dict[str, Any]:
+        """
+        Update webhook
+        
+        Args:
+            app_id: Application ID
+            webhook_id: Webhook ID
+            url: New webhook URL
+            events: New list of events
+            secret: New webhook secret
+            
+        Returns:
+            Updated webhook data
+        """
+        data = {}
+        if url:
+            data['url'] = url
+        if events:
+            data['events'] = events
+        if secret:
+            data['secret'] = secret
+        
+        return await self.client.put(f'/webhooks/{app_id}/{webhook_id}', data)
+    
+    async def delete_webhook(self, app_id: str, webhook_id: str) -> Dict[str, Any]:
+        """
+        Delete webhook
+        
+        Args:
+            app_id: Application ID
+            webhook_id: Webhook ID
+            
+        Returns:
+            Deletion result
+        """
+        return await self.client.delete(f'/webhooks/{app_id}/{webhook_id}')
+    
+    async def test_webhook(self, app_id: str, webhook_id: str) -> Dict[str, Any]:
+        """
+        Test webhook with sample data
+        
+        Args:
+            app_id: Application ID
+            webhook_id: Webhook ID
+            
+        Returns:
+            Test result
+        """
+        return await self.client.post(f'/webhooks/{app_id}/{webhook_id}/test')