Daniel t impliment crud for rating

starter-project-backend-g32/src/app.ts

@@ -2,17 +2,20 @@ import express, {Application, Request, Response, NextFunction, json} from 'expre
 import dotenv from 'dotenv';
 
 dotenv.config();
-import routes from "./routes";
+// import routes from "./routes";
 import articleRoutes from './routes/article'
+const ratingRouter = require("./routes/rating.routes");
+
 
 
 const app: Application = express();
 app.use(express.urlencoded({ extended: true }));
 app.use(express.json());
 app.use("/" , json({}));
-app.use("/api/v1", require('../src/routes/routes'));
-app.use("/users/:userID/posts/:postID/rates", routes.rateRouter);
+// app.use("/api/v1", require('../src/routes/routes'));
 app.use('/api/v1/articles', articleRoutes)
+app.use('/api/v1/rating', ratingRouter)
+
 
 export default app;
 

starter-project-backend-g32/src/controllers/rating.controller.js

@@ -0,0 +1,4 @@
+const Rating = require("../models/rating");
+const { crudControllers } = require("../utils/ratingCRUD");
+
+module.exports = crudControllers(Rating);

starter-project-backend-g32/src/models/rating.js

@@ -0,0 +1,24 @@
+const mongoose = require("mongoose");
+
+const ratingSchema = mongoose.Schema({
+  stars: {
+    type: Number,
+    required: true,
+    min: [1, "rating too low"],
+    max: [5, "rating too high"],
+  },
+  article: {
+    type: mongoose.Types.ObjectId,
+    ref: "Article",
+    required: true
+  },
+  user: {
+    type: mongoose.Types.ObjectId,
+    ref: "User",
+    required: true
+  },
+});
+
+const Rating = mongoose.model("Rating", ratingSchema);
+
+module.exports = Rating;

starter-project-backend-g32/src/routes/rating.routes.js

@@ -0,0 +1,13 @@
+const express = require('express')
+const router = express.Router()
+const ratingController = require('../controllers/rating.controller')
+
+
+router.route('/').get(ratingController.getMany)
+router.route('/').post(ratingController.createOne)
+
+router.route('/:id').get(ratingController.getOne)
+router.route('/:id').put(ratingController.updateOne)
+router.route('/:id').delete(ratingController.removeOne)
+
+module.exports = router

starter-project-backend-g32/src/server.ts

@@ -2,7 +2,7 @@ import app from "./app"
 import mongoose from 'mongoose';
 
 const PORT = process.env.PORT || 8000
-const DB_URI = process.env.MONGO_URI || "mongodb://localhost:27017/usersdb";
+const DB_URI = process.env.MONGO_URI || "mongodb://localhost:27017/blog";
 mongoose.connect(DB_URI, {
     useNewUrlParser: true,
     useUnifiedTopology: true,

starter-project-backend-g32/src/tests/__tests__/rating.test.ts

@@ -0,0 +1,72 @@
+import supertest from 'supertest';
+import {MongoMemoryServer} from "mongodb-memory-server";
+import app from "../../app"
+const mongoose = require('mongoose');
+
+// payloads For all the tests
+const ratingPayload = {
+    "stars" : 5,
+    "article": "62d510eaf474e57abb69067e",
+    "user": "62d502a8fea5ce18b53f1240"
+}
+
+const wrongRatingPayload = {
+    "stars" : 5,
+    "article": "62d510eaf474e57abb69067e",
+}
+
+describe.only('Rating', ()=> {
+    beforeAll(async () => {
+        const mongoServer = await MongoMemoryServer.create();
+
+        await mongoose.connect(mongoServer.getUri());
+    });
+
+    afterAll(async () => {
+        await mongoose.disconnect();
+        await mongoose.connection.close();
+    });
+    describe('get Rating routes', ()=>{
+        describe('given the rating does not exist', () => {
+            it('should return a 404.', async () => {
+                const ratingId = new mongoose.Types.ObjectId('62d9bb72804a5a74621f838a');
+                await supertest(app).get(`/api/v1/rating/${ratingId}`).expect(404);
+            });
+        });
+
+        describe('given the rating does exist', () => {
+            it('should return a 200 and the rating info.', async () => {
+                //First lets create a rating
+                const {statusCode, body } = await supertest(app).post(`/api/v1/rating`).send(ratingPayload);
+                expect(statusCode).toBe(201);
+
+                const ratingId = body.data._id;
+                await supertest(app).get(`/api/v1/rating/${ratingId}`).expect(200);
+            });
+        });
+    });
+
+    describe('create Rating routes', ()=>{
+        describe('given the rating body is passed correctly', () => {
+            it('should return a 200 and create the rating.', async () => {
+                const {statusCode, body } = await supertest(app).post(`/api/v1/rating`).send(ratingPayload);
+                expect(statusCode).toBe(201);
+                const data = body.data;
+
+                expect(Object.keys(data).length).toEqual(5);
+                // expect(data).toEqual(expect.objectContaining({
+                //     __v: expect.any(Number),
+                //     _id: expect.any(String),
+                //     article: expect.any(String),
+                //     starts: expect.any(Number),
+                //     user: expect.any(String)
+                //     }))
+            });
+        });
+        describe('given the rating request body is passed incorrectly', () => {
+            it('should return a 400.', async () => {
+                await supertest(app).post(`/api/v1/rating`).send(wrongRatingPayload).expect(400);
+            });
+        });
+    });
+});

starter-project-backend-g32/src/utils/ratingCRUD.js

@@ -0,0 +1,86 @@
+const getOne = (model) => async (req, res) => {
+    try {
+      const doc = await model.findOne({ _id: req.params.id }).lean().exec();
+
+      if (!doc) {
+        return res.status(404).end();
+      }
+
+      res.status(200).json({ data: doc });
+    } catch (e) {
+      console.error(e);
+      res.status(400).end();
+    }
+  };
+
+  const getMany = (model) => async (req, res) => {
+    try {
+      const docs = await model.find().lean().exec();
+
+      res.status(200).json({ data: docs });
+    } catch (e) {
+      console.error(e);
+      res.status(400).end();
+    }
+  };
+
+  const createOne = (model) => async (req, res) => {
+    try {
+      const doc = await model.create({ ...req.body });
+      res.status(201).json({ data: doc });
+    } catch (e) {
+      console.error(e);
+      res.status(400).end();
+    }
+  };
+
+  const updateOne = (model) => async (req, res) => {
+    try {
+      const updatedDoc = await model
+        .findOneAndUpdate(
+          {
+            _id: req.params.id,
+          },
+          req.body,
+          { new: true }
+        )
+        .lean()
+        .exec();
+
+      if (!updatedDoc) {
+        return res.status(404).end();
+      }
+
+      res.status(200).json({ data: updatedDoc });
+    } catch (e) {
+      console.error(e);
+      res.status(400).end();
+    }
+  };
+
+  const removeOne = (model) => async (req, res) => {
+    try {
+      const removed = await model.findOneAndRemove({
+        _id: req.params.id,
+      });
+
+      if (!removed) {
+        return res.status(404).end();
+      }
+
+      return res.status(200).json({ data: removed });
+    } catch (e) {
+      console.error(e);
+      res.status(400).end();
+    }
+  };
+
+  const crudControllers = (model) => ({
+    removeOne: removeOne(model),
+    updateOne: updateOne(model),
+    getMany: getMany(model),
+    getOne: getOne(model),
+    createOne: createOne(model),
+  });
+
+  module.exports = { crudControllers };