chore: add student service

frontend/src/composables/services/admins.service.ts

@@ -0,0 +1,40 @@
+import {Admin} from '@/types/Admin.ts';
+import {ref} from 'vue';
+import axios from 'axios';
+import {endpoints} from '@/config/endpoints.ts';
+
+export function useAdmin() {
+    const admins = ref<Admin[]|null>(null);
+    const admin = ref<Admin|null>(null);
+
+    async function getAdminByID(id: number) {
+        const endpoint = endpoints.admins.retrieve.replace('{id}', id.toString());
+
+        axios.get(endpoint).then(response => {
+            admin.value = Admin.fromJSON(response.data);
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(admin)
+    }
+
+    async function getAdmins() {
+        const endpoint = endpoints.admins.index;
+
+        axios.get(endpoint).then(response => {
+            admins.value = response.data.map((adminData: Admin) => Admin.fromJSON(adminData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(admins.value ? admins.value.map((admin, index) => `Admin ${index + 1}: ${JSON.stringify(admin)}`) : 'Admins is null');
+    }
+
+    return {
+        admins,
+        admin,
+        getAdminByID,
+        getAdmins
+    };
+}

frontend/src/composables/services/assistant.service.ts

@@ -0,0 +1,40 @@
+import {Assistant} from '@/types/Assistant.ts';
+import {ref} from 'vue';
+import axios from 'axios';
+import {endpoints} from '@/config/endpoints.ts';
+
+export function useAssistant() {
+    const assistants = ref<Assistant[]|null>(null);
+    const assistant = ref<Assistant|null>(null);
+
+    async function getAssistantByID(id: number) {
+        const endpoint = endpoints.assistants.retrieve.replace('{id}', id.toString());
+
+        axios.get(endpoint).then(response => {
+            assistant.value = Assistant.fromJSON(response.data);
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(assistant)
+    }
+
+    async function getAssistants() {
+        const endpoint = endpoints.assistants.index;
+
+        axios.get(endpoint).then(response => {
+            assistants.value = response.data.map((assistantData: Assistant) => Assistant.fromJSON(assistantData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(assistants.value ? assistants.value.map((assistant, index) => `Assistant ${index + 1}: ${JSON.stringify(assistant)}`) : 'assistants is null');
+    }
+
+    return {
+        assistants,
+        assistant,
+        getAssistantByID,
+        getAssistants
+    };
+}

frontend/src/composables/services/courses.service.ts

@@ -16,12 +16,38 @@ export function useCourses() {
             console.log(error.data);
         });
 
-        console.log(Course)
+        console.log(course)
+    }
+
+    async function getCourses() {
+        const endpoint = endpoints.courses.index;
+
+        axios.get(endpoint).then(response => {
+            courses.value = response.data.map((courseData: Course) => Course.fromJSON(courseData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(courses.value ? courses.value.map((course, index) => `Course ${index + 1}: ${JSON.stringify(course)}`) : 'Courses is null');
+    }
+
+    async function getCoursesByStudent(student_id: number) {
+        const endpoint = endpoints.courses.byStudent.replace('{student_id}', student_id.toString());
+
+        axios.get(endpoint).then(response => {
+            courses.value = response.data.map((courseData: Course) => Course.fromJSON(courseData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(courses.value ? courses.value.map((course, index) => `Course ${index + 1}: ${JSON.stringify(course)}`) : 'Courses is null');
     }
 
     return {
         courses,
         course,
-        getCourseByID
+        getCourseByID,
+        getCourses,
+        getCoursesByStudent
     };
 }

frontend/src/composables/services/faculties.service.ts

@@ -0,0 +1,40 @@
+import {Faculty} from '@/types/Faculty.ts';
+import {ref} from 'vue';
+import axios from 'axios';
+import {endpoints} from '@/config/endpoints.ts';
+
+export function useFaculty() {
+    const faculties = ref<Faculty[]|null>(null);
+    const faculty = ref<Faculty|null>(null);
+
+    async function getFacultyByID(name: string) {
+        const endpoint = endpoints.faculties.retrieve.replace('{name}', name);
+
+        axios.get(endpoint).then(response => {
+            faculty.value = Faculty.fromJSON(response.data);
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(faculty)
+    }
+
+    async function getFacultys() {
+        const endpoint = endpoints.faculties.index;
+
+        axios.get(endpoint).then(response => {
+            faculties.value = response.data.map((facultyData: Faculty) => Faculty.fromJSON(facultyData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(faculties.value ? faculties.value.map((faculty, index) => `Faculty ${index + 1}: ${JSON.stringify(faculty)}`) : 'Facultys is null');
+    }
+
+    return {
+        faculties,
+        faculty,
+        getFacultyByID,
+        getFacultys
+    };
+}

frontend/src/composables/services/groups.service.ts

@@ -0,0 +1,40 @@
+import {Group} from '@/types/Group.ts';
+import {ref} from 'vue';
+import axios from 'axios';
+import {endpoints} from '@/config/endpoints.ts';
+
+export function useGroup() {
+    const groups = ref<Group[]|null>(null);
+    const group = ref<Group|null>(null);
+
+    async function getGroupByID(id: number) {
+        const endpoint = endpoints.groups.retrieve.replace('{id}', id.toString());
+
+        axios.get(endpoint).then(response => {
+            group.value = Group.fromJSON(response.data);
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(group)
+    }
+
+    async function getGroupsByProject(project_id: number) {
+        const endpoint = endpoints.groups.byProject.replace('{project_id}', project_id.toString());
+
+        axios.get(endpoint).then(response => {
+            groups.value = response.data.map((groupData: Group) => Group.fromJSON(groupData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(groups.value ? groups.value.map((group, index) => `Group ${index + 1}: ${JSON.stringify(group)}`) : 'Groups is null');
+    }
+
+    return {
+        groups,
+        group,
+        getGroupByID,
+        getGroupsByProject
+    };
+}

frontend/src/composables/services/helpers.ts

@@ -0,0 +1,11 @@
+/*
+import axios from 'axios';
+
+export function get<T extends Model>(path: string, ref: Ref<T>): void {
+    axios.get(path).then(response =>
+        ref.value = ref.fromJSON(response.data)
+    ).catch(error => {
+        console.log(error.data);
+    });
+}
+*/

frontend/src/composables/services/project.service.ts

@@ -0,0 +1,63 @@
+import {Project} from '@/types/Projects.ts';
+import {ref} from 'vue';
+import axios from 'axios';
+import {endpoints} from '@/config/endpoints.ts';
+
+export function useProject() {
+    const projects = ref<Project[]|null>(null);
+    const project = ref<Project|null>(null);
+
+    async function getProjectByID(id: number) {
+        const endpoint = endpoints.projects.retrieve.replace('{id}', id.toString());
+
+        axios.get(endpoint).then(response => {
+            project.value = Project.fromJSON(response.data);
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(project)
+    }
+
+    async function getProjectsByCourse(course_id: number) {
+        const endpoint = endpoints.projects.byCourse.replace('{course_id}', course_id.toString());
+
+        axios.get(endpoint).then(response => {
+            projects.value = response.data.map((projectData: Project) => Project.fromJSON(projectData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(projects.value ? projects.value.map((project, index) => `Project ${index + 1}: ${JSON.stringify(project)}`) : 'Projects is null');
+    }
+
+    async function getProjectsByCourseAndDeadline(course_id: number, deadlineDate: Date ) {
+
+        const endpoint = endpoints.projects.byCourse.replace('{course_id}', course_id.toString());
+
+        axios.get(endpoint).then(response => {
+            const allProjects = response.data.map((projectData: Project) => Project.fromJSON(projectData));
+
+            // Filter projects based on the deadline date
+            const projectsWithMatchingDeadline = allProjects.filter((project: Project) => {
+                const projectDeadlineDate = project.deadline;
+                return projectDeadlineDate.toDateString() === deadlineDate.toDateString();
+            });
+
+            // Update the projects ref with the filtered projects
+            projects.value = projectsWithMatchingDeadline;
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(projects.value ? projects.value.map((project, index) => `Project ${index + 1}: ${JSON.stringify(project)}`) : 'Projects is null');
+    }
+
+    return {
+        projects,
+        project,
+        getProjectByID,
+        getProjectsByCourse,
+        getProjectsByCourseAndDeadline
+    };
+}

frontend/src/composables/services/structure_check.service.ts

@@ -0,0 +1,40 @@
+import {Structure_check} from '@/types/Structure_check.ts';
+import {ref} from 'vue';
+import axios from 'axios';
+import {endpoints} from '@/config/endpoints.ts';
+
+export function useStructure_check() {
+    const structure_checks = ref<Structure_check[]|null>(null);
+    const structure_check = ref<Structure_check|null>(null);
+
+    async function getStructure_checkByID(id: number) {
+        const endpoint = endpoints.structure_checks.retrieve.replace('{id}', id.toString());
+
+        axios.get(endpoint).then(response => {
+            structure_check.value = Structure_check.fromJSON(response.data);
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(structure_check)
+    }
+
+    async function getStructure_checkByProject(project_id: number) {
+        const endpoint = endpoints.structure_checks.byProject.replace('{project_id}', project_id.toString());
+
+        axios.get(endpoint).then(response => {
+            structure_checks.value = response.data.map((structure_checkData: Structure_check) => Structure_check.fromJSON(structure_checkData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(structure_checks.value ? structure_checks.value.map((structure_check, index) => `Structure_check ${index + 1}: ${JSON.stringify(structure_check)}`) : 'Structure_check is null');
+    }
+
+    return {
+        structure_checks,
+        structure_check,
+        getStructure_checkByID,
+        getStructure_checkByProject
+    };
+}

frontend/src/composables/services/students.service.ts

@@ -0,0 +1,40 @@
+import {Student} from '@/types/Student';
+import {ref} from 'vue';
+import axios from 'axios';
+import {endpoints} from '@/config/endpoints.ts';
+
+export function useStudents() {
+    const students = ref<Student[]|null>(null);
+    const student = ref<Student|null>(null);
+
+    async function getStudentByID(id: number) {
+        const endpoint = endpoints.students.retrieve.replace('{id}', id.toString());
+
+        axios.get(endpoint).then(response => {
+            student.value = Student.fromJSON(response.data);
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(student)
+    }
+
+    async function getStudents() {
+        const endpoint = endpoints.students.index;
+
+        axios.get(endpoint).then(response => {
+            students.value = response.data.map((studentData: Student) => Student.fromJSON(studentData));
+        }).catch(error => {
+            console.log(error.data);
+        });
+
+        console.log(students.value ? students.value.map((student, index) => `Student ${index + 1}: ${JSON.stringify(student)}`) : 'Students is null');
+    }
+
+    return {
+        students,
+        student,
+        getStudentByID,
+        getStudents
+    };
+}