from django.utils.translation import get_language from rest_framework import serializers from django.utils.translation import gettext_lazy as _ # from django.db.models import Count from ..models import HadisSect, HadisCategory, Hadis , HadisCategory from django.utils.translation import get_language def _get_localized_item_value(item): """ Prefer `title`, but fall back to `text`, `name`, or `description` for localized entries. """ if not item: return None if isinstance(item, str): return item if isinstance(item, dict): return item.get("title") or item.get("text") or item.get("name") or item.get("description") return str(item) def get_localized_text(json_list, request=None, fallback_lang="en", language_code=None): """ Extract localized text from a JSON list based on language. Supports items shaped like: - {"language_code": "en", "title": "..."} - {"language_code": "en", "text": "..."} Returns: Single text string or None """ if not json_list: return None if isinstance(json_list, str): return json_list if not isinstance(json_list, list): return _get_localized_item_value(json_list) # Get target language if not provided if not language_code: if request: query_params = getattr(request, "query_params", None) or getattr(request, "GET", None) if query_params: language_code = query_params.get("language_code") or query_params.get("lang") if not language_code: language_code = getattr(request, "LANGUAGE_CODE", None) if not language_code and hasattr(request, "headers"): language_code = request.headers.get("Accept-Language") elif not language_code and hasattr(request, "META"): language_code = request.META.get("HTTP_ACCEPT_LANGUAGE") if language_code: language_code = language_code.split(",")[0].split(";")[0].split("-")[0].strip().lower() if not language_code: language_code = get_language() or fallback_lang # 1) Exact match for item in json_list: if isinstance(item, dict) and item.get("language_code") == language_code: value = _get_localized_item_value(item) if value: return value # 2) Fallback to English for item in json_list: if isinstance(item, dict) and item.get("language_code") == "en": value = _get_localized_item_value(item) if value: return value # 3) First available if json_list: return _get_localized_item_value(json_list[0]) return None def get_arabic_localized_text(json_list): if not json_list: return None if isinstance(json_list, str): return json_list if not isinstance(json_list, list): return _get_localized_item_value(json_list) # 1) Exact match for 'ar' for item in json_list: if isinstance(item, dict) and item.get("language_code") == "ar": value = _get_localized_item_value(item) if value: return value # 2) Fallback to the last item registered if json_list: return _get_localized_item_value(json_list[-1]) return None class LocalizedField(serializers.Field): """ Extracts the correct language from a JSON list based on request.LANGUAGE_CODE (LocaleMiddleware), with sensible fallbacks. """ def to_representation(self, value): if not value: return None if isinstance(value, str): return value if not isinstance(value, list): return _get_localized_item_value(value) # Get language from request, then fall back to global language / 'en' request = self.context.get("request") language_code = None if request: query_params = getattr(request, "query_params", None) or getattr(request, "GET", None) if query_params: language_code = query_params.get("language_code") or query_params.get("lang") if not language_code: language_code = getattr(request, "LANGUAGE_CODE", None) if not language_code and hasattr(request, "headers"): language_code = request.headers.get("Accept-Language") elif not language_code and hasattr(request, "META"): language_code = request.META.get("HTTP_ACCEPT_LANGUAGE") if language_code: language_code = language_code.split(",")[0].split(";")[0].split("-")[0].strip().lower() if not language_code: language_code = get_language() or "en" # 1) Exact match with request language for item in value: if isinstance(item, dict) and item.get("language_code") == language_code: localized_value = _get_localized_item_value(item) if localized_value: return localized_value # 2) Fallback to English for item in value: if isinstance(item, dict) and item.get("language_code") == "en": localized_value = _get_localized_item_value(item) if localized_value: return localized_value # 3) Fallback to first item if value: return _get_localized_item_value(value[0]) return None class ArabicLocalizedField(serializers.Field): """ Extracts the Arabic ('ar') language from a JSON list, or falls back to the last item in the list if 'ar' is not found. """ def to_representation(self, value): if not value: return None if isinstance(value, str): return value if not isinstance(value, list): return _get_localized_item_value(value) for item in value: if isinstance(item, dict) and item.get("language_code") == "ar": localized_value = _get_localized_item_value(item) if localized_value: return localized_value if value: return _get_localized_item_value(value[-1]) return None class SimpleCategory(serializers.ModelSerializer): title = LocalizedField() description = LocalizedField() sect_type = serializers.CharField(source='sect.sect_type', read_only=True) ancestors = serializers.SerializerMethodField() class Meta: model = HadisCategory fields = ['id', 'title', 'slug', 'is_topic', 'source_type', 'sect_type', 'description', 'ancestors'] def get_ancestors(self, obj): if not obj: return [] request = self.context.get('request') ancestors_qs = obj.get_ancestors(include_self=False).select_related('sect') result = [] for a in ancestors_qs: result.append({ "id": a.id, "title": get_localized_text(a.title, request=request) or a.slug, "slug": a.slug, "is_topic": getattr(a, "is_topic", False), "source_type": a.source_type if getattr(a, "is_topic", False) else None, "sect_type": a.sect.sect_type if a.sect else None, "has_hadis": getattr(a, "is_topic", False), }) return result class HadisCategorySectListSerializer(serializers.ModelSerializer): """Serializer for HadisSect list with grouped response""" source_types = serializers.SerializerMethodField() title = LocalizedField() class Meta: model = HadisSect fields = ['id','sect_type', 'title','order', 'description', 'source_types'] def get_source_types(self, obj): """Get unique source types for this sect's categories""" source_types = HadisCategory.objects.filter( sect=obj ).values_list('source_type', flat=True) # Use set to ensure uniqueness, then convert back to list return list(set(source_types)) class HadisCategoryTreeSerializer(serializers.ModelSerializer): title = LocalizedField() class Meta: model = HadisCategory fields = ['id', 'title', 'source_type'] class HadisCategorySelectSerializer(serializers.ModelSerializer): """Serializer for HadisCategory Selection Flow""" sect_id = serializers.IntegerField(source='sect.id', read_only=True) sect_type = serializers.CharField(source='sect.sect_type', read_only=True) # children = serializers.SerializerMethodField() children_count = serializers.SerializerMethodField() has_hadis = serializers.SerializerMethodField() hadis_count= serializers.SerializerMethodField() has_parent = serializers.SerializerMethodField() title = LocalizedField() description =LocalizedField() class Meta: model = HadisCategory fields = ['id', 'title', 'is_topic', 'source_type', 'slug', 'sect_id', 'sect_type', 'description', 'children_count', 'has_hadis', 'hadis_count', 'has_parent', 'share_link', 'xmind_share_link'] def get_has_parent(self, obj): return obj.parent_id is not None def get_has_hadis(self, obj): """Check if category can have hadis (no active children) and has hadis""" # Check if category has active children has_active_children = obj.get_children().filter(sect=obj.sect).exists() # If has active children, cannot have hadis if has_active_children: return False if hasattr(obj, 'active_hadis_count'): return obj.active_hadis_count > 0 # If no active children, check if has hadis from django.db.models import Q return Hadis.objects.filter(Q(category=obj) | Q(categories=obj), status=True).exists() def get_children_count(self, obj): if hasattr(obj, 'total_content_count'): return obj.total_content_count from django.db.models import Q family_tree = obj.get_descendants(include_self=True) return Hadis.objects.filter( Q(category__in=family_tree) | Q(categories__in=family_tree), status=True ).distinct().count() def get_hadis_count(self, obj): if hasattr(obj, 'active_hadis_count'): return obj.active_hadis_count from django.db.models import Q return Hadis.objects.filter(Q(category=obj) | Q(categories=obj), status=True).distinct().count() class HadisCategorySelectSourceSerializer(serializers.ModelSerializer): """Serializer for HadisCategory Selection Flow""" sect_id = serializers.IntegerField(source='sect.id', read_only=True) sect_type = serializers.CharField(source='sect.sect_type', read_only=True) children_count = serializers.SerializerMethodField() has_hadis = serializers.SerializerMethodField() hadis_count = serializers.SerializerMethodField() has_parent = serializers.SerializerMethodField() title = LocalizedField() description = LocalizedField() class Meta: model = HadisCategory fields = ['id', 'title', 'is_topic', 'source_type','slug', 'sect_id', 'sect_type','description','children_count','has_hadis','hadis_count', 'has_parent', 'share_link', 'xmind_share_link'] def get_has_parent(self, obj): return obj.parent_id is not None def get_has_hadis(self, obj): """Check if category can have hadis (no active children) and has hadis""" # Check if category has active children has_active_children = obj.get_children().filter(sect=obj.sect).exists() # If has active children, cannot have hadis if has_active_children: return False if hasattr(obj, 'active_hadis_count'): return obj.active_hadis_count > 0 # If no active children, check if has hadis from django.db.models import Q return Hadis.objects.filter(Q(category=obj) | Q(categories=obj), status=True).exists() def get_children_count(self, obj): if hasattr(obj, 'total_content_count'): return obj.total_content_count from django.db.models import Q family_tree = obj.get_descendants(include_self=True) return Hadis.objects.filter( Q(category__in=family_tree) | Q(categories__in=family_tree), status=True ).distinct().count() def get_hadis_count(self, obj): if hasattr(obj, 'active_hadis_count'): return obj.active_hadis_count from django.db.models import Q return Hadis.objects.filter(Q(category=obj) | Q(categories=obj), status=True).distinct().count() class CategorySerializer(serializers.ModelSerializer): sect_id = serializers.IntegerField(source='sect.id', read_only=True) sect_type = serializers.CharField(source='sect.sect_type', read_only=True) children_count = serializers.SerializerMethodField() has_hadis =serializers.SerializerMethodField() hadis_count=serializers.SerializerMethodField() has_parent = serializers.SerializerMethodField() title = LocalizedField() description = LocalizedField() class Meta: model = HadisCategory fields = ['id', 'title', 'sect_id', 'sect_type', 'is_topic', 'source_type', 'description','slug', 'children_count','has_hadis','hadis_count', 'has_parent', 'share_link', 'xmind_share_link'] def get_has_parent(self, obj): return obj.parent_id is not None def get_children_count(self, obj): if hasattr(obj, 'total_content_count'): return obj.total_content_count from django.db.models import Q family_tree = obj.get_descendants(include_self=True) return Hadis.objects.filter( Q(category__in=family_tree) | Q(categories__in=family_tree), status=True ).distinct().count() def get_has_hadis(self, obj): if hasattr(obj, 'active_hadis_count'): return obj.active_hadis_count > 0 from django.db.models import Q return Hadis.objects.filter(Q(category=obj) | Q(categories=obj), status=True).exists() def get_hadis_count(self, obj): if hasattr(obj, 'active_hadis_count'): return obj.active_hadis_count from django.db.models import Q return Hadis.objects.filter(Q(category=obj) | Q(categories=obj), status=True).distinct().count() # def get_title(self,obj): # # ✅ Get language from request # request = self.context.get('request') # lang = request.query_params.get('lang', 'ru') if request else 'ru' # # ✅ CALL THE MODEL METHOD! # return obj.get_title(lang) from ..models.category import CategoryQuranVerse, QuranSecondaryTranslation from ..models.quran import QuranSurah, QuranAyah, QuranTranslator, QuranAyahTranslation, normalize_quran_lang_code class QuranSecondaryTranslationSerializer(serializers.ModelSerializer): class Meta: model = QuranSecondaryTranslation fields = ['id', 'language_code', 'translation_text', 'translator'] def _resolve_request_lang(request, default="ru") -> str: lang = None if request: query_params = getattr(request, "query_params", None) or getattr(request, "GET", None) if query_params: lang = query_params.get("lang") or query_params.get("language_code") if not lang: lang = getattr(request, "LANGUAGE_CODE", None) if not lang and hasattr(request, "headers"): lang = request.headers.get("Accept-Language") elif not lang and hasattr(request, "META"): lang = request.META.get("HTTP_ACCEPT_LANGUAGE") if lang: lang = lang.split(",")[0].split(";")[0].split("-")[0].strip().lower() return normalize_quran_lang_code(lang or get_language() or default) class CategoryQuranVerseSerializer(serializers.ModelSerializer): surah_id = serializers.IntegerField(read_only=True) ayah_id = serializers.IntegerField(read_only=True) ayah_to_id = serializers.IntegerField(read_only=True) surah_name = serializers.SerializerMethodField() arabic_text = serializers.SerializerMethodField() translation = serializers.SerializerMethodField() translator = serializers.SerializerMethodField() secondary_translations = serializers.SerializerMethodField() def _get_master_translations_for_lang(self, obj, lang: str): """ Returns ordered list of dicts: [{"id": ..., "translator": "...", "text": "..."}] from the Master Quran DB (`QuranAyahTranslation`) for `obj.ayah` (and `obj.ayah_to` if range). """ cache_attr = f"_master_tr_cache_{lang}" if hasattr(obj, cache_attr): return getattr(obj, cache_attr) if not obj.ayah_id: setattr(obj, cache_attr, []) return [] start_ayah = obj.ayah end_ayah = obj.ayah_to is_range = ( start_ayah is not None and end_ayah is not None and end_ayah.surah_id == start_ayah.surah_id and end_ayah.ayah_number > start_ayah.ayah_number ) if not is_range and start_ayah is not None: # Use prefetched translations on `obj.ayah` when available prefetched = getattr(start_ayah, "_prefetched_objects_cache", {}).get("translations") if prefetched is not None: matched = [ tr for tr in prefetched if tr.translator and normalize_quran_lang_code(tr.translator.language_code) == lang and tr.text ] matched.sort(key=lambda t: (t.translator.priority, t.translator_id, t.id)) res = [ { "id": tr.id, "language_code": lang, "translator": tr.translator.get_name(lang), "translation_text": tr.text, } for tr in matched ] setattr(obj, cache_attr, res) return res qs = ( QuranAyahTranslation.objects.filter( ayah_id=obj.ayah_id, translator__language_code=lang, ) .select_related("translator") .order_by("translator__priority", "translator__id", "id") ) res = [ { "id": tr.id, "language_code": lang, "translator": tr.translator.get_name(lang), "translation_text": tr.text, } for tr in qs if tr.text ] setattr(obj, cache_attr, res) return res # Range of ayahs in the same surah qs = ( QuranAyahTranslation.objects.filter( ayah__surah_id=start_ayah.surah_id, ayah__ayah_number__gte=start_ayah.ayah_number, ayah__ayah_number__lte=end_ayah.ayah_number, translator__language_code=lang, ) .select_related("translator", "ayah") .order_by("translator__priority", "translator__id", "ayah__ayah_number") ) grouped = {} order_keys = [] for tr in qs: if not tr.text: continue t_id = tr.translator_id if t_id not in grouped: grouped[t_id] = { "id": tr.id, "language_code": lang, "translator": tr.translator.get_name(lang), "texts": [], } order_keys.append(t_id) grouped[t_id]["texts"].append(f"{tr.text.strip()} ({tr.ayah.ayah_number})") res = [ { "id": grouped[t_id]["id"], "language_code": lang, "translator": grouped[t_id]["translator"], "translation_text": " ".join(grouped[t_id]["texts"]), } for t_id in order_keys ] setattr(obj, cache_attr, res) return res def get_surah_name(self, obj): request = self.context.get("request") lang = _resolve_request_lang(request) if obj.surah_id and obj.surah: name = obj.surah.get_name(lang) if name: return name return get_localized_text(obj.surah_name, request=request, language_code=lang) def get_arabic_text(self, obj): if obj.arabic_text and obj.arabic_text.strip(): return obj.arabic_text if obj.ayah_id and obj.ayah: return obj.ayah.text return "" def get_translation(self, obj): request = self.context.get("request") lang = _resolve_request_lang(request) master_list = self._get_master_translations_for_lang(obj, lang) if master_list: return master_list[0]["translation_text"] return get_localized_text(obj.translation, request=request, language_code=lang) def get_translator(self, obj): request = self.context.get("request") lang = _resolve_request_lang(request) master_list = self._get_master_translations_for_lang(obj, lang) if master_list: return master_list[0]["translator"] return get_localized_text(obj.translator, request=request, language_code=lang) def get_secondary_translations(self, obj): request = self.context.get("request") lang = _resolve_request_lang(request) master_list = self._get_master_translations_for_lang(obj, lang) results = [] seen_translators = set() if master_list: seen_translators.add(master_list[0]["translator"].strip().lower()) for item in master_list[1:]: t_key = item["translator"].strip().lower() seen_translators.add(t_key) results.append(item) # Also include any custom secondary translations not already covered by Master DB prefetched_secs = getattr(obj, "_prefetched_objects_cache", {}).get("secondary_translations") if prefetched_secs is not None: sec_items = [s for s in prefetched_secs if normalize_quran_lang_code(s.language_code) == lang] else: sec_items = list(obj.secondary_translations.filter(language_code=lang)) for sec in sec_items: t_key = (sec.translator or "").strip().lower() if t_key and t_key in seen_translators: continue if sec.translation_text: if t_key: seen_translators.add(t_key) results.append(QuranSecondaryTranslationSerializer(sec).data) return results class Meta: model = CategoryQuranVerse fields = [ "id", "surah_id", "ayah_id", "ayah_to_id", "surah_name", "ayah_number", "arabic_text", "translation", "translator", "secondary_translations", ] class PublicQuranSurahSerializer(serializers.ModelSerializer): name = serializers.SerializerMethodField() def get_name(self, obj): request = self.context.get("request") lang = _resolve_request_lang(request) return obj.get_name(lang) class Meta: model = QuranSurah fields = ["id", "surah_type", "total_verses", "name", "translations"] class PublicQuranAyahSerializer(serializers.ModelSerializer): surah_name = serializers.SerializerMethodField() translations = serializers.SerializerMethodField() def get_surah_name(self, obj): request = self.context.get("request") lang = _resolve_request_lang(request) return obj.surah.get_name(lang) if obj.surah_id and obj.surah else "" def get_translations(self, obj): request = self.context.get("request") lang = _resolve_request_lang(request) prefetched = getattr(obj, "_prefetched_objects_cache", {}).get("translations") if prefetched is not None: items = [ tr for tr in prefetched if tr.translator and normalize_quran_lang_code(tr.translator.language_code) == lang ] items.sort(key=lambda t: (t.translator.priority, t.translator_id, t.id)) else: items = list( obj.translations.filter(translator__language_code=lang) .select_related("translator") .order_by("translator__priority", "translator__id", "id") ) return [ { "id": tr.id, "translator_id": tr.translator_id, "translator": tr.translator.name, "language_code": tr.translator.language_code, "priority": tr.translator.priority, "text": tr.text, } for tr in items ] class Meta: model = QuranAyah fields = ["id", "surah_id", "surah_name", "ayah_number", "text", "translations"]