python-missive 0.2.0__py3-none-any.whl

pymissive/archives/providers/certeurope.py

@@ -0,0 +1,249 @@
+"""Certeurope provider for electronic registered letters (LRE)."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+
+
+class CerteuropeProvider(BaseProvider):
+    """
+    Certeurope provider (Electronic Registered Letter).
+
+    Required configuration:
+        CERTEUROPE_API_KEY: Certeurope API key
+        CERTEUROPE_API_SECRET: API Secret
+        CERTEUROPE_API_URL: API URL
+        CERTEUROPE_SENDER_EMAIL: Registered sender email
+
+    Recipient must have an email and complete postal address.
+    """
+
+    name = "certeurope"
+    display_name = "Certeurope (LRE)"
+    supported_types = ["LRE"]
+    lre_price = 5.5
+    lre_page_price_black_white = 0.0
+    lre_page_price_color = 0.0
+    lre_page_price_single_sided = 0.0
+    lre_page_price_duplex = 0.0
+    lre_allowed_attachment_mime_types: List[str] = ["application/pdf"]
+    lre_allowed_page_formats: List[str] = []
+    lre_envelope_limits: List[Dict[str, Any]] = []
+    lre_page_limit = 200
+    lre_color_printing_available = False
+    lre_duplex_printing_available = False
+    lre_archiving_duration = 3650
+    config_keys = [
+        "CERTEUROPE_API_KEY",
+        "CERTEUROPE_API_SECRET",
+        "CERTEUROPE_API_URL",
+        "CERTEUROPE_SENDER_EMAIL",
+    ]
+    required_packages = ["requests"]
+    site_url = "https://www.certeurope.fr/"
+    description_text = "Electronic registered email with legal value (LRE)"
+    # Geographic scope
+    lre_geographic_coverage = ["Europe"]
+
+    def validate(self) -> tuple[bool, str]:
+        """Validate that the recipient has an email and address"""
+        if not self.missive:
+            return False, "Missive not defined"
+
+        recipient = getattr(self.missive, "recipient", None)
+        if not recipient or not getattr(recipient, "email", None):
+            return False, "Recipient must have an email for Certeurope ERL"
+
+        # Check postal address (often required)
+        warnings = []
+        if not getattr(recipient, "address_line1", None):
+            warnings.append("Postal address missing")
+        if not getattr(recipient, "postal_code", None) or not getattr(
+            recipient, "city", None
+        ):
+            warnings.append("Postal code and city required")
+        if not getattr(recipient, "name", None):
+            warnings.append("Recipient name required")
+
+        if warnings:
+            return False, "; ".join(warnings)
+
+        return True, ""
+
+    def send_lre(self, **kwargs) -> bool:
+        """
+        Send an LRE via Certeurope.
+
+        TODO: Implement actual sending via Certeurope API
+        """
+        is_valid, error = self.validate()
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        # TODO: Implement actual sending
+        # 1. Generate the letter PDF
+        # 2. Create SOAP/REST Certeurope request
+        # 3. Send the signed document
+        # 4. Retrieve the deposit certificate
+
+        missive_id = getattr(self.missive, "id", "unknown")
+        external_id = f"certeurope_sim_{missive_id}"
+        self._update_status(MissiveStatus.SENT, external_id=external_id)
+
+        return True
+
+    def get_lre_service_info(self) -> dict[str, Any]:
+        """Return the service descriptor for LRE deliveries."""
+        return {
+            "provider": self.name,
+            "services": ["lre"],
+            "geographic_coverage": self.lre_geographic_coverage,
+            "features": [
+                "Qualified electronic registered letters",
+                "Deposit and presentation certificates",
+                "Acknowledgement of receipt",
+                "Qualified timestamps",
+                "10-year archiving",
+            ],
+        }
+
+    def check_status(self, external_id: Optional[str] = None) -> Optional[str]:
+        """
+        Check the LRE status (sending, reception, AR).
+
+        TODO: Implement verification via Certeurope API
+        """
+        return None
+
+    def get_proofs_of_delivery(self, service_type: Optional[str] = None) -> list:
+        """
+        Get all Certeurope proofs.
+
+        Certeurope generates several documents:
+        1. Deposit certificate (proof of sending)
+        2. Copy of sent document (archived)
+        3. Acknowledgement of receipt (proof of reading)
+        4. Presentation certificate (if registered)
+        5. Qualified timestamp
+
+        TODO: Implement via Certeurope API
+        """
+        if not self.missive:
+            return []
+
+        external_id = getattr(self.missive, "external_id", None)
+        if not external_id or not str(external_id).startswith("certeurope_"):
+            return []
+
+        # TODO: Real API call (SOAP or REST depending on version)
+
+        # Simulation
+        clock = getattr(self, "_clock", None)
+        sent_at = getattr(self.missive, "sent_at", None) or (
+            clock() if callable(clock) else datetime.now(timezone.utc)
+        )
+        expiration = sent_at + timedelta(days=3650)  # 10 years
+        proofs = []
+
+        # 1. Deposit certificate (always available)
+        proofs.append(
+            {
+                "type": "deposit_certificate",
+                "label": "Deposit Certificate",
+                "available": True,
+                "url": (f"https://www.certeurope.fr/lre/deposit/{external_id}.pdf"),
+                "generated_at": sent_at,
+                "expires_at": expiration,
+                "format": "pdf",
+                "metadata": {
+                    "certificate_type": "deposit",
+                    "legal_value": "eIDAS probative value",
+                    "provider": "certeurope",
+                },
+            }
+        )
+
+        # 2. Signed archived document
+        proofs.append(
+            {
+                "type": "archived_document",
+                "label": "Archived Document",
+                "available": True,
+                "url": (f"https://www.certeurope.fr/lre/archive/{external_id}.pdf"),
+                "generated_at": sent_at,
+                "expires_at": expiration,
+                "format": "pdf",
+                "metadata": {
+                    "document_type": "archived_signed",
+                    "provider": "certeurope",
+                },
+            }
+        )
+
+        # 3. Qualified timestamp
+        proofs.append(
+            {
+                "type": "qualified_timestamp",
+                "label": "Qualified Timestamp",
+                "available": True,
+                "url": (f"https://www.certeurope.fr/lre/timestamp/{external_id}.xml"),
+                "generated_at": sent_at,
+                "expires_at": expiration,
+                "format": "xml",
+                "metadata": {
+                    "timestamp_type": "qualified_eidas",
+                    "provider": "certeurope",
+                },
+            }
+        )
+
+        # 4. Electronic AR (if read)
+        read_at = getattr(self.missive, "read_at", None)
+        if read_at:
+            proofs.append(
+                {
+                    "type": "acknowledgment_receipt",
+                    "label": "Acknowledgement of Receipt",
+                    "available": True,
+                    "url": (f"https://www.certeurope.fr/lre/ar/{external_id}.pdf"),
+                    "generated_at": read_at,
+                    "expires_at": expiration,
+                    "format": "pdf",
+                    "metadata": {
+                        "certificate_type": "acknowledgment",
+                        "read_date": (
+                            read_at.isoformat()
+                            if hasattr(read_at, "isoformat")
+                            else str(read_at)
+                        ),
+                        "provider": "certeurope",
+                    },
+                }
+            )
+        else:
+            proofs.append(
+                {
+                    "type": "acknowledgment_receipt",
+                    "label": "Acknowledgement of Receipt",
+                    "available": False,
+                    "url": None,
+                    "generated_at": None,
+                    "expires_at": None,
+                    "format": "pdf",
+                    "metadata": {
+                        "status": "pending",
+                        "message": "Waiting for read",
+                        "provider": "certeurope",
+                    },
+                }
+            )
+
+        return proofs
+
+
+__all__ = ["CerteuropeProvider"]

pymissive/archives/providers/django_email.py

@@ -0,0 +1,182 @@
+"""Local email provider emulating Django's email backend without Django."""
+
+from __future__ import annotations
+
+import smtplib
+from email.message import EmailMessage
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+from .base.email_message import build_email_message
+
+
+class DjangoEmailProvider(BaseProvider):
+    """Minimal SMTP/file-based email provider compatible with Django configs."""
+
+    name = "django_email"
+    display_name = "Django Email Backend"
+    supported_types = ["EMAIL", "EMAIL_MARKETING"]
+    email_geographic_coverage: List[str] | str = ["*"]
+    email_geo: Any = email_geographic_coverage
+    email_marketing_geographic_coverage: List[str] | str = ["*"]
+    email_marketing_geo = email_marketing_geographic_coverage
+    description_text = (
+        "Lightweight email provider delegating to SMTP or local file delivery. "
+        "Mimics Django's console/backend behaviour without importing Django."
+    )
+    required_packages: List[str] = []
+
+    def validate(self) -> Tuple[bool, str]:
+        """Ensure minimal configuration is present."""
+        # Inject default geo config if not present so BaseProviderCommon validation passes
+        if "email_geo" not in self._raw_config:
+            self._raw_config["email_geo"] = self.email_geo
+
+        if not self._raw_config.get("DEFAULT_FROM_EMAIL"):
+            sender_name = self._get_missive_value("sender") or "noreply@example.com"
+            self._raw_config["DEFAULT_FROM_EMAIL"] = (
+                sender_name if isinstance(sender_name, str) else "noreply@example.com"
+            )
+
+        if not any(
+            [
+                self._raw_config.get("EMAIL_FILE_PATH"),
+                self._raw_config.get("EMAIL_HOST"),
+                self._bool_config("EMAIL_SUPPRESS_SEND", False),
+            ]
+        ):
+            return (
+                False,
+                "Configure EMAIL_HOST/EMAIL_PORT, EMAIL_FILE_PATH, "
+                "or set EMAIL_SUPPRESS_SEND to true to record emails locally.",
+            )
+
+        return super().validate()
+
+    def send_email(self, **kwargs: Any) -> bool:
+        """Send email via SMTP or write it locally, similar to Django's backend."""
+        is_valid, error = self._validate_and_check_recipient(
+            "get_recipient_email", "Recipient email missing"
+        )
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        recipient = self._get_missive_value(
+            "get_recipient_email"
+        ) or self._get_missive_value("recipient_email")
+
+        if not recipient:
+            self._update_status(
+                MissiveStatus.FAILED, error_message="Recipient email missing"
+            )
+            return False
+
+        message = self._build_email_message(recipient)
+
+        try:
+            delivery_target = self._deliver(message)
+        except (smtplib.SMTPException, OSError, ValueError) as exc:
+            return self._handle_send_error(exc)
+
+        external_id = f"django_email_{getattr(self.missive, 'id', 'unknown')}"
+        self._update_status(
+            MissiveStatus.SENT, provider=self.name, external_id=external_id
+        )
+        self._create_event("sent", f"Email dispatched via {delivery_target}")
+        return True
+
+    def send_email_marketing(self, **kwargs: Any) -> bool:
+        """Marketing emails reuse the same simple pipeline."""
+        return self.send_email(**kwargs)
+
+    def get_email_service_info(self) -> Dict[str, Any]:
+        host = self._raw_config.get("EMAIL_HOST") or "localhost"
+        return {
+            "credits": None,
+            "credits_type": "unlimited",
+            "is_available": True,
+            "limits": {"max_attachment_mb": self.max_email_attachment_size_mb},
+            "warnings": [],
+            "details": {
+                "backend": "smtp" if self._raw_config.get("EMAIL_HOST") else "file",
+                "host": host,
+                "port": self._raw_config.get("EMAIL_PORT"),
+                "use_tls": self._bool_config("EMAIL_USE_TLS", False),
+                "use_ssl": self._bool_config("EMAIL_USE_SSL", False),
+            },
+        }
+
+    def get_email_marketing_service_info(self) -> Dict[str, Any]:
+        return self.get_email_service_info()
+
+    def get_service_status(self) -> Dict[str, Any]:
+        """Return lightweight status for monitoring screens."""
+        backend = "smtp" if self._raw_config.get("EMAIL_HOST") else "file"
+        return self._build_generic_service_status(
+            status="operational",
+            is_available=True,
+            credits_type="unlimited",
+            rate_limits={},
+            details={"backend": backend},
+        )
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _build_email_message(self, recipient: str) -> EmailMessage:
+        from_email = str(
+            self._raw_config.get("DEFAULT_FROM_EMAIL") or "noreply@example.com"
+        )
+        return build_email_message(self, recipient, from_email=from_email)
+
+    def _deliver(self, message: EmailMessage) -> str:
+        if self._bool_config("EMAIL_SUPPRESS_SEND", False):
+            path = self._persist_to_file(message)
+            return f"local file (suppressed) -> {path}"
+
+        file_path = self._raw_config.get("EMAIL_FILE_PATH")
+        if file_path:
+            path = self._persist_to_file(message)
+            return f"local file -> {path}"
+
+        return self._send_via_smtp(message)
+
+    def _persist_to_file(self, message: EmailMessage) -> str:
+        directory = Path(self._raw_config.get("EMAIL_FILE_PATH") or "./sent-emails")
+        directory.mkdir(parents=True, exist_ok=True)
+        timestamp = self._clock().strftime("%Y%m%d-%H%M%S")
+        missive_id = getattr(self.missive, "id", "unknown")
+        filename = f"{timestamp}_{missive_id}.eml"
+        target = directory / filename
+        target.write_text(message.as_string(), encoding="utf-8")
+        return str(target)
+
+    def _send_via_smtp(self, message: EmailMessage) -> str:
+        host = self._raw_config.get("EMAIL_HOST") or "localhost"
+        port = int(self._raw_config.get("EMAIL_PORT") or 25)
+        use_ssl = self._bool_config("EMAIL_USE_SSL", False)
+        use_tls = self._bool_config("EMAIL_USE_TLS", not use_ssl)
+        timeout = float(self._raw_config.get("EMAIL_TIMEOUT") or 10)
+
+        smtp_class = smtplib.SMTP_SSL if use_ssl else smtplib.SMTP
+        with smtp_class(host, port, timeout=timeout) as client:
+            if not use_ssl and use_tls:
+                client.starttls()
+            username = self._raw_config.get("EMAIL_HOST_USER")
+            password = self._raw_config.get("EMAIL_HOST_PASSWORD")
+            if username and password:
+                client.login(username, password)
+            client.send_message(message)
+        return f"smtp://{host}:{port}"
+
+    def _bool_config(self, key: str, default: bool) -> bool:
+        value = self._raw_config.get(key, default)
+        if isinstance(value, str):
+            return value.strip().lower() in {"1", "true", "yes", "on"}
+        return bool(value)
+
+
+__all__ = ["DjangoEmailProvider"]

pymissive/archives/providers/fcm.py

@@ -0,0 +1,91 @@
+"""Firebase Cloud Messaging provider for push notifications."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ..status import MissiveStatus
+from .base import BaseProvider
+
+
+class FCMProvider(BaseProvider):
+    """
+    Firebase Cloud Messaging provider (push notifications).
+
+    Required configuration:
+        FCM_SERVER_KEY: Firebase server key
+        or
+        FCM_SERVICE_ACCOUNT_JSON: Path to service account JSON file
+
+    Recipient must have an FCM device_token stored in metadata.
+    """
+
+    name = "fcm"
+    display_name = "Firebase Cloud Messaging"
+    supported_types = ["PUSH_NOTIFICATION"]
+    # Geographic scope
+    push_notification_geo = "*"
+    config_keys = ["FCM_SERVER_KEY"]
+    required_packages = ["firebase-admin"]
+    site_url = "https://firebase.google.com/products/cloud-messaging"
+    description_text = "Mobile push notifications for Android and iOS (Google Firebase)"
+
+    def validate(self) -> tuple[bool, str]:
+        """Validate that the recipient has an FCM device token"""
+        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 {}
+        device_token = metadata.get("fcm_device_token")
+        if not device_token:
+            return (
+                False,
+                "Recipient does not have an FCM device token (add to metadata)",
+            )
+
+        return True, ""
+
+    def send_push_notification(self, **kwargs) -> bool:
+        """
+        Send a push notification via FCM.
+
+        TODO: Implement actual sending via firebase-admin SDK:
+        from firebase_admin import messaging
+        """
+        is_valid, error = self.validate()
+        if not is_valid:
+            self._update_status(MissiveStatus.FAILED, error_message=error)
+            return False
+
+        # TODO: Implement actual sending
+        # message = messaging.Message(
+        #     notification=messaging.Notification(
+        #         title=self.missive.subject,
+        #         body=self.missive.body_text or self.missive.body[:100],
+        #     ),
+        #     token=device_token,
+        # )
+        # response = messaging.send(message)
+
+        external_id = f"fcm_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 delivery status.
+
+        Note: FCM provides callbacks via webhooks.
+        """
+        return None
+
+
+__all__ = ["FCMProvider"]