Como redireciono no expressjs enquanto transmito algum contexto?

Estou usando o express para criar um aplicativo da web no node.js. Esta é uma simplificação do que tenho:

var express = require('express');
var jade = require('jade');
var http = require("http");


var app = express();
var server = http.createServer(app);

app.get('/', function(req, res) {
    // Prepare the context
    res.render('home.jade', context);
});

app.post('/category', function(req, res) {
    // Process the data received in req.body
    res.redirect('/');
});

Meu problema é o seguinte:

Se eu achar que os dados enviados /categorynão são validados, gostaria de passar algum contexto adicional para a /página. Como eu pude fazer isso? O redirecionamento não parece permitir nenhum tipo de parâmetro extra.

Existem algumas maneiras de transmitir dados para diferentes rotas. A resposta mais correta é, é claro, as cadeias de consulta. Você precisará garantir que os valores sejam codificados corretamenteURIComponent e decodeURIComponent .

app.get('/category', function(req, res) {
  var string = encodeURIComponent('something that would break');
  res.redirect('/?valid=' + string);
});

Você pode pegar isso na sua outra rota obtendo os parâmetros enviados usando req.query.

app.get('/', function(req, res) {
  var passedVariable = req.query.valid;
  // Do something with variable
});

Para uma maneira mais dinâmica, você pode usar o urlmódulo principal para gerar a sequência de consultas para você:

const url = require('url');    
app.get('/category', function(req, res) {
    res.redirect(url.format({
       pathname:"/",
       query: {
          "a": 1,
          "b": 2,
          "valid":"your string here"
        }
     }));
 });

Portanto, se você deseja redirecionar todas as variáveis ​​de sequência de consulta de consulta, você pode simplesmente fazer

res.redirect(url.format({
       pathname:"/",
       query:req.query,
     });
 });

E se você estiver usando Nó> = 7.x, também poderá usar o querystringmódulo principal

const querystring = require('querystring');    
app.get('/category', function(req, res) {
      const query = querystring.stringify({
          "a": 1,
          "b": 2,
          "valid":"your string here"
      });
      res.redirect('/?' + query);
 });

Outra maneira de fazer isso é configurando algo na sessão. Você pode ler como configurá-lo aqui , mas configurar e acessar variáveis ​​é algo como isto:

app.get('/category', function(req, res) {
  req.session.valid = true;
  res.redirect('/');
});

E depois depois do redirecionamento ...

app.get('/', function(req, res) {
  var passedVariable = req.session.valid;
  req.session.valid = null; // resets session variable
  // Do something
});

Também há a opção de usar um recurso antigo do Express req.flash,. Para fazer isso nas versões mais recentes do Express, será necessário o uso de outra biblioteca. Essencialmente, ele permite que você configure variáveis ​​que serão exibidas e redefinidas na próxima vez que você acessar uma página. É útil para mostrar erros aos usuários, mas novamente foi removido por padrão. EDIT: Encontrou uma biblioteca que adiciona essa funcionalidade.

Espero que isso lhe dê uma idéia geral de como transmitir informações em um aplicativo Express.

A maneira mais fácil que encontrei de passar dados entre routeHandlers para next()não precisar mexer com redirecionamento ou sessões. Opcionalmente, você pode chamar o seu em homeCtrl(req,res)vez de next()e apenas passar o reqeres

var express  = require('express');
var jade     = require('jade');
var http     = require("http");


var app    = express();
var server = http.createServer(app);

/////////////
// Routing //
/////////////

// Move route middleware into named
// functions
function homeCtrl(req, res) {

    // Prepare the context
    var context = req.dataProcessed;
    res.render('home.jade', context);
}

function categoryCtrl(req, res, next) {

    // Process the data received in req.body
    // instead of res.redirect('/');
    req.dataProcessed = somethingYouDid;
    return next();
    // optionally - Same effect
    // accept no need to define homeCtrl
    // as the last piece of middleware
    // return homeCtrl(req, res, next);
}

app.get('/', homeCtrl);

app.post('/category', categoryCtrl, homeCtrl);

Eu tive que encontrar outra solução porque nenhuma das soluções fornecidas realmente atendeu aos meus requisitos, pelos seguintes motivos:

• Cadeias de consulta : talvez você não queira usar cadeias de consulta porque os URLs podem ser compartilhados por seus usuários e, às vezes, os parâmetros de consulta não fazem sentido para um usuário diferente. Por exemplo, um erro como ?error=sessionExpirednunca deve ser exibido para outro usuário por acidente.

• req.session : talvez você não queira usá- req.sessionlo porque precisa da dependência de sessão expressa para isso, que inclui a configuração de um armazenamento de sessão (como o MongoDB), que talvez você não precise, ou talvez já esteja usando um recurso personalizado. solução de armazenamento de sessão.

• next () : você pode não querer usar next()ou next("router")porque isso essencialmente renderiza sua nova página no URL original, não é realmente um redirecionamento para o novo URL, mais como um encaminhamento / reescrita, o que pode não ser aceitável.

Portanto, esta é a minha quarta solução que não sofre com nenhum dos problemas anteriores. Basicamente, envolve o uso de um cookie temporário, para o qual você deverá primeiro instalar o analisador de cookies . Obviamente, isso significa que ele só funcionará onde os cookies estiverem ativados e com uma quantidade limitada de dados.

Exemplo de implementação:

var cookieParser = require("cookie-parser");

app.use(cookieParser());

app.get("/", function(req, res) {
    var context = req.cookies["context"];
    res.clearCookie("context", { httpOnly: true });
    res.render("home.jade", context); // Here context is just a string, you will have to provide a valid context for your template engine
});

app.post("/category", function(req, res) {
    res.cookie("context", "myContext", { httpOnly: true });
    res.redirect("/");
}

use app.set & app.get

Configurando dados

router.get(
  "/facebook/callback",
  passport.authenticate("facebook"),
  (req, res) => {
    req.app.set('user', res.req.user)
    return res.redirect("/sign");
  }
);

Obtendo dados

router.get("/sign", (req, res) => {
  console.log('sign', req.app.get('user'))
});

Aqui está o que eu sugiro sem usar nenhuma outra dependência, apenas node e express, use app.locals, aqui está um exemplo:

    app.get("/", function(req, res) {
        var context = req.app.locals.specialContext;
        req.app.locals.specialContext = null;
        res.render("home.jade", context); 
        // or if you are using ejs
        res.render("home", {context: context}); 
    });

    function middleware(req, res, next) {
        req.app.locals.specialContext = * your context goes here *
        res.redirect("/");
    }

Você pode transmitir pequenos bits de dados de pares de chave / valor através da string de consulta:

res.redirect('/?error=denied');

E o javascript na página inicial pode acessar isso e ajustar seu comportamento de acordo.

Observe que, se você não se importa em /categorypermanecer como o URL na barra de endereço do navegador, pode renderizar diretamente, em vez de redirecionar. O IMHO muitas vezes as pessoas usam redirecionamentos porque estruturas da Web mais antigas dificultam a resposta direta, mas é fácil de expressar:

app.post('/category', function(req, res) {

  // Process the data received in req.body

  res.render('home.jade', {error: 'denied'});
});

Como o @ Dropped.on.Caprica comentou, o uso do AJAX elimina a preocupação de alteração de URL.

podemos usar sessão expressa para enviar os dados necessários

quando você inicializa o aplicativo

const express = require('express');
const app = express();
const session = require('express-session');
app.use(session({secret: 'mySecret', resave: false, saveUninitialized: false}));

então, antes do redirecionamento, salve o contexto da sessão

app.post('/category', function(req, res) {
    // add your context here 
req.session.context ='your context here' ;
    res.redirect('/');
});

Agora você pode obter o contexto em qualquer lugar da sessão. ele pode ser obtido apenas por req.session.context

app.get('/', function(req, res) {

    // So prepare the context
var context=req.session.context;
    res.render('home.jade', context);
});