Come ricaricare lo stato attuale?

Sto usando Angular UI Router e vorrei ricaricare lo stato corrente e aggiornare tutti i dati / rieseguire i controller per lo stato corrente e il relativo genitore.

Ho 3 livelli di stato: directory.organisations.details

directory.organisations contiene una tabella con un elenco di organizzazioni. Facendo clic su un elemento nella tabella, si carica directory.organisations.details con $ StateParams che passa l'ID dell'elemento. Quindi nello stato dei dettagli carico i dettagli per questo elemento, li modifico e quindi salvo i dati. Tutto bene finora.

Ora devo ricaricare questo stato e aggiornare tutti i dati.

Ho provato:

 $state.transitionTo('directory.organisations');

Il che va allo stato genitore ma non ricarica il controller, immagino perché il percorso non è cambiato. Idealmente, voglio solo rimanere nello stato directory.organisations.details e aggiornare anche tutti i dati nel genitore.

Ho anche provato:

$state.reload()

Ho visto questo sull'API WIKI per $ state.reload "(bug con i controller che si stanno reintegrando in questo momento, risolvendo presto)."

Qualsiasi aiuto sarebbe apprezzato?

Ho scoperto che questo è il modo di lavorare più breve per aggiornare con ui-router:

$state.go($state.current, {}, {reload: true}); //second parameter is for $stateParams

Aggiornamento per le versioni più recenti:

$state.reload();

Quale è un alias per:

$state.transitionTo($state.current, $stateParams, { 
  reload: true, inherit: false, notify: true
});

Documentazione: https://angular-ui.github.io/ui-router/site/#/api/ui.router.state.$state#methods_reload

Questa soluzione funziona in AngularJS V.1.2.2:

$state.transitionTo($state.current, $stateParams, {
    reload: true,
    inherit: false,
    notify: true
});

Questa sarebbe la soluzione finale. (ispirato al post di @ Hollan_Risley)

'use strict';

angular.module('app')

.config(function($provide) {
    $provide.decorator('$state', function($delegate, $stateParams) {
        $delegate.forceReload = function() {
            return $delegate.go($delegate.current, $stateParams, {
                reload: true,
                inherit: false,
                notify: true
            });
        };
        return $delegate;
    });
});

Ora, ogni volta che devi ricaricare, chiama semplicemente:

$state.forceReload();

per quadro ionico

$state.transitionTo($state.current, $state.$current.params, { reload: true, inherit: true, notify: true });//reload

$stateProvider.
  state('home', {
    url: '/',
    cache: false, //required

https://github.com/angular-ui/ui-router/issues/582

Probabilmente l'approccio più pulito sarebbe il seguente:

<a data-ui-sref="directory.organisations.details" data-ui-sref-opts="{reload: true}">Details State</a>

Possiamo ricaricare lo stato solo dal codice HTML.

La risposta di @Holland Risley è ora disponibile come API nell'ultimo UI-router.

$state.reload();

Un metodo che forza ricarica lo stato corrente. Tutte le risoluzioni vengono nuovamente risolte, i controller reintegrati e gli eventi vengono nuovamente attivati.

http://angular-ui.github.io/ui-router/site/#/api/ui.router.state.$state

$state.go($state.current, $stateParams, {reload: true, inherit: false});

$scope.reloadstat = function () { $state.go($state.current, {}, {reload: true}); };

se vuoi ricaricare l'intera pagina, come sembra, basta iniettare $ window nel controller e quindi chiamare

$window.location.href = '/';

ma se vuoi solo ricaricare la tua vista corrente, iniettare $ scope, $ state e $ stateParams (quest'ultimo nel caso in cui tu abbia bisogno di cambiare alcuni parametri in questo prossimo caricamento, qualcosa come il tuo numero di pagina), quindi chiamalo all'interno di qualsiasi metodo del controller:

$stateParams.page = 1;
$state.reload();

AngularJS v1.3.15 angular-ui-router v0.2.15

Soluzione sciocca che funziona sempre.

$state.go("otherState").then(function(){
     $state.go("wantedState")
});

Per angolare v1.2.26, nessuna delle precedenti funzioni. Un ng-click che chiama i metodi di cui sopra dovrà essere cliccato due volte per poter ricaricare lo stato.

Così ho finito per emulare 2 clic usando $ timeout.

$provide.decorator('$state',
        ["$delegate", "$stateParams", '$timeout', function ($delegate, $stateParams, $timeout) {
            $delegate.forceReload = function () {
                var reload = function () {
                    $delegate.transitionTo($delegate.current, angular.copy($stateParams), {
                        reload: true,
                        inherit: true,
                        notify: true
                    })
                };
                reload();
                $timeout(reload, 100);
            };
            return $delegate;
        }]);

Tutto è fallito per me. L'unica cosa che ha funzionato ... è l'aggiunta di cache-view = "false" nella vista che voglio ricaricare quando ci vado.

da questo numero https://github.com/angular-ui/ui-router/issues/582

Non sono sicuro del motivo per cui nessuno di questi sembrava funzionare per me; quello che alla fine lo fece fu:

$state.reload($state.current.name);

Questo era con Angular 1.4.0

Avevo più visualizzazioni nidificate e l'obiettivo era ricaricare solo una con i contenuti. Ho provato approcci diversi ma l'unica cosa che ha funzionato per me è:

//to reload
$stateParams.reload = !$stateParams.reload; //flip value of reload param
$state.go($state.current, $stateParams);

//state config
$stateProvider
  .state('app.dashboard', {
    url: '/',
    templateUrl: 'app/components/dashboard/dashboard.tmpl.html',
    controller: 'DashboardController',
    controllerAs: 'vm',
    params: {reload: false} //add reload param to a view you want to reload
  });

In questo caso verrà ricaricata solo la vista necessaria e la memorizzazione nella cache continuerebbe a funzionare.

So che ci sono state un sacco di risposte, ma il modo migliore che ho trovato per farlo senza causare un aggiornamento della pagina intera è creare un parametro fittizio sulla rotta che voglio aggiornare e poi quando chiamo la rotta che passo in un numero casuale per il parametro fittizio.

            .state("coverage.check.response", {
                params: { coverageResponse: null, coverageResponseId: 0, updater: 1 },
                views: {
                    "coverageResponse": {
                        templateUrl: "/Scripts/app/coverage/templates/coverageResponse.html",
                        controller: "coverageResponseController",
                        controllerAs: "vm"
                    }
                }
            })

e quindi la chiamata a quel percorso

$state.go("coverage.check.response", { coverageResponse: coverage, updater: Math.floor(Math.random() * 100000) + 1 });

Funziona come un incantesimo e gestisce le risoluzioni.

È possibile utilizzare la risposta @Rohan https://stackoverflow.com/a/23609343/3297761

Ma se vuoi far ricaricare ogni controller dopo una modifica della vista, puoi usarlo

myApp.config(function($ionicConfigProvider) { $ionicConfigProvider.views.maxCache(0); ... }

Se si utilizza ionic v1, la soluzione di cui sopra non funzionerà poiché ionic ha abilitato la memorizzazione nella cache dei modelli come parte di $ ionicConfigProvider.

Per ovviare a questo è un po 'confuso - devi impostare la cache su 0 nel file ionic.angular.js:

$ionicConfigProvider.views.maxCache(0);

Ho avuto questo problema che mi stava rovinando la testa, il mio instradamento viene letto da un file JSON e quindi inserito in una direttiva. Potrei fare clic su uno stato dell'interfaccia utente ma non riesco a ricaricare la pagina. Quindi un mio collega mi ha mostrato un bel giochino per questo.

1. Ottieni i tuoi dati
2. Nella tua app config crea uno stato di caricamento
3. Salva lo stato in cui vuoi andare nel rootcope.
4. Imposta la tua posizione su "/ caricamento" in app.run
5. Nel controller di caricamento risolvi la promessa di routing e quindi imposta la posizione sul target desiderato.

Questo ha funzionato per me.

Spero che sia d'aiuto