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

Merged in bugfix/VBV-752-ausbildungsverantwortlicher-export-fixen (pull request #396) 

VBV-752: Ausbildungsverantwortlicher: Export von Personen

Approved-by: Christian Cueni
This commit is contained in:
Elia Bieri 2024-10-09 06:36:23 +00:00 committed by Christian Cueni
parent d1f796d319 7dd38182fc
commit 090082efba
9 changed files with 268 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
client/src/pages/dashboard/DashboardPersonsPage.vue
View File

@ -7,9 +7,10 @@ import {
type DashboardPersonCourseSessionType,
exportPersons,
} from "@/services/dashboard";
import { useCourseSessionsStore } from "@/stores/courseSessions";
import { useUserStore } from "@/stores/user";
import type { DashboardPersonsPageMode, StatisticsFilterItem } from "@/types";
import { exportDataAsXls } from "@/utils/export";
import type { DashboardPersonsPageMode } from "@/types";
import { openDataAsXls } from "@/utils/export";
import { useRouteQuery } from "@vueuse/router";
import dayjs from "dayjs";
import { useTranslation } from "i18next-vue";
@ -39,6 +40,7 @@ const userStore = useUserStore();
const { loading, dashboardPersons } = useDashboardPersonsDueDates(props.mode);
const { CHOSEN_PROFILE_TO_NAME } = useChosenProfileMapping();
const { allCourseSessionActions } = useCourseSessionsStore();
const courses = computed(() => {
return [
@ -300,9 +302,34 @@ const filtersVisible = computed(() => {
);
});
const canExport = computed(() => {
// If user is only member, he can't export
// member = has is_member property, but not is_expert or is_supervisor
if (!allCourseSessionActions.has("is_member")) {
// is berufsbildner or expert or supervisor
return true;
}
if (
allCourseSessionActions.has("is_expert") ||
allCourseSessionActions.has("is_supervisor")
) {
// is member
return true;
}
return false;
});
function personRoleDisplayValue(personCourseSession: DashboardPersonCourseSessionType) {
if (
["SUPERVISOR", "EXPERT", "LEARNING_MENTOR"].includes(personCourseSession.user_role)
[
"SUPERVISOR",
"EXPERT",
"LEARNING_MENTOR",
"BERUFSBILDNER",
"LEARNING_MENTOR",
].includes(personCourseSession.user_role)
) {
return personCourseSession.user_role_display;
}
@ -310,31 +337,12 @@ function personRoleDisplayValue(personCourseSession: DashboardPersonCourseSessio
return "";
}
function exportData() {
const courseSessionIdsSet = new Set<string>();
// get all course session ids from users
if (selectedSession.value.id === UNFILTERED) {
for (const person of filteredPersons.value) {
for (const courseSession of person.course_sessions) {
courseSessionIdsSet.add(courseSession.id);
}
}
} else {
courseSessionIdsSet.add(selectedSession.value.id);
}
// construct StatisticsFilterItems for export call
const items: StatisticsFilterItem[] = [];
for (const csId of courseSessionIdsSet) {
items.push({
_id: "",
course_session_id: csId,
generation: "",
circle_id: "",
region: "",
});
}
exportDataAsXls(items, exportPersons, userStore.language);
async function exportData() {
const requestData = {
courseSessionUserIds: filteredPersons.value.map((person) => person.csu_id),
};
const data = await exportPersons(requestData, userStore.language);
openDataAsXls(data.encoded_data, data.file_name);
}
watch(selectedCourse, () => {
@ -366,7 +374,7 @@ watch(selectedRegion, () => {
<div class="mb-10 flex items-center justify-between">
<h2 class="my-4">{{ $t("a.Personen") }}</h2>
<button
v-if="userStore.course_session_experts.length > 0"
v-if="canExport"
class="flex"
data-cy="export-button"
@click="exportData"

4
client/src/services/dashboard.ts
View File

@ -20,6 +20,7 @@ import type {
DueDate,
XlsExportRequestData,
XlsExportResponseData,
XlsPersonExportRequestData,
} from "@/types";
export type DashboardPersonRoleType =
@ -79,6 +80,7 @@ export type DashboardPersonType = {
avatar_url: string;
avatar_url_small: string;
chosen_profile: string;
csu_id: string;
competence_metrics?: {
passed_count: number;
failed_count: number;
@ -273,7 +275,7 @@ export async function exportCompetenceElements(
}
export async function exportPersons(
data: XlsExportRequestData,
data: XlsPersonExportRequestData,
language: string
): Promise<XlsExportResponseData> {
return await itPost("/api/dashboard/export/persons/", data, {

13
client/src/stores/courseSessions.ts
View File

@ -129,6 +129,18 @@ export const useCourseSessionsStore = defineStore("courseSessions", () => {
return Boolean(hasPreview && (inLearningPath() || inCompetenceProfile()));
});
const allCourseSessionActions = computed(() => {
const actionsSet = new Set();
allCourseSessions.value.forEach((item) => {
item.actions.forEach((action) => {
actionsSet.add(action);
});
});
return actionsSet;
});
return {
uniqueCourseSessionsByCourse,
allCurrentCourseSessions,
@ -146,5 +158,6 @@ export const useCourseSessionsStore = defineStore("courseSessions", () => {
// only used for unit testing
allCourseSessions,
allCourseSessionActions,
};
});

4
client/src/types.ts
View File

@ -643,6 +643,10 @@ export interface XlsExportRequestData {
circleIds: number[];
}
export interface XlsPersonExportRequestData {
courseSessionUserIds: string[];
}
export interface XlsExportResponseData {
encoded_data: string;
file_name: string;

26
server/vbv_lernwelt/course/creators/test_course.py
View File

@ -35,6 +35,7 @@ from vbv_lernwelt.competence.factories import (
)
from vbv_lernwelt.competence.models import ActionCompetence
from vbv_lernwelt.core.constants import (
TEST_AUSBILDUNGSVERANTWORTLICHER1_USER_ID,
TEST_BERUFSBILDNER1_USER_ID,
TEST_COURSE_SESSION_BERN_ID,
TEST_COURSE_SESSION_ZURICH_ID,
@ -385,6 +386,31 @@ def create_test_course(
),
role="BERUFSBILDNER",
)
# Add Ausbildungsverantwortlicher
AgentParticipantRelation.objects.create(
agent=User.objects.get(id=TEST_AUSBILDUNGSVERANTWORTLICHER1_USER_ID),
participant=CourseSessionUser.objects.get(
user__id=TEST_STUDENT1_USER_ID,
course_session=cs_bern,
),
role="LEARNING_MENTOR",
)
AgentParticipantRelation.objects.create(
agent=User.objects.get(id=TEST_AUSBILDUNGSVERANTWORTLICHER1_USER_ID),
participant=CourseSessionUser.objects.get(
user__id=TEST_STUDENT2_USER_ID,
course_session=cs_zurich,
),
role="LEARNING_MENTOR",
)
AgentParticipantRelation.objects.create(
agent=User.objects.get(id=TEST_AUSBILDUNGSVERANTWORTLICHER1_USER_ID),
participant=CourseSessionUser.objects.get(
user__id=TEST_STUDENT3_USER_ID,
course_session=cs_bern,
),
role="LEARNING_MENTOR",
)
return course

54
server/vbv_lernwelt/dashboard/person_export.py
View File

@ -5,14 +5,12 @@ import structlog
from django.utils.translation import gettext_lazy as _
from openpyxl import Workbook
from vbv_lernwelt.core.models import User
from vbv_lernwelt.course.models import CourseSession
from vbv_lernwelt.course.models import CourseSessionUser
from vbv_lernwelt.course_session.services.export_attendance import (
add_user_headers,
make_export_filename,
sanitize_sheet_name,
)
from vbv_lernwelt.dashboard.utils import create_person_list_with_roles
from vbv_lernwelt.dashboard.utils import create_csu_dict
PERSONS_EXPORT_FILENAME = _("export_personen")
@ -20,28 +18,22 @@ logger = structlog.get_logger(__name__)
def export_persons(
user: User,
course_session_ids: list[str],
course_session_users: list[CourseSessionUser],
save_as_file: bool = False,
) -> Optional[bytes]:
if not course_session_ids:
if not course_session_users:
return
wb = Workbook()
# remove the first sheet is just easier than keeping track of the active sheet
wb.remove(wb.active)
user_with_roles = create_person_list_with_roles(
user, course_session_ids, include_private_data=True
)
course_sessions = CourseSession.objects.filter(id__in=course_session_ids)
for cs in course_sessions:
csu_data = [
create_csu_dict(csu, include_private_data=True) for csu in course_session_users
]
csu_data.sort(key=lambda x: x["last_name"])
_create_sheet(
wb,
cs.title,
cs.id,
user_with_roles,
csu_data,
)
if save_as_file:
@ -56,13 +48,11 @@ def export_persons(
def _create_sheet(
wb: Workbook,
title: str,
cs_id: int,
user_with_roles,
course_session_user_data: list[dict],
):
sheet = wb.create_sheet(title=sanitize_sheet_name(title))
sheet = wb.create_sheet()
if len(user_with_roles) == 0:
if len(course_session_user_data) == 0:
return sheet
# headers
@ -71,7 +61,7 @@ def _create_sheet(
sheet.cell(row=1, column=col_idx, value=str(_("Telefon")))
sheet.cell(row=1, column=col_idx + 1, value=str(_("Rolle")))
_add_rows(sheet, user_with_roles, cs_id)
_add_rows(sheet, course_session_user_data)
return sheet
@ -79,27 +69,11 @@ def _create_sheet(
def _add_rows(
sheet,
users,
course_session_id,
):
idx_offset = 0
for row_idx, user in enumerate(users, start=2):
def get_user_cs_by_id(user_cs, cs_id):
return next((cs for cs in user_cs if int(cs.get("id")) == cs_id), None)
user_cs = get_user_cs_by_id(user["course_sessions"], course_session_id)
if not user_cs:
logger.warning(
"User not found in course session",
user_id=user["user_id"],
course_session_id=course_session_id,
)
idx_offset += 1
continue
user_role = _role_as_string(user_cs.get("user_role"))
user_role = _role_as_string(user.get("role"))
idx = row_idx - idx_offset
sheet.cell(row=idx, column=1, value=user["first_name"])

116
server/vbv_lernwelt/dashboard/tests/test_export.py
View File

@ -4,6 +4,7 @@ from django.utils.translation import activate
from openpyxl import load_workbook
from vbv_lernwelt.core.constants import (
TEST_AUSBILDUNGSVERANTWORTLICHER1_USER_ID,
TEST_STUDENT1_USER_ID,
TEST_STUDENT2_USER_ID,
TEST_STUDENT3_USER_ID,
@ -13,9 +14,9 @@ from vbv_lernwelt.core.constants import (
from vbv_lernwelt.core.create_default_users import create_default_users
from vbv_lernwelt.core.models import User
from vbv_lernwelt.course.creators.test_course import create_test_course
from vbv_lernwelt.course.models import CourseSession
from vbv_lernwelt.course.models import CourseSession, CourseSessionUser
from vbv_lernwelt.course_session.tests.test_attendance_export import ExportBaseTestCase
from vbv_lernwelt.dashboard.person_export import export_persons
from vbv_lernwelt.dashboard.views import _export_persons_as_xls_data
from vbv_lernwelt.learnpath.models import Circle
@ -26,6 +27,8 @@ class PersonsExportTestCase(ExportBaseTestCase):
create_default_users()
create_test_course(include_vv=False, with_sessions=True)
self.default_sheet_name = "Sheet"
self.course_session_be = CourseSession.objects.get(title="Test Bern 2022 a")
self.course_session_zh = CourseSession.objects.get(title="Test Zürich 2022 a")
@ -36,10 +39,32 @@ class PersonsExportTestCase(ExportBaseTestCase):
self.test_trainer1 = User.objects.get(id=TEST_TRAINER1_USER_ID)
self.test_trainer2 = User.objects.get(id=TEST_TRAINER2_USER_ID)
self.test_ausbildungsverantwortlicher1 = User.objects.get(
id=TEST_AUSBILDUNGSVERANTWORTLICHER1_USER_ID
)
self.test_student1 = User.objects.get(id=TEST_STUDENT1_USER_ID)
self.test_student2 = User.objects.get(id=TEST_STUDENT2_USER_ID)
self.test_student3 = User.objects.get(id=TEST_STUDENT3_USER_ID)
self.test_student1_csu_be = CourseSessionUser.objects.get(
user=self.test_student1, course_session=self.course_session_be
)
self.test_student2_csu_be = CourseSessionUser.objects.get(
user=self.test_student2, course_session=self.course_session_be
)
self.test_student2_csu_zh = CourseSessionUser.objects.get(
user=self.test_student2, course_session=self.course_session_zh
)
self.test_student3_csu_be = CourseSessionUser.objects.get(
user=self.test_student3, course_session=self.course_session_be
)
self.test_trainer1_csu_be = CourseSessionUser.objects.get(
user=self.test_trainer1, course_session=self.course_session_be
)
self.test_trainer2_csu_zh = CourseSessionUser.objects.get(
user=self.test_trainer2, course_session=self.course_session_zh
)
self.test_student1_row = [
self.test_student1.first_name,
self.test_student1.last_name,
@ -91,9 +116,9 @@ class PersonsExportTestCase(ExportBaseTestCase):
return expected_data
def _generate_workbook(self, user, course_session_ids):
export_data = io.BytesIO(
export_persons(user, course_session_ids, save_as_file=False)
)
data = _export_persons_as_xls_data(user, course_session_ids)
self.assertIsNotNone(data)
export_data = io.BytesIO(data) # type: ignore
return load_workbook(export_data)
def _make_header(self):
@ -107,10 +132,16 @@ class PersonsExportTestCase(ExportBaseTestCase):
]
def test_export_persons(self):
wb = self._generate_workbook(self.test_trainer1, [self.course_session_be.id])
export_course_session_user_ids = [
self.test_student1_csu_be.id,
self.test_student2_csu_be.id,
self.test_student3_csu_be.id,
self.test_trainer1_csu_be.id,
]
wb = self._generate_workbook(self.test_trainer1, export_course_session_user_ids)
self.assertEqual(len(wb.sheetnames), 1)
self.assertEqual(wb.sheetnames[0], "Test Bern 2022 a")
wb.active = wb["Test Bern 2022 a"]
self.assertEqual(wb.sheetnames[0], self.default_sheet_name)
wb.active = wb[self.default_sheet_name]
data = self._generate_expected_data(
[
@ -120,33 +151,64 @@ class PersonsExportTestCase(ExportBaseTestCase):
self.test_trainer1_row,
]
)
self._check_export(wb, data, 5, 6)
self._check_export(wb, data, 4, 6)
wb = self._generate_workbook(self.test_trainer2, [self.course_session_zh.id])
export_course_session_user_ids = [
self.test_student2_csu_zh.id,
self.test_trainer2_csu_zh.id,
]
wb = self._generate_workbook(self.test_trainer2, export_course_session_user_ids)
self.assertEqual(len(wb.sheetnames), 1)
self.assertEqual(wb.sheetnames[0], "Test Zürich 2022 a")
wb.active = wb["Test Zürich 2022 a"]
self.assertEqual(wb.sheetnames[0], self.default_sheet_name)
wb.active = wb[self.default_sheet_name]
data = self._generate_expected_data(
[self.test_student2_row, self.test_trainer2_row]
)
self._check_export(wb, data, 3, 6)
def test_cannot_export_other_session(self):
wb = self._generate_workbook(self.test_trainer1, [self.course_session_zh.id])
def test_can_only_export_with_role(self):
csu = [
self.test_student1_csu_be.id,
self.test_student2_csu_be.id,
self.test_student3_csu_be.id,
self.test_student2_csu_zh.id,
]
wb = self._generate_workbook(self.test_trainer2, csu)
self.assertEqual(len(wb.sheetnames), 1)
self.assertEqual(wb.sheetnames[0], "Test Zürich 2022 a")
wb.active = wb["Test Zürich 2022 a"]
self.assertEqual(wb.sheetnames[0], self.default_sheet_name)
wb.active = wb[self.default_sheet_name]
self._check_export(wb, [[None] * 6], 1, 6)
data = self._generate_expected_data([self.test_student2_row])
self._check_export(wb, data, 1, 6)
def test_can_only_export_with_agent_participant_relation(self):
csu = [
self.test_student1_csu_be.id,
self.test_student2_csu_be.id,
self.test_student3_csu_be.id,
self.test_student2_csu_zh.id,
]
wb = self._generate_workbook(self.test_ausbildungsverantwortlicher1, csu)
self.assertEqual(len(wb.sheetnames), 1)
self.assertEqual(wb.sheetnames[0], self.default_sheet_name)
wb.active = wb[self.default_sheet_name]
data = self._generate_expected_data([self.test_student2_row])
self._check_export(wb, data, 1, 6)
def test_export_in_fr(self):
activate("fr")
wb = self._generate_workbook(self.test_trainer1, [self.course_session_be.id])
export_course_session_user_ids = [
self.test_student1_csu_be.id,
self.test_student2_csu_be.id,
self.test_student3_csu_be.id,
self.test_trainer1_csu_be.id,
]
wb = self._generate_workbook(self.test_trainer1, export_course_session_user_ids)
self.assertEqual(len(wb.sheetnames), 1)
self.assertEqual(wb.sheetnames[0], "Test Bern 2022 a")
wb.active = wb["Test Bern 2022 a"]
self.assertEqual(wb.sheetnames[0], self.default_sheet_name)
wb.active = wb[self.default_sheet_name]
header = [
"Prénom",
@ -165,10 +227,16 @@ class PersonsExportTestCase(ExportBaseTestCase):
def test_export_in_it(self):
activate("it")
wb = self._generate_workbook(self.test_trainer1, [self.course_session_be.id])
export_course_session_user_ids = [
self.test_student1_csu_be.id,
self.test_student2_csu_be.id,
self.test_student3_csu_be.id,
self.test_trainer1_csu_be.id,
]
wb = self._generate_workbook(self.test_trainer1, export_course_session_user_ids)
self.assertEqual(len(wb.sheetnames), 1)
self.assertEqual(wb.sheetnames[0], "Test Bern 2022 a")
wb.active = wb["Test Bern 2022 a"]
self.assertEqual(wb.sheetnames[0], self.default_sheet_name)
wb.active = wb[self.default_sheet_name]
header = [
"Nome",

27
server/vbv_lernwelt/dashboard/utils.py
View File

@ -95,20 +95,20 @@ def create_course_session_dict(course_session_object, my_role, user_role):
}
def create_person_list_with_roles(
user, course_session_ids=None, include_private_data=False
):
def create_csu_dict(csu: CourseSessionUser):
user_data = create_user_dict(csu.user)
def create_csu_dict(csu: CourseSessionUser, include_private_data=False):
user_data = create_user_dict(csu.user, include_private_data)
user_data["csu_id"] = csu.id
user_data["chosen_profile"] = (
csu.chosen_profile.code if csu.chosen_profile else "all"
)
user_data["paid_datetime"] = (
csu.paid_datetime.isoformat() if csu.paid_datetime else None
)
user_data["role"] = csu.role
return user_data
def create_user_dict(user_object: User):
def create_user_dict(user_object: User, include_private_data=False):
user_data = {
"user_id": user_object.id,
"first_name": user_object.first_name,
@ -123,9 +123,12 @@ def create_person_list_with_roles(
user_data["Lehrvertragsnummer"] = user_object.additional_json_data.get(
"Lehrvertragsnummer", ""
)
return user_data
def create_person_list_with_roles(
user, course_session_ids=None, include_private_data=False
):
course_sessions = get_course_sessions_with_roles_for_user(user)
if course_session_ids:
course_sessions = [
@ -140,7 +143,9 @@ def create_person_list_with_roles(
).select_related("user")
my_role = user_role(cs.roles)
for csu in course_session_users:
person_data = result_persons.get(csu.user.id, create_csu_dict(csu))
person_data = result_persons.get(
csu.user.id, create_csu_dict(csu, include_private_data)
)
person_data["course_sessions"].append(
create_course_session_dict(cs, my_role, csu.role)
)
@ -154,7 +159,9 @@ def create_person_list_with_roles(
participant_user = relation.participant.user
if participant_user.id not in result_persons:
person_data = create_csu_dict(relation.participant)
person_data = create_csu_dict(
relation.participant, include_private_data
)
person_data["course_sessions"] = [course_session_entry]
result_persons[participant_user.id] = person_data
else:
@ -193,7 +200,7 @@ def create_person_list_with_roles(
)
if mentor_relation.agent.id not in result_persons:
person_data = create_user_dict(mentor_relation.agent)
person_data = create_user_dict(mentor_relation.agent, include_private_data)
person_data["course_sessions"] = [course_session_entry]
result_persons[mentor_relation.agent.id] = person_data
else:

50
server/vbv_lernwelt/dashboard/views.py
View File

@ -24,7 +24,10 @@ from vbv_lernwelt.competence.services import (
query_competence_course_session_edoniq_tests,
)
from vbv_lernwelt.core.models import User
from vbv_lernwelt.course.models import CourseConfiguration, CourseSessionUser
from vbv_lernwelt.course.models import (
CourseConfiguration,
CourseSessionUser,
)
from vbv_lernwelt.course.views import logger
from vbv_lernwelt.course_session.services.export_attendance import (
ATTENDANCE_EXPORT_FILENAME,
@ -463,16 +466,43 @@ def export_feedback_as_xsl(request):
@api_view(["POST"])
def export_persons_as_xsl(request):
requested_course_session_ids = request.data.get("courseSessionIds", [])
course_sessions_with_roles = _get_permitted_courses_sessions_for_user(
request.user, requested_course_session_ids
) # noqa
data = export_persons(
request.user,
[cswr.id for cswr in course_sessions_with_roles],
)
requested_course_session_user_ids = request.data.get("courseSessionUserIds", [])
data = _export_persons_as_xls_data(request.user, requested_course_session_user_ids)
if data:
return _make_excel_response(data, PERSONS_EXPORT_FILENAME)
return Response(status=status.HTTP_400_BAD_REQUEST)
def _export_persons_as_xls_data(user: User, course_session_user_ids: List[str]):
permitted_course_session_users = _get_permitted_csus_for_user(
user, course_session_user_ids
)
return export_persons(permitted_course_session_users)
def _get_permitted_csus_for_user(
user: User, requested_coursesessionuser_ids: List[str]
) -> List[CourseSessionUser]:
# Premit course session users where user is agent (Berufsbildner, Lernbegleiter)
premitted_from_agent_participant_rel = CourseSessionUser.objects.filter(
id__in=requested_coursesessionuser_ids,
agentparticipantrelation__agent=user,
)
# Premit course session users where user has a certain role in the user's course session
ALLOWED_ROLES = ["EXPERT", "SUPERVISOR"]
requested_course_session_ids = CourseSessionUser.objects.filter(
id__in=requested_coursesessionuser_ids
).values_list("course_session__id", flat=True)
permitted_course_sessions = _get_course_sessions_with_roles_for_user(
user, ALLOWED_ROLES, requested_course_session_ids
)
permitted_from_role = CourseSessionUser.objects.filter(
id__in=requested_coursesessionuser_ids,
course_session__in=[x.id for x in permitted_course_sessions],
)
return set(premitted_from_agent_participant_rel) | set(permitted_from_role)
def _get_permitted_courses_sessions_for_user(