tdpeuter/2025SELab2-project-Dwengo
tdpeuter/2025SELab2-project-Dwengo
Archived
1
Fork 0
Code Issues Releases 4 Packages 2 Wiki Activity

Merge branch 'dev' into feat/assignment-page

Browse source 
# Conflicts:
#	backend/package.json
#	common/src/interfaces/assignment.ts
#	frontend/src/controllers/learning-paths.ts
#	frontend/src/i18n/locale/de.json
#	frontend/src/i18n/locale/en.json
#	frontend/src/i18n/locale/fr.json
#	frontend/src/i18n/locale/nl.json
#	frontend/src/views/assignments/CreateAssignment.vue
#	package-lock.json
This commit is contained in:
Joyelle Ndagijimana 2025-04-19 16:58:08 +02:00
commit a421b1996a
123 changed files with 2428 additions and 2658 deletions
Download patch file Download diff file Expand all files Collapse all files

4
frontend/src/queries/groups.ts
View file

@ -10,7 +10,7 @@ import {
useQueryClient,
type UseQueryReturnType,
} from "@tanstack/vue-query";
import { computed, type MaybeRefOrGetter, toValue } from "vue";
import { computed, toValue, type MaybeRefOrGetter } from "vue";
import { invalidateAllSubmissionKeys } from "./submissions";
type GroupsQueryKey = ["groups", string, number, boolean];
@ -160,7 +160,7 @@ export function useDeleteGroupMutation(): UseMutationReturnType<
const gn = response.group.groupNumber;
await invalidateAllGroupKeys(queryClient, cid, an, gn);
await invalidateAllSubmissionKeys(queryClient, cid, an, gn);
await invalidateAllSubmissionKeys(queryClient, undefined, undefined, undefined, cid, an, gn);
},
});
}

2
frontend/src/queries/learning-objects.ts
View file

@ -5,7 +5,7 @@ import { getLearningObjectController } from "@/controllers/controllers.ts";
import type { LearningObject } from "@/data-objects/learning-objects/learning-object.ts";
import type { LearningPath } from "@/data-objects/learning-paths/learning-path.ts";
const LEARNING_OBJECT_KEY = "learningObject";
export const LEARNING_OBJECT_KEY = "learningObject";
const learningObjectController = getLearningObjectController();
export function useLearningObjectMetadataQuery(

16
frontend/src/queries/learning-paths.ts
View file

@ -4,19 +4,19 @@ import {useQuery, type UseQueryReturnType} from "@tanstack/vue-query";
import {getLearningPathController} from "@/controllers/controllers";
import type {LearningPath} from "@/data-objects/learning-paths/learning-path.ts";
const LEARNING_PATH_KEY = "learningPath";
export const LEARNING_PATH_KEY = "learningPath";
const learningPathController = getLearningPathController();
export function useGetLearningPathQuery(
hruid: MaybeRefOrGetter<string>,
language: MaybeRefOrGetter<Language>,
options?: MaybeRefOrGetter<{ forGroup?: string; forStudent?: string }>,
forGroup?: MaybeRefOrGetter<{ forGroup: number; assignmentNo: number; classId: string } | undefined>,
): UseQueryReturnType<LearningPath, Error> {
return useQuery({
queryKey: [LEARNING_PATH_KEY, "get", hruid, language, options],
queryKey: [LEARNING_PATH_KEY, "get", hruid, language, forGroup],
queryFn: async () => {
const [hruidVal, languageVal, optionsVal] = [toValue(hruid), toValue(language), toValue(options)];
return learningPathController.getBy(hruidVal, languageVal, optionsVal);
const [hruidVal, languageVal, forGroupVal] = [toValue(hruid), toValue(language), toValue(forGroup)];
return learningPathController.getBy(hruidVal, languageVal, forGroupVal);
},
enabled: () => Boolean(toValue(hruid)) && Boolean(toValue(language)),
});
@ -34,12 +34,14 @@ export function useGetAllLearningPathsByThemeQuery(
export function useSearchLearningPathQuery(
query: MaybeRefOrGetter<string | undefined>,
language: MaybeRefOrGetter<string | undefined>,
): UseQueryReturnType<LearningPath[], Error> {
return useQuery({
queryKey: [LEARNING_PATH_KEY, "search", query],
queryKey: [LEARNING_PATH_KEY, "search", query, language],
queryFn: async () => {
const queryVal = toValue(query)!;
return learningPathController.search(queryVal);
const languageVal = toValue(language)!;
return learningPathController.search(queryVal, languageVal);
},
enabled: () => Boolean(toValue(query)),
});

186
frontend/src/queries/submissions.ts
View file

@ -1,39 +1,39 @@
import { SubmissionController, type SubmissionResponse, type SubmissionsResponse } from "@/controllers/submissions";
import { SubmissionController, type SubmissionResponse } from "@/controllers/submissions";
import type { SubmissionDTO } from "@dwengo-1/common/interfaces/submission";
import {
QueryClient,
useMutation,
type UseMutationReturnType,
useQuery,
useQueryClient,
type UseMutationReturnType,
type UseQueryReturnType,
} from "@tanstack/vue-query";
import { computed, toValue, type MaybeRefOrGetter } from "vue";
import { computed, type MaybeRefOrGetter, toValue } from "vue";
import { LEARNING_PATH_KEY } from "@/queries/learning-paths.ts";
import { LEARNING_OBJECT_KEY } from "@/queries/learning-objects.ts";
import type { Language } from "@dwengo-1/common/util/language";
type SubmissionsQueryKey = ["submissions", string, number, number, boolean];
export const SUBMISSION_KEY = "submissions";
function submissionsQueryKey(
classid: string,
assignmentNumber: number,
groupNumber: number,
full: boolean,
): SubmissionsQueryKey {
return ["submissions", classid, assignmentNumber, groupNumber, full];
}
type SubmissionQueryKey = ["submission", string, number, number, number];
type SubmissionQueryKey = ["submission", string, Language | undefined, number, string, number, number, number];
function submissionQueryKey(
hruid: string,
language: Language,
version: number,
classid: string,
assignmentNumber: number,
groupNumber: number,
submissionNumber: number,
): SubmissionQueryKey {
return ["submission", classid, assignmentNumber, groupNumber, submissionNumber];
return ["submission", hruid, language, version, classid, assignmentNumber, groupNumber, submissionNumber];
}
export async function invalidateAllSubmissionKeys(
queryClient: QueryClient,
hruid?: string,
language?: Language,
version?: number,
classid?: string,
assignmentNumber?: number,
groupNumber?: number,
@ -43,101 +43,134 @@ export async function invalidateAllSubmissionKeys(
await Promise.all(
keys.map(async (key) => {
const queryKey = [key, classid, assignmentNumber, groupNumber, submissionNumber].filter(
(arg) => arg !== undefined,
);
const queryKey = [
key,
hruid,
language,
version,
classid,
assignmentNumber,
groupNumber,
submissionNumber,
].filter((arg) => arg !== undefined);
return queryClient.invalidateQueries({ queryKey: queryKey });
}),
);
await queryClient.invalidateQueries({
queryKey: ["submissions", classid, assignmentNumber, groupNumber].filter((arg) => arg !== undefined),
queryKey: ["submissions", hruid, language, version, classid, assignmentNumber, groupNumber].filter(
(arg) => arg !== undefined,
),
});
await queryClient.invalidateQueries({
queryKey: ["group-submissions", classid, assignmentNumber, groupNumber].filter((arg) => arg !== undefined),
queryKey: ["group-submissions", hruid, language, version, classid, assignmentNumber, groupNumber].filter(
(arg) => arg !== undefined,
),
});
await queryClient.invalidateQueries({
queryKey: ["assignment-submissions", classid, assignmentNumber].filter((arg) => arg !== undefined),
queryKey: ["assignment-submissions", hruid, language, version, classid, assignmentNumber].filter(
(arg) => arg !== undefined,
),
});
}
function checkEnabled(
classid: string | undefined,
assignmentNumber: number | undefined,
groupNumber: number | undefined,
submissionNumber: number | undefined,
): boolean {
return (
Boolean(classid) &&
!isNaN(Number(groupNumber)) &&
!isNaN(Number(assignmentNumber)) &&
!isNaN(Number(submissionNumber))
);
}
interface Values {
cid: string | undefined;
an: number | undefined;
gn: number | undefined;
sn: number | undefined;
f: boolean;
}
function toValues(
classid: MaybeRefOrGetter<string | undefined>,
assignmentNumber: MaybeRefOrGetter<number | undefined>,
groupNumber: MaybeRefOrGetter<number | undefined>,
submissionNumber: MaybeRefOrGetter<number | undefined>,
full: MaybeRefOrGetter<boolean>,
): Values {
return {
cid: toValue(classid),
an: toValue(assignmentNumber),
gn: toValue(groupNumber),
sn: toValue(submissionNumber),
f: toValue(full),
};
function checkEnabled(properties: MaybeRefOrGetter<unknown>[]): boolean {
return properties.every((prop) => Boolean(toValue(prop)));
}
export function useSubmissionsQuery(
hruid: MaybeRefOrGetter<string | undefined>,
language: MaybeRefOrGetter<Language | undefined>,
version: MaybeRefOrGetter<number | undefined>,
classid: MaybeRefOrGetter<string | undefined>,
assignmentNumber: MaybeRefOrGetter<number | undefined>,
groupNumber: MaybeRefOrGetter<number | undefined>,
full: MaybeRefOrGetter<boolean> = true,
): UseQueryReturnType<SubmissionsResponse, Error> {
const { cid, an, gn, sn, f } = toValues(classid, assignmentNumber, groupNumber, 1, full);
): UseQueryReturnType<SubmissionDTO[], Error> {
return useQuery({
queryKey: computed(() => submissionsQueryKey(cid!, an!, gn!, f)),
queryFn: async () => new SubmissionController(cid!, an!, gn!).getAll(f),
enabled: () => checkEnabled(cid, an, gn, sn),
queryKey: ["submissions", hruid, language, version, classid, assignmentNumber, groupNumber, full],
queryFn: async () => {
const hruidVal = toValue(hruid);
const languageVal = toValue(language);
const versionVal = toValue(version);
const classIdVal = toValue(classid);
const assignmentNumberVal = toValue(assignmentNumber);
const groupNumberVal = toValue(groupNumber);
const fullVal = toValue(full);
const response = await new SubmissionController(hruidVal!).getAll(
languageVal,
versionVal!,
classIdVal!,
assignmentNumberVal!,
groupNumberVal,
fullVal,
);
return response ? (response.submissions as SubmissionDTO[]) : undefined;
},
enabled: () => checkEnabled([hruid, language, version, classid, assignmentNumber]),
});
}
export function useSubmissionQuery(
hruid: MaybeRefOrGetter<string | undefined>,
language: MaybeRefOrGetter<Language | undefined>,
version: MaybeRefOrGetter<number | undefined>,
classid: MaybeRefOrGetter<string | undefined>,
assignmentNumber: MaybeRefOrGetter<number | undefined>,
groupNumber: MaybeRefOrGetter<number | undefined>,
submissionNumber: MaybeRefOrGetter<number | undefined>,
): UseQueryReturnType<SubmissionResponse, Error> {
const { cid, an, gn, sn } = toValues(classid, assignmentNumber, groupNumber, 1, true);
const hruidVal = toValue(hruid);
const languageVal = toValue(language);
const versionVal = toValue(version);
const classIdVal = toValue(classid);
const assignmentNumberVal = toValue(assignmentNumber);
const groupNumberVal = toValue(groupNumber);
const submissionNumberVal = toValue(submissionNumber);
return useQuery({
queryKey: computed(() => submissionQueryKey(cid!, an!, gn!, sn!)),
queryFn: async () => new SubmissionController(cid!, an!, gn!).getByNumber(sn!),
enabled: () => checkEnabled(cid, an, gn, sn),
queryKey: computed(() =>
submissionQueryKey(
hruidVal!,
languageVal,
versionVal!,
classIdVal!,
assignmentNumberVal!,
groupNumberVal!,
submissionNumberVal!,
),
),
queryFn: async () =>
new SubmissionController(hruidVal!).getByNumber(
languageVal,
versionVal!,
classIdVal!,
assignmentNumberVal!,
groupNumberVal!,
submissionNumberVal!,
),
enabled: () =>
Boolean(hruidVal) &&
Boolean(languageVal) &&
Boolean(versionVal) &&
Boolean(classIdVal) &&
Boolean(assignmentNumberVal) &&
Boolean(submissionNumber),
});
}
export function useCreateSubmissionMutation(): UseMutationReturnType<
SubmissionResponse,
Error,
{ cid: string; an: number; gn: number; data: SubmissionDTO },
{ data: SubmissionDTO },
unknown
> {
const queryClient = useQueryClient();
return useMutation({
mutationFn: async ({ cid, an, gn, data }) => new SubmissionController(cid, an, gn).createSubmission(data),
mutationFn: async ({ data }) =>
new SubmissionController(data.learningObjectIdentifier.hruid).createSubmission(data),
onSuccess: async (response) => {
if (!response.submission.group) {
await invalidateAllSubmissionKeys(queryClient);
@ -149,7 +182,14 @@ export function useCreateSubmissionMutation(): UseMutationReturnType<
const an = typeof assignment === "number" ? assignment : assignment.id;
const gn = response.submission.group.groupNumber;
await invalidateAllSubmissionKeys(queryClient, cid, an, gn);
const { hruid, language, version } = response.submission.learningObjectIdentifier;
await invalidateAllSubmissionKeys(queryClient, hruid, language, version, cid, an, gn);
await queryClient.invalidateQueries({ queryKey: [LEARNING_PATH_KEY, "get"] });
await queryClient.invalidateQueries({
queryKey: [LEARNING_OBJECT_KEY, "metadata", hruid, language, version],
});
}
},
});
@ -164,7 +204,7 @@ export function useDeleteSubmissionMutation(): UseMutationReturnType<
const queryClient = useQueryClient();
return useMutation({
mutationFn: async ({ cid, an, gn, sn }) => new SubmissionController(cid, an, gn).deleteSubmission(sn),
mutationFn: async ({ cid, sn }) => new SubmissionController(cid).deleteSubmission(sn),
onSuccess: async (response) => {
if (!response.submission.group) {
await invalidateAllSubmissionKeys(queryClient);
@ -176,7 +216,9 @@ export function useDeleteSubmissionMutation(): UseMutationReturnType<
const an = typeof assignment === "number" ? assignment : assignment.id;
const gn = response.submission.group.groupNumber;
await invalidateAllSubmissionKeys(queryClient, cid, an, gn);
const { hruid, language, version } = response.submission.learningObjectIdentifier;
await invalidateAllSubmissionKeys(queryClient, hruid, language, version, cid, an, gn);
}
},
});