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

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

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

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

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

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

backend/app/tasks/compress_tasks.py

@@ -2,15 +2,48 @@
 import os
 import logging
 
+from flask import current_app
+
 from app.extensions import celery
 from app.services.compress_service import compress_pdf, PDFCompressionError
 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
 
 
 def _cleanup(task_id: str):
     cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
 
+
+def _get_output_dir(task_id: str) -> str:
+    """Resolve output directory from app config."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def _finalize_task(
+    task_id: str,
+    user_id: int | None,
+    original_filename: str,
+    result: dict,
+    usage_source: str,
+    api_key_id: int | None,
+    celery_task_id: str | None,
+):
+    """Persist optional history and cleanup task files."""
+    finalize_task_tracking(
+        user_id=user_id,
+        tool="compress-pdf",
+        original_filename=original_filename,
+        result=result,
+        usage_source=usage_source,
+        api_key_id=api_key_id,
+        celery_task_id=celery_task_id,
+    )
+    _cleanup(task_id)
+    return result
+
 logger = logging.getLogger(__name__)
 
 
@@ -21,6 +54,9 @@ def compress_pdf_task(
     task_id: str,
     original_filename: str,
     quality: str = "medium",
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """
     Async task: Compress a PDF file.
@@ -34,8 +70,7 @@ def compress_pdf_task(
     Returns:
         dict with download_url, compression stats, and file info
     """
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}.pdf")
 
     try:
@@ -69,20 +104,40 @@ def compress_pdf_task(
             "reduction_percent": stats["reduction_percent"],
         }
 
-        _cleanup(task_id)
-
         logger.info(
             f"Task {task_id}: PDF compression completed — "
             f"{stats['reduction_percent']}% reduction"
         )
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFCompressionError as e:
         logger.error(f"Task {task_id}: Compression error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )

backend/app/tasks/convert_tasks.py

@@ -2,9 +2,12 @@
 import os
 import logging
 
+from flask import current_app
+
 from app.extensions import celery
 from app.services.pdf_service import pdf_to_word, word_to_pdf, PDFConversionError
 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
 
 
@@ -12,11 +15,50 @@ def _cleanup(task_id: str):
     """Cleanup with local-aware flag."""
     cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
 
+
+def _get_output_dir(task_id: str) -> str:
+    """Resolve output directory from app config."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def _finalize_task(
+    task_id: str,
+    user_id: int | None,
+    tool: str,
+    original_filename: str,
+    result: dict,
+    usage_source: str,
+    api_key_id: int | None,
+    celery_task_id: str | None,
+):
+    """Persist optional history and cleanup task files."""
+    finalize_task_tracking(
+        user_id=user_id,
+        tool=tool,
+        original_filename=original_filename,
+        result=result,
+        usage_source=usage_source,
+        api_key_id=api_key_id,
+        celery_task_id=celery_task_id,
+    )
+    _cleanup(task_id)
+    return result
+
 logger = logging.getLogger(__name__)
 
 
 @celery.task(bind=True, name="app.tasks.convert_tasks.convert_pdf_to_word")
-def convert_pdf_to_word(self, input_path: str, task_id: str, original_filename: str):
+def convert_pdf_to_word(
+    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: Convert PDF to Word document.
 
@@ -28,7 +70,7 @@ def convert_pdf_to_word(self, input_path: str, task_id: str, original_filename:
     Returns:
         dict with download_url and file info
     """
-    output_dir = os.path.join("/tmp/outputs", task_id)
+    output_dir = _get_output_dir(task_id)
 
     try:
         self.update_state(state="PROCESSING", meta={"step": "Converting PDF to Word..."})
@@ -58,24 +100,55 @@ def convert_pdf_to_word(self, input_path: str, task_id: str, original_filename:
         }
 
         # Cleanup local files
-        _cleanup(task_id)
-
         logger.info(f"Task {task_id}: PDF→Word conversion completed")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-to-word",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFConversionError as e:
         logger.error(f"Task {task_id}: Conversion error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-to-word",
+            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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-to-word",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 @celery.task(bind=True, name="app.tasks.convert_tasks.convert_word_to_pdf")
-def convert_word_to_pdf(self, input_path: str, task_id: str, original_filename: str):
+def convert_word_to_pdf(
+    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: Convert Word document to PDF.
 
@@ -87,7 +160,7 @@ def convert_word_to_pdf(self, input_path: str, task_id: str, original_filename:
     Returns:
         dict with download_url and file info
     """
-    output_dir = os.path.join("/tmp/outputs", task_id)
+    output_dir = _get_output_dir(task_id)
 
     try:
         self.update_state(state="PROCESSING", meta={"step": "Converting Word to PDF..."})
@@ -112,17 +185,40 @@ def convert_word_to_pdf(self, input_path: str, task_id: str, original_filename:
             "output_size": os.path.getsize(output_path),
         }
 
-        _cleanup(task_id)
-
         logger.info(f"Task {task_id}: Word→PDF conversion completed")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "word-to-pdf",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFConversionError as e:
         logger.error(f"Task {task_id}: Conversion error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "word-to-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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "word-to-pdf",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )

backend/app/tasks/flowchart_tasks.py

@@ -3,9 +3,12 @@ import os
 import json
 import logging
 
+from flask import current_app
+
 from app.extensions import celery
 from app.services.flowchart_service import extract_and_generate, FlowchartError
 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__)
@@ -15,17 +18,132 @@ def _cleanup(task_id: str):
     cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
 
 
+def _get_output_dir(task_id: str) -> str:
+    """Resolve output directory from app config."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def _finalize_task(
+    task_id: str,
+    user_id: int | None,
+    tool: str,
+    original_filename: str | None,
+    result: dict,
+    usage_source: str,
+    api_key_id: int | None,
+    celery_task_id: str | None,
+):
+    """Persist optional history and cleanup task files."""
+    finalize_task_tracking(
+        user_id=user_id,
+        tool=tool,
+        original_filename=original_filename,
+        result=result,
+        usage_source=usage_source,
+        api_key_id=api_key_id,
+        celery_task_id=celery_task_id,
+    )
+    _cleanup(task_id)
+    return result
+
+
+def _build_sample_result() -> dict:
+    """Return deterministic sample flowchart data for demo mode."""
+    pages = [
+        {
+            "page": 1,
+            "text": (
+                "Employee Onboarding Procedure\n"
+                "1. Create employee profile in HR system.\n"
+                "2. Verify documents and eligibility.\n"
+                "3. Assign department and manager.\n"
+                "4. Send welcome package and access credentials.\n"
+                "5. Confirm first-day orientation schedule."
+            ),
+        }
+    ]
+
+    procedures = [
+        {
+            "id": "sample-proc-1",
+            "title": "Employee Onboarding Procedure",
+            "description": "Create profile, verify docs, assign team, and confirm orientation.",
+            "pages": [1],
+            "step_count": 5,
+        }
+    ]
+
+    flowcharts = [
+        {
+            "id": "flow-sample-proc-1",
+            "procedureId": "sample-proc-1",
+            "title": "Employee Onboarding Procedure",
+            "steps": [
+                {
+                    "id": "1",
+                    "type": "start",
+                    "title": "Begin: Employee Onboarding",
+                    "description": "Start of onboarding process",
+                    "connections": ["2"],
+                },
+                {
+                    "id": "2",
+                    "type": "process",
+                    "title": "Create Employee Profile",
+                    "description": "Register employee in HR system",
+                    "connections": ["3"],
+                },
+                {
+                    "id": "3",
+                    "type": "decision",
+                    "title": "Documents Verified?",
+                    "description": "Check eligibility and required documents",
+                    "connections": ["4"],
+                },
+                {
+                    "id": "4",
+                    "type": "process",
+                    "title": "Assign Team and Access",
+                    "description": "Assign manager, department, and credentials",
+                    "connections": ["5"],
+                },
+                {
+                    "id": "5",
+                    "type": "end",
+                    "title": "Onboarding Complete",
+                    "description": "Employee is ready for orientation",
+                    "connections": [],
+                },
+            ],
+        }
+    ]
+
+    return {
+        "procedures": procedures,
+        "flowcharts": flowcharts,
+        "pages": pages,
+        "total_pages": len(pages),
+    }
+
+
 @celery.task(bind=True, name="app.tasks.flowchart_tasks.extract_flowchart_task")
 def extract_flowchart_task(
-    self, input_path: str, task_id: str, original_filename: str
+    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: Extract procedures from PDF and generate flowcharts.
 
     Returns a JSON result containing procedures and their flowcharts.
     """
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
 
     try:
         self.update_state(
@@ -61,19 +179,87 @@ def extract_flowchart_task(
             "procedures_count": len(result["procedures"]),
         }
 
-        _cleanup(task_id)
         logger.info(
             f"Task {task_id}: Flowchart extraction completed — "
             f"{len(result['procedures'])} procedures, "
             f"{result['total_pages']} pages"
         )
-        return final_result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-flowchart",
+            original_filename,
+            final_result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except FlowchartError as e:
         logger.error(f"Task {task_id}: Flowchart error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-flowchart",
+            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}")
-        _cleanup(task_id)
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-flowchart",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
+
+
+@celery.task(bind=True, name="app.tasks.flowchart_tasks.extract_sample_flowchart_task")
+def extract_sample_flowchart_task(
+    self,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
+):
+    """
+    Async task: Build a sample flowchart payload without requiring file upload.
+    """
+    try:
+        self.update_state(
+            state="PROCESSING",
+            meta={"step": "Preparing sample flowchart..."},
+        )
+
+        result = _build_sample_result()
+        final_result = {
+            "status": "completed",
+            "filename": "sample_flowcharts.json",
+            "procedures": result["procedures"],
+            "flowcharts": result["flowcharts"],
+            "pages": result["pages"],
+            "total_pages": result["total_pages"],
+            "procedures_count": len(result["procedures"]),
+        }
+
+        finalize_task_tracking(
+            user_id=user_id,
+            tool="pdf-flowchart-sample",
+            original_filename="sample-document.pdf",
+            result=final_result,
+            usage_source=usage_source,
+            api_key_id=api_key_id,
+            celery_task_id=self.request.id,
+        )
+        logger.info("Sample flowchart task completed")
+        return final_result
+
+    except Exception as e:
+        logger.error(f"Sample flowchart task failed — {e}")
         return {"status": "failed", "error": "An unexpected error occurred."}

backend/app/tasks/image_tasks.py

@@ -2,15 +2,49 @@
 import os
 import logging
 
+from flask import current_app
+
 from app.extensions import celery
 from app.services.image_service import convert_image, resize_image, ImageProcessingError
 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
 
 
 def _cleanup(task_id: str):
     cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
 
+
+def _get_output_dir(task_id: str) -> str:
+    """Resolve output directory from app config."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def _finalize_task(
+    task_id: str,
+    user_id: int | None,
+    tool: str,
+    original_filename: str,
+    result: dict,
+    usage_source: str,
+    api_key_id: int | None,
+    celery_task_id: str | None,
+):
+    """Persist optional history and cleanup task files."""
+    finalize_task_tracking(
+        user_id=user_id,
+        tool=tool,
+        original_filename=original_filename,
+        result=result,
+        usage_source=usage_source,
+        api_key_id=api_key_id,
+        celery_task_id=celery_task_id,
+    )
+    _cleanup(task_id)
+    return result
+
 logger = logging.getLogger(__name__)
 
 
@@ -22,6 +56,9 @@ def convert_image_task(
     original_filename: str,
     output_format: str,
     quality: int = 85,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """
     Async task: Convert an image to a different format.
@@ -36,8 +73,7 @@ def convert_image_task(
     Returns:
         dict with download_url and conversion stats
     """
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}.{output_format}")
 
     try:
@@ -70,20 +106,43 @@ def convert_image_task(
             "format": stats["format"],
         }
 
-        _cleanup(task_id)
-
         logger.info(f"Task {task_id}: Image conversion to {output_format} completed")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "image-convert",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except ImageProcessingError as e:
         logger.error(f"Task {task_id}: Image error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "image-convert",
+            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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "image-convert",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 @celery.task(bind=True, name="app.tasks.image_tasks.resize_image_task")
@@ -95,6 +154,9 @@ def resize_image_task(
     width: int | None = None,
     height: int | None = None,
     quality: int = 85,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """
     Async task: Resize an image.
@@ -111,8 +173,7 @@ def resize_image_task(
         dict with download_url and resize info
     """
     ext = os.path.splitext(original_filename)[1].lstrip(".")
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}.{ext}")
 
     try:
@@ -144,17 +205,40 @@ def resize_image_task(
             "new_height": stats["new_height"],
         }
 
-        _cleanup(task_id)
-
         logger.info(f"Task {task_id}: Image resize completed")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "image-resize",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except ImageProcessingError as e:
         logger.error(f"Task {task_id}: Image error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "image-resize",
+            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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "image-resize",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )

backend/app/tasks/pdf_tools_tasks.py

@@ -2,6 +2,8 @@
 import os
 import logging
 
+from flask import current_app
+
 from app.extensions import celery
 from app.services.pdf_tools_service import (
     merge_pdfs,
@@ -16,6 +18,7 @@ from app.services.pdf_tools_service import (
     PDFToolsError,
 )
 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
 
 
@@ -23,6 +26,37 @@ def _cleanup(task_id: str):
     cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
 
 
+def _get_output_dir(task_id: str) -> str:
+    """Resolve output directory from app config."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def _finalize_task(
+    task_id: str,
+    user_id: int | None,
+    tool: str,
+    original_filename: str,
+    result: dict,
+    usage_source: str,
+    api_key_id: int | None,
+    celery_task_id: str | None,
+):
+    """Persist optional history and cleanup task files."""
+    finalize_task_tracking(
+        user_id=user_id,
+        tool=tool,
+        original_filename=original_filename,
+        result=result,
+        usage_source=usage_source,
+        api_key_id=api_key_id,
+        celery_task_id=celery_task_id,
+    )
+    _cleanup(task_id)
+    return result
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -31,11 +65,16 @@ logger = logging.getLogger(__name__)
 # ---------------------------------------------------------------------------
 @celery.task(bind=True, name="app.tasks.pdf_tools_tasks.merge_pdfs_task")
 def merge_pdfs_task(
-    self, input_paths: list[str], task_id: str, original_filenames: list[str]
+    self,
+    input_paths: list[str],
+    task_id: str,
+    original_filenames: list[str],
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Merge multiple PDFs into one."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}_merged.pdf")
 
     try:
@@ -56,18 +95,42 @@ def merge_pdfs_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: Merge completed — {stats['files_merged']} files, {stats['total_pages']} pages")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "merge-pdf",
+            ", ".join(original_filenames),
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Merge error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "merge-pdf",
+            ", ".join(original_filenames),
+            {"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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "merge-pdf",
+            ", ".join(original_filenames),
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -77,9 +140,12 @@ def merge_pdfs_task(
 def split_pdf_task(
     self, input_path: str, task_id: str, original_filename: str,
     mode: str = "all", pages: str | None = None,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Split a PDF into individual pages."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
+    output_dir = _get_output_dir(task_id)
 
     try:
         self.update_state(state="PROCESSING", meta={"step": "Splitting PDF..."})
@@ -102,18 +168,42 @@ def split_pdf_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: Split completed — {stats['extracted_pages']} pages extracted")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "split-pdf",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Split error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "split-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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "split-pdf",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -123,10 +213,12 @@ def split_pdf_task(
 def rotate_pdf_task(
     self, input_path: str, task_id: str, original_filename: str,
     rotation: int = 90, pages: str = "all",
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Rotate pages in a PDF."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}_rotated.pdf")
 
     try:
@@ -150,18 +242,42 @@ def rotate_pdf_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: Rotate completed — {stats['rotated_pages']} pages")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "rotate-pdf",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Rotate error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "rotate-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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "rotate-pdf",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -171,10 +287,12 @@ def rotate_pdf_task(
 def add_page_numbers_task(
     self, input_path: str, task_id: str, original_filename: str,
     position: str = "bottom-center", start_number: int = 1,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Add page numbers to a PDF."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}_numbered.pdf")
 
     try:
@@ -196,18 +314,42 @@ def add_page_numbers_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: Page numbers added to {stats['total_pages']} pages")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "page-numbers",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Page numbers error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "page-numbers",
+            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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "page-numbers",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -217,9 +359,12 @@ def add_page_numbers_task(
 def pdf_to_images_task(
     self, input_path: str, task_id: str, original_filename: str,
     output_format: str = "png", dpi: int = 200,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Convert PDF pages to images."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
+    output_dir = _get_output_dir(task_id)
 
     try:
         self.update_state(state="PROCESSING", meta={"step": "Converting PDF to images..."})
@@ -243,18 +388,42 @@ def pdf_to_images_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: PDF→Images completed — {stats['page_count']} pages")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-to-images",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: PDF→Images error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-to-images",
+            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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "pdf-to-images",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -262,11 +431,16 @@ def pdf_to_images_task(
 # ---------------------------------------------------------------------------
 @celery.task(bind=True, name="app.tasks.pdf_tools_tasks.images_to_pdf_task")
 def images_to_pdf_task(
-    self, input_paths: list[str], task_id: str, original_filenames: list[str]
+    self,
+    input_paths: list[str],
+    task_id: str,
+    original_filenames: list[str],
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Combine images into a PDF."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}_images.pdf")
 
     try:
@@ -286,18 +460,42 @@ def images_to_pdf_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: Images→PDF completed — {stats['page_count']} pages")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "images-to-pdf",
+            ", ".join(original_filenames),
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Images→PDF error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "images-to-pdf",
+            ", ".join(original_filenames),
+            {"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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "images-to-pdf",
+            ", ".join(original_filenames),
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -307,10 +505,12 @@ def images_to_pdf_task(
 def watermark_pdf_task(
     self, input_path: str, task_id: str, original_filename: str,
     watermark_text: str, opacity: float = 0.3,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Add watermark to a PDF."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}_watermarked.pdf")
 
     try:
@@ -332,18 +532,42 @@ def watermark_pdf_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: Watermark added")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "watermark-pdf",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Watermark error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "watermark-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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "watermark-pdf",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -353,10 +577,12 @@ def watermark_pdf_task(
 def protect_pdf_task(
     self, input_path: str, task_id: str, original_filename: str,
     password: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Add password protection to a PDF."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}_protected.pdf")
 
     try:
@@ -378,18 +604,42 @@ def protect_pdf_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: PDF protected")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "protect-pdf",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Protect error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "protect-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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "protect-pdf",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -399,10 +649,12 @@ def protect_pdf_task(
 def unlock_pdf_task(
     self, input_path: str, task_id: str, original_filename: str,
     password: str,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """Async task: Remove password from a PDF."""
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}_unlocked.pdf")
 
     try:
@@ -424,15 +676,39 @@ def unlock_pdf_task(
             "output_size": stats["output_size"],
         }
 
-        _cleanup(task_id)
         logger.info(f"Task {task_id}: PDF unlocked")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            "unlock-pdf",
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except PDFToolsError as e:
         logger.error(f"Task {task_id}: Unlock error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "unlock-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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            "unlock-pdf",
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )

backend/app/tasks/video_tasks.py

@@ -2,15 +2,48 @@
 import os
 import logging
 
+from flask import current_app
+
 from app.extensions import celery
 from app.services.video_service import video_to_gif, VideoProcessingError
 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
 
 
 def _cleanup(task_id: str):
     cleanup_task_files(task_id, keep_outputs=not storage.use_s3)
 
+
+def _get_output_dir(task_id: str) -> str:
+    """Resolve output directory from app config."""
+    output_dir = os.path.join(current_app.config["OUTPUT_FOLDER"], task_id)
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def _finalize_task(
+    task_id: str,
+    user_id: int | None,
+    original_filename: str,
+    result: dict,
+    usage_source: str,
+    api_key_id: int | None,
+    celery_task_id: str | None,
+):
+    """Persist optional history and cleanup task files."""
+    finalize_task_tracking(
+        user_id=user_id,
+        tool="video-to-gif",
+        original_filename=original_filename,
+        result=result,
+        usage_source=usage_source,
+        api_key_id=api_key_id,
+        celery_task_id=celery_task_id,
+    )
+    _cleanup(task_id)
+    return result
+
 logger = logging.getLogger(__name__)
 
 
@@ -24,6 +57,9 @@ def create_gif_task(
     duration: float = 5,
     fps: int = 10,
     width: int = 480,
+    user_id: int | None = None,
+    usage_source: str = "web",
+    api_key_id: int | None = None,
 ):
     """
     Async task: Convert video clip to animated GIF.
@@ -40,8 +76,7 @@ def create_gif_task(
     Returns:
         dict with download_url and GIF info
     """
-    output_dir = os.path.join("/tmp/outputs", task_id)
-    os.makedirs(output_dir, exist_ok=True)
+    output_dir = _get_output_dir(task_id)
     output_path = os.path.join(output_dir, f"{task_id}.gif")
 
     try:
@@ -80,17 +115,37 @@ def create_gif_task(
             "height": stats["height"],
         }
 
-        _cleanup(task_id)
-
         logger.info(f"Task {task_id}: Video→GIF creation completed")
-        return result
+        return _finalize_task(
+            task_id,
+            user_id,
+            original_filename,
+            result,
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )
 
     except VideoProcessingError as e:
         logger.error(f"Task {task_id}: Video error — {e}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": str(e)}
+        return _finalize_task(
+            task_id,
+            user_id,
+            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}")
-        _cleanup(task_id)
-        return {"status": "failed", "error": "An unexpected error occurred."}
+        return _finalize_task(
+            task_id,
+            user_id,
+            original_filename,
+            {"status": "failed", "error": "An unexpected error occurred."},
+            usage_source,
+            api_key_id,
+            self.request.id,
+        )