Add files via upload

server/api/department.js

+const express = require('express');
+
+const router = express.Router();
+
+const queries = require('../db/queries');
+
+function isValidId(req, res, next) {
+    if(!isNaN(req.params.id)) return next();
+    next(new Error('Invalid ID'));
+}
+function validDepartment(department) {
+    const hasDepartmentname = typeof department.department_name == 'string' && department.department_name.trim() !='';
+    return hasDepartmentname;
+}
+
+
+router.get('/', (req, res) => {
+    queries.getAll().then(department => {
+        res.json(department);
+    });
+});
+
+router.get('/:id', isValidId, (req, res) => {
+    queries.getOne(req.params.id).then(department => {
+        res.json(department);  
+    });
+});
+
+router.post('/', (req, res, next) => {
+    if(validDepartment(req.body)) {
+        queries.create(req.body).then(department => {
+            res.json(department[0]);
+        });
+    } else {
+        next(new Error('invalid Department'));
+    }
+});
+
+router.put('/:id', isValidId, (req, res, next) => {
+    if(validDepartment(req.body)) {
+        queries.update(req.params.id, req.body).then(department => {
+            res.json(department);
+        });
+    } else {
+        next(new Error('Invalid Department'));
+    }
+});
+
+router.delete('/:id', isValidId, (req, res) => {
+    queries.delete(req.params.id).then(() => {
+        res.json({
+            deleted: true
+        })
+    });
+});
+
+module.exports = router; 
\ No newline at end of file

server/api/employee.js

+const express = require('express');
+
+const router = express.Router();
+
+const queries = require('../db/queries');
+
+function isValidId(req, res, next) {
+    if(!isNaN(req.params.id)) return next();
+    next(new Error('Invalid ID'));
+}
+function validEmployee(employee) {
+    const hasName = typeof employee.name == 'string' && employee.name.trim() !='';
+    const hasMobile = !isNaN(employee.mobile);
+    const hasEmail = typeof employee.email == 'string' && employee.email.trim() !='';
+    const hasDesignation = typeof employee.designation == 'string' && employee.designation.trim() !='';
+    const hasRole = typeof employee.role == 'string' && employee.role.trim() !='';
+    const hasType = typeof employee.type == 'string' && employee.type.trim() !='';
+    const hasDOJ = employee.date_of_joining.trim() !='';
+   // const hasDOB = typeof employee.date_of_birth == 'date' && employee.date_of_birth.trim() !='';
+    const hasAddress = typeof employee.address == 'string' && employee.address.trim() !='';
+    return hasName && hasMobile && hasEmail && hasDesignation && hasRole && hasType && hasDOJ && hasAddress;
+}
+
+
+router.get('/', (req, res) => {
+    queries.getAll().then(employee => {
+        res.json(employee);
+    });
+});
+
+router.get('/:id', isValidId, (req, res) => {
+    queries.getOne(req.params.id).then(employee => {
+        res.json(employee);  
+    });
+});
+
+router.post('/', (req, res, next) => {
+    if(validEmployee(req.body)) {
+        queries.create(req.body).then(employee => {
+            res.json(employee[0]);
+        });
+    } else {
+        next(new Error('invalid Employee'));
+    }
+});
+
+router.put('/:id', isValidId, (req, res, next) => {
+    if(validEmployee(req.body)) {
+        queries.update(req.params.id, req.body).then(employee => {
+            res.json(employee);
+        });
+    } else {
+        next(new Error('Invalid Employee'));
+    }
+});
+
+router.delete('/:id', isValidId, (req, res) => {
+    queries.delete(req.params.id).then(() => {
+        res.json({
+            deleted: true
+        })
+    });
+});
+
+module.exports = router; 
\ No newline at end of file

server/app.js

+const createError = require('http-errors');
+const express = require('express');
+const path = require('path');
+const cookieParser = require('cookie-parser');
+const logger = require('morgan');
+const cors = require('cors'); 
+const app = express();
+const employee = require('./api/employee');
+const department = require('./api/department');
+
+app.use(logger('dev'));
+app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+app.use(cookieParser());
+app.use(cors());
+app.use('/api/employee', employee);
+app.use('/api/department', department);
+const port = process.env.PORT || 5000;
+
+//server starting
+app.get("/", (req, res) => {
+
+    res.status(200).send("Engine Started, Ready to take off!");
+
+})
+
+//configuring dotenv file
+require("./configs/dotenv");
+const client = require("./configs/database");
+
+client.connect((err) => { //Connected Database
+
+    if (err) {
+
+        console.log(err);
+
+    } else {
+
+        console.log("Data logging initiated!");
+    }
+
+});
+
+//routes to user.js
+const api = require("./routes/user");
+
+app.use("/api", api); //Route for /api endpoint of API
+
+//express....
+app.listen(port, () => {
+
+    console.log(`Here we go, Engines started at ${port}.`);
+
+})
+
+// catch 404 and forward to error handler
+app.use(function(req, res, next) {
+  next(createError(404));
+});
+
+// error handler
+app.use(function(err, req, res, next) {
+
+  // render the error page
+  res.status(err.status || 500);
+  res.json({
+     message: err.message,
+     error: req.app.get('env') === 'development' ? err : {} 
+
+  });
+});
+
+module.exports = app;

server/configs/database.js

+const { Client } = require("pg");
+
+const client = new Client(process.env.DB_URL); //Configuring PostgresSQL Database
+
+module.exports = client;
\ No newline at end of file

server/configs/dotenv.js

+if (process.env.NODE_ENV !== 'production') {
+
+    require('dotenv').config() //Configuring dotenv during development stage
+    
+    }
\ No newline at end of file

server/controllers/login.js

+const bcrypt = require("bcrypt");
+
+const client = require("../configs/database");
+
+const jwt = require("jsonwebtoken");
+
+//Login Function
+exports.login = async (req, res) => {
+
+    //Checking if User registered to our application or not
+    const {
+        email,
+        password
+    } = req.body;
+    try {
+        const data = await client.query(`SELECT * FROM users WHERE email= $1;`, [email]) //Verifying if the user exists in the database
+        const user = data.rows;
+        if (user.length === 0) {
+            res.status(400).json({
+                error: "User is not registered, Sign Up first",
+            });
+        }
+
+        //Comparing Hashed Password with User's Password
+        else {
+            bcrypt.compare(password, user[0].password, (err, result) => { //Comparing the hashed password
+                if (err) {
+                    res.status(500).json({
+                        error: "Server error",
+                    });
+                } else if (result === true) { //Checking if credentials match
+                    const token = jwt.sign({
+                            email: email,
+                        },
+                        process.env.SECRET_KEY
+                    );
+                    res.status(200).json({
+                        message: "User signed in!",
+                        token: token,
+                    });
+                }
+
+                //Handling Errors While Signing in the Users
+                else {
+                    //Declaring the errors
+                    if (result != true)
+                        res.status(400).json({
+                            error: "Enter correct password!",
+                        });
+                }
+            })
+        }
+    } catch (err) {
+        console.log(err);
+        res.status(500).json({
+            error: "Database error occurred while signing in!", //Database connection error
+        });
+    };
+};
\ No newline at end of file

server/controllers/register.js

+const bcrypt = require("bcrypt");
+
+const client = require("../configs/database");
+
+const jwt = require("jsonwebtoken");
+
+//Registration Function
+//Checking if user is already present in our database
+exports.register = async (req, res) => {
+    const {
+        name,
+        email,
+        role,
+        password
+    } = req.body;
+    try {
+        const data = await client.query(`SELECT * FROM users WHERE email= $1;`, [email]); //Checking if user already exists
+        const arr = data.rows;
+        if (arr.length != 0) {
+            return res.status(400).json({
+                error: "Email already there, No need to register again.",
+            });
+        } else {
+            //Hashing user's Password
+            bcrypt.hash(password, 10, (err, hash) => {
+                if (err)
+                    res.status(err).json({
+                        error: "Server error",
+                    });
+                const user = {
+                    name,
+                    email,
+                    role,
+                    password: hash,
+                };
+
+                //Inserting User's Information in our Database
+                var flag = 1; //Declaring a flag
+
+                //Inserting data into the database
+
+                client
+                    .query(`INSERT INTO users (name, email, role, password) VALUES ($1,$2,$3,$4);`, [user.name, user.email, user.role, user.password], (err) => {
+
+                        if (err) {
+                            flag = 0; //If user is not inserted is not inserted to database assigning flag as 0/false.
+                            console.error(err);
+                            return res.status(500).json({
+                                error: "Database error"
+                            })
+                        } else {
+                            flag = 1;
+                            res.status(200).send({
+                                message: 'User added to database'
+                            });
+                        }
+                    })
+
+                //Signing JSON Web Token for each User
+                if (flag) {
+                    const token = jwt.sign( //Signing a jwt token
+                        {
+                            email: user.email
+                        },
+                        process.env.SECRET_KEY
+                    );
+                };
+            });
+        }
+    } catch (err) {
+        console.log(err);
+        res.status(500).json({
+            error: "Database error while registring user!", //Database connection error
+        });
+    };
+}
\ No newline at end of file

server/db/knex.js

+const environment = process.env.NODE_ENV || 'development';
+const config = require('../knexfile');
+const environmentConfig = config[environment];
+const knex = require('knex');
+const connection = knex(environmentConfig);
+
+module.exports = connection;

server/db/queries.js

+const knex = require('./knex'); //connection
+
+module.exports = {
+    getAll(){
+        return knex('employee');
+    },
+    getOne(id) {
+        return knex('employee').where('id', id).first();
+    },
+    create(employee) {
+        return knex('employee').insert(employee, '*');
+    },
+    update(id, employee) {
+        return knex('employee').where('id', id).update(employee, '*');
+    },
+    delete(id) {
+         return knex('employee').where('id', id).del();
+    },
+    getAll(){
+        return knex('department');
+    },
+    getOne(id) {
+        return knex('department').where('id', id).first();
+    },
+    create(department) {
+        return knex('department').insert(department, '*');
+    },
+    update(id ,department) {
+        return knex('department').where('id', id).update(department, '*');
+    },
+    delete(id) {
+        return knex('department').where('id', id).del();
+    }
+}

server/knexfile.js

+// Update with your config settings.
+
+module.exports = {
+  development: {
+    client: 'pg',
+    connection: 'postgres://ekbkzdvj:4FKUXKLKeP8sLrJPlnsJ87L5SOJlVTYU@tyke.db.elephantsql.com/ekbkzdvj'
+  },
+  test: {
+    client: 'pg',
+    connection: 'postgres://ekbkzdvj:4FKUXKLKeP8sLrJPlnsJ87L5SOJlVTYU@tyke.db.elephantsql.com/ekbkzdvj'
+  },
+  production: {
+    client: 'pg',
+    connection: process.env.DATABASE_URL
+  }
+};
\ No newline at end of file

server/migrations/20211223131638_employee.js

+
+  exports.up = function(knex) {
+    return knex.schema.createTable('employee', (table) => {
+        table.increments('id');
+        table.string('name');
+        table.bigInteger('mobile');
+        table.string('email');
+        table.string('designation');
+        table.string('role');
+        table.string('department');
+        table.string('type');
+        table.date('date_of_joining');
+        table.date('date_of_birth');
+        table.string('address');
+  
+    })
+  };
+  
+  exports.down = function(knex) {
+    return knex.schema.dropTable('employee');
+  };
+  
\ No newline at end of file

server/migrations/20211229103930_deparment.js

+
+exports.up = function(knex) {
+  return knex.schema.createTable('department', (table) => {
+    table.increments('id');
+    table.text('department_name');
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTable('department');
+};

server/package.json

+{
+  "name": "crud-employee",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "start": "node ./bin/www",
+    "dev": "nodemon app.js",
+    "test": "(dropdb -U postgres --if-exists test-employee && createdb -U postgres test-employee) && NODE_ENV=test mocha"
+  },
+  "dependencies": {
+    "bcrypt": "^5.0.1",
+    "cookie-parser": "~1.4.4",
+    "cors": "^2.8.5",
+    "debug": "~2.6.9",
+    "dotenv": "^10.0.0",
+    "express": "~4.16.1",
+    "http-errors": "~1.6.3",
+    "jsonwebtoken": "^8.5.1",
+    "knex": "^0.95.15",
+    "morgan": "~1.9.1",
+    "pg": "^8.7.1"
+  },
+  "devDependencies": {
+    "chai": "^4.3.4",
+    "mocha": "^9.1.3",
+    "nodemon": "^2.0.15",
+    "supertest": "^6.1.6"
+  }
+}

server/prereq.txt

+express
+knex
+cors
+express-generator
+dotenv
+bcrypt
+jsonwebtoken
\ No newline at end of file

server/public/stylesheets/style.css

+body {
+  padding: 50px;
+  font: 14px "Lucida Grande", Helvetica, Arial, sans-serif;
+}
+
+a {
+  color: #00B7FF;
+}

server/routes/user.js

+const express = require('express');
+
+const router = express.Router();
+
+const {register} = require("../controllers/register");
+
+const {login} = require("../controllers/login");
+
+router.post('/register' , register); //POST request to register the user
+
+router.post('/login' , login); // POST request to login the user
+
+module.exports = router;
\ No newline at end of file

server/seeds/01_employee.js

+ 
+exports.seed = function(knex) {
+  // Deletes ALL existing entries
+  return knex('employee').del()
+    .then(function () {
+      // Inserts seed entries
+      return knex('employee').insert([
+        {id: 1, name:'fazal' ,mobile:'9789898908', email:'fazalurrahman2005@gmail.com', designation:'intern', role:'web dev', department:'Development' , type:'admin', date_of_joining:'10-12-2021', date_of_birth:'8-12-2021', address:'No.5 medavakkam main road,xxxx'},
+      ]);
+    });
+};