Browse Source

feat(quran): implement Central Quran Database models, admin APIs, and topic verse synchronization

master
Mohsen Taba 3 weeks ago
parent
commit
79e056affc
  1. 819
      apps/hadis/management/commands/import_quran_master.py
  2. 142
      apps/hadis/migrations/0069_quransurah_qurantranslator_remove_hadis_share_link_and_more.py
  3. 18
      apps/hadis/migrations/0070_qurantranslator_translations.py
  4. 1
      apps/hadis/models/__init__.py
  5. 139
      apps/hadis/models/category.py
  6. 333
      apps/hadis/models/quran.py
  7. 277
      apps/hadis/serializers/category.py
  8. 537
      apps/hadis/serializers/serializers_admin.py
  9. 21
      apps/hadis/urls.py
  10. 71
      apps/hadis/views/category.py
  11. 8
      apps/hadis/views/hadis.py
  12. 204
      apps/hadis/views_admin.py

819
apps/hadis/management/commands/import_quran_master.py

@ -0,0 +1,819 @@
# -*- coding: utf-8 -*-
import json
import re
from pathlib import Path
from django.core.management.base import BaseCommand
from django.db import transaction
from apps.hadis.models.quran import (
QuranSurah,
QuranAyah,
QuranTranslator,
QuranAyahTranslation,
normalize_quran_lang_code,
)
from apps.hadis.models.category import CategoryQuranVerse
# Canonical 114 Surahs: (id, type, total_verses, ar_name, en_name, ru_name, az_name, tr_name)
CANONICAL_SURAHS = [
(1, "meccan", 7, "الفاتحة", "Al-Fatihah", "Аль-Фатиха", "əl-Fatihə", "Fâtiha"),
(2, "medinan", 286, "البقرة", "Al-Baqarah", "Аль-Бакара", "əl-Bəqərə", "Bakara"),
(3, "medinan", 200, "آل عمران", "Ali 'Imran", "Али Имран", "Ali-İmran", "Âl-i İmrân"),
(4, "medinan", 176, "النساء", "An-Nisa", "Ан-Ниса", "ən-Nisa", "Nisâ"),
(5, "medinan", 120, "المائدة", "Al-Ma'idah", "Аль-Маида", "əl-Maidə", "Mâide"),
(6, "meccan", 165, "الأنعام", "Al-An'am", "Аль-Анам", "əl-Ənam", "En'âm"),
(7, "meccan", 206, "الأعراف", "Al-A'raf", "Аль-Араф", "əl-Əraf", "A'râf"),
(8, "medinan", 75, "الأنفال", "Al-Anfal", "Аль-Анфаль", "əl-Ənfal", "Enfâl"),
(9, "medinan", 129, "التوبة", "At-Tawbah", "Ат-Тауба", "ət-Tövbə", "Tevbe"),
(10, "meccan", 109, "يونس", "Yunus", "Юнус", "Yunus", "Yûnus"),
(11, "meccan", 123, "هود", "Hud", "Худ", "Hud", "Hûd"),
(12, "meccan", 111, "يوسف", "Yusuf", "Юсуф", "Yusif", "Yûsuf"),
(13, "medinan", 43, "الرعد", "Ar-Ra'd", "Ар-Раад", "ər-Rəd", "Ra'd"),
(14, "meccan", 52, "إبراهيم", "Ibrahim", "Ибрахим", "İbrahim", "İbrâhîm"),
(15, "meccan", 99, "الحجر", "Al-Hijr", "Аль-Хиджр", "əl-Hicr", "Hicr"),
(16, "meccan", 128, "النحل", "An-Nahl", "Ан-Нахль", "ən-Nəhl", "Nahl"),
(17, "meccan", 111, "الإسراء", "Al-Isra", "Аль-Исра", "əl-İsra", "İsrâ"),
(18, "meccan", 110, "الكهف", "Al-Kahf", "Аль-Кахф", "əl-Kəhf", "Kehf"),
(19, "meccan", 98, "مريم", "Maryam", "Марьям", "Məryəm", "Meryem"),
(20, "meccan", 135, "طه", "Ta-Ha", "Та Ха", "Taha", "Tâhâ"),
(21, "meccan", 112, "الأنبياء", "Al-Anbiya", "Аль-Анбия", "əl-Ənbiya", "Enbiyâ"),
(22, "medinan", 78, "الحج", "Al-Hajj", "Аль-Хадж", "əl-Həcc", "Hac"),
(23, "meccan", 118, "المؤمنون", "Al-Mu'minun", "Аль-Муминун", "əl-Muminun", "Mü'minûn"),
(24, "medinan", 64, "النور", "An-Nur", "Ан-Нур", "ən-Nur", "Nûr"),
(25, "meccan", 77, "الفرقان", "Al-Furqan", "Аль-Фуркан", "əl-Furqan", "Furkân"),
(26, "meccan", 227, "الشعراء", "Ash-Shu'ara", "Аш-Шуара", "əş-Şuəra", "Şuarâ"),
(27, "meccan", 93, "النمل", "An-Naml", "Ан-Намль", "ən-Nəml", "Neml"),
(28, "meccan", 88, "القصص", "Al-Qasas", "Аль-Касас", "əl-Qəsəs", "Kasas"),
(29, "meccan", 69, "العنكبوت", "Al-'Ankabut", "Аль-Анкабут", "əl-Ənkəbut", "Ankebût"),
(30, "meccan", 60, "الروم", "Ar-Rum", "Ар-Рум", "ər-Rum", "Rûm"),
(31, "meccan", 34, "لقمان", "Luqman", "Лукман", "Loğman", "Lokmân"),
(32, "meccan", 30, "السجدة", "As-Sajdah", "Ас-Саджда", "əs-Səcdə", "Secde"),
(33, "medinan", 73, "الأحزاب", "Al-Ahzab", "Аль-Ахзаб", "əl-Əhzab", "Ahzâb"),
(34, "meccan", 54, "سبأ", "Saba", "Саба", "Səba", "Sebe'"),
(35, "meccan", 45, "فاطر", "Fatir", "Фатыр", "Fatir", "Fâtır"),
(36, "meccan", 83, "يس", "Ya-Sin", "Ясин", "Yasin", "Yâsîn"),
(37, "meccan", 182, "الصافات", "As-Saffat", "Ас-Саффат", "əs-Saffat", "Sâffât"),
(38, "meccan", 88, "ص", "Sad", "Сад", "Sad", "Sâd"),
(39, "meccan", 75, "الزمر", "Az-Zumar", "Аз-Зумар", "əz-Zumər", "Zümer"),
(40, "meccan", 85, "غافر", "Ghafir", "Гафир", "Ğafir", "Mü'min (Gâfir)"),
(41, "meccan", 54, "فصلت", "Fussilat", "Фуссылят", "Fussilət", "Fussilet"),
(42, "meccan", 53, "الشورى", "Ash-Shura", "Аш-Шура", "əş-Şura", "Şûrâ"),
(43, "meccan", 89, "الزخرف", "Az-Zukhruf", "Аз-Зухруф", "əz-Zuxruf", "Zuhruf"),
(44, "meccan", 59, "الدخان", "Ad-Dukhan", "Ад-Духан", "əd-Duxan", "Duhân"),
(45, "meccan", 37, "الجاثية", "Al-Jathiyah", "Аль-Джасия", "əl-Casiyə", "Câsiye"),
(46, "meccan", 35, "الأحقاف", "Al-Ahqaf", "Аль-Ахкаф", "əl-Əhqaf", "Ahkâf"),
(47, "medinan", 38, "محمد", "Muhammad", "Мухаммад", "Muhəmməd", "Muhammed"),
(48, "medinan", 29, "الفتح", "Al-Fath", "Аль-Фатх", "əl-Fəth", "Fetih"),
(49, "medinan", 18, "الحجرات", "Al-Hujurat", "Аль-Худжурат", "əl-Hucurat", "Hucurât"),
(50, "meccan", 45, "ق", "Qaf", "Каф", "Qaf", "Kâf"),
(51, "meccan", 60, "الذاريات", "Adh-Dhariyat", "Аз-Зарият", "əz-Zariyat", "Zâriyât"),
(52, "meccan", 49, "الطور", "At-Tur", "Ат-Тур", "ət-Tur", "Tûr"),
(53, "meccan", 62, "النجم", "An-Najm", "Ан-Наджм", "ən-Nəcm", "Necm"),
(54, "meccan", 55, "القمر", "Al-Qamar", "Аль-Камар", "əl-Qəmər", "Kamer"),
(55, "medinan", 78, "الرحمن", "Ar-Rahman", "Ар-Рахман", "ər-Rəhman", "Rahmân"),
(56, "meccan", 96, "الواقعة", "Al-Waqi'ah", "Аль-Вакиа", "əl-Vaqiə", "Vâkıa"),
(57, "medinan", 29, "الحديد", "Al-Hadid", "Аль-Хадид", "əl-Hədid", "Hadîd"),
(58, "medinan", 22, "المجادلة", "Al-Mujadila", "Аль-Муджадиля", "əl-Mucadələ", "Mücâdele"),
(59, "medinan", 24, "الحشر", "Al-Hashr", "Аль-Хашр", "əl-Həşr", "Haşr"),
(60, "medinan", 13, "الممتحنة", "Al-Mumtahanah", "Аль-Мумтахана", "əl-Mumtəhinə", "Mümtehine"),
(61, "medinan", 14, "الصف", "As-Saff", "Ас-Сафф", "əs-Səff", "Saf"),
(62, "medinan", 11, "الجمعة", "Al-Jumu'ah", "Аль-Джумуа", "əl-Cumə", "Cuma"),
(63, "medinan", 11, "المنافقون", "Al-Munafiqun", "Аль-Мунафикун", "əl-Munafiqun", "Münâfikûn"),
(64, "medinan", 18, "التغابن", "At-Taghabun", "Ат-Тагабун", "ət-Təğabun", "Tegâbün"),
(65, "medinan", 12, "الطلاق", "At-Talaq", "Ат-Таляк", "ət-Talaq", "Talâk"),
(66, "medinan", 12, "التحريم", "At-Tahrim", "Ат-Тахрим", "ət-Təhrim", "Tahrîm"),
(67, "meccan", 30, "الملك", "Al-Mulk", "Аль-Мульк", "əl-Mulk", "Mülk"),
(68, "meccan", 52, "القلم", "Al-Qalam", "Аль-Калям", "əl-Qələm", "Kalem"),
(69, "meccan", 52, "الحاقة", "Al-Haqqah", "Аль-Хакка", "əl-Haqqə", "Hâkka"),
(70, "meccan", 44, "المعارج", "Al-Ma'arij", "Аль-Мааридж", "əl-Məaric", "Meâric"),
(71, "meccan", 28, "نوح", "Nuh", "Нух", "Nuh", "Nûh"),
(72, "meccan", 28, "الجن", "Al-Jinn", "Аль-Джинн", "əl-Cinn", "Cin"),
(73, "meccan", 20, "المزمل", "Al-Muzzammil", "Аль-Муззаммиль", "əl-Muzzəmmil", "Müzzemmil"),
(74, "meccan", 56, "المدثر", "Al-Muddaththir", "Аль-Муддассир", "əl-Muddəssir", "Müddessir"),
(75, "meccan", 40, "القيامة", "Al-Qiyamah", "Аль-Кияма", "əl-Qiyamə", "Kıyâmet"),
(76, "medinan", 31, "الإنسان", "Al-Insan", "Аль-Инсан", "əl-İnsan", "İnsân"),
(77, "meccan", 50, "المرسلات", "Al-Mursalat", "Аль-Мурсалят", "əl-Mursəlat", "Mürselât"),
(78, "meccan", 40, "النبأ", "An-Naba", "Ан-Наба", "ən-Nəbə", "Nebe'"),
(79, "meccan", 46, "النازعات", "An-Nazi'at", "Ан-Назиат", "ən-Naziat", "Nâziât"),
(80, "meccan", 42, "عبس", "'Abasa", "Абаса", "Əbəsə", "Abese"),
(81, "meccan", 29, "التكوير", "At-Takwir", "Ат-Таквир", "ət-Təkvir", "Tekvîr"),
(82, "meccan", 19, "الانفطار", "Al-Infitar", "Аль-Инфитар", "əl-İnfitar", "İnfitâr"),
(83, "meccan", 36, "المطففين", "Al-Mutaffifin", "Аль-Мутаффифин", "əl-Mutəffifin", "Mutaffifîn"),
(84, "meccan", 25, "الانشقاق", "Al-Inshiqaq", "Аль-Иншикак", "əl-İnşiqaq", "İnşikâk"),
(85, "meccan", 22, "البروج", "Al-Buruj", "Аль-Бурудж", "əl-Buruc", "Burûc"),
(86, "meccan", 17, "الطارق", "At-Tariq", "Ат-Тарик", "ət-Tariq", "Târık"),
(87, "meccan", 19, "الأعلى", "Al-A'la", "Аль-Аля", "əl-Əla", "A'lâ"),
(88, "meccan", 26, "الغاشية", "Al-Ghashiyah", "Аль-Гашия", "əl-Ğaşiyə", "Gâşiye"),
(89, "meccan", 30, "الفجر", "Al-Fajr", "Аль-Фаджр", "əl-Fəcr", "Fecr"),
(90, "meccan", 20, "البلد", "Al-Balad", "Аль-Баляд", "əl-Bələd", "Beled"),
(91, "meccan", 15, "الشمس", "Ash-Shams", "Аш-Шамс", "əş-Şəms", "Şems"),
(92, "meccan", 21, "الليل", "Al-Layl", "Аль-Ляйль", "əl-Leyl", "Leyl"),
(93, "meccan", 11, "الضحى", "Ad-Duha", "Ад-Духа", "əd-Duha", "Duhâ"),
(94, "meccan", 8, "الشرح", "Ash-Sharh", "Аш-Шарх", "əş-Şərh", "İnşirâh"),
(95, "meccan", 8, "التين", "At-Tin", "Ат-Тин", "ət-Tin", "Tîn"),
(96, "meccan", 19, "العلق", "Al-'Alaq", "Аль-Аляк", "əl-Ələq", "Alak"),
(97, "meccan", 5, "القدر", "Al-Qadr", "Аль-Кадр", "əl-Qədr", "Kadir"),
(98, "medinan", 8, "البينة", "Al-Bayyinah", "Аль-Баййина", "əl-Bəyyinə", "Beyyine"),
(99, "medinan", 8, "الزلزلة", "Az-Zalzalah", "Аз-Зальзаля", "əz-Zəlzələ", "Zilzâl"),
(100, "meccan", 11, "العاديات", "Al-'Adiyat", "Аль-Адият", "əl-Adiyat", "Âdiyât"),
(101, "meccan", 11, "القارعة", "Al-Qari'ah", "Аль-Кариа", "əl-Qariə", "Kâria"),
(102, "meccan", 8, "التكاثر", "At-Takathur", "Ат-Такасур", "ət-Təkasur", "Tekâsür"),
(103, "meccan", 3, "العصر", "Al-'Asr", "Аль-Аср", "əl-Əsr", "Asr"),
(104, "meccan", 9, "الهمزة", "Al-Humazah", "Аль-Хумаза", "əl-Huməzə", "Hümeze"),
(105, "meccan", 5, "الفيل", "Al-Fil", "Аль-Филь", "əl-Fil", "Fîl"),
(106, "meccan", 4, "قريش", "Quraysh", "Курайш", "Qureyş", "Kureyş"),
(107, "meccan", 7, "الماعون", "Al-Ma'un", "Аль-Маун", "əl-Maun", "Mâûn"),
(108, "meccan", 3, "الكوثر", "Al-Kawthar", "Аль-Каусар", "əl-Kövsər", "Kevser"),
(109, "meccan", 6, "الكافرون", "Al-Kafirun", "Аль-Кафирун", "əl-Kafirun", "Kâfirûn"),
(110, "medinan", 3, "النصر", "An-Nasr", "Ан-Наср", "ən-Nəsr", "Nasr"),
(111, "meccan", 5, "المسد", "Al-Masad", "Аль-Масад", "əl-Məsəd", "Tebbet (Mesed)"),
(112, "meccan", 4, "الإخلاص", "Al-Ikhlas", "Аль-Ихляс", "əl-İxlas", "İhlâs"),
(113, "meccan", 5, "الفلق", "Al-Falaq", "Аль-Фаляк", "əl-Fələq", "Felak"),
(114, "meccan", 6, "الناس", "An-Nas", "Ан-Нас", "ən-Nas", "Nâs"),
]
class Command(BaseCommand):
help = (
"Seeds the 114 canonical Surahs into the Master Quran Database, "
"syncs existing CategoryQuranVerse records, and optionally imports "
"full Quran JSON datasets (surahs, ayahs, translators, translations)."
)
def add_arguments(self, parser):
parser.add_argument(
"--surahs-file",
type=str,
default=None,
help="Path to JSON file containing surahs (or nested surahs+verses).",
)
parser.add_argument(
"--ayahs-file",
type=str,
default=None,
help="Path to JSON file containing ayahs (array or flat '1:1' dictionary).",
)
parser.add_argument(
"--translators-file",
type=str,
default=None,
help="Path to JSON file containing quran_translators.",
)
parser.add_argument(
"--translations-file",
type=str,
default=None,
help="Path to JSON file containing ayah_translations.",
)
parser.add_argument(
"--sync-existing-topics",
action="store_true",
default=True,
help="Sync existing CategoryQuranVerse topic records into Master Quran DB.",
)
def handle(self, *args, **options):
with transaction.atomic():
self._seed_canonical_surahs()
self._seed_default_translators_and_key_ayahs()
if options.get("surahs_file"):
self._import_surahs_file(options["surahs_file"])
if options.get("ayahs_file"):
self._import_ayahs_file(options["ayahs_file"])
if options.get("translators_file"):
self._import_translators_file(options["translators_file"])
if options.get("translations_file"):
self._import_translations_file(options["translations_file"])
if options.get("sync_existing_topics"):
self._sync_existing_topic_verses()
self.stdout.write(
self.style.SUCCESS(
f"Master Quran DB Summary: "
f"{QuranSurah.objects.count()} Surahs, "
f"{QuranAyah.objects.count()} Ayahs, "
f"{QuranTranslator.objects.count()} Translators, "
f"{QuranAyahTranslation.objects.count()} Translations."
)
)
def _seed_canonical_surahs(self):
surahs_to_upsert = []
for s_id, s_type, total_v, ar, en, ru, az, tr in CANONICAL_SURAHS:
translations = [
{"language_code": "ru", "name": ru, "text": ru, "title": ru},
{"language_code": "en", "name": en, "text": en, "title": en},
{"language_code": "ar", "name": ar, "text": ar, "title": ar},
{"language_code": "az", "name": az, "text": az, "title": az},
{"language_code": "tr", "name": tr, "text": tr, "title": tr},
]
surahs_to_upsert.append(
QuranSurah(
id=s_id,
surah_type=s_type,
total_verses=total_v,
translations=translations,
)
)
QuranSurah.objects.bulk_create(
surahs_to_upsert,
update_conflicts=True,
unique_fields=["id"],
update_fields=["surah_type", "total_verses", "translations"],
)
self.stdout.write(f"Canonical Surahs seeded: {len(surahs_to_upsert)} upserted.")
def _seed_default_translators_and_key_ayahs(self):
"""
Seeds standard translators across 5 languages and key Quranic argument verses
so the admin can test selecting verses & seeing multiple translations immediately.
"""
default_translators = [
("Эльмир Кулиев", "ru", 1),
("Абу Адель", "ru", 2),
("И. Ю. Крачковский", "ru", 3),
("Sahih International", "en", 1),
("Ali Quli Qarai", "en", 2),
("التفسير الميسر", "ar", 1),
("Əlixan Musayev", "az", 1),
("Ziya Bünyadov & Vasim Məmmədəliyev", "az", 2),
("Diyanet İşleri", "tr", 1),
("Elmalılı Hamdi Yazır", "tr", 2),
]
existing_tr = {(t.name, t.language_code): t for t in QuranTranslator.objects.all()}
new_tr = []
for name, lang, prio in default_translators:
if (name, lang) not in existing_tr:
new_tr.append(QuranTranslator(name=name, language_code=lang, priority=prio))
if new_tr:
QuranTranslator.objects.bulk_create(new_tr, ignore_conflicts=True)
translator_map = {(t.name, t.language_code): t for t in QuranTranslator.objects.all()}
key_ayahs = [
(
1,
1,
"بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ",
{
("Эльмир Кулиев", "ru"): "Во имя Аллаха, Милостивого, Милосердного!",
("Абу Адель", "ru"): "С именем Аллаха, Милостивого, Милосердного!",
("Sahih International", "en"): "In the name of Allah, the Entirely Merciful, the Especially Merciful.",
("Ali Quli Qarai", "en"): "In the Name of Allah, the All-beneficent, the All-merciful.",
("Əlixan Musayev", "az"): "Mərhəmətli və Rəhmli Allahın adı ilə!",
("Diyanet İşleri", "tr"): "Rahmân ve Rahîm olan Allah'ın adıyla.",
},
),
(
2,
255,
"اللَّهُ لَا إِلَٰهَ إِلَّا هُوَ الْحَيُّ الْقَيُّومُ ۚ لَا تَأْخُذُهُ سِنَةٌ وَلَا نَوْمٌ ۚ لَهُ مَا فِي السَّمَاوَاتِ وَمَا فِي الْأَرْضِ ۗ مَنْ ذَا الَّذِي يَشْفَعُ عِنْدَهُ إِلَّا بِإِذْنِهِ ۚ يَعْلَمُ مَا بَيْنَ أَيْدِيهِمْ وَمَا خَلْفَهُمْ ۖ وَلَا يُحِيطُونَ بِشَيْءٍ مِنْ عِلْمِهِ إِلَّا بِمَا شَاءَ ۚ وَسِعَ كُرْسِيُّهُ السَّمَاوَاتِ وَالْأَرْضَ ۖ وَلَا يَئُودُهُ حِفْظُهُمَا ۚ وَهُوَ الْعَلِيُّ الْعَظِيمُ",
{
("Эльмир Кулиев", "ru"): "Аллах — нет божества, кроме Него, Живого, Поддерживающего жизнь. Им не овладевают ни дремота, ни сон. Ему принадлежит то, что на небесах, и то, что на земле. Кто станет заступаться перед Ним без Его дозволения? Он знает их будущее и прошлое. Они постигают из Его знания только то, что Он пожелает. Его Престол объемлет небеса и землю, и не тяготит Его оберегание их. Он — Возвышенный, Великий.",
("Абу Адель", "ru"): "Аллах – нет божества, кроме Него, Живого, Вседержителя. Не овладевает Им ни дремота, ни сон. Ему принадлежит то, что в небесах, и то, что на земле. Кто заступится пред Ним, иначе как с Его дозволения? Он знает то, что было до них, и то, что будет после них. И они не постигают ничего из Его знания, кроме того, что Он пожелает. Трон Его объемлет небеса и землю, и не тяготит Его охрана их. И Он – Возвышенный, Великий!",
("Sahih International", "en"): "Allah - there is no deity except Him, the Ever-Living, the Sustainer of [all] existence. Neither drowsiness overtakes Him nor sleep. To Him belongs whatever is in the heavens and whatever is on the earth. Who is it that can intercede with Him except by His permission? He knows what is [presently] before them and what will be after them, and they encompass not a thing of His knowledge except for what He wills. His Kursi extends over the heavens and the earth, and their preservation tires Him not. And He is the Most High, the Most Great.",
("Əlixan Musayev", "az"): "Allah, Ondan başqa ibadətə layiq olan məbud yoxdur, əbədi Yaşayandır, bütün yaratdıqlarının Qəyyumudur. Onu nə mürgü, nə də yuxu tutar. Göylərdə və yerdə nə varsa, Ona məxsusdur. Onun izni olmadan Onun yanında kim havadarlıq edə bilər? O, məxluqatın gələcəyini və keçmişini bilir. Onlar Onun elmindən, Özünün istədiyindən başqa heç bir şey qavraya bilməzlər. Onun Kürsüsü göyləri və yeri əhatə edir. Bunları qoruyub saxlamaq Ona ağır gəlmir. O, Ucadır, Uludur.",
("Diyanet İşleri", "tr"): "Allah, kendisinden başka hiçbir ilâh olmayandır. Diridir, kayyumdur. O’nu ne bir uyuklama tutabilir, ne de bir uyku. Göklerdeki her şey, yerdeki her şey O’nundur. İzni olmaksızın O’nun katında şefaatte bulunacak kimdir? O, kulların önlerindekileri ve arkalarındekileri bilir. Onlar O’nun ilminden, kendisinin dilediği kadarından başka bir şey kavrayamazlar. O’nun kürsüsü, bütün gökleri ve yeri kaplayıp kuşatmıştır. Gökleri ve yeri koruyup gözetmek O’na güç gelmez. O, yücedir, büyüktür.",
},
),
(
3,
61,
"فَمَنْ حَاجَّكَ فِيهِ مِنْ بَعْدِ مَا جَاءَكَ مِنَ الْعِلْمِ فَقُلْ تَعَالَوْا نَدْعُ أَبْنَاءَنَا وَأَبْنَاءَكُمْ وَنِسَاءَنَا وَنِسَاءَكُمْ وَأَنْفُسَنَا وَأَنْفُسَكُمْ ثُمَّ نَبْتَهِلْ فَنَجْعَلْ لَعْنَتَ اللَّهِ عَلَى الْكَاذِبِينَ",
{
("Эльмир Кулиев", "ru"): "Тому, кто станет препираться с тобой относительно него после того, что к тебе явилось из знания, скажи: «Давайте призовем наших сыновей и ваших сыновей, наших женщин и ваших женщин, нас самих и вас самих, а затем помолимся и призовем проклятие Аллаха на лжецов!»",
("Абу Адель", "ru"): "А кто станет препираться с тобой относительно него после того, как пришло к тебе знание, то скажи: «Давайте призовем наших сыновей и ваших сыновей, наших женщин и ваших женщин, нас самих и вас самих, а потом обратимся с мольбой и призовем проклятие Аллаха на лжецов!»",
("Ali Quli Qarai", "en"): "Should anyone argue with you concerning him, after the knowledge that has come to you, say, ‘Come! Let us call our sons and your sons, our women and your women, our souls and your souls, then let us pray earnestly and call down Allah’s curse upon the liars.’",
("Əlixan Musayev", "az"): "Sənə bilik gəldikdən sonra kim səninlə İsanın barəsində mübahisə edərsə, de: “Gəlin oğullarımızı və oğullarınızı, qadınlarımızı və qadınlarınızı, özümüzü və özünüzü çağıraq, sonra isə dua edib yalançılara Allahın lənətini diləyək”.",
("Diyanet İşleri", "tr"): "Sana bilgi geldikten sonra kim seninle onun hakkında tartışırsa de ki: “Gelin, oğullarımızı ve oğullarınızı, kadınlarımızı ve kadınlarınızı, kendimizi ve kendinizi çağıralım, sonra da gönülden dua edelim de Allah’ın lanetini yalancıların üzerine kılalım.”",
},
),
(
4,
59,
"يَا أَيُّهَا الَّذِينَ آمَنُوا أَطِيعُوا اللَّهَ وَأَطِيعُوا الرَّسُولَ وَأُولِي الْأَمْرِ مِنْكُمْ ۖ فَإِنْ تَنَازَعْتُمْ فِي شَيْءٍ فَرُدُّوهُ إِلَى اللَّهِ وَالرَّسُولِ إِنْ كُنْتُمْ تُؤْمِنُونَ بِاللَّهِ وَالْيَوْمِ الْآخِرِ ۚ ذَٰلِكَ خَيْرٌ وَأَحْسَنُ تَأْوِيلًا",
{
("Эльмир Кулиев", "ru"): "О те, которые уверовали! Повинуйтесь Аллаху, повинуйтесь Посланнику и обладающим влиянием среди вас. Если же вы станете препираться о чем-нибудь, то обратитесь с этим к Аллаху и Посланнику, если вы веруете в Аллаха и Последний день. Так будет лучше и прекраснее по значению!",
("Абу Адель", "ru"): "О вы, которые уверовали! Повинуйтесь Аллаху и повинуйтесь Посланнику и обладателям власти среди вас. А если вы препираетесь о чем-нибудь, то верните это Аллаху и Посланнику, если вы веруете в Аллаха и в Последний день. Это – лучше и прекраснее по исходу.",
("Ali Quli Qarai", "en"): "O you who have faith! Obey Allah and obey the Apostle and those vested with authority among you. And if you dispute concerning anything, refer it to Allah and the Apostle, if you have faith in Allah and the Last Day. That is better and more favourable in outcome.",
("Əlixan Musayev", "az"): "Ey iman gətirənlər! Allaha və Elçisinə itaət edin, həmçinin özünüzdən olan rəhbərlərə də. Əgər bir şey haqqında mübahisə etsəniz, Allaha və Axirət gününə inanırsınızsa, onu Allaha və Onun Elçisinə həvalə edin. Bu daha xeyirli və nəticə etibarilə daha yaxşıdır.",
("Diyanet İşleri", "tr"): "Ey iman edenler! Allah’a itaat edin. Peygamber’e itaat edin ve sizden olan ulu’l-emre (idarecilere) de. Herhangi bir hususta anlaşmazlığa düştüğünüz takdirde, Allah’a ve ahiret gününe gerçekten inanıyorsanız, onu Allah ve Resûlüne arz edin. Bu, daha iyidir, sonuç bakımından da daha güzeldir.",
},
),
(
5,
55,
"إِنَّمَا وَلِيُّكُمُ اللَّهُ وَرَسُولُهُ وَالَّذِينَ آمَنُوا الَّذِينَ يُقِيمُونَ الصَّلَاةَ وَيُؤْتُونَ الزَّكَاةَ وَهُمْ رَاكِعُونَ",
{
("Эльмир Кулиев", "ru"): "Вашим Покровителем является только Аллах, Его Посланник и верующие, которые совершают намаз, выплачивают закят и преклоняются.",
("Абу Адель", "ru"): "Поистине, вашим Покровителем является только Аллах, и Его Посланник, и те, которые уверовали, которые совершают молитву и дают закят, преклоняясь (в поясном поклоне).",
("Ali Quli Qarai", "en"): "Your guardian is only Allah, His Apostle, and the faithful who maintain the prayer and give the zakat while bowing down.",
("Əlixan Musayev", "az"): "Sizin himayədarınız yalnız Allah, Onun Elçisi və iman gətirənlərdir. O kəslər ki, namaz qılır və rükuda olduqları halda zəkat verirlər.",
("Diyanet İşleri", "tr"): "Sizin dostunuz (veliniz) ancak Allah’tır, Resûlüdür ve Allah’ın emirlerine boyun eğerek namazı kılan, zekâtı veren mü’minlerdir (rükû ederken zekât verenlerdir).",
},
),
(
5,
67,
"يَا أَيُّهَا الرَّسُولُ بَلِّغْ مَا أُنْزِلَ إِلَيْكَ مِنْ رَبِّكَ ۖ وَإِنْ لَمْ تَفْعَلْ فَمَا بَلَّغْتَ رِسَالَتَهُ ۚ وَاللَّهُ يَعْصِمُكَ مِنَ النَّاسِ ۗ إِنَّ اللَّهَ لَا يَهْدِي الْقَوْمَ الْكَافِرِينَ",
{
("Эльмир Кулиев", "ru"): "О Посланник! Возвести то, что ниспослано тебе от твоего Господа. Если ты не сделаешь этого, то не донесешь Его послания. Аллах защитит тебя от людей. Воистину, Аллах не наставляет на прямой путь неверующих людей.",
("Абу Адель", "ru"): "О Посланник! Передай то, что ниспослано тебе от твоего Господа. А если ты не сделаешь этого, то ты не передашь Его послания. И Аллах защитит тебя от людей. Поистине, Аллах не ведет прямым путем неверующих людей!",
("Ali Quli Qarai", "en"): "O Apostle! Communicate that which has been sent down to you from your Lord, and if you do not, you will not have communicated His message, and Allah shall protect you from the people. Indeed Allah does not guide the faithless lot.",
("Əlixan Musayev", "az"): "Ey Elçi! Rəbbindən sənə nazil ediləni təbliğ et! Əgər belə etməsən, Onun risalətini çatdırmamış olarsan. Allah səni insanlardan qoruyar. Şübhəsiz ki, Allah kafir camaatı doğru yola yönəltməz.",
("Diyanet İşleri", "tr"): "Ey Peygamber! Rabbinden sana indirileni tebliğ et. Eğer bunu yapmazsan, O’nun verdiği peygamberlik görevini yerine getirmemiş olursun. Allah, seni insanlardan korur. Şüphesiz Allah, kâfirler topluluğunu hidayete erdirmez.",
},
),
(
33,
33,
"وَقَرْنَ فِي بُيُوتِكُنَّ وَلَا تَبَرَّجْنَ تَبَرُّجَ الْجَاهِلِيَّةِ الْأُولَىٰ ۖ وَأَقِمْنَ الصَّلَاةَ وَآتِينَ الزَّكَاةَ وَأَطِعْنَ اللَّهَ وَرَسُولَهُ ۚ إِنَّمَا يُرِيدُ اللَّهُ لِيُذْهِبَ عَنْكُمُ الرِّجْسَ أَهْلَ الْبَيْتِ وَيُطَهِّرَكُمْ تَطْهِيرًا",
{
("Эльмир Кулиев", "ru"): "Пребывайте в своих домах, не наряжайтесь так, как наряжались во времена первого невежества, совершайте намаз, раздавайте закят и повинуйтесь Аллаху и Его Посланнику. О обитатели дома! Аллах желает лишь избавить вас от скверны и очистить вас полностью.",
("Абу Адель", "ru"): "И пребывайте в своих домах, и не выставляйте себя напоказ, как выставляли себя во времена первого невежества, совершайте молитву, давайте закят и повинуйтесь Аллаху и Его Посланнику. Поистине, Аллах желает только избавить вас от скверны, о люди дома (Пророка), и очистить вас полным очищением!",
("Ali Quli Qarai", "en"): "Stay in your houses and do not display your finery with the display of the former [days of] ignorance. Maintain the prayer and pay the zakat, and obey Allah and His Apostle. Indeed Allah desires to repel all impurity from you, O People of the Household, and purify you with a thorough purification.",
("Əlixan Musayev", "az"): "Evlərinizdə qərar tutun! İlkin cahiliyyə dövründə olduğu kimi açıq-saçıq gəzməyin. Namaz qılın, zəkat verin, Allaha və Onun Elçisinə itaət edin. Ey Əhli-beyt! Allah sizdən çirkinliyi gidermək və sizi pak etmək istəyir!",
("Diyanet İşleri", "tr"): "Evlerinizde oturun. Önceki cahiliye dönemi kadınlarının açılıp saçıldığı gibi siz de açılıp saçılmayın. Namazı kılın, zekâtı verin. Allah’a ve Resûlüne itaat edin. Ey Peygamberin ev halkı (Ehl-i Beyt)! Allah, sizden ancak günahı gidermek ve sizi tertemiz yapmak istiyor.",
},
),
(
42,
23,
"ذَٰلِكَ الَّذِي يُبَشِّرُ اللَّهُ عِبَادَهُ الَّذِينَ آمَنُوا وَعَمِلُوا الصَّالِحَاتِ ۗ قُلْ لَا أَسْأَلُكُمْ عَلَيْهِ أَجْرًا إِلَّا الْمَوَدَّةَ فِي الْقُرْبَىٰ ۗ وَمَنْ يَقْتَرِفْ حَسَنَةً نَزِدْ لَهُ فِيهَا حُسْنًا ۚ إِنَّ اللَّهَ غَفُورٌ شَكُورٌ",
{
("Эльмир Кулиев", "ru"): "Такова благая весть, которую Аллах возвещает Своим рабам, которые уверовали и совершали праведные деяния. Скажи: «Я не прошу у вас за это никакого вознаграждения, кроме любви к ближним». Кто совершит доброе дело, тому Мы увеличим его добро. Воистину, Аллах — Прощающий, Благодарный.",
("Абу Адель", "ru"): "Это – то, чем радует Аллах Своих рабов, которые уверовали и творили праведные деяния. Скажи (о Пророк): «Я не прошу у вас за это награды, кроме любви к (моим) близким». И кто приобретет доброе деяние, тому Мы прибавим в этом благого. Поистине, Аллах – Прощающий, Благодарный!",
("Ali Quli Qarai", "en"): "That is the good news Allah gives to His servants who have faith and do righteous deeds! Say, ‘I do not ask you any reward for it except love of [my] relatives.’ Whoever performs a good deed, We shall enhance for him its goodness. Indeed Allah is all-forgiving, all-appreciative.",
("Əlixan Musayev", "az"): "Allah iman gətirib yaxşı işlər görən qullarına bununla müjdə verir. De: “Mən sizdən bunun əvəzində qohumluq sevgisindən başqa bir şey istəmirəm”. Kim bir yaxşılıq etsə, onun savabını artırarıq. Həqiqətən, Allah Bağışlayandır, Şükrün əvəzini verəndir.",
("Diyanet İşleri", "tr"): "İşte Allah, iman eden ve salih ameller işleyen kullarına bunu müjdeler. De ki: “Ben buna karşılık sizden akrabalık sevgisinden başka bir ücret istemiyorum.” Kim bir iyilik işlerse, onun sevabını fazlasıyla veririz. Şüphesiz Allah, çok bağışlayandır, şükrün karşılığını verendir.",
},
),
]
ayah_objs = []
trans_objs = []
for s_id, a_num, ar_text, tr_dict in key_ayahs:
a_id = QuranAyah.compute_id(s_id, a_num)
ayah_objs.append(
QuranAyah(
id=a_id,
surah_id=s_id,
ayah_number=a_num,
text=ar_text,
normalized_text=QuranAyah.normalize_arabic(ar_text),
)
)
for (t_name, t_lang), t_text in tr_dict.items():
t_obj = translator_map.get((t_name, t_lang))
if t_obj:
trans_objs.append(
QuranAyahTranslation(
ayah_id=a_id,
translator_id=t_obj.id,
text=t_text,
)
)
QuranAyah.objects.bulk_create(
ayah_objs,
update_conflicts=True,
unique_fields=["id"],
update_fields=["surah_id", "ayah_number", "text", "normalized_text"],
)
QuranAyahTranslation.objects.bulk_create(
trans_objs,
update_conflicts=True,
unique_fields=["ayah", "translator"],
update_fields=["text"],
)
def _match_surah_by_name(self, surah_names_json, all_surahs=None) -> QuranSurah:
"""
Matches a CategoryQuranVerse `surah_name` JSON list against the 114 Surahs.
"""
if all_surahs is None:
all_surahs = list(QuranSurah.objects.all())
by_id = {s.id: s for s in all_surahs}
candidates = []
if isinstance(surah_names_json, list):
for entry in surah_names_json:
if isinstance(entry, dict):
val = str(entry.get("text") or entry.get("title") or entry.get("name") or "").strip()
if val:
candidates.append(val)
elif isinstance(surah_names_json, str) and surah_names_json.strip():
candidates.append(surah_names_json.strip())
if not candidates:
return None
# Check if any candidate contains a surah number
for c in candidates:
m = re.search(r"\b(\d{1,3})\b", c)
if m:
num = int(m.group(1))
if 1 <= num <= 114 and num in by_id:
return by_id[num]
def norm(s: str) -> str:
return re.sub(r"[\s\-_'`’ʻʼ«»\".,()]+", "", s.lower())
norm_candidates = [norm(c) for c in candidates if norm(c)]
# Exact normalized match
for surah in all_surahs:
for item in (surah.translations or []):
if isinstance(item, dict):
s_name = norm(str(item.get("name") or item.get("text") or ""))
if s_name and s_name in norm_candidates:
return surah
# Substring match
for surah in all_surahs:
for item in (surah.translations or []):
if isinstance(item, dict):
s_name = norm(str(item.get("name") or item.get("text") or ""))
if len(s_name) >= 3:
for cand in norm_candidates:
if s_name in cand or cand in s_name:
return surah
return None
def _sync_existing_topic_verses(self):
"""
Reads existing CategoryQuranVerse rows and ensures their Ayah, Translators,
and Translations exist in the Master Quran DB and are linked via FK using bulk queries.
"""
all_surahs = list(QuranSurah.objects.all())
verses = list(
CategoryQuranVerse.objects.select_related("surah", "ayah", "ayah_to")
.prefetch_related("secondary_translations")
)
if not verses:
self.stdout.write("Synced 0 existing CategoryQuranVerse records.")
return
existing_ayahs = {a.id: a for a in QuranAyah.objects.all()}
ayahs_to_upsert = {}
new_translators = {}
parsed_rows = []
for cv in verses:
surah = cv.surah or self._match_surah_by_name(cv.surah_name, all_surahs=all_surahs)
if not surah:
continue
raw_num = str(cv.ayah_number or "").strip()
nums = [int(p) for p in re.findall(r"\d+", raw_num) if p.isdigit()]
if not nums:
continue
first_num = nums[0]
end_num = nums[-1] if len(nums) > 1 and nums[-1] > first_num else first_num
if not (1 <= first_num <= surah.total_verses):
continue
ayah_id = QuranAyah.compute_id(surah.id, first_num)
ar_txt = (cv.arabic_text or "").strip()
if ayah_id not in existing_ayahs or (ar_txt and not existing_ayahs[ayah_id].text):
ayahs_to_upsert[ayah_id] = QuranAyah(
id=ayah_id,
surah_id=surah.id,
ayah_number=first_num,
text=ar_txt or (existing_ayahs[ayah_id].text if ayah_id in existing_ayahs else ""),
normalized_text=QuranAyah.normalize_arabic(ar_txt, f"{surah.id}:{first_num}"),
)
end_ayah_id = None
if end_num > first_num and end_num <= surah.total_verses:
end_ayah_id = QuranAyah.compute_id(surah.id, end_num)
if end_ayah_id not in existing_ayahs and end_ayah_id not in ayahs_to_upsert:
ayahs_to_upsert[end_ayah_id] = QuranAyah(
id=end_ayah_id,
surah_id=surah.id,
ayah_number=end_num,
text="",
normalized_text=f"{surah.id}:{end_num}",
)
trans_map = {}
if isinstance(cv.translation, list):
for item in cv.translation:
if isinstance(item, dict) and item.get("language_code"):
lang = normalize_quran_lang_code(item["language_code"])
txt = str(item.get("text") or item.get("title") or "").strip()
if txt:
trans_map[lang] = txt
translator_map = {}
if isinstance(cv.translator, list):
for item in cv.translator:
if isinstance(item, dict) and item.get("language_code"):
lang = normalize_quran_lang_code(item["language_code"])
t_name = str(item.get("text") or item.get("title") or "").strip()
if t_name:
translator_map[lang] = t_name
row_translations = []
for lang, txt in trans_map.items():
t_name = translator_map.get(lang) or f"Primary ({lang.upper()})"
new_translators[(t_name, lang)] = 1
row_translations.append((t_name, lang, txt))
for idx, sec in enumerate(cv.secondary_translations.all(), start=2):
lang = normalize_quran_lang_code(sec.language_code or "ru")
txt = (sec.translation_text or "").strip()
if not txt:
continue
t_name = (sec.translator or "").strip() or f"Translator #{idx} ({lang.upper()})"
if (t_name, lang) not in new_translators:
new_translators[(t_name, lang)] = idx
row_translations.append((t_name, lang, txt))
parsed_rows.append((cv, surah.id, ayah_id, end_ayah_id, row_translations))
if ayahs_to_upsert:
QuranAyah.objects.bulk_create(
list(ayahs_to_upsert.values()),
update_conflicts=True,
unique_fields=["id"],
update_fields=["surah_id", "ayah_number", "text", "normalized_text"],
)
existing_tr_map = {(t.name, t.language_code): t for t in QuranTranslator.objects.all()}
tr_to_create = [
QuranTranslator(name=t_name, language_code=t_lang, priority=prio)
for (t_name, t_lang), prio in new_translators.items()
if (t_name, t_lang) not in existing_tr_map
]
if tr_to_create:
QuranTranslator.objects.bulk_create(tr_to_create, ignore_conflicts=True)
existing_tr_map = {(t.name, t.language_code): t for t in QuranTranslator.objects.all()}
ayah_tr_to_upsert = {}
cv_to_update = []
for cv, s_id, a_id, end_a_id, row_translations in parsed_rows:
for t_name, t_lang, txt in row_translations:
tr_obj = existing_tr_map.get((t_name, t_lang))
if tr_obj:
ayah_tr_to_upsert[(a_id, tr_obj.id)] = QuranAyahTranslation(
ayah_id=a_id,
translator_id=tr_obj.id,
text=txt,
)
cv.surah_id = s_id
cv.ayah_id = a_id
cv.ayah_to_id = end_a_id
cv_to_update.append(cv)
if ayah_tr_to_upsert:
QuranAyahTranslation.objects.bulk_create(
list(ayah_tr_to_upsert.values()),
update_conflicts=True,
unique_fields=["ayah", "translator"],
update_fields=["text"],
)
if cv_to_update:
CategoryQuranVerse.objects.bulk_update(
cv_to_update,
["surah_id", "ayah_id", "ayah_to_id"],
)
self.stdout.write(f"Synced {len(cv_to_update)} existing CategoryQuranVerse records to Master Quran DB.")
def _import_surahs_file(self, path_str: str):
path = Path(path_str)
if not path.exists():
self.stderr.write(f"Surahs file not found: {path}")
return
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
items = data.get("data", data) if isinstance(data, dict) else data
if not isinstance(items, list):
return
ayahs_to_create = []
for row in items:
if not isinstance(row, dict):
continue
s_id = int(row.get("id") or row.get("surah_id") or row.get("number") or 0)
if not (1 <= s_id <= 114):
continue
s_type = str(row.get("type") or "meccan").lower()
if s_type not in ("meccan", "medinan"):
s_type = "meccan"
total_v = int(row.get("total_verses") or len(row.get("verses") or []) or 0)
raw_tr = row.get("translations") or []
surah_obj = QuranSurah.objects.filter(id=s_id).first()
merged_tr = surah_obj.to_localized_list() if surah_obj else []
by_lang = {x["language_code"]: x for x in merged_tr}
if isinstance(raw_tr, list):
for t_item in raw_tr:
if isinstance(t_item, dict):
l_code = normalize_quran_lang_code(
t_item.get("language_code") or t_item.get("languages_code") or ""
)
name_val = str(t_item.get("name") or t_item.get("text") or t_item.get("title") or "").strip()
if l_code and name_val:
by_lang[l_code] = {
"language_code": l_code,
"name": name_val,
"text": name_val,
"title": name_val,
}
elif isinstance(raw_tr, dict):
for l_key, name_val in raw_tr.items():
l_code = normalize_quran_lang_code(l_key)
if l_code and name_val:
by_lang[l_code] = {
"language_code": l_code,
"name": str(name_val).strip(),
"text": str(name_val).strip(),
"title": str(name_val).strip(),
}
QuranSurah.objects.update_or_create(
id=s_id,
defaults={
"surah_type": s_type,
"total_verses": total_v or (surah_obj.total_verses if surah_obj else 0),
"translations": list(by_lang.values()),
},
)
# Check if nested verses are included: [{"id": 1, "verses": [...]}]
verses = row.get("verses") or row.get("ayahs") or []
if isinstance(verses, list):
for v_idx, v in enumerate(verses, start=1):
if isinstance(v, dict):
a_num = int(v.get("ayah_number") or v.get("id") or v.get("verse_number") or v.get("number") or v_idx)
a_text = str(v.get("text") or v.get("arabic_text") or v.get("t") or "").strip()
else:
a_num = v_idx
a_text = str(v).strip()
if a_text:
a_id = QuranAyah.compute_id(s_id, a_num)
ayahs_to_create.append(
QuranAyah(
id=a_id,
surah_id=s_id,
ayah_number=a_num,
text=a_text,
)
)
if ayahs_to_create:
QuranAyah.objects.bulk_create(
ayahs_to_create,
update_conflicts=True,
unique_fields=["id"],
update_fields=["surah_id", "ayah_number", "text"],
)
self.stdout.write(f"Imported {len(ayahs_to_create)} nested ayahs from surahs file.")
def _import_ayahs_file(self, path_str: str):
path = Path(path_str)
if not path.exists():
self.stderr.write(f"Ayahs file not found: {path}")
return
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
ayahs_to_create = []
if isinstance(data, dict) and "data" not in data:
# Flat dictionary format: {"1:1": {"t": "..."}, ...}
for key, val in data.items():
if ":" in key:
parts = key.split(":")
if len(parts) == 2 and parts[0].isdigit() and parts[1].isdigit():
s_id, a_num = int(parts[0]), int(parts[1])
a_text = val.get("t") or val.get("text") if isinstance(val, dict) else str(val)
if a_text:
ayahs_to_create.append(
QuranAyah(
id=QuranAyah.compute_id(s_id, a_num),
surah_id=s_id,
ayah_number=a_num,
text=str(a_text).strip(),
)
)
else:
items = data.get("data", data) if isinstance(data, dict) else data
if isinstance(items, list):
for row in items:
if not isinstance(row, dict):
continue
a_id = row.get("id")
s_id = row.get("surah_id") or row.get("surah")
a_num = row.get("ayah_number") or row.get("number")
if a_id and (not s_id or not a_num):
s_id, a_num = QuranAyah.split_id(int(a_id))
elif s_id and a_num and not a_id:
a_id = QuranAyah.compute_id(int(s_id), int(a_num))
a_text = str(row.get("text") or row.get("arabic_text") or "").strip()
if a_id and s_id and a_num:
ayahs_to_create.append(
QuranAyah(
id=int(a_id),
surah_id=int(s_id),
ayah_number=int(a_num),
text=a_text,
)
)
if ayahs_to_create:
QuranAyah.objects.bulk_create(
ayahs_to_create,
update_conflicts=True,
unique_fields=["id"],
update_fields=["surah_id", "ayah_number", "text"],
)
self.stdout.write(f"Imported {len(ayahs_to_create)} ayahs from {path.name}.")
def _import_translators_file(self, path_str: str):
path = Path(path_str)
if not path.exists():
self.stderr.write(f"Translators file not found: {path}")
return
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
items = data.get("data", data) if isinstance(data, dict) else data
if not isinstance(items, list):
return
count = 0
for row in items:
if not isinstance(row, dict):
continue
t_id = row.get("id")
name = str(row.get("name") or "").strip()
lang = normalize_quran_lang_code(
row.get("lang_code") or row.get("language_code") or "ru"
)
priority = int(row.get("priority") or 0)
if not name:
continue
if t_id:
QuranTranslator.objects.update_or_create(
id=int(t_id),
defaults={"name": name, "language_code": lang, "priority": priority},
)
else:
QuranTranslator.objects.update_or_create(
name=name,
language_code=lang,
defaults={"priority": priority},
)
count += 1
self.stdout.write(f"Imported {count} translators from {path.name}.")
def _import_translations_file(self, path_str: str):
path = Path(path_str)
if not path.exists():
self.stderr.write(f"Translations file not found: {path}")
return
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
items = data.get("data", data) if isinstance(data, dict) else data
if not isinstance(items, list):
return
objs = []
for row in items:
if not isinstance(row, dict):
continue
ayah_id = row.get("ayah_id") or row.get("ayah")
translator_id = row.get("translator_id")
text = str(row.get("text") or "").strip()
if not ayah_id or not text:
continue
if not translator_id and row.get("translator"):
lang = normalize_quran_lang_code(row.get("language_code") or "ru")
tr_obj, _ = QuranTranslator.objects.get_or_create(
name=str(row["translator"]).strip(),
language_code=lang,
)
translator_id = tr_obj.id
if ayah_id and translator_id:
objs.append(
QuranAyahTranslation(
ayah_id=int(ayah_id),
translator_id=int(translator_id),
text=text,
)
)
if objs:
QuranAyahTranslation.objects.bulk_create(
objs,
update_conflicts=True,
unique_fields=["ayah", "translator"],
update_fields=["text"],
)
self.stdout.write(f"Imported {len(objs)} ayah translations from {path.name}.")

142
apps/hadis/migrations/0069_quransurah_qurantranslator_remove_hadis_share_link_and_more.py

@ -0,0 +1,142 @@
# Generated by Django 4.2.30 on 2026-10-31 11:07
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('hadis', '0068_alter_correctionreference_options_and_more'),
]
operations = [
migrations.CreateModel(
name='QuranSurah',
fields=[
('id', models.PositiveSmallIntegerField(primary_key=True, serialize=False, verbose_name='Surah Number (1-114)')),
('surah_type', models.CharField(choices=[('meccan', 'Meccan'), ('medinan', 'Medinan')], db_column='type', default='meccan', max_length=20, verbose_name='Surah Type')),
('total_verses', models.PositiveSmallIntegerField(default=0, verbose_name='Total Verses')),
('translations', models.JSONField(blank=True, default=list, help_text='List of {"language_code": "ru", "name": "..."} entries', verbose_name='Surah Name Translations')),
],
options={
'verbose_name': 'Quran Surah',
'verbose_name_plural': 'Quran Surahs',
'db_table': 'quran_surahs',
'ordering': ('id',),
},
),
migrations.CreateModel(
name='QuranTranslator',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, verbose_name='Translator Name')),
('language_code', models.CharField(db_column='lang_code', db_index=True, default='ru', max_length=15, verbose_name='Language Code')),
('priority', models.IntegerField(db_index=True, default=0, verbose_name='Display Priority')),
],
options={
'verbose_name': 'Quran Translator',
'verbose_name_plural': 'Quran Translators',
'db_table': 'quran_translators',
'ordering': ('priority', 'id'),
},
),
migrations.SeparateDatabaseAndState(
database_operations=[],
state_operations=[
migrations.RemoveField(
model_name='hadis',
name='share_link',
),
migrations.RemoveField(
model_name='hadiscorrection',
name='share_link',
),
migrations.RemoveField(
model_name='transmitteroriginaltext',
name='share_link',
),
],
),
migrations.AlterField(
model_name='categoryquranverse',
name='arabic_text',
field=models.TextField(blank=True, default='', verbose_name='Arabic Text'),
),
migrations.AlterField(
model_name='categoryquranverse',
name='ayah_number',
field=models.CharField(blank=True, default='', max_length=50, verbose_name='Ayah Number'),
),
migrations.AlterField(
model_name='categoryquranverse',
name='surah_name',
field=models.JSONField(blank=True, default=list, verbose_name='Surah Name'),
),
migrations.AlterField(
model_name='categoryquranverse',
name='translation',
field=models.JSONField(blank=True, default=list, verbose_name='Primary Translation'),
),
migrations.AlterField(
model_name='categoryquranverse',
name='translator',
field=models.JSONField(blank=True, default=list, verbose_name='Primary Translator'),
),
migrations.CreateModel(
name='QuranAyah',
fields=[
('id', models.PositiveIntegerField(primary_key=True, serialize=False, verbose_name='Composite Ayah ID (surah_id * 100000 + ayah_number)')),
('ayah_number', models.PositiveSmallIntegerField(db_index=True, verbose_name='Ayah Number')),
('text', models.TextField(verbose_name='Arabic Text (Uthmani)')),
('normalized_text', models.TextField(blank=True, null=True, verbose_name='Normalized Arabic Text for Search')),
('surah', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ayahs', to='hadis.quransurah', verbose_name='Surah')),
],
options={
'verbose_name': 'Quran Ayah',
'verbose_name_plural': 'Quran Ayahs',
'db_table': 'quran_ayahs',
'ordering': ('id',),
},
),
migrations.AddField(
model_name='categoryquranverse',
name='ayah',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='category_verses', to='hadis.quranayah', verbose_name='Ayah (Master DB)'),
),
migrations.AddField(
model_name='categoryquranverse',
name='ayah_to',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='category_verses_end', to='hadis.quranayah', verbose_name='End Ayah (Optional Range)'),
),
migrations.AddField(
model_name='categoryquranverse',
name='surah',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='category_verses', to='hadis.quransurah', verbose_name='Surah (Master DB)'),
),
migrations.CreateModel(
name='QuranAyahTranslation',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('text', models.TextField(verbose_name='Translation Text')),
('ayah', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='translations', to='hadis.quranayah', verbose_name='Ayah')),
('translator', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ayah_translations', to='hadis.qurantranslator', verbose_name='Translator')),
],
options={
'verbose_name': 'Quran Ayah Translation',
'verbose_name_plural': 'Quran Ayah Translations',
'db_table': 'quran_ayah_translations',
'ordering': ('translator__priority', 'id'),
'indexes': [models.Index(fields=['ayah', 'translator'], name='quran_ayah__ayah_id_6eba36_idx')],
'unique_together': {('ayah', 'translator')},
},
),
migrations.AddIndex(
model_name='quranayah',
index=models.Index(fields=['surah', 'ayah_number'], name='quran_ayahs_surah_i_a54283_idx'),
),
migrations.AlterUniqueTogether(
name='quranayah',
unique_together={('surah', 'ayah_number')},
),
]

18
apps/hadis/migrations/0070_qurantranslator_translations.py

@ -0,0 +1,18 @@
# Generated by Django 4.2.30 on 2026-10-31 14:31
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('hadis', '0069_quransurah_qurantranslator_remove_hadis_share_link_and_more'),
]
operations = [
migrations.AddField(
model_name='qurantranslator',
name='translations',
field=models.JSONField(blank=True, default=list, help_text='List of {"language_code": "ru", "name": "..."} entries', verbose_name='Translator Name Translations'),
),
]

1
apps/hadis/models/__init__.py

@ -3,3 +3,4 @@ from .hadis import *
from .transmitter import *
from .reference import *
from .version import *
from .quran import *

139
apps/hadis/models/category.py

@ -234,6 +234,8 @@ class CategoryQuranVerse(models.Model):
"""
Model to store Quranic verse details for a HadisCategory
when its source_type is 'quran'.
Can reference an Ayah (or range of Ayahs) in the Master Quran Database
(`QuranSurah` / `QuranAyah`), while preserving legacy/custom fields.
"""
category = models.OneToOneField(
HadisCategory,
@ -241,13 +243,37 @@ class CategoryQuranVerse(models.Model):
related_name='quran_verse',
verbose_name=_('Category')
)
surah_name = models.JSONField(default=list, verbose_name=_('Surah Name'))
surah = models.ForeignKey(
'hadis.QuranSurah',
on_delete=models.SET_NULL,
null=True,
blank=True,
related_name='category_verses',
verbose_name=_('Surah (Master DB)')
)
ayah = models.ForeignKey(
'hadis.QuranAyah',
on_delete=models.SET_NULL,
null=True,
blank=True,
related_name='category_verses',
verbose_name=_('Ayah (Master DB)')
)
ayah_to = models.ForeignKey(
'hadis.QuranAyah',
on_delete=models.SET_NULL,
null=True,
blank=True,
related_name='category_verses_end',
verbose_name=_('End Ayah (Optional Range)')
)
surah_name = models.JSONField(default=list, blank=True, verbose_name=_('Surah Name'))
# برای پشتیبانی از رِنج آیات (مثل 12-15) از CharField استفاده می‌کنیم
ayah_number = models.CharField(max_length=50, verbose_name=_('Ayah Number'))
ayah_number = models.CharField(max_length=50, blank=True, default="", verbose_name=_('Ayah Number'))
arabic_text = models.TextField(verbose_name=_('Arabic Text'))
translation = models.JSONField(default=list, verbose_name=_('Primary Translation'))
translator = models.JSONField(default=list, verbose_name=_('Primary Translator'))
arabic_text = models.TextField(blank=True, default="", verbose_name=_('Arabic Text'))
translation = models.JSONField(default=list, blank=True, verbose_name=_('Primary Translation'))
translator = models.JSONField(default=list, blank=True, verbose_name=_('Primary Translator'))
created_at = models.DateTimeField(auto_now_add=True, verbose_name=_('Created At'))
updated_at = models.DateTimeField(auto_now=True, verbose_name=_('Updated At'))
@ -256,10 +282,111 @@ class CategoryQuranVerse(models.Model):
verbose_name = _('Category Quran Verse')
verbose_name_plural = _('Category Quran Verses')
def sync_from_master_db(self):
"""
If `ayah` (or `surah` + `ayah_number`) is linked to the Master Quran DB,
auto-populates `surah`, `surah_name`, `ayah_number`, `arabic_text`,
and primary `translation`/`translator` per language when not manually overridden.
"""
from .quran import QuranAyah, QuranAyahTranslation
if not self.ayah_id and self.surah_id and self.ayah_number:
raw_num = str(self.ayah_number).strip()
parts = [p.strip() for p in raw_num.split("-") if p.strip().isdigit()]
if parts:
first_num = int(parts[0])
first_ayah_id = QuranAyah.compute_id(self.surah_id, first_num)
self.ayah = QuranAyah.objects.filter(id=first_ayah_id).select_related("surah").first()
if len(parts) > 1:
end_num = int(parts[-1])
if end_num > first_num:
end_ayah_id = QuranAyah.compute_id(self.surah_id, end_num)
self.ayah_to = QuranAyah.objects.filter(id=end_ayah_id).first()
if self.ayah_id and not self.surah_id:
self.surah_id = self.ayah.surah_id
if self.surah_id and self.surah:
master_surah_names = self.surah.to_localized_list()
if master_surah_names:
self.surah_name = master_surah_names
if self.ayah_id and self.ayah:
start_num = self.ayah.ayah_number
end_num = (
self.ayah_to.ayah_number
if (self.ayah_to_id and self.ayah_to and self.ayah_to.surah_id == self.ayah.surah_id and self.ayah_to.ayah_number > start_num)
else start_num
)
if end_num > start_num:
self.ayah_number = f"{start_num}-{end_num}"
ayahs_qs = list(
QuranAyah.objects.filter(
surah_id=self.ayah.surah_id,
ayah_number__gte=start_num,
ayah_number__lte=end_num,
).order_by("ayah_number")
)
if ayahs_qs:
self.arabic_text = " ".join(f"{a.text} ﴿{a.ayah_number}﴾" for a in ayahs_qs)
else:
self.ayah_number = str(start_num)
if self.ayah.text:
self.arabic_text = self.ayah.text
# Populate primary translation & translator per language from Master DB
target_ayah_ids = (
[a.id for a in ayahs_qs]
if (end_num > start_num and 'ayahs_qs' in locals() and ayahs_qs)
else [self.ayah_id]
)
tr_qs = (
QuranAyahTranslation.objects.filter(ayah_id__in=target_ayah_ids)
.select_related("translator")
.order_by("translator__priority", "translator__id", "ayah_id")
)
# Group by language_code -> first translator in priority order
by_lang_primary_translator = {}
by_lang_texts = {}
for tr in tr_qs:
lang = tr.translator.language_code
if lang not in by_lang_primary_translator:
by_lang_primary_translator[lang] = tr.translator
by_lang_texts[lang] = []
if tr.translator_id == by_lang_primary_translator[lang].id:
by_lang_texts[lang].append(tr.text)
if by_lang_primary_translator:
translations_list = []
translators_list = []
for lang, translator_obj in by_lang_primary_translator.items():
joined_text = " ".join(t.strip() for t in by_lang_texts.get(lang, []) if t and t.strip())
if joined_text:
translations_list.append({
"language_code": lang,
"text": joined_text,
"title": joined_text,
})
tr_localized_name = translator_obj.get_name(lang)
translators_list.append({
"language_code": lang,
"text": tr_localized_name,
"title": tr_localized_name,
})
if translations_list:
self.translation = translations_list
if translators_list:
self.translator = translators_list
def save(self, *args, **kwargs):
if self.ayah_id or self.surah_id:
self.sync_from_master_db()
super().save(*args, **kwargs)
def __str__(self):
# تلاش برای استخراج اسم سوره جهت نمایش در ادمین پنل
try:
surah = self.surah_name[0]['text'] if self.surah_name else "Unknown Surah"
surah = self.surah_name[0]['text'] if self.surah_name else (self.surah.get_name() if self.surah_id else "Unknown Surah")
except (IndexError, KeyError, TypeError):
surah = "Unknown Surah"
return f"{self.category} -> {surah} : {self.ayah_number}"

333
apps/hadis/models/quran.py

@ -0,0 +1,333 @@
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)"),
)
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 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})"

277
apps/hadis/serializers/category.py

@ -381,38 +381,275 @@ class CategorySerializer(serializers.ModelSerializer):
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_name = LocalizedField()
translation = LocalizedField()
translator = LocalizedField()
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_secondary_translations(self, obj):
request = self.context.get('request')
lang = None
if request:
lang = request.query_params.get('lang') or getattr(request, 'LANGUAGE_CODE', None)
if not lang:
lang = 'ru'
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)
# Return only the secondary translations for the requested language
qs = obj.secondary_translations.filter(language_code=lang)
return QuranSecondaryTranslationSerializer(qs, many=True).data
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_name',
'ayah_number',
'arabic_text',
'translation',
'translator',
'secondary_translations'
"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"]

537
apps/hadis/serializers/serializers_admin.py

@ -3231,6 +3231,14 @@ class AdminHadisCategoryArchiveSerializer(serializers.ModelSerializer):
is_leaf = serializers.SerializerMethodField()
quran_verse = serializers.SerializerMethodField()
quran_surah_id = serializers.IntegerField(write_only=True, required=False, allow_null=True)
quran_ayah_id = serializers.IntegerField(write_only=True, required=False, allow_null=True)
quran_ayah_to_id = serializers.IntegerField(write_only=True, required=False, allow_null=True)
quran_ayah_number = serializers.CharField(write_only=True, required=False, allow_blank=True, allow_null=True)
quran_arabic_text = serializers.CharField(write_only=True, required=False, allow_blank=True, allow_null=True)
parent = serializers.PrimaryKeyRelatedField(
@ -3251,6 +3259,27 @@ class AdminHadisCategoryArchiveSerializer(serializers.ModelSerializer):
)
def get_quran_verse(self, obj):
if getattr(obj, "source_type", None) != "quran":
return None
try:
cv = getattr(obj, "quran_verse", None)
if not cv:
return None
return {
"id": cv.id,
"surah": cv.surah_id,
"ayah": cv.ayah_id,
"ayah_to": cv.ayah_to_id,
"surah_name": cv.surah_name,
"ayah_number": cv.ayah_number,
"arabic_text": cv.arabic_text,
"translation": cv.translation,
"translator": cv.translator,
}
except Exception:
return None
def get_has_hadith(self, obj):
@ -3339,6 +3368,18 @@ class AdminHadisCategoryArchiveSerializer(serializers.ModelSerializer):
"is_leaf",
"quran_verse",
"quran_surah_id",
"quran_ayah_id",
"quran_ayah_to_id",
"quran_ayah_number",
"quran_arabic_text",
]
read_only_fields = ["id", "share_link", "xmind_share_link"]
@ -3429,18 +3470,113 @@ class AdminHadisCategoryArchiveSerializer(serializers.ModelSerializer):
def _pop_quran_fields(self, validated_data):
return {
"surah_id": validated_data.pop("quran_surah_id", None),
"ayah_id": validated_data.pop("quran_ayah_id", None),
"ayah_to_id": validated_data.pop("quran_ayah_to_id", None),
"ayah_number": validated_data.pop("quran_ayah_number", None),
"arabic_text": validated_data.pop("quran_arabic_text", None),
}
def _sync_topic_quran_verse(self, category_obj, q_fields):
import re
from ..models.category import CategoryQuranVerse
from ..models.quran import QuranSurah, QuranAyah
if not category_obj.is_topic or category_obj.source_type != "quran":
return
s_id = q_fields.get("surah_id")
a_id = q_fields.get("ayah_id")
a_to_id = q_fields.get("ayah_to_id")
raw_num = str(q_fields.get("ayah_number") or "").strip()
ar_txt = (q_fields.get("arabic_text") or "").strip()
if not s_id and not a_id and not raw_num:
return
surah_obj = QuranSurah.objects.filter(id=s_id).first() if s_id else None
ayah_obj = QuranAyah.objects.filter(id=a_id).first() if a_id else None
ayah_to_obj = QuranAyah.objects.filter(id=a_to_id).first() if a_to_id else None
if ayah_obj and not surah_obj:
surah_obj = ayah_obj.surah
if surah_obj and not ayah_obj and raw_num:
nums = [int(p) for p in re.findall(r"\d+", raw_num) if p.isdigit()]
if nums and 1 <= nums[0] <= surah_obj.total_verses:
first_n = nums[0]
end_n = nums[-1] if len(nums) > 1 and nums[-1] > first_n else first_n
ayah_obj, _ = QuranAyah.objects.get_or_create(
id=QuranAyah.compute_id(surah_obj.id, first_n),
defaults={
"surah": surah_obj,
"ayah_number": first_n,
"text": ar_txt,
},
)
if end_n > first_n and end_n <= surah_obj.total_verses and not ayah_to_obj:
ayah_to_obj, _ = QuranAyah.objects.get_or_create(
id=QuranAyah.compute_id(surah_obj.id, end_n),
defaults={
"surah": surah_obj,
"ayah_number": end_n,
"text": "",
},
)
elif surah_obj and a_id and not ayah_obj:
_, a_num = QuranAyah.split_id(a_id)
if 1 <= a_num <= surah_obj.total_verses:
ayah_obj, _ = QuranAyah.objects.get_or_create(
id=a_id,
defaults={
"surah": surah_obj,
"ayah_number": a_num,
"text": ar_txt,
},
)
if ayah_obj and ar_txt and not ayah_obj.text:
ayah_obj.text = ar_txt
ayah_obj.save()
cv, _ = CategoryQuranVerse.objects.get_or_create(category=category_obj)
if surah_obj:
cv.surah = surah_obj
if ayah_obj:
cv.ayah = ayah_obj
cv.ayah_to = ayah_to_obj
if raw_num:
cv.ayah_number = raw_num
if ar_txt and not cv.arabic_text:
cv.arabic_text = ar_txt
cv.save()
def create(self, validated_data):
validated_data.pop("remove_xmind_file", False)
q_fields = self._pop_quran_fields(validated_data)
try:
return super().create(validated_data)
instance = super().create(validated_data)
self._sync_topic_quran_verse(instance, q_fields)
return instance
except DjangoValidationError as exc:
self._raise_drf_validation_error(exc)
def update(self, instance, validated_data):
q_fields = self._pop_quran_fields(validated_data)
try:
instance = super().update(instance, validated_data)
self._sync_topic_quran_verse(instance, q_fields)
return instance
except DjangoValidationError as exc:
self._raise_drf_validation_error(exc)
@ -6676,10 +6812,222 @@ class AdminBookReferenceDetailSerializer(serializers.ModelSerializer):
# Category Quran Verse Admin Serializers
# Category Quran Verse & Master Quran Database Admin Serializers
from ..models.category import CategoryQuranVerse, QuranSecondaryTranslation
from ..models.quran import (
QuranSurah,
QuranAyah,
QuranTranslator,
QuranAyahTranslation,
normalize_quran_lang_code,
)
class AdminQuranSurahSerializer(serializers.ModelSerializer):
ayahs_count = serializers.SerializerMethodField()
translations = serializers.JSONField(default=list)
class Meta:
model = QuranSurah
fields = ["id", "surah_type", "total_verses", "translations", "ayahs_count"]
def get_ayahs_count(self, obj):
if hasattr(obj, "annotated_ayahs_count"):
return obj.annotated_ayahs_count
return obj.ayahs.count()
class AdminQuranTranslatorSerializer(serializers.ModelSerializer):
name = serializers.CharField(max_length=255, required=False, allow_blank=True, default="")
translations = serializers.JSONField(default=list, required=False)
translations_count = serializers.SerializerMethodField()
class Meta:
model = QuranTranslator
fields = ["id", "name", "translations", "language_code", "priority", "translations_count"]
read_only_fields = ["id"]
def get_translations_count(self, obj):
if hasattr(obj, "annotated_translations_count"):
return obj.annotated_translations_count
return obj.ayah_translations.count()
def to_representation(self, instance):
data = super().to_representation(instance)
data["translations"] = instance.to_localized_list()
data["name"] = instance.get_name(instance.language_code) or instance.name
return data
class AdminQuranAyahTranslationSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(required=False)
translator = serializers.PrimaryKeyRelatedField(
queryset=QuranTranslator.objects.all(),
required=False,
allow_null=True,
)
translator_name = serializers.CharField(
max_length=255, required=False, allow_blank=True, default=""
)
translator_translations = serializers.JSONField(read_only=True, default=list)
language_code = serializers.CharField(
max_length=15, required=False, allow_blank=True, default="ru"
)
priority = serializers.IntegerField(required=False, default=1)
class Meta:
model = QuranAyahTranslation
fields = [
"id",
"translator",
"translator_name",
"translator_translations",
"language_code",
"priority",
"text",
]
def to_representation(self, instance):
data = super().to_representation(instance)
if instance.translator_id and instance.translator:
data["translator"] = instance.translator.id
data["translator_name"] = instance.translator.get_name(instance.translator.language_code)
data["translator_translations"] = instance.translator.to_localized_list()
data["language_code"] = instance.translator.language_code
data["priority"] = instance.translator.priority
return data
class AdminQuranAyahSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(read_only=True)
surah = serializers.PrimaryKeyRelatedField(queryset=QuranSurah.objects.all())
surah_detail = AdminQuranSurahSerializer(source="surah", read_only=True)
verse_key = serializers.SerializerMethodField()
translations = AdminQuranAyahTranslationSerializer(many=True, required=False)
topic_categories = serializers.SerializerMethodField()
class Meta:
model = QuranAyah
fields = [
"id",
"surah",
"surah_detail",
"ayah_number",
"verse_key",
"text",
"translations",
"topic_categories",
]
read_only_fields = ["id", "verse_key", "topic_categories"]
validators = []
def get_verse_key(self, obj):
return f"{obj.surah_id}:{obj.ayah_number}"
def get_topic_categories(self, obj):
result = []
topic_verses = getattr(obj, "prefetched_topic_verses", None)
if topic_verses is None:
topic_verses = obj.category_verses.select_related("category").all()
for tv in topic_verses:
if tv.category_id and tv.category:
result.append({
"id": tv.category.id,
"title": tv.category.title,
"slug": tv.category.slug,
"quran_verse_id": tv.id,
})
return result
def validate(self, attrs):
surah = attrs.get("surah") or getattr(self.instance, "surah", None)
ayah_num = attrs.get("ayah_number") or getattr(self.instance, "ayah_number", None)
if surah and ayah_num:
if ayah_num < 1 or (surah.total_verses and ayah_num > surah.total_verses):
raise serializers.ValidationError({
"ayah_number": _(
f"Ayah number must be between 1 and {surah.total_verses} for Surah {surah.id}."
)
})
return attrs
def _sync_translations(self, ayah_obj, translations_data):
if translations_data is None:
return
keep_ids = []
for idx, tr_item in enumerate(translations_data, start=1):
text_val = (tr_item.get("text") or "").strip()
if not text_val:
continue
translator_obj = tr_item.get("translator")
lang_code = normalize_quran_lang_code(tr_item.get("language_code") or "ru")
tr_name = (tr_item.get("translator_name") or "").strip()
prio = tr_item.get("priority", idx)
if not translator_obj:
if not tr_name:
tr_name = f"Primary ({lang_code.upper()})" if idx == 1 else f"Translator #{idx} ({lang_code.upper()})"
translator_obj, _ = QuranTranslator.objects.get_or_create(
name=tr_name,
language_code=lang_code,
defaults={"priority": prio},
)
obj, _ = QuranAyahTranslation.objects.update_or_create(
ayah=ayah_obj,
translator=translator_obj,
defaults={"text": text_val},
)
keep_ids.append(obj.id)
ayah_obj.translations.exclude(id__in=keep_ids).delete()
def _sync_linked_topic_verses(self, ayah_obj):
from django.db.models import Q
linked_verses = CategoryQuranVerse.objects.filter(
Q(ayah=ayah_obj)
| Q(surah_id=ayah_obj.surah_id, ayah_number=str(ayah_obj.ayah_number))
).select_related("surah", "ayah")
for cv in linked_verses:
cv.surah = ayah_obj.surah
cv.ayah = ayah_obj
cv.sync_from_master_db()
cv.save()
def create(self, validated_data):
from django.db import transaction
with transaction.atomic():
translations_data = validated_data.pop("translations", None)
surah = validated_data["surah"]
ayah_num = validated_data["ayah_number"]
ayah_id = QuranAyah.compute_id(surah.id, ayah_num)
ayah_obj, _ = QuranAyah.objects.update_or_create(
id=ayah_id,
defaults={
"surah": surah,
"ayah_number": ayah_num,
"text": validated_data.get("text", ""),
},
)
self._sync_translations(ayah_obj, translations_data)
self._sync_linked_topic_verses(ayah_obj)
return ayah_obj
def update(self, instance, validated_data):
from django.db import transaction
with transaction.atomic():
translations_data = validated_data.pop("translations", None)
instance.surah = validated_data.get("surah", instance.surah)
instance.ayah_number = validated_data.get("ayah_number", instance.ayah_number)
instance.text = validated_data.get("text", instance.text)
instance.save()
self._sync_translations(instance, translations_data)
self._sync_linked_topic_verses(instance)
return instance
class AdminQuranSecondaryTranslationSerializer(serializers.ModelSerializer):
@ -6706,11 +7054,36 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
category_detail = AdminHadisCategorySerializer(source="category", read_only=True)
surah_name = serializers.JSONField(default=list)
surah = serializers.PrimaryKeyRelatedField(
queryset=QuranSurah.objects.all(),
required=False,
allow_null=True,
)
surah_detail = AdminQuranSurahSerializer(source="surah", read_only=True)
ayah = serializers.PrimaryKeyRelatedField(
queryset=QuranAyah.objects.all(),
required=False,
allow_null=True,
)
ayah_detail = AdminQuranAyahSerializer(source="ayah", read_only=True)
ayah_to = serializers.PrimaryKeyRelatedField(
queryset=QuranAyah.objects.all(),
required=False,
allow_null=True,
)
ayah_to_detail = AdminQuranAyahSerializer(source="ayah_to", read_only=True)
surah_name = serializers.JSONField(default=list, required=False)
ayah_number = serializers.CharField(required=False, allow_blank=True, default="")
translation = serializers.JSONField(default=list)
arabic_text = serializers.CharField(required=False, allow_blank=True, default="")
translator = serializers.JSONField(default=list)
translation = serializers.JSONField(default=list, required=False)
translator = serializers.JSONField(default=list, required=False)
secondary_translations = AdminQuranSecondaryTranslationSerializer(many=True, required=False)
@ -6728,6 +7101,18 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
"category_detail",
"surah",
"surah_detail",
"ayah",
"ayah_detail",
"ayah_to",
"ayah_to_detail",
"surah_name",
"ayah_number",
@ -6748,6 +7133,90 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
read_only_fields = ["id", "created_at", "updated_at"]
def _ensure_master_ayah_and_sync(self, validated_data, instance=None):
"""
Ensures that when a Surah + Ayah Number (or Ayah ID) is selected in the Admin Panel,
the corresponding `QuranAyah` and its translations exist in the Master Quran DB
and are linked to `CategoryQuranVerse`.
"""
import re
surah = validated_data.get("surah") or (instance.surah if instance else None)
ayah = validated_data.get("ayah") or (instance.ayah if instance else None)
ayah_to = validated_data.get("ayah_to") or (instance.ayah_to if instance else None)
raw_num = str(
validated_data.get("ayah_number")
or (instance.ayah_number if instance else "")
or ""
).strip()
if ayah and not surah:
surah = ayah.surah
validated_data["surah"] = surah
if surah and not ayah and raw_num:
nums = [int(p) for p in re.findall(r"\d+", raw_num) if p.isdigit()]
if nums and 1 <= nums[0] <= surah.total_verses:
first_num = nums[0]
end_num = nums[-1] if len(nums) > 1 and nums[-1] > first_num else first_num
ayah_id = QuranAyah.compute_id(surah.id, first_num)
ar_text = (validated_data.get("arabic_text") or "").strip()
ayah, _ = QuranAyah.objects.get_or_create(
id=ayah_id,
defaults={
"surah": surah,
"ayah_number": first_num,
"text": ar_text,
},
)
validated_data["ayah"] = ayah
if end_num > first_num and end_num <= surah.total_verses and not ayah_to:
end_id = QuranAyah.compute_id(surah.id, end_num)
ayah_to, _ = QuranAyah.objects.get_or_create(
id=end_id,
defaults={
"surah": surah,
"ayah_number": end_num,
"text": "",
},
)
validated_data["ayah_to"] = ayah_to
# If admin also provided arabic_text or translations, sync them into the Master DB
if ayah:
ar_text = (validated_data.get("arabic_text") or "").strip()
if ar_text and ar_text != ayah.text:
ayah.text = ar_text
ayah.save()
trans_list = validated_data.get("translation")
translator_list = validated_data.get("translator")
if isinstance(trans_list, list) and trans_list:
tr_map = {}
if isinstance(translator_list, list):
for item in translator_list:
if isinstance(item, dict) and item.get("language_code"):
l_code = normalize_quran_lang_code(item["language_code"])
t_name = str(item.get("text") or item.get("title") or "").strip()
if t_name:
tr_map[l_code] = t_name
for item in trans_list:
if isinstance(item, dict) and item.get("language_code"):
l_code = normalize_quran_lang_code(item["language_code"])
txt = str(item.get("text") or item.get("title") or "").strip()
if txt:
t_name = tr_map.get(l_code) or f"Primary ({l_code.upper()})"
tr_obj, _ = QuranTranslator.objects.get_or_create(
name=t_name,
language_code=l_code,
defaults={"priority": 1},
)
QuranAyahTranslation.objects.update_or_create(
ayah=ayah,
translator=tr_obj,
defaults={"text": txt},
)
def create(self, validated_data):
@ -6757,10 +7226,11 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
with transaction.atomic():
secondary_data = validated_data.pop("secondary_translations", [])
self._ensure_master_ayah_and_sync(validated_data)
verse = CategoryQuranVerse.objects.create(**validated_data)
for sec in secondary_data:
for idx, sec in enumerate(secondary_data, start=2):
QuranSecondaryTranslation.objects.create(
@ -6773,6 +7243,19 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
translator=sec.get("translator", ""),
)
if verse.ayah_id and (sec.get("translation_text") or "").strip():
l_code = normalize_quran_lang_code(sec.get("language_code", "ru"))
t_name = (sec.get("translator") or "").strip() or f"Translator #{idx} ({l_code.upper()})"
tr_obj, _ = QuranTranslator.objects.get_or_create(
name=t_name,
language_code=l_code,
defaults={"priority": idx},
)
QuranAyahTranslation.objects.update_or_create(
ayah=verse.ayah,
translator=tr_obj,
defaults={"text": sec["translation_text"].strip()},
)
return verse
@ -6785,18 +7268,21 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
with transaction.atomic():
secondary_data = validated_data.pop("secondary_translations", None)
instance.surah_name = validated_data.get("surah_name", instance.surah_name)
instance.ayah_number = validated_data.get("ayah_number", instance.ayah_number)
instance.arabic_text = validated_data.get("arabic_text", instance.arabic_text)
instance.translation = validated_data.get("translation", instance.translation)
instance.translator = validated_data.get("translator", instance.translator)
instance.category = validated_data.get("category", instance.category)
self._ensure_master_ayah_and_sync(validated_data, instance=instance)
for field in (
"surah",
"ayah",
"ayah_to",
"surah_name",
"ayah_number",
"arabic_text",
"translation",
"translator",
"category",
):
if field in validated_data:
setattr(instance, field, validated_data[field])
instance.save()
@ -6808,7 +7294,7 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
instance.secondary_translations.exclude(id__in=keep_ids).delete()
for sec in secondary_data:
for idx, sec in enumerate(secondary_data, start=2):
sec_id = sec.get("id")
@ -6837,6 +7323,19 @@ class AdminCategoryQuranVerseSerializer(serializers.ModelSerializer):
translator=sec.get("translator", ""),
)
if instance.ayah_id and (sec.get("translation_text") or "").strip():
l_code = normalize_quran_lang_code(sec.get("language_code", "ru"))
t_name = (sec.get("translator") or "").strip() or f"Translator #{idx} ({l_code.upper()})"
tr_obj, _ = QuranTranslator.objects.get_or_create(
name=t_name,
language_code=l_code,
defaults={"priority": idx},
)
QuranAyahTranslation.objects.update_or_create(
ayah=instance.ayah,
translator=tr_obj,
defaults={"text": sec["translation_text"].strip()},
)
return instance

21
apps/hadis/urls.py

@ -2,7 +2,20 @@ from django.urls import path, include
from rest_framework.routers import SimpleRouter
from .views.category import HadisCategorySectListView, HadisCategoryTreeView, CategoriesView, CategoriesBySectView, HadisCategorySelectBySectView, HadisCategorySelectBySectSourceView , HadisCategoryTreeNormalView ,test_deploy,debug_headers,HadisCategoryXMindView
from .views.category import (
HadisCategorySectListView,
HadisCategoryTreeView,
CategoriesView,
CategoriesBySectView,
HadisCategorySelectBySectView,
HadisCategorySelectBySectSourceView,
HadisCategoryTreeNormalView,
test_deploy,
debug_headers,
HadisCategoryXMindView,
PublicQuranSurahListView,
PublicQuranAyahListView,
)
from .views.hadis import (
@ -39,6 +52,7 @@ from .views_admin import (
DovodiNarratorLayerViewSet, DovodiTransmitterReliabilityViewSet, DovodiOpinionStatusViewSet, DovodiScholarlyOpinionViewSet, DovodiYearValueViewSet,
DovodiHadisSectViewSet, DovodiHadisCategoryViewSet, AdminCategoryQuranVerseViewSet, AdminHadisTransmitterViewSet,
AdminQuranSurahViewSet, AdminQuranAyahViewSet, AdminQuranTranslatorViewSet,
AdminTransmitterOpinionViewSet, AdminTransmitterOriginalTextViewSet, AdminOriginalTextReferenceViewSet, AdminBookEditionViewSet, AdminBookVolumeViewSet,
@ -75,6 +89,9 @@ admin_router.register(r'hadises', AdminHadisViewSet, basename='admin-hadises')
admin_router.register(r'categories', AdminHadisCategoryViewSet, basename='admin-hadis-categories')
admin_router.register(r'quran-verses', AdminCategoryQuranVerseViewSet, basename='admin-category-quran-verses')
admin_router.register(r'quran-surahs', AdminQuranSurahViewSet, basename='admin-quran-surahs')
admin_router.register(r'quran-ayahs', AdminQuranAyahViewSet, basename='admin-quran-ayahs')
admin_router.register(r'quran-translators', AdminQuranTranslatorViewSet, basename='admin-quran-translators')
admin_router.register(r'dovodi-sects', DovodiHadisSectViewSet, basename='dovodi-hadis-sects')
@ -227,6 +244,8 @@ urlpatterns = [
path('info/', cached_view(HadisInfoView.as_view()), name='hadis-info'),
path('tags/', cached_view(HadisTagListView.as_view()), name='hadis-tag-list'),
path('quran/surahs/', cached_view(PublicQuranSurahListView.as_view()), name='public-quran-surahs'),
path('quran/ayahs/', cached_view(PublicQuranAyahListView.as_view()), name='public-quran-ayahs'),

71
apps/hadis/views/category.py

@ -98,9 +98,11 @@ class HadisCategoryTreeView(ListAPIView):
from ..models.category import CategoryQuranVerse
from ..serializers.category import CategoryQuranVerseSerializer
quran_verses = CategoryQuranVerse.objects.filter(
category__in=queryset
).prefetch_related('secondary_translations')
quran_verses = (
CategoryQuranVerse.objects.filter(category__in=queryset)
.select_related('surah', 'ayah', 'ayah_to')
.prefetch_related('secondary_translations', 'ayah__translations__translator')
)
for verse in quran_verses:
quran_data_map[verse.category_id] = CategoryQuranVerseSerializer(
@ -987,3 +989,66 @@ class HadisCategoryXMindView(APIView):
response['Pragma'] = 'no-cache'
response['Expires'] = '0'
return response
class PublicQuranSurahListView(APIView):
"""
Public endpoint returning the 114 Surahs of the Quran with localized names and verse counts.
"""
permission_classes = []
def get(self, request, *args, **kwargs):
from ..models.quran import QuranSurah
from ..serializers.category import PublicQuranSurahSerializer
surahs = QuranSurah.objects.all().order_by("id")
serializer = PublicQuranSurahSerializer(surahs, many=True, context={"request": request})
return Response(serializer.data)
class PublicQuranAyahListView(APIView):
"""
Public endpoint returning Ayahs (and their localized translations ordered by translator priority)
filtered by `surah` (1..114), `ayah_number`, `ayah_id`, or `search`.
"""
permission_classes = []
def get(self, request, *args, **kwargs):
import re
from django.db.models import Q
from ..models.quran import QuranAyah
from ..serializers.category import PublicQuranAyahSerializer
qs = (
QuranAyah.objects.all()
.select_related("surah")
.prefetch_related("translations__translator")
)
surah_id = request.query_params.get("surah") or request.query_params.get("surah_id")
if surah_id and str(surah_id).isdigit():
qs = qs.filter(surah_id=int(surah_id))
ayah_num = request.query_params.get("ayah_number")
if ayah_num and str(ayah_num).isdigit():
qs = qs.filter(ayah_number=int(ayah_num))
ayah_id = request.query_params.get("ayah_id") or request.query_params.get("id")
if ayah_id and str(ayah_id).isdigit():
qs = qs.filter(id=int(ayah_id))
search_q = (request.query_params.get("search") or "").strip()
if search_q:
m = re.match(r"^(\d{1,3})\s*[:/-]\s*(\d{1,3})$", search_q)
if m:
qs = qs.filter(surah_id=int(m.group(1)), ayah_number=int(m.group(2)))
else:
qs = qs.filter(
Q(text__icontains=search_q)
| Q(translations__text__icontains=search_q)
).distinct()
qs = qs.order_by("id")[:300]
serializer = PublicQuranAyahSerializer(qs, many=True, context={"request": request})
return Response(serializer.data)

8
apps/hadis/views/hadis.py

@ -278,9 +278,11 @@ class HadisListView(ListAPIView):
if category_obj.source_type == HadisCategory.SourceType.QURAN:
try:
from ..models.category import CategoryQuranVerse
verse_obj = CategoryQuranVerse.objects.prefetch_related(
'secondary_translations'
).get(category=category_obj)
verse_obj = (
CategoryQuranVerse.objects.select_related('surah', 'ayah', 'ayah_to')
.prefetch_related('secondary_translations', 'ayah__translations__translator')
.get(category=category_obj)
)
from ..serializers.category import CategoryQuranVerseSerializer
quran_data = CategoryQuranVerseSerializer(

204
apps/hadis/views_admin.py

@ -168,7 +168,7 @@ class AdminHadisCategoryViewSet(ReadOnlyModelViewSet):
quran_verse_subquery = CategoryQuranVerse.objects.filter(category=OuterRef("pk"))
queryset = HadisCategory.objects.select_related("parent", "sect").annotate(
queryset = HadisCategory.objects.select_related("parent", "sect", "quran_verse").annotate(
annotated_has_hadith=Exists(hadis_subquery),
@ -342,7 +342,7 @@ class DovodiHadisCategoryViewSet(ModelViewSet):
children_subquery = HadisCategory.objects.filter(parent=OuterRef("pk"))
queryset = HadisCategory.objects.select_related("parent", "sect").annotate(
queryset = HadisCategory.objects.select_related("parent", "sect", "quran_verse").annotate(
annotated_has_hadith=Exists(hadis_subquery),
@ -2358,9 +2358,9 @@ class AdminCategoryQuranVerseViewSet(ModelViewSet):
CategoryQuranVerse.objects.all()
.select_related("category", "category__sect")
.select_related("category", "category__sect", "surah", "ayah", "ayah__surah", "ayah_to", "ayah_to__surah")
.prefetch_related("secondary_translations")
.prefetch_related("secondary_translations", "ayah__translations__translator", "ayah__category_verses__category")
)
@ -2386,6 +2386,10 @@ class AdminCategoryQuranVerseViewSet(ModelViewSet):
| Q(category__slug__icontains=search_query)
| Q(surah__translations__icontains=search_query)
| Q(ayah__text__icontains=search_query)
)
queryset = queryset.filter(q_filter)
@ -2398,6 +2402,14 @@ class AdminCategoryQuranVerseViewSet(ModelViewSet):
queryset = queryset.filter(category_id=category_id)
surah_id = self.request.query_params.get("surah")
if surah_id and surah_id != "all":
queryset = queryset.filter(surah_id=surah_id)
ayah_id = self.request.query_params.get("ayah")
if ayah_id and ayah_id != "all":
queryset = queryset.filter(ayah_id=ayah_id)
source_type = self.request.query_params.get("source_type")
@ -2411,6 +2423,190 @@ class AdminCategoryQuranVerseViewSet(ModelViewSet):
return queryset.order_by("-id")
class AdminQuranSurahViewSet(ModelViewSet):
permission_classes = [IsAuthenticated, IsSuperAdmin]
authentication_classes = [TokenAuthentication]
parser_classes = (JSONParser, MultiPartParser, FormParser)
pagination_class = None
def get_serializer_class(self):
from .serializers.serializers_admin import AdminQuranSurahSerializer
return AdminQuranSurahSerializer
def get_queryset(self):
from django.db.models import Count
from .models.quran import QuranSurah
queryset = QuranSurah.objects.annotate(annotated_ayahs_count=Count("ayahs")).order_by("id")
search_q = (self.request.query_params.get("search") or "").strip()
if search_q:
if search_q.isdigit():
queryset = queryset.filter(Q(id=int(search_q)) | Q(translations__icontains=search_q))
else:
queryset = queryset.filter(translations__icontains=search_q)
return queryset
class AdminQuranTranslatorViewSet(ModelViewSet):
permission_classes = [IsAuthenticated, IsSuperAdmin]
authentication_classes = [TokenAuthentication]
parser_classes = (JSONParser, MultiPartParser, FormParser)
pagination_class = OptionalPagination
def get_serializer_class(self):
from .serializers.serializers_admin import AdminQuranTranslatorSerializer
return AdminQuranTranslatorSerializer
def get_queryset(self):
from django.db.models import Count
from .models.quran import QuranTranslator, normalize_quran_lang_code
queryset = QuranTranslator.objects.annotate(
annotated_translations_count=Count("ayah_translations")
).order_by("priority", "id")
lang = self.request.query_params.get("language_code") or self.request.query_params.get("lang")
if lang and lang != "all":
queryset = queryset.filter(language_code=normalize_quran_lang_code(lang))
search_q = (self.request.query_params.get("search") or "").strip()
if search_q:
queryset = queryset.filter(
Q(name__icontains=search_q) | Q(translations__icontains=search_q)
)
return queryset
class AdminQuranAyahViewSet(ModelViewSet):
permission_classes = [IsAuthenticated, IsSuperAdmin]
authentication_classes = [TokenAuthentication]
parser_classes = (JSONParser, MultiPartParser, FormParser)
pagination_class = OptionalPagination
def get_serializer_class(self):
from .serializers.serializers_admin import AdminQuranAyahSerializer
return AdminQuranAyahSerializer
def get_queryset(self):
import re
from .models.quran import QuranAyah
queryset = (
QuranAyah.objects.all()
.select_related("surah")
.prefetch_related("translations__translator", "category_verses__category")
)
surah_id = self.request.query_params.get("surah") or self.request.query_params.get("surah_id")
if surah_id and str(surah_id) != "all" and str(surah_id).isdigit():
queryset = queryset.filter(surah_id=int(surah_id))
ayah_num = self.request.query_params.get("ayah_number")
if ayah_num and str(ayah_num).isdigit():
queryset = queryset.filter(ayah_number=int(ayah_num))
search_q = (self.request.query_params.get("search") or "").strip()
if search_q:
m = re.match(r"^(\d{1,3})\s*[:/-]\s*(\d{1,3})$", search_q)
if m:
s_id, a_num = int(m.group(1)), int(m.group(2))
queryset = queryset.filter(surah_id=s_id, ayah_number=a_num)
elif search_q.isdigit() and len(search_q) >= 6:
queryset = queryset.filter(id=int(search_q))
elif search_q.isdigit():
num_val = int(search_q)
queryset = queryset.filter(Q(surah_id=num_val) | Q(ayah_number=num_val))
else:
from utils.text_normalizer import normalize_search_text
norm_q = normalize_search_text(search_q)
queryset = queryset.filter(
Q(text__icontains=search_q)
| Q(normalized_text__icontains=norm_q)
| Q(surah__translations__icontains=search_q)
| Q(translations__text__icontains=search_q)
).distinct()
return queryset.order_by("id")
@action(detail=False, methods=["get"], url_path="lookup")
def lookup(self, request):
"""
Quick lookup of an Ayah (or range of Ayahs) in the Master Quran DB by:
- `surah` (1..114) and `ayah_number` (1..total_verses, or range like '1-5')
- or `ayah_id` (composite ID `surah * 100000 + ayah_number`)
Returns the Ayah (and combined range preview if a range is requested) even if the Ayah
has not been imported yet, so the Admin UI always has full Surah metadata and composite ID.
"""
import re
from .models.quran import QuranSurah, QuranAyah
from .serializers.serializers_admin import AdminQuranAyahSerializer, AdminQuranSurahSerializer
ayah_id_param = request.query_params.get("ayah_id")
surah_param = request.query_params.get("surah") or request.query_params.get("surah_id")
ayah_num_param = (request.query_params.get("ayah_number") or "").strip()
if ayah_id_param and str(ayah_id_param).isdigit():
s_id, a_num = QuranAyah.split_id(int(ayah_id_param))
surah_param = s_id
ayah_num_param = str(a_num)
if not surah_param or not str(surah_param).isdigit():
return Response({"error": "Valid surah (1-114) is required."}, status=400)
surah = QuranSurah.objects.filter(id=int(surah_param)).first()
if not surah:
return Response({"error": f"Surah {surah_param} not found."}, status=404)
nums = [int(p) for p in re.findall(r"\d+", str(ayah_num_param)) if p.isdigit()]
first_num = nums[0] if nums else 1
end_num = nums[-1] if len(nums) > 1 and nums[-1] > first_num else first_num
if first_num < 1 or (surah.total_verses and first_num > surah.total_verses):
return Response(
{"error": f"Ayah number must be between 1 and {surah.total_verses}."},
status=400,
)
comp_id = QuranAyah.compute_id(surah.id, first_num)
ayah_obj = (
QuranAyah.objects.select_related("surah")
.prefetch_related("translations__translator", "category_verses__category")
.filter(id=comp_id)
.first()
)
if ayah_obj:
data = AdminQuranAyahSerializer(ayah_obj, context={"request": request}).data
data["exists_in_master_db"] = True
else:
data = {
"id": comp_id,
"surah": surah.id,
"surah_detail": AdminQuranSurahSerializer(surah).data,
"ayah_number": first_num,
"verse_key": f"{surah.id}:{first_num}",
"text": "",
"translations": [],
"topic_categories": [],
"exists_in_master_db": False,
}
if end_num > first_num and end_num <= surah.total_verses:
range_ayahs = list(
QuranAyah.objects.filter(
surah_id=surah.id,
ayah_number__gte=first_num,
ayah_number__lte=end_num,
)
.prefetch_related("translations__translator")
.order_by("ayah_number")
)
data["ayah_to_id"] = QuranAyah.compute_id(surah.id, end_num)
data["ayah_to_number"] = end_num
data["verse_key"] = f"{surah.id}:{first_num}-{end_num}"
if range_ayahs:
data["range_arabic_text"] = " ".join(a.text for a in range_ayahs if a.text)
return Response(data)

Loading…
Cancel
Save