Dokumentace API

#!/usr/bin/env python3
import json
import os
import shutil
import sys
import urllib.error
import urllib.request
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Optional


API_BASE_URL  = os.getenv("PEPPOS_BASE_URL",              "https://sandbox.pepposh.eu")
CLIENT_ID     = os.getenv("PEPPOS_CLIENT_ID",             "YOUR-API-KEY")
CLIENT_SECRET = os.getenv("PEPPOS_CLIENT_SECRET",         "YOUR-API-SECRET")

INPUT_DIR = Path(os.getenv("ISDOC_INPUT_DIR", "isdoc"))
SENT_DIR = Path(os.getenv("ISDOC_SENT_DIR", "isdoc_sent"))

@dataclass
class SendResult:
    filename: str
    sent: bool
    moved_to: Optional[str]
    document_id: Optional[str]
    final_status: Optional[str]
    queue_status: Optional[str]
    message: str


def http_json(
    method: str,
    url: str,
    headers: Optional[dict[str, str]] = None,
    payload: Optional[str] = None,
) -> tuple[int, Any]:
    req_headers = {"Accept": "application/json"}
    if headers:
        req_headers.update(headers)

    data: Optional[bytes] = None
    if payload is not None:
        if isinstance(payload, str):
            data = payload.encode("utf-8")
            req_headers["Content-Type"] = "application/xml"
        else:
            data = json.dumps(payload).encode("utf-8")
            req_headers["Content-Type"] = "application/json"

    req = urllib.request.Request(url, data=data, method=method, headers=req_headers)
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            raw = resp.read().decode("utf-8", errors="replace")
            return resp.getcode(), (json.loads(raw) if raw else {})
    except urllib.error.HTTPError as e:
        body = e.read().decode("utf-8", errors="replace")
        try:
            parsed = json.loads(body) if body else {}
        except json.JSONDecodeError:
            parsed = {"raw": body}
        return e.code, parsed


def get_token() -> str:
    if not CLIENT_ID or not CLIENT_SECRET:
        raise RuntimeError("Missing PEPPOS_CLIENT_ID or PEPPOS_CLIENT_SECRET environment variable.")

    status, body = http_json(
        "POST",
        f"{API_BASE_URL}/api/auth/token",
        payload={
            "client_id": CLIENT_ID,
            "client_secret": CLIENT_SECRET,
            "grant_type": "client_credentials",
        },
    )
    if status != 200 or "access_token" not in body:
        raise RuntimeError(f"Token request failed ({status}): {json.dumps(body, ensure_ascii=False)}")
    return body["access_token"]


def send_isdoc_document(token: str, isdoc_path: Path) -> tuple[Optional[str], dict[str, Any]]:
    content = isdoc_path.read_text(encoding="utf-8")
    status, body = http_json(
        "POST",
        f"{API_BASE_URL}/api/documents/send/as/isdoc?wait-for-result",
        headers={
            "Authorization": f"Bearer {token}",
        },
        payload=content,
    )

    if status not in (200, 201, 202):
        return None, {"http_status": status, "response": body}

    document_id = body.get("data", {}).get("documentId") if isinstance(body, dict) else None
    return document_id, {"http_status": status, "response": body}

def main() -> int:
    if not INPUT_DIR.exists():
        print(f"Input directory not found: {INPUT_DIR}")
        return 1

    SENT_DIR.mkdir(parents=True, exist_ok=True)

    try:
        token = get_token()
    except Exception as e:
        print(f"Token error: {e}")
        return 1

    files = sorted(p for p in INPUT_DIR.glob("*.isdoc") if p.is_file())
    if not files:
        print(f"No .isdoc files found in {INPUT_DIR}")
        return 0

    results: list[SendResult] = []

    for path in files:
        try:
            document_id, send_meta = send_isdoc_document(token, path)
            if not document_id:
                results.append(
                    SendResult(
                        filename=path.name,
                        sent=False,
                        moved_to=None,
                        document_id=None,
                        final_status=None,
                        queue_status=None,
                        message=f"Send failed: {json.dumps(send_meta, ensure_ascii=False)}",
                    )
                )
                continue

            status_body = send_meta.get("response") if isinstance(send_meta, dict) else {}
            final_status = status_body.get("status") if isinstance(status_body, dict) else None
            queue_status = None
            message_status = None
            if isinstance(status_body, dict):
                queue_status = (status_body.get("sendQueueStatus") or {}).get("status")
                message_status = status_body.get("messageStatus")

            is_sent = queue_status in {"sent", "delivered"} or message_status in {"sent", "delivered"}

            if is_sent:
                target = SENT_DIR / path.name
                shutil.move(str(path), str(target))
                results.append(
                    SendResult(
                        filename=path.name,
                        sent=True,
                        moved_to=str(target),
                        document_id=document_id,
                        final_status=final_status,
                        queue_status=queue_status,
                        message="Sent and moved.",
                    )
                )
            else:
                results.append(
                    SendResult(
                        filename=path.name,
                        sent=False,
                        moved_to=None,
                        document_id=document_id,
                        final_status=final_status,
                        queue_status=queue_status,
                        message=f"Not sent or delivery failed: {json.dumps(status_body, ensure_ascii=False)}",
                    )
                )
        except Exception as e:
            results.append(
                SendResult(
                    filename=path.name,
                    sent=False,
                    moved_to=None,
                    document_id=None,
                    final_status=None,
                    queue_status=None,
                    message=f"Error: {e}",
                )
            )

    print("\n=== Batch result ===")
    for r in results:
        print(
            json.dumps(
                {
                    "file": r.filename,
                    "sent": r.sent,
                    "moved_to": r.moved_to,
                    "document_id": r.document_id,
                    "final_status": r.final_status,
                    "queue_status": r.queue_status,
                    "message": r.message,
                },
                ensure_ascii=False,
            )
        )

    sent_count = sum(1 for r in results if r.sent)
    print(f"\nSent successfully: {sent_count}/{len(results)}")
    return 0 if sent_count == len(results) else 2


if __name__ == "__main__":
    sys.exit(main())