rxjs/operators#retry TypeScript Examples

// GET All Books
  GetAllBooks(): Observable<IBookDto[]> {

    console.log(`Get All Books request received.`);

    return this.httpClient
      .get<IBookDto[]>(`${baseUrl}/books`)
      .pipe(retry(1), catchError(this.errorHandler));
  }

// GET All Books
    getAllProducts(): Observable<IProductDto[]> {

        console.log(`Get All Products request received.`);

        return this.httpClient
            .get<IProductDto[]>(`${baseUrl}/products`)
            .pipe(retry(1), catchError(this.errorHandler));

    }

// DELETE
  RemoveProfessorById(id: number) {
    console.log(`Removed Professor request received for ${id}`);
    return this.httpClient.delete<ProfessorDto>(`${baseUrl}/${apiName}/${id}`, httpOptions)
      .pipe(
        retry(1),
        catchError(this.errorHandler)
      )
  }

// UPDATE
  EditProfessorById(id: number, Professor: ProfessorDto) {
    console.log(
      `Update Professor request received for ${id} ${JSON.stringify(Professor)}`
    );
    return this.httpClient
      .put<ProfessorDto>(
        `${baseUrl}/${apiName}`,
        JSON.stringify(Professor),
        httpOptions
      )
      .pipe(retry(1), catchError(this.errorHandler));
  }

// Edit Book By Id
  EditBookById(id: string, bookstore: IBookDto) {

    console.log(`Edit Book request received for ${id} ${JSON.stringify(bookstore)}`);

    return this.httpClient
      .put<IBookDto>(`${baseUrl}/books/${id}`, JSON.stringify(bookstore), httpOptions)
      .pipe(retry(1), catchError(this.errorHandler));
  }

//Add Book
  AddBooks(bookstore: IAddBookDto): Observable<IAddBookDto> {

    console.log(`Adding New Book: ${JSON.stringify(bookstore)}`);

    return this.httpClient
      .post<IAddBookDto>(`${baseUrl}/books`, JSON.stringify(bookstore), httpOptions)
      .pipe(
        retry(1),
        catchError(this.errorHandler)
      )
  }

// Retrieve Book By Id
  GetBookById(id: string): Observable<IBookDto> {

    console.log(`Get Book request received for ${id}`);

    return this.httpClient
      .get<IBookDto>(`${baseUrl}/books/${id}`)
      .pipe(retry(1), catchError(this.errorHandler));
  }

// GET All Books
  GetAllBooks(): Observable<IBookDto[]> {

    console.log(`Get All Books request received.`);

    return this.httpClient
      .get<IBookDto[]>(`${baseUrl}/books`)
      .pipe(retry(1), catchError(this.errorHandler));
  }

// Edit Book By Id
  EditBookById(id: string, bookstore: IBookDto) {

    console.log(`Edit Book request received for ${id} ${JSON.stringify(bookstore)}`);

    return this.httpClient
      .put<IBookDto>(`${baseUrl}/books/${id}`, JSON.stringify(bookstore), httpOptions)
      .pipe(retry(1), catchError(this.errorHandler));
  }

//Add Book
  AddBooks(bookstore: IAddBookDto): Observable<IAddBookDto> {

    console.log(`Adding New Book: ${JSON.stringify(bookstore)}`);

    return this.httpClient
      .post<IAddBookDto>(`${baseUrl}/books`, JSON.stringify(bookstore), httpOptions)
      .pipe(
        retry(1),
        catchError(this.errorHandler)
      )
  }

// Retrieve Book By Id
  GetBookById(id: string): Observable<IBookDto> {

    console.log(`Get Book request received for ${id}`);

    return this.httpClient
      .get<IBookDto>(`${baseUrl}/books/${id}`)
      .pipe(retry(1), catchError(this.errorHandler));
  }

intercept(
    request: HttpRequest<any>,
    next: HttpHandler
  ): Observable<HttpEvent<any>> {
    return next.handle(request).pipe(
      retry(1),
      catchError((err) => this.errorHandler(err))
    );
  }

public ethUsdPriceBN$: Observable<BigNumber> = this.getChainLinkAggregatorInstance(
        environment.ETH_USD_CHAINLINK_ORACLE_CONTRACT_ADDRESS
    ).pipe(
        mergeMap((instance) => {

            // @ts-ignore
            const call$ = instance.methods.latestAnswer().call();
            return fromPromise(call$) as Observable<BigNumber>;
        }),
        retry(5),
        shareReplay({bufferSize: 1, refCount: true})
    );

public getDeposits(): Observable<TokenLpParsed[]> {
    return this.userAddress$.pipe(
      filter(user => Boolean(user?.address)),
      tap(() => this.setDepositsLoading(true)),
      switchMap(user => {
        return from(
          this.web3PublicService[this.blockchain].callContractMethod<DepositsResponse>(
            this.lpContractAddress,
            LP_PROVIDING_CONTRACT_ABI,
            'infoAboutDepositsParsed',
            { methodArguments: [user.address], from: user.address }
          )
        ).pipe(
          retry(3),
          catchError((error: unknown) => {
            this.errorService.catchAnyError(error as Error);
            return EMPTY;
          }),
          map(deposits => this.parseDeposits(deposits)),
          tap(deposits => {
            this.zone.run(() => {
              this._deposits$.next(deposits);
            });
          })
        );
      })
    );
  }

/**
   * Updates user's deposit on backend after entering stake.
   * @param amount Amount that user staked.
   * @param txHash Transaction hash.
   * @return Observable<void>
   */
  private updateUsersDeposit(amount: string, txHash: string): Observable<void> {
    return this.stakingApiService
      .updateUsersDeposit({
        walletAddress: this.walletAddress,
        amount,
        txHash,
        network: 'binance-smart-chain'
      })
      .pipe(
        retry(2),
        catchError((error: unknown) => {
          console.error('update deposit request failed:', error);
          return of(null);
        })
      );
  }

private showContent(contentUrl: string, dataFormatter: (data: string) => string = data => data) {
        this.http
            .get(contentUrl, { responseType: 'text' }).pipe(
                retry(2),
                tap(
                    data => {
                        const formattedData = dataFormatter(data);
                        this.selectedContent = this.sanitizer.bypassSecurityTrustHtml(formattedData);
                        this.cd.markForCheck();
                    },
                    error => {
                        this.selectedContent = `Unable to get content (${error.statusText})`;
                        this.cd.markForCheck();
                    },
                ),
            ).subscribe();
    }

private login(): Observable<UserResult> {
    return this.dataStore.userData$
      .pipe(
        take(1),
        map(userData => userData.email),
        switchMap(email => this.privateCouponService.login(email)),
        retry(5),
      );
  }

public getStakingTokenPrice(): void {
    from(
      this.tokensService.getAndUpdateTokenPrice(
        {
          address: this.stakingToken.address,
          blockchain: this.stakingToken.blockchain
        },
        true
      )
    )
      .pipe(retry(3))
      .subscribe(price => {
        if (!Boolean(this.stakingTokenUsdPrice)) {
          this.stakingTokenUsdPrice = price;
        }
      });
  }

getPoolCurrentBalance(): Observable<number> {
    return this.privateCouponService.poolBalance()
      .pipe(
        retry(5),
        map((res: PoolBalanceResult) => res.response.current_balance),
      );
  }

// GET
  GetProfessorById(id: string): Observable<ProfessorDto> {
    console.log(`Get Professor request received for ${id}`);
    return this.httpClient
      .get<ProfessorDto>(`${baseUrl}/${apiName}/${id}`)
      .pipe(retry(1), catchError(this.errorHandler));
  }

// GET All Professors
  GetAllProfessors(): Observable<ProfessorDto[]> {
    return this.httpClient
      .get<ProfessorDto[]>(`${baseUrl}/${apiName}`)
      .pipe(retry(1), catchError(this.errorHandler));
  }

// POST
  AddProfessor(data: AddProfessorDto): Observable<AddProfessorDto> {
    return this.httpClient.post<AddProfessorDto>(`${baseUrl}/${apiName}`, JSON.stringify(data), httpOptions)
      .pipe(
        retry(1),
        catchError(this.errorHandler)
      )
  }

RemoveBookById(id: string) {
    console.log(`Removed Book request received for ${id}`);
    return this.httpClient.delete<IBookDto>(`${baseUrl}/books/${id}`, httpOptions)
      .pipe(
        retry(1),
        catchError(this.errorHandler)
      )
  }

getFiltered(filter = ''): Observable<any> {
    return this.http.get(this.apiUrl + '?' + filter)
    .pipe(
      retry(1)
    );
  }

getDataByCode(code: string):Observable<DataModel[]> {
    return this.http.get<DataModel[]>(`${environment.apiHost}/api/people/${code}`)
      .pipe(
        retry(3), // retry a failed request up to 3 times
        timeout(5000),
        catchError(this.handleError) // then handle the error
      );
  }

RemoveBookById(id: string) {
    console.log(`Removed Book request received for ${id}`);
    return this.httpClient.delete<IBookDto>(`${baseUrl}/books/${id}`, httpOptions)
      .pipe(
        retry(1),
        catchError(this.errorHandler)
      )
  }

private getUserDetail(userResult: UserResult): Observable<UserDetailResult> {
    return this.privateCouponService.getUserDetail(
      userResult.response.user_id,
      userResult.response.token,
    ).pipe(
      retry(5),
    );
  }

intercept(req: HttpRequest<any>, next: HttpHandler) {
        return next.handle(req)
            .pipe(retry(2)); // Make sure we at minimum always attempt 3 times, to avoid transient errors.
    }

public getTokenBalancesAndPrices(
        userWalletAddress: string,
        tokens: ISymbol2Token
    ): Observable<TokenData> {

        const symbols = Object.keys(tokens);
        const addresses = symbols.map(symbol => tokens[symbol].address);
        const decimals = symbols.map(symbol => tokens[symbol].decimals);

        const token2decimals = {};
        // tslint:disable-next-line:forin
        for (const symbol in tokens) {
            token2decimals[tokens[symbol].address] = tokens[symbol].decimals;
        }

        const result: TokenData = {
            usdBalances: [],
            balances: []
        };

        const tokenBalances$ = fromPromise(this.getBalances(userWalletAddress, addresses));
        const tokenPrices$ = fromPromise(this.fetchTokenEthPricesFromOracle(addresses, decimals));

        return combineLatest([
            tokenBalances$,
            tokenPrices$,
            this.tokenPriceService.ethUsdPriceBN$
        ]).pipe(
            retry(3),
            tap(([balances, prices, ethUsdPrice]) => {
                // tslint:disable-next-line:forin
                for (const token in balances) {
                    const balance = new BigNumber(balances[token]);
                    const price = new BigNumber(prices[token]).mul(ethUsdPrice).div(getNumerator(18));
                    const cost = balance.mul(price).div(getNumerator(token2decimals[token]));
                    result.usdBalances.push(cost);
                    result.balances.push(balance);
                }
            }),
            map(() => result),
            catchError((e) => {
                console.log(e);
                return of({
                    usdBalances: [],
                    balances: []
                });
            }),
            take(1)
        );
    }