Umleiten zur vorherigen Seite nach der Authentifizierung in node.js mithilfe von pass.js

Ich bin versucht, einen login-Mechanismus mit node.js -, express-und passport.js. Der Login selbst funktioniert ganz nett, auch sessions gespeichert sind schön mit redis aber ich habe einige Probleme mit der Umleitung der Nutzer zu, wo er begann aus, bevor Sie aufgefordert, sich zu authentifizieren.

z.B. der Benutzer folgt link http://localhost:3000/hidden wird dann umgeleitet http://localhost:3000/login aber dann will ich ihn umgeleitet zu werden wieder zurück zu http://localhost:3000/hidden.

Der Zweck von diesem ist, wenn der Benutzer Zugriff zufällig eine Seite muss er angemeldet sein erste, soll er umgeleitet werden, um den /login-Seite unter Angabe seiner Zugangsdaten und dann umgeleitet wird, zurück zu der Stelle, die er zuvor versucht, Zugriff auf.

Hier ist meine login-post

app.post('/login', function (req, res, next) {
    passport.authenticate('local', function (err, user, info) {
        if (err) {
            return next(err)
        } else if (!user) { 
            console.log('message: ' + info.message);
            return res.redirect('/login') 
        } else {
            req.logIn(user, function (err) {
                if (err) {
                    return next(err);
                }
                return next(); //<-? Is this line right?
            });
        }
    })(req, res, next);
});

und hier meine ensureAuthenticated Methode

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

denen die Haken in die /hidden Seite

app.get('/hidden', ensureAuthenticated, function(req, res){
    res.render('hidden', { title: 'hidden page' });
});

Die html-Ausgabe für die login-Seite ist ganz einfach

<form method="post" action="/login">

  <div id="username">
    <label>Username:</label>
    <input type="text" value="bob" name="username">
  </div>

  <div id="password">
    <label>Password:</label>
    <input type="password" value="secret" name="password">
  </div>

  <div id="info"></div>
    <div id="submit">
    <input type="submit" value="submit">
  </div>

</form>

InformationsquelleAutor der Frage Alx | 2012-11-11

Ich weiß nicht, über Pass -, aber hier ist, wie ich es mache:

Ich habe eine middleware ich mit app.get('/account', auth.restrict, routes.account) setzt redirectTo in der Sitzung...dann habe ich redirect /Anmeldung

auth.restrict = function(req, res, next){
    if (!req.session.userid) {
        req.session.redirectTo = '/account';
        res.redirect('/login');
    } else {
        next();
    }
};

Dann in routes.login.post ich Folgendes tun:

var redirectTo = req.session.redirectTo ? req.session.redirectTo : '/';
delete req.session.redirectTo;
//is authenticated ?
res.redirect(redirectTo);

InformationsquelleAutor der Antwort chovy

In Ihrem ensureAuthenticated Methode speichern der return-url in der session, wie diese:

...
req.session.returnTo = req.path; 
res.redirect('/login');
...

Dann können Sie die Aktualisierung Ihres Reisepasses.authentifizieren route etwas wie:

app.get('/auth/google/return', passport.authenticate('google'), function(req, res) {
    res.redirect(req.session.returnTo || '/');
    delete req.session.returnTo;
});

InformationsquelleAutor der Antwort linuxdan

14

Werfen Sie einen Blick auf connect-sorgen-logindie arbeiten an der Seite von Pass, genau das zu tun, was Sie wollen!

InformationsquelleAutor der Antwort Jared Hanson
5

Wenn Sie connect-sorgen-login es ist eine super-einfache, integrierte Möglichkeit, dies zu tun mit Pass über die successReturnToOrRedirect parameter. Wenn verwendet, Reisepass senden Sie zurück zu dem ursprünglich angeforderten URL oder fallback auf die URL, die Sie stellen.
```
router.post('/login', passport.authenticate('local', {
  successReturnToOrRedirect: '/user/me',
  failureRedirect: '/user/login',
  failureFlash: true
}));
```
https://github.com/jaredhanson/connect-ensure-login#log-in-and-return-to

InformationsquelleAutor der Antwort igneosaur

Meine Art, Dinge zu tun:

const isAuthenticated = (req, res, next) => {
  if (req.isAuthenticated()) {
    return next()
  }
  res.redirect( `/login?origin=${req.originalUrl}` )
};

GET /login controller:

if( req.query.origin )
  req.session.returnTo = req.query.origin
else
  req.session.returnTo = req.header('Referer')

res.render('account/login')

POST /login controller:

  let returnTo = '/'
  if (req.session.returnTo) {
    returnTo = req.session.returnTo
    delete req.session.returnTo
  }

  res.redirect(returnTo);

POST /logout controller (nicht sicher, ob es 100% ok, Kommentare sind willkommen):

req.logout();
res.redirect(req.header('Referer') || '/');
if (req.session.returnTo) {
  delete req.session.returnTo
}

Klar returnTo middleware (löscht returnTo von session-auf jeder route, außer auth Routen - für mich sind Sie das /login und /auth/:Anbieter ):

String.prototype.startsWith = function(needle)
{
  return(this.indexOf(needle) == 0)
}

app.use(function(req, res, next) {
  if ( !(req.path == '/login' || req.path.startsWith('/auth/')) && req.session.returnTo) {
    delete req.session.returnTo
  }
  next()
})

Dieser Ansatz zwei Funktionen:

Sie können Sie schützen, einige Routen mit isAuthenticated middleware;
auf jeder Seite können Sie einfach klicken Sie auf login-URL, und nach dem login zurück zu dieser Seite;

InformationsquelleAutor der Antwort deksden

1

@chovy und @linuxdan Antworten haben bug mit nicht-clearing - session.returnTo wenn der Benutzer geht auf eine andere Seite nach dem login umleiten (ja, das ist keine Authentifizierung erforderlich ist) und die Anmeldungen durch. So fügen Sie diesen code in Ihre Implementierungen:
```
//clear session.returnTo if user goes to another page after redirect to login
app.use(function(req, res, next) {
    if (req.path != '/login' && req.session.returnTo) {
        delete req.session.returnTo
    }
    next()
})
```
Wenn Sie einige ajax-Anfragen, die von der login-Seite können Sie auch ausschließen.

Ein weiterer Ansatz ist die Verwendung flash in ensureAuthenticated
```
req.flash('redirectTo', req.path)
res.redirect('/login')
```
Und dann in " GET login
```
res.render('login', { redirectTo: req.flash('redirectTo') })
```
In view add hidden-Feld auf login-Formular (Beispiel in jade)
```
if (redirectTo != '')
    input(type="hidden" name="redirectTo" value="#{redirectTo}")
```
In der POST-login -
```
res.redirect(req.body.redirectTo || '/')
```
Beachten Sie, dass redirectTo wird klar, nach dem ersten login.

InformationsquelleAutor der Antwort Alexander Danilov
1

Einfachste (und richtig) Weg, dies zu erreichen ist die Einstellung failureRedirect und successRedirect - Optionen.

InformationsquelleAutor der Antwort Eray

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.