الميزات: إضافة أدوات جديدة لمعالجة ملفات PDF، تشمل التلخيص والترجمة واستخراج الجداول.

- تفعيل مكون SummarizePdf لإنشاء ملخصات PDF باستخدام الذكاء الاصطناعي.

- تفعيل مكون TranslatePdf لترجمة محتوى PDF إلى لغات متعددة.

- تفعيل مكون TableExtractor لاستخراج الجداول من ملفات PDF.

- تحديث الصفحة الرئيسية والتوجيه ليشمل الأدوات الجديدة.

- إضافة ترجمات للأدوات الجديدة باللغات الإنجليزية والعربية والفرنسية.

- توسيع أنواع واجهة برمجة التطبيقات (API) لدعم الميزات الجديدة المتعلقة بمعالجة ملفات PDF. --feat: Initialize frontend with React, Vite, and Tailwind CSS

- Set up main entry point for React application.
- Create About, Home, NotFound, Privacy, and Terms pages with SEO support.
- Implement API service for file uploads and task management.
- Add global styles using Tailwind CSS.
- Create utility functions for SEO and text processing.
- Configure Vite for development and production builds.
- Set up Nginx configuration for serving frontend and backend.
- Add scripts for cleanup of expired files and sitemap generation.
- Implement deployment script for production environment.

backend/app/tasks/compress_image_tasks.py

@@ -0,0 +1,90 @@
+"""Celery tasks for image compression."""
+import os
+import logging
+
+from flask import current_app
+
+from app.extensions import celery
+from app.services.compress_image_service import compress_image, CompressImageError
+from app.services.storage_service import storage
+from app.services.task_tracking_service import finalize_task_tracking
+from app.utils.sanitizer import cleanup_task_files
+
+logger = logging.getLogger(__name__)
+
+
+def _cleanup(task_id: str):
+    cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
+
+
+@celery.task(bind=True, name="app.tasks.compress_image_tasks.compress_image_task")
+def compress_image_task(
+    self,
+    input_path: str,
+    task_id: str,
+    original_filename: str,
+    quality: int = 75,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Compress an image file."""
+    ext = os.path.splitext(original_filename)[1].lstrip(".")
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, f"{task_id}.{ext}")
+
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Compressing image..."})
+
+        stats = compress_image(input_path, output_path, quality)
+
+        self.update_state(state="PROCESSING", meta={"step": "Uploading result..."})
+        s3_key = storage.upload_file(output_path, task_id, folder="outputs")
+
+        name_without_ext = os.path.splitext(original_filename)[0]
+        download_name = f"{name_without_ext}_compressed.{ext}"
+        download_url = storage.generate_presigned_url(s3_key, original_filename=download_name)
+
+        result = {
+            "status": "completed",
+            "download_url": download_url,
+            "filename": download_name,
+            "original_size": stats["original_size"],
+            "compressed_size": stats["compressed_size"],
+            "reduction_percent": stats["reduction_percent"],
+        }
+
+        logger.info(f"Task {task_id}: Image compression completed")
+        finalize_task_tracking(
+            user_id=user_id, tool="compress-image",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except CompressImageError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="compress-image",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="compress-image",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result

backend/app/tasks/html_to_pdf_tasks.py

@@ -0,0 +1,86 @@
+"""Celery tasks for HTML to PDF conversion."""
+import os
+import logging
+
+from flask import current_app
+
+from app.extensions import celery
+from app.services.html_to_pdf_service import html_to_pdf, html_string_to_pdf, HtmlToPdfError
+from app.services.storage_service import storage
+from app.services.task_tracking_service import finalize_task_tracking
+from app.utils.sanitizer import cleanup_task_files
+
+logger = logging.getLogger(__name__)
+
+
+def _cleanup(task_id: str):
+    cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
+
+
+@celery.task(bind=True, name="app.tasks.html_to_pdf_tasks.html_to_pdf_task")
+def html_to_pdf_task(
+    self,
+    input_path: str,
+    task_id: str,
+    original_filename: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Convert an HTML file to PDF."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, f"{task_id}.pdf")
+
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Converting HTML to PDF..."})
+
+        stats = html_to_pdf(input_path, output_path)
+
+        self.update_state(state="PROCESSING", meta={"step": "Uploading result..."})
+        s3_key = storage.upload_file(output_path, task_id, folder="outputs")
+
+        name_without_ext = os.path.splitext(original_filename)[0]
+        download_name = f"{name_without_ext}.pdf"
+        download_url = storage.generate_presigned_url(s3_key, original_filename=download_name)
+
+        result = {
+            "status": "completed",
+            "download_url": download_url,
+            "filename": download_name,
+            "output_size": stats["output_size"],
+        }
+
+        logger.info(f"Task {task_id}: HTML to PDF completed")
+        finalize_task_tracking(
+            user_id=user_id, tool="html-to-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except HtmlToPdfError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="html-to-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="html-to-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result

backend/app/tasks/pdf_ai_tasks.py

@@ -0,0 +1,266 @@
+"""Celery tasks for PDF AI tools — Chat, Summarize, Translate, Table Extract."""
+import os
+import logging
+
+from flask import current_app
+
+from app.extensions import celery
+from app.services.pdf_ai_service import (
+    chat_with_pdf,
+    summarize_pdf,
+    translate_pdf,
+    extract_tables,
+    PdfAiError,
+)
+from app.services.task_tracking_service import finalize_task_tracking
+from app.utils.sanitizer import cleanup_task_files
+
+logger = logging.getLogger(__name__)
+
+
+def _cleanup(task_id: str):
+    cleanup_task_files(task_id, keep_outputs=False)
+
+
+# ---------------------------------------------------------------------------
+# Chat with PDF
+# ---------------------------------------------------------------------------
+@celery.task(bind=True, name="app.tasks.pdf_ai_tasks.chat_with_pdf_task")
+def chat_with_pdf_task(
+    self,
+    input_path: str,
+    task_id: str,
+    original_filename: str,
+    question: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Ask a question about a PDF document."""
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Analyzing document..."})
+
+        data = chat_with_pdf(input_path, question)
+
+        result = {
+            "status": "completed",
+            "reply": data["reply"],
+            "pages_analyzed": data["pages_analyzed"],
+        }
+
+        logger.info(f"Task {task_id}: Chat with PDF completed")
+        finalize_task_tracking(
+            user_id=user_id, tool="chat-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except PdfAiError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="chat-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="chat-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+
+# ---------------------------------------------------------------------------
+# Summarize PDF
+# ---------------------------------------------------------------------------
+@celery.task(bind=True, name="app.tasks.pdf_ai_tasks.summarize_pdf_task")
+def summarize_pdf_task(
+    self,
+    input_path: str,
+    task_id: str,
+    original_filename: str,
+    length: str = "medium",
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Generate a summary of a PDF document."""
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Summarizing document..."})
+
+        data = summarize_pdf(input_path, length)
+
+        result = {
+            "status": "completed",
+            "summary": data["summary"],
+            "pages_analyzed": data["pages_analyzed"],
+        }
+
+        logger.info(f"Task {task_id}: PDF summarize completed")
+        finalize_task_tracking(
+            user_id=user_id, tool="summarize-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except PdfAiError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="summarize-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="summarize-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+
+# ---------------------------------------------------------------------------
+# Translate PDF
+# ---------------------------------------------------------------------------
+@celery.task(bind=True, name="app.tasks.pdf_ai_tasks.translate_pdf_task")
+def translate_pdf_task(
+    self,
+    input_path: str,
+    task_id: str,
+    original_filename: str,
+    target_language: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Translate a PDF document to another language."""
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Translating document..."})
+
+        data = translate_pdf(input_path, target_language)
+
+        result = {
+            "status": "completed",
+            "translation": data["translation"],
+            "pages_analyzed": data["pages_analyzed"],
+            "target_language": data["target_language"],
+        }
+
+        logger.info(f"Task {task_id}: PDF translate completed")
+        finalize_task_tracking(
+            user_id=user_id, tool="translate-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except PdfAiError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="translate-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="translate-pdf",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+
+# ---------------------------------------------------------------------------
+# Extract Tables
+# ---------------------------------------------------------------------------
+@celery.task(bind=True, name="app.tasks.pdf_ai_tasks.extract_tables_task")
+def extract_tables_task(
+    self,
+    input_path: str,
+    task_id: str,
+    original_filename: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Extract tables from a PDF document."""
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Extracting tables..."})
+
+        data = extract_tables(input_path)
+
+        result = {
+            "status": "completed",
+            "tables": data["tables"],
+            "tables_found": data["tables_found"],
+        }
+
+        logger.info(f"Task {task_id}: Table extraction completed")
+        finalize_task_tracking(
+            user_id=user_id, tool="extract-tables",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except PdfAiError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="extract-tables",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="extract-tables",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result

backend/app/tasks/pdf_to_excel_tasks.py

@@ -0,0 +1,87 @@
+"""Celery tasks for PDF to Excel conversion."""
+import os
+import logging
+
+from flask import current_app
+
+from app.extensions import celery
+from app.services.pdf_to_excel_service import pdf_to_excel, PdfToExcelError
+from app.services.storage_service import storage
+from app.services.task_tracking_service import finalize_task_tracking
+from app.utils.sanitizer import cleanup_task_files
+
+logger = logging.getLogger(__name__)
+
+
+def _cleanup(task_id: str):
+    cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
+
+
+@celery.task(bind=True, name="app.tasks.pdf_to_excel_tasks.pdf_to_excel_task")
+def pdf_to_excel_task(
+    self,
+    input_path: str,
+    task_id: str,
+    original_filename: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Convert PDF tables to Excel."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, f"{task_id}.xlsx")
+
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Extracting tables from PDF..."})
+
+        stats = pdf_to_excel(input_path, output_path)
+
+        self.update_state(state="PROCESSING", meta={"step": "Uploading result..."})
+        s3_key = storage.upload_file(output_path, task_id, folder="outputs")
+
+        name_without_ext = os.path.splitext(original_filename)[0]
+        download_name = f"{name_without_ext}.xlsx"
+        download_url = storage.generate_presigned_url(s3_key, original_filename=download_name)
+
+        result = {
+            "status": "completed",
+            "download_url": download_url,
+            "filename": download_name,
+            "tables_found": stats["tables_found"],
+            "output_size": stats["output_size"],
+        }
+
+        logger.info(f"Task {task_id}: PDF to Excel completed")
+        finalize_task_tracking(
+            user_id=user_id, tool="pdf-to-excel",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except PdfToExcelError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="pdf-to-excel",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="pdf-to-excel",
+            original_filename=original_filename, result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result

backend/app/tasks/pdf_tools_tasks.py

@@ -15,6 +15,9 @@ from app.services.pdf_tools_service import (
     add_watermark,
     protect_pdf,
     unlock_pdf,
+    remove_watermark,
+    reorder_pdf_pages,
+    extract_pages,
     PDFToolsError,
 )
 from app.services.storage_service import storage
@@ -712,3 +715,172 @@ def unlock_pdf_task(
             api_key_id,
             self.request.id,
         )
+
+
+# ---------------------------------------------------------------------------
+# Remove Watermark
+# ---------------------------------------------------------------------------
+@celery.task(bind=True, name="app.tasks.pdf_tools_tasks.remove_watermark_task")
+def remove_watermark_task(
+    self, input_path: str, task_id: str, original_filename: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Async task: Remove watermark from a PDF."""
+    output_dir = _get_output_dir(task_id)
+    output_path = os.path.join(output_dir, f"{task_id}_no_watermark.pdf")
+
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Removing watermark..."})
+        stats = remove_watermark(input_path, output_path)
+
+        self.update_state(state="PROCESSING", meta={"step": "Uploading result..."})
+        s3_key = storage.upload_file(output_path, task_id, folder="outputs")
+
+        name_without_ext = os.path.splitext(original_filename)[0]
+        download_name = f"{name_without_ext}_no_watermark.pdf"
+        download_url = storage.generate_presigned_url(s3_key, original_filename=download_name)
+
+        result = {
+            "status": "completed",
+            "download_url": download_url,
+            "filename": download_name,
+            "total_pages": stats["total_pages"],
+            "output_size": stats["output_size"],
+        }
+
+        logger.info(f"Task {task_id}: Watermark removed")
+        return _finalize_task(
+            task_id, user_id, "remove-watermark", original_filename,
+            result, usage_source, api_key_id, self.request.id,
+        )
+
+    except PDFToolsError as e:
+        logger.error(f"Task {task_id}: Remove watermark error — {e}")
+        return _finalize_task(
+            task_id, user_id, "remove-watermark", original_filename,
+            {"status": "failed", "error": str(e)},
+            usage_source, api_key_id, self.request.id,
+        )
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        return _finalize_task(
+            task_id, user_id, "remove-watermark", original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source, api_key_id, self.request.id,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Reorder PDF Pages
+# ---------------------------------------------------------------------------
+@celery.task(bind=True, name="app.tasks.pdf_tools_tasks.reorder_pdf_task")
+def reorder_pdf_task(
+    self, input_path: str, task_id: str, original_filename: str,
+    page_order: list[int],
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Async task: Reorder pages in a PDF."""
+    output_dir = _get_output_dir(task_id)
+    output_path = os.path.join(output_dir, f"{task_id}_reordered.pdf")
+
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Reordering pages..."})
+        stats = reorder_pdf_pages(input_path, output_path, page_order)
+
+        self.update_state(state="PROCESSING", meta={"step": "Uploading result..."})
+        s3_key = storage.upload_file(output_path, task_id, folder="outputs")
+
+        name_without_ext = os.path.splitext(original_filename)[0]
+        download_name = f"{name_without_ext}_reordered.pdf"
+        download_url = storage.generate_presigned_url(s3_key, original_filename=download_name)
+
+        result = {
+            "status": "completed",
+            "download_url": download_url,
+            "filename": download_name,
+            "total_pages": stats["total_pages"],
+            "reordered_pages": stats["reordered_pages"],
+            "output_size": stats["output_size"],
+        }
+
+        logger.info(f"Task {task_id}: PDF pages reordered")
+        return _finalize_task(
+            task_id, user_id, "reorder-pdf", original_filename,
+            result, usage_source, api_key_id, self.request.id,
+        )
+
+    except PDFToolsError as e:
+        logger.error(f"Task {task_id}: Reorder error — {e}")
+        return _finalize_task(
+            task_id, user_id, "reorder-pdf", original_filename,
+            {"status": "failed", "error": str(e)},
+            usage_source, api_key_id, self.request.id,
+        )
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        return _finalize_task(
+            task_id, user_id, "reorder-pdf", original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source, api_key_id, self.request.id,
+        )
+
+
+# ---------------------------------------------------------------------------
+# Extract Pages (to single PDF)
+# ---------------------------------------------------------------------------
+@celery.task(bind=True, name="app.tasks.pdf_tools_tasks.extract_pages_task")
+def extract_pages_task(
+    self, input_path: str, task_id: str, original_filename: str,
+    pages: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Async task: Extract specific pages from a PDF into a new PDF."""
+    output_dir = _get_output_dir(task_id)
+    output_path = os.path.join(output_dir, f"{task_id}_extracted.pdf")
+
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Extracting pages..."})
+        stats = extract_pages(input_path, output_path, pages)
+
+        self.update_state(state="PROCESSING", meta={"step": "Uploading result..."})
+        s3_key = storage.upload_file(output_path, task_id, folder="outputs")
+
+        name_without_ext = os.path.splitext(original_filename)[0]
+        download_name = f"{name_without_ext}_extracted.pdf"
+        download_url = storage.generate_presigned_url(s3_key, original_filename=download_name)
+
+        result = {
+            "status": "completed",
+            "download_url": download_url,
+            "filename": download_name,
+            "total_pages": stats["total_pages"],
+            "extracted_pages": stats["extracted_pages"],
+            "output_size": stats["output_size"],
+        }
+
+        logger.info(f"Task {task_id}: Pages extracted")
+        return _finalize_task(
+            task_id, user_id, "extract-pages", original_filename,
+            result, usage_source, api_key_id, self.request.id,
+        )
+
+    except PDFToolsError as e:
+        logger.error(f"Task {task_id}: Extract pages error — {e}")
+        return _finalize_task(
+            task_id, user_id, "extract-pages", original_filename,
+            {"status": "failed", "error": str(e)},
+            usage_source, api_key_id, self.request.id,
+        )
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        return _finalize_task(
+            task_id, user_id, "extract-pages", original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source, api_key_id, self.request.id,
+        )

backend/app/tasks/qrcode_tasks.py

@@ -0,0 +1,88 @@
+"""Celery tasks for QR code generation."""
+import os
+import logging
+
+from flask import current_app
+
+from app.extensions import celery
+from app.services.qrcode_service import generate_qr_code, QRCodeError
+from app.services.storage_service import storage
+from app.services.task_tracking_service import finalize_task_tracking
+from app.utils.sanitizer import cleanup_task_files
+
+logger = logging.getLogger(__name__)
+
+
+def _cleanup(task_id: str):
+    cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
+
+
+@celery.task(bind=True, name="app.tasks.qrcode_tasks.generate_qr_task")
+def generate_qr_task(
+    self,
+    task_id: str,
+    data: str,
+    size: int = 300,
+    output_format: str = "png",
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """Generate a QR code image."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, f"{task_id}.{output_format}")
+
+    try:
+        self.update_state(state="PROCESSING", meta={"step": "Generating QR code..."})
+
+        stats = generate_qr_code(data, output_path, size, output_format)
+
+        self.update_state(state="PROCESSING", meta={"step": "Uploading result..."})
+        s3_key = storage.upload_file(output_path, task_id, folder="outputs")
+
+        download_name = f"qrcode.{output_format}"
+        download_url = storage.generate_presigned_url(s3_key, original_filename=download_name)
+
+        result = {
+            "status": "completed",
+            "download_url": download_url,
+            "filename": download_name,
+            "output_size": stats["output_size"],
+            "width": stats["width"],
+            "height": stats["height"],
+        }
+
+        logger.info(f"Task {task_id}: QR code generated")
+        finalize_task_tracking(
+            user_id=user_id, tool="qr-code",
+            original_filename="qrcode", result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except QRCodeError as e:
+        logger.error(f"Task {task_id}: {e}")
+        result = {"status": "failed", "error": str(e)}
+        finalize_task_tracking(
+            user_id=user_id, tool="qr-code",
+            original_filename="qrcode", result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"Task {task_id}: Unexpected error — {e}")
+        result = {"status": "failed", "error": "An unexpected error occurred."}
+        finalize_task_tracking(
+            user_id=user_id, tool="qr-code",
+            original_filename="qrcode", result=result,
+            usage_source=usage_source, api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        _cleanup(task_id)
+        return result