From 4a7148c835abdde44160d32399c8240d2e75fb4d Mon Sep 17 00:00:00 2001
From: EwoutV <ewoutverlinde@hotmail.com>
Date: Thu, 23 May 2024 09:58:00 +0200
Subject: [PATCH] fix: project service

---
 .../src/composables/services/admin.service.ts | 24 +++---
 .../composables/services/assistant.service.ts | 48 ++++++------
 .../composables/services/course.service.ts    | 76 +++++++++----------
 .../composables/services/docker.service.ts    | 36 ++++-----
 .../services/extra_checks.service.ts          | 24 +++---
 .../composables/services/faculty.service.ts   | 24 +++---
 .../src/composables/services/group.service.ts | 30 ++++----
 frontend/src/composables/services/helpers.ts  | 32 ++++----
 .../composables/services/project.service.ts   | 64 ++++++++--------
 .../services/structure_check.service.ts       | 30 ++++----
 .../composables/services/student.service.ts   | 60 +++++++--------
 .../services/submission.service.ts            | 30 ++++----
 .../services/submission_status.service.ts     |  6 +-
 .../composables/services/teacher.service.ts   | 48 ++++++------
 .../src/composables/services/users.service.ts | 30 ++++----
 15 files changed, 282 insertions(+), 280 deletions(-)

diff --git a/frontend/src/composables/services/admin.service.ts b/frontend/src/composables/services/admin.service.ts
index a1fb1c50..5b576414 100644
--- a/frontend/src/composables/services/admin.service.ts
+++ b/frontend/src/composables/services/admin.service.ts
@@ -6,27 +6,27 @@ import { User } from '@/types/users/User.ts';
 interface AdminState {
     admins: Ref<User[] | null>;
     admin: Ref<User | null>;
-    getAdminByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getAdmins: (selfprocessError?: boolean) => Promise<void>;
-    createAdmin: (adminData: User, selfprocessError?: boolean) => Promise<void>;
-    deleteAdmin: (id: string, selfprocessError?: boolean) => Promise<void>;
+    getAdminByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getAdmins: (selfProcessError?: boolean) => Promise<void>;
+    createAdmin: (adminData: User, selfProcessError?: boolean) => Promise<void>;
+    deleteAdmin: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useAdmin(): AdminState {
     const admins = ref<User[] | null>(null);
     const admin = ref<User | null>(null);
 
-    async function getAdminByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getAdminByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.retrieve.replace('{id}', id);
-        await get<User>(endpoint, admin, User.fromJSON, selfprocessError);
+        await get<User>(endpoint, admin, User.fromJSON, selfProcessError);
     }
 
-    async function getAdmins(selfprocessError: boolean = true): Promise<void> {
+    async function getAdmins(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.index;
-        await getList<User>(endpoint, admins, User.fromJSON, selfprocessError);
+        await getList<User>(endpoint, admins, User.fromJSON, selfProcessError);
     }
 
-    async function createAdmin(user: User, selfprocessError: boolean = true): Promise<void> {
+    async function createAdmin(user: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.index;
         await createToast<User>(
             'admin',
@@ -37,13 +37,13 @@ export function useAdmin(): AdminState {
             admin,
             User.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteAdmin(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteAdmin(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.admins.retrieve.replace('{id}', id);
-        await deleteId<User>(endpoint, admin, User.fromJSON, selfprocessError);
+        await deleteId<User>(endpoint, admin, User.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/assistant.service.ts b/frontend/src/composables/services/assistant.service.ts
index 7239469b..c2e5eff3 100644
--- a/frontend/src/composables/services/assistant.service.ts
+++ b/frontend/src/composables/services/assistant.service.ts
@@ -20,14 +20,14 @@ interface AssistantState {
     assistant: Ref<Assistant | null>;
     response: Ref<Response | null>;
     assistantPagination: Ref<PaginatorResponse<Assistant> | null>;
-    getAssistantByID: (id: string, init?: boolean, selfprocessError?: boolean) => Promise<void>;
-    getAssistantsByCourse: (courseId: string, selfprocessError?: boolean) => Promise<void>;
-    getAssistants: (selfprocessError?: boolean) => Promise<void>;
-    searchAssistants: (filters: Filter, page: number, pageSize: number, selfprocessError?: boolean) => Promise<void>;
-    assistantJoinCourse: (courseId: string, assistantId: string, selfprocessError?: boolean) => Promise<void>;
-    assistantLeaveCourse: (courseId: string, assistantId: string, selfprocessError?: boolean) => Promise<void>;
-    createAssistant: (assistantData: Assistant, selfprocessError?: boolean) => Promise<void>;
-    deleteAssistant: (id: string, selfprocessError?: boolean) => Promise<void>;
+    getAssistantByID: (id: string, init?: boolean, selfProcessError?: boolean) => Promise<void>;
+    getAssistantsByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getAssistants: (selfProcessError?: boolean) => Promise<void>;
+    searchAssistants: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    assistantJoinCourse: (courseId: string, assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    assistantLeaveCourse: (courseId: string, assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    createAssistant: (assistantData: Assistant, selfProcessError?: boolean) => Promise<void>;
+    deleteAssistant: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useAssistant(): AssistantState {
@@ -37,26 +37,26 @@ export function useAssistant(): AssistantState {
     const response = ref<Response | null>(null);
     const assistantPagination = ref<PaginatorResponse<Assistant> | null>(null);
 
-    async function getAssistantByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getAssistantByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.retrieve.replace('{id}', id);
-        await get<Assistant>(endpoint, assistant, Assistant.fromJSON, selfprocessError);
+        await get<Assistant>(endpoint, assistant, Assistant.fromJSON, selfProcessError);
     }
 
-    async function getAssistantsByCourse(courseId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getAssistantsByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.byCourse.replace('{courseId}', courseId);
-        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON, selfprocessError);
+        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON, selfProcessError);
     }
 
-    async function getAssistants(selfprocessError: boolean = true): Promise<void> {
+    async function getAssistants(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.index;
-        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON, selfprocessError);
+        await getList<Assistant>(endpoint, assistants, Assistant.fromJSON, selfProcessError);
     }
 
     async function searchAssistants(
         filters: Filter,
         page: number,
         pageSize: number,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.assistants.search;
         await getPaginatedList<Assistant>(
@@ -66,14 +66,14 @@ export function useAssistant(): AssistantState {
             pageSize,
             assistantPagination,
             Assistant.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function assistantJoinCourse(
         courseId: string,
         assistantId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.assistants.byCourse.replace('{courseId}', courseId);
         await create<Response>(
@@ -82,14 +82,14 @@ export function useAssistant(): AssistantState {
             response,
             Response.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function assistantLeaveCourse(
         courseId: string,
         assistantId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.assistants.byCourse.replace('{courseId}', courseId);
         await deleteIdWithData<Response>(
@@ -97,11 +97,11 @@ export function useAssistant(): AssistantState {
             { assistant: assistantId },
             response,
             Response.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function createAssistant(user: User, selfprocessError: boolean = true): Promise<void> {
+    async function createAssistant(user: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.index;
         await createToast<Assistant>(
             'assistant',
@@ -112,13 +112,13 @@ export function useAssistant(): AssistantState {
             assistant,
             Assistant.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteAssistant(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteAssistant(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.assistants.retrieve.replace('{id}', id);
-        await deleteId<Assistant>(endpoint, assistant, Assistant.fromJSON, selfprocessError);
+        await deleteId<Assistant>(endpoint, assistant, Assistant.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/course.service.ts b/frontend/src/composables/services/course.service.ts
index 9e45620a..89c99247 100644
--- a/frontend/src/composables/services/course.service.ts
+++ b/frontend/src/composables/services/course.service.ts
@@ -14,23 +14,23 @@ interface CoursesState {
     courses: Ref<Course[] | null>;
     course: Ref<Course | null>;
 
-    getCourseByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getCourses: (selfprocessError?: boolean) => Promise<void>;
-    searchCourses: (filters: Filter, page: number, pageSize: number, selfprocessError?: boolean) => Promise<void>;
-    getCoursesByStudent: (studentId: string, selfprocessError?: boolean) => Promise<void>;
-    getCoursesByTeacher: (teacherId: string, selfprocessError?: boolean) => Promise<void>;
-    getCourseByAssistant: (assistantId: string, selfprocessError?: boolean) => Promise<void>;
-    getCoursesByUser: (user: User, selfprocessError?: boolean) => Promise<void>;
-    createCourse: (courseData: Course, selfprocessError?: boolean) => Promise<void>;
-    updateCourse: (courseData: Course, selfprocessError?: boolean) => Promise<void>;
+    getCourseByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getCourses: (selfProcessError?: boolean) => Promise<void>;
+    searchCourses: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    getCoursesByStudent: (studentId: string, selfProcessError?: boolean) => Promise<void>;
+    getCoursesByTeacher: (teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    getCourseByAssistant: (assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    getCoursesByUser: (user: User, selfProcessError?: boolean) => Promise<void>;
+    createCourse: (courseData: Course, selfProcessError?: boolean) => Promise<void>;
+    updateCourse: (courseData: Course, selfProcessError?: boolean) => Promise<void>;
     cloneCourse: (
         courseId: string,
         cloneAssistants: boolean,
         cloneTeachers: boolean,
-        selfprocessError?: boolean,
+        selfProcessError?: boolean,
     ) => Promise<void>;
-    activateInvitationLink: (courseId: string, linkDuration: number, selfprocessError?: boolean) => Promise<void>;
-    deleteCourse: (id: string, selfprocessError?: boolean) => Promise<void>;
+    activateInvitationLink: (courseId: string, linkDuration: number, selfProcessError?: boolean) => Promise<void>;
+    deleteCourse: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useCourses(): CoursesState {
@@ -39,21 +39,21 @@ export function useCourses(): CoursesState {
     const course = ref<Course | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getCourseByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getCourseByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.retrieve.replace('{id}', id);
-        await get<Course>(endpoint, course, Course.fromJSON, selfprocessError);
+        await get<Course>(endpoint, course, Course.fromJSON, selfProcessError);
     }
 
-    async function getCourses(selfprocessError: boolean = true): Promise<void> {
+    async function getCourses(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.index;
-        await getList<Course>(endpoint, courses, Course.fromJSON, selfprocessError);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
     async function searchCourses(
         filters: Filter,
         page: number,
         pageSize: number,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.courses.search;
         await getPaginatedList<Course>(
@@ -63,38 +63,38 @@ export function useCourses(): CoursesState {
             pageSize,
             pagination,
             Course.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function getCoursesByStudent(studentId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getCoursesByStudent(studentId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.byStudent.replace('{studentId}', studentId);
-        await getList<Course>(endpoint, courses, Course.fromJSON, selfprocessError);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
-    async function getCoursesByTeacher(teacherId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getCoursesByTeacher(teacherId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.byTeacher.replace('{teacherId}', teacherId);
-        await getList<Course>(endpoint, courses, Course.fromJSON, selfprocessError);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
-    async function getCourseByAssistant(assistantId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getCourseByAssistant(assistantId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.byAssistant.replace('{assistantId}', assistantId);
-        await getList<Course>(endpoint, courses, Course.fromJSON, selfprocessError);
+        await getList<Course>(endpoint, courses, Course.fromJSON, selfProcessError);
     }
 
-    async function getCoursesByUser(user: User, selfprocessError: boolean = true): Promise<void> {
+    async function getCoursesByUser(user: User, selfProcessError: boolean = true): Promise<void> {
         if (user.isTeacher()) {
-            await getCoursesByTeacher(user.id, selfprocessError);
+            await getCoursesByTeacher(user.id, selfProcessError);
         } else if (user.isAssistant()) {
-            await getCourseByAssistant(user.id, selfprocessError);
+            await getCourseByAssistant(user.id, selfProcessError);
         } else if (user.isStudent()) {
-            await getCoursesByStudent(user.id, selfprocessError);
+            await getCoursesByStudent(user.id, selfProcessError);
         } else {
             courses.value = [];
         }
     }
 
-    async function createCourse(courseData: Course, selfprocessError: boolean = true): Promise<void> {
+    async function createCourse(courseData: Course, selfProcessError: boolean = true): Promise<void> {
         const { t } = i18n.global;
         const { addSuccessMessage } = useMessagesStore();
         const endpoint = endpoints.courses.index;
@@ -112,7 +112,7 @@ export function useCourses(): CoursesState {
             course,
             Course.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
         addSuccessMessage(
             t('toasts.messages.success'),
@@ -120,7 +120,7 @@ export function useCourses(): CoursesState {
         );
     }
 
-    async function updateCourse(courseData: Course, selfprocessError: boolean = true): Promise<void> {
+    async function updateCourse(courseData: Course, selfProcessError: boolean = true): Promise<void> {
         // Endpoint to update is same as retrieve
         const endpoint = endpoints.courses.retrieve.replace('{id}', courseData.id);
 
@@ -136,7 +136,7 @@ export function useCourses(): CoursesState {
             },
             response,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
@@ -144,7 +144,7 @@ export function useCourses(): CoursesState {
         courseId: string,
         cloneAssistants: boolean,
         cloneTeachers: boolean,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.courses.clone.replace('{courseId}', courseId);
         await create<Course>(
@@ -156,19 +156,19 @@ export function useCourses(): CoursesState {
             course,
             Course.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteCourse(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteCourse(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.courses.retrieve.replace('{id}', id);
-        await deleteId<Course>(endpoint, course, Course.fromJSON, selfprocessError);
+        await deleteId<Course>(endpoint, course, Course.fromJSON, selfProcessError);
     }
 
     async function activateInvitationLink(
         courseId: string,
         linkDuration: number,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.courses.invitationLink.replace('{courseId}', courseId);
         await patch(
@@ -178,7 +178,7 @@ export function useCourses(): CoursesState {
             },
             response,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
diff --git a/frontend/src/composables/services/docker.service.ts b/frontend/src/composables/services/docker.service.ts
index 2034cf72..6ed450f2 100644
--- a/frontend/src/composables/services/docker.service.ts
+++ b/frontend/src/composables/services/docker.service.ts
@@ -17,12 +17,12 @@ interface DockerImagesState {
     pagination: Ref<PaginatorResponse<DockerImage> | null>;
     dockerImages: Ref<DockerImage[] | null>;
     response: Ref<Response | null>;
-    getDockerImages: (selfprocessError?: boolean) => Promise<void>;
-    searchDockerImages: (filters: Filter, page: number, pageSize: number, selfprocessError?: boolean) => Promise<void>;
-    patchDockerImage: (dockerData: DockerImage, selfprocessError?: boolean) => Promise<void>;
-    createDockerImage: (dockerData: DockerImage, file: File, selfprocessError?: boolean) => Promise<void>;
-    deleteDockerImage: (id: string, selfprocessError?: boolean) => Promise<void>;
-    deleteDockerImages: (ids: string[], selfprocessError?: boolean) => Promise<void>;
+    getDockerImages: (selfProcessError?: boolean) => Promise<void>;
+    searchDockerImages: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    patchDockerImage: (dockerData: DockerImage, selfProcessError?: boolean) => Promise<void>;
+    createDockerImage: (dockerData: DockerImage, file: File, selfProcessError?: boolean) => Promise<void>;
+    deleteDockerImage: (id: string, selfProcessError?: boolean) => Promise<void>;
+    deleteDockerImages: (ids: string[], selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useDockerImages(): DockerImagesState {
@@ -30,16 +30,16 @@ export function useDockerImages(): DockerImagesState {
     const dockerImages = ref<DockerImage[] | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getDockerImages(selfprocessError: boolean = true): Promise<void> {
+    async function getDockerImages(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.index;
-        await getList<DockerImage>(endpoint, dockerImages, DockerImage.fromJSON, selfprocessError);
+        await getList<DockerImage>(endpoint, dockerImages, DockerImage.fromJSON, selfProcessError);
     }
 
     async function searchDockerImages(
         filters: Filter,
         page: number,
         pageSize: number,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.dockerImages.search;
         await getPaginatedList<DockerImage>(
@@ -49,19 +49,19 @@ export function useDockerImages(): DockerImagesState {
             pageSize,
             pagination,
             DockerImage.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function patchDockerImage(dockerData: DockerImage, selfprocessError: boolean = true): Promise<void> {
+    async function patchDockerImage(dockerData: DockerImage, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.patch.replace('{id}', dockerData.id);
-        await patch(endpoint, { public: dockerData.public }, response, undefined, selfprocessError);
+        await patch(endpoint, { public: dockerData.public }, response, undefined, selfProcessError);
     }
 
     async function createDockerImage(
         dockerData: DockerImage,
         file: File,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.dockerImages.index;
         await createToast<Response>(
@@ -75,19 +75,19 @@ export function useDockerImages(): DockerImagesState {
             response,
             Response.fromJSON,
             'multipart/form-data',
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteDockerImage(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteDockerImage(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.retrieve.replace('{id}', id);
-        await deleteId<Response>(endpoint, response, Response.fromJSON, selfprocessError);
+        await deleteId<Response>(endpoint, response, Response.fromJSON, selfProcessError);
     }
 
-    async function deleteDockerImages(ids: string[], selfprocessError: boolean = true): Promise<void> {
+    async function deleteDockerImages(ids: string[], selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.dockerImages.deleteMany;
         const data = { ids };
-        await deleteIdWithData<Response>(endpoint, data, response, Response.fromJSON, selfprocessError);
+        await deleteIdWithData<Response>(endpoint, data, response, Response.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/extra_checks.service.ts b/frontend/src/composables/services/extra_checks.service.ts
index 39ef35d6..1e7a99f1 100644
--- a/frontend/src/composables/services/extra_checks.service.ts
+++ b/frontend/src/composables/services/extra_checks.service.ts
@@ -7,10 +7,10 @@ import { Response } from '@/types/Response';
 interface ExtraCheckState {
     extraCheck: Ref<ExtraCheck | null>;
     extraChecks: Ref<ExtraCheck[] | null>;
-    getExtraChecksByProject: (projectId: string, selfprocessError?: boolean) => Promise<void>;
-    addExtraCheck: (extraCheckData: ExtraCheck, projectId: string, selfprocessError?: boolean) => Promise<void>;
-    setExtraChecks: (extraChecks: ExtraCheck[], projectId: string, selfprocessError?: boolean) => Promise<void>;
-    deleteExtraCheck: (extraCheckId: string, selfprocessError?: boolean) => Promise<void>;
+    getExtraChecksByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    addExtraCheck: (extraCheckData: ExtraCheck, projectId: string, selfProcessError?: boolean) => Promise<void>;
+    setExtraChecks: (extraChecks: ExtraCheck[], projectId: string, selfProcessError?: boolean) => Promise<void>;
+    deleteExtraCheck: (extraCheckId: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useExtraCheck(): ExtraCheckState {
@@ -18,15 +18,15 @@ export function useExtraCheck(): ExtraCheckState {
     const extraChecks = ref<ExtraCheck[] | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getExtraChecksByProject(projectId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getExtraChecksByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.extraChecks.byProject.replace('{projectId}', projectId);
-        await getList<ExtraCheck>(endpoint, extraChecks, ExtraCheck.fromJSON, selfprocessError);
+        await getList<ExtraCheck>(endpoint, extraChecks, ExtraCheck.fromJSON, selfProcessError);
     }
 
     async function addExtraCheck(
         extraCheckData: ExtraCheck,
         projectId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.extraChecks.byProject.replace('{projectId}', projectId);
         await create<ExtraCheck>(
@@ -42,25 +42,25 @@ export function useExtraCheck(): ExtraCheckState {
             extraCheck,
             ExtraCheck.fromJSON,
             'multipart/form-data',
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function setExtraChecks(
         extraChecks: ExtraCheck[],
         projectId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         for (const extraCheck of extraChecks) {
             if (extraCheck.id === '') {
-                await addExtraCheck(extraCheck, projectId, selfprocessError);
+                await addExtraCheck(extraCheck, projectId, selfProcessError);
             }
         }
     }
 
-    async function deleteExtraCheck(extraCheckId: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteExtraCheck(extraCheckId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.extraChecks.retrieve.replace('{id}', extraCheckId);
-        await deleteId(endpoint, response, Response.fromJSON, selfprocessError);
+        await deleteId(endpoint, response, Response.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/faculty.service.ts b/frontend/src/composables/services/faculty.service.ts
index 0bfafa1d..6c2c31f4 100644
--- a/frontend/src/composables/services/faculty.service.ts
+++ b/frontend/src/composables/services/faculty.service.ts
@@ -6,27 +6,27 @@ import { get, getList, deleteId, createToast } from '@/composables/services/help
 interface FacultyState {
     faculties: Ref<Faculty[] | null>;
     faculty: Ref<Faculty | null>;
-    getFacultyByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getFaculties: (selfprocessError?: boolean) => Promise<void>;
-    createFaculty: (facultyData: Faculty, selfprocessError?: boolean) => Promise<void>;
-    deleteFaculty: (id: string, selfprocessError?: boolean) => Promise<void>;
+    getFacultyByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getFaculties: (selfProcessError?: boolean) => Promise<void>;
+    createFaculty: (facultyData: Faculty, selfProcessError?: boolean) => Promise<void>;
+    deleteFaculty: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useFaculty(): FacultyState {
     const faculties = ref<Faculty[] | null>(null);
     const faculty = ref<Faculty | null>(null);
 
-    async function getFacultyByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getFacultyByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.retrieve.replace('{id}', id);
-        await get<Faculty>(endpoint, faculty, Faculty.fromJSON, selfprocessError);
+        await get<Faculty>(endpoint, faculty, Faculty.fromJSON, selfProcessError);
     }
 
-    async function getFaculties(selfprocessError: boolean = true): Promise<void> {
+    async function getFaculties(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.index;
-        await getList<Faculty>(endpoint, faculties, Faculty.fromJSON, selfprocessError);
+        await getList<Faculty>(endpoint, faculties, Faculty.fromJSON, selfProcessError);
     }
 
-    async function createFaculty(facultyData: Faculty, selfprocessError: boolean = true): Promise<void> {
+    async function createFaculty(facultyData: Faculty, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.index;
         await createToast<Faculty>(
             'faculty',
@@ -35,13 +35,13 @@ export function useFaculty(): FacultyState {
             faculty,
             Faculty.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteFaculty(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteFaculty(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.faculties.retrieve.replace('{id}', id);
-        await deleteId<Faculty>(endpoint, faculty, Faculty.fromJSON, selfprocessError);
+        await deleteId<Faculty>(endpoint, faculty, Faculty.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/group.service.ts b/frontend/src/composables/services/group.service.ts
index ec748c04..a810d429 100644
--- a/frontend/src/composables/services/group.service.ts
+++ b/frontend/src/composables/services/group.service.ts
@@ -6,33 +6,33 @@ import { get, getList, create, deleteId } from '@/composables/services/helpers.t
 interface GroupState {
     groups: Ref<Group[] | null>;
     group: Ref<Group | null>;
-    getGroupByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getGroupsByProject: (projectId: string, selfprocessError?: boolean) => Promise<void>;
-    getGroupsByStudent: (studentId: string, selfprocessError?: boolean) => Promise<void>;
-    createGroup: (groupData: Group, projectId: string, selfprocessError?: boolean) => Promise<void>;
-    deleteGroup: (id: string, selfprocessError?: boolean) => Promise<void>;
+    getGroupByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getGroupsByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    getGroupsByStudent: (studentId: string, selfProcessError?: boolean) => Promise<void>;
+    createGroup: (groupData: Group, projectId: string, selfProcessError?: boolean) => Promise<void>;
+    deleteGroup: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useGroup(): GroupState {
     const groups = ref<Group[] | null>(null);
     const group = ref<Group | null>(null);
 
-    async function getGroupByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getGroupByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.retrieve.replace('{id}', id);
-        await get<Group>(endpoint, group, Group.fromJSON, selfprocessError);
+        await get<Group>(endpoint, group, Group.fromJSON, selfProcessError);
     }
 
-    async function getGroupsByProject(projectId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getGroupsByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.byProject.replace('{projectId}', projectId);
-        await getList<Group>(endpoint, groups, Group.fromJSON, selfprocessError);
+        await getList<Group>(endpoint, groups, Group.fromJSON, selfProcessError);
     }
 
-    async function getGroupsByStudent(studentId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getGroupsByStudent(studentId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.byStudent.replace('{studentId}', studentId);
-        await getList<Group>(endpoint, groups, Group.fromJSON, selfprocessError);
+        await getList<Group>(endpoint, groups, Group.fromJSON, selfProcessError);
     }
 
-    async function createGroup(groupData: Group, projectId: string, selfprocessError: boolean = true): Promise<void> {
+    async function createGroup(groupData: Group, projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.byProject.replace('{projectId}', projectId);
         await create<Group>(
             endpoint,
@@ -43,13 +43,13 @@ export function useGroup(): GroupState {
             group,
             Group.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteGroup(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteGroup(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.groups.retrieve.replace('{id}', id);
-        await deleteId<Group>(endpoint, group, Group.fromJSON, selfprocessError);
+        await deleteId<Group>(endpoint, group, Group.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/helpers.ts b/frontend/src/composables/services/helpers.ts
index e3a4a2ca..31f9d0f3 100644
--- a/frontend/src/composables/services/helpers.ts
+++ b/frontend/src/composables/services/helpers.ts
@@ -18,13 +18,13 @@ export async function get<T>(
     endpoint: string,
     ref: Ref<T | null>,
     fromJson: (data: any) => T,
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.get(endpoint);
         ref.value = fromJson(response.data);
     } catch (error: any) {
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
@@ -48,7 +48,7 @@ export async function create<T>(
     ref: Ref<T | null>,
     fromJson: (data: any) => T,
     contentType: string = 'application/json',
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.post(endpoint, data, {
@@ -58,7 +58,7 @@ export async function create<T>(
         });
         ref.value = fromJson(response.data);
     } catch (error: any) {
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
@@ -105,7 +105,7 @@ export async function patch(
     data: any,
     ref: Ref<Response | null>,
     contentType: string = 'application/json',
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response: AxiosResponse<Response, any> = await client.patch(endpoint, data, {
@@ -115,7 +115,7 @@ export async function patch(
         });
         ref.value = Response.fromJSON(response.data);
     } catch (error: any) {
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
@@ -135,7 +135,7 @@ export async function put<T>(
     endpoint: string,
     data: T | string,
     contentType: string = 'application/json',
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         await client.put(endpoint, data, {
@@ -144,7 +144,7 @@ export async function put<T>(
             },
         });
     } catch (error: any) {
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
@@ -164,13 +164,13 @@ export async function deleteId<T>(
     endpoint: string,
     ref: Ref<T | null>,
     fromJson: (data: any) => T,
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.delete(endpoint);
         ref.value = fromJson(response.data);
     } catch (error: any) {
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
@@ -192,13 +192,13 @@ export async function deleteIdWithData<T>(
     data: any,
     ref: Ref<T | null>,
     fromJson: (data: any) => T,
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.delete(endpoint, { data });
         ref.value = fromJson(response.data);
     } catch (error: any) {
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
@@ -218,14 +218,14 @@ export async function getList<T>(
     endpoint: string,
     ref: Ref<T[] | null>,
     fromJson: (data: any) => T,
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.get(endpoint);
         ref.value = response.data.map((data: T) => fromJson(data));
     } catch (error: any) {
         ref.value = []; // Set the ref to an empty array
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
@@ -251,7 +251,7 @@ export async function getPaginatedList<T>(
     pageSize: number,
     pagination: Ref<PaginatorResponse<T> | null>,
     fromJson: (data: any) => T,
-    selfprocessError: boolean = true,
+    selfProcessError: boolean = true,
 ): Promise<void> {
     try {
         const response = await client.get(endpoint, {
@@ -274,7 +274,7 @@ export async function getPaginatedList<T>(
             results: [],
         };
 
-        if (selfprocessError) {
+        if (selfProcessError) {
             processError(error);
             console.error(error); // Log the error for debugging
         } else {
diff --git a/frontend/src/composables/services/project.service.ts b/frontend/src/composables/services/project.service.ts
index d6664d17..97d8a81d 100644
--- a/frontend/src/composables/services/project.service.ts
+++ b/frontend/src/composables/services/project.service.ts
@@ -10,20 +10,20 @@ import { useMessagesStore } from '@/store/messages.store.ts';
 interface ProjectState {
     projects: Ref<Project[] | null>;
     project: Ref<Project | null>;
-    getProjectByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getProjectsByCourse: (courseId: string, selfprocessError?: boolean) => Promise<void>;
-    getProjectsByStudent: (studentId: string, selfprocessError?: boolean) => Promise<void>;
-    getProjectsByAssistant: (assistantId: string, selfprocessError?: boolean) => Promise<void>;
-    getProjectsByTeacher: (teacherId: string, selfprocessError?: boolean) => Promise<void>;
-    getProjectsByCourseAndDeadline: (courseId: string, deadlineDate: Date, selfprocessError?: boolean) => Promise<void>;
+    getProjectByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByStudent: (studentId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByAssistant: (assistantId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByTeacher: (teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    getProjectsByCourseAndDeadline: (courseId: string, deadlineDate: Date, selfProcessError?: boolean) => Promise<void>;
     createProject: (
         projectData: Project,
         courseId: string,
         numberOfGroups: number,
-        selfprocessError?: boolean,
+        selfProcessError?: boolean,
     ) => Promise<void>;
-    updateProject: (projectData: Project, selfprocessError?: boolean) => Promise<void>;
-    deleteProject: (id: string, selfprocessError?: boolean) => Promise<void>;
+    updateProject: (projectData: Project, selfProcessError?: boolean) => Promise<void>;
+    deleteProject: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useProject(): ProjectState {
@@ -31,48 +31,50 @@ export function useProject(): ProjectState {
     const project = ref<Project | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getProjectByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getProjectByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.retrieve.replace('{id}', id);
-        await get<Project>(endpoint, project, Project.fromJSON, selfprocessError);
+        await get<Project>(endpoint, project, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByCourse(courseId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getProjectsByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byCourse.replace('{courseId}', courseId);
-        await getList<Project>(endpoint, projects, Project.fromJSON, selfprocessError);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByStudent(studentId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getProjectsByStudent(studentId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byStudent.replace('{studentId}', studentId);
-        await getList<Project>(endpoint, projects, Project.fromJSON, selfprocessError);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByAssistant(assistantId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getProjectsByAssistant(assistantId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byAssistant.replace('{assistantId}', assistantId);
-        await getList<Project>(endpoint, projects, Project.fromJSON, selfprocessError);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
-    async function getProjectsByTeacher(teacherId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getProjectsByTeacher(teacherId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.byTeacher.replace('{teacherId}', teacherId);
-        await getList<Project>(endpoint, projects, Project.fromJSON, selfprocessError);
+        await getList<Project>(endpoint, projects, Project.fromJSON, selfProcessError);
     }
 
     async function getProjectsByCourseAndDeadline(
         courseId: string,
         deadlineDate: Date,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
-        await getProjectsByCourse(courseId, selfprocessError);
-        const allProjects = (projects.value ?? []).map((projectData: ProjectJSON) => Project.fromJSON(projectData));
-        projects.value = allProjects.filter((project: Project) => {
-            return project.deadline.toDateString() === deadlineDate.toDateString();
-        });
+        await getProjectsByCourse(courseId, selfProcessError);
+
+        if (projects.value !== null) {
+            projects.value = projects.value.filter((project: Project) => {
+                return project.deadline.toDateString() === deadlineDate.toDateString();
+            });
+        }
     }
 
     async function createProject(
         projectData: Project,
         courseId: string,
         numberOfGroups: number,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const { t } = i18n.global;
         const { addSuccessMessage } = useMessagesStore();
@@ -104,7 +106,7 @@ export function useProject(): ProjectState {
             project,
             Project.fromJSON,
             'multipart/form-data',
-            selfprocessError,
+            selfProcessError,
         );
         addSuccessMessage(
             t('toasts.messages.success'),
@@ -112,7 +114,7 @@ export function useProject(): ProjectState {
         );
     }
 
-    async function updateProject(projectData: Project, selfprocessError: boolean = true): Promise<void> {
+    async function updateProject(projectData: Project, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.retrieve.replace('{id}', projectData.id);
         await patch(
             endpoint,
@@ -130,13 +132,13 @@ export function useProject(): ProjectState {
             },
             response,
             'multipart/form-data',
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteProject(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteProject(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.projects.retrieve.replace('{id}', id);
-        await deleteId<Project>(endpoint, project, Project.fromJSON, selfprocessError);
+        await deleteId<Project>(endpoint, project, Project.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/structure_check.service.ts b/frontend/src/composables/services/structure_check.service.ts
index b50833a8..fa1df7fe 100644
--- a/frontend/src/composables/services/structure_check.service.ts
+++ b/frontend/src/composables/services/structure_check.service.ts
@@ -7,39 +7,39 @@ interface StructureCheckState {
     structureChecks: Ref<StructureCheck[] | null>;
     structureCheck: Ref<StructureCheck | null>;
 
-    getStructureCheckByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getStructureCheckByProject: (projectId: string, selfprocessError?: boolean) => Promise<void>;
+    getStructureCheckByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getStructureCheckByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
     createStructureCheck: (
         structureCheckData: StructureCheck,
         projectId: string,
-        selfprocessError?: boolean,
+        selfProcessError?: boolean,
     ) => Promise<void>;
     setStructureChecks: (
         structureChecks: StructureCheck[],
         projectId: string,
-        selfprocessError?: boolean,
+        selfProcessError?: boolean,
     ) => Promise<void>;
-    deleteStructureCheck: (id: string, selfprocessError?: boolean) => Promise<void>;
+    deleteStructureCheck: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useStructureCheck(): StructureCheckState {
     const structureChecks = ref<StructureCheck[] | null>(null);
     const structureCheck = ref<StructureCheck | null>(null);
 
-    async function getStructureCheckByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getStructureCheckByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.structureChecks.retrieve.replace('{id}', id);
-        await get<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON, selfprocessError);
+        await get<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON, selfProcessError);
     }
 
-    async function getStructureCheckByProject(projectId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getStructureCheckByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.structureChecks.byProject.replace('{projectId}', projectId);
-        await getList<StructureCheck>(endpoint, structureChecks, StructureCheck.fromJSON, selfprocessError);
+        await getList<StructureCheck>(endpoint, structureChecks, StructureCheck.fromJSON, selfProcessError);
     }
 
     async function createStructureCheck(
         structureCheckData: StructureCheck,
         projectId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.structureChecks.byProject.replace('{projectId}', projectId);
         await createToast<StructureCheck>(
@@ -51,22 +51,22 @@ export function useStructureCheck(): StructureCheckState {
             structureCheck,
             StructureCheck.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function setStructureChecks(
         structureChecks: StructureCheck[],
         projectId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.structureChecks.byProject.replace('{projectId}', projectId);
-        await put(endpoint, structureChecks, undefined, selfprocessError);
+        await put(endpoint, structureChecks, undefined, selfProcessError);
     }
 
-    async function deleteStructureCheck(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteStructureCheck(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.structureChecks.retrieve.replace('{id}', id);
-        await deleteId<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON, selfprocessError);
+        await deleteId<StructureCheck>(endpoint, structureCheck, StructureCheck.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/student.service.ts b/frontend/src/composables/services/student.service.ts
index 49b80ee0..f12cf6d6 100644
--- a/frontend/src/composables/services/student.service.ts
+++ b/frontend/src/composables/services/student.service.ts
@@ -8,16 +8,16 @@ interface StudentsState {
     students: Ref<Student[] | null>;
     student: Ref<Student | null>;
     response: Ref<Response | null>;
-    getStudentByID: (id: string, init?: boolean, selfprocessError?: boolean) => Promise<void>;
-    getStudents: (selfprocessError?: boolean) => Promise<void>;
-    getStudentsByCourse: (courseId: string, selfprocessError?: boolean) => Promise<void>;
-    getStudentsByGroup: (groupId: string, selfprocessError?: boolean) => Promise<void>;
-    createStudent: (studentData: Student, selfprocessError?: boolean) => Promise<void>;
-    deleteStudent: (id: string, selfprocessError?: boolean) => Promise<void>;
-    studentJoinCourse: (courseId: string, studentId: string, selfprocessError?: boolean) => Promise<void>;
-    studentLeaveCourse: (courseId: string, studentId: string, selfprocessError?: boolean) => Promise<void>;
-    studentJoinGroup: (groupId: string, studentId: string, selfprocessError?: boolean) => Promise<void>;
-    studentLeaveGroup: (groupId: string, studentId: string, selfprocessError?: boolean) => Promise<void>;
+    getStudentByID: (id: string, init?: boolean, selfProcessError?: boolean) => Promise<void>;
+    getStudents: (selfProcessError?: boolean) => Promise<void>;
+    getStudentsByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getStudentsByGroup: (groupId: string, selfProcessError?: boolean) => Promise<void>;
+    createStudent: (studentData: Student, selfProcessError?: boolean) => Promise<void>;
+    deleteStudent: (id: string, selfProcessError?: boolean) => Promise<void>;
+    studentJoinCourse: (courseId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
+    studentLeaveCourse: (courseId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
+    studentJoinGroup: (groupId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
+    studentLeaveGroup: (groupId: string, studentId: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useStudents(): StudentsState {
@@ -26,30 +26,30 @@ export function useStudents(): StudentsState {
     const student = ref<Student | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getStudentByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getStudentByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.retrieve.replace('{id}', id);
-        await get<Student>(endpoint, student, Student.fromJSON, selfprocessError);
+        await get<Student>(endpoint, student, Student.fromJSON, selfProcessError);
     }
 
-    async function getStudents(selfprocessError: boolean = true): Promise<void> {
+    async function getStudents(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.index;
-        await getList<Student>(endpoint, students, Student.fromJSON, selfprocessError);
+        await getList<Student>(endpoint, students, Student.fromJSON, selfProcessError);
     }
 
-    async function getStudentsByCourse(courseId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getStudentsByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.byCourse.replace('{courseId}', courseId);
-        await getList<Student>(endpoint, students, Student.fromJSON, selfprocessError);
+        await getList<Student>(endpoint, students, Student.fromJSON, selfProcessError);
     }
 
-    async function getStudentsByGroup(groupId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getStudentsByGroup(groupId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.byGroup.replace('{groupId}', groupId);
-        await getList<Student>(endpoint, students, Student.fromJSON, selfprocessError);
+        await getList<Student>(endpoint, students, Student.fromJSON, selfProcessError);
     }
 
     async function studentJoinCourse(
         courseId: string,
         studentId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.students.byCourse.replace('{courseId}', courseId);
         await create<Response>(
@@ -58,14 +58,14 @@ export function useStudents(): StudentsState {
             response,
             Response.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function studentLeaveCourse(
         courseId: string,
         studentId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.students.byCourse.replace('{courseId}', courseId);
         await deleteIdWithData<Response>(
@@ -73,14 +73,14 @@ export function useStudents(): StudentsState {
             { student: studentId },
             response,
             Response.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function studentJoinGroup(
         groupId: string,
         studentId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.students.byGroup.replace('{groupId}', groupId);
         await create<Response>(
@@ -89,14 +89,14 @@ export function useStudents(): StudentsState {
             response,
             Response.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function studentLeaveGroup(
         groupId: string,
         studentId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.students.byGroup.replace('{groupId}', groupId);
         await deleteIdWithData<Response>(
@@ -104,11 +104,11 @@ export function useStudents(): StudentsState {
             { student: studentId },
             response,
             Response.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function createStudent(studentData: Student, selfprocessError: boolean = true): Promise<void> {
+    async function createStudent(studentData: Student, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.index;
 
         await createToast<Student>(
@@ -121,13 +121,13 @@ export function useStudents(): StudentsState {
             student,
             Student.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteStudent(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteStudent(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.students.retrieve.replace('{id}', id);
-        await deleteId<Student>(endpoint, student, Student.fromJSON, selfprocessError);
+        await deleteId<Student>(endpoint, student, Student.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/submission.service.ts b/frontend/src/composables/services/submission.service.ts
index ae3dd779..2387d0a2 100644
--- a/frontend/src/composables/services/submission.service.ts
+++ b/frontend/src/composables/services/submission.service.ts
@@ -8,36 +8,36 @@ import { useMessagesStore } from '@/store/messages.store.ts';
 interface SubmissionState {
     submissions: Ref<Submission[] | null>;
     submission: Ref<Submission | null>;
-    getSubmissionByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getSubmissionByProject: (projectId: string, selfprocessError?: boolean) => Promise<void>;
-    getSubmissionByGroup: (groupId: string, selfprocessError?: boolean) => Promise<void>;
-    createSubmission: (submissionData: UnwrapRef<File[]>, groupId: string, selfprocessError?: boolean) => Promise<void>;
-    deleteSubmission: (id: string, selfprocessError?: boolean) => Promise<void>;
+    getSubmissionByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getSubmissionByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
+    getSubmissionByGroup: (groupId: string, selfProcessError?: boolean) => Promise<void>;
+    createSubmission: (submissionData: UnwrapRef<File[]>, groupId: string, selfProcessError?: boolean) => Promise<void>;
+    deleteSubmission: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useSubmission(): SubmissionState {
     const submissions = ref<Submission[] | null>(null);
     const submission = ref<Submission | null>(null);
 
-    async function getSubmissionByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getSubmissionByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.retrieve.replace('{id}', id);
-        await get<Submission>(endpoint, submission, Submission.fromJSON, selfprocessError);
+        await get<Submission>(endpoint, submission, Submission.fromJSON, selfProcessError);
     }
 
-    async function getSubmissionByProject(projectId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getSubmissionByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.byProject.replace('{projectId}', projectId);
-        await getList<Submission>(endpoint, submissions, Submission.fromJSON, selfprocessError);
+        await getList<Submission>(endpoint, submissions, Submission.fromJSON, selfProcessError);
     }
 
-    async function getSubmissionByGroup(groupId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getSubmissionByGroup(groupId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.byGroup.replace('{groupId}', groupId);
-        await getList<Submission>(endpoint, submissions, Submission.fromJSON, selfprocessError);
+        await getList<Submission>(endpoint, submissions, Submission.fromJSON, selfProcessError);
     }
 
     async function createSubmission(
         uploadedFiles: File[],
         groupId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const { t } = i18n.global;
         const { addSuccessMessage } = useMessagesStore();
@@ -48,13 +48,13 @@ export function useSubmission(): SubmissionState {
         uploadedFiles.forEach((file: File) => {
             formData.append('files', file); // Gebruik 'files' in plaats van 'files[]'
         });
-        await create(endpoint, formData, submission, Submission.fromJSON, 'multipart/form-data', selfprocessError);
+        await create(endpoint, formData, submission, Submission.fromJSON, 'multipart/form-data', selfProcessError);
         addSuccessMessage(t('toasts.messages.success'), t('toasts.messages.submissions.create.success'));
     }
 
-    async function deleteSubmission(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteSubmission(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.retrieve.replace('{id}', id);
-        await deleteId<Submission>(endpoint, submission, Submission.fromJSON, selfprocessError);
+        await deleteId<Submission>(endpoint, submission, Submission.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/submission_status.service.ts b/frontend/src/composables/services/submission_status.service.ts
index 5e9e2e84..e63cb176 100644
--- a/frontend/src/composables/services/submission_status.service.ts
+++ b/frontend/src/composables/services/submission_status.service.ts
@@ -5,15 +5,15 @@ import { SubmissionStatus } from '@/types/SubmisionStatus';
 
 interface SubmissionStatusState {
     submissionStatus: Ref<SubmissionStatus | null>;
-    getSubmissionStatusByProject: (projectId: string, selfprocessError?: boolean) => Promise<void>;
+    getSubmissionStatusByProject: (projectId: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useSubmissionStatus(): SubmissionStatusState {
     const submissionStatus = ref<SubmissionStatus | null>(null);
 
-    async function getSubmissionStatusByProject(projectId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getSubmissionStatusByProject(projectId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.submissions.status.replace('{projectId}', projectId);
-        await get<SubmissionStatus>(endpoint, submissionStatus, SubmissionStatus.fromJSON, selfprocessError);
+        await get<SubmissionStatus>(endpoint, submissionStatus, SubmissionStatus.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/teacher.service.ts b/frontend/src/composables/services/teacher.service.ts
index 66101d32..f25583c5 100644
--- a/frontend/src/composables/services/teacher.service.ts
+++ b/frontend/src/composables/services/teacher.service.ts
@@ -21,14 +21,14 @@ interface TeacherState {
     teacher: Ref<Teacher | null>;
     response: Ref<Response | null>;
     teacherPagination: Ref<PaginatorResponse<Teacher> | null>;
-    getTeacherByID: (id: string, init?: boolean, selfprocessError?: boolean) => Promise<void>;
-    getTeachersByCourse: (courseId: string, selfprocessError?: boolean) => Promise<void>;
-    getTeachers: (selfprocessError?: boolean) => Promise<void>;
-    searchTeachers: (filters: Filter, page: number, pageSize: number, selfprocessError?: boolean) => Promise<void>;
-    teacherJoinCourse: (courseId: string, teacherId: string, selfprocessError?: boolean) => Promise<void>;
-    teacherLeaveCourse: (courseId: string, teacherId: string, selfprocessError?: boolean) => Promise<void>;
-    createTeacher: (teacherData: Teacher, selfprocessError?: boolean) => Promise<void>;
-    deleteTeacher: (id: string, selfprocessError?: boolean) => Promise<void>;
+    getTeacherByID: (id: string, init?: boolean, selfProcessError?: boolean) => Promise<void>;
+    getTeachersByCourse: (courseId: string, selfProcessError?: boolean) => Promise<void>;
+    getTeachers: (selfProcessError?: boolean) => Promise<void>;
+    searchTeachers: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    teacherJoinCourse: (courseId: string, teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    teacherLeaveCourse: (courseId: string, teacherId: string, selfProcessError?: boolean) => Promise<void>;
+    createTeacher: (teacherData: Teacher, selfProcessError?: boolean) => Promise<void>;
+    deleteTeacher: (id: string, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useTeacher(): TeacherState {
@@ -38,26 +38,26 @@ export function useTeacher(): TeacherState {
     const response = ref<Response | null>(null);
     const teacherPagination = ref<PaginatorResponse<Teacher> | null>(null);
 
-    async function getTeacherByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getTeacherByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.retrieve.replace('{id}', id);
-        await get<Teacher>(endpoint, teacher, Teacher.fromJSON, selfprocessError);
+        await get<Teacher>(endpoint, teacher, Teacher.fromJSON, selfProcessError);
     }
 
-    async function getTeachersByCourse(courseId: string, selfprocessError: boolean = true): Promise<void> {
+    async function getTeachersByCourse(courseId: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.byCourse.replace('{courseId}', courseId);
-        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON, selfprocessError);
+        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON, selfProcessError);
     }
 
-    async function getTeachers(selfprocessError: boolean = true): Promise<void> {
+    async function getTeachers(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.index;
-        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON, selfprocessError);
+        await getList<Teacher>(endpoint, teachers, Teacher.fromJSON, selfProcessError);
     }
 
     async function searchTeachers(
         filters: Filter,
         page: number,
         pageSize: number,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.teachers.search;
         await getPaginatedList<Teacher>(
@@ -67,14 +67,14 @@ export function useTeacher(): TeacherState {
             pageSize,
             teacherPagination,
             Teacher.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function teacherJoinCourse(
         courseId: string,
         teacherId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.teachers.byCourse.replace('{courseId}', courseId);
         await create<Response>(
@@ -83,14 +83,14 @@ export function useTeacher(): TeacherState {
             response,
             Response.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
     async function teacherLeaveCourse(
         courseId: string,
         teacherId: string,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.teachers.byCourse.replace('{courseId}', courseId);
         await deleteIdWithData<Response>(
@@ -98,11 +98,11 @@ export function useTeacher(): TeacherState {
             { teacher: teacherId },
             response,
             Response.fromJSON,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function createTeacher(user: User, selfprocessError: boolean = true): Promise<void> {
+    async function createTeacher(user: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.index;
         await createToast<Teacher>(
             'teacher',
@@ -113,13 +113,13 @@ export function useTeacher(): TeacherState {
             teacher,
             Teacher.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function deleteTeacher(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function deleteTeacher(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.teachers.retrieve.replace('{id}', id);
-        await deleteId<Teacher>(endpoint, teacher, Teacher.fromJSON, selfprocessError);
+        await deleteId<Teacher>(endpoint, teacher, Teacher.fromJSON, selfProcessError);
     }
 
     return {
diff --git a/frontend/src/composables/services/users.service.ts b/frontend/src/composables/services/users.service.ts
index 2d83e126..1f6bfaf9 100644
--- a/frontend/src/composables/services/users.service.ts
+++ b/frontend/src/composables/services/users.service.ts
@@ -10,11 +10,11 @@ interface userState {
     pagination: Ref<PaginatorResponse<User> | null>;
     users: Ref<User[] | null>;
     user: Ref<User | null>;
-    getUserByID: (id: string, selfprocessError?: boolean) => Promise<void>;
-    getUsers: (selfprocessError?: boolean) => Promise<void>;
-    searchUsers: (filters: Filter, page: number, pageSize: number, selfprocessError?: boolean) => Promise<void>;
-    createUser: (user_data: User, selfprocessError?: boolean) => Promise<void>;
-    toggleAdmin: (id: string, is_staff: boolean, selfprocessError?: boolean) => Promise<void>;
+    getUserByID: (id: string, selfProcessError?: boolean) => Promise<void>;
+    getUsers: (selfProcessError?: boolean) => Promise<void>;
+    searchUsers: (filters: Filter, page: number, pageSize: number, selfProcessError?: boolean) => Promise<void>;
+    createUser: (user_data: User, selfProcessError?: boolean) => Promise<void>;
+    toggleAdmin: (id: string, is_staff: boolean, selfProcessError?: boolean) => Promise<void>;
 }
 
 export function useUser(): userState {
@@ -23,27 +23,27 @@ export function useUser(): userState {
     const user = ref<User | null>(null);
     const response = ref<Response | null>(null);
 
-    async function getUserByID(id: string, selfprocessError: boolean = true): Promise<void> {
+    async function getUserByID(id: string, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.retrieve.replace('{id}', id);
-        await get<User>(endpoint, user, User.fromJSON, selfprocessError);
+        await get<User>(endpoint, user, User.fromJSON, selfProcessError);
     }
 
-    async function getUsers(selfprocessError: boolean = true): Promise<void> {
+    async function getUsers(selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.index;
-        await getList<User>(endpoint, users, User.fromJSON, selfprocessError);
+        await getList<User>(endpoint, users, User.fromJSON, selfProcessError);
     }
 
     async function searchUsers(
         filters: Filter,
         page: number,
         pageSize: number,
-        selfprocessError: boolean = true,
+        selfProcessError: boolean = true,
     ): Promise<void> {
         const endpoint = endpoints.users.search;
-        await getPaginatedList<User>(endpoint, filters, page, pageSize, pagination, User.fromJSON, selfprocessError);
+        await getPaginatedList<User>(endpoint, filters, page, pageSize, pagination, User.fromJSON, selfProcessError);
     }
 
-    async function createUser(userData: User, selfprocessError: boolean = true): Promise<void> {
+    async function createUser(userData: User, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.index;
         await createToast<User>(
             'user',
@@ -58,11 +58,11 @@ export function useUser(): userState {
             user,
             User.fromJSON,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }
 
-    async function toggleAdmin(id: string, isStaff: boolean, selfprocessError: boolean = true): Promise<void> {
+    async function toggleAdmin(id: string, isStaff: boolean, selfProcessError: boolean = true): Promise<void> {
         const endpoint = endpoints.users.admin.replace('{id}', id);
         await patch(
             endpoint,
@@ -71,7 +71,7 @@ export function useUser(): userState {
             },
             response,
             undefined,
-            selfprocessError,
+            selfProcessError,
         );
     }