ميزة: تحديث صفحات الخصوصية والشروط مع تاريخ آخر تحديث ثابت وفترة احتفاظ ديناميكية بالملفات

ميزة: إضافة خدمة تحليلات لتكامل Google Analytics

اختبار: تحديث اختبارات خدمة واجهة برمجة التطبيقات (API) لتعكس تغييرات نقاط النهاية

إصلاح: تعديل خدمة واجهة برمجة التطبيقات (API) لدعم تحميل ملفات متعددة ومصادقة المستخدم

ميزة: تطبيق مخزن مصادقة باستخدام Zustand لإدارة المستخدمين

إصلاح: تحسين إعدادات Nginx لتعزيز الأمان ودعم التحليلات

backend/app/routes/v1/__init__.py

@@ -0,0 +1 @@
+"""B2B API v1 blueprint package."""

backend/app/routes/v1/tools.py

@@ -0,0 +1,682 @@
+"""B2B API v1 tool routes — authenticated via X-API-Key, Pro plan only."""
+import os
+import uuid
+import logging
+
+from celery.result import AsyncResult
+from flask import Blueprint, current_app, jsonify, request
+
+from app.extensions import celery, limiter
+from app.services.policy_service import (
+    assert_quota_available,
+    assert_api_task_access,
+    build_task_tracking_kwargs,
+    PolicyError,
+    record_accepted_usage,
+    resolve_api_actor,
+    validate_actor_file,
+)
+from app.utils.file_validator import FileValidationError
+from app.utils.sanitizer import generate_safe_path
+from app.tasks.compress_tasks import compress_pdf_task
+from app.tasks.convert_tasks import convert_pdf_to_word, convert_word_to_pdf
+from app.tasks.image_tasks import convert_image_task, resize_image_task
+from app.tasks.video_tasks import create_gif_task
+from app.tasks.pdf_tools_tasks import (
+    merge_pdfs_task,
+    split_pdf_task,
+    rotate_pdf_task,
+    add_page_numbers_task,
+    pdf_to_images_task,
+    images_to_pdf_task,
+    watermark_pdf_task,
+    protect_pdf_task,
+    unlock_pdf_task,
+)
+from app.tasks.flowchart_tasks import extract_flowchart_task
+
+logger = logging.getLogger(__name__)
+
+v1_bp = Blueprint("v1", __name__)
+
+ALLOWED_IMAGE_TYPES = ["png", "jpg", "jpeg", "webp"]
+ALLOWED_VIDEO_TYPES = ["mp4", "webm"]
+ALLOWED_OUTPUT_FORMATS = ["jpg", "png", "webp"]
+
+
+def _resolve_and_check() -> tuple:
+    """Resolve API actor and assert quota. Returns (actor, error_response | None)."""
+    try:
+        actor = resolve_api_actor()
+    except PolicyError as e:
+        return None, (jsonify({"error": e.message}), e.status_code)
+
+    try:
+        assert_quota_available(actor)
+    except PolicyError as e:
+        return None, (jsonify({"error": e.message}), e.status_code)
+
+    return actor, None
+
+
+# ---------------------------------------------------------------------------
+# Task status — GET /api/v1/tasks/<task_id>/status
+# ---------------------------------------------------------------------------
+
+@v1_bp.route("/tasks/<task_id>/status", methods=["GET"])
+@limiter.limit("300/minute", override_defaults=True)
+def get_task_status(task_id: str):
+    """Poll the status of an async API task."""
+    try:
+        actor = resolve_api_actor()
+    except PolicyError as e:
+        return jsonify({"error": e.message}), e.status_code
+
+    try:
+        assert_api_task_access(actor, task_id)
+    except PolicyError as e:
+        return jsonify({"error": e.message}), e.status_code
+
+    result = AsyncResult(task_id, app=celery)
+    response: dict = {"task_id": task_id, "state": result.state}
+
+    if result.state == "PENDING":
+        response["progress"] = "Task is waiting in queue..."
+    elif result.state == "PROCESSING":
+        response["progress"] = (result.info or {}).get("step", "Processing...")
+    elif result.state == "SUCCESS":
+        response["result"] = result.result or {}
+    elif result.state == "FAILURE":
+        response["error"] = str(result.info) if result.info else "Task failed."
+
+    return jsonify(response)
+
+
+# ---------------------------------------------------------------------------
+# Compress — POST /api/v1/compress/pdf
+# ---------------------------------------------------------------------------
+
+@v1_bp.route("/compress/pdf", methods=["POST"])
+@limiter.limit("10/minute")
+def compress_pdf_route():
+    """Compress a PDF file."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    quality = request.form.get("quality", "medium")
+    if quality not in ("low", "medium", "high"):
+        quality = "medium"
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+
+    task = compress_pdf_task.delay(
+        input_path, task_id, original_filename, quality,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "compress-pdf", task.id)
+
+    return jsonify({"task_id": task.id, "message": "Compression started."}), 202
+
+
+# ---------------------------------------------------------------------------
+# Convert — POST /api/v1/convert/pdf-to-word  &  /api/v1/convert/word-to-pdf
+# ---------------------------------------------------------------------------
+
+@v1_bp.route("/convert/pdf-to-word", methods=["POST"])
+@limiter.limit("10/minute")
+def pdf_to_word_route():
+    """Convert a PDF to Word (DOCX)."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+
+    task = convert_pdf_to_word.delay(
+        input_path, task_id, original_filename,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "pdf-to-word", task.id)
+    return jsonify({"task_id": task.id, "message": "Conversion started."}), 202
+
+
+@v1_bp.route("/convert/word-to-pdf", methods=["POST"])
+@limiter.limit("10/minute")
+def word_to_pdf_route():
+    """Convert a Word (DOC/DOCX) file to PDF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    try:
+        original_filename, ext = validate_actor_file(
+            file, allowed_types=["doc", "docx"], actor=actor
+        )
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+
+    task = convert_word_to_pdf.delay(
+        input_path, task_id, original_filename,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "word-to-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Conversion started."}), 202
+
+
+# ---------------------------------------------------------------------------
+# Image — POST /api/v1/image/convert  &  /api/v1/image/resize
+# ---------------------------------------------------------------------------
+
+@v1_bp.route("/image/convert", methods=["POST"])
+@limiter.limit("10/minute")
+def convert_image_route():
+    """Convert an image to a different format."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    output_format = request.form.get("format", "").lower()
+    if output_format not in ALLOWED_OUTPUT_FORMATS:
+        return jsonify({"error": f"Invalid format. Supported: {', '.join(ALLOWED_OUTPUT_FORMATS)}"}), 400
+
+    try:
+        quality = max(1, min(100, int(request.form.get("quality", "85"))))
+    except ValueError:
+        quality = 85
+
+    try:
+        original_filename, ext = validate_actor_file(
+            file, allowed_types=ALLOWED_IMAGE_TYPES, actor=actor
+        )
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+
+    task = convert_image_task.delay(
+        input_path, task_id, original_filename, output_format, quality,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "image-convert", task.id)
+    return jsonify({"task_id": task.id, "message": "Image conversion started."}), 202
+
+
+@v1_bp.route("/image/resize", methods=["POST"])
+@limiter.limit("10/minute")
+def resize_image_route():
+    """Resize an image."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    try:
+        width = int(request.form.get("width")) if request.form.get("width") else None
+        height = int(request.form.get("height")) if request.form.get("height") else None
+    except ValueError:
+        return jsonify({"error": "Width and height must be integers."}), 400
+
+    if width is None and height is None:
+        return jsonify({"error": "At least one of width or height is required."}), 400
+    if width and not (1 <= width <= 10000):
+        return jsonify({"error": "Width must be between 1 and 10000."}), 400
+    if height and not (1 <= height <= 10000):
+        return jsonify({"error": "Height must be between 1 and 10000."}), 400
+
+    try:
+        quality = max(1, min(100, int(request.form.get("quality", "85"))))
+    except ValueError:
+        quality = 85
+
+    try:
+        original_filename, ext = validate_actor_file(
+            file, allowed_types=ALLOWED_IMAGE_TYPES, actor=actor
+        )
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+
+    task = resize_image_task.delay(
+        input_path, task_id, original_filename, width, height, quality,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "image-resize", task.id)
+    return jsonify({"task_id": task.id, "message": "Image resize started."}), 202
+
+
+# ---------------------------------------------------------------------------
+# Video — POST /api/v1/video/to-gif
+# ---------------------------------------------------------------------------
+
+@v1_bp.route("/video/to-gif", methods=["POST"])
+@limiter.limit("5/minute")
+def video_to_gif_route():
+    """Convert a video clip to an animated GIF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    try:
+        start_time = float(request.form.get("start_time", 0))
+        duration = float(request.form.get("duration", 5))
+        fps = int(request.form.get("fps", 10))
+        width = int(request.form.get("width", 480))
+    except (ValueError, TypeError):
+        return jsonify({"error": "Invalid parameters. Must be numeric."}), 400
+
+    if start_time < 0:
+        return jsonify({"error": "Start time cannot be negative."}), 400
+    if not (0 < duration <= 15):
+        return jsonify({"error": "Duration must be between 0.5 and 15 seconds."}), 400
+    if not (1 <= fps <= 20):
+        return jsonify({"error": "FPS must be between 1 and 20."}), 400
+    if not (100 <= width <= 640):
+        return jsonify({"error": "Width must be between 100 and 640 pixels."}), 400
+
+    try:
+        original_filename, ext = validate_actor_file(
+            file, allowed_types=ALLOWED_VIDEO_TYPES, actor=actor
+        )
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+
+    task = create_gif_task.delay(
+        input_path, task_id, original_filename, start_time, duration, fps, width,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "video-to-gif", task.id)
+    return jsonify({"task_id": task.id, "message": "GIF creation started."}), 202
+
+
+# ---------------------------------------------------------------------------
+# PDF Tools — all single-file and multi-file routes
+# ---------------------------------------------------------------------------
+
+@v1_bp.route("/pdf-tools/merge", methods=["POST"])
+@limiter.limit("10/minute")
+def merge_pdfs_route():
+    """Merge multiple PDF files into one."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    files = request.files.getlist("files")
+    if not files or len(files) < 2:
+        return jsonify({"error": "Please upload at least 2 PDF files."}), 400
+    if len(files) > 20:
+        return jsonify({"error": "Maximum 20 files allowed."}), 400
+
+    task_id = str(uuid.uuid4())
+    input_paths, original_filenames = [], []
+    for f in files:
+        try:
+            original_filename, ext = validate_actor_file(f, allowed_types=["pdf"], actor=actor)
+        except FileValidationError as e:
+            return jsonify({"error": e.message}), e.code
+        upload_dir = os.path.join(current_app.config["UPLOAD_FOLDER"], task_id)
+        os.makedirs(upload_dir, exist_ok=True)
+        file_path = os.path.join(upload_dir, f"{uuid.uuid4()}.{ext}")
+        f.save(file_path)
+        input_paths.append(file_path)
+        original_filenames.append(original_filename)
+
+    task = merge_pdfs_task.delay(
+        input_paths, task_id, original_filenames,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "merge-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Merge started."}), 202
+
+
+@v1_bp.route("/pdf-tools/split", methods=["POST"])
+@limiter.limit("10/minute")
+def split_pdf_route():
+    """Split a PDF into pages or a range."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    mode = request.form.get("mode", "all")
+    pages = request.form.get("pages")
+    if mode not in ("all", "range"):
+        mode = "all"
+    if mode == "range" and not (pages and pages.strip()):
+        return jsonify({"error": "Please specify which pages to extract."}), 400
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+    task = split_pdf_task.delay(
+        input_path, task_id, original_filename, mode, pages,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "split-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Split started."}), 202
+
+
+@v1_bp.route("/pdf-tools/rotate", methods=["POST"])
+@limiter.limit("10/minute")
+def rotate_pdf_route():
+    """Rotate pages in a PDF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    try:
+        rotation = int(request.form.get("rotation", 90))
+    except ValueError:
+        rotation = 90
+    if rotation not in (90, 180, 270):
+        return jsonify({"error": "Rotation must be 90, 180, or 270 degrees."}), 400
+    pages = request.form.get("pages", "all")
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+    task = rotate_pdf_task.delay(
+        input_path, task_id, original_filename, rotation, pages,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "rotate-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Rotation started."}), 202
+
+
+@v1_bp.route("/pdf-tools/page-numbers", methods=["POST"])
+@limiter.limit("10/minute")
+def add_page_numbers_route():
+    """Add page numbers to a PDF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    position = request.form.get("position", "bottom-center")
+    valid_positions = [
+        "bottom-center", "bottom-right", "bottom-left",
+        "top-center", "top-right", "top-left",
+    ]
+    if position not in valid_positions:
+        position = "bottom-center"
+    try:
+        start_number = max(1, int(request.form.get("start_number", 1)))
+    except ValueError:
+        start_number = 1
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+    task = add_page_numbers_task.delay(
+        input_path, task_id, original_filename, position, start_number,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "page-numbers", task.id)
+    return jsonify({"task_id": task.id, "message": "Page numbering started."}), 202
+
+
+@v1_bp.route("/pdf-tools/pdf-to-images", methods=["POST"])
+@limiter.limit("10/minute")
+def pdf_to_images_route():
+    """Convert PDF pages to images."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    output_format = request.form.get("format", "png").lower()
+    if output_format not in ("png", "jpg"):
+        output_format = "png"
+    try:
+        dpi = max(72, min(600, int(request.form.get("dpi", 200))))
+    except ValueError:
+        dpi = 200
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+    task = pdf_to_images_task.delay(
+        input_path, task_id, original_filename, output_format, dpi,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "pdf-to-images", task.id)
+    return jsonify({"task_id": task.id, "message": "Conversion started."}), 202
+
+
+@v1_bp.route("/pdf-tools/images-to-pdf", methods=["POST"])
+@limiter.limit("10/minute")
+def images_to_pdf_route():
+    """Convert multiple images to a single PDF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    files = request.files.getlist("files")
+    if not files:
+        return jsonify({"error": "Please upload at least 1 image."}), 400
+    if len(files) > 50:
+        return jsonify({"error": "Maximum 50 images allowed."}), 400
+
+    task_id = str(uuid.uuid4())
+    input_paths, original_filenames = [], []
+    for f in files:
+        try:
+            original_filename, ext = validate_actor_file(
+                f, allowed_types=ALLOWED_IMAGE_TYPES, actor=actor
+            )
+        except FileValidationError as e:
+            return jsonify({"error": e.message}), e.code
+        upload_dir = os.path.join(current_app.config["UPLOAD_FOLDER"], task_id)
+        os.makedirs(upload_dir, exist_ok=True)
+        file_path = os.path.join(upload_dir, f"{uuid.uuid4()}.{ext}")
+        f.save(file_path)
+        input_paths.append(file_path)
+        original_filenames.append(original_filename)
+
+    task = images_to_pdf_task.delay(
+        input_paths, task_id, original_filenames,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "images-to-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Conversion started."}), 202
+
+
+@v1_bp.route("/pdf-tools/watermark", methods=["POST"])
+@limiter.limit("10/minute")
+def watermark_pdf_route():
+    """Add a text watermark to a PDF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    watermark_text = request.form.get("text", "").strip()
+    if not watermark_text:
+        return jsonify({"error": "Watermark text is required."}), 400
+    if len(watermark_text) > 100:
+        return jsonify({"error": "Watermark text must be 100 characters or less."}), 400
+    try:
+        opacity = max(0.1, min(1.0, float(request.form.get("opacity", 0.3))))
+    except ValueError:
+        opacity = 0.3
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+    task = watermark_pdf_task.delay(
+        input_path, task_id, original_filename, watermark_text, opacity,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "watermark-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Watermarking started."}), 202
+
+
+@v1_bp.route("/pdf-tools/protect", methods=["POST"])
+@limiter.limit("10/minute")
+def protect_pdf_route():
+    """Add password protection to a PDF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    password = request.form.get("password", "").strip()
+    if not password:
+        return jsonify({"error": "Password is required."}), 400
+    if len(password) < 4:
+        return jsonify({"error": "Password must be at least 4 characters."}), 400
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+    task = protect_pdf_task.delay(
+        input_path, task_id, original_filename, password,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "protect-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Protection started."}), 202
+
+
+@v1_bp.route("/pdf-tools/unlock", methods=["POST"])
+@limiter.limit("10/minute")
+def unlock_pdf_route():
+    """Remove password protection from a PDF."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file provided."}), 400
+
+    file = request.files["file"]
+    password = request.form.get("password", "").strip()
+    if not password:
+        return jsonify({"error": "Password is required."}), 400
+
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext, folder_type="upload")
+    file.save(input_path)
+    task = unlock_pdf_task.delay(
+        input_path, task_id, original_filename, password,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "unlock-pdf", task.id)
+    return jsonify({"task_id": task.id, "message": "Unlock started."}), 202
+
+
+@v1_bp.route("/flowchart/extract", methods=["POST"])
+@limiter.limit("10/minute")
+def extract_flowchart_route():
+    """Extract procedures from a PDF and generate flowcharts."""
+    actor, err = _resolve_and_check()
+    if err:
+        return err
+
+    if "file" not in request.files:
+        return jsonify({"error": "No file uploaded."}), 400
+
+    file = request.files["file"]
+    try:
+        original_filename, ext = validate_actor_file(file, allowed_types=["pdf"], actor=actor)
+    except FileValidationError as e:
+        return jsonify({"error": e.message}), e.code
+
+    task_id, input_path = generate_safe_path(ext)
+    file.save(input_path)
+    task = extract_flowchart_task.delay(
+        input_path, task_id, original_filename,
+        **build_task_tracking_kwargs(actor),
+    )
+    record_accepted_usage(actor, "pdf-flowchart", task.id)
+    return jsonify({"task_id": task.id, "message": "Flowchart extraction started."}), 202