assignment 1

Middlewares/tokenVerif.js

@@ -0,0 +1,14 @@
+const jwt=require("jsonwebtoken");
+const secret=process.env.SECRET || 'secret';
+
+const verifyToken = (req, res, next) => {
+  try {
+    let decodedToken=jwt.verify(req.get('Authorization'), secret);
+    req.decodedToken=decodedToken;
+    next();
+  } catch (error) {
+   res.status(401).send({status:401,message:"Unauthorized"});
+  }
+}
+
+module.exports=verifyToken;

Models/category.model.js

@@ -0,0 +1,22 @@
+const mongoose=require('mongoose');
+
+const categorySchema=mongoose.Schema({
+    name:String,
+    user_id:{
+        type:mongoose.Schema.Types.ObjectId,
+        ref:'users'
+    },
+     createdAt:{
+        type:Date,
+        default:Date.now()
+
+    },
+    updatedAt:{
+        type:Date,
+        default:Date.now()
+    }
+
+
+})
+
+module.exports=mongoose.model('category',categorySchema)

Models/item.model.js

@@ -0,0 +1,36 @@
+const mongoose=require('mongoose');
+
+const itemSchema=mongoose.Schema({
+
+    name:String,
+    user_id:{
+        type:mongoose.Schema.Types.ObjectId,
+        ref:'users'
+
+    },
+    category_id:{
+        type:mongoose.Schema.Types.ObjectId,
+        ref:'categorys'
+    },
+    note:String
+
+
+    ,
+    image:String,
+
+    createdAt:{
+        type:Date,
+        default:Date.now()
+
+    },
+    updatedAt:{
+        type:Date,
+        default:Date.now()
+    }
+});
+itemSchema.post('remove',itemId=>{
+ let cleanUp=require("../middlewares/cleanUp");
+ cleanUp(itemId._id);
+
+})
+module.exports=mongoose.model('item',itemSchema)

Models/list.model.js

@@ -0,0 +1,23 @@
+const mongoose=require('mongoose');
+
+const listSchema=mongoose.Schema({
+    name:{
+        type:String,
+        required:true
+    },
+    user_id:{
+        type:mongoose.Schema.Types.ObjectId,
+        ref:'users'
+    },
+    createdAt:{
+        type:Date,
+        default:Date.now()
+    },
+    updatedAt:{
+        type:Date,
+        default:Date.now()
+    },
+    items:[{type:mongoose.Schema.Types.ObjectId,ref:'items'}]
+
+})
+module.exports=mongoose.model('list',listSchema);

Models/user.model.js

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+
+const userSchema=new mongoose.Schema({
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+    trim: true,
+    lowercase: true,
+  },
+
+  password: {
+    type: String,
+    required: true,
+    trim: true,
+  },
+  userName: { type: String, required: true, trim: true },
+});
+
+module.exports=mongoose.model('user',userSchema);

Routes/auth.js

@@ -0,0 +1,36 @@
+const Router = require('express').Router;
+const userService=require("../services/user.service");
+const verifyToken=require("../middlewares/verifyToken");
+const router = Router({
+    mergeParams: true
+  });
+router.post("/login",async (req,res)=>{
+  try {
+  const result=await userService.login(req.body.email,req.body.password);
+  if(result)
+  res.status(201).send(result);
+  } catch (error) {
+    res.send(error);
+  }
+
+
+})
+router.post("/register",async (req,res)=>{
+  try {
+    await userService.register({email:req.body.email,password:req.body.password,userName:req.body.userName})
+    res.sendStatus(201);
+  } catch (error) {
+    res.send(error);
+  }
+
+})
+router.get("/getUser",verifyToken,async(req,res)=>{
+  console.log(req.decodedToken);
+  try {
+      const result=await userService.getUser(req.decodedToken.id);
+      res.status(200).send(result);
+  } catch (error) {
+    res.send(error);
+  }
+})
+module.exports=router;

Routes/category.js

@@ -0,0 +1,50 @@
+const Router = require('express').Router;
+
+const verifyToken=require("../middlewares/verifyToken");
+const cateogyService=require("../services/category.service");
+const router = Router({
+    mergeParams: true
+  });
+router.post("/categories",verifyToken,async(req,res)=>{
+  try {
+    const result=await cateogyService.addCategory(req.body,req.decodedToken.id);
+    res.send(result);
+  } catch (error) {
+    res.send(error);
+  }
+
+})
+
+router.get("/categories",verifyToken,async(req,res)=>{
+  try {
+    const result=await cateogyService.getCategory(req.decodedToken.id);
+  res.status(201).send(result);
+  } catch (error) {
+    res.send(error);
+  }
+
+})
+router.put("/categories/:categoryId",verifyToken,async(req,res)=>{
+  try {
+    const result=await cateogyService.changeCategory(req.params.categoryId,req.body);
+  res.send(result);
+  } catch (error) {
+    res.send(error);
+  }
+
+})
+
+router.delete("/categories/:categoryId",verifyToken,async(req,res)=>{
+  try {
+    const result=await cateogyService.deleteCategory(req.params.categoryId);
+  res.send(result);
+  } catch (error) {
+    res.send(error);
+  }
+
+})
+
+
+
+
+module.exports=router;

Routes/item.js

@@ -0,0 +1,49 @@
+const Router = require('express').Router;
+
+const verifyToken=require("../middlewares/verifyToken");
+const itemService=require("../services/item.service");
+const router = Router({
+    mergeParams: true
+  });
+router.post('/items',verifyToken,async(req,res)=>{
+  try {
+    await itemService.addItem(req.body,req.decodedToken.id);
+    res.send("ok");
+  } catch (error) {
+    res.send(error)
+  }
+
+})
+router.get('/items',verifyToken,async(req,res)=>{
+  try {
+    let items=await itemService.getItems(req.decodedToken.id);
+  res.send(items);
+  } catch (error) {
+        res.send(error)
+
+  }
+
+})
+
+router.put('/items/:item_id',verifyToken,async(req,res)=>{
+  try {
+     let item=await itemService.modifyItem(req.params.item_id,req.body);
+  res.send(item);
+  } catch (error) {
+        res.send(error)
+
+  }
+
+})
+router.delete('/items/:item_id',verifyToken,async(req,res)=>{
+  try {
+    await itemService.deleteItem(req.params.item_id);
+  res.sendStatus(200);
+  } catch (error) {
+        res.send(error)
+
+  }
+
+})
+
+  module.exports=router;

Routes/list.js

@@ -0,0 +1,78 @@
+const Router = require('express').Router;
+
+const verifyToken=require("../middlewares/verifyToken");
+const listService=require("../services/list.service");
+const router = Router({
+    mergeParams: true
+  });
+
+router.get('/lists',verifyToken,async(req,res)=>{
+
+  try {
+    const lists=await listService.getListByUserId(req.decodedToken.id);
+    res.status(201).send(lists);
+  }catch (error) {
+       res.send(error)
+
+  }
+});
+router.post('/lists',verifyToken,async(req,res)=>{
+  try {
+    await listService.addList(req.body,req.decodedToken.id);
+    res.sendStatus(201);
+  } catch (error) {
+     res.send(error);
+  }
+
+})
+router.put('/lists/:listId',verifyToken,async(req,res)=>{
+  try {
+     await listService.updateList(req.body,req.params.listId);
+  res.sendStatus(200);
+  } catch (error) {
+     res.send(error);
+  }
+
+})
+router.delete('/lists/:listId',verifyToken,async(req,res)=>{
+  try {
+     await listService.deleteList(req.params.listId);
+     res.sendStatus(200)
+  } catch (error) {
+      res.status(401);
+  }
+
+
+
+})
+router.get('/lists/:listId/items',async(req,res)=>{
+  try {
+     await listService.getItemsOfList(req.params.listId);
+  res.send("ok")
+  } catch (error) {
+     res.send(error);
+  }
+
+})
+
+router.post('/lists/:listId/items',async(req,res)=>{
+  try {
+    let result=await listService.addItemToList(req.params.listId,req.body.itemId);
+  res.send(result);
+  } catch (error) {
+     res.send(error);
+  }
+
+})
+
+router.put('/lists/:listId/items',async(req,res)=>{
+  try {
+     let {itemId,...rest}=req.body;
+  let result= await listService.updateItemFromList(req.params.listId,itemId,rest);
+  res.send(result);
+  } catch (error) {
+    res.send(error);
+  }
+
+})
+module.exports=router;

Services/category.service.js

@@ -0,0 +1,21 @@
+const Category=require("../models/category.model")
+
+module.exports={
+    addCategory:async(categoryInfo,user_id)=>{
+
+       let result= await Category.create({...categoryInfo,user_id});
+       return result
+    },
+    getCategory:async(user_id)=>{
+        let result=await Category.find({user_id});
+        return result;
+    },
+    changeCategory:async(categoryId,modifs)=>{
+        let result=await Category.findByIdAndUpdate(categoryId,{...modifs,updatedAt:Date.now()});
+        return result;
+    },
+    deleteCategory:async(categoryId)=>{
+        let result =await Category.findByIdAndDelete(categoryId);
+        return result;
+    }
+}

Services/item.service.js

@@ -0,0 +1,20 @@
+const Item=require("../models/item.model");
+
+
+module.exports={
+    addItem:async(itemInfo,user_id)=>{
+        //add item to current user
+        return await Item.create({...itemInfo,user_id});
+    },
+    getItems:async(user_id)=>{
+        return await Item.find({user_id});
+    },
+    modifyItem:async(itemId,update)=>{
+        return await Item.findByIdAndUpdate(itemId,{...update,updatedAt:Date.now()});
+    },
+    deleteItem:async(itemId)=>{
+        let item=await Item.findById(itemId);
+       return item.remove();
+    }
+
+}