Merge pull request #65 from AlessGarau/develop

Author: AlessGarau

packages/client/src/api/endpoints/class.ts

@@ -0,0 +1,29 @@
+import type { ClassCreate, ClassFilters, ClassUpdate } from '../../types/Class';
+import { apiClient } from '../client';
+
+export const classApi = {
+    getClasses: async (filters: ClassFilters = {}) => {
+        const response = await apiClient.get('/class', { params: filters });
+        return response.data;
+    },
+
+    getClassesCount: async (filters: ClassFilters = {}) => {
+        const response = await apiClient.get('/class/count', { params: filters });
+        return response.data;
+    },
+
+    createClass: async (data: ClassCreate) => {
+        const response = await apiClient.post('/class', data);
+        return response.data;
+    },
+
+    updateClass: async (id: string, data: ClassUpdate) => {
+        const response = await apiClient.put(`/class/${id}`, data);
+        return response.data;
+    },
+
+    deleteClass: async (id: string) => {
+        const response = await apiClient.delete(`/class/${id}`);
+        return response.data;
+    },
+};

packages/client/src/api/endpoints/report.ts

@@ -0,0 +1,50 @@
+import type { Report, ReportFilters } from "../../types/Reports";
+import { apiClient } from "../client";
+
+export const reportApi = {
+    getReportsCount: async (
+        filters: ReportFilters = {}
+    ): Promise<{ data: { count: number } }> => {
+        const params = new URLSearchParams();
+        if (filters.status) params.append("status", filters.status);
+        if (filters.equipmentType) params.append("equipmentType", String(filters.equipmentType));
+        if (filters.roomName) params.append("roomName", String(filters.roomName));
+        const response = await apiClient.get(
+            `/reporting/count?${params.toString()}`
+        );
+        return response.data;
+    },
+
+    createReport: async (data: {
+        equipmentId: string;
+        description: string;
+    }): Promise<void> => {
+        await apiClient.post(`/reporting`, data);
+    },
+
+    getReports: async (filters: ReportFilters = {}): Promise<{ data: Report[] }> => {
+        const params = new URLSearchParams();
+        if (filters.status) params.append("status", filters.status);
+        if (filters.equipmentType) params.append("equipmentType", String(filters.equipmentType));
+        if (filters.roomName) params.append("roomName", String(filters.roomName));
+        if (filters.limit) params.append("limit", String(filters.limit));
+        if (filters.offset) params.append("offset", String(filters.offset));
+        const response = await apiClient.get(
+            `/reporting?${params.toString()}`
+        );
+        return response.data;
+    },
+
+    deleteReport: async (reportId: string): Promise<void> => {
+        await apiClient.delete(`/reporting/${reportId}`);
+    },
+
+    updateReport: async (
+        reportId: string,
+        data: {
+            status: string;
+        }
+    ): Promise<void> => {
+        await apiClient.patch(`/reporting/${reportId}`, data);
+    },
+};

packages/client/src/api/endpoints/room.ts

@@ -23,6 +23,11 @@ export const roomApi = {
         return response.data;
     },
 
+    getRoomNameOptions: async (): Promise<{ data: RoomFilterOptions }> => {
+        const response = await apiClient.get("/room/filters?name=true");
+        return response.data;
+    },
+
     getFloorOptions: async (
         building: string
     ): Promise<{ data: RoomFilterOptions }> => {

packages/client/src/api/endpoints/teacher.ts

@@ -0,0 +1,29 @@
+import type { TeacherCreate, TeacherFilters, TeacherUpdate } from '../../types/Teacher';
+import { apiClient } from '../client';
+
+export const teacherApi = {
+    getTeachers: async (filters: TeacherFilters = {}) => {
+        const response = await apiClient.get('/teacher', { params: filters });
+        return response.data;
+    },
+
+    getTeachersCount: async (filters: TeacherFilters = {}) => {
+        const response = await apiClient.get('/teacher/count', { params: filters });
+        return response.data;
+    },
+
+    createTeacher: async (data: TeacherCreate) => {
+        const response = await apiClient.post('/teacher', data);
+        return response.data;
+    },
+
+    updateTeacher: async (id: string, data: TeacherUpdate) => {
+        const response = await apiClient.put(`/teacher/${id}`, data);
+        return response.data;
+    },
+
+    deleteTeacher: async (id: string) => {
+        const response = await apiClient.delete(`/teacher/${id}`);
+        return response.data;
+    },
+};

packages/client/src/api/queryOptions.ts

@@ -1,9 +1,14 @@
+import type { ClassCreate, ClassFilters, ClassUpdate } from "../types/Class";
 import type { PlannedClass, PlanningFilters } from "../types/Planning";
+import type { TeacherCreate, TeacherFilters, TeacherUpdate } from "../types/Teacher";
 import type { LoginCredentials } from "../types/User";
+import { classApi } from "./endpoints/class";
 import { lessonApi } from "./endpoints/lesson";
 import { planningApi } from "./endpoints/planning";
+import { reportApi } from "./endpoints/report";
 import { roomApi } from "./endpoints/room";
 import { sensorApi } from "./endpoints/sensor";
+import { teacherApi } from "./endpoints/teacher";
 import { userApi } from "./endpoints/user";
 import { weatherApi } from "./endpoints/weather";
 
@@ -77,6 +82,12 @@ export const roomQueryOptions = {
         staleTime: 60 * 60 * 1000,
     }),
 
+    roomNameOptions: () => ({
+        queryKey: ["room", "nameOptions"],
+        queryFn: () => roomApi.getRoomNameOptions(),
+        staleTime: 60 * 60 * 1000,
+    }),
+
     floorOptions: (building: string) => ({
         queryKey: ["room", "floorOptions", building],
         queryFn: () => roomApi.getFloorOptions(building),
@@ -170,6 +181,116 @@ export const roomQueryOptions = {
     }),
 };
 
+export const reportQueryOptions = {
+    reportCount: (filters = {}) => ({
+        queryKey: ["report", "count", filters],
+        queryFn: () => reportApi.getReportsCount(filters),
+        staleTime: 60 * 60 * 1000,
+    }),
+
+    createReport: () => ({
+        mutationKey: ["report", "createReport"],
+        mutationFn: (data: {
+            equipmentId: string;
+            description: string;
+        }) => reportApi.createReport(data),
+    }),
+
+    getReports: (filters = {}) => ({
+        queryKey: ["report", "allReports", filters],
+        queryFn: () => reportApi.getReports(filters),
+        staleTime: 60 * 60 * 1000,
+    }),
+
+    deleteReport: () => ({
+        mutationKey: ["report", "deleteReport"],
+        mutationFn: (reportId: string) => reportApi.deleteReport(reportId),
+    }),
+
+    updateReport: () => ({
+        mutationKey: ["report", "updateReport"],
+        mutationFn: ({
+            reportId,
+            data,
+        }: {
+            reportId: string;
+            data: {
+                status: string;
+            };
+        }) => reportApi.updateReport(reportId, data),
+    }),
+}
+
+export const classQueryOptions = {
+    classCount: (filters: ClassFilters = {}) => ({
+        queryKey: ["class", "count", filters],
+        queryFn: () => classApi.getClassesCount(filters),
+        staleTime: 60 * 60 * 1000,
+    }),
+
+    getClasses: (filters: ClassFilters = {}) => ({
+        queryKey: ["class", "allClasses", filters],
+        queryFn: () => classApi.getClasses(filters),
+        staleTime: 60 * 60 * 1000,
+    }),
+
+    createClass: () => ({
+        mutationKey: ["class", "createClass"],
+        mutationFn: (data: ClassCreate) => classApi.createClass(data),
+    }),
+
+    updateClass: () => ({
+        mutationKey: ["class", "updateClass"],
+        mutationFn: ({
+            classId,
+            data,
+        }: {
+            classId: string;
+            data: ClassUpdate;
+        }) => classApi.updateClass(classId, data),
+    }),
+
+    deleteClass: () => ({
+        mutationKey: ["class", "deleteClass"],
+        mutationFn: (classId: string) => classApi.deleteClass(classId),
+    }),
+};
+
+export const teacherQueryOptions = {
+    teacherCount: (filters: TeacherFilters = {}) => ({
+        queryKey: ["teacher", "count", filters],
+        queryFn: () => teacherApi.getTeachersCount(filters),
+        staleTime: 60 * 60 * 1000,
+    }),
+
+    getTeachers: (filters: TeacherFilters = {}) => ({
+        queryKey: ["teacher", "allTeachers", filters],
+        queryFn: () => teacherApi.getTeachers(filters),
+        staleTime: 60 * 60 * 1000,
+    }),
+
+    createTeacher: () => ({
+        mutationKey: ["teacher", "createTeacher"],
+        mutationFn: (data: TeacherCreate) => teacherApi.createTeacher(data),
+    }),
+
+    updateTeacher: () => ({
+        mutationKey: ["teacher", "updateTeacher"],
+        mutationFn: ({
+            teacherId,
+            data,
+        }: {
+            teacherId: string;
+            data: TeacherUpdate;
+        }) => teacherApi.updateTeacher(teacherId, data),
+    }),
+
+    deleteTeacher: () => ({
+        mutationKey: ["teacher", "deleteTeacher"],
+        mutationFn: (teacherId: string) => teacherApi.deleteTeacher(teacherId),
+    }),
+};
+
 export const lessonQueryOptions = {
     deleteLesson: () => ({
         mutationFn: (lessonId: string) => lessonApi.deleteLesson(lessonId),