PDF Export V1

README.md

@@ -72,3 +72,17 @@ Environment variables for the API:
 
 Frontend environment variables:
 - `VITE_API_BASE` (optional, default: `/api`)
+
+## PDF Export (ReportLab)
+
+The server generates PDFs using ReportLab at:
+
+```
+GET /api/sessions/{session_id}/export.pdf
+```
+
+Install dependencies:
+
+```powershell
+pip install -r server/requirements.txt
+```

frontend/src/pages/ExportPage.tsx

@@ -84,6 +84,9 @@ export default function ExportPage() {
   const serverExportUrl = sessionId
     ? `${API_BASE}/sessions/${sessionId}/export`
     : "";
+  const serverPdfUrl = sessionId
+    ? `${API_BASE}/sessions/${sessionId}/export.pdf`
+    : "";
 
   function downloadJson() {
     const pack: Record<string, unknown> = {};
@@ -261,18 +264,31 @@ export default function ExportPage() {
                 <div>
                   <div className="text-sm font-semibold text-gray-900">PDF export</div>
                   <div className="text-xs text-gray-500">
-                    Use the browser print dialog to save as PDF
+                    Generate a PDF on the server (ReportLab) or use the browser print dialog.
                   </div>
                 </div>
               </div>
 
-              <button
-                type="button"
-                onClick={handlePrint}
-                className="mt-4 inline-flex items-center justify-center gap-2 rounded-lg bg-blue-600 px-4 py-2.5 text-white font-semibold hover:bg-blue-700 transition"
-              >
-                Print / Save PDF
-              </button>
+              <div className="mt-4 grid grid-cols-1 sm:grid-cols-2 gap-3">
+                <a
+                  href={serverPdfUrl}
+                  target="_blank"
+                  rel="noreferrer"
+                  className={[
+                    "inline-flex items-center justify-center gap-2 rounded-lg bg-blue-600 px-4 py-2.5 text-white font-semibold hover:bg-blue-700 transition",
+                    !sessionId ? "pointer-events-none opacity-50" : "",
+                  ].join(" ")}
+                >
+                  Download PDF (server)
+                </a>
+                <button
+                  type="button"
+                  onClick={handlePrint}
+                  className="inline-flex items-center justify-center gap-2 rounded-lg border border-gray-200 bg-white px-4 py-2.5 text-sm font-semibold text-gray-800 hover:bg-gray-50 transition"
+                >
+                  Print / Save PDF (browser)
+                </button>
+              </div>
             </div>
           </div>
         </div>

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "RepEx",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

server/app/api/routes/sessions.py

@@ -19,6 +19,7 @@ from ..schemas import (
 from ...services import SessionStore
 from ...services.session_store import DATA_EXTS, IMAGE_EXTS
 from ...services.data_import import populate_session_from_data_files
+from ...services.pdf_reportlab import render_report_pdf
 
 
 router = APIRouter()
@@ -291,6 +292,24 @@ def export_package(
     )
 
 
+@router.get("/{session_id}/export.pdf")
+def export_pdf(
+    session_id: str, store: SessionStore = Depends(get_session_store)
+) -> FileResponse:
+    session_id = _normalize_session_id(session_id, store)
+    session = store.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found.")
+    pages = store.ensure_pages(session)
+    export_path = Path(store.session_dir(session_id)) / "export.pdf"
+    render_report_pdf(store, session, pages, export_path)
+    return FileResponse(
+        export_path,
+        media_type="application/pdf",
+        filename=f"repex_report_{session_id}.pdf",
+    )
+
+
 @router.get("/{session_id}/export.xlsx")
 def export_excel(
     session_id: str, store: SessionStore = Depends(get_session_store)

server/app/services/pdf_reportlab.py

@@ -0,0 +1,608 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import mm
+from reportlab.lib.utils import ImageReader
+from PIL import Image
+from reportlab.pdfgen import canvas
+
+from .session_store import SessionStore
+
+
+def _has_template_content(template: dict | None) -> bool:
+    if not template:
+        return False
+    for value in template.values():
+        if isinstance(value, str) and value.strip():
+            return True
+        if value not in (None, ""):
+            return True
+    return False
+
+
+def _chunk(items: List[str], size: int) -> List[List[str]]:
+    if not items:
+        return []
+    return [items[i : i + size] for i in range(0, len(items), size)]
+
+
+def _safe_text(value: Optional[str]) -> str:
+    return (value or "").strip()
+
+
+def _wrap_lines(
+    pdf: canvas.Canvas,
+    text: str,
+    width: float,
+    max_lines: int,
+    font: str,
+    size: int,
+) -> List[str]:
+    if not text:
+        return []
+    pdf.setFont(font, size)
+    words = text.split()
+    lines: List[str] = []
+    current: List[str] = []
+    for word in words:
+        test = " ".join(current + [word])
+        if pdf.stringWidth(test, font, size) <= width or not current:
+            current.append(word)
+        else:
+            lines.append(" ".join(current))
+            current = [word]
+        if len(lines) >= max_lines:
+            current = []
+            break
+    if current and len(lines) < max_lines:
+        lines.append(" ".join(current))
+    return lines
+
+
+def _draw_wrapped(
+    pdf: canvas.Canvas,
+    text: str,
+    x: float,
+    y: float,
+    width: float,
+    leading: float,
+    max_lines: int,
+    font: str,
+    size: int,
+) -> float:
+    lines = _wrap_lines(pdf, text, width, max_lines, font, size)
+    if not lines:
+        return y
+    pdf.setFont(font, size)
+    for line in lines:
+        pdf.drawString(x, y, line)
+        y -= leading
+    return y
+
+
+def _draw_centered_block(
+    pdf: canvas.Canvas,
+    lines: List[str],
+    x_center: float,
+    box_bottom: float,
+    box_height: float,
+    leading: float,
+    font: str,
+    size: int,
+) -> None:
+    if not lines:
+        return
+    pdf.setFont(font, size)
+    block_h = len(lines) * leading
+    start_y = box_bottom + (box_height + block_h) / 2 - leading
+    y = start_y
+    for line in lines:
+        pdf.drawCentredString(x_center, y, line)
+        y -= leading
+
+
+def _draw_label_value(
+    pdf: canvas.Canvas,
+    label: str,
+    value: str,
+    x: float,
+    y: float,
+    label_font: str,
+    value_font: str,
+    label_size: int,
+    value_size: int,
+    label_color: colors.Color,
+    value_color: colors.Color,
+) -> float:
+    pdf.setFillColor(label_color)
+    pdf.setFont(label_font, label_size)
+    pdf.drawString(x, y, label)
+    y -= label_size + 1
+    pdf.setFillColor(value_color)
+    pdf.setFont(value_font, value_size)
+    pdf.drawString(x, y, value or "-")
+    return y
+
+
+def _badge_style(value: str, scale: dict) -> tuple[str, colors.Color, colors.Color]:
+    key = (value or "").strip().upper()
+    tone = scale.get(key)
+    if not tone:
+        return (value or "-"), colors.HexColor("#f9fafb"), colors.HexColor("#374151")
+    return f"{key} - {tone['label']}", tone["bg"], tone["text"]
+
+
+def _resolve_logo_path(store: SessionStore, session: dict, raw: str) -> Optional[Path]:
+    value = _safe_text(raw)
+    if not value:
+        return None
+    uploads = (session.get("uploads") or {}).get("photos") or []
+    lower = value.lower()
+    for item in uploads:
+        name = (item.get("name") or "").lower()
+        if not name:
+            continue
+        stem = name.rsplit(".", 1)[0]
+        if lower == name or lower == stem:
+            path = store.resolve_upload_path(session, item.get("id"))
+            if path and path.exists():
+                return path
+    return None
+
+
+def _draw_image_fit(
+    pdf: canvas.Canvas,
+    image_path: Path,
+    x: float,
+    y: float,
+    width: float,
+    height: float,
+) -> bool:
+    try:
+        reader = ImageReader(str(image_path))
+        iw, ih = reader.getSize()
+    except Exception:
+        try:
+            img = Image.open(image_path)
+            img.load()
+            if img.mode not in ("RGB", "L"):
+                img = img.convert("RGB")
+            reader = ImageReader(img)
+            iw, ih = reader.getSize()
+        except Exception:
+            try:
+                pdf.drawImage(
+                    str(image_path),
+                    x,
+                    y,
+                    width,
+                    height,
+                    preserveAspectRatio=True,
+                    mask="auto",
+                )
+                return True
+            except Exception:
+                return False
+    if iw <= 0 or ih <= 0:
+        return False
+    scale = min(width / iw, height / ih)
+    draw_w = iw * scale
+    draw_h = ih * scale
+    draw_x = x + (width - draw_w) / 2
+    draw_y = y + (height - draw_h) / 2
+    pdf.drawImage(
+        reader,
+        draw_x,
+        draw_y,
+        draw_w,
+        draw_h,
+        preserveAspectRatio=True,
+        mask="auto",
+    )
+    return True
+
+
+def render_report_pdf(
+    store: SessionStore,
+    session: dict,
+    pages: List[dict],
+    output_path: Path,
+) -> Path:
+    width, height = A4
+    margin = 10 * mm
+    header_h = 20 * mm
+    footer_h = 8 * mm
+    gap = 4 * mm
+
+    gray_50 = colors.HexColor("#f9fafb")
+    gray_200 = colors.HexColor("#e5e7eb")
+    gray_500 = colors.HexColor("#6b7280")
+    gray_700 = colors.HexColor("#374151")
+    gray_800 = colors.HexColor("#1f2937")
+    gray_900 = colors.HexColor("#111827")
+    gray_600 = colors.HexColor("#4b5563")
+    amber_50 = colors.HexColor("#fffbeb")
+    amber_300 = colors.HexColor("#fcd34d")
+    amber_800 = colors.HexColor("#92400e")
+    emerald_50 = colors.HexColor("#ecfdf5")
+    emerald_800 = colors.HexColor("#065f46")
+    blue_50 = colors.HexColor("#eff6ff")
+    blue_300 = colors.HexColor("#93c5fd")
+    blue_800 = colors.HexColor("#1e40af")
+    blue_200 = colors.HexColor("#bfdbfe")
+    blue_900 = colors.HexColor("#1e3a8a")
+    purple_200 = colors.HexColor("#e9d5ff")
+    purple_800 = colors.HexColor("#6b21a8")
+    green_100 = colors.HexColor("#dcfce7")
+    green_200 = colors.HexColor("#bbf7d0")
+    yellow_100 = colors.HexColor("#fef9c3")
+    yellow_200 = colors.HexColor("#fef08a")
+    orange_200 = colors.HexColor("#fed7aa")
+    red_200 = colors.HexColor("#fecaca")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    pdf = canvas.Canvas(str(output_path), pagesize=A4)
+
+    uploads = (session.get("uploads") or {}).get("photos") or []
+    by_id = {item.get("id"): item for item in uploads if item.get("id")}
+
+    print_pages: List[dict] = []
+    for page_index, page in enumerate(pages):
+        template = page.get("template") or {}
+        photo_ids = page.get("photo_ids") or []
+        photo_entries = []
+        for pid in photo_ids:
+            item = by_id.get(pid)
+            if not item:
+                continue
+            path = store.resolve_upload_path(session, pid)
+            if path and path.exists():
+                label = _safe_text(item.get("name") or path.name)
+                photo_entries.append({"path": path, "label": label})
+        chunks = _chunk(photo_entries, 6) or [[]]
+        for chunk_index, chunk in enumerate(chunks):
+            print_pages.append(
+                {
+                    "page_index": page_index,
+                    "template": template,
+                    "photos": chunk,
+                    "variant": "full" if chunk_index == 0 else "photos",
+                }
+            )
+
+    if not print_pages:
+        print_pages = [
+            {
+                "page_index": 0,
+                "template": {},
+                "photos": [],
+                "variant": "full",
+            }
+        ]
+
+    total_pages = len(print_pages)
+    repo_root = Path(__file__).resolve().parents[3]
+    logo_candidates = [
+        repo_root / "frontend" / "public" / "assets" / "prosento-logo.png",
+        repo_root / "frontend" / "dist" / "assets" / "prosento-logo.png",
+        repo_root / "server" / "assets" / "prosento-logo.png",
+    ]
+    default_logo = next((path for path in logo_candidates if path.exists()), None)
+
+    for output_index, payload in enumerate(print_pages):
+        template = payload["template"]
+        photos = payload["photos"]
+        variant = payload["variant"]
+
+        header_y = height - margin
+        content_top = header_y - header_h - gap
+        content_bottom = margin + footer_h + gap
+        content_height = content_top - content_bottom
+
+        # Header
+        logo_x = margin
+        logo_y = header_y - 15 * mm
+        logo_w = 28 * mm
+        logo_h = 15 * mm
+        logo_drawn = False
+        if default_logo:
+            logo_drawn = _draw_image_fit(pdf, default_logo, logo_x, logo_y, logo_w, logo_h)
+        if not logo_drawn:
+            pdf.setStrokeColor(colors.red)
+            pdf.setLineWidth(1)
+            pdf.rect(logo_x, logo_y, logo_w, logo_h, stroke=1, fill=0)
+            pdf.setFillColor(colors.red)
+            pdf.setFont("Helvetica-Bold", 9)
+            pdf.drawString(logo_x + 2, logo_y + logo_h / 2 - 3, "LOGO MISSING")
+        else:
+            pdf.setStrokeColor(gray_200)
+            pdf.setLineWidth(0.5)
+            pdf.rect(logo_x, logo_y, logo_w, logo_h, stroke=1, fill=0)
+        client_logo = _resolve_logo_path(store, session, template.get("company_logo", ""))
+        if client_logo:
+            _draw_image_fit(
+                pdf,
+                client_logo,
+                width - margin - 32 * mm,
+                header_y - 15 * mm,
+                32 * mm,
+                15 * mm,
+            )
+        pdf.setFillColor(gray_900)
+        pdf.setFont("Helvetica-Bold", 13)
+        pdf.drawCentredString(width / 2, header_y - 7 * mm, "RepEx Inspection Job Sheet")
+        pdf.setFillColor(gray_600)
+        pdf.setFont("Helvetica", 11)
+        pdf.drawCentredString(width / 2, header_y - 13 * mm, f"Page {output_index + 1} of {total_pages}")
+        pdf.setStrokeColor(gray_200)
+        pdf.line(margin, header_y - 17 * mm, width - margin, header_y - 17 * mm)
+
+        y = content_top
+
+        if variant == "full":
+            # Observations and Findings
+            pdf.setFillColor(gray_800)
+            pdf.setFont("Helvetica-Bold", 14)
+            pdf.drawString(margin, y, "Observations and Findings")
+            pdf.setStrokeColor(gray_200)
+            pdf.line(margin, y - 2, width - margin, y - 2)
+            y -= 8 * mm
+
+            ref = _safe_text(template.get("reference"))
+            area = _safe_text(template.get("area"))
+            location = _safe_text(template.get("functional_location"))
+            item_desc = _safe_text(template.get("item_description"))
+            condition_desc = _safe_text(template.get("condition_description"))
+            action_type = _safe_text(template.get("action_type"))
+            required_action = _safe_text(template.get("required_action"))
+
+            left_w = (width - 2 * margin) * 0.6
+            right_w = (width - 2 * margin) * 0.4
+            left_x = margin
+            right_x = margin + left_w + 4 * mm
+
+            label_size = 11
+            value_size = 12
+            value_gap = 2 * mm
+            row_gap = 4 * mm
+            leading = 14
+
+            row_y = y
+            _draw_label_value(
+                pdf,
+                "Ref",
+                ref,
+                left_x,
+                row_y,
+                "Helvetica",
+                "Helvetica-Bold",
+                label_size,
+                value_size,
+                gray_500,
+                gray_900,
+            )
+            _draw_label_value(
+                pdf,
+                "Area",
+                area,
+                left_x + left_w / 2,
+                row_y,
+                "Helvetica",
+                "Helvetica-Bold",
+                label_size,
+                value_size,
+                gray_500,
+                gray_900,
+            )
+
+            pdf.setFillColor(gray_500)
+            pdf.setFont("Helvetica", label_size)
+            pdf.drawString(right_x, row_y, "Location")
+            pdf.setFillColor(gray_900)
+            loc_lines = _wrap_lines(
+                pdf,
+                location or "-",
+                right_w - 2 * mm,
+                2,
+                "Helvetica-Bold",
+                value_size,
+            )
+            _draw_wrapped(
+                pdf,
+                location or "-",
+                right_x,
+                row_y - label_size - value_gap,
+                right_w - 2 * mm,
+                leading,
+                2,
+                "Helvetica-Bold",
+                value_size,
+            )
+
+            y = row_y - (label_size + value_gap + leading * max(1, len(loc_lines))) - row_gap
+
+            category = _safe_text(template.get("category"))
+            priority = _safe_text(template.get("priority"))
+            cat_scale = {
+                "0": {"label": "Excellent", "bg": green_100, "text": colors.HexColor("#166534")},
+                "1": {"label": "Good", "bg": green_200, "text": colors.HexColor("#166534")},
+                "2": {"label": "Fair", "bg": yellow_100, "text": colors.HexColor("#854d0e")},
+                "3": {"label": "Poor", "bg": yellow_200, "text": colors.HexColor("#854d0e")},
+                "4": {"label": "Worse", "bg": orange_200, "text": colors.HexColor("#9a3412")},
+                "5": {"label": "Severe", "bg": red_200, "text": colors.HexColor("#991b1b")},
+            }
+            pr_scale = {
+                "1": {"label": "Immediate", "bg": red_200, "text": colors.HexColor("#991b1b")},
+                "2": {"label": "1 Year", "bg": orange_200, "text": colors.HexColor("#9a3412")},
+                "3": {"label": "3 Years", "bg": green_200, "text": colors.HexColor("#166534")},
+                "X": {"label": "At Use", "bg": purple_200, "text": purple_800},
+                "M": {"label": "Monitor", "bg": blue_200, "text": blue_900},
+            }
+            cat_text, cat_bg, cat_text_color = _badge_style(category, cat_scale)
+            pr_text, pr_bg, pr_text_color = _badge_style(priority, pr_scale)
+
+            badge_w = 40 * mm
+            badge_h = 10 * mm
+            y -= 2 * mm
+            pdf.setFillColor(gray_500)
+            pdf.setFont("Helvetica", 11)
+            cat_label_x = margin + 20 * mm + badge_w / 2
+            pr_label_x = margin + 100 * mm + badge_w / 2
+            label_y = y
+            pdf.drawCentredString(cat_label_x, label_y, "Category")
+            pdf.drawCentredString(pr_label_x, label_y, "Priority")
+            y -= 16 * mm
+            pdf.setFillColor(cat_bg)
+            pdf.setStrokeColor(gray_200)
+            pdf.roundRect(margin + 20 * mm, y - 2, badge_w, badge_h, 2 * mm, stroke=1, fill=1)
+            pdf.setFillColor(cat_text_color)
+            pdf.setFont("Helvetica-Bold", 11)
+            pdf.drawCentredString(cat_label_x, y - 2 + badge_h / 2 - 4, cat_text)
+            pdf.setFillColor(pr_bg)
+            pdf.roundRect(margin + 100 * mm, y - 2, badge_w, badge_h, 2 * mm, stroke=1, fill=1)
+            pdf.setFillColor(pr_text_color)
+            pdf.drawCentredString(pr_label_x, y - 2 + badge_h / 2 - 4, pr_text)
+            y -= 10 * mm
+
+            condition = " - ".join([v for v in [item_desc, condition_desc] if v])
+            action = " - ".join([v for v in [action_type, required_action] if v])
+
+            pdf.setFillColor(gray_500)
+            pdf.setFont("Helvetica", 11)
+            pdf.drawCentredString(
+                margin + (width - 2 * margin) / 2, y, "Condition Description"
+            )
+            y -= 4 * mm
+            pdf.setFillColor(amber_50)
+            pdf.setStrokeColor(amber_300)
+            cond_lines = _wrap_lines(
+                pdf,
+                condition or "-",
+                width - 2 * margin - 4 * mm,
+                4,
+                "Helvetica-Bold",
+                11,
+            )
+            cond_h = max(18 * mm, (len(cond_lines) or 1) * leading + 6 * mm)
+            cond_bottom = y - cond_h
+            pdf.rect(margin, cond_bottom, width - 2 * margin, cond_h, stroke=1, fill=1)
+            pdf.setLineWidth(3)
+            pdf.line(margin, cond_bottom, margin, y)
+            pdf.setLineWidth(1)
+            pdf.setFillColor(amber_800)
+            pdf.setFont("Helvetica-Bold", 11)
+            text_center_x = margin + (width - 2 * margin) / 2
+            _draw_centered_block(
+                pdf,
+                cond_lines,
+                text_center_x,
+                cond_bottom,
+                cond_h,
+                leading,
+                "Helvetica-Bold",
+                11,
+            )
+            y = cond_bottom - 6 * mm
+
+            pdf.setFillColor(gray_500)
+            pdf.setFont("Helvetica", 11)
+            pdf.drawCentredString(
+                margin + (width - 2 * margin) / 2, y, "Required Action"
+            )
+            y -= 4 * mm
+            pdf.setFillColor(blue_50)
+            pdf.setStrokeColor(blue_300)
+            action_lines = _wrap_lines(
+                pdf,
+                action or "-",
+                width - 2 * margin - 4 * mm,
+                4,
+                "Helvetica-Bold",
+                11,
+            )
+            action_h = max(18 * mm, (len(action_lines) or 1) * leading + 6 * mm)
+            action_bottom = y - action_h
+            pdf.rect(margin, action_bottom, width - 2 * margin, action_h, stroke=1, fill=1)
+            pdf.setLineWidth(3)
+            pdf.line(margin, action_bottom, margin, y)
+            pdf.setLineWidth(1)
+            pdf.setFillColor(blue_800)
+            pdf.setFont("Helvetica-Bold", 11)
+            text_center_x = margin + (width - 2 * margin) / 2
+            _draw_centered_block(
+                pdf,
+                action_lines,
+                text_center_x,
+                action_bottom,
+                action_h,
+                leading,
+                "Helvetica-Bold",
+                11,
+            )
+            y = action_bottom - 6 * mm
+        else:
+            pdf.setFillColor(gray_800)
+            pdf.setFont("Helvetica-Bold", 11)
+            pdf.drawString(margin, y, "Photo Documentation (continued)")
+            pdf.setStrokeColor(gray_200)
+            pdf.line(margin, y - 2, width - margin, y - 2)
+            y -= 8 * mm
+
+        if variant == "full":
+            y -= 2 * mm
+            pdf.setFillColor(gray_800)
+            pdf.setFont("Helvetica-Bold", 14)
+            pdf.drawString(margin, y, "Photo Documentation")
+            pdf.setStrokeColor(gray_200)
+            pdf.line(margin, y - 2, width - margin, y - 2)
+            y -= 8 * mm
+
+        photo_area_top = y
+        photo_area_height = max(40 * mm, photo_area_top - content_bottom)
+
+        if photos:
+            columns = 1 if len(photos) == 1 else 2
+            rows = math.ceil(len(photos) / columns)
+            cell_w = (width - 2 * margin - (columns - 1) * 6 * mm) / columns
+            cell_h = (photo_area_height - (rows - 1) * 6 * mm) / rows
+
+            for idx, photo in enumerate(photos):
+                photo_path = photo["path"]
+                label = photo.get("label") or photo_path.name
+                row = idx // columns
+                col = idx % columns
+                x = margin + col * (cell_w + 6 * mm)
+                y = photo_area_top - (row + 1) * cell_h - row * 6 * mm
+                pdf.setStrokeColor(gray_200)
+                pdf.setFillColor(gray_50)
+                pdf.roundRect(x, y, cell_w, cell_h, 3 * mm, stroke=1, fill=1)
+                _draw_image_fit(
+                    pdf, photo_path, x + 2 * mm, y + 8 * mm, cell_w - 4 * mm, cell_h - 14 * mm
+                )
+                pdf.setFillColor(gray_500)
+                pdf.setFont("Helvetica", 11)
+                if label:
+                    pdf.drawCentredString(
+                        x + cell_w / 2, y + 3 * mm, f"Fig {idx + 1}: {label}"
+                    )
+        else:
+            pdf.setFont("Helvetica", 11)
+            pdf.drawString(margin, photo_area_top - 10 * mm, "No photos selected.")
+
+        # Footer
+        footer_y = margin
+        pdf.setFillColor(gray_500)
+        pdf.setFont("Helvetica", 11)
+        pdf.drawCentredString(width / 2, footer_y + 5 * mm, "Prosento - (c) 2026 All Rights Reserved")
+        pdf.drawCentredString(width / 2, footer_y + 1 * mm, "Automatically generated job sheet")
+
+        pdf.showPage()
+
+    pdf.save()
+    return output_path
+

server/requirements.txt

@@ -3,3 +3,5 @@ uvicorn[standard]>=0.30.0,<0.32.0
 python-multipart>=0.0.9,<0.1.0
 openpyxl>=3.1.2,<4.0.0
 xlrd>=2.0.1,<3.0.0
+reportlab>=4.2.5,<5.0.0
+pillow>=10.4.0,<11.0.0