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.
277 lines
11 KiB
277 lines
11 KiB
from django.views.generic import TemplateView, FormView
|
|
from django.http import Http404
|
|
from .forms import preference_form_builder
|
|
from rest_framework.generics import GenericAPIView
|
|
from rest_framework.response import Response
|
|
from dynamic_preferences.registries import global_preferences_registry
|
|
from .serializers import (
|
|
AboutUsSerializer,
|
|
FAQItemSerializer,
|
|
SupportSerializer,
|
|
CardSerializer,
|
|
AboutUsDobodiSerializer
|
|
)
|
|
|
|
from rest_framework.authentication import TokenAuthentication
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from apps.account.permissions import IsSuperAdmin
|
|
|
|
class AboutUsAPIView(GenericAPIView):
|
|
serializer_class = AboutUsSerializer
|
|
authentication_classes = [TokenAuthentication]
|
|
|
|
def get_permissions(self):
|
|
if self.request.method in ['PUT', 'POST', 'PATCH']:
|
|
return [IsSuperAdmin()]
|
|
return []
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
preferences = global_preferences_registry.manager()
|
|
about_us = preferences.get('aboutus__aboutus', '')
|
|
serializer = self.get_serializer({'content': about_us})
|
|
return Response(serializer.data)
|
|
|
|
def put(self, request, *args, **kwargs):
|
|
serializer = self.get_serializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
content = serializer.validated_data.get('content', '')
|
|
preferences = global_preferences_registry.manager()
|
|
preferences['aboutus__aboutus'] = content
|
|
return Response(serializer.data)
|
|
|
|
class FAQCourseAPIView(GenericAPIView):
|
|
serializer_class = FAQItemSerializer
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
preferences = global_preferences_registry.manager()
|
|
faq_course = preferences.get('FAQ_Course__FAQ_Course', [])
|
|
serializer = self.get_serializer(faq_course, many=True)
|
|
return Response(serializer.data)
|
|
|
|
class FAQGeneralAPIView(GenericAPIView):
|
|
serializer_class = FAQItemSerializer
|
|
authentication_classes = [TokenAuthentication]
|
|
|
|
def get_permissions(self):
|
|
if self.request.method in ['PUT', 'POST', 'PATCH']:
|
|
return [IsAuthenticated(), IsSuperAdmin()]
|
|
return []
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
preferences = global_preferences_registry.manager()
|
|
faq_general = preferences.get('FAQ_General__FAQ_General', [])
|
|
serializer = self.get_serializer(faq_general, many=True)
|
|
return Response(serializer.data)
|
|
|
|
def put(self, request, *args, **kwargs):
|
|
serializer = self.get_serializer(data=request.data, many=True)
|
|
serializer.is_valid(raise_exception=True)
|
|
preferences = global_preferences_registry.manager()
|
|
preferences['FAQ_General__FAQ_General'] = serializer.validated_data
|
|
return Response(serializer.data)
|
|
|
|
class SupportAPIView(GenericAPIView):
|
|
serializer_class = SupportSerializer
|
|
authentication_classes = [TokenAuthentication]
|
|
|
|
def get_permissions(self):
|
|
if self.request.method in ['PUT', 'POST', 'PATCH']:
|
|
return [IsSuperAdmin()]
|
|
return []
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
preferences = global_preferences_registry.manager()
|
|
support = preferences.get('support__support', {})
|
|
if not isinstance(support, dict):
|
|
support = {}
|
|
serializer = self.get_serializer(support)
|
|
return Response(serializer.data)
|
|
|
|
def put(self, request, *args, **kwargs):
|
|
serializer = self.get_serializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
preferences = global_preferences_registry.manager()
|
|
preferences['support__support'] = serializer.validated_data
|
|
return Response(serializer.data)
|
|
|
|
class CardAPIView(GenericAPIView):
|
|
serializer_class = CardSerializer
|
|
authentication_classes = [TokenAuthentication]
|
|
|
|
def get_permissions(self):
|
|
if self.request.method in ['PUT', 'POST', 'PATCH']:
|
|
return [IsSuperAdmin()]
|
|
return []
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
preferences = global_preferences_registry.manager()
|
|
card = preferences.get('card__card', {})
|
|
if not isinstance(card, dict):
|
|
card = {}
|
|
serializer = self.get_serializer(card)
|
|
return Response(serializer.data)
|
|
|
|
def put(self, request, *args, **kwargs):
|
|
serializer = self.get_serializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
preferences = global_preferences_registry.manager()
|
|
preferences['card__card'] = serializer.validated_data
|
|
return Response(serializer.data)
|
|
|
|
class AboutUsDobodiAPIView(GenericAPIView):
|
|
serializer_class = AboutUsDobodiSerializer
|
|
authentication_classes = [TokenAuthentication]
|
|
|
|
def get_permissions(self):
|
|
if self.request.method in ['PUT', 'POST', 'PATCH']:
|
|
return [IsAuthenticated(), IsSuperAdmin()]
|
|
return []
|
|
|
|
def _build_response_payload(self, request, raw_data):
|
|
from apps.hadis.serializers.category import get_localized_text
|
|
from apps.library.models import Book
|
|
from apps.article.models import Article
|
|
from apps.video.models import Video
|
|
from apps.podcast.models import Podcast
|
|
from apps.hadis.models import Transmitters
|
|
|
|
data = dict(raw_data) if isinstance(raw_data, dict) else {}
|
|
translations = data.get('translations')
|
|
if not isinstance(translations, list):
|
|
translations = []
|
|
|
|
title_translations = data.get('title_translations')
|
|
if not isinstance(title_translations, list):
|
|
title_translations = []
|
|
|
|
# Backward compatibility: if translations is empty but legacy content exists, seed it
|
|
legacy_content = data.get('content') or data.get('description') or ''
|
|
if not translations and legacy_content:
|
|
translations = [{'language_code': 'en', 'text': legacy_content, 'title': legacy_content}]
|
|
|
|
footer_translations = data.get('footer_translations')
|
|
if not isinstance(footer_translations, list):
|
|
footer_translations = []
|
|
|
|
legacy_footer = data.get('footer_description') or ''
|
|
if not footer_translations and legacy_footer:
|
|
footer_translations = [{'language_code': 'en', 'text': legacy_footer, 'title': legacy_footer}]
|
|
|
|
localized_content = get_localized_text(translations, request=request) or legacy_content or ''
|
|
localized_footer = get_localized_text(footer_translations, request=request) or legacy_footer or ''
|
|
localized_title = get_localized_text(title_translations, request=request) or data.get('title') or ''
|
|
|
|
payload = {
|
|
**data,
|
|
'title': localized_title,
|
|
'content': localized_content,
|
|
'description': localized_content,
|
|
'footer_description': localized_footer,
|
|
'translations': translations,
|
|
'footer_translations': footer_translations,
|
|
'title_translations': title_translations,
|
|
'books_count': Book.objects.filter(status=True).count(),
|
|
'articles_count': Article.objects.filter(status=True).count(),
|
|
'videos_count': Video.objects.filter(status=True).count(),
|
|
'podcasts_count': Podcast.objects.filter(status=True).count(),
|
|
'scholars_count': Transmitters.objects.count(),
|
|
}
|
|
return payload
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
preferences = global_preferences_registry.manager()
|
|
about_us_dobodi = preferences.get('about_us_dobodi__about_us_dobodi', {})
|
|
payload = self._build_response_payload(request, about_us_dobodi)
|
|
serializer = self.get_serializer(payload)
|
|
return Response(serializer.data)
|
|
|
|
def put(self, request, *args, **kwargs):
|
|
serializer = self.get_serializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
preferences = global_preferences_registry.manager()
|
|
existing = preferences.get('about_us_dobodi__about_us_dobodi', {})
|
|
if not isinstance(existing, dict):
|
|
existing = {}
|
|
|
|
validated = {**existing, **dict(serializer.validated_data)}
|
|
if 'translations' not in request.data and 'translations' in existing:
|
|
validated['translations'] = existing['translations']
|
|
if 'footer_translations' not in request.data and 'footer_translations' in existing:
|
|
validated['footer_translations'] = existing['footer_translations']
|
|
|
|
from apps.hadis.serializers.category import get_localized_text
|
|
|
|
# Ensure content/description fallback is synced with translations if provided
|
|
translations = validated.get('translations')
|
|
if isinstance(translations, list) and translations:
|
|
default_text = get_localized_text(translations, fallback_lang='en') or ''
|
|
if default_text:
|
|
validated['content'] = default_text
|
|
validated['description'] = default_text
|
|
|
|
# Ensure footer_description fallback is synced with footer_translations if provided
|
|
footer_translations = validated.get('footer_translations')
|
|
if isinstance(footer_translations, list) and footer_translations:
|
|
default_footer = get_localized_text(footer_translations, fallback_lang='en') or ''
|
|
if default_footer:
|
|
validated['footer_description'] = default_footer
|
|
|
|
preferences['about_us_dobodi__about_us_dobodi'] = validated
|
|
payload = self._build_response_payload(request, validated)
|
|
return Response(self.get_serializer(payload).data)
|
|
|
|
|
|
"""Todo : remove these views and use only context processors"""
|
|
|
|
|
|
class RegularTemplateView(TemplateView):
|
|
"""Used for testing context"""
|
|
|
|
template_name = "dynamic_preferences/testcontext.html"
|
|
|
|
|
|
class PreferenceFormView(FormView):
|
|
"""
|
|
Display a form for updating preferences of the given
|
|
section provided via URL arg.
|
|
If no section is provided, will display a form for all
|
|
fields of a given registry.
|
|
"""
|
|
|
|
#: the registry for preference lookups
|
|
registry = None
|
|
|
|
#: will be used by :py:func:`forms.preference_form_builder`
|
|
# to create the form
|
|
form_class = None
|
|
template_name = "dynamic_preferences/form.html"
|
|
|
|
def dispatch(self, request, *args, **kwargs):
|
|
self.section_name = kwargs.get("section", None)
|
|
if self.section_name:
|
|
try:
|
|
self.section = self.registry.section_objects[self.section_name]
|
|
except KeyError:
|
|
raise Http404
|
|
else:
|
|
self.section = None
|
|
return super(PreferenceFormView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_form_class(self, *args, **kwargs):
|
|
form_class = preference_form_builder(self.form_class, section=self.section_name)
|
|
return form_class
|
|
|
|
def get_context_data(self, *args, **kwargs):
|
|
context = super(PreferenceFormView, self).get_context_data(*args, **kwargs)
|
|
context["registry"] = self.registry
|
|
context["section"] = self.section
|
|
|
|
return context
|
|
|
|
def get_success_url(self):
|
|
return self.request.path
|
|
|
|
def form_valid(self, form):
|
|
|
|
form.update_preferences()
|
|
return super(PreferenceFormView, self).form_valid(form)
|