AngularJS- Login und Authentifizierung in jeder Route und jedem Controller


130

Ich habe eine AngularJS-Anwendung, die mit yeoman, grunt und bower erstellt wurde.

Ich habe eine Anmeldeseite mit einem Controller, der die Authentifizierung überprüft. Wenn die Anmeldeinformationen korrekt sind, leite ich zur Startseite um.

app.js.

'use strict';
//Define Routing for app
angular.module('myApp', []).config(['$routeProvider', '$locationProvider',
  function($routeProvider,$locationProvider) {
    $routeProvider
    .when('/login', {
        templateUrl: 'login.html',
        controller: 'LoginController'
    })
    .when('/register', {
        templateUrl: 'register.html',
        controller: 'RegisterController'
      })
    .when('/forgotPassword', {
        templateUrl: 'forgotpassword.html',
        controller: 'forgotController'
      })
   .when('/home', {
       templateUrl: 'views/home.html',
       controller: 'homeController'
    })
    .otherwise({
       redirectTo: '/login'
    });
//    $locationProvider.html5Mode(true); //Remove the '#' from URL.
}]);

angular.module('myApp').factory("page", function($rootScope){
    var page={};
    var user={};
    page.setPage=function(title,bodyClass){
        $rootScope.pageTitle = title;
        $rootScope.bodylayout=bodyClass;
    };
    page.setUser=function(user){
        $rootScope.user=user;
    }
    return page;
});

LoginControler.js

'use strict';

angular.module('myApp').controller('LoginController', function($scope, $location, $window,page) {
    page.setPage("Login","login-layout");
    $scope.user = {};
    $scope.loginUser=function()
    {
        var username=$scope.user.name;
        var password=$scope.user.password;
        if(username=="admin" && password=="admin123")
        {
            page.setUser($scope.user);
            $location.path( "/home" );
        }
        else
        {
            $scope.message="Error";
            $scope.messagecolor="alert alert-danger";
        }
    }
});

Auf der Homepage habe ich

<span class="user-info">
    <small>Welcome,</small>
    {{user.name}}
</span>
<span class="logout"><a href="" ng-click="logoutUser()">Logout</a></span>

In der loginControllerüberprüfe ich die Anmeldeinformationen und wenn es erfolgreich ist, setze ich das Benutzerobjekt in der Service Factory. Ich weiß nicht, ob das richtig ist oder nicht.

Was ich brauche ist, wenn der Benutzer angemeldet ist, setzt es einen Wert im Benutzerobjekt, damit alle anderen Seiten diesen Wert erhalten können.

Bei Routenänderungen sollte der Controller prüfen, ob der Benutzer angemeldet ist oder nicht. Wenn nicht, sollte es zur Anmeldeseite umleiten. Wenn der Benutzer bereits angemeldet ist und zur Seite zurückkehrt, sollte er zur Startseite wechseln. Der Controller sollte auch die Anmeldeinformationen auf allen Routen überprüfen.

Ich habe von ng-Cookies gehört, weiß aber nicht, wie ich sie verwenden soll.

Viele der Beispiele, die ich gesehen habe, waren nicht sehr klar und sie verwenden irgendeine Art von Zugriffsrollen oder so. Das will ich nicht Ich möchte nur einen Anmeldefilter. Kann mir jemand ein paar Ideen geben?

Antworten:


180

Meine Lösung gliedert sich in drei Teile: Der Status des Benutzers wird in einem Dienst gespeichert, in der Ausführungsmethode, die Sie beobachten, wenn sich die Route ändert, und Sie prüfen, ob der Benutzer auf die angeforderte Seite zugreifen darf, in Ihrem Hauptcontroller beobachten Sie, ob Der Status des Benutzers ändert sich.

app.run(['$rootScope', '$location', 'Auth', function ($rootScope, $location, Auth) {
    $rootScope.$on('$routeChangeStart', function (event) {

        if (!Auth.isLoggedIn()) {
            console.log('DENY');
            event.preventDefault();
            $location.path('/login');
        }
        else {
            console.log('ALLOW');
            $location.path('/home');
        }
    });
}]);

Sie sollten einen Dienst erstellen (ich werde ihn benennen Auth), der das Benutzerobjekt behandelt und über eine Methode verfügt, um festzustellen, ob der Benutzer protokolliert ist oder nicht.

Service :

 .factory('Auth', function(){
var user;

return{
    setUser : function(aUser){
        user = aUser;
    },
    isLoggedIn : function(){
        return(user)? user : false;
    }
  }
})

Von Ihrem app.runsollten Sie das $routeChangeStartEreignis hören . Wenn sich die Route ändert, wird überprüft, ob der Benutzer protokolliert ist (die isLoggedInMethode sollte damit umgehen). Die angeforderte Route wird nicht geladen, wenn der Benutzer nicht angemeldet ist, und der Benutzer wird auf die richtige Seite umgeleitet (in Ihrem Fall bei der Anmeldung).

Das loginControllersollte auf Ihrer Anmeldeseite verwendet werden, um die Anmeldung zu verwalten. Es sollte nur mit dem AuthDienst interagieren und den Benutzer als protokolliert festlegen oder nicht.

loginController :

.controller('loginCtrl', [ '$scope', 'Auth', function ($scope, Auth) {
  //submit
  $scope.login = function () {
    // Ask to the server, do your job and THEN set the user

    Auth.setUser(user); //Update the state of the user in the app
  };
}])

Von Ihrem Hauptcontroller aus können Sie abhören, wenn sich der Benutzerstatus ändert, und mit einer Umleitung reagieren.

.controller('mainCtrl', ['$scope', 'Auth', '$location', function ($scope, Auth, $location) {

  $scope.$watch(Auth.isLoggedIn, function (value, oldValue) {

    if(!value && oldValue) {
      console.log("Disconnect");
      $location.path('/login');
    }

    if(value) {
      console.log("Connect");
      //Do something when the user is connected
    }

  }, true);

1
Der loginController ermöglicht es dem Benutzer, sich von der Anmeldeseite aus anzumelden. Es wird das Anmeldeformular behandeln. Das Formular muss eine Submit-Methode aufrufen, die Teil Ihres loginControllers ist. Diese Methode aktualisiert (wenn das Formular korrekt ist und der Benutzer angemeldet sein muss) den Status des Benutzers, der den von mir beschriebenen Auth-Dienst verwendet.
GIBT

2
Lief wie am Schnürchen! Anstelle des bereitgestellten Dienstes habe ich Auth0 mit AngularJS verwendet .
Nikos Baxevanis

34
Was ist, wenn der Benutzer F5 drückt und aktualisiert? Dann ist Ihre In-Memory-Authentifizierung weg.
Gaui

4
Nur für den Fall, dass andere Probleme haben, dieses Beispiel auszuführen: Im routeChangeStartRückruf sollten Sie überprüfen, ob der Speicherort tatsächlich "/ login" ist, und if ( $location.path() === "/login" ) return;
Folgendes

1
es bringt mich in eine Endlosschleife.
Nipun Tyagi

110

Hier ist eine andere mögliche Lösung, die das resolveAttribut des $stateProvideroder des verwendet $routeProvider. Beispiel mit $stateProvider:

.config(["$stateProvider", function ($stateProvider) {

  $stateProvider

  .state("forbidden", {
    /* ... */
  })

  .state("signIn", {
    /* ... */
    resolve: {
      access: ["Access", function (Access) { return Access.isAnonymous(); }],
    }
  })

  .state("home", {
    /* ... */
    resolve: {
      access: ["Access", function (Access) { return Access.isAuthenticated(); }],
    }
  })

  .state("admin", {
    /* ... */
    resolve: {
      access: ["Access", function (Access) { return Access.hasRole("ROLE_ADMIN"); }],
    }
  });

}])

Access löst ein Versprechen in Abhängigkeit von den aktuellen Benutzerrechten auf oder lehnt es ab:

.factory("Access", ["$q", "UserProfile", function ($q, UserProfile) {

  var Access = {

    OK: 200,

    // "we don't know who you are, so we can't say if you're authorized to access
    // this resource or not yet, please sign in first"
    UNAUTHORIZED: 401,

    // "we know who you are, and your profile does not allow you to access this resource"
    FORBIDDEN: 403,

    hasRole: function (role) {
      return UserProfile.then(function (userProfile) {
        if (userProfile.$hasRole(role)) {
          return Access.OK;
        } else if (userProfile.$isAnonymous()) {
          return $q.reject(Access.UNAUTHORIZED);
        } else {
          return $q.reject(Access.FORBIDDEN);
        }
      });
    },

    hasAnyRole: function (roles) {
      return UserProfile.then(function (userProfile) {
        if (userProfile.$hasAnyRole(roles)) {
          return Access.OK;
        } else if (userProfile.$isAnonymous()) {
          return $q.reject(Access.UNAUTHORIZED);
        } else {
          return $q.reject(Access.FORBIDDEN);
        }
      });
    },

    isAnonymous: function () {
      return UserProfile.then(function (userProfile) {
        if (userProfile.$isAnonymous()) {
          return Access.OK;
        } else {
          return $q.reject(Access.FORBIDDEN);
        }
      });
    },

    isAuthenticated: function () {
      return UserProfile.then(function (userProfile) {
        if (userProfile.$isAuthenticated()) {
          return Access.OK;
        } else {
          return $q.reject(Access.UNAUTHORIZED);
        }
      });
    }

  };

  return Access;

}])

UserProfileDie aktuellen Benutzereigenschaften Kopien und implementieren die $hasRole, $hasAnyRole, $isAnonymousund $isAuthenticatedMethoden Logik (plus ein $refreshVerfahren, später erläutert):

.factory("UserProfile", ["Auth", function (Auth) {

  var userProfile = {};

  var clearUserProfile = function () {
    for (var prop in userProfile) {
      if (userProfile.hasOwnProperty(prop)) {
        delete userProfile[prop];
      }
    }
  };

  var fetchUserProfile = function () {
    return Auth.getProfile().then(function (response) {
      clearUserProfile();
      return angular.extend(userProfile, response.data, {

        $refresh: fetchUserProfile,

        $hasRole: function (role) {
          return userProfile.roles.indexOf(role) >= 0;
        },

        $hasAnyRole: function (roles) {
          return !!userProfile.roles.filter(function (role) {
            return roles.indexOf(role) >= 0;
          }).length;
        },

        $isAnonymous: function () {
          return userProfile.anonymous;
        },

        $isAuthenticated: function () {
          return !userProfile.anonymous;
        }

      });
    });
  };

  return fetchUserProfile();

}])

Auth ist dafür verantwortlich, den Server anzufordern, um das Benutzerprofil zu kennen (das beispielsweise mit einem an die Anforderung angehängten Zugriffstoken verknüpft ist):

.service("Auth", ["$http", function ($http) {

  this.getProfile = function () {
    return $http.get("api/auth");
  };

}])

Es wird erwartet, dass der Server ein solches JSON-Objekt zurückgibt, wenn er Folgendes anfordert GET api/auth:

{
  "name": "John Doe", // plus any other user information
  "roles": ["ROLE_ADMIN", "ROLE_USER"], // or any other role (or no role at all, i.e. an empty array)
  "anonymous": false // or true
}

Wenn Accessein Versprechen abgelehnt wird ui.router, wird das $stateChangeErrorEreignis ausgelöst , wenn es verwendet wird:

.run(["$rootScope", "Access", "$state", "$log", function ($rootScope, Access, $state, $log) {

  $rootScope.$on("$stateChangeError", function (event, toState, toParams, fromState, fromParams, error) {
    switch (error) {

    case Access.UNAUTHORIZED:
      $state.go("signIn");
      break;

    case Access.FORBIDDEN:
      $state.go("forbidden");
      break;

    default:
      $log.warn("$stateChangeError event catched");
      break;

    }
  });

}])

Bei Verwendung ngRoutewird das $routeChangeErrorEreignis ausgelöst:

.run(["$rootScope", "Access", "$location", "$log", function ($rootScope, Access, $location, $log) {

  $rootScope.$on("$routeChangeError", function (event, current, previous, rejection) {
    switch (rejection) {

    case Access.UNAUTHORIZED:
      $location.path("/signin");
      break;

    case Access.FORBIDDEN:
      $location.path("/forbidden");
      break;

    default:
      $log.warn("$stateChangeError event catched");
      break;

    }
  });

}])

Auf das Benutzerprofil kann auch in den Controllern zugegriffen werden:

.state("home", {
  /* ... */
  controller: "HomeController",
  resolve: {
    userProfile: "UserProfile"
  }
})

UserProfileEnthält dann die vom Server zurückgegebenen Eigenschaften, wenn Folgendes angefordert wird GET api/auth:

.controller("HomeController", ["$scope", "userProfile", function ($scope, userProfile) {

  $scope.title = "Hello " + userProfile.name; // "Hello John Doe" in the example

}])

UserProfilemuss aktualisiert werden, wenn sich ein Benutzer anmeldet oder abmeldet, damit Accessdie Routen mit dem neuen Benutzerprofil verarbeitet werden können. Sie können entweder die gesamte Seite neu laden oder anrufen UserProfile.$refresh(). Beispiel bei der Anmeldung:

.service("Auth", ["$http", function ($http) {

  /* ... */

  this.signIn = function (credentials) {
    return $http.post("api/auth", credentials).then(function (response) {
      // authentication succeeded, store the response access token somewhere (if any)
    });
  };

}])
.state("signIn", {
  /* ... */
  controller: "SignInController",
  resolve: {
    /* ... */
    userProfile: "UserProfile"
  }
})
.controller("SignInController", ["$scope", "$state", "Auth", "userProfile", function ($scope, $state, Auth, userProfile) {

  $scope.signIn = function () {
    Auth.signIn($scope.credentials).then(function () {
      // user successfully authenticated, refresh UserProfile
      return userProfile.$refresh();
    }).then(function () {
      // UserProfile is refreshed, redirect user somewhere
      $state.go("home");
    });
  };

}])

3
Ich denke, dies ist die einfachste und auch erweiterbarste Antwort
Jotham

2
@LeblancMeneses Danke :) Nur um es klarer zu machen: UNAUTHORIZED bedeutet "Wir wissen nicht, wer Sie sind, daher können wir nicht sagen, ob Sie zum Zugriff auf diese Ressource berechtigt sind oder noch nicht, bitte melden Sie sich zuerst an" , während FORBIDDEN bedeutet "Wir wissen, wer Sie sind und Ihr Profil erlaubt Ihnen nicht, auf diese Ressource zuzugreifen" .
sp00m

1
Gute Lösung, potenziell passend zur Spring-Authentifizierung auf der Serverseite
Jan Peter

1
Die beste Lösung aller Zeiten!
Renan Franca

1
@jsbisht Es hängt alles davon ab, wo Sie die Zugriffstoken speichern (siehe das letzte Snippet). Wenn Sie es nur im JS-Speicher speichern, dann ja: F5 entfernt Authentifizierungsinformationen. Wenn Sie es jedoch in einem dauerhaften Speicher speichern (z. B. cookie / localStorage / sessionStorage), entfernt no: F5 keine Authentifizierungsinformationen (solange Sie das Token an alle $ http-Anforderungen oder zumindest an die an angehängten Anforderungen anhängen rest / users / profile, da vom Server erwartet wird, dass er das Profil des mit dem angehängten Token verknüpften Benutzers zurückgibt. Achten Sie jedoch auf CSRF, wenn Sie die Cookie-Speicherung verwenden.
sp00m

21

Die einfachste Art, benutzerdefiniertes Verhalten für einzelne Routen zu definieren, wäre ziemlich einfach:

1) routes.js: Erstellen Sie eine neue Eigenschaft (wie requireAuth) für jede gewünschte Route

angular.module('yourApp').config(function($routeProvider) {
    $routeProvider
        .when('/home', {
            templateUrl: 'templates/home.html',
            requireAuth: true // our custom property
        })
        .when('/login', {
            templateUrl: 'templates/login.html',
        })
        .otherwise({
            redirectTo: '/home'
        });
})

2) Überprüfen Sie in einem Controller der obersten Ebene, der nicht an ein Element innerhalb des Controllers gebunden ist ng-view(um Konflikte mit dem Winkel zu vermeiden $routeProvider), ob der newUrlüber die requireAuthEigenschaft verfügt, und handeln Sie entsprechend

 angular.module('YourApp').controller('YourController', function ($scope, $location, session) {

     // intercept the route change event
     $scope.$on('$routeChangeStart', function (angularEvent, newUrl) {

         // check if the custom property exist
         if (newUrl.requireAuth && !session.user) {

             // user isn’t authenticated
             $location.path("/login");
         }
     });
 });

1
Können wir das Attribut 'requireAuth: true' für alle Routen an einem Ort angeben? In meinem Szenario handelt es sich nicht um eine Anmeldeseite, sondern um eine Authentifizierung durch einen Restanruf eines Drittanbieters. Also wollte ich an einer Stelle angeben, und es sollte auch für zukünftige hinzugefügte Routen gelten.
Raghuveer

1
Nicht, dass ich davon Wüste. Vielleicht können Sie jede Route überprüfen , in der KEINE spezielle Eigenschaft definiert ist routes.js.
DotBot

1
Tolles und einfaches Beispiel. Es war sehr hilfreich für meine Bedürfnisse.
error505

6

Ich habe vor einigen Monaten einen Beitrag zum Einrichten der Benutzerregistrierungs- und Anmeldefunktion mit Angular geschrieben. Sie können ihn unter http://jasonwatmore.com/post/2015/03/10/AngularJS-User-Registration-and nachlesen -Login-Example.aspx

Ich überprüfe, ob der Benutzer bei dem $locationChangeStartEreignis angemeldet ist. Hier ist meine Haupt-App.js, die dies zeigt:

(function () {
    'use strict';
 
    angular
        .module('app', ['ngRoute', 'ngCookies'])
        .config(config)
        .run(run);
 
    config.$inject = ['$routeProvider', '$locationProvider'];
    function config($routeProvider, $locationProvider) {
        $routeProvider
            .when('/', {
                controller: 'HomeController',
                templateUrl: 'home/home.view.html',
                controllerAs: 'vm'
            })
 
            .when('/login', {
                controller: 'LoginController',
                templateUrl: 'login/login.view.html',
                controllerAs: 'vm'
            })
 
            .when('/register', {
                controller: 'RegisterController',
                templateUrl: 'register/register.view.html',
                controllerAs: 'vm'
            })
 
            .otherwise({ redirectTo: '/login' });
    }
 
    run.$inject = ['$rootScope', '$location', '$cookieStore', '$http'];
    function run($rootScope, $location, $cookieStore, $http) {
        // keep user logged in after page refresh
        $rootScope.globals = $cookieStore.get('globals') || {};
        if ($rootScope.globals.currentUser) {
            $http.defaults.headers.common['Authorization'] = 'Basic ' + $rootScope.globals.currentUser.authdata; // jshint ignore:line
        }
 
        $rootScope.$on('$locationChangeStart', function (event, next, current) {
            // redirect to login page if not logged in and trying to access a restricted page
            var restrictedPage = $.inArray($location.path(), ['/login', '/register']) === -1;
            var loggedIn = $rootScope.globals.currentUser;
            if (restrictedPage && !loggedIn) {
                $location.path('/login');
            }
        });
    }
 
})();

Schön zu schreiben. Ich habe es als Referenz verwendet. Vielen Dank an Jason.
Venkat Kotra

2

Ich denke, dieser Weg ist am einfachsten, aber vielleicht ist es nur eine persönliche Präferenz.

Wenn Sie Ihre Anmelderoute (und alle anderen anonymen Routen, z. B. / register, / logout, / refreshToken usw.) angeben, fügen Sie Folgendes hinzu:

allowAnonymous: true

Also so etwas:

$stateProvider.state('login', {
    url: '/login',
    allowAnonymous: true, //if you move this, don't forget to update
                          //variable path in the force-page check.
    views: {
        root: {
            templateUrl: "app/auth/login/login.html",
            controller: 'LoginCtrl'
        }
    }
    //Any other config
}

Sie müssen niemals "allowAnonymous: false" angeben, wenn es nicht vorhanden ist, wird es bei der Prüfung als false angenommen. In einer App, in der die meisten URLs zwangsweise authentifiziert werden, ist dies weniger Arbeit. Und sicherer; Wenn Sie vergessen, es einer neuen URL hinzuzufügen, ist das Schlimmste, was passieren kann, dass eine anonyme URL geschützt ist. Wenn Sie es andersherum tun und "requireAuthentication: true" angeben und vergessen, es einer URL hinzuzufügen, wird eine vertrauliche Seite an die Öffentlichkeit weitergegeben.

Führen Sie dies dann aus, wo immer Sie der Meinung sind, dass es am besten zu Ihrem Code-Design passt.

//I put it right after the main app module config. I.e. This thing:
angular.module('app', [ /* your dependencies*/ ])
       .config(function (/* you injections */) { /* your config */ })

//Make sure there's no ';' ending the previous line. We're chaining. (or just use a variable)
//
//Then force the logon page
.run(function ($rootScope, $state, $location, User /* My custom session obj */) {
    $rootScope.$on('$stateChangeStart', function(event, newState) {
        if (!User.authenticated && newState.allowAnonymous != true) {
            //Don't use: $state.go('login');
            //Apparently you can't set the $state while in a $state event.
            //It doesn't work properly. So we use the other way.
            $location.path("/login");
        }
    });
});

1

app.js.

'use strict';
// Declare app level module which depends on filters, and services
var app= angular.module('myApp', ['ngRoute','angularUtils.directives.dirPagination','ngLoadingSpinner']);
app.config(['$routeProvider', function($routeProvider) {
  $routeProvider.when('/login', {templateUrl: 'partials/login.html', controller: 'loginCtrl'});
  $routeProvider.when('/home', {templateUrl: 'partials/home.html', controller: 'homeCtrl'});
  $routeProvider.when('/salesnew', {templateUrl: 'partials/salesnew.html', controller: 'salesnewCtrl'});
  $routeProvider.when('/salesview', {templateUrl: 'partials/salesview.html', controller: 'salesviewCtrl'});
  $routeProvider.when('/users', {templateUrl: 'partials/users.html', controller: 'usersCtrl'});
    $routeProvider.when('/forgot', {templateUrl: 'partials/forgot.html', controller: 'forgotCtrl'});


  $routeProvider.otherwise({redirectTo: '/login'});


}]);


app.run(function($rootScope, $location, loginService){
    var routespermission=['/home'];  //route that require login
    var salesnew=['/salesnew'];
    var salesview=['/salesview'];
    var users=['/users'];
    $rootScope.$on('$routeChangeStart', function(){
        if( routespermission.indexOf($location.path()) !=-1
        || salesview.indexOf($location.path()) !=-1
        || salesnew.indexOf($location.path()) !=-1
        || users.indexOf($location.path()) !=-1)
        {
            var connected=loginService.islogged();
            connected.then(function(msg){
                if(!msg.data)
                {
                    $location.path('/login');
                }

            });
        }
    });
});

loginServices.js

'use strict';
app.factory('loginService',function($http, $location, sessionService){
    return{
        login:function(data,scope){
            var $promise=$http.post('data/user.php',data); //send data to user.php
            $promise.then(function(msg){
                var uid=msg.data;
                if(uid){
                    scope.msgtxt='Correct information';
                    sessionService.set('uid',uid);
                    $location.path('/home');
                }          
                else  {
                    scope.msgtxt='incorrect information';
                    $location.path('/login');
                }                  
            });
        },
        logout:function(){
            sessionService.destroy('uid');
            $location.path('/login');
        },
        islogged:function(){
            var $checkSessionServer=$http.post('data/check_session.php');
            return $checkSessionServer;
            /*
            if(sessionService.get('user')) return true;
            else return false;
            */
        }
    }

});

sessionServices.js

'use strict';

app.factory('sessionService', ['$http', function($http){
    return{
        set:function(key,value){
            return sessionStorage.setItem(key,value);
        },
        get:function(key){
            return sessionStorage.getItem(key);
        },
        destroy:function(key){
            $http.post('data/destroy_session.php');
            return sessionStorage.removeItem(key);
        }
    };
}])

loginCtrl.js

'use strict';

app.controller('loginCtrl', ['$scope','loginService', function ($scope,loginService) {
    $scope.msgtxt='';
    $scope.login=function(data){
        loginService.login(data,$scope); //call login service
    };

}]);

1

Sie können verwenden resolve:

angular.module('app',[])
.config(function($routeProvider)
{
    $routeProvider
    .when('/', {
        templateUrl  : 'app/views/login.html',
        controller   : 'YourController',
        controllerAs : 'Your',
        resolve: {
            factory : checkLoginRedirect
        }
    })
}

Und die Funktion der Entschlossenheit:

function checkLoginRedirect($location){

    var user = firebase.auth().currentUser;

    if (user) {
        // User is signed in.
        if ($location.path() == "/"){
            $location.path('dash'); 
        }

        return true;
    }else{
        // No user is signed in.
        $location.path('/');
        return false;
    }   
}

Firebase hat auch eine Methode, mit der Sie einen Beobachter installieren können. Ich empfehle, sie in einem zu installieren .run:

.run(function(){

    firebase.auth().onAuthStateChanged(function(user) {
        if (user) {
            console.log('User is signed in.');
        } else {
            console.log('No user is signed in.');
        }
    });
  }

0

Zum Beispiel hat eine Anwendung zwei Benutzer namens ap und auc. Ich übergebe jeder Route eine zusätzliche Eigenschaft und verarbeite das Routing basierend auf den Daten, die ich in $ routeChangeStart erhalte.

Versuche dies:

angular.module("app").config(['$routeProvider',
function ($routeProvider) {

    $routeProvider.
            when('/ap', {
                templateUrl: 'template1.html',
                controller: 'template1',
                isAp: 'ap',
            }).
            when('/auc', {
                templateUrl: 'template2.html',
                controller: 'template2',
                isAp: 'common',
            }).
            when('/ic', {
                templateUrl: 'template3.html',
                controller: 'template3',
                isAp: 'auc',
            }).
            when('/mup', {
                templateUrl: 'template4.html',
                controller: 'template4',
                isAp: 'ap',
            }).

            when('/mnu', {
                templateUrl: 'template5.html',
                controller: 'template5',
                isAp: 'common',
            }).                               
            otherwise({
                redirectTo: '/ap',
            });
   }]);

app.js:

.run(['$rootScope', '$location', function ($rootScope, $location) {                
    $rootScope.$on("$routeChangeStart", function (event, next, current) {
        if (next.$$route.isAp != 'common') {
            if ($rootScope.userTypeGlobal == 1) {
                if (next.$$route.isAp != 'ap') {
                    $location.path("/ap");
                }
            }
            else {
                if (next.$$route.isAp != 'auc') {
                    $location.path("/auc");
                }                        
            }
        }

    });
}]);

0

Alle haben eine große Lösung vorgeschlagen, warum Sie sich Sorgen um die Sitzung auf der Clientseite machen. Ich meine, wenn sich Status / URL ändert, führen Sie vermutlich einen Ajax-Aufruf aus, um die Daten für Tempelate zu laden.

Note :- To Save user's data you may use `resolve` feature of `ui-router`.
 Check cookie if it exist load template , if even cookies doesn't exist than 
there is no chance of logged in , simply redirect to login template/page.

Jetzt werden die Ajax-Daten vom Server mit einer beliebigen API zurückgegeben. Jetzt kam der Punkt ins Spiel, Standardrückgabetypen über den Server entsprechend dem Anmeldestatus des Benutzers zurückzugeben. Überprüfen Sie diese Rückkehrcodes und bearbeiten Sie Ihre Anfrage im Controller. Hinweis: - Für Controller, die nativ keinen Ajax-Aufruf benötigen, können Sie eine leere Anforderung an den Server wie diesen aufrufen.server.location/api/checkSession.php Dies ist checkSession.php

<?php/ANY_LANGUAGE
session_start();//You may use your language specific function if required
if(isset($_SESSION["logged_in"])){
set_header("200 OK");//this is not right syntax , it is just to hint
}
else{
set_header("-1 NOT LOGGED_IN");//you may set any code but compare that same       
//code on client side to check if user is logged in or not.
}
//thanks.....

Auf der Clientseite innerhalb des Controllers oder über einen beliebigen Dienst, wie in anderen Antworten gezeigt

    $http.get(dataUrl)
    .success(function (data){
        $scope.templateData = data;
    })
    .error(function (error, status){
        $scope.data.error = { message: error, status: status};
        console.log($scope.data.error.status);
if(status == CODE_CONFIGURED_ON_SERVER_SIDE_FOR_NON_LOGGED_IN){
//redirect to login
  });

Hinweis: - Ich werde morgen oder in Zukunft weitere Updates durchführen


-1

Sie sollten die Benutzerauthentifizierung an zwei Hauptstandorten überprüfen.

  • Wenn Benutzer den Status ändern, überprüfen Sie ihn mithilfe eines '$routeChangeStart'Rückrufs
  • Wenn eine $ http-Anforderung von Angular mithilfe eines Interceptors gesendet wird.
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.