Completed User API Documentation

backend/app.js

@@ -2,9 +2,14 @@ import express from "express";
 import cookieParser from "cookie-parser";
 import logger from "morgan";
 import testResource from "./resources/testResource.js";
-
+import userResource from "./resources/userResource.js";
 import authResource from "./resources/authResource.js";
 import otpResource from "./resources/otpResource.js";
+import studentResource from "./resources/studentResouce.js";
+import facultyResource from "./resources/facultyResource.js";
+import skillResource from "./resources/skillResource.js";
+import achievementResource from "./resources/achievementResource.js";
+import courseResource from "./resources/courseResource.js";
 import Connection from "./database/db.js";
 import cors from "cors";
 import auth from "./middlewares/auth.js";
@@ -24,7 +29,13 @@ app.use(cors());
 // Get Database connection
 Connection();
 app.use(authResource);
+app.use(userResource);
 app.use(otpResource);
+app.use(studentResource);
+app.use(facultyResource);
+app.use(skillResource);
+app.use(courseResource);
+app.use(achievementResource);
 app.use("/", testResource);
 app.use("/rooms", roomListResource);
 app.use("/room", roomResource);

backend/resources/achievementResource.js

@@ -0,0 +1,71 @@
+import Achievement from '../models/achievement.js';
+import express from 'express';
+import * as errorMessages from '../constants/errorMessages.js';
+const achievementRouter = express.Router();
+
+achievementRouter.get('/achievements', async (req, res) => {
+    try {
+        const achievement = await Achievement.find({});
+        res.json(achievement)
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+achievementRouter.get('/achievements/:id', async (req, res) => {
+    const achievementId = req.params.id;
+
+    try {
+        const achievementDetails = await Achievement.findById(achievementId);
+
+        if (!achievementDetails) {
+            return res.status(404).json({ message: errorMessages.achievementNotFound });
+        }
+
+        res.json(achievementDetails);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+achievementRouter.post('/achievements', async (req, res) => {
+    const achievementData = req.body;
+
+    try {
+        const newAchievement = new Achievement(achievementData);
+        await newAchievement.save();
+
+        res.status(201).json(newAchievement);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError});
+    }
+});
+
+achievementRouter.put('/achievements/:id', async (req, res) => {
+    const achievementId = req.params.id;
+    const achievementData = req.body;
+
+    try {
+        const updatedAchievement = await Achievement.findByIdAndUpdate(achievementId,achievementData,{new:true});
+        res.json(updatedAchievement);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+
+});
+
+achievementRouter.delete('/achievements/:id', async (req, res) => {
+    const achievementId = req.params.id;
+
+    try {
+        const deletedAchievement = await Achievement.findByIdAndDelete(achievementId);
+        res.json(deletedAchievement);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+export default achievementRouter;
+
+
+

backend/resources/authResource.js

@@ -1,11 +1,11 @@
-import mongoose from "mongoose";
-import express from "express";
-import bcryptjs from "bcryptjs";
-import jwt from "jsonwebtoken";
-import * as errorMessages from "../constants/errorMessages.js";
-import Student from "../models/student.js";
-import Faculty from "../models/faculty.js";
-import Admin from "../models/admin.js";
+import mongoose from 'mongoose';
+import express from 'express';
+import bcryptjs from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import * as errorMessages from '../constants/errorMessages.js';
+import Student from '../models/Student.js';
+import Faculty from '../models/faculty.js';
+import Admin from '../models/admin.js';
 
 const authRouter = express.Router();
 

backend/resources/courseResource.js

@@ -0,0 +1,71 @@
+import Course from '../models/course.js';
+import express from 'express';
+import * as errorMessages from '../constants/errorMessages.js';
+const courseRouter = express.Router();
+
+courseRouter.get('/courses', async (req, res) => {
+    try {
+        const courses = await Course.find({});
+        res.json(courses)
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+courseRouter.get('/courses/:id', async (req, res) => {
+    const courseId = req.params.id;
+
+    try {
+        const courseDetails = await Course.findById(courseId);
+
+        if (!courseDetails) {
+            return res.status(404).json({ message: errorMessages.courseNotFound });
+        }
+
+        res.json(courseDetails);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+courseRouter.post('/courses', async (req, res) => {
+    const courseData = req.body;
+
+    try {
+        const newCourse = new Course(courseData);
+        await newCourse.save();
+
+        res.status(201).json(newCourse);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError});
+    }
+});
+
+courseRouter.put('/courses/:id', async (req, res) => {
+    const courseId = req.params.id;
+    const courseData = req.body;
+
+    try {
+        const updatedCourse = await Course.findByIdAndUpdate(courseId,courseData,{new:true});
+        res.json(updatedCourse);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+
+});
+
+courseRouter.delete('/courses/:id', async (req, res) => {
+    const courseId = req.params.id;
+
+    try {
+        const deletedCourse = await Course.findByIdAndDelete(courseId);
+        res.json(deletedCourse);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+export default courseRouter;
+
+
+

backend/resources/facultyResource.js

@@ -0,0 +1,87 @@
+import Faculty from '../models/faculty.js';
+import express from 'express';
+import * as errorMessages from '../constants/errorMessages.js';
+const facultyRouter = express.Router();
+
+facultyRouter.get('/faculties', async (req, res) => {
+    try {
+        const faculties = await Faculty.find().populate('courses');
+        res.json(faculties);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+facultyRouter.post('/faculties', async (req, res) => {
+    const {email} = req.body;
+    let existingUser = await Faculty.findOne({ email });
+    try {
+        if (!existingUser) {
+            const newUser = new Faculty({ email });
+            await newUser.save();
+            res.send({ message: errorMessages.userCreated, user: newUser });
+        } else {
+            res.send({ message: errorMessages.userAlreadyExists, user: existingUser});
+        }
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+facultyRouter.get('/faculties/:id', async (req, res) => {
+    const facultyId = req.params.id;
+
+    try {
+        const facultyDetails = await Faculty.findById(facultyId).populate('courses');
+
+        if (!facultyDetails) {
+            return res.status(404).json({ message: errorMessages.facultyNotFound });
+        }
+
+        res.json(facultyDetails);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+facultyRouter.post('/faculties', async (req, res) => {
+    const {email} = req.body;
+    let existingUser = await Faculty.findOne({ email });
+    try {
+        if (!existingUser) {
+            const newUser = new Faculty({ email });
+            await newUser.save();
+            res.send({ message: errorMessages.userCreated, user: newUser });
+        } else {
+            res.send({ message: errorMessages.userAlreadyExists, user: existingUser});
+        }
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+facultyRouter.put('/faculties/:id', async (req, res) => {
+    const facultyId = req.params.id;
+    const facultyData = req.body;
+
+    try {
+        const updatedFaculty = await Faculty.findByIdAndUpdate(facultyId,facultyData,{new:true}).populate('courses');
+        res.json(updatedFaculty);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+
+});
+
+facultyRouter.delete('/faculties/:id', async (req, res) => {
+    const facultyId = req.params.id;
+
+    try {
+        const deletedFaculty = await Faculty.findByIdAndDelete(facultyId).populate('courses');
+        res.json(deletedFaculty);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+export default facultyRouter;

backend/resources/lostAndFound/lostAndFoundListResource.js

@@ -1,7 +1,7 @@
 import { Router } from "express";
 import LostAndFoundItem from "../../models/lost_and_found.js";
 import fs from "fs/promises";
-import uploader from "../../database/multerConfig.js";
+import uploader from "../../middlewares/multerConfig.js";
 
 const router = Router();
 
@@ -13,7 +13,7 @@ router.get("/", async (req, res) => {
 
     // Create an empty array to store items with images
     const itemsWithImages = [];
-
+``
     // Iterate through each item
     for (const item of items) {
       // Check if imagePath is null

backend/resources/skillResource.js

@@ -0,0 +1,71 @@
+import Skill from '../models/Skill.js';
+import express from 'express';
+import * as errorMessages from '../constants/errorMessages.js';
+const skillRouter = express.Router();
+
+skillRouter.get('/skills', async (req, res) => {
+    try {
+        const skills = await Skill.find({});
+        res.json(skills)
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+skillRouter.get('/skills/:id', async (req, res) => {
+    const skillId = req.params.id;
+
+    try {
+        const skillDetails = await Skill.findById(skillId);
+
+        if (!skillDetails) {
+            return res.status(404).json({ message: errorMessages.skillNotFound });
+        }
+
+        res.json(skillDetails);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+skillRouter.post('/skills', async (req, res) => {
+    const skillData = req.body;
+
+    try {
+        const newSkill = new Skill(skillData);
+        await newSkill.save();
+
+        res.status(201).json(newSkill);
+    } catch (err) {
+        res.status(500).json({ message: errorMessages.internalServerError});
+    }
+});
+
+skillRouter.put('/skills/:id', async (req, res) => {
+    const skillId = req.params.id;
+    const skillData = req.body;
+
+    try {
+        const updatedSkill = await Skill.findByIdAndUpdate(skillId,skillData,{new:true});
+        res.json(updatedSkill);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+
+});
+
+skillRouter.delete('/skills/:id', async (req, res) => {
+    const skillId = req.params.id;
+
+    try {
+        const deletedSkill = await Skill.findByIdAndDelete(skillId);
+        res.json(deletedSkill);
+    } catch (error) {
+        res.status(500).json({ message: errorMessages.internalServerError });
+    }
+});
+
+export default skillRouter;
+
+
+