AngularJS- Login e autenticazione in ogni percorso e controller


130

Ho un'applicazione AngularJS creata usando yeoman, grugnito e pergolato.

Ho una pagina di accesso che ha un controller che verifica l'autenticazione. Se le credenziali sono corrette, reinstrado alla home page.

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

Nella home page che ho

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

Nel loginController, controllo le informazioni di accesso e se ha esito positivo, ho impostato l'oggetto utente nella factory di servizio. Non so se sia corretto o meno.

Ciò di cui ho bisogno è che, quando l'utente ha effettuato l'accesso, imposta un valore nell'oggetto utente in modo che tutte le altre pagine possano ottenere quel valore.

Ogni volta che si verificano cambiamenti del percorso, il controller dovrebbe verificare se l'utente ha effettuato l'accesso o meno. In caso contrario, dovrebbe reindirizzare alla pagina di accesso. Inoltre, se l'utente ha già effettuato l'accesso e torna alla pagina, dovrebbe andare alla home page. Il controllore dovrebbe anche controllare le credenziali su tutte le rotte.

Ho sentito parlare di ng-cookies, ma non so come usarli.

Molti degli esempi che ho visto non erano molto chiari e usano una sorta di ruoli di accesso o qualcosa del genere. Non lo voglio. Voglio solo un filtro di accesso. Qualcuno può darmi alcune idee?

Risposte:


180

La mia soluzione si suddivide in 3 parti: lo stato dell'utente è memorizzato in un servizio, nel metodo di esecuzione guardi quando il percorso cambia e controlli se l'utente è autorizzato ad accedere alla pagina richiesta, nel tuo controller principale guardi se lo stato dell'utente cambia.

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

Dovresti creare un servizio (lo nominerò Auth) che gestirà l'oggetto utente e abbia un metodo per sapere se l'utente è registrato o meno.

servizio :

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

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

Dal tuo app.run, dovresti ascoltare l' $routeChangeStartevento. Quando il percorso cambierà, controllerà se l'utente è registrato (ilisLoggedIn metodo dovrebbe gestirlo). Non caricherà il percorso richiesto se l'utente non è registrato e reindirizzerà l'utente alla pagina giusta (nel tuo caso login).

Il loginControllerdovrebbe essere utilizzato nella tua pagina di login per maniglia di accesso. Dovrebbe semplicemente interrompere il Authservizio e impostare l'utente come registrato o meno.

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

Dal controller principale, è possibile ascoltare se lo stato dell'utente cambia e reagisce con un reindirizzamento.

.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
LoginController consentirà all'utente di accedere dalla pagina di accesso. Gestirà il modulo di accesso. Il modulo deve chiamare un metodo di invio che fa parte del tuo loginController. Questo metodo aggiornerà (se il modulo è corretto e l'utente deve aver effettuato l'accesso) lo stato dell'utente UTILIZZANDO il servizio Auth che ho descritto.
gab

2
Ha funzionato come un fascino! Invece del servizio fornito ho usato Auth0 con AngularJS .
Nikos Baxevanis,

34
Cosa succede se l'utente preme F5 e aggiorna? Quindi il tuo Auth in memoria è sparito.
Gaui,

4
Nel caso in cui altri abbiano problemi a far funzionare questo esempio: nel routeChangeStartcallback dovresti verificare se la posizione è effettivamente "/ login" e consentire che:if ( $location.path() === "/login" ) return;
user2084865

1
mi mette in un ciclo infinito.
Nipun Tyagi,

110

Ecco un'altra possibile soluzione, usando l' resolveattributo di $stateProvidero il $routeProvider. Esempio con $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 risolve o rifiuta una promessa in base ai diritti dell'utente corrente:

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

}])

UserProfilecopia le proprietà utente corrente e attuare la $hasRole, $hasAnyRole, $isAnonymouse $isAuthenticatedmetodi logico (più un $refreshmetodo, descritto più avanti):

.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 è responsabile della richiesta del server, per conoscere il profilo utente (collegato ad esempio a un token di accesso allegato alla richiesta):

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

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

}])

Il server dovrebbe restituire un oggetto JSON simile quando richiede 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
}

Infine, quando Accessrifiuta una promessa, se si utilizza ui.router, l' $stateChangeErrorevento verrà generato:

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

    }
  });

}])

Se si utilizza ngRoute, l' $routeChangeErrorevento verrà generato:

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

    }
  });

}])

È possibile accedere al profilo utente nei controller:

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

UserProfilecontiene quindi le proprietà restituite dal server quando richiede GET api/auth:

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

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

}])

UserProfiledeve essere aggiornato quando un utente accede o esce, in modo da Accesspoter gestire i percorsi con il nuovo profilo utente. Puoi ricaricare l'intera pagina o chiamare UserProfile.$refresh(). Esempio al momento dell'accesso:

.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
Penso che questa sia la risposta più semplice e anche estendibile
Jotham,

2
@LeblancMeneses Grazie :) Giusto per chiarire: UNAUTORIZZATO significa "non sappiamo chi sei, quindi non possiamo dire se sei autorizzato ad accedere a questa risorsa o no, per favore accedi prima" , mentre VIETATO significa "sappiamo chi sei e il tuo profilo non ti consente di accedere a questa risorsa" .
sp00m,

1
Bella soluzione, potenziale adattamento con l'autenticazione Spring sul lato server
Jan Peter

1
La migliore soluzione di sempre!
Renan Franca,

1
@jsbisht Tutto dipende da dove memorizzi i token di accesso (vedi l'ultimo frammento). Se lo memorizzi solo nella memoria JS, allora sì: F5 rimuoverà le informazioni di autenticazione. Ma se lo memorizzi in un archivio persistente (ad es. Cookie / localStorage / sessionStorage), allora no: F5 non rimuoverà le informazioni di autenticazione (purché allegi il token a ogni richiesta $ http, o almeno alle richieste inviate a resto / utenti / profilo, poiché il server dovrebbe restituire il profilo dell'utente collegato al token allegato). Fai attenzione a CSRF quando usi l'archiviazione dei cookie.
sp00m,

21

Il modo più semplice di definire il comportamento personalizzato per i singoli percorsi sarebbe abbastanza semplice:

1) routes.js: crea una nuova proprietà (come requireAuth) per qualsiasi percorso desiderato

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) In un controller di livello superiore che non è associato a un elemento all'interno di ng-view(per evitare conflitti con angolari $routeProvider), controlla se newUrlha la requireAuthproprietà e agisci di conseguenza

 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
Possiamo specificare l'attributo 'requestAuth: true' a tutte le rotte in un unico posto ?. Perché nel mio scenario la loro non è una pagina di accesso ma viene autenticata da una chiamata di riposo di terze parti. Quindi ho voluto specificare in un unico posto, e dovrebbe applicarsi anche per i percorsi aggiunti in futuro.
Raghuveer,

1
Non che io sappia. Forse puoi controllare ogni percorso in cui NON è definita una proprietà speciale routes.js.
DotBot,

1
Grande e semplice esempio. È stato molto utile per le mie esigenze.
errore 505

6

Ho scritto un post qualche mese fa su come impostare la registrazione utente e la funzionalità di accesso con Angular, puoi verificarlo su http://jasonwatmore.com/post/2015/03/10/AngularJS-User-Registration-and -login-Example.aspx

Controllo se l'utente ha effettuato l'accesso $locationChangeStartall'evento, ecco la mia app.js principale che mostra questo:

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

Bello scrivere. L'ho usato come riferimento. Grazie @Jason.
Venkat Kotra,

2

Sento che questo è il modo più semplice, ma forse è solo una preferenza personale.

Quando si specifica il percorso di accesso (e qualsiasi altro percorso anonimo; es: / register, / logout, / refreshToken, ecc.), Aggiungere:

allowAnonymous: true

Quindi, qualcosa del genere:

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

Non è mai necessario specificare "allowAnonymous: false", se non presente, si presume falso, nel controllo. In un'app in cui la maggior parte degli URL è autenticata forzatamente, è meno lavoro. E più sicuro; se si dimentica di aggiungerlo a un nuovo URL, il peggio che può accadere è che un URL anonimo sia protetto. Se lo fai in un altro modo, specificando "requestAuthentication: true" e dimentichi di aggiungerlo a un URL, stai perdendo una pagina sensibile al pubblico.

Quindi esegui questo dove ritieni che si adatti meglio al tuo design del codice.

//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

Puoi usare resolve:

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

E, la funzione della risoluzione:

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 ha anche un metodo che ti aiuta a installare un osservatore, ti consiglio di installarlo all'interno di un .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

Ad esempio, un'applicazione ha due utenti chiamati ap e auc. Sto passando una proprietà extra per ogni percorso e gestendo il routing in base ai dati che ottengo in $ routeChangeStart.

Prova questo:

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

Tutti hanno suggerito una grande soluzione per cui ti preoccupi della sessione sul lato client. Voglio dire quando lo stato / url cambia suppongo che tu stia facendo una chiamata Ajax per caricare i dati per il modello.

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.

Ora i dati ajax vengono restituiti dal server utilizzando qualsiasi API. Ora è entrato in gioco il punto, restituire i tipi di ritorno standard utilizzando il server in base allo stato di accesso dell'utente. Controllare quei codici di ritorno ed elaborare la richiesta nel controller. Nota: - Per il controller che non richiede una chiamata Ajax in modo nativo, è possibile chiamare una richiesta vuota al server in questo modo server.location/api/checkSession.phpe questo è 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.....

Sul lato client all'interno del controller o tramite qualsiasi servizio, come mostrato nelle altre risposte

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

Nota: - Aggiornerò di più domani o in futuro


-1

È necessario verificare l'autenticazione utente in due siti principali.

  • Quando gli utenti cambiano stato, controllandolo utilizzando '$routeChangeStart' callback
  • Quando una richiesta $ http viene inviata da angolare, usando un intercettore.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.