Comment rediriger dans expressjs tout en passant du contexte?

J'utilise express pour créer une application web dans node.js. Ceci est une simplification de ce que j'ai:

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('/');
});

Mon problème est le suivant:

Si je trouve que les données envoyées /categoryne sont pas validées, je voudrais passer un contexte supplémentaire à la /page. Comment pourrais-je faire ça? La redirection ne semble autoriser aucun type de paramètre supplémentaire.

Il existe plusieurs façons de transmettre des données à différents itinéraires. La réponse la plus correcte est, bien sûr, les chaînes de requête. Vous devrez vous assurer que les valeurs sont correctement encodéesURIComponent et decodeURIComponent .

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

Vous pouvez accrocher cela dans votre autre itinéraire en obtenant les paramètres envoyés à l'aide de req.query.

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

Pour une manière plus dynamique, vous pouvez utiliser le urlmodule principal pour générer la chaîne de requête pour vous:

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

Donc, si vous souhaitez rediriger toutes les variables de chaîne de requête req, vous pouvez simplement faire

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

Et si vous utilisez Node> = 7.x, vous pouvez également utiliser le querystringmodule 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);
 });

Une autre façon de le faire est de configurer quelque chose dans la session. Vous pouvez lire comment le configurer ici , mais définir et accéder aux variables est quelque chose comme ceci:

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

Et plus tard après la redirection ...

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

Il y a aussi la possibilité d'utiliser une ancienne fonction d'Express, req.flash. Pour ce faire, dans les versions plus récentes d'Express, vous devrez utiliser une autre bibliothèque. Essentiellement, cela vous permet de configurer des variables qui s'afficheront et se réinitialiseront la prochaine fois que vous vous rendrez sur une page. C'est pratique pour montrer les erreurs aux utilisateurs, mais encore une fois, il a été supprimé par défaut. EDIT: Trouvé une bibliothèque qui ajoute cette fonctionnalité.

J'espère que cela vous donnera une idée générale de la façon de transmettre des informations dans une application Express.

La manière la plus simple que j'ai trouvée pour passer des données entre routeHandlers pour next()ne pas avoir besoin de jouer avec la redirection ou les sessions. En option, vous pouvez simplement appeler votre homeCtrl(req,res)au lieu de next()et simplement passer le reqetres

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);

J'ai dû trouver une autre solution car aucune des solutions fournies ne répondait réellement à mes besoins, pour les raisons suivantes:

• Chaînes de requête : il se peut que vous ne souhaitiez pas utiliser de chaînes de requête car les URL peuvent être partagées par vos utilisateurs, et parfois les paramètres de requête n'ont pas de sens pour un autre utilisateur. Par exemple, une erreur telle que ?error=sessionExpiredne devrait jamais être affichée par accident à un autre utilisateur.

• req.session : vous ne voudrez peut-être pas l'utiliser req.sessioncar vous avez besoin de la dépendance de session express pour cela, ce qui inclut la configuration d'un magasin de sessions (tel que MongoDB), dont vous n'avez peut-être pas du tout besoin, ou peut-être utilisez-vous déjà une personnalisation solution de magasin de session.

• next () : Vous ne voudrez peut-être pas utiliser next()ou next("router")parce que cela rend simplement votre nouvelle page sous l'URL d'origine, ce n'est pas vraiment une redirection vers la nouvelle URL, plus comme un transfert / réécriture, ce qui peut ne pas être acceptable.

C'est donc ma quatrième solution qui ne souffre d'aucun des problèmes précédents. Fondamentalement, cela implique l'utilisation d'un cookie temporaire, pour lequel vous devrez d'abord installer un analyseur de cookies . Évidemment, cela signifie que cela ne fonctionnera que lorsque les cookies sont activés et avec une quantité limitée de données.

Exemple d'implémentation:

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("/");
}

utilisez app.set & app.get

Définition des données

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

Obtenir des données

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

Voici ce que je suggère sans utiliser aucune autre dépendance, juste node et express, utilisez app.locals, voici un exemple:

    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("/");
    }

Vous pouvez transmettre de petits bits de données de paire clé / valeur via la chaîne de requête:

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

Et javascript sur la page d'accueil peut y accéder et ajuster son comportement en conséquence.

Notez que si cela ne vous dérange pas de /categoryrester en tant qu'URL dans la barre d'adresse du navigateur, vous pouvez simplement afficher directement au lieu de rediriger. À mon humble avis, les gens utilisent souvent des redirections parce que les cadres Web plus anciens rendaient la réponse directe difficile, mais c'est facile en express:

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

  // Process the data received in req.body

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

Comme l'a commenté @ Dropped.on.Caprica, l'utilisation d'AJAX élimine le problème de changement d'URL.

nous pouvons utiliser express-session pour envoyer les données requises

lorsque vous initialisez l'application

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

donc avant la redirection, enregistrez simplement le contexte de la session

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

Vous pouvez maintenant obtenir le contexte n'importe où pour la session. il peut être obtenu simplement par req.session.context

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

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