Javascript 尝试使用mongodb和nodejs登录用户

我试图登录一个用户，但不断收到错误用户未定义我尝试使用大写和小写的“用户/用户”，但它仍然说未定义

var mongoose = require("mongoose")
var Schema = mongoose.Schema
//var bcrypt = require("bcrypt-nodejs")
var bcrypt = require("bcryptjs")

mongoose.set('useCreateIndex', true,

);


var userSchema = new Schema({
    fname: { type: String, required: true },
    lname: { type: String, required: true },
    email: { type: String, set: toLower, required: true },
    address: { type: String, required: true },
    phonenumber: { type: String, required: true },
    city: { type: String, required: true },
    state: { type: String, required: true },
    country: { type: String, required: true },
    zipcode: { type: Number, required: true },
    cpassword: { type: String, required: true }

})

var db = mongoose.createConnection('mongodb://localhost/main', {
    useNewUrlParser: true,
    useUnifiedTopology: true
});

userSchema.statics.authenticate =


    function (email, password, callback) {
        console.log('im here')
        
        user.findOne({ email: email })
            .exec(function (err, user) {
                if (err) {
                    return callback(err)
                } else if (!user) {
                    var err = new Error('User not found!');
                    err.status = 401;
                    return callback(err);
                } else {
                    bcrypt.compare(password, user.cpassword, function (err, result) {
                        if (result === true) {
                            return callback(null, user);
                        } else {
                            return callback('Wrong password!');
                        }
                    })
                }
            });
    }

//userSchema.methods.authenticate = function (password) {

userSchema.methods.validPassword = function (password) {
    return bcrypt.compareSync(password, this.cpassword)
}
/*
//}


userSchema.methods.encryptPassword = function (cpassword) {
    return bcrypt.hashSync(cpassword, bcrypt.genSaltSync(5), null)
}
/*
userSchema.methods.validPassword = function (cpassword) {
    return bcrypt.compareSync(cpassword, this.cpassword)
}
*/

function toLower(str) {
    return str.toLowerCase();
}



//userSchema.plugin(passportLocalMongoose);
module.exports = mongoose.model("User", userSchema, "users")

上面是model-users.js文件

下面是我的server.js文件

var express = require('express');
const app = express();
var bodyParser = require("body-parser");
var router = express.Router();
var path = require('path');
var passport = require('passport');
const flash = require('connect-flash');
var LocalStrategy = require("passport-local").Strategy;
var user = require('./models/user-model.js');
var config = require('./passport-config')
const methodOverride = require('method-override')
var morgan = require('morgan')
const get = require('./insert.js');
//const register = require('./register.js');
const mongoose = require('mongoose')
const session = require('express-session');
const { check, validationResult }
    = require('express-validator');
const MongoStore = require('connect-mongo')(session);

var bcrypt = require("bcryptjs");
const { triggerAsyncId } = require('async_hooks');

mongoose.connect('mongodb://localhost/main', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    useFindAndModify: false,
    useCreateIndex: true
});


app.use(session({
    store: new MongoStore({ mongooseConnection: mongoose.connection, collection: 'sessions', }
    ),
    secret: 'keyboard cat',
    resave: true,
    saveUninitialized: true,
    unset: 'destroy',
    cookie: {
        secure: false,
    }

}));

var db = mongoose.createConnection('mongodb://localhost/main', {
    useNewUrlParser: true,
    useUnifiedTopology: true
});
app.set('views', __dirname + '/views');
app.set('view engine', 'pug');
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
    extended: true,
}));
app.use(morgan('dev'))
app.use(flash())


// ROUTES
app.get('/about', function (req, res) {
    res.render('about,{ title: "About Us" }')
})
app.get('/contact', function (req, res) {
    res.render('contact', { title: "Contact Us" });
});
app.get('/index', function (req, res) {
    res.render('index', { title: "Home" });
});
app.get('/bookingform', function (req, res) {
    res.render('bookingform', { title: "Book Your Tour" });
});
app.get('/login', function (req, res) {
    res.render('login', { title: "Login" });
});

app.get('/tours', function (req, res) {
    res.render('tours', { title: "Tours" });
});


app.get('/', (req, res) => {
    app.use(express.static(path.join(__dirname + '/public')));
    res.render('index');
})


app.get('/signup', (req, res) => {
    //app.use(express.static(path.join(__dirname + '/public')));
    res.render('signup');
})

app.get('/checkout', (req, res) => {
    get(req, res);
    res.render('checkout')
})

//
app.post('/insert', (req, res) => {
    get(req, res);
    console.log(req.body)
});
      
app.post("/login",

    function (req, res, next) {

        if (req.body.email && req.body.password) {
            console.log(req.body)
            db.collection("users")
            user.authenticate(req.body.email, req.body.password,
                function (error, user) {
                    if (error || !user) {
                        error.status = 401;
                        return next(error);
                    }
                    else {
                        //res.send(user);
                        console.log("Sign in Successfull ")
                        res.redirect('about');
                    }
                }

            );
        }
        else {

            var err = new Error('Something went wrong!');

            err.status = 400;
            res.render('login', { notif: err })
            return next(err);
        }

        console.log('failed')
    },

)





function checkPassword(password) {
    return bcrypt.compareSync(password, user.cpassword)
}
function findUserByEmail(email) {

    if (email) {
        return new Promise((resolve, reject) => {
            user.findOne({ email: email })
                .exec((err, doc) => {
                    if (err) return reject(err)
                    if (doc) return reject(new Error('This email already exists. Please enter another email.'))
                    else return resolve(email)
                })
        })
    }
}



//Handling user logout  
app.get("/logout", function (req, res) {
    req.logout();
    res.redirect("/");
});

function isLoggedIn(req, res, next) {
    if (req.isAuthenticated()) return next();
    res.redirect("/login");
}

function checkAuthenticated(req, res, next) {
    if (req.isAuthenticated()) {
        return next()
    }

    res.redirect('/login')
}

function unWindMessages(em) {
    var m = [];

    for (var i in em) {
        m.push(em[i].msg);
    }

    return m;
}

function checkNotAuthenticated(req, res, next) {
    if (req.isAuthenticated()) {
        return res.redirect('/')
    }
    next()
}

app.listen(27017, function () {
    console.log('listening on 27017')
})


module.exports = app;

---

到目前为止，我已经尝试在两个文件中指定要使用的数据库集合，但仍然无法获得未定义的用户。

我通过创建一个存储模型的用户变量来修复它

var User = mongoose.model("User", userSchema, "users")
module.exports = User