django-camomilla-cms 6.0.0b16__py2.py3-none-any.whl → 6.0.0b17__py2.py3-none-any.whl

camomilla/{contrib/rest_framework/serializer.py → serializers/mixins/translation.py}

@@ -1,7 +1,5 @@
 from functools import cached_property
-from typing import Iterable, Union, List
-from django.http import QueryDict
-
+from typing import Iterable, List
 from modeltranslation import settings as mt_settings
 from modeltranslation.translator import NotRegistered, translator
 from modeltranslation.utils import build_localized_fieldname
@@ -9,50 +7,8 @@ from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
 from camomilla.utils.getters import pointed_getter
 from camomilla.utils.translation import is_translatable
-
-
-TRANS_ACCESSOR = "translations"
-
-
-def plain_to_nest(data, fields, accessor=TRANS_ACCESSOR):
-    """
-    This function transforms a plain dictionary with translations fields (es. {"title_en": "Hello"})
-    into a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}}).
-    """
-    trans_data = {}
-    for lang in mt_settings.AVAILABLE_LANGUAGES:
-        lang_data = {}
-        for field in fields:
-            trans_field_name = build_localized_fieldname(field, lang)
-            if trans_field_name in data:
-                lang_data[field] = data.pop(trans_field_name)
-        if lang_data.keys():
-            trans_data[lang] = lang_data
-    if trans_data.keys():
-        data[accessor] = trans_data
-    return data
-
-
-def nest_to_plain(data: Union[dict, QueryDict], fields: List[str], accessor=TRANS_ACCESSOR):
-    """
-    This function is the inverse of plain_to_nest.
-    It transforms a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}})
-    into a plain dictionary with translations fields (es. {"title_en": "Hello"}).
-    """
-    if isinstance(data, QueryDict):
-        data = data.dict()
-    translations = data.pop(accessor, {})
-    for lang in mt_settings.AVAILABLE_LANGUAGES:
-        nest_trans = translations.pop(lang, {})
-        for k in fields:
-            data.pop(k, None)  # this removes all trans field without lang
-            if k in nest_trans:
-                # this saves on the default field the default language value
-                if lang == mt_settings.DEFAULT_LANGUAGE:
-                    data[k] = nest_trans[k]
-                key = build_localized_fieldname(k, lang)
-                data[key] = data.get(key, nest_trans[k])
-    return data
+from camomilla.utils.translation import nest_to_plain, plain_to_nest
+from camomilla.settings import API_TRANSLATION_ACCESSOR
 
 
 class TranslationsMixin(serializers.ModelSerializer):
@@ -67,6 +23,16 @@ class TranslationsMixin(serializers.ModelSerializer):
     `{"translations": {"en": {"title": "Hello"}, "it": {"title": "Ciao"}}` -> `{"title_en": "Hello", "title_it": "Ciao"}`
     """
 
+    def _transform_input(self, data):
+        return nest_to_plain(
+            data, self.translation_fields or [], API_TRANSLATION_ACCESSOR
+        )
+
+    def _transform_output(self, data):
+        return plain_to_nest(
+            data, self.translation_fields or [], API_TRANSLATION_ACCESSOR
+        )
+
     @cached_property
     def translation_fields(self) -> List[str]:
         try:
@@ -81,22 +47,16 @@ class TranslationsMixin(serializers.ModelSerializer):
                 yield field
 
     def to_internal_value(self, data):
-        if self.translation_fields:
-            nest_to_plain(data, self.translation_fields)
-        return super().to_internal_value(data)
+        return super().to_internal_value(self._transform_input(data))
 
     def to_representation(self, instance):
-        representation = super().to_representation(instance)
-        if self.translation_fields:
-            plain_to_nest(representation, self.translation_fields)
-        return representation
+        return self._transform_output(super().to_representation(instance))
 
     def run_validation(self, *args, **kwargs):
         try:
             return super().run_validation(*args, **kwargs)
         except ValidationError as ex:
-            if self.translation_fields:
-                plain_to_nest(ex.detail, self.translation_fields)
+            ex.detail.update(self._transform_input(ex.detail))
             raise ValidationError(detail=ex.detail)
 
     @property

camomilla/serializers/utils.py

@@ -1,13 +1,13 @@
 def get_standard_bases() -> tuple:
     from rest_framework.serializers import ModelSerializer
-    from camomilla.serializers.fields import FieldsOverrideMixin
-    from camomilla.serializers.mixins.filter_fields import FilterFieldsMixin
-    from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
     from camomilla.serializers.mixins import (
         JSONFieldPatchMixin,
         NestMixin,
         OrderingMixin,
         SetupEagerLoadingMixin,
+        FieldsOverrideMixin,
+        FilterFieldsMixin,
+        RemoveTranslationsMixin,
     )
 
     return (

camomilla/serializers/validators.py

@@ -31,9 +31,13 @@ class UniquePermalinkValidator:
         for language in activate_languages():
             autopermalink_f = build_localized_fieldname("autopermalink", language)
             f_name = build_localized_fieldname("permalink", language)
-            permalink = value.get(f_name, instance and get_nofallbacks(instance, "permalink"))
+            permalink = value.get(
+                f_name, instance and get_nofallbacks(instance, "permalink")
+            )
             permalink = UrlNode.sanitize_permalink(permalink)
-            autopermalink = value.get(autopermalink_f, instance and get_nofallbacks(instance, "autopermalink"))
+            autopermalink = value.get(
+                autopermalink_f, instance and get_nofallbacks(instance, "autopermalink")
+            )
             if autopermalink:
                 continue
             fake_instance = serializer.Meta.model()

camomilla/settings.py

@@ -1,5 +1,5 @@
 from django.conf import settings as django_settings
-from modeltranslation.settings import ENABLE_REGISTRATIONS
+from modeltranslation.settings import ENABLE_REGISTRATIONS, AVAILABLE_LANGUAGES
 
 from camomilla.utils.getters import pointed_getter
 
@@ -53,6 +53,10 @@ ENABLE_TRANSLATIONS = (
     ENABLE_REGISTRATIONS and "modeltranslation" in django_settings.INSTALLED_APPS
 )
 
+DEFAULT_LANGUAGE = pointed_getter(django_settings, "LANGUAGE_CODE", "en")
+
+LANGUAGE_CODES = AVAILABLE_LANGUAGES
+
 MEDIA_OPTIMIZE_MAX_WIDTH = pointed_getter(
     django_settings, "CAMOMILLA.MEDIA.OPTIMIZE.MAX_WIDTH", 1980
 )
@@ -79,6 +83,10 @@ TEMPLATE_CONTEXT_FILES = pointed_getter(
     django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
 )
 
+API_TRANSLATION_ACCESSOR = pointed_getter(
+    django_settings, "CAMOMILLA.API.TRANSLATION_ACCESSOR", "translations"
+)
+
 DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
 
 # camomilla settings example
@@ -100,6 +108,6 @@ DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG
 #     "STRUCTURED_FIELD": {
 #         "CACHE_ENABLED": True
 #     }
-#     "API": {"NESTING_DEPTH": 10 },
+#     "API": {"NESTING_DEPTH": 10, "TRANSLATION_ACCESSOR": "translations"},
 #     "DEBUG": False
 # }

camomilla/storages/default.py

@@ -1,6 +1,12 @@
 from django.utils.module_loading import import_string
 from django.conf import settings
 
+from django import VERSION as DJANGO_VERSION
+
 
 def get_default_storage_class():
-    return import_string(settings.STORAGES["default"]["BACKEND"])
+    if DJANGO_VERSION >= (4, 2):
+        storage = settings.STORAGES["default"]["BACKEND"]
+    else:
+        storage = settings.DEFAULT_FILE_STORAGE
+    return import_string(storage)

camomilla/templates/defaults/parts/menu.html

@@ -4,7 +4,7 @@
   {% for item in menu.nodes %}
   <li>
     {% if item.link.url %}
-      <a href="{{ item.link.url }}{% if is_preview %}?preview=true{% endif %}">{{ item.title }}</a>
+      <a href="{{ item|node_url }}{% if is_preview %}?preview=true{% endif %}">{{ item.title }}</a>
     {% else %}
       <span>{{item.title}}</span>
     {% endif %}

camomilla/templatetags/menus.py

@@ -22,6 +22,9 @@ def render_menu(
     menu_key: str,
     template_path: str = "defaults/parts/menu.html",
 ):
+    if context is not None and not isinstance(context, dict):
+        context = context.__dict__
+
     return context.get("menus", Menu.defaultdict())[menu_key].render(
         template_path=template_path,
         context=context,

camomilla/theme/__init__.py

@@ -1 +1 @@
-__version__ = "6.0.0-beta.16"
+__version__ = "6.0.0-beta.17"

camomilla/theme/{admin.py → admin/__init__.py}

@@ -1,33 +1,30 @@
-from ckeditor_uploader.widgets import CKEditorUploadingWidget
+from tinymce.widgets import TinyMCE
 from django import forms
 from django.contrib import admin
 from django.http import HttpResponse
-
-from camomilla import settings
-
-if settings.ENABLE_TRANSLATIONS:
-    from modeltranslation.admin import (
-        TabbedTranslationAdmin as TranslationAwareModelAdmin,
-    )
-else:
-    from django.contrib.admin import ModelAdmin as TranslationAwareModelAdmin
-
-from camomilla.models import Article, Content, Media, MediaFolder, Page, Tag, Menu
-
-
-class AbstractPageAdmin(TranslationAwareModelAdmin):
-    change_form_template = "admin/camomilla/page/change_form.html"
+from .pages import AbstractPageModelForm, AbstractPageAdmin
+from .translations import TranslationAwareModelAdmin
+from camomilla.models import (
+    Article,
+    Content,
+    Media,
+    MediaFolder,
+    Page,
+    Tag,
+    Menu,
+    UrlRedirect,
+)
 
 
 class UserProfileAdmin(admin.ModelAdmin):
     pass
 
 
-class ArticleAdminForm(forms.ModelForm):
+class ArticleAdminForm(AbstractPageModelForm):
     class Meta:
         model = Article
         fields = "__all__"
-        widgets = {"content": CKEditorUploadingWidget}
+        widgets = {"content": TinyMCE()}
 
 
 class ArticleAdmin(AbstractPageAdmin):
@@ -47,7 +44,7 @@ class ContentAdminForm(forms.ModelForm):
     class Meta:
         model = Content
         fields = "__all__"
-        widgets = {"content": CKEditorUploadingWidget}
+        widgets = {"content": TinyMCE()}
 
 
 class ContentAdmin(TranslationAwareModelAdmin):
@@ -81,13 +78,17 @@ class MediaAdmin(TranslationAwareModelAdmin):
 
 
 class PageAdmin(AbstractPageAdmin):
-    readonly_fields = ("permalink",)
+    pass
 
 
 class MenuAdmin(TranslationAwareModelAdmin):
     pass
 
 
+class UrlRedirectAdmin(admin.ModelAdmin):
+    pass
+
+
 admin.site.register(Article, ArticleAdmin)
 admin.site.register(MediaFolder, MediaFolderAdmin)
 admin.site.register(Tag, TagAdmin)
@@ -95,3 +96,4 @@ admin.site.register(Content, ContentAdmin)
 admin.site.register(Media, MediaAdmin)
 admin.site.register(Page, PageAdmin)
 admin.site.register(Menu, MenuAdmin)
+admin.site.register(UrlRedirect, UrlRedirectAdmin)

camomilla/theme/admin/pages.py

@@ -0,0 +1,46 @@
+from django import forms
+from camomilla import settings
+from .translations import TranslationAwareModelAdmin
+from camomilla.models import UrlNode
+
+
+class AbstractPageModelFormMeta(forms.models.ModelFormMetaclass):
+    def __new__(mcs, name, bases, attrs):
+        new_class = super().__new__(mcs, name, bases, attrs)
+        fields_to_add = forms.fields_for_model(UrlNode, UrlNode.LANG_PERMALINK_FIELDS)
+        if settings.ENABLE_TRANSLATIONS:
+            for i, field_name in enumerate(fields_to_add.keys()):
+                field_classes = ["mt", f"mt-field-{field_name.replace('_', '-')}"]
+                i == 0 and field_classes.append("mt-default")
+                fields_to_add[field_name].widget.attrs.update(
+                    {"class": " ".join(field_classes)}
+                )
+        new_class.base_fields.update(fields_to_add)
+        return new_class
+
+
+class AbstractPageModelForm(
+    forms.models.BaseModelForm, metaclass=AbstractPageModelFormMeta
+):
+
+    def get_initial_for_field(self, field, field_name):
+        if field_name in UrlNode.LANG_PERMALINK_FIELDS:
+            return getattr(self.instance, field_name)
+        return super().get_initial_for_field(field, field_name)
+
+    def save(self, commit: bool = True):
+        model = super().save(commit=False)
+        for field_name in UrlNode.LANG_PERMALINK_FIELDS:
+            if field_name in self.cleaned_data:
+                if getattr(model, field_name) != self.cleaned_data[field_name]:
+                    # sets autopermalink to False if permalink is manually set
+                    setattr(model, f"auto{field_name}", False)
+                setattr(model, field_name, self.cleaned_data[field_name])
+        if commit:
+            model.save()
+        return model
+
+
+class AbstractPageAdmin(TranslationAwareModelAdmin):
+    form = AbstractPageModelForm
+    change_form_template = "admin/camomilla/page/change_form.html"

camomilla/theme/admin/translations.py

@@ -0,0 +1,13 @@
+from camomilla import settings
+
+if settings.ENABLE_TRANSLATIONS:
+    from modeltranslation.admin import (
+        TabbedTranslationAdmin as TranslationAwareModelAdmin,
+    )
+else:
+    from django.contrib.admin import ModelAdmin as TranslationAwareModelAdmin
+
+
+__all__ = [
+    "TranslationAwareModelAdmin",
+]

camomilla/theme/apps.py

@@ -29,12 +29,8 @@ class CamomillaThemeConfig(AppConfig):
     name = "camomilla.theme"
 
     def ready(self):
-        set_default_settings(
-            CKEDITOR_UPLOAD_PATH="editor-uploads/", X_FRAME_OPTIONS="SAMEORIGIN"
-        )
         add_apps(
-            "ckeditor_uploader",
-            "ckeditor",
+            "tinymce",
             "django_jsonform",
             "admin_interface",
             "colorfield",

camomilla/translation.py

@@ -16,7 +16,13 @@ class SeoMixinTranslationOptions(TranslationOptions):
 
 
 class AbstractPageTranslationOptions(SeoMixinTranslationOptions):
-    fields = ("breadcrumbs_title", "autopermalink", "status", "indexable", "template_data")
+    fields = (
+        "breadcrumbs_title",
+        "autopermalink",
+        "status",
+        "indexable",
+        "template_data",
+    )
 
 
 @register(Article)

camomilla/urls.py

@@ -1,4 +1,3 @@
-from django.shortcuts import redirect
 from django.urls import include, path
 from rest_framework import routers
 from importlib.util import find_spec
@@ -21,6 +20,7 @@ from camomilla.views import (
     MenuViewSet,
 )
 from camomilla.views.pages import fetch_page
+from camomilla.redirects import url_patterns as old_redirects
 
 router = routers.DefaultRouter()
 
@@ -30,18 +30,15 @@ router.register(r"contents", ContentViewSet, "camomilla-content")
 router.register(r"media", MediaViewSet, "camomilla-media")
 router.register(r"media-folders", MediaFolderViewSet, "camomilla-media_folders")
 router.register(r"pages", PageViewSet, "camomilla-pages")
-router.register(r"sitemap", PageViewSet, "camomilla-sitemap")
 router.register(r"users", UserViewSet, "camomilla-users")
 router.register(r"permissions", PermissionViewSet, "camomilla-permissions")
 router.register(r"menus", MenuViewSet, "camomilla-menus")
 
 urlpatterns = [
+    *old_redirects,
     path("", include(router.urls)),
     path("pages-router/", fetch_page),
     path("pages-router/<path:permalink>", fetch_page),
-    path(
-        "profiles/me/", lambda _: redirect("../../users/current/"), name="profiles-me"
-    ),
     path("token-auth/", CamomillaObtainAuthToken.as_view(), name="api_token"),
     path("auth/login/", CamomillaAuthLogin.as_view(), name="login"),
     path("auth/logout/", CamomillaAuthLogout.as_view(), name="logout"),

camomilla/utils/query_parser.py

@@ -1,14 +1,21 @@
 import re
 from django.db.models import Q
+from typing import List, Dict, Optional
 
-CONDITION_PATTERN = re.compile(r"(\w+__\w+='[^']+'|\w+__\w+=\S+)")  # Updated regex to handle quoted values
-LOGICAL_OPERATORS = {"AND", "OR"}
 
 class ConditionParser:
-    def __init__(self, query):
+    CONDITION_PATTERN = re.compile(
+        r"(\w+__\w+='[^']+'|\w+__\w+=\S+|\w+='[^']+'|\w+=\S+)"
+    )
+    LOGICAL_OPERATORS = {"AND", "OR"}
+
+    __db_query: Optional[Q] = None
+
+    def __init__(self, query: str):
+        self.__db_query = None
         self.query = query
-    
-    def parse(self, query=None):
+
+    def parse(self, query: str = None) -> Dict:
         """Parse the query or subquery. If no query is provided, use the instance's query."""
         if query is None:
             query = self.query
@@ -19,31 +26,31 @@ class ConditionParser:
             return tokens[0]
         return self.build_tree(tokens)
 
-    def tokenize(self, query):
+    def tokenize(self, query: str) -> List:
         tokens = []
         i = 0
         while i < len(query):
-            if query[i] == '(':
+            if query[i] == "(":
                 j = i + 1
                 open_parens = 1
                 while j < len(query) and open_parens > 0:
-                    if query[j] == '(':
+                    if query[j] == "(":
                         open_parens += 1
-                    elif query[j] == ')':
+                    elif query[j] == ")":
                         open_parens -= 1
                     j += 1
                 if open_parens == 0:
-                    subquery = query[i + 1:j - 1]
+                    subquery = query[i + 1 : j - 1]
                     tokens.append(self.parse(subquery))  # Pass the subquery here
                     i = j
                 else:
                     raise ValueError("Mismatched parentheses")
-            elif query[i:i+3] == 'AND' or query[i:i+2] == 'OR':
-                operator = 'AND' if query[i:i+3] == 'AND' else 'OR'
+            elif query[i : i + 3] == "AND" or query[i : i + 2] == "OR":
+                operator = "AND" if query[i : i + 3] == "AND" else "OR"
                 tokens.append(operator)
-                i += 3 if operator == 'AND' else 2
+                i += 3 if operator == "AND" else 2
             else:
-                match = CONDITION_PATTERN.match(query[i:])
+                match = self.CONDITION_PATTERN.match(query[i:])
                 if match:
                     condition = self.parse_condition(match.group())
                     tokens.append(condition)
@@ -52,10 +59,10 @@ class ConditionParser:
                     i += 1
         return tokens
 
-    def parse_condition(self, condition_str):
+    def parse_condition(self, condition: str) -> Optional[Dict]:
         """Parse a single condition into field lookup and value."""
-        if '=' in condition_str:
-            field_lookup, value = condition_str.split("=")
+        if "=" in condition:
+            field_lookup, value = condition.split("=")
             value = value.strip("'").strip('"')  # Remove single or double quotes
             value = self.parse_value(value)  # Parse the value
             return {"field_lookup": field_lookup, "value": value}
@@ -71,7 +78,7 @@ class ConditionParser:
             string = int(string)
         return string
 
-    def build_tree(self, tokens):
+    def build_tree(self, tokens: List[str]) -> Dict:
         """Build a tree-like structure with operators and conditions."""
         if not tokens:
             return None
@@ -88,23 +95,26 @@ class ConditionParser:
                     if isinstance(output_stack[-1], dict):
                         output_stack[-1] = {
                             "operator": operator,
-                            "conditions": [output_stack[-1], token]
+                            "conditions": [output_stack[-1], token],
                         }
                     else:
                         output_stack[-1]["conditions"].append(token)
                 else:
                     output_stack.append(token)
 
-            elif token in LOGICAL_OPERATORS:
+            elif token in self.LOGICAL_OPERATORS:
                 # Operator found (AND/OR), handle precedence
                 operator_stack.append(token)
 
         # If only one item in output_stack, return it directly
         if len(output_stack) == 1:
             return output_stack[0]
-        return {"operator": "AND", "conditions": output_stack}  # Default to AND if no operators
+        return {
+            "operator": "AND",
+            "conditions": output_stack,
+        }  # Default to AND if no operators
 
-    def to_q(self, parsed_tree):
+    def to_q(self, parsed_tree: Dict) -> Q:
         """Convert parsed tree structure into Q objects."""
         if isinstance(parsed_tree, list):
             # If parsed_tree is a list, combine all conditions with AND by default
@@ -140,9 +150,18 @@ class ConditionParser:
 
         raise ValueError("Parsed tree structure is invalid")
 
-    def parse_to_q(self):
+    def parse_to_q(self) -> Q:
         """Parse the query and convert to Q object."""
         parsed_tree = self.parse()
         if not parsed_tree:
             return Q()  # Return an empty Q if parsing fails
         return self.to_q(parsed_tree)
+
+    @property
+    def db_query(self) -> Q:
+        if self.__db_query is None:
+            self.__db_query = self.parse_to_q()
+        return self.__db_query
+
+    def __str__(self) -> str:
+        return f"ConditionParser({self.db_query})"

camomilla/utils/translation.py

@@ -1,11 +1,12 @@
 import re
-from typing import Any, Sequence, Iterator
+from typing import Any, Sequence, Iterator, Union, List
 
 from django.db.models import Model, Q
 from django.utils.translation.trans_real import activate, get_language
 from modeltranslation.settings import AVAILABLE_LANGUAGES, DEFAULT_LANGUAGE
 from modeltranslation.utils import build_localized_fieldname
 from camomilla.settings import BASE_URL
+from django.http import QueryDict
 
 
 def activate_languages(languages: Sequence[str] = AVAILABLE_LANGUAGES) -> Iterator[str]:
@@ -34,11 +35,9 @@ def get_nofallbacks(instance: Model, attr: str, *args, **kwargs) -> Any:
 
 def url_lang_decompose(url):
     if BASE_URL and url.startswith(BASE_URL):
-        url = url[len(BASE_URL):]
+        url = url[len(BASE_URL) :]
     data = {"url": url, "permalink": url, "language": DEFAULT_LANGUAGE}
-    result = re.match(
-        f"^\/?({'|'.join(AVAILABLE_LANGUAGES)})?\/(.*)", url
-    )  # noqa: W605
+    result = re.match(rf"^/?({'|'.join(AVAILABLE_LANGUAGES)})?/(.*)", url)  # noqa: W605
     groups = result and result.groups()
     if groups and len(groups) == 2:
         data["language"] = groups[0]
@@ -70,3 +69,46 @@ def is_translatable(model: Model) -> bool:
     from modeltranslation.translator import translator
 
     return model in translator.get_registered_models()
+
+
+def plain_to_nest(data, fields, accessor="translations"):
+    """
+    This function transforms a plain dictionary with translations fields (es. {"title_en": "Hello"})
+    into a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}}).
+    """
+    trans_data = {}
+    for lang in AVAILABLE_LANGUAGES:
+        lang_data = {}
+        for field in fields:
+            trans_field_name = build_localized_fieldname(field, lang)
+            if trans_field_name in data:
+                lang_data[field] = data.pop(trans_field_name)
+        if lang_data.keys():
+            trans_data[lang] = lang_data
+    if trans_data.keys():
+        data[accessor] = trans_data
+    return data
+
+
+def nest_to_plain(
+    data: Union[dict, QueryDict], fields: List[str], accessor="translations"
+):
+    """
+    This function is the inverse of plain_to_nest.
+    It transforms a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}})
+    into a plain dictionary with translations fields (es. {"title_en": "Hello"}).
+    """
+    if isinstance(data, QueryDict):
+        data = data.dict()
+    translations = data.pop(accessor, {})
+    for lang in AVAILABLE_LANGUAGES:
+        nest_trans = translations.pop(lang, {})
+        for k in fields:
+            data.pop(k, None)  # this removes all trans field without lang
+            if k in nest_trans:
+                # this saves on the default field the default language value
+                if lang == DEFAULT_LANGUAGE:
+                    data[k] = nest_trans[k]
+                key = build_localized_fieldname(k, lang)
+                data[key] = data.get(key, nest_trans[k])
+    return data