django-nepkit 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

django_nepkit/serializers.py

@@ -12,19 +12,21 @@ except ModuleNotFoundError as e:
         "to use `django_nepkit.serializers`."
     ) from e
 
-from django_nepkit.utils import try_parse_nepali_date, try_parse_nepali_datetime
-
-# --------------------------------------------------
-# Base Serializer Field
-# --------------------------------------------------
+from django_nepkit.conf import nepkit_settings
+from django_nepkit.utils import (
+    BS_DATE_FORMAT,
+    BS_DATETIME_FORMAT,
+    format_nepali_currency,
+    try_parse_nepali_date,
+    try_parse_nepali_datetime,
+)
 
 
 class BaseNepaliBSField(serializers.Field):
     """
-    Base DRF field for Nepali (BS) Date / DateTime.
-
-    - **Input**: BS string, or an already-parsed `nepalidate`/`nepalidatetime`
-    - **Output**: formatted BS string (configurable)
+    Handles Nepali (BS) dates.
+    - Input: A date string (like '2080-01-01') or a date object.
+    - Output: A formatted string for your API.
     """
 
     format: str = ""
@@ -35,14 +37,36 @@ class BaseNepaliBSField(serializers.Field):
         "invalid_type": "Invalid type. Expected a string.",
     }
 
-    def __init__(self, *, format: Optional[str] = None, **kwargs: Any) -> None:
+    def __init__(
+        self,
+        *,
+        format: Optional[str] = None,
+        ne: Optional[bool] = None,
+        en: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> None:
         """
         Args:
             format: Optional `strftime` format used for representation.
                     If not provided, uses the class default.
+            ne: If True, output in Devanagari script. If None, uses DEFAULT_LANGUAGE.
+            en: If True, output in English. If None, derived from ne.
         """
         if format is not None:
             self.format = format
+
+        default_lang = nepkit_settings.DEFAULT_LANGUAGE
+
+        if ne is None:
+            self.ne = default_lang == "ne"
+        else:
+            self.ne = ne
+
+        if en is None:
+            self.en = not self.ne
+        else:
+            self.en = en
+
         super().__init__(**kwargs)
 
     def _parse(self, value: str):
@@ -52,20 +76,25 @@ class BaseNepaliBSField(serializers.Field):
             return try_parse_nepali_datetime(value)
         return None
 
+    def _format_value(self, value: Any) -> str:
+        """Format value using strftime or strftime_ne (Devanagari) based on self.ne."""
+        if self.ne and hasattr(value, "strftime_ne"):
+            return value.strftime_ne(self.format)  # type: ignore[attr-defined]
+        return value.strftime(self.format)  # type: ignore[attr-defined]
+
     def to_representation(self, value: Any) -> Optional[str]:
         if value is None:
             return None
 
         if isinstance(value, self.nepali_type):
-            return value.strftime(self.format)  # type: ignore[attr-defined]
+            return self._format_value(value)
 
-        # If DB returns string, try to normalize it.
+        # Convert string dates to Nepali date objects
         if isinstance(value, str):
             parsed = self._parse(value)
             if parsed is not None:
-                return parsed.strftime(self.format)  # type: ignore[attr-defined]
+                return self._format_value(parsed)
 
-        # Fallback: best-effort stringify (keeps behavior non-breaking)
         return str(value)
 
     def to_internal_value(self, data: Any):
@@ -85,29 +114,99 @@ class BaseNepaliBSField(serializers.Field):
         self.fail("invalid", format=self.format)
 
 
-# --------------------------------------------------
-# Nepali Date (BS)
-# --------------------------------------------------
+class NepaliDateSerializerField(BaseNepaliBSField):
+    """API field for Nepali Dates."""
 
+    format = BS_DATE_FORMAT
+    nepali_type = nepalidate
 
-class NepaliDateSerializerField(BaseNepaliBSField):
+
+class NepaliDateTimeSerializerField(BaseNepaliBSField):
+    """API field for Nepali Date and Time."""
+
+    format = BS_DATETIME_FORMAT
+    nepali_type = nepalidatetime
+
+
+class NepaliCurrencySerializerField(serializers.Field):
     """
-    DRF field for Nepali BS Date (YYYY-MM-DD)
+    API field for Nepali Currency.
+    Formats decimal values with Nepali-style commas.
     """
 
-    format = "%Y-%m-%d"
-    nepali_type = nepalidate
+    def __init__(self, currency_symbol="Rs.", ne=None, **kwargs):
+        self.currency_symbol = currency_symbol
+        self.ne = ne
+        super().__init__(**kwargs)
+
+    def to_representation(self, value):
+        if value is None:
+            return None
 
+        ne = self.ne
+        if ne is None:
+            ne = self.context.get("ne", nepkit_settings.DEFAULT_LANGUAGE == "ne")
 
-# --------------------------------------------------
-# Nepali DateTime (BS)
-# --------------------------------------------------
+        return format_nepali_currency(
+            value, currency_symbol=self.currency_symbol, ne=ne
+        )
 
+    def to_internal_value(self, data):
+        # We don't support converting back from formatted string to decimal here
+        # Users should send raw decimal/float values for input.
+        return data
 
-class NepaliDateTimeSerializerField(BaseNepaliBSField):
+
+class NepaliLocalizedSerializerMixin:
     """
-    DRF field for Nepali BS DateTime (YYYY-MM-DD HH:MM:SS)
+    A mixin for ModelSerializer that automatically adds localized counterparts
+    for eligible fields if `ne=True` is passed in the context.
+    Eligible fields: NepaliDateField, NepaliDateTimeField, NepaliCurrencyField.
+
+    Usage:
+        class MySerializer(NepaliLocalizedSerializerMixin, serializers.ModelSerializer):
+            ...
     """
 
-    format = "%Y-%m-%d %H:%M:%S"
-    nepali_type = nepalidatetime
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)  # type: ignore[misc]
+        ne = self.context.get("ne", False)
+        if not ne:
+            return ret
+
+        from django_nepkit.models import (
+            NepaliCurrencyField,
+            NepaliDateField,
+            NepaliDateTimeField,
+        )
+
+        model = getattr(self.Meta, "model", None)  # type: ignore[attr-defined]
+        if not model:
+            return ret
+
+        for field_name, value in list(ret.items()):
+            try:
+                model_field = model._meta.get_field(field_name)
+                localized_name = f"{field_name}_ne"
+
+                if localized_name in ret:
+                    continue
+
+                if isinstance(model_field, NepaliDateField):
+                    raw_val = getattr(instance, field_name)
+                    if hasattr(raw_val, "strftime_ne"):
+                        ret[localized_name] = raw_val.strftime_ne(BS_DATE_FORMAT)
+
+                elif isinstance(model_field, NepaliDateTimeField):
+                    raw_val = getattr(instance, field_name)
+                    if hasattr(raw_val, "strftime_ne"):
+                        ret[localized_name] = raw_val.strftime_ne(BS_DATETIME_FORMAT)
+
+                elif isinstance(model_field, NepaliCurrencyField):
+                    ret[localized_name] = format_nepali_currency(
+                        value, currency_symbol="", ne=True
+                    )
+            except Exception:
+                continue
+
+        return ret

django_nepkit/static/django_nepkit/js/address-chaining.js

@@ -1,6 +1,20 @@
 (function() {
     'use strict';
 
+    // Placeholder text constants
+    const PLACEHOLDERS = {
+        province: { ne: 'प्रदेश छान्नुहोस्', en: 'Select Province' },
+        district: { ne: 'जिल्ला छान्नुहोस्', en: 'Select District' },
+        municipality: { ne: 'नगरपालिका छान्नुहोस्', en: 'Select Municipality' }
+    };
+
+    /**
+     * Get placeholder text for a specific location type
+     */
+    function getPlaceholder(type, isNepali) {
+        return PLACEHOLDERS[type][isNepali ? 'ne' : 'en'];
+    }
+
     function updateOptions(selectElement, data, placeholder) {
         selectElement.innerHTML = '';
         if (placeholder) {
@@ -18,47 +32,133 @@
         selectElement.dispatchEvent(new Event('change'));
     }
 
+    function getLocalData(type, parentId, isNepali) {
+        if (!window.NEPKIT_DATA) return null;
+        const lang = isNepali ? 'ne' : 'en';
+        const data = window.NEPKIT_DATA[lang];
+        if (!data) return null;
+
+        if (type === 'districts') {
+            return data.districts[parentId] || [];
+        } else if (type === 'municipalities') {
+            return data.municipalities[parentId] || [];
+        }
+        return null;
+    }
+
+    function getMatchingSelect(container, selector, isNepali) {
+        const matches = container.querySelectorAll(selector);
+        for (let el of matches) {
+            const elIsNepali = el.dataset.ne === 'true';
+            if (elIsNepali === isNepali) {
+                return el;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Fetch data from server endpoint
+     */
+    function fetchData(selectElement, paramName, paramValue, placeholderType, isNepali) {
+        if (!selectElement.dataset.url) return;
+
+        let url = selectElement.dataset.url + '?' + paramName + '=' + encodeURIComponent(paramValue);
+        if (isNepali) url += '&ne=true';
+        if (selectElement.dataset.en === 'true') url += '&en=true';
+
+        fetch(url)
+            .then(response => response.json())
+            .then(data => {
+                updateOptions(selectElement, data, getPlaceholder(placeholderType, isNepali));
+            });
+    }
+
+    /**
+     * Update dependent select element based on parent value
+     */
+    function updateDependentSelect(childSelect, dataType, parentValue, placeholderType, isNepali, paramName) {
+        if (!childSelect) return;
+
+        if (!parentValue) {
+            updateOptions(childSelect, [], getPlaceholder(placeholderType, isNepali));
+            return;
+        }
+
+        const localData = getLocalData(dataType, parentValue, isNepali);
+
+        if (localData) {
+            updateOptions(childSelect, localData, getPlaceholder(placeholderType, isNepali));
+        } else {
+            fetchData(childSelect, paramName, parentValue, placeholderType, isNepali);
+        }
+    }
+
+    function init() {
+        // Initialize province selects
+        document.querySelectorAll('.nepkit-province-select').forEach(provinceSelect => {
+            const isNepali = provinceSelect.dataset.ne === 'true';
+            const container = provinceSelect.closest('form') || document;
+            const districtSelect = getMatchingSelect(container, '.nepkit-district-select', isNepali);
+            const municipalitySelect = getMatchingSelect(container, '.nepkit-municipality-select', isNepali);
+
+            if (!provinceSelect.value) {
+                if (districtSelect && !districtSelect.value) {
+                    updateOptions(districtSelect, [], getPlaceholder('district', isNepali));
+                }
+                if (municipalitySelect && !municipalitySelect.value) {
+                    updateOptions(municipalitySelect, [], getPlaceholder('municipality', isNepali));
+                }
+            }
+        });
+
+        // Initialize district selects
+        document.querySelectorAll('.nepkit-district-select').forEach(districtSelect => {
+            const isNepali = districtSelect.dataset.ne === 'true';
+            const container = districtSelect.closest('form') || document;
+            const municipalitySelect = getMatchingSelect(container, '.nepkit-municipality-select', isNepali);
+
+            if (!districtSelect.value) {
+                if (municipalitySelect && !municipalitySelect.value) {
+                    updateOptions(municipalitySelect, [], getPlaceholder('municipality', isNepali));
+                }
+            }
+        });
+    }
+
     document.addEventListener('change', function(e) {
+        // Handle province select change
         if (e.target.matches('.nepkit-province-select')) {
             const province = e.target.value;
+            const isNepali = e.target.dataset.ne === 'true';
             const container = e.target.closest('form') || document;
-            const districtSelect = container.querySelector('.nepkit-district-select');
-            const municipalitySelect = container.querySelector('.nepkit-municipality-select');
-
-            if (districtSelect) {
-                if (!province) {
-                    updateOptions(districtSelect, [], 'Select District');
-                    if (municipalitySelect) updateOptions(municipalitySelect, [], 'Select Municipality');
-                    return;
-                }
+            const districtSelect = getMatchingSelect(container, '.nepkit-district-select', isNepali);
+            const municipalitySelect = getMatchingSelect(container, '.nepkit-municipality-select', isNepali);
 
-                const url = districtSelect.dataset.url + '?province=' + encodeURIComponent(province);
-                fetch(url)
-                    .then(response => response.json())
-                    .then(data => {
-                        updateOptions(districtSelect, data, 'Select District');
-                    });
+            // Always clear municipality if province changes
+            if (municipalitySelect) {
+                updateOptions(municipalitySelect, [], getPlaceholder('municipality', isNepali));
             }
+
+            // Update district options
+            updateDependentSelect(districtSelect, 'districts', province, 'district', isNepali, 'province');
         }
 
+        // Handle district select change
         if (e.target.matches('.nepkit-district-select')) {
             const district = e.target.value;
+            const isNepali = e.target.dataset.ne === 'true';
             const container = e.target.closest('form') || document;
-            const municipalitySelect = container.querySelector('.nepkit-municipality-select');
-
-            if (municipalitySelect) {
-                if (!district) {
-                    updateOptions(municipalitySelect, [], 'Select Municipality');
-                    return;
-                }
+            const municipalitySelect = getMatchingSelect(container, '.nepkit-municipality-select', isNepali);
 
-                const url = municipalitySelect.dataset.url + '?district=' + encodeURIComponent(district);
-                fetch(url)
-                    .then(response => response.json())
-                    .then(data => {
-                        updateOptions(municipalitySelect, data, 'Select Municipality');
-                    });
-            }
+            // Update municipality options
+            updateDependentSelect(municipalitySelect, 'municipalities', district, 'municipality', isNepali, 'district');
         }
     });
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
 })();