159 lines
4.5 KiB
Python
159 lines
4.5 KiB
Python
"""
|
|
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
|