Node.js next（）在中间件中的使用

我是编程新手，我一直在关注Colt Steele的web开发者训练营，并试图创建一个简单的博客应用程序。我已经附上了整个代码，但我想重点关注的部分是

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

在本例中，我尝试使用中间件isLoggedIn来检查用户是否只有在登录之后才能添加新的相册或博客文章。但单击“添加新相册”时，如果用户已登录，则会将我带回登录页面

经过一些研究，我试图将req.originalUrl存储在req.session.returnTo中。这应该将用户GET请求的URL存储在我们使用中间件的任何位置

登录路径如下

//handling login logic
app.post('/login', passport.authenticate("local", 
    {
    failureRedirect: "/login"
}), (req, res) => { 
    let returnTo = req.session.returnTo ? req.session.returnTo : '/albums'
    delete req.session.returnTo;   
    res.redirect(returnTo);
})

在这里，我从Passport对象中删除了successRedirect，因此我不会过早地重定向，并在回调中处理了重定向到req.session.returnTo的操作

我的主要假设是next（）将运行res.render，但它似乎不运行，我也不知道为什么

const express            = require('express'),
      app                = express(),
      mongoose           = require('mongoose'),
      bodyParser         = require('body-parser'),
      expressSanitizer   = require('express-sanitizer'),
      methodOverride     = require('method-override'),
      passport           = require('passport'),
      LocalSrategy       = require('passport-local'),
      User               = require('./models/users');

//APP CONFIG          
mongoose.connect('mongodb+srv://arya123:password1234567890@crudclust-gc08c.mongodb.net/<dbname>?retryWrites=true&w=majority', { 
    useNewUrlParser: true, 
    useUnifiedTopology: true,
    useFindAndModify: false
    }).then(() => {
        console.log('Connected to DB!')
    }).catch(err => {
        console.log('ERROR', err.message);
    })

app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({extended: true}));
app.use(expressSanitizer());
app.use(express.static("public"));
app.use(methodOverride("_method"));

//PASSPORT CONFIG
app.use(require("express-session")({
    secret: "Nico wins cutest dog!",
    resave: false,
    saveUnititialized: false,
    cookie: { secure: true }
}));
app.use(passport.initialize());
app.use(passport.session());
passport.use(new LocalSrategy(User.authenticate()));
passport.serializeUser(User.serializeUser());
passport.serializeUser(User.deserializeUser());

//MODEL CONFIG
let cataSchema = new mongoose.Schema({
    title: String,
    artist: String,
    body: String,
    art: String
});

let Catalog = mongoose.model('Catalog', cataSchema);

// let George = new Catalog ({
//     title: "All things must pass",
//     artist: "George Harrison",
//     body: "This is an album"
// });
// George.save();


//ROUTES
app.get('/', (req, res) => {
    res.redirect('/albums');
});

app.get('/albums', (req, res) => {
        Catalog.find({}, function(err, catalogs){
            if(err){
                console.log("ERROR!");
            } else {
               res.render("index", {catalogs: catalogs}); 
            }
        });
}); 

//NEW ALBUM
app.get('/albums/new', isLoggedIn, (req, res) => {
    res.render("new");
});

//POST ROUTE
app.post('/albums', (req, res) =>  {
    console.log(req.body);
    Catalog.create(req.body.catalog, (err, newCatlog) => {
        if(err){
            res.render('/albums/new');
        }
        else{
            res.redirect('/albums');
        }
    });
});

//SHOW
app.get('/albums/:id', (req, res) =>{
    Catalog.findById(req.params.id, (err, foundCatalog) => {
        if(err){
            res.redirect('/albums');
        }
        else{
            res.render('show', {catalog: foundCatalog});
        }
    });
});

//EDIT
app.get('/albums/:id/edit', (req, res) => {
    Catalog.findById(req.params.id, (err, foundCatalog) => {
        if(err){
            res.redirect('/albums');
        }
        else{
            res.render('edit', {catalog: foundCatalog})
        }
    });
});

//UPDATE ROUTE
app.put('/albums/:id', (req, res) => {
    req.body.catalog.body = req.sanitize(req.body.catalog.body);
    console.log(req.body.catalog);
    console.log(req.params.id);
    console.log("===================")
    Catalog.findByIdAndUpdate(req.params.id, req.body.catalog, (err, updated) => {
        if(err){
            console.log(err);
            console.log("===============");
            res.redirect('/albums');
        }
        else{
            res.redirect("/albums/"+ req.params.id);
        }
    });
});

//DELETE ROUTE
app.delete('/albums/:id' , (req, res) => {
    Catalog.findByIdAndRemove(req.params.id, (err, removed) => {
        if(err){
            console.log(err);
            console.log(req.params.body);
            console.log("==============");
            res.redirect('/albums');
        }
        else{
            res.redirect('/albums');
        }
    });
});

//===========
//AUTH ROUTES
//===========

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

//SIGN UP
app.post('/register', (req, res) => {
    let newUser = new User({username: req.body.username});
    User.register(newUser, req.body.password, (err, user) => {
        if(err){
            console.log(err);
            return res.redirect("register")
        }
        passport.authenticate("local")(req, res, () => {
            res.redirect('/albums')
        })
    })
   
});

//SHOW LOGIN
app.get("/login", (req, res) => {
    res.render('login')
})
//handling login logic
app.post('/login', passport.authenticate("local", 
    {
    failureRedirect: "/login"
}), (req, res) => { 
    let returnTo = req.session.returnTo ? req.session.returnTo : '/albums'
    delete req.session.returnTo;   
    res.redirect(returnTo);
})

//LOGOUT ROUTE
app.get("/logout", (req, res) => {
    req.logout();
    res.redirect("/albums")
})

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

//PORT
const port = process.env.PORT || 3000;

app.listen(port, () =>{
    console.log(`Now listening on Port: ${port}`);
})

const express=require（'express'），
app=express（），
mongoose=require（'mongoose'），
bodyParser=require（'body-parser'），
expressSanitizer=require（'express-sanitizer'），
methodOverride=require（'method-override'），
passport=require（'passport'），
LocalSrategy=require（'passport-local'），
用户=要求（'./型号/用户'）；
//应用程序配置
mongoose.connect（'mongodb+srv://arya123:password1234567890@crudclust-gc08c.mongodb.net/？retryWrites=true&w=maist'，{
useNewUrlParser:true，
useUnifiedTopology：正确，
UseFindModify:false
}).然后（（）=>{
console.log（'连接到数据库！'）
}).catch（错误=>{
console.log（'ERROR'，err.message）；
})
应用程序集（“查看引擎”、“ejs”）；
use（bodyParser.urlencoded（{extended:true}））；
app.use（expressSanitizer（））；
应用程序使用（快速静态（“公共”）；
应用程序使用（methodOverride（“_方法”）；
//护照配置
应用程序使用（需要（“快速会话”）({
秘密：“尼科赢了最可爱的狗！”，
resave:false，
saveunitialized:false，
cookie:{secure:true}
}));
app.use（passport.initialize（））；
app.use（passport.session（））；
use（新的LocalSrategy（User.authenticate（））；
passport.serializeUser（User.serializeUser（））；
passport.serializeUser（User.deserializeUser（））；
//模型配置
让cataSchema=newmongoose.Schema({
标题：字符串，
艺术家：弦，
正文：字符串，
艺术：弦乐
});
让Catalog=mongoose.model（'Catalog'，cataSchema）；
//让乔治=新目录({
//标题：“一切都必须通过”，
//艺术家：“乔治·哈里森”，
//正文：“这是一张专辑”
// });
//乔治。保存（）；
//路线
应用程序获取（“/”，（请求，请求）=>{
res.redirect（'/albums'）；
});
app.get（'/albums'，（请求、回复）=>{
Catalog.find（{}，函数（err，catalogs）{
如果（错误）{
log（“错误！”）；
}否则{
res.render（“索引”{catalogs:catalogs}）；
}
});
}); 
//新专辑
app.get（'/albums/new'，isLoggedIn，（请求，回复）=>{
res.render（“新”）；
});
//邮路
app.post（'/albums'，（请求、回复）=>{
控制台日志（请求主体）；
Catalog.create（req.body.Catalog，（err，newCatlog）=>{
如果（错误）{
res.render（'/albums/new'）；
}
否则{
res.redirect（'/albums'）；
}
});
});
//展示
app.get（'/albums/：id'，（req，res）=>{
Catalog.findById（req.params.id，（err，foundCatalog）=>{
如果（错误）{
res.redirect（'/albums'）；
}
否则{
res.render（'show'，{catalog:foundCatalog}）；
}
});
});
//编辑
app.get（'/albums/：id/edit'，（请求，res）=>{
Catalog.findById（req.params.id，（err，foundCatalog）=>{
如果（错误）{
res.redirect（'/albums'）；
}
否则{
res.render（'edit'，{catalog:foundCatalog}）
}
});
});
//更新路线
app.put（'/albums/：id'，（请求，res）=>{
req.body.catalog.body=req.sanitize（req.body.catalog.body）；
控制台日志（请求主体目录）；
控制台日志（请求参数id）；
console.log（“============================”）
Catalog.findByIdAndUpdate（req.params.id，req.body.Catalog，（err，updated）=>{
如果（错误）{
控制台日志（err）；
console.log（“============================”）；
res.redirect（'/albums'）；
}
否则{
res.redirect（“/albums/”+req.params.id）；
}
});
});
//删除路由
app.delete（'/albums/:id'，（请求、回复）=>{
Catalog.findbyiandremove（req.params.id，（err，remove）=>{
如果（错误）{
控制台日志（err）；
控制台日志（请求参数正文）；
console.log（“=========================”）；
res.redirect（'/albums'）；
}
否则{
res.redirect（'/albums'）；
}
});
});
//===========
//认证路由
//===========
//出示登记表
应用程序获取（'/寄存器'，（请求，恢复）=>{
res.render（“寄存器”）；
})
//报名
应用程序发布（“/寄存器”，（请求，回复）=>{
让newUser=newUser（{username:req.body.username}）；
User.register（newUser，req.body.password，（err，User）=>{
如果（错误）{
控制台日志（err）；
返回res.redirect（“寄存器”）
}
passport.Authentication（“本地”）（请求，回复，（）=>{
res.redirect（“/albums”）
})
})
});
//显示登录
app.get（“/login）”，（请求、回复）=>{
res.render（'login'）
})
//处理登录逻辑
app.post（'/login'，passport.authenticate（“本地”，
{
failureRedirect:“/login”
})，（请求，res）=>{
让returnTo=req.session.returnTo？req.session.returnTo:“/albums”
删除req.session.returnTo；
res.redirect（返回到）；
})
//注销路线
app.get（“/logout）”，（请求、回复）=>{
请求注销（）；
res.redirect（“/albums”）
})
函数isLoggedIn（请求、恢复、下一步）{
如果（请求isAuthenticated（））{
返回next（）；
}
req.session.redirectTo=req.originalUrl；
res.redirect（“/login”）；
}
/
app.post("/login", auth, middleware1, middleware2, middleware3, lastMiddleware);

app.use(function() {
   res.send("Error cannot find")
})