Angular: Standard-Handler für nicht behandelte http Fehler

Question

In meinem AngularJS App, definierte ich einen Standard-Handler für HTTP-Fehler auf diese Weise:

myapp.config([ '$httpProvider', function($httpProvider) { 
    $httpProvider.responseInterceptors.push('errorInterceptor') 
}]) 

wo errorInterceptor ist ein Dienst, der einige Details über den Fehler in einem Alarmfeld zeigt oben auf der aktuellen Seite.

Nun, wenn ich möchte einen bestimmten Fehler in einer anderen Art und Weise behandeln (zum Beispiel der Abfrage in einem modalen ausgelöst wird, und ich möchte nur die Warnung angezeigt wird in dieser modal und nicht auf Seitenebene):

$http.get('/my/request').then(success, specificErrorHandling) 

Angular tut die specificErrorHandling aber löst immer noch meine errorInterceptor, so wird mein Fehler zweimal gemeldet. Gibt es eine Möglichkeit, das zu vermeiden?

Allgemeiner gibt es eine eckige Möglichkeit, nur Fehler zu behandeln, die nicht bereits entlang der promise-Kette behandelt werden, genauso wie der Fehlerhandler der obersten Ebene einer Serveranwendung keine eingefangenen Ausnahmen verarbeiten muss ?

Edit: Wie von Rote-Bete-Rote-Bete in Kommentaren aufgefordert, hier ist der Code für mein Interceptor:

@app.factory 'errorInterceptor', [ '$q', 'alertsHandler', 
    ($q, alertsHandler) -> 
    success = (response) -> 
     response 

    failure = (response) -> 
     alertsHandler.raise(response) 

    (promise) -> 
     promise.then success, failure 
] 

Answer 1

Unter der Annahme, dass Sie wissen, welche Fehler unterdrückt werden muss, und die man brauchen zu propagieren. Auch, da der Antwort-Interceptor eine Funktion ist, die das Versprechen selbst zurückgibt

Sie können die Antwort für den Fehlerfall abfangen, und statt es den Stapel weiterzugeben, können Sie etwas wie leere Antwort zurückgeben.

Wenn Sie am sample Beispiel in Winkel Dokumentation sucht Interceptor

$provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) { 
    return function(promise) { 
     return promise.then(function(response) { 
      // do something on success 
     }, function(response) { 
      // do something on error 
      if (canRecover(response)) { 
       return responseOrNewPromise; // This can suppress the error. 
      } 
      return $q.reject(response); // This propogates it. 
     }); 
    } 
}); 

Answer 2

Wir haben so etwas.

Wenn wir die HTTP-Fehler umgehen, übergeben wir eine Immobilie an dem errorHandled:true

$http({ 
    method: 'GET', 
    url: '/my/url', 
    errorHandled:true 
}).then(function(){ ... }, function(){ ... }); 

Und dann im Schnittpunkt für responseError: function(rejection){ ... } genannt Wunsch können wir sehen, ob dieser Flag durch einen Blick auf rejection.config.errorHandled und wenn nicht festgelegt ist - dann machen wir einen toastr-dialog mit dem fehler. der Code sieht in etwa so

function (rejection) { 
    if (!rejection.config.errorHandled && rejection.data.message){ 
     toastr.error(rejection.data.message, 'Error'); 
    } 
    return $q.reject(rejection); 
} 

Die Chancen, dass jemand schreibt „errorHandled: true“ ohne einen Handler hinzugefügt sind schlank. Die Wahrscheinlichkeit, 2 Fehlerindikatoren zu haben, ist auch gering, weil wir uns daran gewöhnt haben - aber eigentlich sind 2 Indikatoren besser als gar keine.

Es wäre toll, wenn wir das Versprechen hätten, es abzufragen, wenn es einen Fehlerhandler hat oder nicht die then Kette hinunter, aber wir konnten das nirgendwo finden.