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

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})"