Come reindirizzare in una risoluzione del router?

Question

Sto provando a reindirizzare all'interno di una risoluzione del router e volevo sapere se c'è un modo per reindirizzare in un resolver router. Attualmente questo non funziona come si potrebbe pensare.

resolver(auth, $state){ 
    if(!auth.isLoggedIn()){ 
     $state.go('noLoggedInPath'); 
    } 
} 

come si fa a reindirizzamento in un resolver correttamente?

Il mio mod di risposta è questo ma non mi sento a mio agio.

resolver(auth, $state, $timeout){ 
    if(!auth.isLoggedIn()){ 
     $timeout(function() { 

      $state.go('noLoggedInPath'); 
     }, 0); 
    } 
} 

Answer 1

È possibile restituire una promessa da parte vostra funzione resolver che indicherà se continuare la navigazione verso lo stato o meno. Se si decide di spostarsi da qualche altra parte - respingere la promessa e specificare il corretto stato:

resolver($q, $state, $timeout, auth) { 
    var deferred = $q.defer(); 

    // $timeout is an example; it also can be an xhr request or any other async function 
    $timeout(function() { 
     if (!auth.isLoggedIn()) { 
     // user is not logged, do not proceed 
     // instead, go to a different page 
     $state.go('noLoggedInPath'); 
     deferred.reject(); 
     } else { 
     // everything is fine, proceed 
     deferred.resolve(); 
     } 
    }); 

    return deferred.promise; 
} 

Plunkr here.

UPD: codice aggiornato e aggiunto plunkr. Sembra che funzioni solo se lo inserisci in una funzione di timeout.

Answer 2

La risposta di Yauheni funziona, ma per aggirare la strana funzione di timeout, è possibile rifiutare la promessa e rilevarla nell'evento $ stateChangeError, quindi eseguire il reindirizzamento. In questo modo ...

state('admin', { 
    resolve: { 
    auth: function(UserService, $q, permissionService) { 
    var deferred = $q.defer(); 
    return UserService.load().then(function(user){ 
     if (permissionService.can(user, {goTo: state})) { 
     return deferred.resolve({}); 
     } else { 
     return deferred.reject({redirectTo: 'some_other_state'}); 
     } 
    } 
    } 
}); 

E poi ui-router trasmette sempre "stateChangeError", in modo da poter fare qualcosa di simile ..

$rootScope.$on('$stateChangeError', function(evt, to, toParams, from, fromParams, error) { 
    if (error.redirectTo) { 
    $state.go(error.redirectTo); 
    } else { 
    $state.go('error', {status: error.status}) 
    } 
}) 

Answer 3

Questo è quello che in realtà fare, e posso' t trovare una soluzione migliore

resolver($q, $timeout, myService) { 
    if(!areParameterValuesValid() || !isEverythingLogicallyOk()){ 
     var deferred = $q.defer(); 
     $timeout(function() { 
      $state.go('somewhere'); 
      deferred.reject(); 
     }); 
     return deferred.promise; 
    } else { 
     return myService.loadSomething(passingSomeParams); 
    }   
} 

Answer 4

io uso questo

function Check($state, $q) { 
     var deferred = $q.defer(); 
     if (condition) { 
      deferred.resolve(); 
     } 
     else { 
      deferred.reject(); 
     } 
     return deferred.promise.catch(function() { $state.go('path'); }); 
    } 

Answer 5

È possibile utilizzare le promesse resolver dal con la configurazione RedirectTo

redirectTo: function($transition$) { 
     return $transition$.injector().getAsync('isNew').then(function(isNew) { 
     return isNew ? 'estate.edit' : 'estate.view'; 
     }); 
    }, 

Answer 6

Credo che una risposta molto più pulito è quello di restituire una promessa già respinto in questo modo:

resolver(auth, $state, $q){ 
 
    if(!auth.isLoggedIn()){ 
 
     $state.go('noLoggedInPath'); 
 
     
 
     // Return rejected promise 
 
     return $q.reject(); 
 
    } 
 
    return true; 
 
}

Answer 7

Utilizzando risolve per questo non ha funzionato abbastanza per me. Ho adattato la logica di this post per eseguire una funzione di reindirizzamento sulla proprietà data dell'oggetto stato. È quindi possibile toccare l'evento $ stateChangeStart su $ rootScope dal blocco di esecuzione del modulo e utilizzare il metodo invoke del servizio injector per modificare lo stato in base alle condizioni specificate. Funziona bene anche tra i moduli.