You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

678 lines
26 KiB

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 or not getattr(obj, 'parent_id', None):
return []
request = self.context.get('request')
ancestors_list = None
if hasattr(obj, '_state') and 'parent' in obj._state.fields_cache:
chain = []
curr = obj.parent
complete = True
while curr is not None:
chain.append(curr)
if curr.parent_id is None:
break
if hasattr(curr, '_state') and 'parent' in curr._state.fields_cache:
curr = curr.parent
else:
complete = False
break
if complete:
ancestors_list = list(reversed(chain))
if ancestors_list is None:
ancestors_list = obj.get_ancestors(include_self=False).select_related('sect')
result = []
for a in ancestors_list:
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()
transliteration = 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_transliteration(self, obj):
request = self.context.get("request")
lang = _resolve_request_lang(request)
return obj.get_transliteration(lang)
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.get_name(lang),
"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", "transliteration", "translations"]