Spezifische Verwendung des Ausnahmefilters Exceptionfilter in nestjs

{"exceptionCode":40005,"message":"Benutzerdefinierte Ausnahme","path":"/"}

{"statusCode":500,"message":"Interner Serverfehler"}

importiere { HttpException } von "@nestjs/common";

/**
 * Definieren Sie die Basisausnahmeklasse *
 * @export
 * @class BaseException
 * @extends {HttpException}
 */
Exportklasse BaseException erweitert HttpException {

  /**
   * Erstellt eine Instanz von BaseException.
   * @param {number} exceptionCode benutzerdefinierte Ausnahmenummer* @param {string} errorMessage Eingabeaufforderungsnachricht* @param {number} statusCode Statuscode* @memberof BaseException
   */
  Konstruktor(öffentlicher Ausnahmecode: Zahl, öffentliche Fehlermeldung: Zeichenfolge, öffentlicher Statuscode: Zahl) {
    super({ Ausnahmecode: Ausnahmecode, Fehlermeldung: Fehlermeldung }, Statuscode);
  }

  /**
   * Benutzerdefinierten Ausnahmecode abrufen *
   * @zurückkehren {*}
   * @memberof BaseException
   */
  getExceptionCode(): Zahl {
    gib diesen Ausnahmecode zurück;
  }

  getErrorMessage(): Zeichenfolge {
    gib diese Fehlermeldung zurück;
  }

  getStatusCode(): Nummer {
    gib diesen Statuscode zurück;
  }
}

importiere { HttpStatus } von "@nestjs/common";
importiere { BaseException } aus "./base.exception";

Exportklasse UnCauhtException erweitert BaseException {
  Konstruktor() {
    super(40000, "Systembetriebsstörung, bitte kontaktieren Sie den Administrator!", HttpStatus.FORBIDDEN);
  }
}

importiere { ArgumentsHost, ExceptionFilter, HttpException } von "@nestjs/common";
importiere { HttpArgumentsHost } von "@nestjs/common/interfaces";
importiere { BaseException } aus "src/exceptions/base.exception";
importiere { Antwort, Anfrage } von "express";

/**
 * Abnormaler Basisklassenfilter *
 * @export
 * @class BaseExceptionFilter
 * @implements {ExceptionFilter<BaseException>}
 */
exportiere abstrakte Klasse BaseExceptionFilter implementiert ExceptionFilter<BaseException>
{
  /**
   *Ausnahmeklassenerfassung*
   * @abstrakt
   * @param {BaseException} Ausnahme
   * @param {ArgumentsHost} Gastgeber
   * @memberof BaseExceptionFilter
   */
  abstrakter Catch (Ausnahme: BaseException, Host: ArgumentsHost);

  /**
   * Kontextparameter für HTTP-Anforderungen abrufen *
   * @geschützt
   * @param {ArgumentsHost} Gastgeber
   * @zurückkehren {*}
   * @memberof BaseExceptionFilter
   */
  geschützt getHttpContext(host: ArgumentsHost) {
    host.switchToHttp() zurückgeben;
  }

  /**
   * HTTP-Antwortparameter abrufen *
   * @geschützt
   * @param {HttpArgumentsHost} httpContext
   * @zurückkehren {*}
   * @memberof BaseExceptionFilter
   */
  geschützt getResponse(httpContext: HttpArgumentsHost): Antwort {
    returniere httpContext.getResponse<Antwort>();
  }

  /**
   * HTTP-Anforderungsparameter abrufen *
   * @geschützt
   * @param {HttpArgumentsHost} httpContext
   * @zurückkehren {*}
   * @memberof BaseExceptionFilter
   */
  geschützt getRequest(httpContext: HttpArgumentsHost): Anfrage {
    return httpContext.getRequest<Anfrage>();
  }

  /**
   * Ausnahmeinformationen an den Client schreiben *
   * @param {ArgumentsHost} Gastgeber
   * @param {BaseException} Ausnahme
   * @memberof BaseExceptionFilter
   */
  geschützt writeToClient(host: ArgumentsHost, Ausnahme: BaseException) {
    const ctx = this.getHttpContext(host);
    if (Ausnahmeinstanz von BaseException) {
      dies.getResponse(ctx).status(Ausnahme.statusCode).json({
        Ausnahmecode: Ausnahme.getExceptionCode(),
        Nachricht: Ausnahme.getErrorMessage(),
        Pfad: this.getRequest(ctx).url
      });
    }anders {
      const httpException=Ausnahme;
      dies.getResponse(ctx).status(500).json({
        Meldung: „Unbehandelte Ausnahme“,
        Pfad: this.getRequest(ctx).url
      });
    }

  }
}

importiere { ArgumentsHost, Catch } von "@nestjs/common";
importiere { AuthException } aus "src/exceptions/auth.exception";
importiere { BaseException } aus "src/exceptions/base.exception";
importiere { BaseExceptionFilter } aus "./base.exception.filter";

@Catch(AuthException)
Exportklasse AuthExceptionFilter erweitert BaseExceptionFilter
{
  Konstruktor(){
    super();
    console.log("Initialisierung des Autorisierungsausnahmekonstruktors"+new Date().toISOString());
  }
  Fang(Ausnahme: AuthException, Host: ArgumentsHost) {
    Ausnahme.AusnahmeCode=40002;
    console.log("Ausführung der Autorisierungsausnahme"+new Date().toISOString());
    this.writeToClient(host,Ausnahme);
  }

}

importiere { Controller, ForbiddenException, Get, HttpException, HttpStatus, UseFilters } von '@nestjs/common';
importiere { AppService } aus './app.service';
importiere { AuthException } aus './exceptions/auth.exception';
importiere { BusinessException } aus './exceptions/business.exception';
importiere { UnCauhtException } von './exceptions/uncauht.exception';
importiere { AuthExceptionFilter } aus './filters/auth.exception.filter';
importiere { BusinessExceptionFilter } aus './filters/business.exception.filter';


/**
 * Einfaches Controller-Beispiel mit einer einzigen Route
 */
@UseFilters(AuthExceptionFilter,BusinessExceptionFilter)
@Regler()
exportiere Klasse AppController {
 Konstruktor (privater schreibgeschützter AppService: AppService) {}

 @Erhalten()
 getHello(): Zeichenfolge {
  //neuen Fehler werfen("666");
  throw new BusinessException("benutzerdefinierte Ausnahme",HttpStatus.OK);
  neue AuthException werfen();
  throw new HttpException("benutzerdefinierte Ausnahme",HttpStatus.FORBIDDEN);
  gib dies zurück.appService.getHello();
 }

 @Get("Name")
 getName():Zeichenfolge
 {
  gib "guozhiqi" zurück;
 }
}