teacher crud

src/controllers/TeacherController.js

@@ -0,0 +1,123 @@
+import TeacherService from '../services/TeacherServices.js'
+import Util from '../utils/Utils.js';
+
+const util = new Util();
+
+class teacherController {
+  static async home(req, res) {
+    res.send(`<h1>Welcome to the teacher's Route</h1>`)
+  }
+
+  static async getAllTeachers(req, res) {
+    try {
+      const allTeacher = await TeacherService.getAllTeachers();
+      if (allTeacher.length > 0) {
+        util.setSuccess(200, 'teachers retrieved', allTeacher);
+      } else {
+        util.setFound(400, 'No teahcer found in the database');
+      }
+      return util.send(res);
+    } catch (error) {
+      util.setError(400, error.message);
+      return util.send(res);
+    }
+  }
+
+  static async addTeacher(req, res) {
+    if (!req.body.teacherId || !req.body.classId ) {
+      util.setError(400, 'Please provide complete details of the teacher');
+      return util.send(res);
+    }
+    const newTeacher = req.body;
+    try {
+      const createdTeacher = await TeacherService.addTeacher(newTeacher);
+      util.setSuccess(201, 'Teacher Added Successfully!', createdTeacher);
+      return util.send(res);
+    } catch (error) {
+      util.setError(400, error.message);
+      return util.send(res);
+    }
+  }
+
+  static async updatedTeacher(req, res) {
+    const alteredTeacher = req.body;
+    const { id } = req.params;
+    // if (!util.checkIfValidUUID(id)) {
+    //   util.setError(400, 'Please input a valid Id');
+    //   return util.send(res);
+    // }
+    try {
+      const updateTeacher = await TeacherService.updateTeacher(id, alteredTeacher);
+      if (!updateTeacher) {
+        util.setError(404, `Cannot find a teacher with the id: ${id}`);
+      } else {
+        util.setSuccess(200, 'Teacher updated', updateTeacher);
+      }
+      return util.send(res);
+    } catch (error) {
+      util.setError(404, error.message);
+      return util.send(res);
+    }
+  }
+
+  static async getATeacher(req, res) {
+    const { id } = req.params;
+
+    // if (!util.checkIfValidUUID(id)) {
+    //   util.setError(400, 'Please input a valid numeric value');
+    //   return util.send(res);
+    // }
+
+    try {
+      const theTeacher = await TeacherService.getATeacher(id);
+
+      if (!theTeacher) {
+        util.setError(404, `Cannot find a teacher with the id ${id}`);
+      } else {
+        util.setSuccess(200, 'Found Teacher', theTeacher);
+      }
+      return util.send(res);
+    } catch (error) {
+      util.setError(404, error.message);
+      return util.send(res);
+    }
+  }
+
+
+
+
+  // static  getATeacher = async(req, res)=> {
+  //   try{
+  //     const teacherById = await TeacherService.findById(req.params.id)
+  //     res.json(teacherById)
+  //   }catch(err){
+  //     res.send('Error' + err)
+  //   }
+
+  // }
+
+  static async deleteTeacher(req, res) {
+    const { id } = req.params;
+
+    // if (!util.checkIfValidUUID(id)) {
+    //   util.setError(400, 'Please provide a numeric value');
+    //   return util.send(res);
+    // }
+
+    try {
+      const teacherToDelete = await TeacherService.deleteTeacher(id);
+
+      if (teacherToDelete) {
+        util.setSuccess(200, `Teacher with ${id} deleted`);
+      } else {
+        util.setError(404, `Teacher with the id ${id} cannot be found`);
+      }
+      return util.send(res);
+    } catch (error) {
+      util.setError(400, error.message);
+      return util.send(res);
+    }
+  }
+}
+
+export default teacherController;

src/db/migrations/20221030101838-create-class-teacher.js

@@ -4,13 +4,20 @@ module.exports = {
   async up(queryInterface, Sequelize) {
     await queryInterface.createTable('ClassTeachers', {
       id: {
+        type: Sequelize.UUID,
         allowNull: false,
-        autoIncrement: true,
-        primaryKey: true,
-        type: Sequelize.INTEGER
+        defaultValue:Sequelize.UUIDV4,
+
       },
       classId: {
-        type: Sequelize.STRING
+        type: Sequelize.UUID,
+        allowNull:false,
+        foreignKey:true
+      },
+      teacherId:{
+        type: Sequelize.UUID,
+        allowNull:false,
+        foreignKey:true
       },
       createdAt: {
         allowNull: false,

src/db/migrations/20221030102005-create-class-student.js

@@ -8,7 +8,7 @@ module.exports = {
     await queryInterface.createTable('ClassStudents', {
       id: {
         allowNull: false,
-        autoIncrement: true,
+        // autoIncrement: true,
         primaryKey: true,
         type: Sequelize.UUID
       },

src/db/models/classteacher.js

@@ -17,6 +17,7 @@ module.exports = (sequelize, DataTypes) => {
   ClassTeacher.init({
     id:{
       type: DataTypes.UUID,
+      defaultValue:DataTypes.UUIDV4,
       allowNull:false,
       primaryKey: true
     },

src/db/models/user.js

@@ -16,6 +16,8 @@ module.exports = (sequelize, DataTypes) => {
       User.hasMany(models.Message, {foreignKey: 'senderId', as: 'sender'});
       User.hasMany(models.Message, {foreignKey: 'receiverId', as: 'receiver'});
       User.belongsTo(models.Role, {foreignKey: 'roleId', as: 'role'})
+      User.hasMany(models.Class, {foreignKey: 'classId', as: 'class'});
+      User.hasMany(models.User, {foreignKey: 'teacherId', as: 'teacher'});
     }
   }
   User.init({

src/index.js

@@ -2,6 +2,7 @@ import express from "express";
 import dotenv from "dotenv";
 import messageRouter from "./routers/MessageRouter.js";
 import { studentRouter } from './routers/studentsRoutes.js';
+import {teacherRouter} from "./routers/TeacherRouter.js";
 const app = express();
 dotenv.config();
 
@@ -10,6 +11,7 @@ app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 app.use('/api/message', messageRouter);
 app.use('/api/students', studentRouter);
+app.use("/api/teacher", teacherRouter)
 
 
 app.get('/', (req, res) => {

src/routers/TeacherRouter.js

@@ -0,0 +1,13 @@
+import { Router } from "express";
+import teacherController from '../controllers/TeacherController.js'
+
+const teacherRouter = Router();
+
+teacherRouter.get('/', teacherController.getAllTeachers);
+teacherRouter.get('/home', teacherController.home);
+teacherRouter.post('/', teacherController.addTeacher);
+teacherRouter.get('/:id', teacherController.getATeacher);
+teacherRouter.put('/:id', teacherController.updatedTeacher);
+teacherRouter.delete('/:id', teacherController.deleteTeacher);
+
+export { teacherRouter };

src/services/TeacherServices.js

@@ -0,0 +1,68 @@
+import database from '../db/models/index.js';
+
+class TeacherService {
+  static async getAllTeachers() {
+    try {
+      const result = await database.ClassTeacher.findAll();
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  static async addTeacher(newTeacher) {
+    try {
+      const result = await database.ClassTeacher.create(newTeacher);
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  static async updateTeacher(id, updateTeacher) {
+    try {
+      const teacherToUpdate = await database.ClassTeacher.findOne({
+        where: { id: id }
+      });
+
+      if (teacherToUpdate) {
+        await database.ClassTeacher.update(updateTeacher, { where: { id: id } });
+
+        return updateTeacher;
+      }
+      return null;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  static async getATeacher(id) {
+    try {
+      const allTeacher = await database.ClassTeacher.findOne({
+        where: { id: id }
+      });
+
+      return allTeacher;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  static async deleteTeacher(id) {
+    try {
+      const TeacherToDelete = await database.ClassTeacher.findOne({ where: { id: id } });
+
+      if (TeacherToDelete) {
+        const deletedTeacher = await database.ClassTeacher.destroy({
+          where: { id: id }
+        });
+        return deletedTeacher;
+      }
+      return null;
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+export default TeacherService;

src/utils/Utils.js

@@ -34,4 +34,6 @@ export default class Util {
         message: this.message,
       });
     }
+
+
   }