如何使用Sequelize实现Node.JS模型_Node.js_Express_Sequelize.js

如何使用Sequelize实现Node.JS模型

node.js express sequelize.js

如何使用Sequelize实现Node.JS模型,node.js,express,sequelize.js,Node.js,Express,Sequelize.js,我有一个项目，其中包含用户的以下模型、控制器和路由文件。我想实现sequelize，我已经设法使用下面的帐户文件部分实现了它，但是，我正在努力解决如何实现登录并确保请求具有有效的令牌，使用的是user.ensureToken，它将成为account.ensureToken 我对Node.Js相当陌生，所以我甚至不知道从哪里开始 user.model.js const bcrypt = require('bcrypt'); const sql = require("./db.js&qu

我有一个项目，其中包含

用户的以下模型、控制器和路由文件

。我想实现sequelize，我已经设法使用下面的

帐户

文件部分实现了它，但是，我正在努力解决如何实现登录并确保请求具有有效的令牌，使用的是

user.ensureToken

，它将成为

account.ensureToken

我对Node.Js相当陌生，所以我甚至不知道从哪里开始

user.model.js

const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

user.controller.js

const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

user.routes.js

const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

account.model.js

const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

account.controller.js

const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

account.routes.js

const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

您需要使用jwt令牌作为访问令牌，正如您所说，您是模型文件中的bcrypt密码，这将是安全问题。您必须在请求中立即输入bcrypt密码。我已在我的回答中实现了此功能。从您的模型文件中删除密码bcrypt的代码

您必须在

account.controller.js中导入
const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

然后，您必须为授权创建一个单独的文件夹，如authorize.js
或authJwt.js
，您必须在其中检查令牌是否有效或是否将此代码放入authorize.js

const bcrypt = require('bcrypt');

const sql = require("./db.js");
const HashBits = require("../config/auth.config.js");
const faker = require('faker');

// constructor
const User = function(user) {
    this.first_name = user.first_name;
    this.last_name = user.last_name;
    this.mob_no = user.mob_no;
    this.user_name = user.user_name;
    this.password = user.password;
};

User.create = (newUser, result) => {
    bcrypt.hash(newUser.password, HashBits.saltRounds, (err, hash) => {
        newUser.password = hash;
        sql.query("INSERT INTO users SET ?", newUser, (err, res) => {
            if (err) {
                // console.log("error: ", err);
                result(err, null);
                return;
            }
            newID = res.insertId;
            // console.log("created user: ", { id: res.insertId, ...newUser });
            result(null, { id: res.insertId, ...newUser });
        });
        
    });
};

User.authenticate = (user,result) => {
    // sql.query(`SELECT * FROM customers WHERE id = ${customerId}`, (err, res) => {
    sql.query(`SELECT * FROM users WHERE user_name = '${user.user_name}'`, (err, res) => {
        // sql.query("SELECT * FROM users ", (err, res) => {
        if (err) {
            // console.log("error: ", err);
            result(err, null);
            return;
        }
        if(res.length !== 1){
            // console.log("error: found multiple users");
            result("error: found multiple users", null);
            return;
        }
        
        // console.log("Found user: ",res[0]);
        bcrypt.compare(user.password, res[0].password, function(err, res2) {
            if(res2){
                // console.log("Yes");
                result(null,res[0]);
            }else{
                // console.log("On ya bike");
                result("ERROR",null);
                // return;
            }
        });
    });
};
module.exports = User;

const User = require("../models/user.model.js");

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new User
exports.create = (req, res) => {
  // Validate request
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  // Create a User
  const user = new User({
    first_name: req.body.first_name,
    last_name: req.body.last_name,
    mob_no: req.body.mob_no,
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  // Save User in the database
  User.create(user, (err, data) => {
    if (err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while creating the User."
    });
    else res.send(data);
  });
};

exports.authenticate = (req,res) => {
  
  if (!req.body) {
    res.status(400).send({
      message: "Content can not be empty!"
    });
  }
  
  const user = new User({
    user_name: req.body.user_name,
    password: req.body.password
  });
  
  User.authenticate(user, (err,data) => {
    if(err)
    res.status(500).send({
      message:
      err.message || "Some error occurred while authenticating the User."
    });
    else {
      var token = jwt.sign({ id: user.id }, config.secret, {
        expiresIn: 86400 // 24 hours
      });
      // res.send(data);
      
      res.status(200).send({
        id: data.id,
        username: data.user_name,
        accessToken: token
      });
    }
  });
};

exports.ensureToken = (req, res, next) => {
  let token = req.headers["x-access-token"];
  
  if (!token) {
    return res.status(403).send({
      message: "No token provided!"
    });
  }
  
  jwt.verify(token, config.secret, (err, decoded) => {
    if (err) {
      return res.status(401).send({
        message: "Unauthorized!"
      });
    }
    req.userId = decoded.id;
    next();
  });
}

module.exports = app => {
    const users = require("../controllers/user.controller.js");
    // Create a new User
    app.post("/User", users.create);
    // Login
    app.post("/User/Login", users.authenticate);

  };

const bcrypt = require("bcrypt");


module.exports = (sequelize, Sequelize) => {
    const Account = sequelize.define("account", {
        firstName: {
            type: Sequelize.STRING
        },
        username: { 
            type: Sequelize.STRING
        },
        password: {
            type: Sequelize.STRING,
            set(value){
                const hash = bcrypt.hashSync(value, 10);
                this.setDataValue('password', hash);
            }
        }
    });

    return Account;
};

const db = require("../models");
const Account = db.accounts;
const Op = db.Sequelize.Op;

var jwt = require("jsonwebtoken");

const config = require("../config/auth.config.js");

// Create and Save a new New
exports.create = (req, res) => {

    // Validate request
if (!req.body.username) {
    res.status(400).send({
    message: "Content can not be empty!"
    });
    return;
}

// Create a Site
const account = {
    firstName: req.body.firstName,
    username: req.body.username,
    password: req.body.password
};

Account.create(account)
.then(data => {
    res.send(data);
})
.catch(err => {
    res.status(500).send({
    message:
    err.message || "Some error occurred while creating the Account."
    });
});
};

exports.authenticate = (req,res) => {

    if (!req.body) {
        res.status(400).send({
        message: "Content can not be empty!"
        });
    }
    
    const account = new Account({
        username: req.body.username,
        password: req.body.password
    });

};

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");
    
    var router = require("express").Router();

    app.post("/account", accounts.create);

    app.post("/account/Login", accounts.authenticate);

};

  const db = require("../models");
  const User = db.user;
  require('dotenv').config();
  const Op = db.Sequelize.Op;
  const errors = require('../config/errors');
  const error = errors.errors;

  var jwt = require("jsonwebtoken");
  var bcrypt = require("bcryptjs");

 module.exports = {
 signup: async (req, res) => {
 if (!req.body.first_name|| !req.body.lastt_name || !req.body.password) {

  return res.status(200).send(error.MANDATORY_FIELDS);
}
try {
  // Save User to Database
  User.create({
    name: req.body.name,
    email: req.body.email,
    mo_no: req.body.mo_no,
    city: req.body.city,
    password: bcrypt.hashSync(req.body.password, 8),
    user_type: "admin"
  }).then(function (user) {
 
        return res.status(200).send(error.OK)
  })
    .catch(function (err) {
      console.log(err);
      return res.status(500).send(error.SERVER_ERROR)
    });
} catch (e) {
  console.log(e);
  return res.status(500).send(error.SERVER_ERROR)
}
},

signin: async (req, res) => {
if (!req.body.email || !req.body.password) {
  return res.status(200).send(error.MANDATORY_FIELDS);
}
User.findOne({
  where: {
    email: req.body.email
  }
}).then(function (user) {
  if (!user) {
    return res.status(404).send(error.USER_NOT_PRESENT);
  }

  const passwordIsValid = bcrypt.compareSync(
    req.body.password,
    user.password
  );

  if (!passwordIsValid) {
    return res.status(422).send(error.PASSWORD_MISSMATCH, {
      accessToken: null
    });
  }

  const token = jwt.sign({ id: user.id, first_name: user.first_name }, 
  process.env.secret, {
    expiresIn: 86400 // 24 hours
  });

  const authorities = [];
    return res.status(200).send({
      id: user.id,
      name: user.name,
      email: user.email,
      accessToken: token
    });
  });
})
  .catch(function (err) {
    console.log(err)
    return res.status(500).send(error.SERVER_ERROR);
  });
 }
}

在解码时，还需要您在.env文件中拥有的秘密令牌或密码
const jwt = require("jsonwebtoken");

 verifyToken = (req, res, next) => {
 let token = req.headers["x-access-token"];

if (!token) {
  return res.status(403).send(error.TOKEN_NOT_PROVIDED);
}

jwt.verify(token, process.env.secret, (err, decoded) => {
 if (err) {
  return res.status(401).send(error.UNAUTHORIZED);
 }
 req.first_name= decoded.first_name;
 req.id = decoded.user_id
 next();
 });
};

const authJwt = {
  verifyToken: verifyToken
};
module.exports = authJwt;

然后，只要您愿意，就必须在路由中导入authorize.js
文件
const authorize = require('../authorize.js');

module.exports = app => {
    const accounts = require("../controllers/account.controller.js");

     var router = require("express").Router();

     app.post("/account",  accounts.create);

     app.post("/account/Login", 
     authorize.verifyToken,accounts.authenticate);

};

如果您在登录时生成访问令牌将更加有效，这对我验证jwt的方式是有意义的，我以前在用户控制器中使用函数以类似的方式实现了jwt。ensureToken
。我面临的主要问题是如何在用户登录时生成jwt。因为我使用Sequelize来定义帐户模型，所以我不确定如何创建一个函数来使用用户名和密码验证帐户并返回jwt。好的，我正在实现我的答案以在登录时生成jwt令牌我已更新答案，您可以根据您的应用程序文件和文件夹进行更改