Comment utiliser angularJS intercepteur à seulement intercepter des requêtes http spécifiques?

Je sais comment intercepter TOUTES les demandes, mais je ne veux intercepter les demandes de mes ressources.

Personne ne sait comment faire cela?

services.config(['$httpProvider',function($httpProvider) {
    $httpProvider.interceptors.push('myHttpInterceptor');
}]);

services.factory("userPurchased", function ($resource) {
    return $resource("/api/user/purchases/:action/:item", 
        {}, 
        {
            'list': {method: 'GET', params: {action: 'list'}, isArray: false},
            'save': {method: 'PUT', params: {item: '@item'}},
            'remove': {method: 'DELETE', params: {item: '@item'}},
        }
    );
});

services.factory('myHttpInterceptor', function($q,$rootScope) {
    //$rootScope.showSpinner = false;
    return {

      response: function(response) {
        $rootScope.showSpinner = false;
        //do something on success
        console.log('success');
        console.log('status', response.status);
        //return response;
        return response || $q.when(response);
      },

     responseError: function(response) {
        //do something on error
        $rootScope.showSpinner = true;
        console.log('failure');
        console.log('status', response.status)
        //return response;
        return $q.reject(response);
      }
    };
  });

InformationsquelleAutor jrutter | 2014-04-11

angularjs angularjs-service

Si vous voulez intercepter seules les demandes de ressources spécifiques, vous pouvez utiliser l'option interceptor propriété de $request action. Angulaire de la documentation voir ici (Utilisation>actions)

JavaScript

angular.module('app', ['ngResource']).
  factory('resourceInterceptor', function() {
    return {
      response: function(response) {
        console.log('response intercepted: ', response);
      }
    }
  }).
  factory('resourceService', ['$resource', 'resourceInterceptor', function($resource, resourceInterceptor) {
    return $resource(":name", 
        {}, 
        {
            'list': {method: 'GET', isArray: false, interceptor: resourceInterceptor}
        }
    );
  }]).
  run(['resourceService', '$http', function(resourceService, $http) {
    resourceService.list({name: 'list.json'}); //<= intercepted
    $http.get('list.json'); //<= not intercepted
  }]);

Plunker: http://plnkr.co/edit/xjJH1rdJyB6vvpDACJOT?p=preview

Merci, c'est exactement ce que je cherchais!
Exactement ce dont j'avais besoin! Merci!
Ce n'est pas de travail quand je pousse plusieurs intercepteurs à httpProvider. Je tiens à appeler uniquement une sepecific intercepteur, ce que je fais comme ci-dessus , mais la demande de la méthode est appelée de tous les intercepteurs je me suis inscrit.

InformationsquelleAutor Vadim

23

Le seul moyen que je connaisse de faire ce qu'il suffit de filtrer les demandes que vous voulez dans la réponse du gestionnaire.

par exemple
```
...
response: function(response) {
    if(response.config.url.startsWith('/api/')) {
        //Do your custom processing here
    }

    return response;
}
...
```
Polyfill pour la chaîne.startsWith()
```
//Taken from http://stackoverflow.com/questions/646628/javascript-startswith
if (typeof(String.prototype.startsWith) === 'undefined') {
    String.prototype.startsWith = function(str) {
        return this.slice(0, str.length) === str;
    };
}
```
- +1 pour polyfill extrait de l'attribution
- Si vous utilisez des url directes, le bon vieux indexOf('/api/') > -1 devrait également fonctionner
- Cette réponse ne fonctionne que si le reste de l'api est ainsi nommé à l'aide de '/api/'. Je préfère vérification de l'en-tête http content-type (tels que XML ou JSON)
InformationsquelleAutor rob

/**object single interceptor**/ 
 function SingleCallInterceptor(callbacks){

    this.receive=function(response) {

      switch (response.status) {

        case 200:

          callbacks.success(apiResponse);

          break;

        default :

          callbacks.error(response);
      }

    }

  }


var successfn=function(response){  //i have my response}

var errorfn=function(response){  //i have my error}

var responseInterceptor=new SingleCallInterceptor({success:successfn,error:errorfn});

        $http({

        url: "www.itsdirtysolutioniknow.it,

        method: "GET",

        dataType: "JSONP",

      }).then(responseInterceptor.receive,responseInterceptor.receive);

C'est seulement en fournissant une fonction de rappel. Comment pourrait-on l'utiliser comme un appel http intercepteur?

InformationsquelleAutor dnocode

0

Mon manière préférée est d'utiliser un HTTP intercepteur qui remplace un "magie" en-tête d'Autorisation auprès de l'actuel jeton OAuth. Le code ci-dessous est OAuth spécifiques, mais remédier que c'est un simple exercice pour le lecteur.
```
//Injects an HTTP interceptor that replaces a "Bearer" authorization header
//with the current Bearer token.
module.factory('oauthHttpInterceptor', function (OAuth) {
  return {
    request: function (config) {
      if (config.headers.Authorization === 'Bearer') {
        config.headers.Authorization = 'Bearer ' + btoa(OAuth.accessToken);
      }
      return config;
    }
  };
});

module.config(function ($httpProvider) {
  $httpProvider.interceptors.push('oauthHttpInterceptor');
});
```
- Ce n'est pas vraiment répondre à la question qui a été posée
- Il n' - il suffit de fournir une Authorization en-tête de "Porteur" / "la magie de la chaîne" à vos demandes (et aucune autre), et de l'intercepteur sera appelée. Vous pouvez utiliser la accepté de répondre - et c'est sans doute plus évident - mais signifie que vous êtes attachant que l'intercepteur dans le monde - alors que la méthode dans mon exemple, propose d'indirection.
InformationsquelleAutor Ben Walding

Par défaut angulaire envoie et reçoit application/json en-têtes. Vous pouvez l'obtenir sur la tête de réponse HTTP, comme :

services.config(['$httpProvider',function($httpProvider) {
$httpProvider.interceptors.push('myHttpInterceptor');
}]);
services.factory("userPurchased", function ($resource) {
return $resource("/api/user/purchases/:action/:item", 
{}, 
{
'list': {method: 'GET', params: {action: 'list'}, isArray: false},
'save': {method: 'PUT', params: {item: '@item'}},
'remove': {method: 'DELETE', params: {item: '@item'}},
}
);
});
services.factory('myHttpInterceptor', function($q,$rootScope) {
//$rootScope.showSpinner = false;
return {
response: function(response) {
//use this line to if you are receiving json, else use xml or any other type
var isJson = response.config.headers.Accept.indexOf('json')>-1;
$rootScope.showSpinner = false;
//do something on success
console.log('success');
console.log('status', response.status);
//return response;
return response || $q.when(response);
},
responseError: function(response) {
//use this line to if you are receiving json, else use xml or any other type
var isJson = response.config.headers.Accept.indexOf('json')>-1;
//do something on error
$rootScope.showSpinner = true;
console.log('failure');
console.log('status', response.status)
//return response;
return $q.reject(response);
}
};
});

InformationsquelleAutor Yacine

0

Je viens de tomber sur un problème où les googleapis utilise également un Authorization en-tête, et lançait une réponse 401 parce que le JWT-je utiliser sur mon serveur n'est pas valide pour leur serveur (évidemment), et mon code est automatiquement configuré pour supprimer mon jeton et de rediriger la personne vers la page de connexion. (Il n'était pas écrit super bien, car TOUTE réponse 401 pourrait ouvrir une session mon utilisateur).

Je suis juste venu avec cette solution, à mon request méthode de l'intercepteur, qui, je pense, fonctionne assez bien:
```
.service('authInterceptor', ["$q", "$location", "tokenService", function($q, $location, tokenService){
this.request = function(config) {
//       console.log($location.host());
var token = tokenService.getToken();
if(token && config.url.indexOf($location.host()) > -1) {
config.headers = config.headers || {};
config.headers.Authorization = "Bearer " + token
}
return config
}
this.responseError = function(response) {
//       console.log(response.config.url)
if (response.status === 401) {
tokenService.removeToken();
$location.path('/login')
}
return $q.reject(response);
}
}])
```
La request méthode vérifie si j'ai un jeton dans le local de stockage ET si l'url de la requête est faite sur le même hôte (que je reçois de $location.host()) ainsi que celle de ma page est sur. Cela fonctionne pour localhost ainsi que tout autre URL que j'ai en fin de déployer mon site sur.

Je n'ai pas fait beaucoup de tests avec ce, donc si quelqu'un trouve une faille dans cette s'il vous plaît laissez-moi savoir 🙂

InformationsquelleAutor bobbyz

Vous devez vous connecter pour publier un commentaire.