# ===================================================== # EXAM VIEWS FOR PARENT MODULE # ===================================================== from datetime import date from django.db.models import Q, Prefetch from django.utils import timezone from rest_framework.views import APIView from rest_framework.response import Response from rest_framework import status from rest_framework.permissions import IsAuthenticated from django.db.models import Sum, Count, Q, Avg, F, FloatField from people.models import Parent from academics.models import StudentEnrollment, AcademicYear from exam.models import ( Exam, ExamSubject, StudentMarks, StudentExamRegistration, ExamResult, ClassTest, ClassTestStudent ) from .serializers import ( ExamListSerializer, ExamDetailSerializer, StudentMarksSerializer, ExamResultSerializer, ExamRegistrationStatusSerializer, ExamSubjectSerializer ) import logging logger = logging.getLogger(__name__) class ParentUpcomingExamsView(APIView): """ GET /parent/exams/upcoming/ Get all upcoming and ongoing exams for all children of the parent. """ permission_classes = [IsAuthenticated] def get(self, request): try: parent = Parent.objects.get(external_user_id=request.user.id) student_parents = parent.student_parents.filter(is_active=True).select_related('student') if not student_parents.exists(): return Response({ "success": True, "data": {"upcoming_exams": [], "ongoing_exams": [], "total_upcoming": 0, "total_ongoing": 0} }, status=status.HTTP_200_OK) student_ids = list(student_parents.values_list('student_id', flat=True)) enrollment_id = request.query_params.get('enrollment_id') academic_year_id = request.query_params.get('academic_year_id') enrollments = StudentEnrollment.objects.filter( student_id__in=student_ids, is_active=True ).select_related('academic_class') if enrollment_id: enrollments = enrollments.filter(id=enrollment_id) if academic_year_id: enrollments = enrollments.filter(academic_class__academic_year_id=academic_year_id) if not enrollments.exists(): return Response({ "success": True, "data": {"upcoming_exams": [], "ongoing_exams": [], "total_upcoming": 0, "total_ongoing": 0} }, status=status.HTTP_200_OK) class_ids = list(enrollments.values_list('academic_class_id', flat=True).distinct()) today = timezone.now().date() exams_qs = Exam.objects.filter( academic_class_id__in=class_ids, is_active=True, status__in=['scheduled', 'ongoing'] ).select_related('exam_type', 'academic_class', 'academic_year' ).prefetch_related('exam_subjects').order_by('start_date') upcoming_exams = [] ongoing_exams = [] for exam in exams_qs: exam_data = ExamListSerializer(exam, context={'request': request}).data if exam.start_date > today: upcoming_exams.append(exam_data) elif exam.start_date <= today <= exam.end_date: ongoing_exams.append(exam_data) return Response({ "success": True, "data": { "upcoming_exams": upcoming_exams, "ongoing_exams": ongoing_exams, "total_upcoming": len(upcoming_exams), "total_ongoing": len(ongoing_exams) } }, status=status.HTTP_200_OK) except Parent.DoesNotExist: return Response({"success": False, "message": "Parent profile not found"}, status=status.HTTP_404_NOT_FOUND) except Exception as e: logger.error(f"Error in ParentUpcomingExamsView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentPastExamsView(APIView): """ GET /parent/exams/past/ Get all past exams (completed) for all children of the parent. """ permission_classes = [IsAuthenticated] def get(self, request): try: parent = Parent.objects.get(external_user_id=request.user.id) student_parents = parent.student_parents.filter(is_active=True).select_related('student') enrollment_id = request.query_params.get('enrollment_id') academic_year_id = request.query_params.get('academic_year_id') student_ids = list(student_parents.values_list('student_id', flat=True)) enrollments = StudentEnrollment.objects.filter( student_id__in=student_ids, is_active=True ).select_related('academic_class') if enrollment_id: enrollments = enrollments.filter(id=enrollment_id) if academic_year_id: enrollments = enrollments.filter(academic_class__academic_year_id=academic_year_id) if not enrollments.exists(): return Response({ "success": True, "data": { "completed_exams": [], "results_published_exams": [], "total_completed": 0, "total_results_published": 0 } }, status=status.HTTP_200_OK) class_ids = list(enrollments.values_list('academic_class_id', flat=True).distinct()) today = timezone.now().date() exams_qs = Exam.objects.filter( academic_class_id__in=class_ids, is_active=True, end_date__lt=today ).select_related('exam_type', 'academic_class', 'academic_year').order_by('-end_date') exams_qs2 = Exam.objects.filter( academic_class_id__in=class_ids, is_active=True, status__in=['completed', 'results_published'] ).select_related('exam_type', 'academic_class', 'academic_year').order_by('-end_date') all_exams = (exams_qs | exams_qs2).distinct() completed_exams = [] results_published_exams = [] for exam in all_exams: exam_data = ExamListSerializer(exam, context={'request': request}).data if exam.status == 'results_published': results_published_exams.append(exam_data) else: completed_exams.append(exam_data) return Response({ "success": True, "data": { "completed_exams": completed_exams, "results_published_exams": results_published_exams, "total_completed": len(completed_exams), "total_results_published": len(results_published_exams) } }, status=status.HTTP_200_OK) except Parent.DoesNotExist: return Response({"success": False, "message": "Parent profile not found"}, status=status.HTTP_404_NOT_FOUND) except Exception as e: logger.error(f"Error in ParentPastExamsView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentExamDetailView(APIView): """ GET /parent/exams// Get detailed exam information. """ permission_classes = [IsAuthenticated] def get(self, request, exam_id): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') academic_year_id = request.query_params.get('academic_year_id') if not enrollment_id: return Response( {"success": False, "message": "enrollment_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id enrollment = StudentEnrollment.objects.filter( **enrollment_filters ).select_related('student', 'academic_class').first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) exam = Exam.objects.filter( id=exam_id, academic_class=enrollment.academic_class, is_active=True ).select_related('exam_type', 'academic_class', 'academic_year' ).prefetch_related( Prefetch('exam_subjects', queryset=ExamSubject.objects.filter(is_active=True).order_by('exam_date', 'start_time')) ).first() if not exam: return Response({"success": False, "message": "Exam not found"}, status=status.HTTP_404_NOT_FOUND) registration = StudentExamRegistration.objects.filter( student_enrollment=enrollment, exam=exam, is_registered=True ).first() exam_data = ExamDetailSerializer(exam, context={'request': request}).data exam_data['student_registration'] = { 'is_registered': registration is not None, 'hall_ticket_number': registration.hall_ticket_number if registration else None, 'seat_number': registration.seat_number if registration else None, 'needs_special_accommodation': registration.needs_special_accommodation if registration else False, 'accommodation_details': registration.accommodation_details if registration else None } exam_data['enrollment_info'] = { 'enrollment_id': enrollment.id, 'student_name': enrollment.student.full_name, 'roll_number': enrollment.roll_number } return Response({"success": True, "data": exam_data}, status=status.HTTP_200_OK) except Parent.DoesNotExist: return Response({"success": False, "message": "Parent profile not found"}, status=status.HTTP_404_NOT_FOUND) except Exception as e: logger.error(f"Error in ParentExamDetailView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentExamSubjectDetailView(APIView): """ GET /parent/exams//subjects// """ permission_classes = [IsAuthenticated] def get(self, request, exam_id, subject_id): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') academic_year_id = request.query_params.get('academic_year_id') if not enrollment_id: return Response( {"success": False, "message": "enrollment_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id enrollment = StudentEnrollment.objects.filter(**enrollment_filters).first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) exam_subject = ExamSubject.objects.filter( id=subject_id, exam_id=exam_id, is_active=True ).select_related('exam', 'subject', 'teacher_in_charge').prefetch_related('invigilators').first() if not exam_subject: return Response({"success": False, "message": "Exam subject not found"}, status=status.HTTP_404_NOT_FOUND) exam = exam_subject.exam if exam.academic_class_id != enrollment.academic_class_id: return Response({"success": False, "message": "Exam not available for this class"}, status=status.HTTP_403_FORBIDDEN) response_data = { 'id': exam_subject.id, 'subject': exam_subject.subject.id, 'subject_name': exam_subject.subject.name, 'subject_code': exam_subject.subject.code, 'max_marks': exam_subject.max_marks, 'passing_marks': exam_subject.passing_marks, 'exam_date': exam_subject.exam_date, 'start_time': exam_subject.start_time, 'duration_minutes': exam_subject.duration_minutes, 'room_number': exam_subject.room_number, 'extra_instructions': exam_subject.extra_instructions, 'exam_info': { 'id': exam.id, 'name': exam.name, 'code': exam.code, 'status': exam.status, 'is_results_published': exam.status == 'results_published' } } if exam.status == 'results_published': marks = StudentMarks.objects.filter( student_enrollment=enrollment, exam_subject=exam_subject ).first() if marks: response_data['student_marks'] = { 'obtained_marks': marks.obtained_marks, 'percentage': marks.percentage, 'is_passed': marks.is_passed, 'grade': marks.grade, 'is_absent': marks.is_absent } response_data['is_absent'] = marks.is_absent else: response_data['student_marks'] = None response_data['is_absent'] = False else: response_data['student_marks'] = None response_data['is_absent'] = False registration = StudentExamRegistration.objects.filter( student_enrollment=enrollment, exam=exam, is_registered=True ).first() response_data['is_registered'] = registration is not None response_data['hall_ticket_number'] = registration.hall_ticket_number if registration else None response_data['seat_number'] = registration.seat_number if registration else None return Response({"success": True, "data": response_data}, status=status.HTTP_200_OK) except Exception as e: logger.error(f"Error in ParentExamSubjectDetailView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentExamResultView(APIView): """ GET /parent/exams//result/ """ permission_classes = [IsAuthenticated] def get(self, request, exam_id): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') if not enrollment_id: return Response( {"success": False, "message": "enrollment_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) academic_year_id = request.query_params.get('academic_year_id') enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id enrollment = StudentEnrollment.objects.filter( **enrollment_filters ).select_related('student', 'academic_class').first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) exam = Exam.objects.filter( id=exam_id, academic_class=enrollment.academic_class, is_active=True ).first() if not exam: return Response({"success": False, "message": "Exam not found"}, status=status.HTTP_404_NOT_FOUND) if exam.status != 'results_published': return Response({ "success": False, "message": "Results are not published yet", "data": {"exam_status": exam.status} }, status=status.HTTP_400_BAD_REQUEST) exam_result = ExamResult.objects.filter(student_enrollment=enrollment, exam=exam).first() if not exam_result: return Response({"success": False, "message": "Result not found"}, status=status.HTTP_404_NOT_FOUND) exam_subjects = ExamSubject.objects.filter(exam=exam, is_active=True) subject_marks = StudentMarks.objects.filter( student_enrollment=enrollment, exam_subject__in=exam_subjects ) total_subjects = exam_subjects.count() passed_subjects = sum(1 for m in subject_marks if m.is_passed) return Response({ "success": True, "data": { "exam_info": { "id": exam.id, "name": exam.name, "code": exam.code, "start_date": exam.start_date, "end_date": exam.end_date }, "result_summary": { "total_marks": exam_result.total_marks, "total_max_marks": exam_result.total_max_marks, "percentage": exam_result.percentage, "overall_grade": exam_result.overall_grade, "rank": exam_result.rank, "result_status": exam_result.result_status }, "subject_marks": [ { "subject_name": m.exam_subject.subject.name, "obtained_marks": m.obtained_marks, "max_marks": m.exam_subject.max_marks, "percentage": m.percentage, "is_passed": m.is_passed, "grade": m.grade } for m in subject_marks ], "statistics": { "total_subjects": total_subjects, "passed_subjects": passed_subjects, "failed_subjects": total_subjects - passed_subjects, "pass_percentage": (passed_subjects / total_subjects * 100) if total_subjects > 0 else 0 } } }, status=status.HTTP_200_OK) except Exception as e: logger.error(f"Error in ParentExamResultView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentStudentExamRegistrationStatusView(APIView): """ GET /parent/exams/registration-status/ """ permission_classes = [IsAuthenticated] def get(self, request): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') if not enrollment_id: return Response( {"success": False, "message": "enrollment_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) academic_year_id = request.query_params.get('academic_year_id') enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id enrollment = StudentEnrollment.objects.filter(**enrollment_filters).first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) registrations = StudentExamRegistration.objects.filter( student_enrollment=enrollment, is_registered=True ).select_related('exam').order_by('-exam__start_date') data = [] for reg in registrations: data.append({ 'exam_id': reg.exam.id, 'exam_name': reg.exam.name, 'exam_code': reg.exam.code, 'exam_start_date': reg.exam.start_date, 'exam_end_date': reg.exam.end_date, 'exam_status': reg.exam.status, 'is_registered': reg.is_registered, 'hall_ticket_number': reg.hall_ticket_number, 'seat_number': reg.seat_number, 'registration_date': reg.registration_date }) return Response({"success": True, "data": data}, status=status.HTTP_200_OK) except Exception as e: logger.error(f"Error in ParentStudentExamRegistrationStatusView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentExamHallTicketView(APIView): """ GET /parent/exams//hall-ticket/ """ permission_classes = [IsAuthenticated] def get(self, request, exam_id): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') if not enrollment_id: return Response( {"success": False, "message": "enrollment_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) academic_year_id = request.query_params.get('academic_year_id') enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id enrollment = StudentEnrollment.objects.filter( **enrollment_filters ).select_related('student', 'academic_class').first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) exam = Exam.objects.filter( id=exam_id, academic_class=enrollment.academic_class, is_active=True ).select_related('exam_type', 'academic_year').first() if not exam: return Response({"success": False, "message": "Exam not found"}, status=status.HTTP_404_NOT_FOUND) registration = StudentExamRegistration.objects.filter( student_enrollment=enrollment, exam=exam, is_registered=True ).first() if not registration: return Response({"success": False, "message": "Student not registered"}, status=status.HTTP_404_NOT_FOUND) exam_subjects = ExamSubject.objects.filter(exam=exam, is_active=True).order_by('exam_date', 'start_time') return Response({ "success": True, "data": { "exam_info": { "id": exam.id, "name": exam.name, "code": exam.code, "exam_type": exam.exam_type.name, "start_date": exam.start_date, "end_date": exam.end_date, "instructions": exam.instructions }, "student_info": { "enrollment_id": enrollment.id, "student_id": enrollment.student.id, "name": enrollment.student.full_name, "roll_number": enrollment.roll_number, "class_name": str(enrollment.academic_class), "academic_year": exam.academic_year.name }, "registration_info": { "hall_ticket_number": registration.hall_ticket_number, "seat_number": registration.seat_number, "registration_date": registration.registration_date }, "exam_schedule": [ { "subject": es.subject.name, "subject_code": es.subject.code, "date": es.exam_date, "start_time": es.start_time, "duration_minutes": es.duration_minutes, "room_number": es.room_number, "max_marks": es.max_marks, "passing_marks": es.passing_marks } for es in exam_subjects ] } }, status=status.HTTP_200_OK) except Exception as e: logger.error(f"Error in ParentExamHallTicketView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentAllExamsSummaryView(APIView): """ GET /parent/exams/summary/ Get exams summary for a specific student using enrollment_id. Query Parameters: - enrollment_id (required) """ permission_classes = [IsAuthenticated] def get(self, request): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') if not enrollment_id: return Response( {"success": False, "message": "enrollment_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) academic_year_id = request.query_params.get('academic_year_id') enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id # Get enrollment and verify parent has access enrollment = StudentEnrollment.objects.filter( **enrollment_filters ).select_related('student', 'academic_class', 'academic_class__standard', 'academic_class__section').first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) # Verify parent has access to this student student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) today = timezone.now().date() # Get exams for this student's class exams = Exam.objects.filter( academic_class=enrollment.academic_class, is_active=True ).select_related('exam_type') # Initialize counters upcoming_exams = [] ongoing_exams = [] completed_exams = [] results_published_exams = [] for exam in exams: exam_info = { "id": exam.id, "name": exam.name, "code": exam.code, "exam_type": exam.exam_type.name, "start_date": exam.start_date, "end_date": exam.end_date, "status": exam.status } if exam.start_date > today: upcoming_exams.append(exam_info) elif exam.start_date <= today <= exam.end_date: ongoing_exams.append(exam_info) elif exam.status == 'results_published': results_published_exams.append(exam_info) else: completed_exams.append(exam_info) # Build response student_data = { "student_id": enrollment.student.id, "student_name": enrollment.student.full_name, "profile_image": enrollment.student.profile_image.url if enrollment.student.profile_image else None, "roll_number": enrollment.roll_number, "relationship": student_parent.relationship, "class_name": str(enrollment.academic_class), "standard": enrollment.academic_class.standard.name, "section": enrollment.academic_class.section.code, "exams_summary": { "upcoming": len(upcoming_exams), "ongoing": len(ongoing_exams), "completed": len(completed_exams), "results_published": len(results_published_exams), "total": len(upcoming_exams) + len(ongoing_exams) + len(completed_exams) + len(results_published_exams) }, "exams": { "upcoming": upcoming_exams, "ongoing": ongoing_exams, "completed": completed_exams, "results_published": results_published_exams } } return Response({ "success": True, "data": student_data }, status=status.HTTP_200_OK) except Parent.DoesNotExist: return Response({"success": False, "message": "Parent profile not found"}, status=status.HTTP_404_NOT_FOUND) except Exception as e: logger.error(f"Error in ParentAllExamsSummaryView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentExamSubjectWiseResultView(APIView): """ GET /parent/exams/subject-wise-result/ Get subject-wise detailed result for a specific exam. Query Parameters: - enrollment_id (required) - exam_id (required) """ permission_classes = [IsAuthenticated] def get(self, request): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') exam_id = request.query_params.get('exam_id') if not enrollment_id or not exam_id: return Response( {"success": False, "message": "enrollment_id and exam_id are required"}, status=status.HTTP_400_BAD_REQUEST ) academic_year_id = request.query_params.get('academic_year_id') enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id # Get enrollment and verify parent has access enrollment = StudentEnrollment.objects.filter( **enrollment_filters ).select_related('student', 'academic_class').first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) # Verify parent has access to this student student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) # Get exam exam = Exam.objects.filter( id=exam_id, academic_class=enrollment.academic_class, is_active=True ).select_related('exam_type', 'academic_year').first() if not exam: return Response({"success": False, "message": "Exam not found"}, status=status.HTTP_404_NOT_FOUND) # Get all subjects for this exam exam_subjects = ExamSubject.objects.filter(exam=exam, is_active=True).select_related('subject') # Get marks for this student subject_marks = StudentMarks.objects.filter( student_enrollment=enrollment, exam_subject__in=exam_subjects ).select_related('exam_subject__subject', 'entered_by') # Create a map for quick lookup marks_map = {sm.exam_subject_id: sm for sm in subject_marks} # Build subject-wise result data subject_results = [] total_obtained = 0 total_max = 0 passed_count = 0 failed_count = 0 absent_count = 0 for exam_subject in exam_subjects: subject_mark = marks_map.get(exam_subject.id) if subject_mark: obtained = subject_mark.obtained_marks if subject_mark.obtained_marks else 0 max_marks = exam_subject.max_marks is_passed = subject_mark.is_passed if subject_mark.obtained_marks is not None else False subject_results.append({ 'subject_id': exam_subject.subject.id, 'subject_name': exam_subject.subject.name, 'subject_code': exam_subject.subject.code, 'max_marks': max_marks, 'obtained_marks': float(obtained) if obtained else None, 'percentage': float(subject_mark.percentage) if subject_mark.percentage else None, 'is_passed': is_passed, 'grade': subject_mark.grade, 'is_absent': subject_mark.is_absent, 'remarks': subject_mark.remarks, 'entered_by': subject_mark.entered_by.full_name if subject_mark.entered_by else None, 'last_updated': subject_mark.last_updated }) if not subject_mark.is_absent and subject_mark.obtained_marks is not None: total_obtained += subject_mark.obtained_marks total_max += max_marks if is_passed: passed_count += 1 else: failed_count += 1 elif subject_mark.is_absent: absent_count += 1 total_max += max_marks else: # No marks entered yet subject_results.append({ 'subject_id': exam_subject.subject.id, 'subject_name': exam_subject.subject.name, 'subject_code': exam_subject.subject.code, 'max_marks': exam_subject.max_marks, 'obtained_marks': None, 'percentage': None, 'is_passed': False, 'grade': None, 'is_absent': False, 'remarks': None, 'entered_by': None, 'last_updated': None }) total_max += exam_subject.max_marks # Calculate overall percentage overall_percentage = (total_obtained / total_max * 100) if total_max > 0 else 0 # Get ExamResult if exists exam_result = ExamResult.objects.filter( student_enrollment=enrollment, exam=exam ).first() return Response({ "success": True, "data": { "exam_info": { "exam_id": exam.id, "exam_name": exam.name, "exam_code": exam.code, "exam_type": exam.exam_type.name, "exam_status": exam.status, "start_date": exam.start_date, "end_date": exam.end_date, "weightage": float(exam.weightage) if exam.weightage else None, "instructions": exam.instructions }, "student_info": { "student_id": enrollment.student.id, "student_name": enrollment.student.full_name, "roll_number": enrollment.roll_number, "profile_image": enrollment.student.profile_image.url if enrollment.student.profile_image else None, "class_name": str(enrollment.academic_class) }, "overall_result": { "total_marks": float(total_obtained), "total_max_marks": float(total_max), "percentage": round(overall_percentage, 2), "overall_grade": exam_result.overall_grade if exam_result else None, "rank": exam_result.rank if exam_result else None, "result_status": exam_result.result_status if exam_result else ('pending' if exam.status == 'results_published' else 'not_published'), "passed_subjects": passed_count, "failed_subjects": failed_count, "absent_subjects": absent_count, "total_subjects": len(subject_results) }, "subject_results": subject_results } }, status=status.HTTP_200_OK) except Parent.DoesNotExist: return Response({"success": False, "message": "Parent profile not found"}, status=status.HTTP_404_NOT_FOUND) except Exception as e: logger.error(f"Error in ParentExamSubjectWiseResultView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) class ParentStudentClassTestsView(APIView): """ GET /parent/exams/class-tests/ Get mini/daily class test results for a specific student. Query Parameters: - enrollment_id (required) - academic_year_id (optional) """ permission_classes = [IsAuthenticated] def get(self, request): try: parent = Parent.objects.get(external_user_id=request.user.id) enrollment_id = request.query_params.get('enrollment_id') if not enrollment_id: return Response( {"success": False, "message": "enrollment_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) academic_year_id = request.query_params.get('academic_year_id') enrollment_filters = {"id": enrollment_id, "is_active": True} if academic_year_id: enrollment_filters["academic_class__academic_year_id"] = academic_year_id enrollment = StudentEnrollment.objects.filter( **enrollment_filters ).select_related('student', 'academic_class').first() if not enrollment: return Response({"success": False, "message": "Enrollment not found"}, status=status.HTTP_404_NOT_FOUND) student_parent = parent.student_parents.filter(student=enrollment.student, is_active=True).first() if not student_parent: return Response({"success": False, "message": "Access denied"}, status=status.HTTP_403_FORBIDDEN) results = ClassTestStudent.objects.filter( student_enrollment=enrollment ).select_related( 'class_test', 'class_test__subject', 'class_test__subject_teacher__teacher' ).order_by('-class_test__test_date', '-class_test__created_at') class_tests = [] total_obtained = 0 total_max = 0 passed_count = 0 failed_count = 0 absent_count = 0 pending_count = 0 for result in results: test = result.class_test subject_teacher = test.subject_teacher marks_entered = result.marks_obtained is not None or result.is_absent percentage = result.percentage if marks_entered and not result.is_absent else None is_passed = result.is_passed if marks_entered and not result.is_absent else None class_tests.append({ 'id': test.id, 'result_id': result.id, 'title': test.title, 'test_type': test.test_type, 'subject_id': test.subject_id, 'subject_name': test.subject.name if test.subject else None, 'teacher_name': subject_teacher.teacher.full_name if subject_teacher and subject_teacher.teacher else None, 'test_date': test.test_date, 'max_marks': test.max_marks, 'passing_marks': test.passing_marks, 'obtained_marks': float(result.marks_obtained) if result.marks_obtained is not None else None, 'percentage': round(percentage, 2) if percentage is not None else None, 'is_passed': is_passed, 'is_absent': result.is_absent, 'remarks': result.remarks, 'status': test.status, 'marks_entered': marks_entered, }) if result.is_absent: absent_count += 1 total_max += test.max_marks elif result.marks_obtained is not None: total_obtained += float(result.marks_obtained) total_max += test.max_marks if is_passed: passed_count += 1 else: failed_count += 1 else: pending_count += 1 overall_percentage = (total_obtained / total_max * 100) if total_max > 0 else 0 return Response({ "success": True, "data": { "student_info": { "student_id": enrollment.student.id, "student_name": enrollment.student.full_name, "roll_number": enrollment.roll_number, "class_name": str(enrollment.academic_class), }, "summary": { "total_tests": len(class_tests), "passed": passed_count, "failed": failed_count, "absent": absent_count, "pending": pending_count, "total_marks": round(total_obtained, 2), "total_max_marks": total_max, "overall_percentage": round(overall_percentage, 2), }, "class_tests": class_tests, } }, status=status.HTTP_200_OK) except Parent.DoesNotExist: return Response({"success": False, "message": "Parent profile not found"}, status=status.HTTP_404_NOT_FOUND) except Exception as e: logger.error(f"Error in ParentStudentClassTestsView: {str(e)}") return Response({"success": False, "message": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)