Non-counting questions

evap/evaluation/migrations/0161_question_counts_for_grade.py

@@ -0,0 +1,42 @@
+# Generated by Django 5.2 on 2025-05-12 21:30
+
+from django.db import migrations, models
+from django.db.models import Q
+
+TEXT = 0
+HEADING = 5
+DROPOUT_QUESTIONNAIRE = 5
+
+
+def set_initial_values(apps, _schema_editor):
+    Question = apps.get_model("evaluation", "Question")
+
+    Question.objects.filter(Q(type__in=[TEXT, HEADING]) | Q(questionnaire__type=DROPOUT_QUESTIONNAIRE)).update(
+        counts_for_grade=False
+    )
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("evaluation", "0160_evaluation_staff_notes"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="question",
+            name="counts_for_grade",
+            field=models.BooleanField(default=True, verbose_name="counts toward the evaluation's grade"),
+        ),
+        migrations.RunPython(set_initial_values, reverse_code=migrations.RunPython.noop),
+        migrations.AddConstraint(
+            model_name="question",
+            constraint=models.CheckConstraint(
+                condition=models.Q(
+                    models.Q(("type", TEXT), ("type", HEADING), _connector="OR", _negated=True),
+                    ("counts_for_grade", False),
+                    _connector="OR",
+                ),
+                name="check_evaluation_textanswer_or_heading_question_does_not_count_for_grade",
+            ),
+        ),
+    ]

evap/evaluation/models.py

@@ -1268,6 +1268,7 @@ class Question(models.Model):
     text_en = models.CharField(max_length=1024, verbose_name=_("question text (english)"))
     text = translate(en="text_en", de="text_de")
     allows_additional_textanswers = models.BooleanField(default=True, verbose_name=_("allow additional text answers"))
+    counts_for_grade = models.BooleanField(default=True, verbose_name=_("counts toward the evaluation's grade"))
 
     type = models.PositiveSmallIntegerField(choices=QUESTION_TYPES, verbose_name=_("question type"))
 
@@ -1282,14 +1283,21 @@ class Meta:
                     ~(Q(type=QuestionType.TEXT) | Q(type=QuestionType.HEADING)) | ~Q(allows_additional_textanswers=True)
                 ),
                 name="check_evaluation_textanswer_or_heading_question_has_no_additional_textanswers",
-            )
+            ),
+            CheckConstraint(
+                condition=(~(Q(type=QuestionType.TEXT) | Q(type=QuestionType.HEADING)) | Q(counts_for_grade=False)),
+                name="check_evaluation_textanswer_or_heading_question_does_not_count_for_grade",
+            ),
         ]
 
     def save(self, *args, **kwargs):
         if self.type in [QuestionType.TEXT, QuestionType.HEADING]:
             self.allows_additional_textanswers = False
+            self.counts_for_grade = False
             if "update_fields" in kwargs:
-                kwargs["update_fields"] = {"allows_additional_textanswers"}.union(kwargs["update_fields"])
+                kwargs["update_fields"] = {"allows_additional_textanswers", "counts_for_grade"}.union(
+                    kwargs["update_fields"]
+                )
 
         super().save(*args, **kwargs)
 

evap/evaluation/tests/test_models.py

@@ -5,6 +5,7 @@
 from django.core import mail
 from django.core.cache import caches
 from django.core.exceptions import ValidationError
+from django.db import models
 from django.test import override_settings
 from django_fsm import TransitionNotAllowed
 from model_bakery import baker
@@ -1146,3 +1147,58 @@ class QuestionnaireTests(TestCase):
     def test_locked_contributor_questionnaire(self):
         questionnaire = baker.prepare(Questionnaire, is_locked=True, type=Questionnaire.Type.CONTRIBUTOR)
         self.assertRaises(ValidationError, questionnaire.clean)
+
+
+class QuestionTests(TestCase):
+    def test_save_for_text_and_heading_question_type(self):
+        questionaire = baker.make(Questionnaire)
+        # Use prepare() instead of make() to test Question.save() method behavior
+        question_text = baker.prepare(
+            Question,
+            questionnaire=questionaire,
+            type=QuestionType.TEXT,
+            allows_additional_textanswers=True,
+            counts_for_grade=True,
+        )
+        question_heading = baker.prepare(
+            Question,
+            questionnaire=questionaire,
+            type=QuestionType.HEADING,
+            allows_additional_textanswers=True,
+            counts_for_grade=True,
+        )
+        question_rating = baker.prepare(
+            Question,
+            questionnaire=questionaire,
+            type=QuestionType.NEGATIVE_LIKERT,
+            allows_additional_textanswers=True,
+            counts_for_grade=True,
+        )
+
+        question_rating.save()
+        question_rating.refresh_from_db()
+        self.assertEqual(question_rating.allows_additional_textanswers, True)
+        self.assertEqual(question_rating.counts_for_grade, True)
+
+        # Check if setting allows_additional_textanswers and counts_for_grade to False in the save method works
+        question_rating.type = QuestionType.TEXT
+        question_rating.save(update_fields=["type"])
+        question_rating.refresh_from_db()
+        self.assertEqual(question_rating.allows_additional_textanswers, False)
+        self.assertEqual(question_rating.counts_for_grade, False)
+
+        with patch.object(models.Model, "save") as mock_save:
+            question_text.save(update_fields=["text_de"])
+            mock_save.assert_called_once()
+            args, kwargs = mock_save.call_args
+            self.assertEqual(
+                set(kwargs["update_fields"]), {"allows_additional_textanswers", "counts_for_grade", "text_de"}
+            )
+
+            mock_save.reset_mock()
+            question_heading.save(update_fields=["text_de"])
+            mock_save.assert_called_once()
+            args, kwargs = mock_save.call_args
+            self.assertEqual(
+                set(kwargs["update_fields"]), {"allows_additional_textanswers", "counts_for_grade", "text_de"}
+            )

evap/evaluation/tests/tools.py

@@ -359,6 +359,9 @@ def setUpClass(cls) -> None:
         super().setUpClass()
         cls.selenium.set_window_size(*cls.window_size)
 
+    def set_tomselect_value(self, instance: WebElement, value: str) -> None:
+        self.selenium.execute_script(f"arguments[0].tomselect.setValue('{value}');", instance)
+
 
 def classes_of_element(element: WebElement) -> list[str]:
     classes = element.get_attribute("class")

evap/results/fixtures/minimal_test_data_results.json

@@ -189,6 +189,7 @@
     "text_de": "how?",
     "text_en": "how?",
     "allows_additional_textanswers": false,
+    "counts_for_grade": false,
     "type": 0
   }
 },
@@ -201,6 +202,7 @@
     "text_de": "how much?",
     "text_en": "how much?",
     "allows_additional_textanswers": true,
+    "counts_for_grade": true,
     "type": 1
   }
 },
@@ -213,6 +215,7 @@
     "text_de": "how?",
     "text_en": "how?",
     "allows_additional_textanswers": false,
+    "counts_for_grade": false,
     "type": 0
   }
 },
@@ -225,6 +228,7 @@
     "text_de": "how much?",
     "text_en": "how much?",
     "allows_additional_textanswers": true,
+    "counts_for_grade": true,
     "type": 1
   }
 },
@@ -237,6 +241,7 @@
     "text_de": "your grade",
     "text_en": "your grade",
     "allows_additional_textanswers": false,
+    "counts_for_grade": true,
     "type": 2
   }
 },

evap/results/tests/test_exporters.py

@@ -544,6 +544,7 @@ def test_text_answer_export(self):
             _quantity=len(Questionnaire.Type.values),
             _bulk_create=True,
             allows_additional_textanswers=False,
+            counts_for_grade=False,
         )
 
         baker.make(

evap/results/tests/test_tools.py

@@ -20,6 +20,8 @@
 from evap.results.tools import (
     ViewContributorResults,
     ViewGeneralResults,
+    average_grade_questions_distribution,
+    average_non_grade_rating_questions_distribution,
     cache_results,
     calculate_average_course_distribution,
     calculate_average_distribution,
@@ -417,24 +419,93 @@ def test_calculate_average_course_distribution(self):
         self.assertEqual(distribution[3], 0)
         self.assertEqual(distribution[4], 0)
 
-    def test_dropout_questionnaires_are_not_included(self):
-        general_questionnaire = baker.make(Questionnaire, type=Questionnaire.Type.TOP)
-        general_question = baker.make(Question, questionnaire=general_questionnaire, type=QuestionType.GRADE)
+    def test_average_questions_distribution(self):
+        grade_question = baker.make(
+            Question, questionnaire=self.questionnaire, type=QuestionType.GRADE, counts_for_grade=True
+        )
+        non_counting_grade_question = baker.make(
+            Question, questionnaire=self.questionnaire, type=QuestionType.GRADE, counts_for_grade=False
+        )
+        likert_question = baker.make(
+            Question, questionnaire=self.questionnaire, type=QuestionType.POSITIVE_LIKERT, counts_for_grade=True
+        )
+        non_counting_likert_question = baker.make(
+            Question, questionnaire=self.questionnaire, type=QuestionType.POSITIVE_LIKERT, counts_for_grade=False
+        )
 
-        dropout_questionnaire = baker.make(Questionnaire, type=Questionnaire.Type.DROPOUT)
-        dropout_question = baker.make(Question, questionnaire=dropout_questionnaire, type=QuestionType.GRADE)
+        counters = [
+            *make_rating_answer_counters(non_counting_grade_question, self.contribution1, [0, 0, 0, 0, 1], False),
+            *make_rating_answer_counters(non_counting_likert_question, self.contribution1, [0, 0, 0, 0, 3], False),
+        ]
+        RatingAnswerCounter.objects.bulk_create(counters)
 
-        contribution = baker.make(
-            Contribution, evaluation=self.evaluation, questionnaires=[general_questionnaire, dropout_questionnaire]
+        cache_results(self.evaluation)
+        evaluation_results = get_results(self.evaluation)
+
+        question_results = [
+            question_result
+            for contribution_result in evaluation_results.contribution_results
+            for questionnaire_result in contribution_result.questionnaire_results
+            for question_result in questionnaire_result.question_results
+        ]
+
+        self.assertIsNone(average_grade_questions_distribution(question_results))
+        self.assertIsNone(average_non_grade_rating_questions_distribution(question_results))
+
+        counters = [
+            *make_rating_answer_counters(grade_question, self.contribution1, [1, 0, 0, 0, 0], False),
+            *make_rating_answer_counters(likert_question, self.contribution1, [0, 0, 3, 0, 0], False),
+        ]
+        RatingAnswerCounter.objects.bulk_create(counters)
+
+        cache_results(self.evaluation)
+        evaluation_results = get_results(self.evaluation)
+
+        question_results = [
+            question_result
+            for contribution_result in evaluation_results.contribution_results
+            for questionnaire_result in contribution_result.questionnaire_results
+            for question_result in questionnaire_result.question_results
+        ]
+
+        grade_distribution = average_grade_questions_distribution(question_results)
+        self.assertEqual(grade_distribution, (1, 0, 0, 0, 0))  # Only the counting grade question should be included
+        self.assertAlmostEqual(distribution_to_grade(grade_distribution), 1.0)
+
+        non_grade_distribution = average_non_grade_rating_questions_distribution(question_results)
+        self.assertEqual(
+            non_grade_distribution, (0, 0, 1, 0, 0)
+        )  # Only the counting likert question should be included
+        self.assertAlmostEqual(distribution_to_grade(non_grade_distribution), 3.0)
+
+    def test_dropout_questionnaire_excluded_from_distribution(self):
+        make_rating_answer_counters(self.question_grade, self.general_contribution, [0, 0, 0, 0, 10])
+        cache_results(self.evaluation)
+
+        distribution_without_dropout = calculate_average_distribution(self.evaluation)
+        self.assertIsNotNone(distribution_without_dropout)
+
+        dropout_questionnaire = baker.make(Questionnaire, type=Questionnaire.Type.DROPOUT)
+        dropout_question = baker.make(
+            Question,
+            questionnaire=dropout_questionnaire,
+            type=QuestionType.GRADE,
+            counts_for_grade=False,
         )
+        self.evaluation.general_contribution.questionnaires.add(dropout_questionnaire)
+        make_rating_answer_counters(dropout_question, self.evaluation.general_contribution, [10, 0, 0, 0, 0])
+        cache_results(self.evaluation)
 
-        make_rating_answer_counters(general_question, contribution, [10, 10, 0, 0, 0])
-        make_rating_answer_counters(dropout_question, contribution, [0, 0, 0, 0, 10])
+        distribution_with_dropout = calculate_average_distribution(self.evaluation)
+        self.assertEqual(distribution_without_dropout, distribution_with_dropout)
 
+        dropout_question.counts_for_grade = True
+        dropout_question.save()
         cache_results(self.evaluation)
 
-        calculated_grade = distribution_to_grade(calculate_average_distribution(self.evaluation))
-        self.assertAlmostEqual(calculated_grade, 1.5)
+        # Should raise AssertionError because dropout questionnaire has counts_for_grade=True
+        with self.assertRaises(AssertionError):
+            calculate_average_distribution(self.evaluation)
 
 
 class TestTextAnswerVisibilityInfo(TestCase):

evap/results/tools.py

@@ -324,7 +324,7 @@ def average_grade_questions_distribution(results):
         [
             (unipolarized_distribution(result), result.count_sum)
             for result in results
-            if result.question.is_grade_question
+            if result.question.is_grade_question and result.question.counts_for_grade
         ]
     )
 
@@ -334,7 +334,7 @@ def average_non_grade_rating_questions_distribution(results):
         [
             (unipolarized_distribution(result), result.count_sum)
             for result in results
-            if result.question.is_non_grade_rating_question
+            if result.question.is_non_grade_rating_question and result.question.counts_for_grade
         ]
     )
 
@@ -393,7 +393,9 @@ def calculate_average_distribution(evaluation):
     grouped_results = defaultdict(list)
     for contribution_result in get_results(evaluation).contribution_results:
         for questionnaire_result in contribution_result.questionnaire_results:
-            if not questionnaire_result.questionnaire.is_dropout:  # dropout questionnaires are not counted
+            if questionnaire_result.questionnaire.is_dropout:  # dropout questionnaires are not counted
+                assert not any(result.question.counts_for_grade for result in questionnaire_result.question_results)
+            if not questionnaire_result.questionnaire.is_dropout:
                 grouped_results[contribution_result.contributor].extend(questionnaire_result.question_results)
 
     evaluation_results = grouped_results.pop(None, [])
@@ -413,6 +415,8 @@ def calculate_average_distribution(evaluation):
                         ),
                     ]
                 ),
+                # The weight of this contributors grade is supposed to represent the number of students the
+                # contributor interacted with, which we derive from the max answer count, independently of counts_for_grades.
                 max(
                     (result.count_sum for result in contributor_results if result.question.is_rating_question),
                     default=0,

evap/staff/forms.py

@@ -907,22 +907,29 @@ def save(self, commit=True):
 class QuestionForm(forms.ModelForm):
     class Meta:
         model = Question
-        fields = ("order", "questionnaire", "text_de", "text_en", "type", "allows_additional_textanswers")
+        fields = (
+            "order",
+            "questionnaire",
+            "text_de",
+            "text_en",
+            "type",
+            "allows_additional_textanswers",
+            "counts_for_grade",
+        )
         widgets = {
             "text_de": forms.Textarea(attrs={"rows": 2}),
             "text_en": forms.Textarea(attrs={"rows": 2}),
             "order": forms.HiddenInput(),
         }
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if self.instance.pk and self.instance.type in [QuestionType.TEXT, QuestionType.HEADING]:
-            self.fields["allows_additional_textanswers"].disabled = True
-
     def clean(self):
         super().clean()
+        questionnaire = self.cleaned_data.get("questionnaire")
+        if questionnaire and questionnaire.is_dropout:
+            self.cleaned_data["counts_for_grade"] = False
         if self.cleaned_data.get("type") in [QuestionType.TEXT, QuestionType.HEADING]:
             self.cleaned_data["allows_additional_textanswers"] = False
+            self.cleaned_data["counts_for_grade"] = False
         return self.cleaned_data