holger/Django-Translatable-Fields
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' of https://repo.backender.de/holger/Django-Translatable-Fields

Browse Source
This commit is contained in:
Holger Sielaff
2026-02-04 16:49:47 +01:00
parent 6aa74c5e6c c2dc9215c2
commit 31a3c6e29a
2 changed files with 159 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
django_translatable_fields/fields.py
+6 -5
View File
@@ -74,11 +74,12 @@ class TranslatableMixin:
if not self.translatable:
return value
# Check if we're in admin context by looking at the call stack
# Check if we're in admin or API context by looking at the call stack
frames = inspect.getouterframes(inspect.currentframe())
is_admin_context = os.environ.get('DJANGO_ADMIN_OVERRIDE', False) == '1' or any('admin' in frame.filename or 'forms' in frame.filename for frame in frames[:5])
is_api_context = any('serializers' in frame.filename or 'rest_framework' in frame.filename or '/api/' in frame.filename for frame in frames[:10])
logging.debug(f"{self.__class__.__name__} from_db_value - admin context: {is_admin_context}")
logging.debug(f"{self.__class__.__name__} from_db_value - admin context: {is_admin_context}, api context: {is_api_context}")
try:
translations = json.loads(value) if isinstance(value, str) else value
@@ -87,10 +88,10 @@ class TranslatableMixin:
logging.debug(f"{self.__class__.__name__} from_db_value - parsed translations: {translations}")
# For admin/forms, return the full dict so widgets can access all translations
if is_admin_context:
# For admin/forms/API, return the full dict so serializers/widgets can access all translations
if is_admin_context or is_api_context:
logging.debug(
f"{self.__class__.__name__} from_db_value - returning full dict for admin: {translations}")
f"{self.__class__.__name__} from_db_value - returning full dict for admin/api: {translations}")
return translations
# For regular use, return the appropriate language
django_translatable_fields/serializers.py
+153 -61
View File
@@ -20,18 +20,31 @@ Usage:
fields = ['id', 'name', 'description', 'price']
# API Usage:
# GET /api/products/?language=de -> Returns German translations
# GET /api/products/?lang=de -> Returns German translations as strings
# GET /api/products/ -> Returns all translations as dicts
# POST /api/products/ with {"name": "Test", "language": "de"} -> Saves to German
# POST /api/products/ with {"name": "Test", "lang": "de"} -> Saves to German
Author: Holger Sielaff <holger@backender.de>
Version: 0.1.0
"""
import json
import logging
from rest_framework import serializers
from django.utils.translation import get_language
# Optional drf-spectacular support for OpenAPI schema generation
try:
from drf_spectacular.utils import extend_schema_field
HAS_SPECTACULAR = True
except ImportError:
HAS_SPECTACULAR = False
# Dummy decorator if drf-spectacular is not installed
def extend_schema_field(schema):
def decorator(cls):
return cls
return decorator
class TranslatableSerializerMixin:
"""
@@ -42,48 +55,59 @@ class TranslatableSerializerMixin:
writing translatable content via API endpoints.
Features:
- Language parameter detection (?language=de)
- Language parameter detection (?lang=de or ?language=de for backward compatibility)
- Automatic field conversion for translatable fields
- Support for both single-language and multi-language responses
- Proper handling of JSON storage format
Usage:
class MySerializer(TranslatableSerializerMixin, serializers.ModelSerializer):
class Meta:
model = MyModel
fields = ['name', 'description'] # name and description are translatable
# API calls:
# GET /api/items/?language=de -> returns German values
# GET /api/items/?lang=de -> returns German values as strings
# GET /api/items/ -> returns full translation dicts
# POST /api/items/ with language param -> saves to specific language
# POST /api/items/ with {"name": "Test", "lang": "de"} -> saves to specific language
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._setup_translatable_fields()
def _setup_translatable_fields(self):
"""Identify and setup translatable fields in the serializer"""
self._translatable_fields = []
if hasattr(self, 'Meta') and hasattr(self.Meta, 'model'):
# Method 1: Check Meta.translatable_fields (explicit definition)
if hasattr(self, 'Meta') and hasattr(self.Meta, 'translatable_fields'):
self._translatable_fields = list(self.Meta.translatable_fields)
# Method 2: Auto-detect from model fields with translatable=True
elif hasattr(self, 'Meta') and hasattr(self.Meta, 'model'):
model = self.Meta.model
for field_name in self.fields:
if hasattr(model, field_name):
model_field = model._meta.get_field(field_name)
if hasattr(model_field, 'translatable') and model_field.translatable:
self._translatable_fields.append(field_name)
# Replace translatable fields with TranslatableField for proper schema generation
for field_name in self._translatable_fields:
if field_name in self.fields:
self.fields[field_name] = TranslatableField()
def _get_request_language(self):
"""Get the language parameter from the request context"""
if hasattr(self, 'context') and 'request' in self.context:
request = self.context['request']
# Check for language parameter in query params or data
language = request.query_params.get('language')
if not language and hasattr(request, 'data'):
language = request.data.get('language')
return language
# Check for lang parameter in query params or data
# Also support 'language' for backward compatibility
lang = request.query_params.get('lang') or request.query_params.get('language')
if not lang and hasattr(request, 'data'):
lang = request.data.get('lang') or request.data.get('language')
return lang
return None
def to_representation(self, instance):
@@ -138,53 +162,93 @@ class TranslatableSerializerMixin:
data[field_name] = field_value
return data
def to_internal_value(self, data):
def update(self, instance, validated_data):
"""
Convert API input data to internal representation.
Logic:
- With language parameter: converts single values to {language: value}
- Without language parameter:
* If value is dict -> use dict as-is
* If value is not dict -> convert to {'en': value}
Override update to merge translatable fields for PATCH requests.
For PATCH: merge new translations with existing ones
For PUT: replace completely (default behavior)
"""
request_language = self._get_request_language()
# Process translatable fields in input data
for field_name in self._translatable_fields:
if field_name in data:
field_value = data[field_name]
if request_language:
# Convert single value to translation dict for specific language
if not isinstance(field_value, dict):
data[field_name] = {request_language: str(field_value)}
# If it's already a dict, use it as-is
else:
# No language specified:
# - If dict: use as-is (full translations)
# - If not dict: assume English
if not isinstance(field_value, dict):
data[field_name] = {'en': str(field_value)}
# If it's already a dict, leave it unchanged
return super().to_internal_value(data)
logger = logging.getLogger(__name__)
request_method = None
if hasattr(self, 'context') and 'request' in self.context:
request_method = self.context['request'].method
logger.info(f"UPDATE METHOD CALLED - Version 2.0 - Method: {request_method}")
# For PATCH: merge translatable fields
if request_method == 'PATCH':
for field_name in self._translatable_fields:
if field_name in validated_data:
new_value = validated_data[field_name]
# Get existing value (model field returns dict in API context)
existing_value = getattr(instance, field_name, None)
# Parse existing value
existing_translations = {}
if existing_value:
if isinstance(existing_value, str):
try:
existing_translations = json.loads(existing_value)
if not isinstance(existing_translations, dict):
existing_translations = {}
except (json.JSONDecodeError, TypeError):
existing_translations = {}
elif isinstance(existing_value, dict):
existing_translations = existing_value
# Parse new value
new_translations = {}
if new_value:
if isinstance(new_value, str):
try:
new_translations = json.loads(new_value)
if not isinstance(new_translations, dict):
new_translations = {}
except (json.JSONDecodeError, TypeError):
new_translations = {}
elif isinstance(new_value, dict):
new_translations = new_value
# Merge: existing + new (new overwrites)
if existing_translations or new_translations:
merged = existing_translations.copy()
merged.update(new_translations)
validated_data[field_name] = merged
return super().update(instance, validated_data)
@extend_schema_field({
'type': 'object',
'properties': {
'en': {'type': 'string', 'description': 'English translation'},
'de': {'type': 'string', 'description': 'German translation'},
'fr': {'type': 'string', 'description': 'French translation'},
},
'example': {
'en': 'Example text',
'de': 'Beispieltext',
'fr': 'Texte d\'exemple'
},
'description': 'Translatable field: accepts string (sets default language), dict with language codes, or JSON string'
})
class TranslatableField(serializers.Field):
"""
Custom DRF field for handling translatable content.
This field can be used when you need more control over how translatable
fields are handled in your serializer, or when you want to use it
independently of the TranslatableSerializerMixin.
Usage:
class ProductSerializer(serializers.ModelSerializer):
name = TranslatableField()
description = TranslatableField()
class Meta:
model = Product
fields = ['id', 'name', 'description', 'price']
@@ -196,10 +260,17 @@ class TranslatableField(serializers.Field):
def to_representation(self, value):
"""Convert database value to API representation"""
# Get lang parameter from request if not set explicitly on field
request_language = self.language
if not request_language and hasattr(self, 'parent') and self.parent:
if hasattr(self.parent, 'context') and 'request' in self.parent.context:
request = self.parent.context['request']
request_language = request.query_params.get('lang') or request.query_params.get('language')
if not value:
return '' if self.language else {}
# Handle JSON string from database
return '' if request_language else {}
# Value is already a dict in API context (from model field's from_db_value)
if isinstance(value, str):
try:
translations = json.loads(value)
@@ -209,11 +280,11 @@ class TranslatableField(serializers.Field):
translations = value
else:
translations = {'en': str(value)}
# Return specific language or full dict
if self.language:
if self.language in translations:
return translations[self.language]
if request_language:
if request_language in translations:
return translations[request_language]
elif 'en' in translations:
return translations['en']
elif translations:
@@ -224,15 +295,36 @@ class TranslatableField(serializers.Field):
return translations
def to_internal_value(self, data):
"""Convert API input to internal representation"""
if self.language:
# Convert single value to translation dict
"""
Convert API input to internal representation.
- Handles lang parameter for single-value inputs
- Converts to dict format
- Merging for PATCH is handled by TranslatableSerializerMixin.update()
"""
# Get request context from parent serializer
request_language = None
if hasattr(self, 'parent') and self.parent:
# Get lang parameter from request
if hasattr(self.parent, 'context') and 'request' in self.parent.context:
request = self.parent.context['request']
request_language = request.query_params.get('lang') or request.query_params.get('language')
if not request_language and hasattr(request, 'data'):
request_language = request.data.get('lang') or request.data.get('language')
# Use self.language if set explicitly on the field
language = self.language or request_language
# Convert input to translation dict
if language:
# Language specified: convert single value to translation dict
if isinstance(data, dict):
return data
else:
return {self.language: str(data)}
return {language: str(data)}
else:
# Expect full translation dict
# No language: expect full translation dict or assume English
if isinstance(data, dict):
return data
else:
@@ -261,4 +353,4 @@ class TranslatableURLField(TranslatableField, serializers.URLField):
class TranslatableSlugField(TranslatableField, serializers.SlugField):
"""Translatable SlugField for DRF serializers"""
pass
pass