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.
412 lines
16 KiB
412 lines
16 KiB
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
|
|
def normalize_quran_lang_code(code: str) -> str:
|
|
"""
|
|
Normalizes locale codes like 'ru-RU', 'en-US', 'ar-SA', 'az-AZ', 'tr-TR'
|
|
to the system's 2-letter language codes ('ru', 'en', 'ar', 'az', 'tr').
|
|
"""
|
|
if not code or not isinstance(code, str):
|
|
return "ru"
|
|
cleaned = code.strip().split("-")[0].split("_")[0].lower()
|
|
return cleaned or "ru"
|
|
|
|
|
|
class QuranSurah(models.Model):
|
|
"""
|
|
Master table of the 114 Surahs of the Quran (`surahs`).
|
|
`id` is explicitly 1..114 matching the canonical Surah order.
|
|
"""
|
|
|
|
class SurahType(models.TextChoices):
|
|
MECCAN = "meccan", _("Meccan")
|
|
MEDINAN = "medinan", _("Medinan")
|
|
|
|
id = models.PositiveSmallIntegerField(
|
|
primary_key=True,
|
|
verbose_name=_("Surah Number (1-114)"),
|
|
)
|
|
surah_type = models.CharField(
|
|
max_length=20,
|
|
choices=SurahType.choices,
|
|
default=SurahType.MECCAN,
|
|
db_column="type",
|
|
verbose_name=_("Surah Type"),
|
|
)
|
|
total_verses = models.PositiveSmallIntegerField(
|
|
default=0,
|
|
verbose_name=_("Total Verses"),
|
|
)
|
|
translations = models.JSONField(
|
|
default=list,
|
|
blank=True,
|
|
verbose_name=_("Surah Name Translations"),
|
|
help_text=_('List of {"language_code": "ru", "name": "..."} entries'),
|
|
)
|
|
|
|
class Meta:
|
|
db_table = "quran_surahs"
|
|
ordering = ("id",)
|
|
verbose_name = _("Quran Surah")
|
|
verbose_name_plural = _("Quran Surahs")
|
|
|
|
def __str__(self):
|
|
name = self.get_name("en") or self.get_name("ru") or self.get_name("ar") or f"Surah {self.id}"
|
|
return f"{self.id}. {name}"
|
|
|
|
def get_name(self, lang: str = "ru") -> str:
|
|
target = normalize_quran_lang_code(lang)
|
|
if isinstance(self.translations, list):
|
|
for item in self.translations:
|
|
if isinstance(item, dict):
|
|
item_lang = normalize_quran_lang_code(
|
|
item.get("language_code") or item.get("languages_code") or ""
|
|
)
|
|
if item_lang == target:
|
|
val = item.get("name") or item.get("text") or item.get("title")
|
|
if val:
|
|
return str(val).strip()
|
|
for fallback in ("en", "ru", "ar"):
|
|
for item in self.translations:
|
|
if isinstance(item, dict):
|
|
item_lang = normalize_quran_lang_code(
|
|
item.get("language_code") or item.get("languages_code") or ""
|
|
)
|
|
if item_lang == fallback:
|
|
val = item.get("name") or item.get("text") or item.get("title")
|
|
if val:
|
|
return str(val).strip()
|
|
if self.translations and isinstance(self.translations[0], dict):
|
|
val = (
|
|
self.translations[0].get("name")
|
|
or self.translations[0].get("text")
|
|
or self.translations[0].get("title")
|
|
)
|
|
if val:
|
|
return str(val).strip()
|
|
return f"Surah {self.id}"
|
|
|
|
def to_localized_list(self) -> list:
|
|
"""
|
|
Converts `translations` into standard system JSON format:
|
|
[{"language_code": "ru", "name": "...", "text": "...", "title": "..."}]
|
|
"""
|
|
result = []
|
|
seen = set()
|
|
if isinstance(self.translations, list):
|
|
for item in self.translations:
|
|
if isinstance(item, dict):
|
|
raw_lang = item.get("language_code") or item.get("languages_code") or ""
|
|
if not raw_lang:
|
|
continue
|
|
lang = normalize_quran_lang_code(raw_lang)
|
|
val = str(item.get("name") or item.get("text") or item.get("title") or "").strip()
|
|
if val and lang not in seen:
|
|
seen.add(lang)
|
|
result.append({
|
|
"language_code": lang,
|
|
"name": val,
|
|
"text": val,
|
|
"title": val,
|
|
})
|
|
return result
|
|
|
|
|
|
class QuranAyah(models.Model):
|
|
"""
|
|
Master table of all 6236 Ayahs of the Quran (`ayahs`).
|
|
`id` is a non-autoincrement composite integer:
|
|
ayah_id = surah_id * 100000 + ayah_number
|
|
Example: Surah 2, Ayah 255 -> 200255
|
|
"""
|
|
|
|
id = models.PositiveIntegerField(
|
|
primary_key=True,
|
|
verbose_name=_("Composite Ayah ID (surah_id * 100000 + ayah_number)"),
|
|
)
|
|
surah = models.ForeignKey(
|
|
QuranSurah,
|
|
on_delete=models.CASCADE,
|
|
related_name="ayahs",
|
|
verbose_name=_("Surah"),
|
|
)
|
|
ayah_number = models.PositiveSmallIntegerField(
|
|
db_index=True,
|
|
verbose_name=_("Ayah Number"),
|
|
)
|
|
text = models.TextField(
|
|
verbose_name=_("Arabic Text (Uthmani)"),
|
|
)
|
|
transliteration = models.JSONField(
|
|
default=list,
|
|
blank=True,
|
|
verbose_name=_("Transliteration"),
|
|
help_text=_('List of {"language_code": "ru", "text": "..."} entries'),
|
|
)
|
|
normalized_text = models.TextField(
|
|
blank=True,
|
|
null=True,
|
|
verbose_name=_("Normalized Arabic Text for Search"),
|
|
)
|
|
|
|
class Meta:
|
|
db_table = "quran_ayahs"
|
|
ordering = ("id",)
|
|
unique_together = (("surah", "ayah_number"),)
|
|
indexes = [
|
|
models.Index(fields=["surah", "ayah_number"]),
|
|
]
|
|
verbose_name = _("Quran Ayah")
|
|
verbose_name_plural = _("Quran Ayahs")
|
|
|
|
@staticmethod
|
|
def compute_id(surah_id: int, ayah_number: int) -> int:
|
|
return int(surah_id) * 100000 + int(ayah_number)
|
|
|
|
@staticmethod
|
|
def split_id(ayah_id: int):
|
|
ayah_id = int(ayah_id)
|
|
return ayah_id // 100000, ayah_id % 100000
|
|
|
|
@staticmethod
|
|
def normalize_arabic(text: str, ref: str = "") -> str:
|
|
from utils.text_normalizer import build_search_blob
|
|
return build_search_blob(text or "", ref or "")
|
|
|
|
def get_transliteration(self, lang: str = "ru") -> str:
|
|
target = normalize_quran_lang_code(lang or "ru")
|
|
if isinstance(self.transliteration, str):
|
|
return self.transliteration.strip()
|
|
if isinstance(self.transliteration, dict):
|
|
for k, v in self.transliteration.items():
|
|
if normalize_quran_lang_code(k) == target and v and str(v).strip():
|
|
return str(v).strip()
|
|
if isinstance(self.transliteration, list):
|
|
for item in self.transliteration:
|
|
if isinstance(item, dict):
|
|
item_lang = normalize_quran_lang_code(
|
|
item.get("language_code") or item.get("languages_code") or ""
|
|
)
|
|
if item_lang == target:
|
|
val = item.get("text") or item.get("title") or item.get("name")
|
|
if val and str(val).strip():
|
|
return str(val).strip()
|
|
for fallback in ("ru", "en", "az", "tr"):
|
|
for item in self.transliteration:
|
|
if isinstance(item, dict):
|
|
item_lang = normalize_quran_lang_code(
|
|
item.get("language_code") or item.get("languages_code") or ""
|
|
)
|
|
if item_lang == fallback:
|
|
val = item.get("text") or item.get("title") or item.get("name")
|
|
if val and str(val).strip():
|
|
return str(val).strip()
|
|
for item in self.transliteration:
|
|
if isinstance(item, dict):
|
|
val = item.get("text") or item.get("title") or item.get("name")
|
|
if val and str(val).strip():
|
|
return str(val).strip()
|
|
return ""
|
|
|
|
def to_localized_transliteration_list(self) -> list:
|
|
result = []
|
|
seen = set()
|
|
if isinstance(self.transliteration, list):
|
|
for item in self.transliteration:
|
|
if isinstance(item, dict):
|
|
raw_lang = item.get("language_code") or item.get("languages_code") or ""
|
|
if not raw_lang:
|
|
continue
|
|
lang = normalize_quran_lang_code(raw_lang)
|
|
val = str(item.get("text") or item.get("title") or item.get("name") or "").strip()
|
|
if val and lang not in seen:
|
|
seen.add(lang)
|
|
result.append({
|
|
"language_code": lang,
|
|
"text": val,
|
|
"title": val,
|
|
})
|
|
elif isinstance(self.transliteration, dict):
|
|
for raw_lang, raw_val in self.transliteration.items():
|
|
lang = normalize_quran_lang_code(raw_lang)
|
|
val = str(raw_val or "").strip()
|
|
if val and lang not in seen:
|
|
seen.add(lang)
|
|
result.append({
|
|
"language_code": lang,
|
|
"text": val,
|
|
"title": val,
|
|
})
|
|
elif isinstance(self.transliteration, str) and self.transliteration.strip():
|
|
val = self.transliteration.strip()
|
|
result.append({
|
|
"language_code": "ru",
|
|
"text": val,
|
|
"title": val,
|
|
})
|
|
return result
|
|
|
|
def save(self, *args, **kwargs):
|
|
if self.surah_id and self.ayah_number:
|
|
self.id = self.compute_id(self.surah_id, self.ayah_number)
|
|
elif self.id and not self.surah_id:
|
|
s_id, a_num = self.split_id(self.id)
|
|
self.surah_id = s_id
|
|
self.ayah_number = a_num
|
|
|
|
self.normalized_text = self.normalize_arabic(self.text, f"{self.surah_id}:{self.ayah_number}")
|
|
super().save(*args, **kwargs)
|
|
|
|
def __str__(self):
|
|
return f"{self.surah_id}:{self.ayah_number} (#{self.id})"
|
|
|
|
|
|
class QuranTranslator(models.Model):
|
|
"""
|
|
Master table of Quran translators (`quran_translators`).
|
|
"""
|
|
|
|
name = models.CharField(
|
|
max_length=255,
|
|
verbose_name=_("Translator Name"),
|
|
)
|
|
translations = models.JSONField(
|
|
default=list,
|
|
blank=True,
|
|
verbose_name=_("Translator Name Translations"),
|
|
help_text=_('List of {"language_code": "ru", "name": "..."} entries'),
|
|
)
|
|
language_code = models.CharField(
|
|
max_length=15,
|
|
db_index=True,
|
|
default="ru",
|
|
db_column="lang_code",
|
|
verbose_name=_("Language Code"),
|
|
)
|
|
priority = models.IntegerField(
|
|
default=0,
|
|
db_index=True,
|
|
verbose_name=_("Display Priority"),
|
|
)
|
|
|
|
class Meta:
|
|
db_table = "quran_translators"
|
|
ordering = ("priority", "id")
|
|
verbose_name = _("Quran Translator")
|
|
verbose_name_plural = _("Quran Translators")
|
|
|
|
def get_name(self, lang: str = "") -> str:
|
|
target = normalize_quran_lang_code(lang or self.language_code or "ru")
|
|
if isinstance(self.translations, list):
|
|
for item in self.translations:
|
|
if isinstance(item, dict):
|
|
item_lang = normalize_quran_lang_code(
|
|
item.get("language_code") or item.get("languages_code") or ""
|
|
)
|
|
if item_lang == target:
|
|
val = item.get("name") or item.get("text") or item.get("title")
|
|
if val and str(val).strip():
|
|
return str(val).strip()
|
|
for fallback in (self.language_code, "ru", "en", "ar"):
|
|
fb = normalize_quran_lang_code(fallback or "ru")
|
|
for item in self.translations:
|
|
if isinstance(item, dict):
|
|
item_lang = normalize_quran_lang_code(
|
|
item.get("language_code") or item.get("languages_code") or ""
|
|
)
|
|
if item_lang == fb:
|
|
val = item.get("name") or item.get("text") or item.get("title")
|
|
if val and str(val).strip():
|
|
return str(val).strip()
|
|
for item in self.translations:
|
|
if isinstance(item, dict):
|
|
val = item.get("name") or item.get("text") or item.get("title")
|
|
if val and str(val).strip():
|
|
return str(val).strip()
|
|
return self.name or ""
|
|
|
|
def to_localized_list(self) -> list:
|
|
result = []
|
|
seen = set()
|
|
if isinstance(self.translations, list):
|
|
for item in self.translations:
|
|
if isinstance(item, dict):
|
|
raw_lang = item.get("language_code") or item.get("languages_code") or ""
|
|
if not raw_lang:
|
|
continue
|
|
lang = normalize_quran_lang_code(raw_lang)
|
|
val = str(item.get("name") or item.get("text") or item.get("title") or "").strip()
|
|
if val and lang not in seen:
|
|
seen.add(lang)
|
|
result.append({
|
|
"language_code": lang,
|
|
"name": val,
|
|
"text": val,
|
|
"title": val,
|
|
})
|
|
if not result and self.name:
|
|
lang = normalize_quran_lang_code(self.language_code or "ru")
|
|
result.append({
|
|
"language_code": lang,
|
|
"name": self.name,
|
|
"text": self.name,
|
|
"title": self.name,
|
|
})
|
|
return result
|
|
|
|
def save(self, *args, **kwargs):
|
|
if self.language_code:
|
|
self.language_code = normalize_quran_lang_code(self.language_code)
|
|
# Keep `name` synced with primary localized name and vice-versa
|
|
if isinstance(self.translations, list) and self.translations:
|
|
resolved = self.get_name(self.language_code)
|
|
if resolved:
|
|
self.name = resolved
|
|
elif self.name and not self.translations:
|
|
self.translations = [{
|
|
"language_code": self.language_code or "ru",
|
|
"name": self.name,
|
|
"text": self.name,
|
|
"title": self.name,
|
|
}]
|
|
super().save(*args, **kwargs)
|
|
|
|
def __str__(self):
|
|
return f"{self.get_name(self.language_code)} ({self.language_code})"
|
|
|
|
|
|
class QuranAyahTranslation(models.Model):
|
|
"""
|
|
Master table of Ayah translations (`ayah_translations`).
|
|
Language is determined via `translator.language_code`.
|
|
"""
|
|
|
|
ayah = models.ForeignKey(
|
|
QuranAyah,
|
|
on_delete=models.CASCADE,
|
|
related_name="translations",
|
|
verbose_name=_("Ayah"),
|
|
)
|
|
translator = models.ForeignKey(
|
|
QuranTranslator,
|
|
on_delete=models.CASCADE,
|
|
related_name="ayah_translations",
|
|
verbose_name=_("Translator"),
|
|
)
|
|
text = models.TextField(
|
|
verbose_name=_("Translation Text"),
|
|
)
|
|
|
|
class Meta:
|
|
db_table = "quran_ayah_translations"
|
|
ordering = ("translator__priority", "id")
|
|
unique_together = (("ayah", "translator"),)
|
|
indexes = [
|
|
models.Index(fields=["ayah", "translator"]),
|
|
]
|
|
verbose_name = _("Quran Ayah Translation")
|
|
verbose_name_plural = _("Quran Ayah Translations")
|
|
|
|
def __str__(self):
|
|
return f"{self.ayah_id} - {self.translator.name} ({self.translator.language_code})"
|