Ashref RESTFUL-API

api/controllers/item.js

@@ -0,0 +1,110 @@
+const mongoose = require('mongoose');
+const item = require('../models/item');
+
+exports.getAllitems = (req, res, next) => {
+	item
+		.find()
+		.exec()
+		.then(items => {
+			const response = {
+				count: items.length,
+				items: items.map(item => {
+					return {
+						_id: item._id,
+						name: item.name,
+						image: item.image,
+						category_id: item.category_id
+					}
+				})
+			};
+			res.status(200).json(response);
+		})
+		.catch(error => {
+			next(error);
+		})
+};
+
+exports.createOneitem = (req, res, next) => {
+	const item = createitem(req);
+
+	item
+		.save()
+		.then(item => {
+			res.status(200).json({
+				message: 'item Created Successfully!',
+				item: {
+					_id: item._id,
+					name: item.name,
+					image: item.image,
+					category_id: item.category_id
+				}
+			});
+		})
+		.catch(error => {
+			next(error);
+		});
+};
+
+exports.getOneitem = (req, res, next) => {
+	const id = req.params.itemId;
+	item
+		.findById(id)
+		.select('_id name image image')
+		.exec()
+		.then(item => {
+			if (item) {
+				res.status(200).json(item);
+			}
+			else {
+				res.status(404).json({
+					message: 'item Not Found!'
+				});
+			}
+		})
+		.catch(error => {
+			next(error);
+		});
+};
+
+exports.updateOneitem = (req, res, next) => {
+	const itemId = req.params.itemId;
+
+
+	item
+		.update({ _id: itemId }, { $set: req.body })
+		.exec()
+		.then(result => {
+			res.status(200).json({
+				message: 'Updated item Successfully!',
+				result: result
+			});
+		})
+		.catch(error => {
+			next(error);
+		})
+};
+
+exports.deleteOneitem = (req, res, next) => {
+	const itemId = req.params.itemId;
+	item
+		.remove({ _id: itemId })
+		.exec()
+		.then(result => {
+			res.status(200).json({
+				message: 'Deleted item Successfully!',
+				result: result
+			});
+		})
+		.catch(error => {
+			next(error);
+		});
+};
+
+function createitem(req) {
+	return new item({
+		_id: new mongoose.Types.ObjectId(),
+		name: req.body.name,
+		image: req.body.image,
+		image: req.file.path
+	});
+}

api/controllers/user.js

@@ -0,0 +1,96 @@
+const mongoose = require('mongoose');
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+
+const User = require('../models/user');
+
+exports.signUp = (req, res, next) => {
+    User
+        .find({ email: req.body.email })
+        .exec()
+        .then(user => {
+            if (user.length < 1) {
+                return bcrypt.hash(req.body.password, 10);
+            }
+            const error = new Error();
+            error.message = 'User Exists!';
+            throw error;
+        })
+        .then(hash => {
+            const user = createUser(req.body.email, hash);
+            return user.save();
+        })
+        .then(result => {
+            return res.status(201).json({
+                message: 'User created successfully!'
+            })
+        })
+        .catch((error) => {
+            next(error);
+        });
+};
+
+exports.logIn = (req, res, next) => {
+    let email = undefined, userId = undefined;
+    User
+        .find({ email: req.body.email })
+        .exec()
+        .then(user => {
+            if (user.length < 1) {
+                const error = new Error();
+                error.message = 'Auth Failed!';
+                throw error;
+            }
+            email = user[0].email;
+            userId = user[0]._id;
+            return bcrypt.compare(req.body.password, user[0].password);
+        })
+        .then(result => {
+            if (result) {
+                const token = jwt.sign(
+                    {
+                        email: email,
+                        userId: userId
+                    },
+                    process.env.JWT_KEY,
+                    {
+                        expiresIn: "1h"
+                    }
+                );
+                return res.status(200).json({
+                    message: 'Auth Successful!',
+                    token: token
+                });
+            }
+            const error = new Error();
+            error.message = 'Auth Failed!';
+            throw error;
+        })
+        .catch(error => {
+            next(error);
+        });
+};
+
+exports.deleteUser = (req, res, next) => {
+    const userId = req.params.userId;
+    User
+        .remove({ _id: userId })
+        .exec()
+        .then(result => {
+            res.status(200).json({
+                message: 'User Deleted Successfully!'
+            });
+        })
+        .catch(error => {
+            error.message = 'Could Not Delete User!';
+            next(error);
+        });
+};
+
+function createUser(email, hash) {
+    return new User({
+        _id: new mongoose.Types.ObjectId(),
+        email: email,
+        password: hash
+    });
+}

api/middleware/check-auth.js

@@ -0,0 +1,35 @@
+const jwt = require('jsonwebtoken');
+
+module.exports = (req, res, next) => {
+    try {
+        if (req.headers.authorization) {
+            const token = req.headers.authorization.split(" ")[1];
+            if (token) {
+                const decodedToken = jwt.verify(token, process.env.JWT_KEY);
+                req.userData = decodedToken;
+                next();
+            }
+            else {
+                handleError(null, next);
+            }
+        }
+        else {
+            handleError(null, next);
+        }
+    }
+    catch (error) {
+        handleError(error, next);
+    }
+};
+
+function handleError(error, next) {
+    if (error) {
+        error.message = 'Auth Failed!!!';
+        next(error);
+    }
+    else {
+        const error = new Error();
+        error.message = 'Auth Failed!!';
+        next(error);
+    }
+}

api/models/item.js

@@ -0,0 +1,10 @@
+const mongoose = require('mongoose');
+
+const itemSchema = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: { type: String, required: true },
+    category_id: { type: Number, required: true },
+    image: { type: String }
+});
+
+module.exports = mongoose.model('item', itemSchema);

api/models/user.js

@@ -0,0 +1,14 @@
+const mongoose = require('mongoose');
+
+const userSchema = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    email: {
+        type: String,
+        required: true,
+        unique: true,
+        match: /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/
+    },
+    password: { type: String, required: true }
+});
+
+module.exports = mongoose.model('User', userSchema);

api/routes/item.js

@@ -0,0 +1,36 @@
+const express = require('express');
+const router = express.Router();
+const multer = require('multer');
+
+const checkAuth = require('../middleware/check-auth');
+
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, 'uploads/');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    }
+});
+
+const itemsController = require('../controllers/items');
+
+router.get('/', checkAuth, itemsController.getAllitems);
+
+router.post('/', checkAuth, upload.single('itemImage'), itemsController.createOneitem);
+
+router.get('/:itemId', checkAuth, itemsController.getOneitem);
+
+router.patch('/:itemId', checkAuth,  itemsController.updateOneitem);
+
+router.delete('/:itemId', checkAuth, itemsController.deleteOneitem);
+
+module.exports = router;

api/routes/user.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+const checkAuth = require('../middleware/check-auth');
+
+const UserController = require('../controllers/user');
+
+router.post('/signup', UserController.signUp);
+
+router.post('/login', UserController.logIn);
+
+router.delete('/:userId', checkAuth, UserController.deleteUser)
+
+module.exports = router;

app.js

@@ -0,0 +1,53 @@
+const express = require('express');
+const morgan = require('morgan');
+const bodyParser = require('body-parser');
+const mongoose = require('mongoose');
+
+const itemRoutes = require('./api/routes/items');
+const orderRoutes = require('./api/routes/orders');
+const userRoutes = require('./api/routes/user');
+
+mongoose.connect(process.env.MONGO_URL_DEV);
+
+const app = express();
+// Log request data
+app.use(morgan('dev'));
+
+// Setup static files path
+app.use('/uploads', express.static('uploads'));
+
+// Use body parser middleware to parse body of incoming requests
+app.use(bodyParser.urlencoded({ extended: false }));
+app.use(bodyParser.json());
+
+// Setup CORS
+app.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+    if (req.method === 'OPTIONS') {
+        res.header('Access-Control-Allow-Methods', 'PUT, POST, PATCH, DELETE, GET');
+        return res.status(200).json({});
+    }
+    next();
+});
+
+// Routes which should handle requests
+app.use('/items', itemRoutes);
+app.use('/orders', orderRoutes);
+app.use('/user', userRoutes);
+
+// Handle Error Requests
+app.use((req, res, next) => {
+    const error = new Error();
+    error.message = 'Not Found';
+    error.status = 404;
+    next(error);
+});
+
+app.use((error, req, res, next) => {
+    res.status(error.status || 500).json({
+        error: error
+    });
+});
+
+module.exports = app;

nodemon.json

@@ -0,0 +1,7 @@
+{
+    "env": {
+        "MONGO_URL_DEV": "mongodb://127.0.0.1:27017/node-rest-shop",
+        "MONGO_URL_PROD": "",
+        "JWT_KEY": "dmp42dsokcmXkda@gjC"
+    }
+}