ramon
/
vbv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: dashboard attendance days

This commit is contained in:
Reto Aebersold 2023-10-16 15:14:17 +02:00
parent 90a8f851d2
commit 7d691e4f78
4 changed files with 397 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
server/vbv_lernwelt/dashboard/graphql/queries.py
View File

@ -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)

106
server/vbv_lernwelt/dashboard/graphql/types.py
View File

@ -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):
session = []
def resolve_attendance_day_presences(root, info):
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")

240
server/vbv_lernwelt/dashboard/tests/test_graphql.py
View File

@ -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):
self.trainer = create_user("supervisor")
self.course = create_course("Test Course")
self.course_session = create_course_session(
course=self.course, title="Test Bern 2022 a"
)
# def test_course_dashboard(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,
# )
#
# 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,
user=self.trainer,
course_session=course_session,
user=supervisor,
role=CourseSessionUser.Role.SESSION_SUPERVISOR,
)
def test_courses(self):
# GIVEN
some_course = create_course("Other Course")
some_course_session = create_course_session(
course=some_course, title="Here is go study"
)
circle, _ = create_circle(title="Test Circle", course_page=course_page)
m1 = create_user("member_1")
add_course_session_user(
course_session=some_course_session,
user=self.trainer,
course_session=course_session,
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
course_sessions{{
session_id
attendance_day_presences{{
summary{{
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)
self.assertEqual(course_dashboard[0]["course_id"], str(self.course.id))
attendance_day_presences = data["course_dashboard"][0][
"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)

82
server/vbv_lernwelt/dashboard/tests/utils.py
View File

@ -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
def create_course(title: str) -> Course:
return Course.objects.create(
title=title, slug=slugify(title), category_name="Handlungsfeld"
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) -> Tuple[Course, CoursePage]:
course = Course.objects.create(title=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(
username="username",
return User.objects.create_user(
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,
),
)