init source

src/server/config/config.json

@@ -0,0 +1,26 @@
+{
+  "development": {
+    "username": "savvy",
+    "password": "savvy001!",
+    "database": "savvy",
+    "host": "postgres",
+    "port": 5432,
+    "dialect": "postgres"
+  },
+  "test": {
+    "username": "savvy",
+    "password": "savvy001!",
+    "database": "savvy",
+    "host": "postgres",
+    "port": 5432,
+    "dialect": "postgres"
+  },
+  "production": {
+    "username": "savvy",
+    "password": "savvy001!",
+    "database": "savvy",
+    "host": "postgres",
+    "port": 5432,
+    "dialect": "postgres"
+  }
+}

src/server/controllers/index.js

@@ -0,0 +1,5 @@
+const member = require("./member");
+
+module.exports = {
+  member
+};

src/server/controllers/member.js

@@ -0,0 +1,112 @@
+var Sequelize = require('sequelize');
+const nodemailer = require('nodemailer');
+const { body, validationResult } = require('express-validator');
+
+const member = require("../models").member;
+const memberServices = require("../services").members;
+module.exports = {
+  validate(method) {
+    switch (method) {
+      case 'createUser':
+        {
+          return [
+            body('username', 'userName doesn\'t exists').exists(),
+            body('email', 'Invalid email').exists().isEmail(),
+            body('phone').optional().isInt()
+          ]
+        }
+    }
+  },
+  register(req, res) {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+      console.log(errors)
+      return res.status(400).json({ errors: errors.array() });
+    }
+
+    return memberServices.create(req)
+      .then(member => res.status(200).send("Register successfully"))
+      .catch(error => res.status(400).send(error.errors));
+  },
+
+  async login(req, res) {
+    return memberServices.login(req)
+      .then(accessToken => res.status(200).send(accessToken))
+      .catch(error => res.status(400).send(error.errors));
+  },
+
+  profile(req, res) {
+    memberServices.getProfile(req)
+      .then(member => res.status(200).send(member))
+      .catch(error => res.status(400).send(error.errors));
+  },
+
+  async forgotPassword(req, res) {
+    try {
+      const email = req.body.email;
+      const user = await member.findOne({
+        where: { username: email }
+      });
+      if (user) {
+        return res.status(200).send('Please check email');
+      } else {
+        res.send("Email doen't exist");
+      }
+    } catch (error) {
+      console.log(error);
+      res.status(500).send("Internal Server error Occured");
+    }
+  },
+
+  async resetPassword(req, res) {
+    const email = req.body.email;
+    const user = await member.findOne({
+      where: { username: email }
+    });
+    const salt = await bcrypt.genSaltSync(10);
+    const password = bcrypt.hashSync(req.body.password, salt);
+    user.password = password;
+    user.save();
+    res.status(200).send(user.email);
+    return member
+      .update({
+        password: password
+      }, { returning: true, where: { id: user.id } })
+      .then(([rowsUpdate, [updatedRow]]) => res.status(200).send(updatedRow))
+      .catch(error => res.status(400).send(error));
+  },
+
+  update(req, res) {
+    return member
+      .update({
+        name: req.body.name,
+        size: req.body.size,
+        price: req.body.price,
+        status: req.body.status
+      }, { returning: true, where: { id: req.params.id } })
+      .then(([rowsUpdate, [updatedRow]]) => res.status(200).send(updatedRow))
+      .catch(error => res.status(400).send(error));
+  },
+
+  delete(req, res) {
+    return member
+      .destroy({
+        where: {
+          id: req.params.id
+        }
+      })
+      .then(rowDeleted => {
+        if (rowDeleted !== 1) {
+          throw ({
+            "name": "ValidationError",
+            "errors": [{
+              message: 'Item not found'
+            }]
+          });
+        }
+        return res.status(200).json({ message: "Deleted successfully" });
+      })
+      .catch(error => res.status(400).send(error));
+  }
+
+};

src/server/migrations/20191012205040-create-order-item.js

@@ -0,0 +1,33 @@
+'use strict';
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.createTable('orderItems', {
+      id: {
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+        type: Sequelize.INTEGER
+      },
+      orderId: {
+        type: Sequelize.INTEGER
+      },
+      itemId: {
+        type: Sequelize.INTEGER
+      },
+      quantity: {
+        type: Sequelize.INTEGER
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      }
+    });
+  },
+  down: (queryInterface, Sequelize) => {
+    return queryInterface.dropTable('orderItems');
+  }
+};

src/server/models/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Sequelize = require('sequelize');
+const basename = path.basename(__filename);
+const env = process.env.NODE_ENV || 'development';
+const config = require(__dirname + '/../config/config.json')[env];
+const db = {};
+
+let sequelize;
+if (config.use_env_variable) {
+  sequelize = new Sequelize(process.env[config.use_env_variable], config);
+} else {
+  sequelize = new Sequelize(config.database, config.username, config.password, config);
+}
+
+fs
+  .readdirSync(__dirname)
+  .filter(file => {
+    return (file.indexOf('.') !== 0) && (file !== basename) && (file.slice(-3) === '.js');
+  })
+  .forEach(file => {
+    const model = sequelize['import'](path.join(__dirname, file));
+    db[model.name] = model;
+  });
+
+Object.keys(db).forEach(modelName => {
+  if (db[modelName].associate) {
+    db[modelName].associate(db);
+  }
+});
+
+db.sequelize = sequelize;
+db.Sequelize = Sequelize;
+
+module.exports = db;

src/server/models/member.js

@@ -0,0 +1,64 @@
+'use strict';
+module.exports = (sequelize, DataTypes) => {
+  const member = sequelize.define('member', {
+    email: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: {
+        msg: 'This email is already taken.'
+      },
+      validate: {
+        isEmail: {
+          msg: 'Email address must be valid.'
+        }
+      }
+    },
+    username: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: {
+        msg: 'This username is already taken.'
+      },
+      validate: {
+        len: {
+          args: [5, 50],
+          msg: 'Your username may be 5 to 50 characters only.'
+        }
+      }
+    },
+    password: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      validate: {
+        len: {
+          args: [5, 72],
+          msg: 'Your password may be 5 to 72 characters only.'
+        }
+      }
+    },
+    firstname: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      validate: {
+        len: {
+          args: [5, 50],
+          msg: 'Your first name may be 5 to 50 characters only.'
+        }
+      }
+    },
+    lastname: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      validate: {
+        len: {
+          args: [5, 50],
+          msg: 'Your last name may be 5 to 50 characters only.'
+        }
+      }
+    },
+  }, {});
+  member.associate = function (models) {
+    // associations
+  };
+  return member;
+};

src/server/routes/index.js

@@ -0,0 +1,17 @@
+const memberController = require("../controllers").member;
+
+module.exports = app => {
+  app.get("/api", (req, res) =>
+    res.status(200).send({
+      message: "Welcome to the Pizza API!"
+    })
+  );
+
+  app.post("/api/v1/user/register", memberController.register);
+  app.put("/api/v1/user/login", memberController.login);
+  app.get("/api/v1/user/forgot-password", memberController.forgotPassword);
+  app.get("/api/v1/user/reset-password", memberController.resetPassword);
+  app.delete("/api/v1/user/profile", memberController.profile);
+
+
+};

src/server/services/index.js

@@ -0,0 +1,5 @@
+const member = require("./user/members");
+
+module.exports = {
+  member
+};

src/server/services/user/members.js

@@ -0,0 +1,60 @@
+const member = require("../../models").member;
+
+const jwt = require('jsonwebtoken');
+var bcrypt = require('bcrypt');
+
+module.exports = {
+  async create(req) {
+    console.log(req.body)
+    const { username, password, firstname, lastname, phone, email } = req.body;
+    const user = {
+      username: username,
+      password: password,
+      firstname: firstname,
+      lastname: lastname,
+      phone: phone,
+      email: email
+    }
+    return await member.create(user);
+  },
+  async login(req) {
+    try {
+      const user = await member.findOne({
+        where: { username: req.body.username }
+      });
+      if (user) {
+        const cmp = await bcrypt.compare(req.body.password, user.password);
+
+        if (cmp) {
+          user.last_login = Date.now()
+          user.save()
+          console.log(user)
+          const token = jwt.sign({
+            username: user.username
+          },
+            process.env.TOKEN_SECRET, { expiresIn: process.env.TOKEN_EXPIRES }
+          );
+          console.log(token)
+          return {
+            accessToken: token
+          };
+        } else {
+          return "Wrong username or password.";
+        }
+      } else {
+        return "Wrong username or password.";
+      }
+    } catch (error) {
+      return "Internal Server error Occured";
+    }
+  },
+  async getProfile(req) {
+    const username = req.user.username;
+    return await member.findOne({
+      where: { username: username },
+      attributes: ['username', 'email', 'phone', 'firstname', 'lastname']
+    });
+  }
+
+
+}