Add LocalizedBooleanField (#93)

Author: GRazvan12

localized_fields/admin.py

@@ -1,5 +1,6 @@
 from . import widgets
 from .fields import (
+    LocalizedBooleanField,
     LocalizedCharField,
     LocalizedField,
     LocalizedFileField,
@@ -11,6 +12,7 @@
     LocalizedCharField: {"widget": widgets.AdminLocalizedCharFieldWidget},
     LocalizedTextField: {"widget": widgets.AdminLocalizedFieldWidget},
     LocalizedFileField: {"widget": widgets.AdminLocalizedFileFieldWidget},
+    LocalizedBooleanField: {"widget": widgets.AdminLocalizedBooleanFieldWidget},
 }
 
 

localized_fields/fields/__init__.py

@@ -1,4 +1,5 @@
 from .autoslug_field import LocalizedAutoSlugField
+from .boolean_field import LocalizedBooleanField
 from .char_field import LocalizedCharField
 from .field import LocalizedField
 from .file_field import LocalizedFileField
@@ -16,6 +17,7 @@
     "LocalizedFileField",
     "LocalizedIntegerField",
     "LocalizedFloatField",
+    "LocalizedBooleanField",
 ]
 
 try:

localized_fields/fields/boolean_field.py

@@ -0,0 +1,110 @@
+from typing import Dict, Optional, Union
+
+from django.conf import settings
+from django.db.utils import IntegrityError
+
+from ..forms import LocalizedBooleanFieldForm
+from ..value import LocalizedBooleanValue, LocalizedValue
+from .field import LocalizedField
+
+
+class LocalizedBooleanField(LocalizedField):
+    """Stores booleans as a localized value."""
+
+    attr_class = LocalizedBooleanValue
+
+    @classmethod
+    def from_db_value(cls, value, *_) -> Optional[LocalizedBooleanValue]:
+        db_value = super().from_db_value(value)
+
+        if db_value is None:
+            return db_value
+
+        if isinstance(db_value, str):
+            if db_value.lower() == "true":
+                return True
+            return False
+
+        if not isinstance(db_value, LocalizedValue):
+            return db_value
+
+        return cls._convert_localized_value(db_value)
+
+    def to_python(
+        self, value: Union[Dict[str, str], str, None]
+    ) -> LocalizedBooleanValue:
+        """Converts the value from a database value into a Python value."""
+
+        db_value = super().to_python(value)
+        return self._convert_localized_value(db_value)
+
+    def get_prep_value(self, value: LocalizedBooleanValue) -> dict:
+        """Gets the value in a format to store into the database."""
+
+        # apply default values
+        default_values = LocalizedBooleanValue(self.default)
+        if isinstance(value, LocalizedBooleanValue):
+            for lang_code, _ in settings.LANGUAGES:
+                local_value = value.get(lang_code)
+                if local_value is None:
+                    value.set(lang_code, default_values.get(lang_code, None))
+
+        prepped_value = super().get_prep_value(value)
+        if prepped_value is None:
+            return None
+
+        # make sure all values are proper values to be converted to bool
+        for lang_code, _ in settings.LANGUAGES:
+            local_value = prepped_value[lang_code]
+
+            if local_value is not None and local_value.lower() not in (
+                "false",
+                "true",
+            ):
+                raise IntegrityError(
+                    'non-boolean value in column "%s.%s" violates '
+                    "boolean constraint" % (self.name, lang_code)
+                )
+
+            # convert to a string before saving because the underlying
+            # type is hstore, which only accept strings
+            prepped_value[lang_code] = (
+                str(local_value) if local_value is not None else None
+            )
+
+        return prepped_value
+
+    def formfield(self, **kwargs):
+        """Gets the form field associated with this field."""
+        defaults = {"form_class": LocalizedBooleanFieldForm}
+
+        defaults.update(kwargs)
+        return super().formfield(**defaults)
+
+    @staticmethod
+    def _convert_localized_value(
+        value: LocalizedValue,
+    ) -> LocalizedBooleanValue:
+        """Converts from :see:LocalizedValue to :see:LocalizedBooleanValue."""
+
+        integer_values = {}
+        for lang_code, _ in settings.LANGUAGES:
+            local_value = value.get(lang_code, None)
+
+            if isinstance(local_value, str):
+                if local_value.lower() == "false":
+                    local_value = False
+                elif local_value.lower() == "true":
+                    local_value = True
+                else:
+                    raise ValueError(
+                        f"Could not convert value {local_value} to boolean."
+                    )
+
+                integer_values[lang_code] = local_value
+            elif local_value is not None:
+                raise TypeError(
+                    f"Expected value of type str instead of {type(local_value)}."
+                )
+
+        return LocalizedBooleanValue(integer_values)

localized_fields/forms.py

@@ -6,12 +6,14 @@
 from django.forms.widgets import FILE_INPUT_CONTRADICTION
 
 from .value import (
+    LocalizedBooleanValue,
     LocalizedFileValue,
     LocalizedIntegerValue,
     LocalizedStringValue,
     LocalizedValue,
 )
 from .widgets import (
+    AdminLocalizedBooleanFieldWidget,
     AdminLocalizedIntegerFieldWidget,
     LocalizedCharFieldWidget,
     LocalizedFieldWidget,
@@ -102,6 +104,15 @@ class LocalizedIntegerFieldForm(LocalizedFieldForm):
     value_class = LocalizedIntegerValue
 
 
+class LocalizedBooleanFieldForm(LocalizedFieldForm, forms.BooleanField):
+    """Form for a localized boolean field, allows editing the field in multiple
+    languages."""
+
+    widget = AdminLocalizedBooleanFieldWidget
+    field_class = forms.fields.BooleanField
+    value_class = LocalizedBooleanValue
+
+
 class LocalizedFileFieldForm(LocalizedFieldForm, forms.FileField):
     """Form for a localized file field, allows editing the field in multiple
     languages."""

localized_fields/value.py

@@ -237,6 +237,35 @@ def localized(self):
         return self.get(translation.get_language())
 
 
+class LocalizedBooleanValue(LocalizedValue):
+    def translate(self):
+        """Gets the value in the current language, or in the configured fallbck
+        language."""
+
+        value = super().translate()
+        if value is None or (isinstance(value, str) and value.strip() == ""):
+            return None
+
+        if isinstance(value, bool):
+            return value
+
+        if value.lower() == "true":
+            return True
+        return False
+
+    def __bool__(self):
+        """Gets the value in the current language as a boolean."""
+        value = self.translate()
+
+        return value
+
+    def __str__(self):
+        """Returns string representation of value."""
+
+        value = self.translate()
+        return str(value) if value is not None else ""
+
+
 class LocalizedNumericValue(LocalizedValue):
     def __int__(self):
         """Gets the value in the current language as an integer."""

localized_fields/widgets.py

@@ -120,6 +120,18 @@ class AdminLocalizedFieldWidget(LocalizedFieldWidget):
     widget = widgets.AdminTextareaWidget
 
 
+class AdminLocalizedBooleanFieldWidget(LocalizedFieldWidget):
+    widget = forms.Select
+
+    def __init__(self, *args, **kwargs):
+        """Initializes a new instance of :see:LocalizedBooleanFieldWidget."""
+
+        super().__init__(*args, **kwargs)
+
+        for widget in self.widgets:
+            widget.choices = [("False", False), ("True", True)]
+
+
 class AdminLocalizedCharFieldWidget(AdminLocalizedFieldWidget):
     widget = widgets.AdminTextInputWidget
 

setup.py

@@ -90,7 +90,7 @@ def run(self):
             "psycopg2==2.8.4",
         ],
         "analysis": [
-            "black==19.3b0",
+            "black==22.3.0",
             "flake8==3.7.7",
             "autoflake==1.3",
             "autopep8==1.4.4",