[DSC-1437] Refactoring

Author: vins01-4science

src/app/lucky-search/search/lucky-search.component.ts

@@ -1,30 +1,30 @@
-import { Component, OnInit } from '@angular/core';
-import { BehaviorSubject, mergeMap, Observable, of } from 'rxjs';
+import { Component, OnDestroy, OnInit } from '@angular/core';
+import { BehaviorSubject, mergeMap, Observable, Subject, Subscription } from 'rxjs';
 import { RemoteData } from '../../core/data/remote-data';
 import { PaginatedList } from '../../core/data/paginated-list.model';
 import { SearchResult } from '../../shared/search/models/search-result.model';
 import { DSpaceObject } from '../../core/shared/dspace-object.model';
 import { PaginatedSearchOptions } from '../../shared/search/models/paginated-search-options.model';
-import { getFirstSucceededRemoteData } from '../../core/shared/operators';
+import { getFirstCompletedRemoteData, getFirstSucceededRemoteData } from '../../core/shared/operators';
 import { SearchFilter } from '../../shared/search/models/search-filter.model';
 import { LuckySearchService } from '../lucky-search.service';
-import { Router } from '@angular/router';
-import { filter, switchMap, tap } from 'rxjs/operators';
+import { Params, Router } from '@angular/router';
+import { filter, map, switchMap, tap } from 'rxjs/operators';
 import { Context } from '../../core/shared/context.model';
 import { SearchConfigurationService } from '../../core/shared/search/search-configuration.service';
 import { Item } from '../../core/shared/item.model';
 import { BitstreamDataService, MetadataFilter } from '../../core/data/bitstream-data.service';
-import { getBitstreamDownloadRoute } from '../../app-routing-paths';
 import { Bitstream } from '../../core/shared/bitstream.model';
-import { hasValue } from '../../shared/empty.util';
+import { hasValue, isEmpty, isNotEmpty } from '../../shared/empty.util';
 import { getItemPageRoute } from '../../item-page/item-page-routing-paths';
+import { getBitstreamDownloadRoute } from '../../app-routing-paths';
 
 @Component({
   selector: 'ds-lucky-search',
   templateUrl: './lucky-search.component.html',
   styleUrls: ['./lucky-search.component.scss']
 })
-export class LuckySearchComponent implements OnInit {
+export class LuckySearchComponent implements OnInit, OnDestroy {
   /**
    * The current search results
    */
@@ -55,8 +55,10 @@ export class LuckySearchComponent implements OnInit {
   private DESCRIPTION_METADATA = 'dc.description';
 
   bitstreamFilters: MetadataFilter[];
-  bitstreams$ = new BehaviorSubject([]);
-  item$ = new BehaviorSubject(null);
+  bitstreams$ = new Subject<Bitstream[]>();
+  item$ = new Subject<Item>();
+
+  private readonly subscription = new Subscription();
 
   constructor(private luckySearchService: LuckySearchService,
               private router: Router,
@@ -66,39 +68,54 @@ export class LuckySearchComponent implements OnInit {
 
   ngOnInit(): void {
     this.searchOptions$ = this.getSearchOptions();
+    this.handleBitstreamResults();
     this.readResult();
-    const urlTree = this.router.parseUrl(this.router.url);
-    if (urlTree?.queryParams) {
-      Object.keys(urlTree.queryParams).forEach((key) => {
+    const { queryParams } = this.router.parseUrl(this.router.url);
+    if (isNotEmpty(queryParams)) {
+      Object.keys(queryParams).forEach((key) => {
         if (key && key === 'index') {
-          this.currentFilter.identifier = urlTree.queryParams[key];
+          this.currentFilter.identifier = queryParams[key];
         }
         if (key && key === 'value') {
-          this.currentFilter.value = urlTree.queryParams[key];
+          this.currentFilter.value = queryParams[key];
         }
       });
-      this.bitstreamFilters = this.parseBitstreamFilters(urlTree.queryParams);
+      this.bitstreamFilters = this.parseBitstreamFilters(queryParams);
     }
     if (!(this.currentFilter.value !== '' && this.currentFilter.identifier !== '')) {
       this.showEmptySearchSection = true;
       return;
     }
-    this.searchOptions$.pipe(
-      switchMap((options: PaginatedSearchOptions) => {
-        options.filters = [new SearchFilter('f.' + this.currentFilter.identifier, [this.currentFilter.value], 'equals')];
-        return this.luckySearchService.sendRequest(options).pipe(
-          tap((rd: any) => {
-            if (rd.state && rd.state === 'Error') {
-              this.showEmptySearchSection = true;
-            }
-          }),
-          getFirstSucceededRemoteData());
-      }))
-      .subscribe((results) => {
-        return this.resultsRD$.next(results as any);
-      });
+    this.subscription.add(
+      this.searchOptions$
+          .pipe(switchMap((options: PaginatedSearchOptions) => this.getLuckySearchResults(options)))
+          .subscribe((results) => this.resultsRD$.next(results as any))
+    );
+  }
 
+  private handleBitstreamResults() {
+    this.subscription.add(
+      this.bitstreams$.pipe(
+        filter(bitstreams => isNotEmpty(bitstreams) && bitstreams.length === 1),
+        map(bitstreams => getBitstreamDownloadRoute(bitstreams[0]))
+      ).subscribe(bitstreamRoute => this.redirect(bitstreamRoute))
+    );
+    this.subscription.add(
+      this.bitstreams$.pipe(
+        filter(isEmpty)
+      ).subscribe(bitstreamRoute => this.showEmptySearchSection = true)
+    );
+  }
 
+  private getLuckySearchResults(options: PaginatedSearchOptions) {
+    options.filters = [new SearchFilter('f.' + this.currentFilter.identifier, [this.currentFilter.value], 'equals')];
+    return this.luckySearchService.sendRequest(options).pipe(
+      tap((rd: any) => {
+        if (rd.state && rd.state === 'Error') {
+          this.showEmptySearchSection = true;
+        }
+      }),
+      getFirstSucceededRemoteData());
   }
 
   getDescription(bitstream: Bitstream): string {
@@ -115,33 +132,36 @@ export class LuckySearchComponent implements OnInit {
   }
 
   private readResult() {
-    this.resultsRD$
-      .pipe(
-        filter(res => !!res),
-        mergeMap(res => this.handleResultAndRedirectIfNeeded(res))
-      ).subscribe();
-  }
-
-  private handleResultAndRedirectIfNeeded(res: RemoteData<PaginatedList<SearchResult<DSpaceObject>>>) {
-    const total = res.payload.totalElements;
-    if (total === 0) {
-      this.showEmptySearchSection = true;
-    } else if (total === 1) {
-      return this.handleSingleItemResult(res);
-    } else {
-      this.showMultipleSearchSection = true;
-    }
-    return of(null);
-  }
-
-  private handleSingleItemResult(res: RemoteData<PaginatedList<SearchResult<DSpaceObject>>>) {
-    const item = res.payload.page[0].indexableObject as Item;
-    if (this.isBitstreamSearch()) {
-      return this.loadBitstreamsAndRedirectIfNeeded(item);
-    } else {
-      this.redirect(getItemPageRoute(item));
-    }
-    return of(null);
+    this.subscription.add(
+        this.resultsRD$.pipe(
+          filter(results => results?.payload?.totalElements === 0)
+        ).subscribe(_ => this.showEmptySearchSection = true)
+    );
+    this.subscription.add(
+        this.resultsRD$.pipe(
+          filter(results =>
+            this.isBitstreamSearch() && results?.payload?.totalElements === 1
+          ),
+          map(results => results.payload.page[0].indexableObject as Item),
+          tap(item => this.item$.next(item)),
+          mergeMap(item => this.loadBitstreamsAndRedirectIfNeeded(item))
+        ).subscribe(results => this.bitstreams$.next(results))
+    );
+    this.subscription.add(
+        this.resultsRD$.pipe(
+          filter(results =>
+            !this.isBitstreamSearch() && results?.payload?.totalElements === 1
+          ),
+          map(results => results.payload.page[0].indexableObject as Item),
+          tap(item => this.item$.next(item)),
+          map(item => getItemPageRoute(item))
+        ).subscribe(results => this.redirect(results))
+    );
+    this.subscription.add(
+        this.resultsRD$.pipe(
+          filter(results => results?.payload?.totalElements > 1),
+        ).subscribe(_ => this.showMultipleSearchSection = true)
+    );
   }
 
   private isBitstreamSearch() {
@@ -156,7 +176,7 @@ export class LuckySearchComponent implements OnInit {
     this.router.navigateByUrl(url, {replaceUrl: true});
   }
 
-  private parseBitstreamFilters(queryParams): MetadataFilter[] {
+  private parseBitstreamFilters(queryParams: Params): MetadataFilter[] {
     const metadataName = queryParams?.bitstreamMetadata;
     const metadataValue = queryParams?.bitstreamValue;
     if (!!metadataName && !!metadataValue) {
@@ -172,21 +192,16 @@ export class LuckySearchComponent implements OnInit {
     return [];
   }
 
-  private loadBitstreamsAndRedirectIfNeeded(item: Item): Observable<RemoteData<PaginatedList<Bitstream>>> {
+  private loadBitstreamsAndRedirectIfNeeded(item: Item): Observable<Bitstream[]> {
     return this.bitstreamDataService.findByItem(item.uuid, 'ORIGINAL', this.bitstreamFilters, {})
       .pipe(
-        getFirstSucceededRemoteData(),
-        tap(bitstreamsResult => {
-          const bitstreams = bitstreamsResult.payload?.page;
-          this.bitstreams$.next(bitstreams);
-          this.item$.next(item);
-
-          if (!bitstreams?.length) {
-            this.showEmptySearchSection = true;
-          } else if (bitstreams.length === 1) {
-            this.redirect(getBitstreamDownloadRoute(bitstreams[0]));
-          }
-        })
+        getFirstCompletedRemoteData(),
+        map(bitstreamsResult => bitstreamsResult.payload?.page)
       );
   }
+
+  ngOnDestroy(): void {
+    this.subscription.unsubscribe();
+  }
+
 }