AngularJS- Login und Authentifizierung in jeder Route und jedem Controller

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?

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

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

}])

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

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

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

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

}]);

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

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

    });
}]);

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

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.