Initial
This commit is contained in:
Holger Sielaff
264
django_translatable_fields/serializers.py
Normal file
264
django_translatable_fields/serializers.py
Normal file
@@ -0,0 +1,264 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Django Translatable Fields - DRF Serializer Support
|
||||
|
||||
This module provides Django REST Framework serializer mixins and fields
|
||||
for handling translatable fields in API responses and requests.
|
||||
|
||||
Key Features:
|
||||
- Automatic language detection from request parameters
|
||||
- Language-specific field serialization and deserialization
|
||||
- Support for both single-language and multi-language API responses
|
||||
- Easy integration with existing DRF serializers
|
||||
|
||||
Usage:
|
||||
from django_translatable_fields.serializers import TranslatableSerializerMixin
|
||||
|
||||
class ProductSerializer(TranslatableSerializerMixin, serializers.ModelSerializer):
|
||||
class Meta:
|
||||
model = Product
|
||||
fields = ['id', 'name', 'description', 'price']
|
||||
|
||||
# API Usage:
|
||||
# GET /api/products/?language=de -> Returns German translations
|
||||
# GET /api/products/ -> Returns all translations as dicts
|
||||
# POST /api/products/ with {"name": "Test", "language": "de"} -> Saves to German
|
||||
|
||||
Author: Holger Sielaff <holger@backender.de>
|
||||
Version: 0.1.0
|
||||
"""
|
||||
|
||||
import json
|
||||
from rest_framework import serializers
|
||||
from django.utils.translation import get_language
|
||||
|
||||
|
||||
class TranslatableSerializerMixin:
|
||||
"""
|
||||
Mixin for DRF serializers that automatically handles translatable fields.
|
||||
|
||||
This mixin provides automatic language detection and processing for fields
|
||||
that have the `translatable=True` attribute. It supports both reading and
|
||||
writing translatable content via API endpoints.
|
||||
|
||||
Features:
|
||||
- Language parameter detection (?language=de)
|
||||
- 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/ -> returns full translation dicts
|
||||
# POST /api/items/ with language param -> 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'):
|
||||
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)
|
||||
|
||||
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
|
||||
return None
|
||||
|
||||
def to_representation(self, instance):
|
||||
"""
|
||||
Convert model instance to API representation.
|
||||
|
||||
Logic:
|
||||
- With language parameter: returns single-language values
|
||||
- Without language parameter:
|
||||
* If DB value is dict -> return dict
|
||||
* If DB value is not dict -> return the value directly (assume current language)
|
||||
"""
|
||||
data = super().to_representation(instance)
|
||||
request_language = self._get_request_language()
|
||||
|
||||
# Process translatable fields
|
||||
for field_name in self._translatable_fields:
|
||||
if field_name in data:
|
||||
field_value = data[field_name]
|
||||
|
||||
# Handle JSON string from database
|
||||
if isinstance(field_value, str):
|
||||
try:
|
||||
parsed_value = json.loads(field_value)
|
||||
if isinstance(parsed_value, dict):
|
||||
field_value = parsed_value
|
||||
# If JSON but not dict, keep as string
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
# If not JSON, keep as string
|
||||
pass
|
||||
|
||||
# Return specific language or handle based on type
|
||||
if request_language:
|
||||
# Language specified: extract specific language value
|
||||
if isinstance(field_value, dict):
|
||||
# Return value for requested language, fallback to English, then first available
|
||||
if request_language in field_value:
|
||||
data[field_name] = field_value[request_language]
|
||||
elif 'en' in field_value:
|
||||
data[field_name] = field_value['en']
|
||||
elif field_value:
|
||||
data[field_name] = next(iter(field_value.values()))
|
||||
else:
|
||||
data[field_name] = ''
|
||||
else:
|
||||
# Single value, return as-is
|
||||
data[field_name] = field_value
|
||||
else:
|
||||
# No language specified:
|
||||
# - If dict: return dict (full translations)
|
||||
# - If not dict: return value as-is (current language)
|
||||
data[field_name] = field_value
|
||||
|
||||
return data
|
||||
|
||||
def to_internal_value(self, 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}
|
||||
"""
|
||||
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)
|
||||
|
||||
|
||||
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']
|
||||
"""
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
self.language = kwargs.pop('language', None)
|
||||
super().__init__(**kwargs)
|
||||
|
||||
def to_representation(self, value):
|
||||
"""Convert database value to API representation"""
|
||||
if not value:
|
||||
return '' if self.language else {}
|
||||
|
||||
# Handle JSON string from database
|
||||
if isinstance(value, str):
|
||||
try:
|
||||
translations = json.loads(value)
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
translations = {'en': value}
|
||||
elif isinstance(value, dict):
|
||||
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]
|
||||
elif 'en' in translations:
|
||||
return translations['en']
|
||||
elif translations:
|
||||
return next(iter(translations.values()))
|
||||
else:
|
||||
return ''
|
||||
else:
|
||||
return translations
|
||||
|
||||
def to_internal_value(self, data):
|
||||
"""Convert API input to internal representation"""
|
||||
if self.language:
|
||||
# Convert single value to translation dict
|
||||
if isinstance(data, dict):
|
||||
return data
|
||||
else:
|
||||
return {self.language: str(data)}
|
||||
else:
|
||||
# Expect full translation dict
|
||||
if isinstance(data, dict):
|
||||
return data
|
||||
else:
|
||||
return {'en': str(data)}
|
||||
|
||||
|
||||
class TranslatableCharField(TranslatableField, serializers.CharField):
|
||||
"""Translatable CharField for DRF serializers"""
|
||||
pass
|
||||
|
||||
|
||||
class TranslatableTextField(TranslatableField, serializers.CharField):
|
||||
"""Translatable TextField for DRF serializers"""
|
||||
pass
|
||||
|
||||
|
||||
class TranslatableEmailField(TranslatableField, serializers.EmailField):
|
||||
"""Translatable EmailField for DRF serializers"""
|
||||
pass
|
||||
|
||||
|
||||
class TranslatableURLField(TranslatableField, serializers.URLField):
|
||||
"""Translatable URLField for DRF serializers"""
|
||||
pass
|
||||
|
||||
|
||||
class TranslatableSlugField(TranslatableField, serializers.SlugField):
|
||||
"""Translatable SlugField for DRF serializers"""
|
||||
pass
|
||||
Reference in New Issue
Block a user