gerenciamento-subscribtion.js

@Component({
  selector: 'my-app'
})
export class MyComponent implements OnInit, OnDestroy {

  public processamentoSubject = new BehaviorSubject<Processamento[]>(null);
  public processamentos$: Observable<Processamento[]> = this.processamentoSubject.asObservable();

  // 1. Criar objeto subject de bool.
  destroy$: Subject<boolean> = new Subject<boolean>();

  constructor(private processamentoService: ProcessamentoService,
              private notificationsService: NotificationsService) {
  }

  ngOnInit() {

/* 2. Usar o operador `takeUntil(this.destroy$)` para todos as "inscrições" 
    em Streams que não podem ser finalizadas enquando o componente permanece "ativo" */
    this.processamentoService.historicoProcessamentos$
      .map((historicoProcessamentos: Processamento[]) => _.orderBy(historicoProcessamentos, ['mesEnvio', 'grauJurisdicao'], ['desc']))
      .do(totalizadorProcessosDaRemessa => {
        // ... //
      })
      .takeUntil(this.destroy$) // (2)
      .subscribe();

    
    Observable.interval(1000 * 10)
      .startWith(0)
      .flatMap(() => this.processamentoService.atualizarHistoricoProcessamentos())
      .takeUntil(this.destroy$) // (2)
      .subscribe(() => {
      }, (error) => this.notificationsService.exibirMensagemDeErro(error.message));
  }

/* Ação realizada uma única vez, então não será preciso mais "escutar" esse Stream enquanto a aplicação permanece "ativa".
  Nesse caso pode ser usado o operador `first` antes de chamarmos o `subscribe`.*/
  enviar(idPedidoRemessa: number) {

    this.processamentoService.enviar(idPedidoRemessa)
      .first()
      .subscribe(() => {
          this.notificationsService.exibirMensagemDeSucesso('Processo enviado com sucesso! O processamento será ' +
            'feito em lotes e poderá demorar até horas para ser finalizado.');
        },
        (error) => this.notificationsService.exibirMensagemDeErro(error.message));
  }

/* Ao "finalizar" o componente, devemos executar os códigos abaixo para finalizar todos os Streams que estavam "ativos" 
enquanto a aplicação também permanecia "ativa" */
  ngOnDestroy(): void {
    this.destroy$.next(true);
    this.destroy$.unsubscribe();
  }

}