fix: groups queries types gefixt

frontend/src/controllers/groups.ts

@@ -12,39 +12,43 @@ export interface GroupResponse {
 }
 
 export class GroupController extends BaseController {
-    constructor(classid: string, assignmentNumber: number) {
+    constructor() {
-        super(`class/${classid}/assignments/${assignmentNumber}/groups`);
+        super('');
     }
 
     update(classid: string, assignmentNumber: number) {
         this.basePath = `class/${classid}/assignments/${assignmentNumber}/groups`;
     }
 
-    async getAll(full = true): Promise<GroupsResponse> {
+    protected getBasePath(classid: string, assignmentNumber: number) {
-        return this.get<GroupsResponse>(`/`, { full });
+        return `class/${classid}/assignments/${assignmentNumber}/groups`;
     }
 
-    async getByNumber(num: number | string): Promise<GroupResponse> {
+    async getAll(classid: string, assignmentNumber: number, full = true): Promise<GroupsResponse> {
-        return this.get<GroupResponse>(`/${num}`);
+        return this.get<GroupsResponse>(`${this.getBasePath(classid, assignmentNumber)}/`, { full });
     }
 
-    async createGroup(data: GroupDTO): Promise<GroupResponse> {
+    async getByNumber(classid: string, assignmentNumber: number, num: number | string): Promise<GroupResponse> {
-        return this.post<GroupResponse>(`/`, data);
+        return this.get<GroupResponse>(`${this.getBasePath(classid, assignmentNumber)}/${num}`);
     }
 
-    async deleteGroup(num: number): Promise<GroupResponse> {
+    async createGroup(classid: string, assignmentNumber: number, data: GroupDTO): Promise<GroupResponse> {
-        return this.delete<GroupResponse>(`/${num}`);
+        return this.post<GroupResponse>(`${this.getBasePath(classid, assignmentNumber)}/`, data);
     }
 
-    async updateGroup(num: number, data: Partial<GroupDTO>): Promise<GroupResponse> {
+    async deleteGroup(classid: string, assignmentNumber: number, num: number): Promise<GroupResponse> {
-        return this.put<GroupResponse>(`/${num}`, data);
+        return this.delete<GroupResponse>(`${this.getBasePath(classid, assignmentNumber)}/${num}`);
     }
 
-    async getSubmissions(groupNumber: number, full = true): Promise<SubmissionsResponse> {
+    async updateGroup(classid: string, assignmentNumber: number, num: number, data: Partial<GroupDTO>): Promise<GroupResponse> {
-        return this.get<SubmissionsResponse>(`/${groupNumber}/submissions`, { full });
+        return this.put<GroupResponse>(`${this.getBasePath(classid, assignmentNumber)}/${num}`, data);
     }
 
-    async getQuestions(groupNumber: number, full = true): Promise<QuestionsResponse> {
+    async getSubmissions(classid: string, assignmentNumber: number, groupNumber: number, full = true): Promise<SubmissionsResponse> {
-        return this.get<QuestionsResponse>(`/${groupNumber}/questions`, { full });
+        return this.get<SubmissionsResponse>(`${this.getBasePath(classid, assignmentNumber)}/${groupNumber}/submissions`, { full });
+    }
+
+    async getQuestions(classid: string, assignmentNumber: number, groupNumber: number, full = true): Promise<QuestionsResponse> {
+        return this.get<QuestionsResponse>(`${this.getBasePath(classid, assignmentNumber)}/${groupNumber}/questions`, { full });
     }
 }

frontend/src/queries/groups.ts

@@ -5,7 +5,7 @@ import type { SubmissionsResponse } from "@/controllers/submissions";
 import { useQuery, type UseQueryReturnType } from "@tanstack/vue-query";
 import { computed, toValue, type MaybeRefOrGetter } from "vue";
 
-const groupController = new GroupController('', 0);
+const groupController = new GroupController();
 
 function groupsQueryKey(classid: string, assignmentNumber: number) {
     return [ "groups", classid, assignmentNumber ];
@@ -20,15 +20,31 @@ function groupQuestionsQueryKey(classid: string, assignmentNumber: number, group
     return [ "group-questions", classid, assignmentNumber, groupNumber, full ];
 }
 
+function checkEnabled(
+    classid: string | undefined, 
+    assignmentNumber: number | undefined, 
+    groupNumber: number | undefined,
+): boolean {
+    return  Boolean(classid) && !isNaN(Number(groupNumber)) && !isNaN(Number(assignmentNumber));
+}
+function toValues(
+    classid: MaybeRefOrGetter<string | undefined>, 
+    assignmentNumber: MaybeRefOrGetter<number | undefined>, 
+    groupNumber: MaybeRefOrGetter<number | undefined>,
+) {
+    return { cid: toValue(classid), an: toValue(assignmentNumber), gn: toValue(groupNumber) };
+}
+
 export function useGroupsQuery(
-    classid: string, 
+    classid: MaybeRefOrGetter<string | undefined>, 
-    assignmentNumber: number, 
+    assignmentNumber: MaybeRefOrGetter<number | undefined>, 
 ): UseQueryReturnType<GroupsResponse, Error> {
-    groupController.update(classid, assignmentNumber);
+    const { cid, an, gn } = toValues(classid, assignmentNumber, 1);
 
     return useQuery({
-        queryKey: computed(() => (groupsQueryKey(classid, assignmentNumber))),
+        queryKey: computed(() => (groupsQueryKey(cid!, an!))),
-        queryFn: async () => groupController.getAll(),
+        queryFn: async () => groupController.getAll(cid!, an!),
+        enabled: () => checkEnabled(cid, an, 1),
     });
 }
 
@@ -37,12 +53,12 @@ export function useGroupQuery(
     assignmentNumber: number, 
     groupNumber: MaybeRefOrGetter<number | undefined>,
 ): UseQueryReturnType<GroupResponse, Error> {
-    groupController.update(classid, assignmentNumber);
+    const { cid, an, gn } = toValues(classid, assignmentNumber, groupNumber);
 
     return useQuery({
-        queryKey: computed(() => groupQueryKey(classid, assignmentNumber, toValue(groupNumber)!)),
+        queryKey: computed(() => groupQueryKey(cid!, an!, gn!)),
-        queryFn: async () => groupController.getByNumber(toValue(groupNumber)!),
+        queryFn: async () => groupController.getByNumber(cid!, an!, gn!),
-        enabled: () => !isNaN(Number(toValue(groupNumber))),
+        enabled: () => checkEnabled(cid, an, gn),
     });
 }
 
@@ -52,26 +68,26 @@ export function useGroupSubmissionsQuery(
     groupNumber: MaybeRefOrGetter<number | undefined>,
     full: MaybeRefOrGetter<boolean> = true,
 ): UseQueryReturnType<SubmissionsResponse, Error> {
-    groupController.update(classid, assignmentNumber);
+    const { cid, an, gn } = toValues(classid, assignmentNumber, groupNumber);
 
     return useQuery({
-        queryKey: computed(() => groupSubmissionsQueryKey(classid, assignmentNumber, toValue(groupNumber)!, toValue(full)!)),
+        queryKey: computed(() => groupSubmissionsQueryKey(cid!, an!, gn!, toValue(full))),
-        queryFn: async () => groupController.getSubmissions(toValue(groupNumber)!, toValue(full)!),
+        queryFn: async () => groupController.getSubmissions(cid!, an!, gn!, toValue(full)),
-        enabled: () => !isNaN(Number(toValue(groupNumber))),
+        enabled: () => checkEnabled(cid, an, gn),
     });
 }
 
 export function useGroupQuestionsQuery(
-    classid: string, 
+    classid: MaybeRefOrGetter<string | undefined>, 
-    assignmentNumber: number, 
+    assignmentNumber: MaybeRefOrGetter<number | undefined>, 
     groupNumber: MaybeRefOrGetter<number | undefined>,
     full: MaybeRefOrGetter<boolean> = true,
 ): UseQueryReturnType<QuestionsResponse, Error> {
-    groupController.update(toValue(classid)!, toValue(assignmentNumber));
+    const { cid, an, gn } = toValues(classid, assignmentNumber, groupNumber);
 
     return useQuery({
-        queryKey: computed(() => groupQuestionsQueryKey(classid, assignmentNumber, toValue(groupNumber)!, toValue(full)!)),
+        queryKey: computed(() => groupQuestionsQueryKey(cid!, an!, gn!, toValue(full))),
-        queryFn: async () => groupController.getSubmissions(toValue(groupNumber)!, toValue(full)!),
+        queryFn: async () => groupController.getSubmissions(cid!, an!, gn!, toValue(full)),
-        enabled: () => !isNaN(Number(toValue(groupNumber))),
+        enabled: () => checkEnabled(cid, an, gn),
     });
 }