Release/v1.8.1

backend/apps/config_app.py

@@ -6,6 +6,7 @@
 from apps.datamate_app import router as datamate_router
 from apps.vectordatabase_app import router as vectordatabase_router
 from apps.dify_app import router as dify_router
+from apps.idata_app import router as idata_router
 from apps.file_management_app import file_management_config_router as file_manager_router
 from apps.image_app import router as proxy_router
 from apps.knowledge_summary_app import router as summary_router
@@ -39,6 +40,7 @@
 app.include_router(proxy_router)
 app.include_router(tool_config_router)
 app.include_router(dify_router)
+app.include_router(idata_router)
 
 # Choose user management router based on IS_SPEED_MODE
 if IS_SPEED_MODE:

backend/apps/data_process_app.py

@@ -11,6 +11,7 @@
     ConvertStateRequest,
     TaskRequest,
 )
+from consts.exceptions import OfficeConversionException
 from data_process.tasks import process_and_forward, process_sync
 from services.data_process_service import get_data_process_service
 
@@ -311,3 +312,35 @@ async def convert_state(request: ConvertStateRequest):
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             detail=f"Error converting state: {str(e)}"
         )
+
+
+@router.post("/convert_to_pdf")
+async def convert_office_to_pdf(
+        object_name: str = Form(...),
+        pdf_object_name: str = Form(...)
+):
+    """
+    Convert an Office document stored in MinIO to PDF.
+
+    Parameters:
+        object_name: Source Office file path in MinIO
+        pdf_object_name: Destination PDF path in MinIO
+    """
+    try:
+        await service.convert_office_to_pdf_impl(
+            object_name=object_name,
+            pdf_object_name=pdf_object_name,
+        )
+        return JSONResponse(status_code=HTTPStatus.OK, content={"success": True})
+    except OfficeConversionException as exc:
+        logger.error(f"Office conversion failed for '{object_name}': {exc}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=str(exc)
+        )
+    except Exception as exc:
+        logger.error(f"Unexpected error during conversion for '{object_name}': {exc}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Office conversion failed: {exc}"
+        )

backend/apps/file_management_app.py

@@ -9,22 +9,29 @@
 from fastapi import APIRouter, Body, File, Form, Header, HTTPException, Path as PathParam, Query, UploadFile
 from fastapi.responses import JSONResponse, RedirectResponse, StreamingResponse
 
+from consts.exceptions import FileTooLargeException, NotFoundException, OfficeConversionException, UnsupportedFileTypeException
 from consts.model import ProcessParams
 from services.file_management_service import upload_to_minio, upload_files_impl, \
-    get_file_url_impl, get_file_stream_impl, delete_file_impl, list_files_impl
+    get_file_url_impl, get_file_stream_impl, delete_file_impl, list_files_impl, \
+    preview_file_impl
 from utils.file_management_utils import trigger_data_process
 
 logger = logging.getLogger("file_management_app")
 
 
-def build_content_disposition_header(filename: Optional[str]) -> str:
+def build_content_disposition_header(filename: Optional[str], inline: bool = False) -> str:
     """
     Build a Content-Disposition header that keeps the original filename.
 
+    Args:
+        filename: Original filename to include in header
+        inline: If True, use 'inline' disposition (for preview); otherwise 'attachment' (for download)
+
     - ASCII filenames are returned directly.
     - Non-ASCII filenames include both an ASCII fallback and RFC 5987 encoded value
       so modern browsers keep the original name.
     """
+    disposition = "inline" if inline else "attachment"
     safe_name = (filename or "download").strip() or "download"
 
     def _sanitize_ascii(value: str) -> str:
@@ -40,26 +47,26 @@ def _sanitize_ascii(value: str) -> str:
 
     try:
         safe_name.encode("ascii")
-        return f'attachment; filename="{_sanitize_ascii(safe_name)}"'
+        return f'{disposition}; filename="{_sanitize_ascii(safe_name)}"'
     except UnicodeEncodeError:
         try:
             encoded = quote(safe_name, safe="")
         except Exception:
             # quote failure, fallback to sanitized ASCII only
             logger.warning("Failed to encode filename '%s', using fallback", safe_name)
-            return f'attachment; filename="{_sanitize_ascii(safe_name)}"'
+            return f'{disposition}; filename="{_sanitize_ascii(safe_name)}"'
 
         fallback = _sanitize_ascii(
             safe_name.encode("ascii", "ignore").decode("ascii") or "download"
         )
-        return f'attachment; filename="{fallback}"; filename*=UTF-8\'\'{encoded}'
+        return f'{disposition}; filename="{fallback}"; filename*=UTF-8\'\'{encoded}'
     except Exception as exc:  # pragma: no cover
         logger.warning(
             "Failed to encode filename '%s': %s. Using fallback.",
             safe_name,
             exc,
         )
-        return 'attachment; filename="download"'
+        return f'{disposition}; filename="download"'
 
 # Create API router
 file_management_runtime_router = APIRouter(prefix="/file")
@@ -567,3 +574,69 @@ async def get_storage_file_batch_urls(
         "failed_count": sum(1 for r in results if not r.get("success", False)),
         "results": results
     }
+
+@file_management_config_router.get("/preview/{object_name:path}")
+async def preview_file(
+    object_name: str = PathParam(..., description="File object name to preview"),
+    filename: Optional[str] = Query(None, description="Original filename for display (optional)")
+):
+    """
+    Preview file inline in browser 
+
+    - **object_name**: File object name in storage
+    - **filename**: Original filename for Content-Disposition header (optional)
+
+    Returns file stream with Content-Disposition: inline for browser preview
+    """
+    try:
+        # Get file stream from preview service
+        file_stream, content_type = await preview_file_impl(object_name=object_name)
+
+        # Use provided filename or extract from object_name
+        display_filename = filename
+        if not display_filename:
+            display_filename = object_name.split("/")[-1] if "/" in object_name else object_name
+
+        # Build Content-Disposition header for inline display
+        content_disposition = build_content_disposition_header(display_filename, inline=True)
+
+        return StreamingResponse(
+            file_stream,
+            media_type=content_type,
+            headers={
+                "Content-Disposition": content_disposition,
+                "Cache-Control": "public, max-age=3600",
+                "ETag": f'"{object_name}"',
+            }
+        )
+
+    except FileTooLargeException as e:
+        logger.warning(f"[preview_file] File too large: object_name={object_name}, error={str(e)}")
+        raise HTTPException(
+            status_code=HTTPStatus.REQUEST_ENTITY_TOO_LARGE,
+            detail=str(e)
+        )
+    except NotFoundException as e:
+        logger.error(f"[preview_file] File not found: object_name={object_name}, error={str(e)}")
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND,
+            detail=f"File not found: {object_name}"
+        )
+    except UnsupportedFileTypeException as e:
+        logger.error(f"[preview_file] Unsupported file type: object_name={object_name}, error={str(e)}")
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST,
+            detail=f"File format not supported for preview: {str(e)}"
+        )
+    except OfficeConversionException as e:
+        logger.error(f"[preview_file] Conversion failed: object_name={object_name}, error={str(e)}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Failed to preview file: {str(e)}"
+        )
+    except Exception as e:
+        logger.error(f"[preview_file] Unexpected error: object_name={object_name}, error={str(e)}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Failed to preview file: {str(e)}"
+        )

backend/apps/idata_app.py

@@ -0,0 +1,109 @@
+"""
+iData App Layer
+FastAPI endpoints for iData knowledge space operations.
+
+This module provides API endpoints to interact with iData's API,
+including fetching knowledge spaces and transforming responses to a format
+compatible with the frontend.
+"""
+import logging
+from http import HTTPStatus
+
+from fastapi import APIRouter, Query
+from fastapi.responses import JSONResponse
+
+from consts.error_code import ErrorCode
+from consts.exceptions import AppException
+from services.idata_service import (
+    fetch_idata_knowledge_spaces_impl,
+    fetch_idata_datasets_impl,
+)
+
+router = APIRouter(prefix="/idata")
+logger = logging.getLogger("idata_app")
+
+
+@router.get("/knowledge-space")
+async def fetch_idata_knowledge_spaces_api(
+    idata_api_base: str = Query(..., description="iData API base URL"),
+    api_key: str = Query(..., description="iData API key"),
+    user_id: str = Query(..., description="iData user ID"),
+):
+    """
+    Fetch knowledge spaces from iData API.
+
+    Returns knowledge spaces in a format with id and name for frontend compatibility.
+    """
+    try:
+        # Normalize URL by removing trailing slash
+        idata_api_base = idata_api_base.rstrip('/')
+    except Exception as e:
+        logger.error(f"Invalid iData configuration: {e}")
+        raise AppException(
+            ErrorCode.IDATA_CONFIG_INVALID,
+            f"Invalid URL format: {str(e)}"
+        )
+
+    try:
+        result = fetch_idata_knowledge_spaces_impl(
+            idata_api_base=idata_api_base,
+            api_key=api_key,
+            user_id=user_id,
+        )
+        return JSONResponse(
+            status_code=HTTPStatus.OK,
+            content=result
+        )
+    except AppException:
+        # Re-raise AppException to be handled by global middleware
+        raise
+    except Exception as e:
+        logger.error(f"Failed to fetch iData knowledge spaces: {e}")
+        raise AppException(
+            ErrorCode.IDATA_SERVICE_ERROR,
+            f"Failed to fetch iData knowledge spaces: {str(e)}"
+        )
+
+
+@router.get("/datasets")
+async def fetch_idata_datasets_api(
+    idata_api_base: str = Query(..., description="iData API base URL"),
+    api_key: str = Query(..., description="iData API key"),
+    user_id: str = Query(..., description="iData user ID"),
+    knowledge_space_id: str = Query(..., description="Knowledge space ID"),
+):
+    """
+    Fetch datasets (knowledge bases) from iData API.
+
+    Returns knowledge bases in a format consistent with DataMate for frontend compatibility.
+    """
+    try:
+        # Normalize URL by removing trailing slash
+        idata_api_base = idata_api_base.rstrip('/')
+    except Exception as e:
+        logger.error(f"Invalid iData configuration: {e}")
+        raise AppException(
+            ErrorCode.IDATA_CONFIG_INVALID,
+            f"Invalid URL format: {str(e)}"
+        )
+
+    try:
+        result = fetch_idata_datasets_impl(
+            idata_api_base=idata_api_base,
+            api_key=api_key,
+            user_id=user_id,
+            knowledge_space_id=knowledge_space_id,
+        )
+        return JSONResponse(
+            status_code=HTTPStatus.OK,
+            content=result
+        )
+    except AppException:
+        # Re-raise AppException to be handled by global middleware
+        raise
+    except Exception as e:
+        logger.error(f"Failed to fetch iData datasets: {e}")
+        raise AppException(
+            ErrorCode.IDATA_SERVICE_ERROR,
+            f"Failed to fetch iData datasets: {str(e)}"
+        )