AbrarNa'im

server/.env

@@ -0,0 +1,3 @@
+PORT=3000
+RAHASIA='nami<==**'
+SALT=10

server/.gitignore

@@ -0,0 +1 @@
+node_modules

server/app.js

@@ -0,0 +1,16 @@
+require('dotenv').config()
+
+const express = require('express')
+const app = express()
+const port = process.env.PORT
+const routers = require('./routes')
+const errorHandler = require('./middlewares/errorHandler.js')
+
+app.use(express.json())
+app.use(express.urlencoded({extended: true}))
+app.use(routers)
+app.use(errorHandler)
+
+app.listen(port, ()=>{
+    console.log(`Let's Go to app FancyTodo http://localhost:${port}`)
+})

server/config/config.json

@@ -0,0 +1,23 @@
+{
+  "development": {
+    "username": "postgres",
+    "password": "postgres",
+    "database": "FancyTodo",
+    "host": "127.0.0.1",
+    "dialect": "postgres"
+  },
+  "test": {
+    "username": "postgres",
+    "password": null,
+    "database": "FancyTodo",
+    "host": "127.0.0.1",
+    "dialect": "postgres"
+  },
+  "production": {
+    "username": "root",
+    "password": null,
+    "database": "database_production",
+    "host": "127.0.0.1",
+    "dialect": "mysql"
+  }
+}

server/controller/todo-controller.js

@@ -0,0 +1,113 @@
+const {Todo} = require ('../models')
+const Super = require('../helper/super.js')
+
+class TodoController{
+
+    static async getTodo(req, res, next){
+        try {
+            let data = await Todo.findAll({
+                where: {UserId: req.key.id}
+            })
+            res.status(200).json(data)
+        } catch (err) {
+            next(err)
+        }
+    }
+
+    static async postTodo(req, res, next){
+        try {
+            let dataInput = req.body
+            let validasiError = Super.validasiPutTodo(dataInput)
+            if(validasiError.length>0){
+                let error ={
+                    cek: 'postTodo',
+                    status: 400,
+                    msg: validasiError,
+                }
+                next(error)
+            }else{
+                dataInput.UserId = req.key.id
+                let data = await Todo.create(dataInput)
+                res.status(201).json(data)
+            }
+        } catch (err) {
+            next(err)
+        }
+    }
+
+    static async getTodoById(req, res, next){
+        try {
+            let id = +req.params.id
+            let data = await Todo.findByPk(id)
+            res.status(200).json(data)
+        } catch (err) {
+           next(err)
+        }
+    }
+
+    static async putTodo(req, res, next){
+        try {
+            let id = +req.params.id
+            let dataInput = req.body
+
+            let validasiError = Super.validasiPutTodo(dataInput)
+            if(validasiError.length>0){
+                let error ={
+                    cek: 'postTodo',
+                    status: 400,
+                    msg: validasiError,
+                }
+                next(error)    
+            }else{
+                if(!dataInput.status){
+                    dataInput.status = 'not done'
+                }
+                let data = await Todo.update(dataInput, {
+                    where: {id}
+                })
+                res.status(200).json(dataInput)
+            }
+        } catch (err) {
+            next(err)
+        }
+    }
+
+    static async patchTodo(req, res, next){
+        try {
+            let id = +req.params.id
+            let dataInput = req.body.status
+            let data = Todo.findByPk(id)
+            data.status = dataInput
+            Todo.update(data, {
+                where: {id}
+            })
+            res.status(200).json(data)
+        } catch (err) {
+            next(err)
+        }
+    }
+
+    static async deleteTodo(req, res, next){
+        try {
+            let id = +req.params.id
+            let data = await Todo.destroy({
+                where: {id}
+            })
+            if(data===0){
+                let errMess = {
+                    massage: 'Id Tidak ditemukan'
+                }
+                res.status(400).json(errMess)
+            }else{
+                let output = {
+                    massage: 'todo succes to delete'
+                }
+                res.status(200).json(output)
+            }
+        } catch (err) {
+            next(err)
+        }
+    }
+}
+
+module.exports = TodoController

server/controller/user-controller.js

@@ -0,0 +1,52 @@
+const {User} = require('../models')
+const Super = require('../helper/super.js')
+
+class UserController{
+    static async register(req, res){
+        try {
+            let dataBody =  req.body
+            console.log(dataBody, 'benar' )
+            let newData = Super.validasiRegister(dataBody.password)
+            let dataUpuser = {
+                email: dataBody.email,
+                password: newData.password
+            }
+            let data = await User.create(dataUpuser)
+            let postData = {
+                id: data.id,
+                email: data.email
+            }
+            res.status(201).json(postData)
+        } catch (err) {
+            console.log(err, 'err')
+            res.status(400).json(err)
+        }
+    }
+
+    static async login(req, res){
+        try {
+            let dataBody = req.body
+            let dataBaseUsers = await User.findOne({
+                where: {email: dataBody.email}
+            })
+            if(!dataBaseUsers){
+                res.status(401).json({error: 'Email atau Password anda tidak Valid 1'})
+            }else if(!Super.validasiLoginUser(dataBody.password, dataBaseUsers.password)){
+                res.status(401).json({error: 'Email atau Password anda tidak Valid 2'})
+            }else{
+                let dataUser = {
+                    id: dataBaseUsers.id,
+                    email: dataBaseUsers.email
+                }
+                let userToken = Super.tokenUser(dataUser)
+                dataUser.token = userToken
+                res.status(200).json(dataUser)
+            }
+        } catch (err) {
+            res.status(400).json(err)
+        }
+    }
+}
+
+
+module.exports = UserController

server/ctt.txt

@@ -0,0 +1,11 @@
+[email protected]
+abrarnaim
+
+[email protected]
+nami
+
+[email protected]
+nana
+
+[email protected]
+yuke

server/helper/super.js

@@ -0,0 +1,46 @@
+const bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken')
+
+class Super {
+
+    static validasiPutTodo(data){
+        let dataEror = ''
+        for(let i in data){
+            if(i !== 'status'){
+                if(!data[i]){
+                    let output = `${i} Tidak boleh kosong - `
+                    dataEror += output
+                }
+            }
+        }
+
+        return dataEror
+    }
+
+    static validasiRegister(data){
+        const salt = bcrypt.genSaltSync(+process.env.SALT);
+        const hash = bcrypt.hashSync(data, salt);
+
+        return {
+            password: hash
+        }
+    }
+
+    static validasiLoginUser(passLogin, passDB){
+        return bcrypt.compareSync(passLogin, passDB)
+    }
+
+    static tokenUser(data){
+        const token = jwt.sign(data, process.env.RAHASIA)
+        return token
+    }
+
+    static cekToken(data){
+        var decoded = jwt.verify(data, process.env.RAHASIA);
+        return decoded
+        // console.log(decoded.foo)
+    }
+
+}
+
+module.exports = Super

server/middlewares/authentication.js

@@ -0,0 +1,26 @@
+const Super = require('../helper/super.js')
+const {User} = require('../models')
+
+const authentication = async (req, res, next)=>{
+    // console.log(req.headers)
+    let token = req.headers.token
+    try {
+        if(!token){
+            throw({msg: 'invalid token', status: 401})
+        }else{
+            let cekToken = Super.cekToken(token)
+            let dataUserDB = await User.findByPk(cekToken.id)
+
+            if(!dataUserDB){
+                throw({msg: 'invalid token', status: 401})
+            }else{
+                req.key = dataUserDB
+                next()
+            }
+        }
+    } catch (err) {
+        res.status(400).json(err)
+    }
+}
+
+module.exports = authentication

server/middlewares/authorization.js

@@ -0,0 +1,26 @@
+const {Todo} = require('../models')
+
+const authorization = async (req, res, next)=>{
+    try {
+        let dataTodo = await Todo.findOne({
+            where: {
+                id: +req.params.id
+            }
+        })
+        if(dataTodo.UserId===req.key.id){
+            next()
+        }else{
+            throw({msg: 'Unauthorized', status: 401})
+        }
+    } catch (err) {
+        // let error ={
+        //     name: 'suthorization',
+        //     status: 400,
+        //     msg: 'Unauthorized'
+        // }
+        next(err)
+    }
+
+} 
+
+module.exports = authorization

server/middlewares/errorHandler.js

@@ -0,0 +1,13 @@
+module.exports = (err, req, res, next) =>{
+    let status
+    let msg 
+    if(!err.cek){
+        status = 500
+        msg = 'Internal Server Error, try again leter'
+    }else{
+        status = err.status
+        msg = err.msg
+    }
+
+    res.status(status).json({msg})
+}

server/migrations/20201026063326-create-todo.js

@@ -0,0 +1,36 @@
+'use strict';
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('Todos', {
+      id: {
+        allowNull: false,
+        autoIncrement: true,
+        primaryKey: true,
+        type: Sequelize.INTEGER
+      },
+      title: {
+        type: Sequelize.STRING
+      },
+      description: {
+        type: Sequelize.STRING
+      },
+      status: {
+        type: Sequelize.STRING
+      },
+      dueDate: {
+        type: Sequelize.DATE
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE
+      }
+    });
+  },
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('Todos');
+  }
+};