Automate SLA Reporting and Compliance Certificates with DocForge API in Python

pip install requests python-dotenv

import os
import json
import requests
from datetime import datetime, date
from typing import Any
from dotenv import load_dotenv
 
load_dotenv()
 
DOCFORGE_KEY = os.getenv("YOUR_API_KEY")
DOCFORGE_BASE = "https://apivult.com/api/docforge"
 
HEADERS = {
    "X-RapidAPI-Key": DOCFORGE_KEY,
    "Content-Type": "application/json"
}

SLA_REPORT_TEMPLATE = {
    "template_id": "sla_monthly_report_v2",
    "document_type": "pdf",
    "page_size": "A4",
    "branding": {
        "logo_url": "https://apivult.com/_static/logo.png",
        "primary_color": "#1e40af",
        "font_family": "Inter"
    },
    "sections": [
        {
            "type": "header",
            "fields": ["report_title", "customer_name", "report_period", "generated_date"]
        },
        {
            "type": "summary_metrics",
            "title": "Service Level Summary",
            "metrics": [
                {"label": "Uptime", "field": "uptime_pct", "format": "percentage", "threshold": 99.9},
                {"label": "Avg Response Time", "field": "avg_latency_ms", "format": "ms"},
                {"label": "P99 Latency", "field": "p99_latency_ms", "format": "ms"},
                {"label": "Incidents", "field": "incident_count", "format": "integer"},
                {"label": "SLA Breaches", "field": "sla_breach_count", "format": "integer"}
            ]
        },
        {
            "type": "table",
            "title": "Incident Summary",
            "columns": ["date", "severity", "duration_minutes", "affected_services", "root_cause"],
            "data_field": "incidents"
        },
        {
            "type": "chart",
            "chart_type": "line",
            "title": "Uptime Trend (Last 30 Days)",
            "data_field": "daily_uptime_data"
        },
        {
            "type": "compliance_statement",
            "field": "sla_compliance_statement"
        },
        {
            "type": "footer",
            "fields": ["generated_by", "document_id", "page_numbers"]
        }
    ]
}

def get_sla_metrics(
    customer_id: str,
    start_date: date,
    end_date: date,
    monitoring_api_url: str,
    monitoring_token: str
) -> dict:
    """Fetch SLA metrics for a customer from your monitoring system."""
    resp = requests.get(
        f"{monitoring_api_url}/customers/{customer_id}/metrics",
        params={
            "start": start_date.isoformat(),
            "end": end_date.isoformat(),
            "metrics": "uptime,latency,incidents"
        },
        headers={"Authorization": f"Bearer {monitoring_token}"}
    )
    resp.raise_for_status()
    return resp.json()
 
 
def build_sla_report_data(
    customer: dict,
    metrics: dict,
    report_period: str
) -> dict:
    """Structure SLA data for the DocForge template."""
    uptime_pct = metrics["uptime_percentage"]
    sla_target = customer.get("sla_target_pct", 99.9)
    breach_count = sum(
        1 for day in metrics.get("daily_uptime", [])
        if day["uptime_pct"] < sla_target
    )
 
    # Build compliance statement
    if uptime_pct >= sla_target:
        compliance = (
            f"This report confirms that {customer['company_name']} achieved "
            f"{uptime_pct:.3f}% uptime during {report_period}, meeting the "
            f"contracted SLA target of {sla_target}%."
        )
    else:
        shortfall = sla_target - uptime_pct
        compliance = (
            f"Service availability during {report_period} was {uptime_pct:.3f}%, "
            f"which fell {shortfall:.3f}% below the contracted SLA target of "
            f"{sla_target}%. Service credits have been applied per Section 4.2 "
            f"of the Master Service Agreement."
        )
 
    return {
        "report_title": f"Monthly Service Level Report — {report_period}",
        "customer_name": customer["company_name"],
        "customer_id": customer["id"],
        "report_period": report_period,
        "generated_date": datetime.utcnow().strftime("%B %d, %Y"),
        "uptime_pct": uptime_pct,
        "avg_latency_ms": metrics["avg_latency_ms"],
        "p99_latency_ms": metrics["p99_latency_ms"],
        "incident_count": len(metrics.get("incidents", [])),
        "sla_breach_count": breach_count,
        "incidents": metrics.get("incidents", []),
        "daily_uptime_data": metrics.get("daily_uptime", []),
        "sla_compliance_statement": compliance,
        "generated_by": "APIVult Automated Reporting System",
        "document_id": f"SLA-{customer['id']}-{report_period.replace(' ', '-')}"
    }

def generate_sla_report_pdf(report_data: dict) -> bytes:
    """Generate a PDF SLA report via DocForge API."""
    payload = {
        "template": SLA_REPORT_TEMPLATE,
        "data": report_data,
        "options": {
            "watermark": None,  # Set to "DRAFT" for previews
            "digital_signature": False,
            "compress": True
        }
    }
 
    resp = requests.post(
        f"{DOCFORGE_BASE}/generate",
        json=payload,
        headers=HEADERS
    )
    resp.raise_for_status()
    result = resp.json()
 
    if not result["success"]:
        raise ValueError(f"Document generation failed: {result['error']}")
 
    # DocForge returns base64-encoded PDF
    import base64
    return base64.b64decode(result["data"]["document_base64"])

COMPLIANCE_CERT_TEMPLATE = {
    "template_id": "compliance_certificate_v1",
    "document_type": "pdf",
    "page_size": "A4",
    "orientation": "landscape",
    "branding": {
        "logo_url": "https://apivult.com/_static/logo.png",
        "primary_color": "#1e40af",
        "style": "formal_certificate"
    },
    "sections": [
        {
            "type": "certificate_header",
            "title": "Certificate of Compliance"
        },
        {
            "type": "certificate_body",
            "fields": [
                "entity_name", "framework", "audit_period",
                "compliance_scope", "certification_statement"
            ]
        },
        {
            "type": "certificate_signatures",
            "signatories": ["issued_by", "reviewed_by"],
            "date_field": "issue_date"
        },
        {
            "type": "certificate_footer",
            "fields": ["certificate_id", "valid_until", "verification_url"]
        }
    ]
}
 
 
def generate_compliance_certificate(
    entity_name: str,
    framework: str,
    audit_period: str,
    scope_items: list[str],
    issued_by: str,
    cert_id: str
) -> bytes:
    """Generate a compliance certificate PDF."""
    cert_data = {
        "entity_name": entity_name,
        "framework": framework,
        "audit_period": audit_period,
        "compliance_scope": scope_items,
        "certification_statement": (
            f"This certifies that {entity_name} has demonstrated compliance with "
            f"all applicable requirements of {framework} for the audit period "
            f"{audit_period}. All controls were assessed and found to be operating "
            f"effectively as of the audit completion date."
        ),
        "issued_by": issued_by,
        "reviewed_by": "Independent Compliance Reviewer",
        "issue_date": datetime.utcnow().strftime("%B %d, %Y"),
        "certificate_id": cert_id,
        "valid_until": "12 months from issue date",
        "verification_url": f"https://apivult.com/verify/{cert_id}"
    }
 
    payload = {
        "template": COMPLIANCE_CERT_TEMPLATE,
        "data": cert_data,
        "options": {
            "watermark": None,
            "digital_signature": True,
            "compress": True
        }
    }
 
    resp = requests.post(
        f"{DOCFORGE_BASE}/generate",
        json=payload,
        headers=HEADERS
    )
    resp.raise_for_status()
    result = resp.json()
 
    if not result["success"]:
        raise ValueError(f"Certificate generation failed: {result['error']}")
 
    import base64
    return base64.b64decode(result["data"]["document_base64"])

def generate_monthly_sla_reports(
    customers: list[dict],
    report_month: str,
    monitoring_api_url: str,
    monitoring_token: str,
    output_dir: str = "reports"
) -> list[str]:
    """Generate SLA reports for all enterprise customers."""
    import os
    os.makedirs(output_dir, exist_ok=True)
 
    generated = []
    failed = []
 
    for customer in customers:
        try:
            # Parse date range for the report month
            from dateutil.relativedelta import relativedelta
            from dateutil.parser import parse as parse_date
            month_start = parse_date(f"{report_month}-01").date()
            month_end = (month_start + relativedelta(months=1, days=-1))
 
            metrics = get_sla_metrics(
                customer["id"], month_start, month_end,
                monitoring_api_url, monitoring_token
            )
            report_data = build_sla_report_data(customer, metrics, report_month)
            pdf_bytes = generate_sla_report_pdf(report_data)
 
            filename = f"{output_dir}/SLA-{customer['id']}-{report_month}.pdf"
            with open(filename, "wb") as f:
                f.write(pdf_bytes)
 
            generated.append(filename)
            print(f"  ✅ Generated: {filename}")
 
        except Exception as e:
            failed.append({"customer_id": customer["id"], "error": str(e)})
            print(f"  ❌ Failed for {customer['id']}: {e}")
 
    print(f"\nGenerated {len(generated)} reports, {len(failed)} failed")
    return generated
 
 
if __name__ == "__main__":
    customers = [
        {"id": "ENT-001", "company_name": "Acme Corp", "sla_target_pct": 99.9},
        {"id": "ENT-002", "company_name": "Globex Industries", "sla_target_pct": 99.5},
        {"id": "ENT-003", "company_name": "Initech Systems", "sla_target_pct": 99.95}
    ]
 
    generate_monthly_sla_reports(
        customers=customers,
        report_month="2026-03",
        monitoring_api_url="https://internal-monitoring-api",
        monitoring_token=os.getenv("MONITORING_API_TOKEN"),
        output_dir="reports/2026-03"
    )