added Joi validaion for lesson

Author: nmanikiran

server/controllers/CoursesCtrl.ts

@@ -1,26 +1,24 @@
 
 import { Router, Request, Response, NextFunction } from "express";
 import CourseRepo from "./../repositories/CoursesRepo";
-
 import { apiErrorHandler } from "./../handlers/errorHandler";
 
 export default class CoursesRoutes {
 
-    constructor(router: Router) {
-        router.get("/", this.getAllCourses.bind(this));
-        router.get("/:id", this.getCourseDetails.bind(this));
+    constructor() {
+
     }
 
-    private getAllCourses(req: Request, res: Response, next: NextFunction) {
+    getAllCourses(req: Request, res: Response, next: NextFunction) {
         CourseRepo.getAllCourses({ order: ["seqNo"] })
             .then((result) => res.json(result))
             .catch((err) => { apiErrorHandler(err, req, res, "Fetch All Courses failed."); });
     }
 
-    private getCourseDetails(req: Request, res: Response, next: NextFunction) {
+    getCourseDetails(req: Request, res: Response, next: NextFunction) {
 
         CourseRepo.getById(req.params.id)
             .then((result) => res.json(result))
-            .catch((err) => { apiErrorHandler(err, req, res, "Course not found."); });
+            .catch((err) => { apiErrorHandler(err, req, res, `Course ${req.params.id} not found.`); });
     }
-}
+}

server/controllers/LessonsCtrl.ts

@@ -1,30 +1,46 @@
 import { NextFunction, Request, Response, Router } from 'express';
 
+import { apiErrorHandler } from '../handlers/errorHandler';
 import LessonRepo from '../repositories/LessonsRepo';
 
 export default class LessonRoutes {
 
-    constructor(router: Router) {
-        router.post("/", this.createLesson.bind(this));
-        router.put("/:id", this.updateLesson.bind(this));
-        router.delete("/:id", this.deleteLesson.bind(this));
+    constructor() { }
+
+    getAllLessons(req: Request, res: Response, next: NextFunction) {
+        LessonRepo.getAllLessons({ order: ["seqNo"] })
+            .then((result) => res.json(result))
+            .catch((err) => { apiErrorHandler(err, req, res, "Fetch All Lessons failed."); });
+    }
+
+    getLessonByCourse(req: Request, res: Response, next: NextFunction) {
+
+        LessonRepo.getLessonByCourse(req.params.id)
+            .then((result) => res.json(result))
+            .catch((err) => { apiErrorHandler(err, req, res, "Fetch All Lessons failed."); });
+    }
+
+    getLessonById(req: Request, res: Response, next: NextFunction) {
+        LessonRepo.getLessonById(req.params.id)
+            .then((result) => res.json(result))
+            .catch((err) => { apiErrorHandler(err, req, res, `Lesson ${req.params.id} not found.`); });
     }
 
-    private createLesson(req: Request, res: Response, next: NextFunction) {
-        LessonRepo.createLesson(req.body)
+    createLesson(req: Request, res: Response, next: NextFunction) {
+        LessonRepo.createLesson(req['value']['body'])
             .then((result) => { res.json(result); })
-            .catch((err) => { res.json({ error: err }); });
+            .catch((err) => { apiErrorHandler(err, req, res, "Creation of Lesson failed."); });
     }
 
-    private updateLesson(req: Request, res: Response, next: NextFunction) {
-        LessonRepo.updateLesson(req.params.id, req.body)
+    updateLesson(req: Request, res: Response, next: NextFunction) {
+        LessonRepo.updateLesson(req.params.id, req['value']['body'])
             .then((result) => { res.json(result); })
-            .catch((err) => { res.json({ error: err }); });
+            .catch((err) => { apiErrorHandler(err, req, res, `updation of Lesson ${req.params.id}  failed.`); });
     }
 
-    private deleteLesson(req: Request, res: Response, next: NextFunction) {
+    deleteLesson(req: Request, res: Response, next: NextFunction) {
         LessonRepo.deleteLesson(req.params.id)
             .then((result) => { res.json(result); })
-            .catch((err) => { res.json({ error: err }); });
+            .catch((err) => { apiErrorHandler(err, req, res, `deletion of Lesson ${req.params.id}  failed.`); });
     }
-}
+}

server/repositories/CoursesRepo.ts

@@ -1,12 +1,9 @@
-
-import { Lesson } from "./../models/Lesson";
-import { Course } from "./../models/Course";
+import { Course } from '../models/Course';
+import { Lesson } from '../models/Lesson';
 
 class CourseRepo {
 
-    constructor() {
-        console.log("Courses Repo...");
-    }
+    constructor() {    }
 
     getAllCourses(options) {
         return Course.findAll(options);

server/repositories/LessonsRepo.ts

@@ -1,19 +1,30 @@
-
-import { Lesson } from "./../models/Lesson";
-import { Course } from "./../models/Course";
+import { Course } from '../models/Course';
+import { Lesson } from '../models/Lesson';
 
 class LessonRepo {
 
-    constructor() {
-        console.log("Lessons Repo...");
+    constructor() {    }
+
+    getAllLessons(options) {
+        return Lesson.findAll(options);
+    }
+
+    getLessonById(id) {
+        return Lesson.findById(id);
+    }
+
+    getLessonByCourse(id) {
+        return Lesson.findAll({ where: { 'courseId': id } });
     }
 
     createLesson(props: any) {
         return Lesson.create(props);
     }
+
     updateLesson(id: Number, props: any) {
         return Lesson.update(props, { where: { id } });
     }
+
     deleteLesson(id: Number) {
         return Lesson.destroy({ where: { id } });
     }

server/routes.ts

@@ -1,19 +1,28 @@
 
 import { Application, Request, Response, NextFunction, Router } from "express";
-import Courses from "./controllers/CoursesCtrl";
-import Lessons from "./controllers/LessonsCtrl";
+import CoursesCtrl from "./controllers/CoursesCtrl";
+import LessonsCtrl from "./controllers/LessonsCtrl";
+import { LessonValidator, lessonSchema } from './validators/lessonValidator';
 
 export default class Routes {
 
-    public router: Router;
+    lessonsCtrl = new LessonsCtrl();
+    coursesCtrl = new CoursesCtrl();
+
+    lessonValidator = new LessonValidator();
 
     constructor(app: Application) {
 
-        this.router = Router();
-        var coursesRoutes: Courses = new Courses(this.router);
-        var lessonRoutes: Lessons = new Lessons(this.router);
+        //course reoutes
+        app.route("/api/courses/").get(this.coursesCtrl.getAllCourses);
+        app.route("/api/courses/:id").get(this.coursesCtrl.getCourseDetails);
 
-        app.use("/api/lesson", this.router);
-        app.use("/api/courses", this.router);
+        // lesson routes
+        app.route("/api/lessons").get(this.lessonsCtrl.getAllLessons);
+        app.route("/api/lessons/course/:id").get(this.lessonsCtrl.getLessonByCourse);
+        app.route("/api/lessons/:id").get(this.lessonsCtrl.getLessonById);
+        app.route("/api/lessons").post(this.lessonValidator.validateBody(lessonSchema), this.lessonsCtrl.createLesson);
+        app.route("/api/lessons/:id").put(this.lessonValidator.validateBody(lessonSchema), this.lessonsCtrl.updateLesson);
+        app.route("/api/lessons/:id").delete(this.lessonsCtrl.deleteLesson);
     }
 }

server/validators/lessonValidator.ts

@@ -0,0 +1,40 @@
+import * as Joi from 'joi';
+import { JoiObject } from 'joi';
+import { Router, Request, Response, NextFunction } from "express";
+
+export class LessonValidator {
+    
+    constructor() { }
+
+    validateBody(schema) {
+        return (req: Request, res: Response, next: NextFunction) => {
+            const result = Joi.validate(req.body, schema);
+
+            if (result.error) {
+                return res.status(400).json(result.error);
+            } else {
+                if (!req['value']) {
+                    req['value'] = {};
+                }
+                if (!req['value']['body']) {
+                    req['value']['body'] = {};
+                }
+                req['value']['body'] = result.value;
+                next();
+            }
+        }
+    }
+}
+
+export const lessonSchema = Joi.object().keys({
+    courseId: Joi.number().integer().required(),
+    url: Joi.string().trim().required(),
+    gitHubUrl: Joi.string().trim().required(),
+    tags: Joi.string().trim().required(),
+    description: Joi.string().trim(),
+    duration: Joi.string(),
+    pro: Joi.boolean(),
+    seqNo: Joi.number(),
+    createdAt: Joi.date(),
+    updatedAt: Joi.date()
+});