feat: add assessment_* pages

models.py

@@ -72,12 +72,11 @@ class Assessment(db.Model):
             for grading_element in exercise.grading_elements:
                 total_elements += total_students
                 
-                # Compter les notes saisies (valeur non nulle et non vide)
+                # Compter les notes saisies (valeur non nulle et non vide, y compris '.')
                 completed_for_element = db.session.query(Grade).filter(
                     Grade.grading_element_id == grading_element.id,
                     Grade.value.isnot(None),
-                    Grade.value != '',
-                    Grade.value != '.'
+                    Grade.value != ''
                 ).count()
                 
                 completed_elements += completed_for_element
@@ -107,6 +106,112 @@ class Assessment(db.Model):
             'status': status,
             'students_count': total_students
         }
+    
+    def calculate_student_scores(self):
+        """Calcule les scores de tous les élèves pour cette évaluation.
+        Retourne un dictionnaire avec les scores par élève et par exercice."""
+        from collections import defaultdict
+        import statistics
+        
+        students_scores = {}
+        exercise_scores = defaultdict(lambda: defaultdict(float))
+        
+        for student in self.class_group.students:
+            total_score = 0
+            total_max_points = 0
+            student_exercises = {}
+            
+            for exercise in self.exercises:
+                exercise_score = 0
+                exercise_max_points = 0
+                
+                for element in exercise.grading_elements:
+                    grade = Grade.query.filter_by(
+                        student_id=student.id,
+                        grading_element_id=element.id
+                    ).first()
+                    
+                    # Si une note a été saisie pour cet élément (y compris '.')
+                    if grade and grade.value and grade.value != '':
+                        if element.grading_type == 'points':
+                            if grade.value == '.':
+                                # '.' signifie non répondu = 0 point mais on compte le max
+                                exercise_score += 0
+                                exercise_max_points += element.max_points
+                            else:
+                                try:
+                                    exercise_score += float(grade.value)
+                                    exercise_max_points += element.max_points
+                                except ValueError:
+                                    pass
+                        else:  # compétences
+                            if grade.value == '.':
+                                # '.' signifie non évalué = 0 point mais on compte le max
+                                exercise_score += 0
+                                exercise_max_points += (1/3) * 3 * element.max_points  # Score max de 3
+                            else:
+                                try:
+                                    score_value = float(grade.value)
+                                    exercise_score += (1/3) * score_value * element.max_points
+                                    exercise_max_points += (1/3) * 3 * element.max_points  # Score max de 3
+                                except ValueError:
+                                    pass
+                
+                student_exercises[exercise.id] = {
+                    'score': exercise_score,
+                    'max_points': exercise_max_points,
+                    'title': exercise.title
+                }
+                total_score += exercise_score
+                total_max_points += exercise_max_points
+                exercise_scores[exercise.id][student.id] = exercise_score
+            
+            students_scores[student.id] = {
+                'student': student,
+                'total_score': round(total_score, 2),
+                'total_max_points': total_max_points,
+                'exercises': student_exercises
+            }
+        
+        return students_scores, dict(exercise_scores)
+    
+    def get_assessment_statistics(self):
+        """Calcule les statistiques descriptives pour cette évaluation."""
+        students_scores, _ = self.calculate_student_scores()
+        scores = [data['total_score'] for data in students_scores.values()]
+        
+        if not scores:
+            return {
+                'count': 0,
+                'mean': 0,
+                'median': 0,
+                'min': 0,
+                'max': 0,
+                'std_dev': 0
+            }
+        
+        import statistics
+        import math
+        
+        return {
+            'count': len(scores),
+            'mean': round(statistics.mean(scores), 2),
+            'median': round(statistics.median(scores), 2),
+            'min': min(scores),
+            'max': max(scores),
+            'std_dev': round(statistics.stdev(scores) if len(scores) > 1 else 0, 2)
+        }
+    
+    def get_total_max_points(self):
+        """Calcule le total des points maximum pour cette évaluation."""
+        total = 0
+        for exercise in self.exercises:
+            for element in exercise.grading_elements:
+                if element.grading_type == 'points':
+                    total += element.max_points
+                else:  # compétences
+                    total += (1/3) * 3 * element.max_points  # Score max de 3
+        return total
 
 class Exercise(db.Model):
     id = db.Column(db.Integer, primary_key=True)