[add] i18n support zh,en

api/app/i18n/dependencies.py

@@ -0,0 +1,158 @@
+"""
+FastAPI dependency injection functions for i18n.
+
+This module provides dependency injection functions that can be used
+in FastAPI route handlers to access the current language and translator.
+"""
+
+import logging
+from typing import Callable
+
+from fastapi import Request
+
+from app.i18n.service import get_translation_service
+
+logger = logging.getLogger(__name__)
+
+
+async def get_current_language(request: Request) -> str:
+    """
+    Get the current language from the request context.
+
+    This dependency extracts the language that was determined by the
+    LanguageMiddleware and stored in request.state.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        Language code (e.g., "zh", "en")
+
+    Usage:
+        @router.get("/example")
+        async def example(language: str = Depends(get_current_language)):
+            return {"language": language}
+    """
+    # Get language from request state (set by LanguageMiddleware)
+    language = getattr(request.state, "language", None)
+
+    if language is None:
+        # Fallback to default language if not set
+        from app.core.config import settings
+        language = settings.I18N_DEFAULT_LANGUAGE
+        logger.warning(
+            "Language not found in request.state, using default: "
+            f"{language}"
+        )
+
+    return language
+
+
+async def get_translator(request: Request) -> Callable:
+    """
+    Get a translator function bound to the current request's language.
+
+    This dependency returns a translation function that automatically
+    uses the current request's language, making it easy to translate
+    strings in route handlers.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        Translation function with signature: t(key: str, **params) -> str
+
+    Usage:
+        @router.post("/workspaces")
+        async def create_workspace(
+            data: WorkspaceCreate,
+            t: Callable = Depends(get_translator)
+        ):
+            workspace = await workspace_service.create(data)
+            return {
+                "success": True,
+                "message": t("workspace.created_successfully"),
+                "data": workspace
+            }
+
+        # With parameters
+        @router.get("/items")
+        async def get_items(t: Callable = Depends(get_translator)):
+            count = 5
+            return {
+                "message": t("items.found", count=count)
+            }
+    """
+    # Get current language
+    language = await get_current_language(request)
+
+    # Get translation service
+    service = get_translation_service()
+
+    # Return a bound translation function
+    def translate(key: str, **params) -> str:
+        """
+        Translate a key using the current request's language.
+
+        Args:
+            key: Translation key (e.g., "common.success.created")
+            **params: Parameters for parameterized messages
+
+        Returns:
+            Translated string
+        """
+        return service.translate(key, language, **params)
+
+    return translate
+
+
+async def get_enum_translator(request: Request) -> Callable:
+    """
+    Get an enum translator function bound to the current request's language.
+
+    This dependency returns a function for translating enum values
+    that automatically uses the current request's language.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        Enum translation function with signature:
+        t_enum(enum_type: str, value: str) -> str
+
+    Usage:
+        @router.get("/workspace/{id}")
+        async def get_workspace(
+            id: str,
+            t_enum: Callable = Depends(get_enum_translator)
+        ):
+            workspace = await workspace_service.get(id)
+            return {
+                "id": workspace.id,
+                "role": workspace.role,
+                "role_display": t_enum("workspace_role", workspace.role),
+                "status": workspace.status,
+                "status_display": t_enum("workspace_status", workspace.status)
+            }
+    """
+    # Get current language
+    language = await get_current_language(request)
+
+    # Get translation service
+    service = get_translation_service()
+
+    # Return a bound enum translation function
+    def translate_enum(enum_type: str, value: str) -> str:
+        """
+        Translate an enum value using the current request's language.
+
+        Args:
+            enum_type: Enum type name (e.g., "workspace_role")
+            value: Enum value (e.g., "manager")
+
+        Returns:
+            Translated enum display name
+        """
+        return service.translate_enum(enum_type, value, language)
+
+    return translate_enum