"""Approved-report and company-form PDF generation. WeasyPrint (BSD-3-Clause) renders Jinja2 HTML templates, so every layout is plain HTML/CSS that anyone on the team can edit. The approved Daily Call Report and every company form (tour plan, fare chart, sales & stock, ...) extend ``templates/forms/_form_base.html``, because each is a copy of the company's printed form; each has its own template (``dcr.html`` or one under ``templates/forms/``). What a form shows is decided in ``app.pdf.forms``. WeasyPrint needs system libraries (Pango, HarfBuzz) and DejaVu fonts. They are pinned in the Dockerfile. If they are genuinely absent (a bare dev machine, CI without the apt step) the service falls back to a minimal built-in writer so the workflow still completes and tests still run — and logs a loud warning, because that fallback produces a plain-text PDF, not the designed layout. Production must have WeasyPrint; ``pdf_engine_ready()`` lets the health check and startup log say so. """ import logging import uuid from html.parser import HTMLParser from pathlib import Path from zoneinfo import ZoneInfo from jinja2 import Environment, FileSystemLoader, select_autoescape from sqlalchemy.ext.asyncio import AsyncSession from app.audit.service import AuditService from app.common.enums import AuditAction, EntityType from app.config.settings import settings from app.pdf.forms import approval_signature_line, build_dcr_context, build_form_context from app.reports.models import DailyCallReport from app.reports.serializers import planned_visits from app.users.models import User logger = logging.getLogger(__name__) _TEMPLATE_DIR = Path(__file__).parent / "templates" _env = Environment( loader=FileSystemLoader(_TEMPLATE_DIR), autoescape=select_autoescape(["html"]), ) _env.globals.update( company_name=settings.PDF_COMPANY_NAME, company_address=settings.PDF_COMPANY_ADDRESS, company_website=settings.PDF_COMPANY_WEBSITE, company_email=settings.PDF_COMPANY_EMAIL, company_phone=settings.PDF_COMPANY_PHONE, ) try: # pragma: no cover - depends on system libraries from weasyprint import HTML as _WeasyHTML WEASYPRINT_AVAILABLE = True except Exception: # noqa: BLE001 - ImportError or OSError from missing libs _WeasyHTML = None WEASYPRINT_AVAILABLE = False def pdf_engine_ready() -> bool: """True when the designed (WeasyPrint) layout can be rendered.""" return WEASYPRINT_AVAILABLE def _minimal_pdf(text: str) -> bytes: """Fallback renderer: a valid single-page PDF containing plain text. Used ONLY when WeasyPrint's system libraries are unavailable. It exists so the approval workflow and its tests never depend on native libraries being present. """ lines = [ln[:95] for ln in text.splitlines()][:52] content = ["BT", "/F1 9 Tf", "40 780 Td", "11 TL"] for line in lines: escaped = line.replace("\\", r"\\").replace("(", r"\(").replace(")", r"\)") content.append(f"({escaped}) Tj T*") content.append("ET") stream = "\n".join(content).encode("latin-1", "replace") objects = [ b"<< /Type /Catalog /Pages 2 0 R >>", b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>", b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] " b"/Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>", b"<< /Length " + str(len(stream)).encode() + b" >>\nstream\n" + stream + b"\nendstream", b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>", ] out = bytearray(b"%PDF-1.4\n") offsets = [0] for i, body in enumerate(objects, start=1): offsets.append(len(out)) out += f"{i} 0 obj\n".encode() + body + b"\nendobj\n" xref_pos = len(out) out += f"xref\n0 {len(objects) + 1}\n".encode() out += b"0000000000 65535 f \n" for off in offsets[1:]: out += f"{off:010d} 00000 n \n".encode() out += ( f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n" f"startxref\n{xref_pos}\n%%EOF\n" ).encode() return bytes(out) class _TextExtractor(HTMLParser): """Flattens a rendered form to lines of text for the plain-text fallback.""" _SKIP = {"style", "title", "script"} _BREAK = {"tr", "div", "h1", "h2", "p", "br", "table"} def __init__(self) -> None: super().__init__() self.parts: list[str] = [] self._skipping = 0 def handle_starttag(self, tag: str, attrs: list) -> None: if tag in self._SKIP: self._skipping += 1 def handle_endtag(self, tag: str) -> None: if tag in self._SKIP: self._skipping -= 1 elif tag in {"td", "th"}: self.parts.append(" | ") elif tag in self._BREAK: self.parts.append("\n") def handle_data(self, data: str) -> None: if not self._skipping and data.strip(): self.parts.append(" ".join(data.split()) + " ") def _html_to_text(html: str) -> str: parser = _TextExtractor() parser.feed(html) lines = ("".join(parser.parts)).splitlines() cleaned = (" ".join(line.split()).strip(" |") for line in lines) return "\n".join(line for line in cleaned if line) def _approval_signature_line( table_name: str, approval_status: str | None = None, am_name: str | None = None, am_role: str = "Area Manager", ) -> str: return approval_signature_line(table_name, approval_status, am_name) def csv_table_pdf_bytes( table_name: str, table_label: str, columns: tuple[str, ...], rows: list[dict[str, object]], approval_status: str | None = None, am_name: str | None = None, am_role: str = "Area Manager", approved_at: str | None = None, renumber: bool = False, ) -> bytes: """Render every stored row of an imported table on its own company-form layout.""" context = build_form_context( table_name, table_label, columns, rows, approval_status, am_name, approved_at, renumber ) html = _env.get_template(f"forms/{context['template']}.html").render(**context) if WEASYPRINT_AVAILABLE: return _WeasyHTML(string=html).write_pdf() logger.warning( "WeasyPrint unavailable — using the plain-text fallback renderer for %s. " "Install Pango/HarfBuzz (see Dockerfile) before production use.", table_name, ) return _minimal_pdf(_html_to_text(html)) def csv_pdf_bytes(table_label: str, row: dict[str, object]) -> bytes: """Render one imported table row for the row-level PDF action.""" columns = tuple(key for key in row if key not in {"id", "source_row_number"}) return csv_table_pdf_bytes("row", table_label, columns, [row]) class PDFService: def __init__(self, db: AsyncSession) -> None: self.db = db self.audit = AuditService(db) async def _approval(self, dcr: DailyCallReport) -> dict[str, str] | None: """Who approved the report and when, from the audit trail — the signature cannot be typed in.""" if dcr.approved_at is None: return None approvals = [h for h in await self.audit.approval_history_for(dcr.id) if h.action == AuditAction.APPROVE] if not approvals: return None approver = await self.db.get(User, approvals[-1].actor_user_id) if approver is None: return None when = dcr.approved_at.astimezone(ZoneInfo(settings.APP_TIMEZONE)).strftime("%d/%m/%Y %H:%M") return {"name": approver.full_name, "at": when} async def _context(self, dcr: DailyCallReport) -> dict: missed = [ {"name": p.name, "kind": p.kind.title(), "reason": p.missed_reason} for p in planned_visits(dcr) if p.status == "MISSED" ] return build_dcr_context( dcr, sorted(dcr.doctor_calls, key=lambda c: c.visit_time), sorted(dcr.chemist_calls, key=lambda c: c.visit_time), await self._approval(dcr), missed, ) async def render_bytes(self, dcr: DailyCallReport) -> bytes: """The report as a PDF in the current layout — a pure function of the stored report.""" context = await self._context(dcr) html = _env.get_template("dcr.html").render(**context) if WEASYPRINT_AVAILABLE: return _WeasyHTML(string=html).write_pdf() logger.warning( "WeasyPrint unavailable — using the plain-text fallback renderer. " "Install Pango/cairo (see Dockerfile) before production use." ) return _minimal_pdf(_env.get_template("dcr.txt").render(**context)) async def render_and_store(self, dcr: DailyCallReport, approver: User) -> str: pdf_bytes = await self.render_bytes(dcr) directory = Path(settings.PDF_STORAGE_PATH) / str(dcr.report_date.year) directory.mkdir(parents=True, exist_ok=True) path = directory / f"DCR-{dcr.report_date.isoformat()}-{dcr.id}.pdf" path.write_bytes(pdf_bytes) await self.audit.log( actor_user_id=approver.id, entity_type=EntityType.DCR, entity_id=dcr.id, action=AuditAction.UPDATE, after={"pdf_generated": str(path)}, ) return str(path)