feat: dashboard attendance days

server/vbv_lernwelt/dashboard/graphql/queries.py

@@ -5,14 +5,21 @@ from vbv_lernwelt.dashboard.graphql.types import CourseDashboardType
 
 
 class DashboardQuery(graphene.ObjectType):
-    course_dashboard = graphene.List(CourseDashboardType)
+    course_dashboard = graphene.List(
+        CourseDashboardType, course_id=graphene.String(required=False)
+    )
 
     def resolve_course_dashboard(root, info, course_id: str | None = None):
         user = info.context.user
-        courses = Course.objects.filter(
+        query = Course.objects.filter(
             coursesession__coursesessionuser__user=user,
             coursesession__coursesessionuser__role=CourseSessionUser.Role.SESSION_SUPERVISOR,
-        ).distinct()
+        )
+
+        if course_id:
+            query = query.filter(id=course_id)
+
+        courses = query.distinct()
 
         return [
             CourseDashboardType(course_id=course.id, course_title=course.title)

server/vbv_lernwelt/dashboard/graphql/types.py

@@ -1,16 +1,114 @@
+import datetime
+import math
+from typing import List
+
 import graphene
 
+from vbv_lernwelt.course.models import CourseSessionUser
+from vbv_lernwelt.course_session.models import CourseSessionAttendanceCourse
+from vbv_lernwelt.course_session.services.attendance import AttendanceUserStatus
+from vbv_lernwelt.notify.email.email_services import format_swiss_datetime
+
+
+class CircleDashboardType(graphene.ObjectType):
+    circle_id = graphene.String()
+    circle_title = graphene.String()
+
 
 class CourseSessionDashboardType(graphene.ObjectType):
     session_id = graphene.String()
+    session_title = graphene.String()
+    session_generation = graphene.String()
+
+
+class AttendanceSummary(graphene.ObjectType):
+    days_completed = graphene.Int()
+    participants_present = graphene.Int()
+
+
+class Record(graphene.ObjectType):
+    course_session_id = graphene.String()
+    generation = graphene.String()
+    circle_id = graphene.String()
+    due_date = graphene.String()
+    participants_present = graphene.Int()
+    participants_total = graphene.Int()
+    cockpit_url = graphene.String()
+
+
+class AttendanceDayPresences(graphene.ObjectType):
+    records = graphene.List(Record)
+    summary = graphene.Field(AttendanceSummary)
+    filter = graphene.String()
+
+
+def calculate_avg_participation(records: List[Record]) -> float:
+    if not records:
+        return 0.0
+
+    total_ratio = 0.0
+    for record in records:
+        if record.participants_total == 0:
+            continue
+        total_ratio += float(record.participants_present) / float(
+            record.participants_total
+        )
+
+    return math.ceil(total_ratio / len(records) * 100)
 
 
 class CourseDashboardType(graphene.ObjectType):
     course_id = graphene.String()
     course_title = graphene.String()
-    course_sessions = graphene.List(CourseSessionDashboardType)
+    # course_sessions = graphene.List(CourseSessionDashboardType)
+    attendance_day_presences = graphene.Field(AttendanceDayPresences)
 
-    def resolve_course_sessions(self, info):
+    def resolve_attendance_day_presences(root, info):
-        session = []
+        user = info.context.user
+        completed = CourseSessionAttendanceCourse.objects.filter(
+            course_session__coursesessionuser__user=user,
+            course_session__coursesessionuser__role=CourseSessionUser.Role.SESSION_SUPERVISOR,
+            due_date__end__lt=datetime.datetime.now(),
+        ).order_by("-due_date__end")
 
-        return [CourseSessionDashboardType() for s in session]
+        _filter = {}
+        records = []
+
+        for attendance_day in completed:
+            circle = attendance_day.learning_content.get_parent_circle()
+
+            course_session = attendance_day.course_session
+
+            url = f"/course/{course_session.course.slug}/cockpit/attendance?id={attendance_day.learning_content.id}&courseSessionId={course_session.id}"
+
+            participants_total = CourseSessionUser.objects.filter(
+                course_session=course_session, role=CourseSessionUser.Role.MEMBER
+            ).count()
+
+            participants_present = len(
+                [
+                    participant
+                    for participant in attendance_day.attendance_user_list
+                    if participant["status"] == AttendanceUserStatus.PRESENT.value
+                ]
+            )
+
+            _filter[circle.id] = circle.title
+            records.append(
+                Record(
+                    course_session_id=course_session.id,
+                    generation=course_session.generation,
+                    circle_id=circle.id,
+                    due_date=format_swiss_datetime(attendance_day.due_date.end),
+                    participants_present=participants_present,
+                    participants_total=participants_total,
+                    cockpit_url=url,
+                )
+            )
+
+        summary = AttendanceSummary(
+            days_completed=completed.count(),
+            participants_present=calculate_avg_participation(records),
+        )
+
+        return AttendanceDayPresences(summary=summary, records=records, filter="fuck")

server/vbv_lernwelt/dashboard/tests/test_graphql.py

@@ -1,8 +1,14 @@
+from datetime import timedelta
+
+from django.utils import timezone
 from graphene_django.utils import GraphQLTestCase
 
 from vbv_lernwelt.course.models import CourseSessionUser
+from vbv_lernwelt.course_session.services.attendance import AttendanceUserStatus
 from vbv_lernwelt.dashboard.tests.utils import (
     add_course_session_user,
+    create_attendance_course,
+    create_circle,
     create_course,
     create_course_session,
     create_user,
@@ -12,38 +18,209 @@ from vbv_lernwelt.dashboard.tests.utils import (
 class DashboardTestCase(GraphQLTestCase):
     GRAPHQL_URL = "/server/graphql/"
 
-    def setUp(self):
+    # def test_course_dashboard(self):
-        self.trainer = create_user("supervisor")
+    #     # GIVEN
-        self.course = create_course("Test Course")
+    #     supervisor = create_user("supervisor")
-        self.course_session = create_course_session(
+    #     course = create_course("Test Course")
-            course=self.course, title="Test Bern 2022 a"
+    #     course_session = create_course_session(
-        )
+    #         course=course, title="Test Bern 2022 a"
+    #     )
+    #     add_course_session_user(
+    #         course_session=course_session,
+    #         user=supervisor,
+    #         role=CourseSessionUser.Role.SESSION_SUPERVISOR,
+    #     )
+    #
+    #     some_course = create_course("Other Course")
+    #     some_course_session = create_course_session(
+    #         course=some_course, title="Here is go study"
+    #     )
+    #     add_course_session_user(
+    #         course_session=some_course_session,
+    #         user=supervisor,
+    #         role=CourseSessionUser.Role.MEMBER,
+    #     )
+    #
+    #     self.client.force_login(supervisor)
+    #
+    #     query = f"""
+    #             query {{
+    #                 course_dashboard {{
+    #                     course_id
+    #                     course_title
+    #                 }}
+    #             }}
+    #             """
+    #
+    #     # WHEN
+    #     response = self.query(query)
+    #
+    #     # THEN
+    #     self.assertResponseNoErrors(response)
+    #
+    #     course_dashboard = response.json()["data"]["course_dashboard"]
+    #
+    #     self.assertEqual(len(course_dashboard), 1)
+    #     self.assertEqual(course_dashboard[0]["course_id"], str(course.id))
+    #     self.assertEqual(course_dashboard[0]["course_title"], str(course.title))
+    #
+    # def test_course_dashboard_id(self):
+    #     # GIVEN
+    #     supervisor = create_user("supervisor")
+    #     course_1 = create_course("Test Course 1")
+    #     course_2 = create_course("Test Course 2")
+    #     course_session_1 = create_course_session(
+    #         course=course_1, title="Test Course 1 Session"
+    #     )
+    #     course_session_2 = create_course_session(
+    #         course=course_2, title="Test Course 2 Session"
+    #     )
+    #     add_course_session_user(
+    #         course_session=course_session_1,
+    #         user=supervisor,
+    #         role=CourseSessionUser.Role.SESSION_SUPERVISOR,
+    #     )
+    #     add_course_session_user(
+    #         course_session=course_session_2,
+    #         user=supervisor,
+    #         role=CourseSessionUser.Role.SESSION_SUPERVISOR,
+    #     )
+    #
+    #     self.client.force_login(supervisor)
+    #
+    #     query = f"""query($course_id: String) {{
+    #         course_dashboard(course_id: $course_id) {{
+    #             course_id
+    #         }}
+    #     }}
+    #                         """
+    #     variables = {"course_id": str(course_2.id)}
+    #
+    #     # WHEN
+    #     response = self.query(query, variables=variables)
+    #
+    #     # THEN
+    #     self.assertResponseNoErrors(response)
+    #
+    #     course_dashboard = response.json()["data"]["course_dashboard"]
+    #
+    #     self.assertEqual(len(course_dashboard), 1)
+    #     self.assertEqual(course_dashboard[0]["course_id"], str(course_2.id))
+    #
+    # def test_course_dashboard_sessions(self):
+    #     # GIVEN
+    #     supervisor = create_user("supervisor")
+    #     course = create_course("Test Course")
+    #     course_session = create_course_session(
+    #         course=course, title="Test Bern 2022 a"
+    #     )
+    #     add_course_session_user(
+    #         course_session=course_session,
+    #         user=supervisor,
+    #         role=CourseSessionUser.Role.SESSION_SUPERVISOR,
+    #     )
+    #
+    #     self.client.force_login(supervisor)
+    #
+    #     query = f"""
+    #             query {{
+    #                 course_dashboard {{
+    #                     course_sessions{{
+    #                         session_id
+    #                         session_title
+    #                         session_generation
+    #                     }}
+    #                 }}
+    #             }}
+    #             """
+    #
+    #     # WHEN
+    #     response = self.query(query)
+    #
+    #     # THEN
+    #     self.assertResponseNoErrors(response)
+    #
+    #     course_dashboard = response.json()["data"]["course_dashboard"][0]
+    #     session = course_dashboard["course_sessions"][0]
+    #     self.assertEqual(session["session_id"], str(course_session.id))
+    #     self.assertEqual(session["session_title"], str(course_session.title))
+    #     self.assertEqual(session["session_generation"], str(course_session.generation))
+
+    def test_attendance_day_presences(self):
+        # GIVEN
+        course, course_page = create_course("Test Course")
+        course_session = create_course_session(course=course, title="Test Bern 2022 a")
+
+        supervisor = create_user("supervisor")
+
         add_course_session_user(
-            course_session=self.course_session,
+            course_session=course_session,
-            user=self.trainer,
+            user=supervisor,
             role=CourseSessionUser.Role.SESSION_SUPERVISOR,
         )
 
-    def test_courses(self):
+        circle, _ = create_circle(title="Test Circle", course_page=course_page)
-        # GIVEN
+
-        some_course = create_course("Other Course")
+        m1 = create_user("member_1")
-        some_course_session = create_course_session(
-            course=some_course, title="Here is go study"
-        )
         add_course_session_user(
-            course_session=some_course_session,
+            course_session=course_session,
-            user=self.trainer,
+            user=m1,
             role=CourseSessionUser.Role.MEMBER,
         )
 
-        self.client.force_login(self.trainer)
+        m2 = create_user("member_2")
+        add_course_session_user(
+            course_session=course_session,
+            user=m2,
+            role=CourseSessionUser.Role.MEMBER,
+        )
+
+        m3 = create_user("member_3")
+        add_course_session_user(
+            course_session=course_session,
+            user=m3,
+            role=CourseSessionUser.Role.MEMBER,
+        )
+
+        e1 = create_user("expert_1")
+        add_course_session_user(
+            course_session=course_session,
+            user=e1,
+            role=CourseSessionUser.Role.EXPERT,
+        )
+
+        attendance_user_list = [
+            {"user_id": str(m1.id), "status": AttendanceUserStatus.PRESENT.value},
+            {"user_id": str(m2.id), "status": AttendanceUserStatus.ABSENT.value},
+        ]
+
+        due_date_end = timezone.now() - timedelta(hours=2)
+        attendance_course = create_attendance_course(
+            course_session=course_session,
+            circle=circle,
+            attendance_user_list=attendance_user_list,
+            due_date_end=due_date_end,
+        )
+
+        self.client.force_login(supervisor)
 
         query = f"""
                 query {{
                     course_dashboard {{
-                        course_id
+                        attendance_day_presences{{
-                        course_sessions{{
+                            summary{{
-                            session_id
+                                days_completed
+                                participants_present    
+                            }}
+                            records{{
+                                course_session_id
+                                generation
+                                circle_id
+                                due_date
+                                participants_present
+                                participants_total
+                                cockpit_url                                
+                            }}                            
                         }}
                     }}
                 }}
@@ -52,10 +229,25 @@ class DashboardTestCase(GraphQLTestCase):
         # WHEN
         response = self.query(query)
 
-        # THEN
         self.assertResponseNoErrors(response)
 
-        course_dashboard = response.json()["data"]["course_dashboard"]
+        data = response.json()["data"]
 
-        self.assertEqual(len(course_dashboard), 1)
+        attendance_day_presences = data["course_dashboard"][0][
-        self.assertEqual(course_dashboard[0]["course_id"], str(self.course.id))
+            "attendance_day_presences"
+        ]
+
+        record = attendance_day_presences["records"][0]
+
+        self.assertEqual(record["course_session_id"], str(course_session.id))
+        self.assertEqual(record["generation"], "2023")
+        self.assertEqual(record["participants_present"], 1)
+        self.assertEqual(record["participants_total"], 3)
+        self.assertEqual(
+            record["cockpit_url"],
+            f"/course/test-lehrgang/cockpit/attendance?id={attendance_course.learning_content.id}&courseSessionId={course_session.id}",
+        )
+
+        summary = attendance_day_presences["summary"]
+        self.assertEqual(summary["days_completed"], 1)
+        self.assertEqual(summary["participants_present"], 34)

server/vbv_lernwelt/dashboard/tests/utils.py

@@ -1,33 +1,57 @@
+from datetime import datetime, timedelta
+from typing import List, Tuple
+
 from django.contrib.auth.hashers import make_password
 from django.utils import timezone
-from django.utils.text import slugify
 
 from vbv_lernwelt.core.models import User
-from vbv_lernwelt.course.models import Course, CourseSession, CourseSessionUser
+from vbv_lernwelt.course.factories import CoursePageFactory
+from vbv_lernwelt.course.models import (
+    Course,
+    CoursePage,
+    CourseSession,
+    CourseSessionUser,
+)
+from vbv_lernwelt.course.utils import get_wagtail_default_site
+from vbv_lernwelt.course_session.models import CourseSessionAttendanceCourse
+from vbv_lernwelt.duedate.models import DueDate
+from vbv_lernwelt.learnpath.models import Circle, LearningPath
+from vbv_lernwelt.learnpath.tests.learning_path_factories import (
+    CircleFactory,
+    LearningContentAttendanceCourseFactory,
+    LearningPathFactory,
+)
 
 
-def create_course(title: str) -> Course:
+def create_course(title: str) -> Tuple[Course, CoursePage]:
-    return Course.objects.create(
+    course = Course.objects.create(title=title, category_name="Handlungsfeld")
-        title=title, slug=slugify(title), category_name="Handlungsfeld"
+
+    course_page = CoursePageFactory(
+        title="Test Lehrgang",
+        parent=get_wagtail_default_site().root_page,
+        course=course,
     )
+    course.slug = course_page.slug
+    course.save()
+
+    return course, course_page
 
 
 def create_user(username: str) -> User:
-    user = User.objects.create_user(
+    return User.objects.create_user(
-        username="username",
+        username=username,
         password=make_password("test"),
         email=f"{username}@example.com",
         language="de",
     )
 
-    return user
-
 
 def create_course_session(course: Course, title: str) -> CourseSession:
     return CourseSession.objects.create(
         course=course,
         title=title,
         import_id=title,
+        generation="2023",
         start_date=timezone.now(),
     )
 
@@ -40,3 +64,39 @@ def add_course_session_user(
         user=user,
         role=role,
     )
+
+
+def create_circle(
+    title: str, course_page: CoursePage, learning_path: LearningPath | None = None
+) -> Tuple[Circle, LearningPath]:
+    if not learning_path:
+        learning_path = LearningPathFactory(title="Test Lernpfad", parent=course_page)
+
+    circle = CircleFactory(
+        title=title, parent=learning_path, description="Circle Description"
+    )
+
+    return circle, learning_path
+
+
+def create_attendance_course(
+    course_session: CourseSession,
+    circle: Circle,
+    attendance_user_list: List,
+    due_date_end: datetime,
+) -> CourseSessionAttendanceCourse:
+    learning_content_dummy = LearningContentAttendanceCourseFactory(
+        title="Lerninhalt Dummy",
+        parent=circle,
+    )
+
+    return CourseSessionAttendanceCourse.objects.create(
+        course_session=course_session,
+        learning_content=learning_content_dummy,
+        attendance_user_list=attendance_user_list,
+        due_date=DueDate.objects.create(
+            course_session=course_session,
+            start=due_date_end - timedelta(hours=8),
+            end=due_date_end,
+        ),
+    )