Angular
  • Angular learning
  • Angular
    • Change Detection
      • Angular Change Detection Strategies
      • Understanding Change Detection Strategy in Angular
    • Angular Components Overview
      • Lifecycle hooks
      • View encapsulation
    • Text interpolation
    • Pipes
    • ARIA
    • Event binding
    • Directives
    • Dependency injection in Angular
    • Difference between Template-Driven and Reactive Forms
    • Guards
    • Resolvers
      • Resolver example
  • Memory management in Angular applications
  • Renderer2
  • Angular test
    • Testing
      • The different types of tests
      • Some testing best practices
      • Angular Service Testing in Depth
        • About Jasmine
        • Jasmine - Test suites
        • Implementation of First Jasmine Specfication
        • spyOn() & jasmine.createSpyObj()
        • beforeEach()
        • Testing services
        • Disabled and Focused Tests
        • flush
        • HttpTestingController
        • Sample code
      • Angular Component Testing in Depth
        • Intro to Angular Component testing
        • DOM interaction
        • Trigger Change Detection
        • Test Card List Test Suite Conclusion
        • Window.requestAnimationFrame()
        • Asynchronous Work (Jasmine)
        • Cooperative asynchronous JavaScript: Timeouts and intervals
        • FakeAsync - Asynchronous Work (Jasmine) part 2
        • tick()
        • Sample codes
      • Testing Promised-based code-intro Microtasks
        • Microtasks
        • Micro-tasks within an event loop (Summary)
        • Macro-tasks within an event loop (Summary)
        • Test promised Microtasks (code)
      • Using fakeAsync to test Async Observables
      • Cypress.io
        • Create our first e2e test
      • Angular CLI code coverage and deployment in prod mode.
      • Travis CI
  • Angular best practices
    • Angular best practices
      • Security
      • Accessibility in Angular
      • Keeping your Angular projects up-to-date
    • Bootstrapping an Angular Application
      • Understanding the File Structure
      • Bootstrapping Providers
    • Components in Angular
      • Creating Components
      • Application Structure with Components
        • Accessing Child Components from Template
        • Using Two-Way Data Binding
        • Responding to Component Events
        • Passing Data into a Component
      • Projection
      • Structuring Applications with Components
      • Using Other Components
  • Reactive extensions
    • RxJS
      • RxJS Operators
      • of
      • Observable
      • async pipe (Angular)
      • Interval
      • fromEvent
      • Pipe
      • Map
      • Tap
      • ShareReplay
      • Concat
      • ConcatMap
      • Merge
      • MergeMap
      • ExhaustMap
      • fromEvent
      • DebounceTime
        • Type Ahead
      • Distinct Until Changed
      • SwitchMap
      • CatchError
      • Finalize
      • RetryWhen
      • DelayWhen
      • ForkJoin
      • First
      • Interview Questions
      • Zip
  • NgRx
    • What's NgRx
      • Actions
      • Reducers
      • Selectors
      • 🙅‍♂️Authentication guard with NgRX
      • @ngrx/effects
        • Side-Effect refresh survivor
  • Interview Q&A
    • Angular Unit Testing Interview Questions
    • Angular Questions And Answers
  • Angular Advanced
    • Setting up our environment
      • Understanding Accessors (TS)
      • The host & ::ng-deep Pseudo Selector
Powered by GitBook
On this page

Was this helpful?

  1. Angular
  2. Resolvers

Resolver example

import { Injectable } from '@angular/core';
import { Resolve } from '@angular/router';
import { Observable, throwError, timer } from 'rxjs';
import { catchError, delayWhen, retryWhen } from 'rxjs/operators';
import { IPost } from 'src/app/core/interfaces/IPost';
import { PostActionsService } from '../services/post-actions.service';

@Injectable()
export class JobListResolver implements Resolve<IPost[]> {

    constructor(private postActionsSvc: PostActionsService) { }
    resolve(): Observable<IPost[]> {
        return this.postActionsSvc.getLatestPostsRequest()
            .pipe(
                catchError(err => {
                    return throwError(err);
                }),
                retryWhen(errors => errors.pipe(
                    delayWhen(() => timer(500))
                ))
            );
    }
}

Routing module

import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { JobListComponent } from './job-list/job-list.component';
import { JobListResolver } from './_resolvers/job-list.resolver';

// Main routes
const routes: Routes = [
  { 
    path: 'jobs/search', 
    component: JobListComponent, 
    resolve: { posts: JobListResolver } 
  },
];

@NgModule({
  imports: [RouterModule.forChild(routes)],
  exports: []
})
export class EmployeePortalRoutingModule {
}

Component

constructor(private route: ActivatedRoute) { }

  ngOnInit(): void {
    this.getPosts();
    this.setSearchForm();
  }

  // Get all posts from the BD
  public getPosts(): void {
    this.loader = true;
    const posts$ = this.route.data
      .pipe(
        catchError(err => {
          return throwError(err);
        }),
        shareReplay(),
        takeUntil(this.onDestroy$)
      );

    // Run the subscription
    posts$.subscribe(res => {
      this.loader = false;
      this.posts = res.posts;

      // Object destructuring
      const [first] = res.posts;
      this.post = first;

      this.validatePost(first.id, true);
      this.validatePost(first.id, false);
    });
  }
PreviousResolversNextMemory management in Angular applications

Last updated 4 years ago

Was this helpful?