python-missive 0.2.0__py3-none-any.whl

pymissive/archives/providers/messenger.py

@@ -0,0 +1,74 @@
+"""Facebook Messenger provider."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+
+
+class MessengerProvider(BaseProvider):
+    """
+    Facebook Messenger provider.
+
+    Required configuration:
+        MESSENGER_PAGE_ACCESS_TOKEN: Facebook page access token
+        MESSENGER_APP_SECRET: Application secret
+
+    Recipient must have a PSID (Page-Scoped ID) Messenger stored in metadata.
+    """
+
+    name = "messenger"
+    display_name = "Facebook Messenger"
+    supported_types = ["BRANDED"]
+    brands = ["messenger"]  # Facebook Messenger only
+    config_keys = ["MESSENGER_PAGE_ACCESS_TOKEN", "MESSENGER_VERIFY_TOKEN"]
+    required_packages = ["requests"]
+    site_url = "https://www.messenger.com/"
+    description_text = "Facebook Messenger - Consumer instant messaging (Meta)"
+
+    def validate(self) -> tuple[bool, str]:
+        """Validate that the recipient has a Messenger PSID"""
+        if not self.missive:
+            return False, "Missive not defined"
+
+        recipient = getattr(self.missive, "recipient", None)
+        if not recipient:
+            return False, "Recipient not defined"
+
+        metadata = getattr(recipient, "metadata", None) or {}
+        psid = metadata.get("messenger_psid")
+        if not psid:
+            return False, "Recipient does not have a Messenger PSID (add to metadata)"
+
+        return True, ""
+
+    def send_branded(self, brand_name: Optional[str] = None, **kwargs) -> bool:
+        """
+        Send a message via Messenger Send API.
+
+        TODO: Implement actual sending via:
+        POST https://graph.facebook.com/v18.0/me/messages
+        """
+        is_valid, error = self.validate()
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        # TODO: Implement actual sending
+        external_id = f"messenger_sim_{getattr(self.missive, 'id', 'unknown')}"
+        self._update_status(
+            MissiveStatus.SENT,
+            external_id=external_id,
+        )
+
+        return True
+
+    def check_status(self, external_id: Optional[str] = None) -> Optional[str]:
+        """Check status via Messenger webhooks"""
+        # TODO: Implement webhook handlers
+        return None
+
+
+__all__ = ["MessengerProvider"]

pymissive/archives/providers/notification.py

@@ -0,0 +1,112 @@
+"""In-app notification provider."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional, Tuple
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+
+
+class InAppNotificationProvider(BaseProvider):
+    """In-app notification provider."""
+
+    name = "notification"
+    display_name = "Notification In-App"
+    supported_types = ["NOTIFICATION"]
+    services = ["notification"]
+    notification_geographic_coverage = ["*"]
+    notification_geo = notification_geographic_coverage
+    required_packages = []
+    description_text = "In-app notifications without external dependency"
+
+    def send_notification(self, **kwargs) -> bool:
+        """Create an in-app notification"""
+        # Validation
+        is_valid, error = self.validate()
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        if not self._get_missive_value("recipient_user"):
+            self._update_status(MissiveStatus.FAILED, error_message="User missing")
+            return False
+
+        try:
+            # TODO: Create the notification
+            # Can use:
+            # - Django signals
+            # - WebSocket (channels)
+            # - Firebase Cloud Messaging
+            # - OneSignal
+            #
+            # Example with signal:
+            # from django.dispatch import Signal
+            # notification_created = Signal()
+            # notification_created.send(
+            #     sender=self.__class__,
+            #     missive=self.missive,
+            #     recipient=self.missive.recipient_user,
+            #     subject=self.missive.subject,
+            #     body=self.missive.body
+            # )
+
+            # Notification is instantaneous
+            clock = getattr(self, "_clock", None)
+            now = clock() if callable(clock) else datetime.now(timezone.utc)
+
+            self._update_status(
+                MissiveStatus.SENT,
+                provider=self.name,
+            )
+            # Set sent_at and delivered_at to now for instant notifications
+            if self.missive and hasattr(self.missive, "sent_at"):
+                self.missive.sent_at = now
+            if self.missive and hasattr(self.missive, "delivered_at"):
+                self.missive.delivered_at = now
+
+            self._create_event("sent", "Notification created")
+            self._create_event("delivered", "Notification delivered")
+
+            return True
+
+        except Exception as e:
+            self._update_status(MissiveStatus.FAILED, error_message=str(e))
+            self._create_event("failed", str(e))
+            return False
+
+    def validate_webhook_signature(
+        self,
+        payload: Any,
+        headers: Dict[str, str],
+        *,
+        missive_type: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Tuple[bool, str]:
+        """No webhooks for in-app notifications"""
+        return False, "In-app notifications do not use webhooks"
+
+    def get_service_status(self) -> Dict:
+        """
+        Gets in-app notification system status.
+
+        In-app notifications are managed locally, no limits.
+
+        Returns:
+            Dict with status, availability, etc.
+        """
+        return self._build_generic_service_status(
+            status="operational",
+            is_available=True,
+            credits_type="unlimited",
+            rate_limits={"per_second": None},
+            sla={"uptime_percentage": 100.0},
+            details={
+                "provider_type": "In-App (Local)",
+                "note": "Notifications stockées en base de données",
+            },
+        )
+
+
+__all__ = ["InAppNotificationProvider"]

pymissive/archives/providers/sendgrid.py

@@ -0,0 +1,160 @@
+"""SendGrid email provider."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+from typing import Any, Dict, Optional, Tuple
+
+from .base import BaseProvider
+
+
+class SendGridProvider(BaseProvider):
+    """SendGrid email provider."""
+
+    name = "SendGrid"
+    display_name = "SendGrid"
+    supported_types = ["EMAIL", "EMAIL_MARKETING"]
+    # Geographic scope and pricing
+    email_geographic_coverage = ["*"]
+    email_geo = email_geographic_coverage
+    email_marketing_geographic_coverage = ["*"]
+    email_marketing_geo = email_marketing_geographic_coverage
+    email_price = 0.9  # Similar to Mailgun baseline
+    email_marketing_price = 0.15  # Marketing credits slightly higher
+    email_marketing_max_attachment_size_mb = 10
+    email_marketing_allowed_attachment_mime_types = [
+        "text/html",
+        "image/jpeg",
+        "image/png",
+    ]
+    config_keys = ["SENDGRID_API_KEY"]
+    required_packages = ["sendgrid"]
+    site_url = "https://sendgrid.com/"
+    status_url = "https://status.sendgrid.com/"
+    documentation_url = "https://docs.sendgrid.com/"
+    description_text = "Transactional and marketing email (Twilio SendGrid)"
+
+    def send_email(self, **kwargs) -> bool:
+        """Sends email via SendGrid API."""
+        return self._send_email_simulation(
+            prefix="sg", event_message="Email sent via SendGrid"
+        )
+
+    def send_email_marketing(self, **kwargs) -> bool:
+        """Marketing campaigns follow the transactional send path."""
+        return self.send_email(**kwargs)
+
+    def validate_webhook_signature(
+        self,
+        payload: Any,
+        headers: Dict[str, str],
+        *,
+        missive_type: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Tuple[bool, str]:
+        """Validate SendGrid webhook signature."""
+        webhook_key = self._config.get("SENDGRID_WEBHOOK_KEY")
+        if not webhook_key:
+            return True, ""  # No validation
+
+        sig_header = "HTTP_X_TWILIO_EMAIL_EVENT_WEBHOOK_SIGNATURE"
+        signature = headers.get(sig_header, "")
+        ts_header = "HTTP_X_TWILIO_EMAIL_EVENT_WEBHOOK_TIMESTAMP"
+        timestamp = headers.get(ts_header, "")
+
+        if not signature or not timestamp:
+            return False, "Signature or timestamp missing"
+
+        # Reconstruct the signature
+        payload_str = json.dumps(payload, separators=(",", ":"))
+        signed_payload = timestamp + payload_str
+
+        expected_signature = base64.b64encode(
+            hmac.new(
+                webhook_key.encode(), signed_payload.encode(), hashlib.sha256
+            ).digest()
+        ).decode()
+
+        if hmac.compare_digest(signature, expected_signature):
+            return True, ""
+        return False, "Signature does not match"
+
+    def validate_email_marketing_webhook_signature(
+        self,
+        payload: Any,
+        headers: Dict[str, str],
+        *,
+        missive_type: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Tuple[bool, str]:
+        """Marketing webhooks reuse the same verification."""
+        return self.validate_webhook_signature(
+            payload, headers, missive_type="EMAIL_MARKETING", **kwargs
+        )
+
+    def extract_email_missive_id(self, payload: Any) -> Optional[str]:
+        """Extract missive ID from SendGrid webhook."""
+        # SendGrid sends an array of events
+        if isinstance(payload, list) and len(payload) > 0:
+            event = payload[0]
+            if isinstance(event, dict):
+                result = event.get("missive_id") or event.get("custom_args", {}).get(
+                    "missive_id"
+                )
+                return str(result) if result else None
+        elif isinstance(payload, dict):
+            result = payload.get("missive_id") or payload.get("custom_args", {}).get(
+                "missive_id"
+            )
+            return str(result) if result else None
+        return None
+
+    def extract_email_marketing_missive_id(self, payload: Any) -> Optional[str]:
+        """Reuse transactional ID extraction."""
+        return self.extract_email_missive_id(payload)
+
+    def extract_event_type(self, payload: Any) -> str:
+        """Extract event type from SendGrid webhook."""
+        if isinstance(payload, list) and len(payload) > 0:
+            event = payload[0]
+            if isinstance(event, dict):
+                result = event.get("event", "unknown")
+                return str(result) if result else "unknown"
+        elif isinstance(payload, dict):
+            result = payload.get("event", "unknown")
+            return str(result) if result else "unknown"
+        return "unknown"
+
+    def handle_email_marketing_webhook(
+        self, payload: Dict[str, Any], headers: Dict[str, str]
+    ) -> Tuple[bool, str, Optional[Any]]:
+        """Delegate marketing webhook handling to transactional handler."""
+        return self.handle_email_webhook(payload, headers)
+
+    def get_service_status(self) -> Dict:
+        """
+        Gets SendGrid status and credits.
+
+        Returns:
+            Dict with status, credits, etc.
+        """
+        return self._build_generic_service_status(
+            credits_type="emails",
+            credits_currency="emails",
+            rate_limits={"per_second": 10, "per_minute": 600},
+            warnings=["SendGrid API not implemented - uncomment the code"],
+            details={
+                "status_page": "https://status.sendgrid.com/",
+                "api_docs": (
+                    "https://docs.sendgrid.com/api-reference/"
+                    "stats/retrieve-email-statistics"
+                ),
+            },
+            sla={"uptime_percentage": 99.99, "response_time_ms": 100},
+        )
+
+
+__all__ = ["SendGridProvider"]

pymissive/archives/providers/ses.py

@@ -0,0 +1,185 @@
+"""Amazon SES email provider."""
+
+from __future__ import annotations
+
+from typing import Dict
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+
+
+class SESProvider(BaseProvider):
+    """
+    Amazon SES (Simple Email Service) provider.
+
+    Required configuration:
+        AWS_ACCESS_KEY_ID: AWS access key
+        AWS_SECRET_ACCESS_KEY: AWS secret key
+        AWS_REGION: AWS region (e.g., eu-west-1, us-east-1)
+        SES_FROM_EMAIL: Verified sender email in SES
+
+    Supports:
+    - Transactional email
+    - Email marketing (with SES v2)
+    - Reputation management
+    """
+
+    name = "ses"
+    display_name = "Amazon SES"
+    supported_types = ["EMAIL"]
+    services = ["email", "email_transactional", "email_marketing"]
+    config_keys = [
+        "AWS_ACCESS_KEY_ID",
+        "AWS_SECRET_ACCESS_KEY",
+        "AWS_REGION",
+        "SES_FROM_EMAIL",
+    ]
+    required_packages = ["boto3"]
+    site_url = "https://aws.amazon.com/ses/"
+    status_url = "https://health.aws.amazon.com/health/status"
+    documentation_url = "https://docs.aws.amazon.com/ses/"
+    description_text = "Amazon Simple Email Service - AWS transactional email"
+
+    def send_email(self, **kwargs) -> bool:
+        """Send an email via Amazon SES"""
+        # Validation
+        is_valid, error = self.validate()
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        if not self._get_missive_value("recipient_email"):
+            self._update_status(MissiveStatus.FAILED, error_message="Email missing")
+            return False
+
+        try:
+            # Configuration AWS
+            aws_access_key = self._config.get("AWS_ACCESS_KEY_ID")
+            aws_secret_key = self._config.get("AWS_SECRET_ACCESS_KEY")
+            self._config.get("AWS_REGION", "eu-west-1")
+            from_email = self._config.get("SES_FROM_EMAIL")
+
+            if not all([aws_access_key, aws_secret_key, from_email]):
+                self._update_status(
+                    MissiveStatus.FAILED,
+                    error_message="Incomplete AWS SES configuration",
+                )
+                return False
+
+            # TODO: Implement actual SES sending
+            # import boto3
+            # from botocore.exceptions import ClientError
+            #
+            # client = boto3.client(
+            #     "ses",
+            #     aws_access_key_id=aws_access_key,
+            #     aws_secret_access_key=aws_secret_key,
+            #     region_name=aws_region,
+            # )
+            #
+            # destination = {"ToAddresses": [self.missive.recipient_email]}
+            # message = {
+            #     "Subject": {"Data": self.missive.subject, "Charset": "UTF-8"},
+            #     "Body": {},
+            # }
+            #
+            # if self.missive.body_html:
+            #     message["Body"]["Html"] = {
+            #         "Data": self.missive.body_html,
+            #         "Charset": "UTF-8",
+            #     }
+            # if self.missive.body_text or self.missive.body:
+            #     message["Body"]["Text"] = {
+            #         "Data": self.missive.body_text or self.missive.body,
+            #         "Charset": "UTF-8",
+            #     }
+            #
+            # response = client.send_email(
+            #     Source=from_email,
+            #     Destination=destination,
+            #     Message=message,
+            # )
+            #
+            # message_id = response.get("MessageId")
+
+            # Simulation
+            message_id = f"ses_{getattr(self.missive, 'id', 'unknown')}"
+
+            self._update_status(
+                MissiveStatus.SENT,
+                provider=self.name,
+                external_id=message_id,
+            )
+            self._create_event("sent", f"Email sent via Amazon SES (ID: {message_id})")
+
+            return True
+
+        except Exception as e:
+            self._update_status(MissiveStatus.FAILED, error_message=str(e))
+            self._create_event("failed", str(e))
+            return False
+
+    def get_email_service_info(self) -> Dict:
+        """
+        Gets Amazon SES service information.
+
+        Returns:
+            Dict with quotas, credits, reputation, etc.
+        """
+        try:
+            aws_access_key = self._config.get("AWS_ACCESS_KEY_ID")
+            aws_secret_key = self._config.get("AWS_SECRET_ACCESS_KEY")
+            aws_region = self._config.get("AWS_REGION", "eu-west-1")
+
+            if not all([aws_access_key, aws_secret_key]):
+                return {
+                    "credits": None,
+                    "credits_type": "quota",
+                    "is_available": False,
+                    "limits": {},
+                    "warnings": ["Incomplete AWS configuration"],
+                    "reputation": {},
+                    "details": {},
+                }
+
+            # TODO: Implement actual SES API calls
+            # import boto3
+            # from botocore.exceptions import ClientError
+            #
+            # client = boto3.client(
+            #     "ses",
+            #     aws_access_key_id=aws_access_key,
+            #     aws_secret_access_key=aws_secret_key,
+            #     region_name=aws_region,
+            # )
+            #
+            # quota = client.get_send_quota()
+            # max_24h = int(quota.get("Max24HourSend", 0))
+            # sent_last_24h = int(quota.get("SentLast24Hours", 0))
+            # remaining = max_24h - sent_last_24h
+
+            return {
+                "credits": None,
+                "credits_type": "quota",
+                "is_available": None,
+                "limits": {},
+                "warnings": ["SES API not implemented - uncomment the code"],
+                "reputation": {},
+                "details": {
+                    "region": aws_region,
+                },
+            }
+
+        except Exception as e:
+            return {
+                "credits": None,
+                "credits_type": "quota",
+                "is_available": False,
+                "limits": {},
+                "warnings": [f"Error: {str(e)}"],
+                "reputation": {},
+                "details": {},
+            }
+
+
+__all__ = ["SESProvider"]

pymissive/archives/providers/signal.py

@@ -0,0 +1,68 @@
+"""Signal Messenger provider."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+
+
+class SignalProvider(BaseProvider):
+    """
+    Signal Messenger provider.
+
+    Required configuration:
+        SIGNAL_CLI_REST_API_URL: signal-cli-rest-api URL
+        SIGNAL_SENDER_NUMBER: Registered sender number
+
+    Recipient must have a mobile phone number.
+    """
+
+    name = "signal"
+    display_name = "Signal"
+    supported_types = ["BRANDED"]
+    brands = ["signal"]  # Signal only
+    config_keys = ["SIGNAL_API_KEY"]
+    required_packages = ["requests"]
+    site_url = "https://signal.org/"
+    description_text = "Secure end-to-end encrypted messaging"
+
+    def validate(self) -> tuple[bool, str]:
+        """Validate that the recipient has a mobile number"""
+        if not self.missive:
+            return False, "Missive not defined"
+
+        recipient = getattr(self.missive, "recipient", None)
+        if not recipient or not getattr(recipient, "mobile", None):
+            return False, "Recipient must have a mobile number for Signal"
+
+        return True, ""
+
+    def send_branded(self, brand_name: Optional[str] = None, **kwargs) -> bool:
+        """
+        Send a message via Signal.
+
+        TODO: Implement actual sending via signal-cli-rest-api
+        """
+        is_valid, error = self.validate()
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        # TODO: Implement actual sending
+        external_id = f"signal_sim_{getattr(self.missive, 'id', 'unknown')}"
+        self._update_status(
+            MissiveStatus.SENT,
+            external_id=external_id,
+        )
+
+        return True
+
+    def check_status(self, external_id: Optional[str] = None) -> Optional[str]:
+        """Check status of a Signal message"""
+        # TODO: Implement if needed
+        return None
+
+
+__all__ = ["SignalProvider"]

pymissive/archives/providers/slack.py

@@ -0,0 +1,80 @@
+"""Slack provider for channel and direct messaging."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+
+
+class SlackProvider(BaseProvider):
+    """Slack provider."""
+
+    name = "slack"
+    display_name = "Slack"
+    supported_types = ["BRANDED"]
+    services = ["slack", "messaging"]
+    brands = ["slack"]
+    config_keys = ["SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"]
+    required_packages = ["slack-sdk"]
+    site_url = "https://slack.com/"
+    status_url = "https://status.slack.com/"
+    documentation_url = "https://api.slack.com/"
+    description_text = "Professional team collaboration messaging"
+    # Geographic scope
+    branded_geo = "*"
+
+    def validate(self) -> tuple[bool, str]:
+        """Validates recipient has Slack user_id or channel_id."""
+        if not self.missive:
+            return False, "Missive not defined"
+
+        recipient = getattr(self.missive, "recipient", None)
+        if not recipient:
+            return False, "Recipient not defined"
+
+        metadata = getattr(recipient, "metadata", None) or {}
+        user_id = metadata.get("slack_user_id")
+        channel_id = metadata.get("slack_channel_id")
+
+        if not user_id and not channel_id:
+            return (
+                False,
+                "Recipient must have slack_user_id or slack_channel_id in metadata",
+            )
+
+        return True, ""
+
+    def send_slack(self) -> bool:
+        """Sends Slack message via Web API."""
+        is_valid, error = self.validate()
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        # TODO: Implement actual sending
+        # from slack_sdk import WebClient
+        #
+        # client = WebClient(token=self._config.get("SLACK_BOT_TOKEN"))
+        # response = client.chat_postMessage(
+        #     channel=channel_id or user_id,
+        #     text=self.missive.body_text,
+        #     blocks=[...]  # For rich formatting
+        # )
+
+        external_id = f"slack_sim_{getattr(self.missive, 'id', 'unknown')}"
+        self._update_status(
+            MissiveStatus.SENT,
+            external_id=external_id,
+        )
+
+        return True
+
+    def check_status(self, external_id: Optional[str] = None) -> Optional[str]:
+        """Checks if message was read (requires Events API)."""
+        # TODO: Implement via Slack Events API
+        return None
+
+
+__all__ = ["SlackProvider"]