Feature/duration

server/controllers/duration.controller.ts

@@ -0,0 +1,98 @@
+import { NextFunction, Request, Response } from "express";
+import mongoose from "mongoose";
+const Duration = require("../models/duration");
+const HttpStatus = require("http-status-codes");
+const {ErrorResponse} = require("../helper");
+
+class DurationController {
+    async create(req: Request, res: Response, next: NextFunction) {
+        try {
+            const duration = new Duration(req.body);
+            const savedDuration = await duration.save();
+
+            return savedDuration._doc;
+        } catch (err: any) {
+            throw err;
+        }
+    }
+
+    async update(req: Request, res: Response, next: NextFunction) {
+        try {
+            const studentId = req.params.student_id;
+            const newData = req.body;
+            const updatedDuration = await Duration.findOneAndUpdate(
+                { student_id: studentId },
+                newData
+            );
+
+            if (!updatedDuration) {
+                throw new ErrorResponse({
+                    statusCode: HttpStatus.StatusCodes.NOT_FOUND,
+                    message: `Student with id ${studentId} not found.`
+                })
+            }
+
+            return updatedDuration._doc;
+        } catch (err: any) {
+            throw err;
+        }
+
+    }
+
+    async delete(req: Request, res: Response, next: NextFunction) {
+        try {
+            const studentId = req.params.student_id;
+
+            const deletedDuration = await Duration.findOneAndDelete({ student_id: studentId });
+
+            if (!deletedDuration) {
+                throw new ErrorResponse({
+                    statusCode: HttpStatus.StatusCodes.NOT_FOUND,
+                    message: `Student with id ${studentId} not found.`,
+                });
+            }
+
+            return deletedDuration._doc;
+        } catch (err: any) {
+            throw err;
+        }
+    }
+
+    async findAll(req: Request, res: Response, next: NextFunction) {
+        try {
+            const students = await Duration.findAll();
+
+            if (!students) {
+                throw new ErrorResponse({
+                    statusCode: HttpStatus.StatusCodes.NOT_FOUND,
+                    message: `Students not found.`
+                });
+            }
+
+            return students._doc;
+        } catch (err) {
+            throw err;
+        }
+    }
+
+    async findByStudentId(req: Request, res: Response, next: NextFunction) {
+        try {
+            const studentId = req.params.student_id;
+
+            const student = await Duration.findOne({ student_id: studentId })
+
+            if (!student) {
+                throw new ErrorResponse({
+                    statusCode: HttpStatus.StatusCodes.NOT_FOUND,
+                    message: `Student with id ${studentId} not found.`
+                });
+            }
+
+            return student._doc;
+        } catch (err) {
+            throw err;
+        }
+    }
+}
+
+module.exports = new DurationController();

server/controllers/index.ts

@@ -1,5 +1,7 @@
 const authController = require("./auth.controller");
+const durationController = require("./duration.controller")
 
 module.exports = {
-    authController
+    authController,
+    durationController
 }

server/models/duration.ts

@@ -0,0 +1,36 @@
+import mongoose, { model } from 'mongoose';
+const { Schema } = mongoose;
+
+const durationSchema = new Schema({
+    student_id: {
+        type: Schema.Types.ObjectId,
+        ref: 'Student',
+        required: true
+      },
+      date: {
+        type: Date,
+        required: true
+      },
+      time_started: {
+        type: Date,
+        required: true
+      },
+      time_ended: {
+        type: Date, 
+        required: true
+      },
+      time_total: {
+        type: Number, // Assume that we will retrieve this using time_started - time_ended
+        required: true
+      },
+      activity: {
+        type: String,
+        required: true
+      },
+      notes: {
+        type: String,
+        required: true
+      }
+});
+
+module.exports = mongoose.model('Duration', durationSchema);

server/routes/duration.router.ts

@@ -0,0 +1,13 @@
+import express from "express";
+const router = express.Router();
+const {wrapMiddleware, wrapController} = require("../helper");
+const {durationController} = require("../controllers");
+const durationValidation = require("../validations/duration.validation");
+
+router.post("/create", wrapMiddleware(durationValidation.create), wrapController(durationController.create));
+router.put("/:student_id", wrapMiddleware(durationValidation.update), wrapController(durationController.update));
+router.delete("/:student_id", wrapMiddleware(durationValidation.delete), wrapController(durationController.delete));
+router.get("/all", wrapMiddleware(durationValidation.findAll), wrapController(durationController.findAll));
+router.get("/:student_id", wrapMiddleware(durationValidation.findByStudentId, wrapController(durationValidation.findById)));
+
+module.exports = router;

server/routes/index.ts

@@ -1,7 +1,9 @@
 const authRouter = require("./auth.router");
+const durationRouter = require("./duration.router");
 import express from "express";
 const router = express.Router();
 
 router.use("/auth", authRouter);
+router.use("/duration", durationRouter);
 
 module.exports = router;

server/validations/duration.validation.ts

@@ -0,0 +1,85 @@
+import { CustomHelpers } from "joi";
+
+const Joi = require('joi');
+const mongoose = require('mongoose');
+
+// Define the schema for each route validation
+module.exports = {
+    create: Joi.object({
+        student_id: Joi.string()
+            .custom((value: string, helpers: CustomHelpers) => {
+                if (!mongoose.Types.ObjectId.isValid(value)) {
+                    return helpers.error('Invalid student ID');
+                }
+                return value;
+            })
+            .required(),
+        date: Joi.date().required(),
+        time_started: Joi.date().required(),
+        time_ended: Joi.date()
+            .greater(Joi.ref('time_started'))
+            .required()
+            .messages({
+                "date.greater": "time_ended must be later than time_started",
+            }),
+        time_total: Joi.number()
+            .positive()
+            .required()
+            .messages({
+                "number.positive": "time_total must be a positive number",
+            }),
+        activity: Joi.string().required(),
+        notes: Joi.string().required().allow(null, ''),
+    }),
+
+    update: Joi.object({
+        student_id: Joi.string()
+            .custom((value: string, helpers: CustomHelpers) => {
+                if (!mongoose.Types.ObjectId.isValid(value)) {
+                    return helpers.error('Invalid student ID');
+                }
+                return value;
+            })
+            .required(),
+        date: Joi.date().required(),
+        time_started: Joi.date().required(),
+        time_ended: Joi.date()
+            .greater(Joi.ref('time_started'))
+            .required()
+            .messages({
+                "date.greater": "time_ended must be later than time_started",
+            }),
+        time_total: Joi.number()
+            .positive()
+            .required()
+            .messages({
+                "number.positive": "time_total must be a positive number",
+            }),
+        activity: Joi.string().required(),
+        notes: Joi.string().required().allow(null, ''),
+    }),
+
+    delete: Joi.object({
+        student_id: Joi.string()
+            .custom((value: string, helpers: CustomHelpers) => {
+                if (!mongoose.Types.ObjectId.isValid(value)) {
+                    return helpers.error('Invalid student ID');
+                }
+                return value;
+            })
+            .required(),
+    }),
+
+    findAll: Joi.object({}),
+
+    findByStudentId: Joi.object({
+        student_id: Joi.string()
+            .custom((value: string, helpers: CustomHelpers) => {
+                if (!mongoose.Types.ObjectId.isValid(value)) {
+                    return helpers.error('Invalid student ID');
+                }
+                return value;
+            })
+            .required(),
+    }),
+};