# attendance/views.py from rest_framework import viewsets, filters, status from rest_framework.decorators import action from rest_framework.response import Response from rest_framework.permissions import IsAuthenticated, IsAdminUser from django.shortcuts import get_object_or_404 from django.db import models from django.db.models import Q, Sum, Count, Avg from django.db import IntegrityError from django.utils import timezone from datetime import datetime, timedelta, date from calendar import monthrange from .models import ( AttendanceSession, StudentAttendance, AttendanceLeave, AttendanceSummary ) from .serializers import ( AttendanceSessionSerializer, StudentAttendanceSerializer, StudentAttendanceListSerializer, BulkAttendanceSerializer, AttendanceLeaveSerializer, AttendanceLeaveCreateUpdateSerializer, AttendanceSummarySerializer ) from academics.models import AcademicClass, StudentEnrollment, SubjectTeacher from people.models import Teacher, Student class AttendanceSessionViewSet(viewsets.ModelViewSet): """ ViewSet for Attendance Session CRUD operations """ queryset = AttendanceSession.objects.filter(is_active=True) permission_classes = [IsAuthenticated] filterset_fields = ['academic_class', 'subject', 'date', 'session_type', 'status'] search_fields = ['academic_class__standard__name', 'academic_class__section__name'] ordering_fields = ['date', 'created_at'] ordering = ['-date'] def get_serializer_class(self): if self.action in ['create', 'update', 'partial_update']: return AttendanceSessionSerializer return AttendanceSessionSerializer def get_queryset(self): queryset = super().get_queryset().select_related( 'academic_class', 'academic_class__standard', 'academic_class__section', 'academic_class__academic_year', 'taken_by', 'subject', ) # Filter by academic year academic_year_id = self.request.query_params.get('academic_year') if academic_year_id: queryset = queryset.filter(academic_class__academic_year_id=academic_year_id) # Filter by class class_id = self.request.query_params.get('class_id') if class_id: queryset = queryset.filter(academic_class_id=class_id) # Filter by teacher teacher_id = self.request.query_params.get('teacher_id') if teacher_id: queryset = queryset.filter(taken_by_id=teacher_id) # Filter by exact date — filterset_fields declares 'date' but this ViewSet # never enables DjangoFilterBackend, so it's handled manually like the rest. date_filter = self.request.query_params.get('date') if date_filter: queryset = queryset.filter(date=date_filter) # Filter by date range from_date = self.request.query_params.get('from_date') if from_date: queryset = queryset.filter(date__gte=from_date) to_date = self.request.query_params.get('to_date') if to_date: queryset = queryset.filter(date__lte=to_date) # Filter by status status_filter = self.request.query_params.get('status') if status_filter: queryset = queryset.filter(status=status_filter.upper()) return queryset @action(detail=False, methods=['get']) def today(self, request): """Get today's attendance sessions for a class""" class_id = request.query_params.get('class_id') if not class_id: return Response( {"error": "class_id parameter is required"}, status=status.HTTP_400_BAD_REQUEST ) today = timezone.now().date() sessions = self.get_queryset().filter( academic_class_id=class_id, date=today ) serializer = self.get_serializer(sessions, many=True) return Response(serializer.data) @action(detail=False, methods=['post']) def start_session(self, request): """Start a new attendance session""" class_id = request.data.get('class_id') session_type = request.data.get('session_type', 'FULL_DAY') date_str = request.data.get('date', timezone.now().date()) subject_id = request.data.get('subject_id') if not class_id: return Response( {"error": "class_id is required"}, status=status.HTTP_400_BAD_REQUEST ) try: academic_class = AcademicClass.objects.get(id=class_id, is_active=True) teacher = Teacher.objects.get(external_user_id=request.user.id) # Check if session already exists existing_session = AttendanceSession.objects.filter( academic_class=academic_class, date=date_str, session_type=session_type ).first() if existing_session: serializer = self.get_serializer(existing_session) return Response( {"message": "Session already exists", "data": serializer.data}, status=status.HTTP_200_OK ) # Get total students in class total_students = StudentEnrollment.objects.filter( academic_class=academic_class, is_active=True ).count() # Create session session = AttendanceSession.objects.create( academic_class=academic_class, subject_id=subject_id, taken_by=teacher, date=date_str, session_type=session_type, status='OPEN', total_students=total_students ) # Create attendance records for all students enrollments = StudentEnrollment.objects.filter( academic_class=academic_class, is_active=True ).select_related('student') attendance_records = [] for enrollment in enrollments: attendance_records.append( StudentAttendance( session=session, enrollment=enrollment, student=enrollment.student, status='PENDING', marked_by=teacher ) ) if attendance_records: StudentAttendance.objects.bulk_create(attendance_records) serializer = self.get_serializer(session) return Response(serializer.data, status=status.HTTP_201_CREATED) except AcademicClass.DoesNotExist: return Response( {"error": "Class not found"}, status=status.HTTP_404_NOT_FOUND ) except Teacher.DoesNotExist: return Response( {"error": "Teacher profile not found"}, status=status.HTTP_404_NOT_FOUND ) except Exception as e: return Response( {"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR ) @action(detail=True, methods=['get']) def students(self, request, pk=None): """Get all students with attendance status for a session""" session = self.get_object() attendances = session.student_attendances.filter(is_active=True).select_related( 'student', 'enrollment' ).order_by('enrollment__roll_number') serializer = StudentAttendanceListSerializer(attendances, many=True) return Response({ "session": AttendanceSessionSerializer(session).data, "students": serializer.data, "statistics": { "total": session.total_students, "present": session.present_count, "absent": session.absent_count, "late": session.late_count, "leave": session.leave_count, "completion_percentage": round((session.student_attendances.filter(~Q(status='PENDING')).count() / session.total_students * 100), 2) if session.total_students > 0 else 0 } }) @action(detail=True, methods=['post']) def mark_attendance(self, request, pk=None): """Mark attendance for a single student""" session = self.get_object() if session.status != 'OPEN': return Response( {"error": f"Cannot modify attendance in {session.status} state"}, status=status.HTTP_400_BAD_REQUEST ) enrollment_id = request.data.get('enrollment_id') status_value = request.data.get('status') remarks = request.data.get('remarks', '') late_minutes = request.data.get('late_minutes') if not enrollment_id or not status_value: return Response( {"error": "enrollment_id and status are required"}, status=status.HTTP_400_BAD_REQUEST ) try: attendance = StudentAttendance.objects.get( session=session, enrollment_id=enrollment_id, is_active=True ) attendance.status = status_value attendance.remarks = remarks if late_minutes is not None: attendance.late_minutes = late_minutes attendance.save() session.update_counts() serializer = StudentAttendanceSerializer(attendance) return Response(serializer.data) except StudentAttendance.DoesNotExist: return Response( {"error": "Attendance record not found"}, status=status.HTTP_404_NOT_FOUND ) @action(detail=True, methods=['post']) def bulk_mark(self, request, pk=None): """Bulk mark attendance for multiple students""" session = self.get_object() if session.status != 'OPEN': return Response( {"error": f"Cannot modify attendance in {session.status} state"}, status=status.HTTP_400_BAD_REQUEST ) serializer = BulkAttendanceSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) attendance_data = serializer.validated_data['attendance_data'] updated_count = 0 errors = [] for item in attendance_data: try: attendance = StudentAttendance.objects.get( session=session, enrollment_id=item['enrollment_id'], is_active=True ) attendance.status = item['status'] attendance.remarks = item.get('remarks', '') attendance.late_minutes = item.get('late_minutes') attendance.save() updated_count += 1 except StudentAttendance.DoesNotExist: errors.append({ "enrollment_id": item['enrollment_id'], "error": "Attendance record not found" }) except Exception as e: errors.append({ "enrollment_id": item['enrollment_id'], "error": str(e) }) session.update_counts() return Response({ "updated_count": updated_count, "errors": errors if errors else None, "total_processed": len(attendance_data) }) @action(detail=True, methods=['post']) def submit(self, request, pk=None): """Submit/finalize an attendance session""" session = self.get_object() if session.status != 'OPEN': return Response( {"error": f"Session already {session.status.lower()}"}, status=status.HTTP_400_BAD_REQUEST ) # Check if all students have attendance marked pending_count = session.student_attendances.filter( status='PENDING', is_active=True ).count() if pending_count > 0: return Response( {"error": f"Cannot submit: {pending_count} students pending"}, status=status.HTTP_400_BAD_REQUEST ) session.status = 'SUBMITTED' session.save() return Response({ "message": "Attendance session submitted successfully", "data": AttendanceSessionSerializer(session).data }) @action(detail=True, methods=['post']) def toggle_status(self, request, pk=None): """Toggle session status (OPEN/SUBMITTED)""" session = self.get_object() if session.status == 'OPEN': session.status = 'SUBMITTED' elif session.status == 'SUBMITTED': session.status = 'OPEN' else: return Response( {"error": f"Cannot toggle status from {session.status}"}, status=status.HTTP_400_BAD_REQUEST ) session.save() return Response({ "message": f"Session status changed to {session.status}", "data": AttendanceSessionSerializer(session).data }) @action(detail=True, methods=['post']) def update_attendance(self, request, pk=None): """Admin override: update a student's attendance status regardless of session state.""" session = self.get_object() attendance_id = request.data.get('attendance_id') status_value = request.data.get('status') remarks = request.data.get('remarks', '') late_minutes = request.data.get('late_minutes') if not attendance_id or not status_value: return Response( {"error": "attendance_id and status are required"}, status=status.HTTP_400_BAD_REQUEST ) valid_statuses = ['PRESENT', 'ABSENT', 'LATE', 'LEAVE', 'HALF_DAY', 'HOLIDAY'] if status_value not in valid_statuses: return Response( {"error": f"Invalid status. Choose from: {', '.join(valid_statuses)}"}, status=status.HTTP_400_BAD_REQUEST ) try: attendance = StudentAttendance.objects.get( id=attendance_id, session=session, is_active=True ) attendance.status = status_value attendance.remarks = remarks if late_minutes is not None: attendance.late_minutes = late_minutes attendance.save() session.update_counts() serializer = StudentAttendanceSerializer(attendance) return Response({ "student": serializer.data, "session_counts": { "total_students": session.total_students, "present_count": session.present_count, "absent_count": session.absent_count, "late_count": session.late_count, "leave_count": session.leave_count, } }) except StudentAttendance.DoesNotExist: return Response( {"error": "Attendance record not found"}, status=status.HTTP_404_NOT_FOUND ) class AttendanceLeaveViewSet(viewsets.ModelViewSet): """ ViewSet for Attendance Leave CRUD operations """ queryset = AttendanceLeave.objects.filter(is_active=True) permission_classes = [IsAuthenticated] filterset_fields = ['student', 'leave_type', 'status', 'enrollment'] search_fields = ['student__first_name', 'student__last_name', 'reason'] ordering_fields = ['from_date', 'created_at'] ordering = ['-created_at'] def get_serializer_class(self): if self.action in ['create', 'update', 'partial_update']: return AttendanceLeaveCreateUpdateSerializer return AttendanceLeaveSerializer def get_queryset(self): queryset = super().get_queryset().select_related( 'student', 'enrollment', 'enrollment__academic_class', 'approved_by' ) # Filter by academic year academic_year_id = self.request.query_params.get('academic_year') if academic_year_id: queryset = queryset.filter( enrollment__academic_class__academic_year_id=academic_year_id ) # Filter by class class_id = self.request.query_params.get('class_id') if class_id: queryset = queryset.filter(enrollment__academic_class_id=class_id) # Filter by student student_id = self.request.query_params.get('student_id') if student_id: queryset = queryset.filter(student_id=student_id) # Filter by status status_filter = self.request.query_params.get('status') if status_filter: queryset = queryset.filter(status=status_filter.upper()) # Filter by date range from_date = self.request.query_params.get('from_date') if from_date: queryset = queryset.filter(from_date__gte=from_date) to_date = self.request.query_params.get('to_date') if to_date: queryset = queryset.filter(to_date__lte=to_date) return queryset @action(detail=True, methods=['post']) def approve(self, request, pk=None): """Approve a leave request""" leave = self.get_object() if leave.status != 'PENDING': return Response( {"error": f"Leave request is already {leave.status.lower()}"}, status=status.HTTP_400_BAD_REQUEST ) try: teacher = Teacher.objects.get(external_user_id=request.user.id) leave.status = 'APPROVED' leave.approved_by = teacher leave.approved_at = timezone.now() leave.save() return Response({ "message": "Leave request approved successfully", "data": AttendanceLeaveSerializer(leave).data }) except Teacher.DoesNotExist: return Response( {"error": "Teacher profile not found"}, status=status.HTTP_404_NOT_FOUND ) @action(detail=True, methods=['post']) def reject(self, request, pk=None): """Reject a leave request""" leave = self.get_object() if leave.status != 'PENDING': return Response( {"error": f"Leave request is already {leave.status.lower()}"}, status=status.HTTP_400_BAD_REQUEST ) rejection_reason = request.data.get('rejection_reason') if not rejection_reason: return Response( {"error": "Rejection reason is required"}, status=status.HTTP_400_BAD_REQUEST ) try: teacher = Teacher.objects.get(external_user_id=request.user.id) leave.status = 'REJECTED' leave.approved_by = teacher leave.approved_at = timezone.now() leave.rejection_reason = rejection_reason leave.save() return Response({ "message": "Leave request rejected", "data": AttendanceLeaveSerializer(leave).data }) except Teacher.DoesNotExist: return Response( {"error": "Teacher profile not found"}, status=status.HTTP_404_NOT_FOUND ) @action(detail=True, methods=['post']) def cancel(self, request, pk=None): """Cancel a leave request (soft delete)""" leave = self.get_object() if leave.status != 'PENDING': return Response( {"error": f"Cannot cancel leave request that is {leave.status.lower()}"}, status=status.HTTP_400_BAD_REQUEST ) leave.is_active = False leave.save() return Response({ "message": "Leave request cancelled successfully", "data": None }) class AttendanceDashboardViewSet(viewsets.GenericViewSet): """ ViewSet for Attendance Dashboard and Reports """ permission_classes = [IsAuthenticated] @action(detail=False, methods=['get']) def teacher_stats(self, request): """Get attendance statistics for logged-in teacher""" try: teacher = Teacher.objects.get(external_user_id=request.user.id) # Get classes where teacher is class teacher or subject teacher class_teacher_classes = AcademicClass.objects.filter( class_teacher=teacher, is_active=True ).values_list('id', flat=True) subject_teacher_classes = SubjectTeacher.objects.filter( teacher=teacher, is_active=True ).values_list('academic_class_id', flat=True) all_class_ids = set(list(class_teacher_classes) + list(subject_teacher_classes)) today = timezone.now().date() week_start = today - timedelta(days=today.weekday()) month_start = date(today.year, today.month, 1) # Today's sessions today_sessions = AttendanceSession.objects.filter( academic_class_id__in=all_class_ids, date=today, is_active=True ) # Weekly stats weekly_sessions = AttendanceSession.objects.filter( academic_class_id__in=all_class_ids, date__gte=week_start, date__lte=today, is_active=True ) weekly_stats = weekly_sessions.aggregate( total_students=Sum('total_students'), total_present=Sum('present_count'), total_late=Sum('late_count'), total_leave=Sum('leave_count') ) weekly_percentage = 0 if weekly_stats['total_students']: effective_present = (weekly_stats['total_present'] or 0) + (weekly_stats['total_late'] or 0) weekly_percentage = round((effective_present / weekly_stats['total_students']) * 100, 2) if weekly_stats['total_students'] > 0 else 0 # Monthly stats monthly_sessions = AttendanceSession.objects.filter( academic_class_id__in=all_class_ids, date__gte=month_start, date__lte=today, is_active=True ) monthly_stats = monthly_sessions.aggregate( total_students=Sum('total_students'), total_present=Sum('present_count'), total_late=Sum('late_count'), total_leave=Sum('leave_count') ) monthly_percentage = 0 if monthly_stats['total_students']: effective_present = (monthly_stats['total_present'] or 0) + (monthly_stats['total_late'] or 0) monthly_percentage = round((effective_present / monthly_stats['total_students']) * 100, 2) if monthly_stats['total_students'] > 0 else 0 # Recent sessions recent_sessions = weekly_sessions.order_by('-date')[:10] return Response({ "teacher_name": teacher.full_name, "today_summary": { "total_sessions": today_sessions.count(), "completed": today_sessions.filter(status='SUBMITTED').count(), "pending": today_sessions.filter(status='OPEN').count() }, "weekly_summary": { "total_students": weekly_stats['total_students'] or 0, "present_count": weekly_stats['total_present'] or 0, "late_count": weekly_stats['total_late'] or 0, "leave_count": weekly_stats['total_leave'] or 0, "attendance_percentage": weekly_percentage }, "monthly_summary": { "total_students": monthly_stats['total_students'] or 0, "present_count": monthly_stats['total_present'] or 0, "late_count": monthly_stats['total_late'] or 0, "leave_count": monthly_stats['total_leave'] or 0, "attendance_percentage": monthly_percentage }, "recent_sessions": AttendanceSessionSerializer(recent_sessions, many=True).data }) except Teacher.DoesNotExist: return Response( {"error": "Teacher profile not found"}, status=status.HTTP_404_NOT_FOUND ) @action(detail=False, methods=['get']) def class_summary(self, request): """Get attendance summary by class""" class_id = request.query_params.get('class_id') from_date = request.query_params.get('from_date') to_date = request.query_params.get('to_date') if not class_id: return Response( {"error": "class_id is required"}, status=status.HTTP_400_BAD_REQUEST ) sessions = AttendanceSession.objects.filter( academic_class_id=class_id, is_active=True ) if from_date: sessions = sessions.filter(date__gte=from_date) if to_date: sessions = sessions.filter(date__lte=to_date) class_summary = sessions.aggregate( total_sessions=Count('id'), total_students=Sum('total_students'), total_present=Sum('present_count'), total_absent=Sum('absent_count'), total_late=Sum('late_count'), total_leave=Sum('leave_count') ) total = class_summary['total_students'] or 0 effective_present = (class_summary['total_present'] or 0) + (class_summary['total_late'] or 0) attendance_percentage = round((effective_present / total) * 100, 2) if total > 0 else 0 return Response({ "class_id": class_id, "total_sessions": class_summary['total_sessions'] or 0, "total_students": total, "present_count": class_summary['total_present'] or 0, "absent_count": class_summary['total_absent'] or 0, "late_count": class_summary['total_late'] or 0, "leave_count": class_summary['total_leave'] or 0, "attendance_percentage": attendance_percentage }) @action(detail=False, methods=['get']) def monthly_summary(self, request): """Get monthly attendance summary for a class""" class_id = request.query_params.get('class_id') month = int(request.query_params.get('month', timezone.now().month)) year = int(request.query_params.get('year', timezone.now().year)) if not class_id: return Response( {"error": "class_id is required"}, status=status.HTTP_400_BAD_REQUEST ) try: academic_class = AcademicClass.objects.get(id=class_id, is_active=True) enrollments = StudentEnrollment.objects.filter( academic_class=academic_class, is_active=True ).select_related('student') summaries = [] for enrollment in enrollments: summary, created = AttendanceSummary.objects.get_or_create( enrollment=enrollment, student=enrollment.student, academic_class=academic_class, month=month, year=year ) if created: summary.compute() summaries.append(summary) summaries.sort(key=lambda x: x.enrollment.roll_number) serializer = AttendanceSummarySerializer(summaries, many=True) total_students = len(summaries) avg_attendance = sum([s.attendance_percentage for s in summaries]) / total_students if total_students > 0 else 0 below_minimum = len([s for s in summaries if s.is_below_minimum]) return Response({ "class_info": { "id": academic_class.id, "name": str(academic_class), "total_students": total_students }, "month": month, "year": year, "statistics": { "average_attendance": round(avg_attendance, 2), "students_below_minimum": below_minimum, "minimum_required": float(academic_class.min_attendance_percentage or 75.0) }, "student_summaries": serializer.data }) except AcademicClass.DoesNotExist: return Response( {"error": "Class not found"}, status=status.HTTP_404_NOT_FOUND ) @action(detail=False, methods=['get']) def student_history(self, request): """Get attendance history for a specific student""" student_id = request.query_params.get('student_id') enrollment_id = request.query_params.get('enrollment_id') page = int(request.query_params.get('page', 1)) page_size = int(request.query_params.get('page_size', 20)) if not student_id and not enrollment_id: return Response( {"error": "student_id or enrollment_id is required"}, status=status.HTTP_400_BAD_REQUEST ) attendances = StudentAttendance.objects.filter(is_active=True).select_related( 'session', 'student', 'enrollment', 'enrollment__academic_class' ) if student_id: attendances = attendances.filter(student_id=student_id) if enrollment_id: attendances = attendances.filter(enrollment_id=enrollment_id) # Apply filters from_date = request.query_params.get('from_date') if from_date: attendances = attendances.filter(session__date__gte=from_date) to_date = request.query_params.get('to_date') if to_date: attendances = attendances.filter(session__date__lte=to_date) status_filter = request.query_params.get('status') if status_filter: attendances = attendances.filter(status=status_filter.upper()) attendances = attendances.order_by('-session__date') # Calculate statistics total_records = attendances.count() present_count = attendances.filter(status='PRESENT').count() absent_count = attendances.filter(status='ABSENT').count() late_count = attendances.filter(status='LATE').count() leave_count = attendances.filter(status='LEAVE').count() effective_present = present_count + late_count attendance_percentage = round((effective_present / total_records) * 100, 2) if total_records > 0 else 0 # Pagination start = (page - 1) * page_size end = start + page_size paginated_attendances = attendances[start:end] serializer = StudentAttendanceSerializer(paginated_attendances, many=True) return Response({ "attendance_records": serializer.data, "statistics": { "total_days": total_records, "present": present_count, "absent": absent_count, "late": late_count, "leave": leave_count, "attendance_percentage": attendance_percentage }, "pagination": { "current_page": page, "page_size": page_size, "total_pages": (total_records + page_size - 1) // page_size, "total_items": total_records, "has_next": end < total_records, "has_previous": page > 1 } })