Refactor display

client/src/pages/competence/CompetenceCertificateComponent.vue

@@ -23,7 +23,11 @@ const userPointsEvaluatedAssignments = computed(() => {
 });
 
 const userGrade = computed(() => {
-  return calcCompetenceCertificateGrade(props.competenceCertificate.assignments);
+  return calcCompetenceCertificateGrade(props.competenceCertificate.assignments, true);
+});
+
+const userGradeRounded2Places = computed(() => {
+  return calcCompetenceCertificateGrade(props.competenceCertificate.assignments, false);
 });
 
 const numAssignmentsEvaluated = computed(() => {
@@ -82,6 +86,10 @@ const frontendUrl = computed(() => {
         {{ $t("a.competenceCertificateNoUserPoints") }}
       </section>
 
+      <div class="text-gray-900">
+        {{ $t("a.Ungerundete Note") }}: {{ userGradeRounded2Places }}
+      </div>
+
       <ItProgress :status-count="progressStatusCount" />
       <div>
         {{

client/src/pages/competence/utils.ts

@@ -1,5 +1,5 @@
 import type { StatusCount } from "@/components/ui/ItProgress.vue";
-import { percentToGrade } from "@/services/assignmentService";
+import { percentToRoundedGrade } from "@/services/assignmentService";
 import type { CompetenceCertificate, CompetenceCertificateAssignment } from "@/types";
 import _ from "lodash";
 
@@ -22,7 +22,8 @@ export function assignmentsUserPoints(assignments: CompetenceCertificateAssignme
 }
 
 export function calcCompetenceCertificateGrade(
-  assignments: CompetenceCertificateAssignment[]
+  assignments: CompetenceCertificateAssignment[],
+  roundedToHalfGrade = true
 ) {
   const evaluatedAssignments = assignments.filter(
     (a) => a.completion?.completion_status === "EVALUATION_SUBMITTED"
@@ -43,12 +44,17 @@ export function calcCompetenceCertificateGrade(
     return undefined;
   }
 
-  return percentToGrade(_.sum(adjustedResults) / adjustedAssignmentCount);
+  return percentToRoundedGrade(
+    _.sum(adjustedResults) / adjustedAssignmentCount,
+    roundedToHalfGrade
+  );
 }
 
 export function calcCompetencesTotalGrade(
   competenceCertificates: CompetenceCertificate[]
 ) {
+  // für das Total der Kompetenznote werden jeweils die gerundenten Noten der
+  // einzelnen Kompetenznachweise verwendet und dann noch einmal gerundet.
   const competenceCertificateGrades = competenceCertificates
     .map((cc) => {
       return calcCompetenceCertificateGrade(cc.assignments);
@@ -63,7 +69,7 @@ export function calcCompetencesTotalGrade(
     _.sum(competenceCertificateGrades.map((g) => g - 1)) /
     (competenceCertificateGrades.length * 5);
 
-  return percentToGrade(percentGraded);
+  return percentToRoundedGrade(percentGraded);
 }
 
 export function competenceCertificateProgressStatusCount(

client/src/services/__tests__/assignmentService.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it } from "vitest";
-import { pointsToGrade } from "../assignmentService";
+import { percentToRoundedGrade, pointsToGrade } from "../assignmentService";
 
 describe("assignmentService", () => {
   it("pointsToGrade", () => {
@@ -29,4 +29,61 @@ describe("assignmentService", () => {
     expect(pointsToGrade(1, 24)).toBe(1);
     expect(pointsToGrade(0, 24)).toBe(1);
   });
+
+  it("percentToRoundedGrade with half grades", () => {
+    expect(percentToRoundedGrade(24 / 24)).toBe(6);
+    expect(percentToRoundedGrade(23 / 24)).toBe(6);
+    expect(percentToRoundedGrade(22 / 24)).toBe(5.5);
+    expect(percentToRoundedGrade(21 / 24)).toBe(5.5);
+    expect(percentToRoundedGrade(20 / 24)).toBe(5);
+    expect(percentToRoundedGrade(19 / 24)).toBe(5);
+    expect(percentToRoundedGrade(18 / 24)).toBe(5);
+    expect(percentToRoundedGrade(17 / 24)).toBe(4.5);
+    expect(percentToRoundedGrade(16 / 24)).toBe(4.5);
+    expect(percentToRoundedGrade(15 / 24)).toBe(4);
+    expect(percentToRoundedGrade(14 / 24)).toBe(4);
+    expect(percentToRoundedGrade(13 / 24)).toBe(3.5);
+    expect(percentToRoundedGrade(12 / 24)).toBe(3.5);
+    expect(percentToRoundedGrade(11 / 24)).toBe(3.5);
+    expect(percentToRoundedGrade(10 / 24)).toBe(3);
+    expect(percentToRoundedGrade(9 / 24)).toBe(3);
+    expect(percentToRoundedGrade(8 / 24)).toBe(2.5);
+    expect(percentToRoundedGrade(7 / 24)).toBe(2.5);
+    expect(percentToRoundedGrade(6 / 24)).toBe(2.5);
+    expect(percentToRoundedGrade(5 / 24)).toBe(2);
+    expect(percentToRoundedGrade(4 / 24)).toBe(2);
+    expect(percentToRoundedGrade(3 / 24)).toBe(1.5);
+    expect(percentToRoundedGrade(2 / 24)).toBe(1.5);
+    expect(percentToRoundedGrade(1 / 24)).toBe(1);
+    expect(percentToRoundedGrade(0 / 24)).toBe(1);
+  });
+
+  it("percentToRoundedGrade with 2 decimal places", () => {
+    expect(percentToRoundedGrade(24 / 24, false)).toBeCloseTo(6);
+    expect(percentToRoundedGrade(23 / 24, false)).toBeCloseTo(5.79);
+    expect(percentToRoundedGrade(22 / 24, false)).toBeCloseTo(5.58);
+    expect(percentToRoundedGrade(21 / 24, false)).toBeCloseTo(5.38);
+    expect(percentToRoundedGrade(20 / 24, false)).toBeCloseTo(5.17);
+    expect(percentToRoundedGrade(19 / 24, false)).toBeCloseTo(4.96);
+    expect(percentToRoundedGrade(18 / 24, false)).toBeCloseTo(4.75);
+    expect(percentToRoundedGrade(17 / 24, false)).toBeCloseTo(4.54);
+    expect(percentToRoundedGrade(16 / 24, false)).toBeCloseTo(4.33);
+    expect(percentToRoundedGrade(15 / 24, false)).toBeCloseTo(4.13);
+    expect(percentToRoundedGrade(14 / 24, false)).toBeCloseTo(3.92);
+    expect(percentToRoundedGrade(13 / 24, false)).toBeCloseTo(3.71);
+    expect(percentToRoundedGrade(12 / 24, false)).toBeCloseTo(3.5);
+    expect(percentToRoundedGrade(11 / 24, false)).toBeCloseTo(3.29);
+    expect(percentToRoundedGrade(10 / 24, false)).toBeCloseTo(3.08);
+    expect(percentToRoundedGrade(9 / 24, false)).toBeCloseTo(2.88);
+    expect(percentToRoundedGrade(8 / 24, false)).toBeCloseTo(2.67);
+    expect(percentToRoundedGrade(7 / 24, false)).toBeCloseTo(2.46);
+    expect(percentToRoundedGrade(6 / 24, false)).toBeCloseTo(2.25);
+    expect(percentToRoundedGrade(5 / 24, false)).toBeCloseTo(2.04);
+    expect(percentToRoundedGrade(4 / 24, false)).toBeCloseTo(1.83);
+    expect(percentToRoundedGrade(3 / 24, false)).toBeCloseTo(1.63);
+    expect(percentToRoundedGrade(2 / 24, false)).toBeCloseTo(1.42);
+    expect(percentToRoundedGrade(1 / 24, false)).toBeCloseTo(1.21);
+    expect(percentToRoundedGrade(0 / 24, false)).toBeCloseTo(1);
+  });
+
 });

client/src/services/assignmentService.ts

@@ -91,9 +91,14 @@ export function pointsToGrade(points: number, maxPoints: number) {
   return Math.min(halfGrade, 5) + 1;
 }
 
-export function percentToGrade(percent: number) {
-  // round to half-grades
-  const grade = Math.round(percent * 10);
-  const halfGrade = grade / 2;
-  return Math.min(halfGrade, 5) + 1;
+export function percentToRoundedGrade(percent: number, roundedToHalfGrade = true) {
+  if (roundedToHalfGrade) {
+    // Round to half-grades
+    const grade = Math.round(percent * 10);
+    const halfGrade = grade / 2;
+    return Math.min(halfGrade, 5) + 1;
+  } else {
+    // Round to 2 decimal places
+    return Math.round((percent * 5 + 1) * 100) / 100;
+  }
 }

server/vbv_lernwelt/course/creators/test_course.py

@@ -395,6 +395,8 @@ def create_test_assignment_evaluation_data(
 def create_edoniq_test_result_data(
     assignment, course_session, assignment_user, user_points=19, max_points=24
 ):
+    assignment.assignment.evaluation_tasks.raw_data[0]['value']['max_points'] = max_points
+    assignment.assignment.save()
     if assignment and course_session and assignment_user:
         update_assignment_completion(
             assignment_user=assignment_user,