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
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"]
|