example_client.py

"""Example client demonstrating notification service integration."""

import asyncio
import aiohttp
from typing import Optional


class NotificationClient:
    """Simple client for notification service."""
    
    def __init__(self, base_url: str = "http://localhost:8002", api_token: Optional[str] = None):
        """Initialize client.
        
        Args:
            base_url: Notification service URL
            api_token: API authentication token
        """
        self.base_url = base_url.rstrip("/")
        self.api_token = api_token
        self.headers = {}
        if api_token:
            self.headers["X-API-Token"] = api_token
    
    async def send_sms(self, notification_id: str, phone: str, message: str, priority: str = "medium") -> dict:
        """Send SMS notification.
        
        Args:
            notification_id: Unique notification ID
            phone: Phone number in E.164 format
            message: SMS message text
            priority: Priority level (immediate/high/medium/low)
        
        Returns:
            API response dict
        """
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}/commands/add-notifications",
                json={
                    "notifications": [{
                        "id": notification_id,
                        "type": "sms",
                        "priority": priority,
                        "payload": {
                            "phone": phone,
                            "message": message
                        }
                    }]
                },
                headers=self.headers
            ) as resp:
                resp.raise_for_status()
                return await resp.json()
    
    async def send_push(
        self,
        notification_id: str,
        title: str,
        body: str,
        device_tokens: Optional[list] = None,
        topic: Optional[str] = None,
        priority: str = "medium",
        data: Optional[dict] = None
    ) -> dict:
        """Send push notification.
        
        Args:
            notification_id: Unique notification ID
            title: Notification title
            body: Notification body text
            device_tokens: List of device tokens (for direct targeting)
            topic: Topic name (for broadcast)
            priority: Priority level
            data: Additional data payload
        
        Returns:
            API response dict
        """
        payload = {
            "title": title,
            "body": body
        }
        
        if device_tokens:
            payload["device_tokens"] = device_tokens
        if topic:
            payload["topic"] = topic
        if data:
            payload["data"] = data
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}/commands/add-notifications",
                json={
                    "notifications": [{
                        "id": notification_id,
                        "type": "push",
                        "priority": priority,
                        "payload": payload
                    }]
                },
                headers=self.headers
            ) as resp:
                resp.raise_for_status()
                return await resp.json()
    
    async def trigger_send(self) -> dict:
        """Trigger immediate send cycle."""
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.base_url}/commands/run-now",
                headers=self.headers
            ) as resp:
                resp.raise_for_status()
                return await resp.json()
    
    async def list_notifications(self) -> dict:
        """List all notifications."""
        async with aiohttp.ClientSession() as session:
            async with session.get(
                f"{self.base_url}/notifications",
                headers=self.headers
            ) as resp:
                resp.raise_for_status()
                return await resp.json()
    
    async def check_status(self) -> dict:
        """Check service health."""
        async with aiohttp.ClientSession() as session:
            async with session.get(
                f"{self.base_url}/status",
                headers=self.headers
            ) as resp:
                resp.raise_for_status()
                return await resp.json()


async def main():
    """Example usage."""
    # Initialize client
    client = NotificationClient(
        base_url="http://localhost:8002",
        api_token="your-secret-token"  # Match your config.ini
    )
    
    # Check service status
    print("Checking service status...")
    status = await client.check_status()
    print(f"Status: {status}")
    
    # Send SMS
    print("\nSending SMS...")
    sms_result = await client.send_sms(
        notification_id="example-sms-001",
        phone="+393331234567",
        message="Hello! This is a test SMS from the notification service.",
        priority="high"
    )
    print(f"SMS Result: {sms_result}")
    
    # Send push notification to specific devices
    print("\nSending push notification to devices...")
    push_result = await client.send_push(
        notification_id="example-push-001",
        title="Test Notification",
        body="This is a test push notification",
        device_tokens=["mock-token-1", "mock-token-2"],
        priority="medium",
        data={"type": "test", "timestamp": "2025-01-01T00:00:00Z"}
    )
    print(f"Push Result: {push_result}")
    
    # Broadcast to topic
    print("\nSending broadcast notification...")
    broadcast_result = await client.send_push(
        notification_id="example-broadcast-001",
        title="Important Update",
        body="New version available!",
        topic="all-users",
        priority="low"
    )
    print(f"Broadcast Result: {broadcast_result}")
    
    # Trigger immediate processing
    print("\nTriggering immediate send...")
    await client.trigger_send()
    
    # Wait a moment for processing
    await asyncio.sleep(1)
    
    # List notifications
    print("\nListing notifications...")
    notifications = await client.list_notifications()
    print(f"Found {len(notifications.get('notifications', []))} notifications")
    
    for notif in notifications.get("notifications", [])[:5]:
        print(f"  - {notif['id']}: {notif['type']} (sent: {notif.get('sent_ts') is not None})")


if __name__ == "__main__":
    asyncio.run(main())