project initialization

backend/src/modules/education/serializers/class_serializers.py

@@ -0,0 +1,327 @@
+"""
+Class Serializers
+Serializers for class-related models in the education module
+"""
+
+from rest_framework import serializers
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+
+from ..models.class import Class
+
+User = get_user_model()
+
+
+class ClassSerializer(serializers.ModelSerializer):
+    """Serializer for Class model"""
+
+    display_name = serializers.SerializerMethodField()
+    available_seats = serializers.SerializerMethodField()
+    enrollment_percentage = serializers.SerializerMethodField()
+    is_enrollment_period = serializers.SerializerMethodField()
+    is_active_currently = serializers.SerializerMethodField()
+    duration_in_days = serializers.SerializerMethodField()
+    schedule_summary = serializers.SerializerMethodField()
+    capacity_stats = serializers.SerializerMethodField()
+    class_teacher_name = serializers.CharField(source='class_teacher.name', read_only=True)
+    assistant_teacher_name = serializers.CharField(source='assistant_teacher.name', read_only=True)
+    grade_level_display = serializers.CharField(source='get_grade_level_display', read_only=True)
+    stream_display = serializers.CharField(source='get_stream_display', read_only=True)
+    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    shift_display = serializers.CharField(source='get_shift_display', read_only=True)
+    medium_display = serializers.CharField(source='get_medium_display', read_only=True)
+    created_by_name = serializers.CharField(source='created_by.name', read_only=True)
+    updated_by_name = serializers.CharField(source='updated_by.name', read_only=True)
+    subject_teachers_info = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Class
+        fields = [
+            'id', 'tenant', 'name', 'class_code', 'grade_level', 'grade_level_display',
+            'stream', 'stream_display', 'shift', 'shift_display', 'medium', 'medium_display',
+            'max_students', 'current_students', 'min_students', 'waitlist_count',
+            'available_seats', 'enrollment_percentage', 'is_full', 'has_waitlist',
+            'class_teacher', 'class_teacher_name', 'assistant_teacher', 'assistant_teacher_name',
+            'subject_teachers', 'subject_teachers_info', 'classroom', 'building', 'floor',
+            'academic_year', 'semester', 'term', 'schedule', 'schedule_summary', 'meeting_days',
+            'start_time', 'end_time', 'break_times', 'curriculum', 'subjects_offered',
+            'elective_subjects', 'assessment_methods', 'grading_scale', 'passing_grade',
+            'special_programs', 'support_services', 'class_rules', 'attendance_policy',
+            'homework_policy', 'discipline_policy', 'classroom_equipment', 'learning_materials',
+            'digital_resources', 'parent_group_id', 'communication_preferences', 'status',
+            'status_display', 'start_date', 'end_date', 'enrollment_start_date',
+            'enrollment_end_date', 'is_enrollment_open', 'is_enrollment_period',
+            'is_active_currently', 'duration_in_days', 'description', 'notes', 'tags',
+            'requirements', 'created_by', 'created_by_name', 'updated_by', 'updated_by_name',
+            'created_at', 'updated_at', 'display_name', 'capacity_stats',
+        ]
+        read_only_fields = [
+            'tenant', 'id', 'class_code', 'created_at', 'updated_at', 'created_by',
+            'updated_by', 'display_name', 'available_seats', 'enrollment_percentage',
+            'is_enrollment_period', 'is_active_currently', 'duration_in_days',
+            'schedule_summary', 'capacity_stats',
+        ]
+
+    def get_display_name(self, obj):
+        """Get display name for the class"""
+        return obj.display_name
+
+    def get_available_seats(self, obj):
+        """Get number of available seats"""
+        return obj.available_seats
+
+    def get_enrollment_percentage(self, obj):
+        """Get enrollment percentage"""
+        return round(obj.enrollment_percentage, 2)
+
+    def get_is_enrollment_period(self, obj):
+        """Check if currently in enrollment period"""
+        return obj.is_enrollment_period
+
+    def get_is_active_currently(self, obj):
+        """Check if class is currently active"""
+        return obj.is_active_currently
+
+    def get_duration_in_days(self, obj):
+        """Get class duration in days"""
+        return obj.duration_in_days
+
+    def get_schedule_summary(self, obj):
+        """Get schedule summary"""
+        return obj.get_schedule_summary()
+
+    def get_capacity_stats(self, obj):
+        """Get capacity statistics"""
+        return obj.get_capacity_stats()
+
+    def get_subject_teachers_info(self, obj):
+        """Get subject teachers information"""
+        return [
+            {
+                'id': str(teacher.id),
+                'name': teacher.get_full_name(),
+                'email': teacher.email,
+            }
+            for teacher in obj.subject_teachers.all()
+        ]
+
+    def validate(self, data):
+        """Validate class data"""
+        # Validate dates
+        if data.get('start_date') and data.get('end_date'):
+            if data['end_date'] <= data['start_date']:
+                raise serializers.ValidationError(
+                    "End date must be after start date"
+                )
+
+        # Validate enrollment dates
+        if data.get('enrollment_start_date') and data.get('enrollment_end_date'):
+            if data['enrollment_end_date'] <= data['enrollment_start_date']:
+                raise serializers.ValidationError(
+                    "Enrollment end date must be after start date"
+                )
+
+        # Validate capacity
+        if data.get('min_students') and data.get('max_students'):
+            if data['min_students'] > data['max_students']:
+                raise serializers.ValidationError(
+                    "Minimum students cannot exceed maximum students"
+                )
+
+        # Validate class times
+        if data.get('start_time') and data.get('end_time'):
+            if data['end_time'] <= data['start_time']:
+                raise serializers.ValidationError(
+                    "End time must be after start time"
+                )
+
+        # Validate schedule if provided
+        if data.get('schedule'):
+            self._validate_schedule(data['schedule'])
+
+        # Validate teacher assignments
+        if data.get('class_teacher') and data.get('assistant_teacher'):
+            if data['class_teacher'].id == data['assistant_teacher'].id:
+                raise serializers.ValidationError(
+                    "Assistant teacher cannot be the same as class teacher"
+                )
+
+        return data
+
+    def _validate_schedule(self, schedule):
+        """Validate schedule format"""
+        if not isinstance(schedule, dict):
+            raise serializers.ValidationError("Schedule must be a dictionary")
+
+        valid_days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+
+        for day, periods in schedule.items():
+            if day not in valid_days:
+                raise serializers.ValidationError(f"Invalid day: {day}")
+
+            if not isinstance(periods, list):
+                raise serializers.ValidationError(f"Schedule for {day} must be a list")
+
+            for period in periods:
+                if not isinstance(period, dict):
+                    raise serializers.ValidationError(f"Each period in {day} must be a dictionary")
+
+                required_fields = ['subject', 'time', 'teacher']
+                for field in required_fields:
+                    if field not in period:
+                        raise serializers.ValidationError(f"Missing required field '{field}' in period for {day}")
+
+    def create(self, validated_data):
+        """Create class with tenant context"""
+        validated_data['tenant'] = self.context['tenant']
+        return super().create(validated_data)
+
+    def update(self, instance, validated_data):
+        """Update class with proper validation"""
+        # Remove read-only fields from validated data
+        validated_data.pop('tenant', None)
+        validated_data.pop('class_code', None)
+
+        return super().update(instance, validated_data)
+
+
+class ClassCreateSerializer(ClassSerializer):
+    """Serializer for creating classes with less restrictions"""
+
+    class Meta(ClassSerializer.Meta):
+        read_only_fields = ['id', 'created_at', 'updated_at', 'created_by', 'updated_by']
+
+
+class ClassUpdateSerializer(ClassSerializer):
+    """Serializer for updating classes"""
+
+    class Meta(ClassSerializer.Meta):
+        read_only_fields = ClassSerializer.Meta.read_only_fields + ['class_code']
+
+
+class ClassListSerializer(serializers.ModelSerializer):
+    """Simplified serializer for class lists"""
+
+    display_name = serializers.SerializerMethodField()
+    grade_level_display = serializers.CharField(source='get_grade_level_display', read_only=True)
+    stream_display = serializers.CharField(source='get_stream_display', read_only=True)
+    status_display = serializers.CharField(source='get_status_display', read_only=True)
+    class_teacher_name = serializers.CharField(source='class_teacher.name', read_only=True)
+    available_seats = serializers.SerializerMethodField()
+    enrollment_percentage = serializers.SerializerMethodField()
+    is_enrollment_open = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = Class
+        fields = [
+            'id', 'class_code', 'name', 'display_name', 'grade_level', 'grade_level_display',
+            'stream', 'stream_display', 'classroom', 'max_students', 'current_students',
+            'available_seats', 'enrollment_percentage', 'academic_year', 'status',
+            'status_display', 'class_teacher_name', 'is_enrollment_open', 'start_date', 'end_date',
+        ]
+
+    def get_display_name(self, obj):
+        return obj.display_name
+
+    def get_available_seats(self, obj):
+        return obj.available_seats
+
+    def get_enrollment_percentage(self, obj):
+        return round(obj.enrollment_percentage, 2)
+
+
+class TeacherAssignmentSerializer(serializers.ModelSerializer):
+    """Serializer for teacher assignments"""
+
+    role = serializers.CharField(max_length=20)
+    teacher_name = serializers.CharField(source='teacher.name', read_only=True)
+
+    class Meta:
+        model = Class
+        fields = ['id', 'name', 'role', 'teacher_name', 'academic_year', 'grade_level']
+
+
+class ClassStatisticsSerializer(serializers.Serializer):
+    """Serializer for class statistics"""
+
+    total_classes = serializers.IntegerField()
+    active_classes = serializers.IntegerField()
+    classes_with_open_enrollment = serializers.IntegerField()
+    grade_level_distribution = serializers.DictField()
+    stream_distribution = serializers.DictField()
+    total_capacity = serializers.IntegerField()
+    total_enrollment = serializers.IntegerField()
+    overall_enrollment_rate = serializers.FloatField()
+
+
+class ClassImportSerializer(serializers.Serializer):
+    """Serializer for bulk class import"""
+
+    file = serializers.FileField()
+    update_existing = serializers.BooleanField(default=False)
+    format = serializers.ChoiceField(choices=['csv', 'excel'], default='csv')
+
+
+class ClassExportSerializer(serializers.Serializer):
+    """Serializer for class export options"""
+
+    format = serializers.ChoiceField(choices=['csv', 'excel', 'json'], default='csv')
+    include_schedule = serializers.BooleanField(default=False)
+    include_teachers = serializers.BooleanField(default=True)
+    include_capacity = serializers.BooleanField(default=True)
+    filters = serializers.DictField(required=False)
+
+
+class ScheduleUpdateSerializer(serializers.Serializer):
+    """Serializer for updating class schedule"""
+
+    schedule = serializers.DictField()
+    check_conflicts = serializers.BooleanField(default=True)
+
+    def validate_schedule(self, schedule):
+        """Validate schedule format"""
+        if not isinstance(schedule, dict):
+            raise serializers.ValidationError("Schedule must be a dictionary")
+
+        valid_days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+
+        for day, periods in schedule.items():
+            if day not in valid_days:
+                raise serializers.ValidationError(f"Invalid day: {day}")
+
+            if not isinstance(periods, list):
+                raise serializers.ValidationError(f"Schedule for {day} must be a list")
+
+            for period in periods:
+                if not isinstance(period, dict):
+                    raise serializers.ValidationError(f"Each period in {day} must be a dictionary")
+
+                required_fields = ['subject', 'time', 'teacher']
+                for field in required_fields:
+                    if field not in period:
+                        raise serializers.ValidationError(f"Missing required field '{field}' in period for {day}")
+
+        return schedule
+
+
+class EnrollmentControlSerializer(serializers.Serializer):
+    """Serializer for controlling enrollment"""
+
+    is_enrollment_open = serializers.BooleanField()
+    enrollment_start_date = serializers.DateField(required=False)
+    enrollment_end_date = serializers.DateField(required=False)
+
+    def validate(self, data):
+        """Validate enrollment control data"""
+        if data.get('is_enrollment_open'):
+            if not data.get('enrollment_start_date') or not data.get('enrollment_end_date'):
+                raise serializers.ValidationError(
+                    "Enrollment start and end dates are required when opening enrollment"
+                )
+
+            if data['enrollment_end_date'] <= data['enrollment_start_date']:
+                raise serializers.ValidationError(
+                    "Enrollment end date must be after start date"
+                )
+
+        return data