Intercepteur Angular exclure des URL spécifiques

Question

Je suis en train d'écrire des intercepteurs de sorte que je n'ai pas à gérer les en-têtes dans chaque service appelant mon API web. Le problème avec cela est que 99 % de mes appels nécessitent un ensemble spécifique d'en-têtes, mais les autres 1 % nécessitent seulement un des en-têtes et ne fonctionneront pas avec les autres présents. Sachant cela, mon idée est de créer 2 intercepteurs, le premier ajoutera l'en-tête que tous utilisent et le second ajoutera le reste des en-têtes, en excluant le 1 %.

Voici comment j'exclus le 1 %, ce qui fonctionne, mais je veux voir s'il y a une meilleure manière de procéder :

intercept(request: HttpRequest, next:HttpHandler: Observable> {
  let position = request.url.indexOf('api/');
  if (position > 0){
    let destination: string = request.url.substr(position + 4);
    let matchFound: boolean = false;

    for (let address of this.addressesToUse){
      if (new RegExp(address).test(destination)){
        matchFound = true;
        break;
      }
    }

    if (!matchFound){
      ...FAIRE LE TRAVAIL pour ajouter les en-têtes
    }
  }

Answer 1

Je suggère que, malgré la vérification de la requête, vous puissiez utiliser l'en-tête pour ajouter une propriété "skip", si l'en-tête a la propriété skip, retournez simplement les reqs

export class CustomInterceptor implements HttpInterceptor {
    intercept(req: HttpRequest, next: HttpHandler): Observable> {
        if (req.headers.get("skip"))
           return next.handle(req);

        ....
    }
}

Et vous faites tous les appels dont vous avez besoin pour "sauter" l'intercepteur comme

this.http.get(url, {headers:{skip:"true"});

Answer 2

Ce que j'ai fini par faire, c'est avoir un tableau d'URLs (au format Regex) que je ne voulais pas utiliser dans l'intercepteur comme ceci:

import { Injectable } from '@angular/core';
import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable()
export class AddCustomHeadersInterceptor implements HttpInterceptor {
  urlsToNotUse: Array;

  constructor(
  ) {

    this.urlsToNotUse= [
      'myController1/myAction1/.+',
      'myController1/myAction2/.+',
      'myController1/myAction3'
    ];
  }

  intercept(request: HttpRequest, next: HttpHandler): Observable> {
    if (this.isValidRequestForInterceptor(request.url)) {
      let modifiedRequest = request.clone({
        setHeaders: {
          //FAIRE LE TRAVAIL ICI
        }
      });

      return next.handle(modifiedRequest);
    }
    return next.handle(request);
  }

  private isValidRequestForInterceptor(requestUrl: string): boolean {
    let positionIndicator: string = 'api/';
    let position = requestUrl.indexOf(positionIndicator);
    if (position > 0) {
      let destination: string = requestUrl.substr(position + positionIndicator.length);
      for (let address of this.urlsToNotUse) {
        if (new RegExp(address).test(destination)) {
          return false;
        }
      }
    }
    return true;
  }
}

Answer 3

Après avoir vérifié req.headers.get("skip") comme Eliseo l'a suggéré, je recommanderais de supprimer cet en-tête de la requête car il est lié à Angular uniquement et ne devrait pas être transmis à l'API (en fait, cela peut causer des problèmes)

const skipIntercept = request.headers.has('skip');

if (skipIntercept) {
    request = request.clone({
        headers: request.headers.delete('skip')
    });
}

Answer 4

Lorsqu'il est créé par défaut, HttpClient utilisera un intercesseur. Si vous voulez éviter cela, vous pouvez créer une autre instance de HttpClient en utilisant le constructeur.

@Injectable()
class Service {
  private customHttpClient: HttpClient;

  constructor(backend: HttpBackend) {
    this.customHttpClient = new HttpClient(backend);
  }
}

L'instance customHttpClient n'utilisera pas l'intercepteur.

Answer 5

Vous pouvez essayer d'étendre HttpClient au lieu d'utiliser des intercepteurs.

Dans un monde d'intercepteurs, chaque requête est arrêtée - modifiée (des en-têtes sont ajoutés) - avant d'être exécutée.

Dans un monde HttpClient, cela serait pris en charge au moment de l'instanciation de l'objet Client.

Si vous le jugez nécessaire, vous pouvez envisager d'avoir différentes variantes, par exemple la variante HttpClient99Percent, la variante HttpClientOnePercent, etc.

Le lien ci-dessous peut vous donner un bon point de départ:

https://medium.com/@admin_87321/extending-angular-httpclient-6b33a7a1a4d0