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.
251 lines
10 KiB
251 lines
10 KiB
import asyncio
|
|
import logging
|
|
from apps.account.models import Notification, NotificationTemplate
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class SafeDict(dict):
|
|
def __missing__(self, key):
|
|
return f"{{{key}}}"
|
|
|
|
def get_template_context(user, notification_type, data):
|
|
"""
|
|
Builds a dynamic context dictionary containing user info and target entity details
|
|
(course, lesson, quiz, session) to format templates.
|
|
"""
|
|
context = {
|
|
'student_name': getattr(user, 'fullname', user.username) or user.username,
|
|
'fullname': getattr(user, 'fullname', user.username) or user.username,
|
|
'username': user.username,
|
|
}
|
|
|
|
if not data or not isinstance(data, dict):
|
|
return context
|
|
|
|
# Import models dynamically inside function to avoid circular imports
|
|
from apps.course.models.course import Course
|
|
from apps.course.models.lesson import CourseLesson
|
|
from apps.course.models.live_session import CourseLiveSession
|
|
from apps.quiz.models import Quiz
|
|
|
|
try:
|
|
# 1. Course details
|
|
course_id = data.get('course_id')
|
|
if not course_id and 'session_id' in data:
|
|
session = CourseLiveSession.objects.filter(id=data['session_id']).first()
|
|
if session:
|
|
course_id = session.course_id
|
|
|
|
if course_id:
|
|
course = Course.objects.filter(id=course_id).first()
|
|
if course:
|
|
title_val = course.title
|
|
# course.title might be a JSON list or dict or string
|
|
if isinstance(title_val, list) and title_val:
|
|
course_title = title_val[0].get('title', '')
|
|
elif isinstance(title_val, dict):
|
|
course_title = title_val.get('title', '')
|
|
else:
|
|
course_title = str(title_val)
|
|
context['course_title'] = course_title
|
|
context['course_name'] = course_title
|
|
|
|
slug_val = course.slug
|
|
if isinstance(slug_val, list) and slug_val:
|
|
course_slug = slug_val[0].get('title', '')
|
|
elif isinstance(slug_val, dict):
|
|
course_slug = slug_val.get('title', '')
|
|
else:
|
|
course_slug = str(slug_val)
|
|
context['course_slug'] = course_slug
|
|
|
|
# 2. Lesson details
|
|
lesson_id = data.get('lesson_id')
|
|
if lesson_id:
|
|
lesson = CourseLesson.objects.filter(id=lesson_id).first()
|
|
if lesson:
|
|
title_val = lesson.title
|
|
if isinstance(title_val, list) and title_val:
|
|
lesson_title = title_val[0].get('title', '')
|
|
elif isinstance(title_val, dict):
|
|
lesson_title = title_val.get('title', '')
|
|
else:
|
|
lesson_title = str(title_val)
|
|
context['lesson_title'] = lesson_title
|
|
|
|
# 3. Quiz details
|
|
quiz_id = data.get('quiz_id')
|
|
if quiz_id:
|
|
quiz = Quiz.objects.filter(id=quiz_id).first()
|
|
if quiz:
|
|
title_val = quiz.title
|
|
if isinstance(title_val, list) and title_val:
|
|
quiz_title = title_val[0].get('title', '')
|
|
elif isinstance(title_val, dict):
|
|
quiz_title = title_val.get('title', '')
|
|
else:
|
|
quiz_title = str(title_val)
|
|
context['quiz_title'] = quiz_title
|
|
|
|
# 4. Live Session details
|
|
session_id = data.get('session_id')
|
|
if session_id:
|
|
session = CourseLiveSession.objects.filter(id=session_id).first()
|
|
if session:
|
|
context['session_subject'] = session.subject
|
|
if session.start_at:
|
|
context['session_start_time'] = session.start_at.strftime('%H:%M')
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error building notification template context: {e}")
|
|
|
|
return context
|
|
|
|
def resolve_notification_route(notification_type, data):
|
|
"""
|
|
Resolves standard GoRouter paths based on notification type and payload data.
|
|
"""
|
|
if not data or not isinstance(data, dict):
|
|
return None
|
|
|
|
# Import models dynamically inside function to avoid circular imports
|
|
from apps.course.models.course import Course
|
|
from apps.course.models.live_session import CourseLiveSession
|
|
|
|
try:
|
|
# Group 1: Course related paths (/course_info?slug=...)
|
|
if notification_type in ['course_registered', 'course_completed', 'new_course_weekly',
|
|
'live_class_rescheduled', 'live_class_cancelled',
|
|
'live_recording_available', 'missed_live_sessions',
|
|
'course_access_granted']:
|
|
course_id = data.get('course_id')
|
|
if not course_id and 'session_id' in data:
|
|
session = CourseLiveSession.objects.filter(id=data['session_id']).first()
|
|
if session:
|
|
course_id = session.course_id
|
|
|
|
if course_id:
|
|
course = Course.objects.filter(id=course_id).first()
|
|
if course:
|
|
slug = course.slug[0].get('title') if isinstance(course.slug, list) and course.slug else course.slug
|
|
return f"/course_info?slug={slug}"
|
|
|
|
# Group 2: Lesson path (/lesson?slug=...)
|
|
elif notification_type == 'lesson_completed':
|
|
course_id = data.get('course_id')
|
|
if course_id:
|
|
course = Course.objects.filter(id=course_id).first()
|
|
if course:
|
|
slug = course.slug[0].get('title') if isinstance(course.slug, list) and course.slug else course.slug
|
|
return f"/lesson?slug={slug}"
|
|
|
|
# Group 3: Quiz path (/course_info/quiz?slug=...)
|
|
elif notification_type == 'low_quiz_result':
|
|
from apps.quiz.models import Quiz
|
|
quiz = Quiz.objects.filter(id=data.get('quiz_id')).first()
|
|
if quiz and quiz.course:
|
|
course = quiz.course
|
|
slug = course.slug[0].get('title') if isinstance(course.slug, list) and course.slug else course.slug
|
|
return f"/course_info/quiz?slug={slug}"
|
|
|
|
# Group 4: Chat Room path (/chat/chat_details?room_id=...)
|
|
elif notification_type in ['teacher_reply', 'support_reply']:
|
|
room_id = data.get('room_id')
|
|
if room_id:
|
|
return f"/chat/chat_details?room_id={room_id}"
|
|
|
|
# Group 5: Transactions path
|
|
elif notification_type in ['payment_successful', 'payment_failed', 'refund_completed']:
|
|
return "/profile/transactions"
|
|
|
|
# Group 6: Home path
|
|
elif notification_type == 'student_inactivity':
|
|
return "/home"
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error resolving route for type={notification_type}, data={data}: {e}")
|
|
|
|
return None
|
|
|
|
def create_and_send_notification(user, title_en, body_en, title_fa, body_fa, service='imam-javad',
|
|
data=None, notification_type=None, action='navigate', navigate_to=None):
|
|
"""
|
|
Creates a Notification record in the database and sends a push notification to FCM.
|
|
Loads and renders the NotificationTemplate from the database if present.
|
|
If the template is inactive, the notification is discarded.
|
|
"""
|
|
# Auto-resolve notification type from data payload if not provided
|
|
if not notification_type and isinstance(data, dict):
|
|
notification_type = data.get('type')
|
|
|
|
# 1. Check for template settings in the database
|
|
if notification_type:
|
|
template = NotificationTemplate.objects.filter(notification_type=notification_type).first()
|
|
if template:
|
|
if not template.is_active:
|
|
logger.info(f"Notification type '{notification_type}' is disabled via database template settings.")
|
|
return None
|
|
# Override templates with database values
|
|
title_fa = template.title_fa
|
|
title_en = template.title_en
|
|
body_fa = template.body_fa
|
|
body_en = template.body_en
|
|
|
|
# 2. Render templates safely with dynamic context
|
|
context = get_template_context(user, notification_type, data)
|
|
safe_ctx = SafeDict(context)
|
|
|
|
try:
|
|
title_fa = title_fa.format(**safe_ctx) if title_fa else ""
|
|
title_en = title_en.format(**safe_ctx) if title_en else ""
|
|
body_fa = body_fa.format(**safe_ctx) if body_fa else ""
|
|
body_en = body_en.format(**safe_ctx) if body_en else ""
|
|
except Exception as e:
|
|
logger.error(f"Error formatting templates: {e}")
|
|
|
|
# Determine user localized text
|
|
lang = getattr(user, 'language', None)
|
|
lang_code = lang.code if lang and hasattr(lang, 'code') else 'fa'
|
|
|
|
title = title_fa if lang_code == 'fa' else title_en
|
|
message = body_fa if lang_code == 'fa' else body_en
|
|
|
|
# Auto-resolve GoRouter navigation route if not provided
|
|
if not navigate_to and notification_type:
|
|
navigate_to = resolve_notification_route(notification_type, data)
|
|
|
|
# Save to database
|
|
from apps.account.tasks import send_notification
|
|
notif = Notification.objects.create(
|
|
user=user,
|
|
title=title,
|
|
message=message,
|
|
service=service,
|
|
notification_type=notification_type,
|
|
action=action,
|
|
navigate_to=navigate_to
|
|
)
|
|
|
|
fcm_token = getattr(user, 'fcm', None)
|
|
if fcm_token:
|
|
# Prepare the payload including the new routing properties
|
|
fcm_data = dict(data or {})
|
|
fcm_data.setdefault('type', notification_type or '')
|
|
fcm_data.setdefault('action', action or '')
|
|
fcm_data.setdefault('navigate_to', navigate_to or '')
|
|
|
|
try:
|
|
try:
|
|
loop = asyncio.get_event_loop()
|
|
except RuntimeError:
|
|
loop = asyncio.new_event_loop()
|
|
asyncio.set_event_loop(loop)
|
|
|
|
if loop.is_running():
|
|
loop.create_task(send_notification([fcm_token], title, message, fcm_data))
|
|
else:
|
|
loop.run_until_complete(send_notification([fcm_token], title, message, fcm_data))
|
|
except Exception as e:
|
|
logger.error(f"Failed to send push notification via FCM: {e}")
|
|
|
|
return notif
|