You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
423 lines
16 KiB
423 lines
16 KiB
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.core.exceptions import ValidationError
|
|
from mptt.models import MPTTModel, TreeForeignKey
|
|
from django.utils.text import slugify
|
|
from django.conf import settings
|
|
from utils.mixins import LowercaseSlugMixin
|
|
|
|
|
|
class HadisSect(models.Model):
|
|
class SectType(models.TextChoices):
|
|
SHIA = 'shia', _('Shia')
|
|
SUNNI = 'sunni', _('Sunni')
|
|
|
|
sect_type = models.CharField(max_length=10, choices=SectType.choices, unique=True, verbose_name=_('Sect Name'))
|
|
title = models.JSONField(default = list , verbose_name=_('Title'))
|
|
description = models.JSONField(default = list , verbose_name=_('Description'))
|
|
is_active = models.BooleanField(default=True, verbose_name=_('Is Active'))
|
|
order = models.IntegerField(default=0, verbose_name=_('order'))
|
|
|
|
def __str__(self):
|
|
title = self.title[0]['text'] if self.title else "Untitled Sect"
|
|
return f"{self.sect_type}: {title}"
|
|
|
|
def get_title(self,lang):
|
|
"""
|
|
Get title for a specific language
|
|
"""
|
|
|
|
if not self.title or not isinstance(self.title, list):
|
|
return None
|
|
|
|
for tr in self.title:
|
|
if isinstance(tr, dict) and tr.get('language_code') == lang:
|
|
return tr.get('text', '')
|
|
|
|
for tr in self.title:
|
|
if isinstance(tr, dict) and tr.get('language_code') == 'en':
|
|
return tr.get('text', '')
|
|
return None
|
|
|
|
def get_description(self,lang):
|
|
"""
|
|
Get title for a specific language
|
|
"""
|
|
|
|
if not self.description or not isinstance(self.description, list):
|
|
return None
|
|
|
|
for tr in self.description:
|
|
if isinstance(tr, dict) and tr.get('language_code') == lang:
|
|
return tr.get('text', '')
|
|
|
|
for tr in self.description:
|
|
if isinstance(tr, dict) and tr.get('language_code') == 'en':
|
|
return tr.get('text', '')
|
|
return None
|
|
|
|
|
|
|
|
class Meta:
|
|
verbose_name = _('Hadis Sect')
|
|
verbose_name_plural = _('Hadis Sects')
|
|
ordering = ('order',)
|
|
|
|
|
|
class HadisCategory(LowercaseSlugMixin, MPTTModel):
|
|
class SourceType(models.TextChoices):
|
|
QURAN = 'quran', _('Quran')
|
|
HADITH = 'hadith', _('Hadith')
|
|
HISTORY = 'history', _('History')
|
|
FATWA = 'fatwa', _('Fatwa')
|
|
QUOTE = 'quote', _('Quote')
|
|
|
|
parent = TreeForeignKey('self', on_delete=models.CASCADE, null=True, blank=True, related_name='children')
|
|
sect = models.ForeignKey(HadisSect, on_delete=models.PROTECT, verbose_name=_('Sect'), null=False, blank=False)
|
|
source_type = models.CharField(
|
|
max_length=10,
|
|
choices=SourceType.choices,
|
|
verbose_name=_('Source Type'),
|
|
null=True,
|
|
blank=True
|
|
)
|
|
is_topic = models.BooleanField(
|
|
default=False,
|
|
db_index=True,
|
|
verbose_name=_('Is Topic')
|
|
)
|
|
title = models.JSONField(default = list , verbose_name=_('Title'))
|
|
description = models.JSONField(default = list , blank=True, verbose_name=_('Description'))
|
|
order = models.IntegerField(default=0, verbose_name=_('order'))
|
|
xmind_file = models.FileField(upload_to='hadis/xmind_files/', verbose_name=_('xmind file'), null=True, blank=True)
|
|
slug = models.SlugField(max_length=255, null=True, blank=True,allow_unicode=True)
|
|
normalized_text = models.TextField(blank=True, null=True, verbose_name=_('normalized text for search'))
|
|
content_type = None
|
|
language = None
|
|
language_id = None
|
|
|
|
def clean(self):
|
|
super().clean()
|
|
if self.parent:
|
|
if getattr(self.parent, 'is_topic', False):
|
|
raise ValidationError(
|
|
_('Cannot set parent to a topic. Parent must be a structural category.')
|
|
)
|
|
if self.sect_id != self.parent.sect_id:
|
|
raise ValidationError(
|
|
_('Child category must have the same sect_type as its parent. '
|
|
f'Parent sect: {self.parent.sect.sect_type}, '
|
|
f'Your sect: {self.sect.sect_type}')
|
|
)
|
|
parent_has_hadis = (
|
|
self.parent.hadis_set.exists() or
|
|
(hasattr(self.parent, 'hadis_items') and self.parent.hadis_items.exists())
|
|
)
|
|
if parent_has_hadis:
|
|
raise ValidationError(
|
|
_('Cannot set parent to a category that already contains hadiths/content items.')
|
|
)
|
|
|
|
if self.is_topic:
|
|
if not self.source_type:
|
|
raise ValidationError(
|
|
{'source_type': _('A topic must have a source type.')}
|
|
)
|
|
if self.pk and self.children.exists():
|
|
raise ValidationError(
|
|
_('A topic cannot have subcategories.')
|
|
)
|
|
else:
|
|
# Structural category: clear source_type if set
|
|
if self.source_type:
|
|
self.source_type = None
|
|
|
|
has_hadis = self.pk and (
|
|
self.hadis_set.exists() or
|
|
(hasattr(self, 'hadis_items') and self.hadis_items.exists())
|
|
)
|
|
if has_hadis:
|
|
raise ValidationError(
|
|
_('A structural category cannot have hadiths/content items attached. Only topics can contain hadiths.')
|
|
)
|
|
|
|
slug_source_field = 'title'
|
|
|
|
def save(self, *args, **kwargs):
|
|
from utils.text_normalizer import build_search_blob
|
|
self.normalized_text = build_search_blob(
|
|
self.title,
|
|
self.description
|
|
)
|
|
self.full_clean()
|
|
super().save(*args, **kwargs)
|
|
|
|
@property
|
|
def share_link(self):
|
|
if not self.slug:
|
|
return None
|
|
if self.is_topic:
|
|
return f"{settings.DOVODI_DOMAIN}/arguments/category/{self.slug}"
|
|
|
|
sect_type = "shia"
|
|
if self.sect_id:
|
|
try:
|
|
if hasattr(self, "sect") and self.sect:
|
|
sect_type = getattr(self.sect, "sect_type", "shia")
|
|
else:
|
|
from .category import HadisSect
|
|
sect = HadisSect.objects.filter(id=self.sect_id).first()
|
|
if sect:
|
|
sect_type = sect.sect_type
|
|
except Exception:
|
|
sect_type = "shia"
|
|
return f"{settings.DOVODI_DOMAIN}/arguments/categories/{sect_type}/{self.slug}"
|
|
|
|
@property
|
|
def xmind_share_link(self):
|
|
if self.slug:
|
|
return f"{settings.DOVODI_DOMAIN}/xmind/{self.slug}"
|
|
return None
|
|
|
|
|
|
|
|
class Meta:
|
|
indexes = [
|
|
models.Index(fields=['parent', 'sect']),
|
|
models.Index(fields=['sect', 'order'])
|
|
]
|
|
verbose_name = _('Hadis Category')
|
|
verbose_name_plural = _('Hadis Categories')
|
|
ordering = ('order',)
|
|
|
|
def __str__(self):
|
|
title = self.title[0]['text'] if self.title else "Untitled Category"
|
|
return f"{self.sect.sect_type}: {self.source_type} - {title}"
|
|
|
|
def get_title(self,lang):
|
|
"""
|
|
Get title for a specific language
|
|
"""
|
|
|
|
if not self.title or not isinstance(self.title, list):
|
|
return None
|
|
|
|
for tr in self.title:
|
|
if isinstance(tr, dict) and tr.get('language_code') == lang:
|
|
return tr.get('text', '')
|
|
|
|
for tr in self.title:
|
|
if isinstance(tr, dict) and tr.get('language_code') == 'en':
|
|
return tr.get('text', '')
|
|
return None
|
|
|
|
def get_description(self,lang):
|
|
"""
|
|
Get title for a specific language
|
|
"""
|
|
|
|
if not self.description or not isinstance(self.description, list):
|
|
return None
|
|
|
|
for tr in self.description:
|
|
if isinstance(tr, dict) and tr.get('language_code') == lang:
|
|
return tr.get('text', '')
|
|
|
|
for tr in self.description:
|
|
if isinstance(tr, dict) and tr.get('language_code') == 'en':
|
|
return tr.get('text', '')
|
|
return None
|
|
|
|
|
|
|
|
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,
|
|
on_delete=models.CASCADE,
|
|
related_name='quran_verse',
|
|
verbose_name=_('Category')
|
|
)
|
|
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, blank=True, default="", verbose_name=_('Ayah Number'))
|
|
|
|
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'))
|
|
|
|
class Meta:
|
|
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 (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}"
|
|
|
|
|
|
class QuranSecondaryTranslation(models.Model):
|
|
"""
|
|
Model to store multiple secondary translations for a Quran verse per language.
|
|
"""
|
|
quran_verse = models.ForeignKey(
|
|
CategoryQuranVerse,
|
|
on_delete=models.CASCADE,
|
|
related_name='secondary_translations',
|
|
verbose_name=_('Quran Verse')
|
|
)
|
|
language_code = models.CharField(
|
|
max_length=10,
|
|
db_index=True,
|
|
default='ru',
|
|
verbose_name=_('Language Code')
|
|
)
|
|
translation_text = models.TextField(verbose_name=_('Translation Text'))
|
|
translator = models.CharField(max_length=255, verbose_name=_('Translator Name'))
|
|
|
|
created_at = models.DateTimeField(auto_now_add=True, verbose_name=_('Created At'))
|
|
updated_at = models.DateTimeField(auto_now=True, verbose_name=_('Updated At'))
|
|
|
|
class Meta:
|
|
verbose_name = _('Quran Secondary Translation')
|
|
verbose_name_plural = _('Quran Secondary Translations')
|
|
ordering = ['id']
|
|
|
|
def __str__(self):
|
|
return f"[{self.language_code}] {self.translator}: {self.translation_text[:50]}"
|