Capture-Ausnahme in Prototyp (Typoskript) geworfen

Question

Excellent Angular 2/Material Design Rahmen, Teradata Covalent, bietet eine RESTService abstrakte Klasse, die REST-api hüllt nennt hier:

https://teradata.github.io/covalent/#/components/http

-Code um die Erweiterung zu integrieren ist einfach wie folgt:

export class CustomRESTService extends RESTService<any> { 
    constructor(private _http: Http /* or HttpInterceptorService */) { 
    super(_http, { 
     baseUrl: 'www.api.com', 
     path: '/path/to/endpoint', 
     headers: new Headers(), 
     dynamicHeaders:() => new Headers(), 
     transform: (res: Response): any => res.json(), 
    }); 
    } 
} 

die "Update" Methode in der RESTService abstrakten Klasse wird hier gezeigt:

public update(id: string | number, obj: T, transform?: IRestTransform): Observable<any> { 
    let requestOptions: RequestOptionsArgs = this.buildRequestOptions(); 
    let request: Observable<Response> = this.http.patch(this.buildUrl(id), obj, requestOptions); 
    return request.map((res: Response) => { 
     if (res.status === 200) { 
     if (transform) { 
      return transform(res); 
     } 
     return this.transform(res); 
     } else { 
     return res; 
     } 
    }).catch((error: Response) => { 
     return new Observable<any>((subscriber: Subscriber<any>) => { 
     try { 
      subscriber.error(this.transform(error)); 
     } catch (err) { 
      subscriber.error(error); 
     } 
     }); 
    }); 
    } 

Meine Frage ist: Wenn die Update-Methode der abstrakten Klasse eine Ausnahme auslöst, wie kann das in der CustomRESTService-Klasse erfasst werden? Das heißt, welchen Typoskript-Code könnte man verwenden, um einen Fehler in der Benutzeroberfläche anzuzeigen?

Vielen Dank.

Answer 1

Das erste, was zuerst ist - Warum möchten Sie es in den Rest-Client und nicht in der Logik der App zu fangen?

Angenommen, Sie haben einen guten Grund dafür (irgendeinen anderen Infrastrukturcode, den Sie in der CustomRESTClient-Klasse ausführen), würde ich die Update-Funktion überschreiben und die Fehlerbehandlung dort implementieren.

Ein einfaches Beispiel ohne Observablen:

abstract class Base { 
    update(n:number):number { 
    return n; 
    } 

    test():bool; 
} 

class Child extends Base { 
    update(n:number):number { 
    return super.update(n)*2; 
    } 

    test():bool { 
    return true; 
    } 
}