Prevent request with page size of 9999

src/app/bitstream-page/edit-bitstream-page/edit-bitstream-page.component.ts

@@ -31,13 +31,16 @@ import cloneDeep from 'lodash/cloneDeep';
 import {
   combineLatest,
   combineLatest as observableCombineLatest,
+  EMPTY,
   Observable,
   of as observableOf,
   Subscription,
 } from 'rxjs';
 import {
+  expand,
   filter,
   map,
+  reduce,
   switchMap,
   tap,
 } from 'rxjs/operators';
@@ -178,7 +181,10 @@ export class EditBitstreamPageComponent implements OnInit, OnDestroy {
   /**
    * Options for fetching all bitstream formats
    */
-  findAllOptions = { elementsPerPage: 9999 };
+  findAllOptions = {
+    elementsPerPage: 20,
+    currentPage: 1,
+  };
 
   /**
    * The Dynamic Input Model for the file's name
@@ -463,14 +469,27 @@ export class EditBitstreamPageComponent implements OnInit, OnDestroy {
     this.itemId = this.route.snapshot.queryParams.itemId;
     this.entityType = this.route.snapshot.queryParams.entityType;
     this.bitstreamRD$ = this.route.data.pipe(map((data: any) => data.bitstream));
-    this.bitstreamFormatsRD$ = this.bitstreamFormatService.findAll(this.findAllOptions);
 
-    const bitstream$ = this.bitstreamRD$.pipe(
+    this.bitstreamFormatsRD$ = this.bitstreamFormatService.findAll(this.findAllOptions).pipe(
       getFirstSucceededRemoteData(),
-      getRemoteDataPayload(),
+      expand((response: RemoteData<PaginatedList<BitstreamFormat>>) => {
+        const pageInfo = response.payload.pageInfo;
+        if (pageInfo.currentPage < pageInfo.totalPages) {
+          const nextPageOptions = { ...this.findAllOptions, currentPage: pageInfo.currentPage + 1 };
+          return this.bitstreamFormatService.findAll(nextPageOptions).pipe(getFirstSucceededRemoteData());
+        } else {
+          return EMPTY;
+        }
+      }),
     );
 
-    const allFormats$ = this.bitstreamFormatsRD$.pipe(
+    const bitstreamFormats$ = this.bitstreamFormatsRD$.pipe(
+      reduce((acc: BitstreamFormat[], response: RemoteData<PaginatedList<BitstreamFormat>>) => {
+        return acc.concat(response.payload.page);
+      }, []),
+    );
+
+    const bitstream$ = this.bitstreamRD$.pipe(
       getFirstSucceededRemoteData(),
       getRemoteDataPayload(),
     );
@@ -493,14 +512,14 @@ export class EditBitstreamPageComponent implements OnInit, OnDestroy {
     this.subs.push(
       observableCombineLatest(
         bitstream$,
-        allFormats$,
+        bitstreamFormats$,
         bundle$,
         primaryBitstream$,
         item$,
       ).pipe()
         .subscribe(([bitstream, allFormats, bundle, primaryBitstream, item]) => {
           this.bitstream = bitstream as Bitstream;
-          this.formats = allFormats.page;
+          this.formats = allFormats;
           this.bundle = bundle;
           // hasValue(primaryBitstream) because if there's no primaryBitstream on the bundle it will
           // be a success response, but empty

src/app/core/data/bitstream-data.service.ts

@@ -241,11 +241,12 @@ export class BitstreamDataService extends IdentifiableDataService<Bitstream> imp
    *                                    no valid cached version. Defaults to true
    * @param reRequestOnStale            Whether or not the request should automatically be re-
    *                                    requested after the response becomes stale
+   * @param options                     the {@link FindListOptions} for the request
    * @return {Observable<Bitstream | null>}
    *    Return an observable that contains primary bitstream information or null
    */
-  public findPrimaryBitstreamByItemAndName(item: Item, bundleName: string, useCachedVersionIfAvailable = true, reRequestOnStale = true): Observable<Bitstream | null> {
-    return this.bundleService.findByItemAndName(item, bundleName, useCachedVersionIfAvailable, reRequestOnStale, followLink('primaryBitstream')).pipe(
+  public findPrimaryBitstreamByItemAndName(item: Item, bundleName: string, useCachedVersionIfAvailable = true, reRequestOnStale = true, options?: FindListOptions): Observable<Bitstream | null> {
+    return this.bundleService.findByItemAndName(item, bundleName, useCachedVersionIfAvailable, reRequestOnStale, options, followLink('primaryBitstream')).pipe(
       getFirstCompletedRemoteData(),
       switchMap((rd: RemoteData<Bundle>) => {
         if (!rd.hasSucceeded) {

src/app/core/data/bundle-data.service.ts

@@ -78,10 +78,11 @@ export class BundleDataService extends IdentifiableDataService<Bundle> implement
    *                                    requested after the response becomes stale
    * @param linksToFollow               List of {@link FollowLinkConfig} that indicate which
    *                                    {@link HALLink}s should be automatically resolved
+   * @param options                     the {@link FindListOptions} for the request
    */
   // TODO should be implemented rest side
-  findByItemAndName(item: Item, bundleName: string, useCachedVersionIfAvailable = true, reRequestOnStale = true, ...linksToFollow: FollowLinkConfig<Bundle>[]): Observable<RemoteData<Bundle>> {
-    return this.findAllByItem(item, { elementsPerPage: 9999 }, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow).pipe(
+  findByItemAndName(item: Item, bundleName: string, useCachedVersionIfAvailable = true, reRequestOnStale = true, options?: FindListOptions, ...linksToFollow: FollowLinkConfig<Bundle>[]): Observable<RemoteData<Bundle>> {
+    return this.findAllByItem(item, options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow).pipe(
       map((rd: RemoteData<PaginatedList<Bundle>>) => {
         if (hasValue(rd.payload) && hasValue(rd.payload.page)) {
           const matchingBundle = rd.payload.page.find((bundle: Bundle) =>
@@ -114,6 +115,47 @@ export class BundleDataService extends IdentifiableDataService<Bundle> implement
     );
   }
 
+  // findByItemAndName(item: Item, bundleName: string, useCachedVersionIfAvailable = true, reRequestOnStale = true, ...linksToFollow: FollowLinkConfig<Bundle>[]): Observable<RemoteData<Bundle>> {
+  //   return this.findAllByItem(item, { elementsPerPage: 1, currentPage: 1 }, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow).pipe(
+  //     expand((rd: RemoteData<PaginatedList<Bundle>>) => {
+  //       if (rd.hasSucceeded && hasValue(rd.payload) && hasValue(rd.payload.page) && rd.payload.currentPage < rd.payload.totalPages) {
+  //         const nextPageOptions = { elementsPerPage: 1, currentPage: rd.payload.currentPage + 1 };
+  //         return this.findAllByItem(item, nextPageOptions, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
+  //       } else {
+  //         return EMPTY;
+  //       }
+  //     }),
+  //     map((rd: RemoteData<PaginatedList<Bundle>>) => {
+  //       if (hasValue(rd.payload) && hasValue(rd.payload.page)) {
+  //         const matchingBundle = rd.payload.page.find((bundle: Bundle) => bundle.name === bundleName);
+  //         if (hasValue(matchingBundle)) {
+  //           return new RemoteData(
+  //             rd.timeCompleted,
+  //             rd.msToLive,
+  //             rd.lastUpdated,
+  //             RequestEntryState.Success,
+  //             null,
+  //             matchingBundle,
+  //             200
+  //           );
+  //         } else {
+  //           return new RemoteData(
+  //             rd.timeCompleted,
+  //             rd.msToLive,
+  //             rd.lastUpdated,
+  //             RequestEntryState.Error,
+  //             `The bundle with name ${bundleName} was not found.`,
+  //             null,
+  //             404
+  //           );
+  //         }
+  //       } else {
+  //         return rd as any;
+  //       }
+  //     })
+  //   );
+  // }
+
   /**
    * Get the bitstreams endpoint for a bundle
    * @param bundleId

src/app/core/data/relationship-type-data.service.ts

@@ -1,12 +1,15 @@
 import { Injectable } from '@angular/core';
 import {
   combineLatest as observableCombineLatest,
+  EMPTY,
+  from,
   Observable,
 } from 'rxjs';
 import {
+  expand,
   map,
   mergeMap,
-  switchMap,
+  reduce,
   toArray,
 } from 'rxjs/operators';
 
@@ -75,11 +78,26 @@ export class RelationshipTypeDataService extends BaseDataService<RelationshipTyp
    */
   getRelationshipTypeByLabelAndTypes(relationshipTypeLabel: string, firstItemType: string, secondItemType: string): Observable<RelationshipType> {
     // Retrieve all relationship types from the server in a single page
-    return this.findAllData.findAll({ currentPage: 1, elementsPerPage: 9999 }, true, true, followLink('leftType'), followLink('rightType'))
+    const initialPageInfo = { currentPage: 1, elementsPerPage: 20 };
+    return this.findAllData.findAll(initialPageInfo, true, true, followLink('leftType'), followLink('rightType'))
       .pipe(
         getFirstSucceededRemoteData(),
         // Emit each type in the page array separately
-        switchMap((typeListRD: RemoteData<PaginatedList<RelationshipType>>) => typeListRD.payload.page),
+        expand((typeListRD: RemoteData<PaginatedList<RelationshipType>>) => {
+          const currentPage = typeListRD.payload.pageInfo.currentPage;
+          const totalPages = typeListRD.payload.pageInfo.totalPages;
+          if (currentPage < totalPages) {
+            const nextPageInfo = { currentPage: currentPage + 1, elementsPerPage: 20 };
+            return this.findAllData.findAll(nextPageInfo, true, true, followLink('leftType'), followLink('rightType')).pipe(
+              getFirstSucceededRemoteData(),
+            );
+          } else {
+            return EMPTY;
+          }
+        }),
+        // Collect all pages into a single array
+        reduce((acc: RelationshipType[], typeListRD: RemoteData<PaginatedList<RelationshipType>>) => acc.concat(typeListRD.payload.page), []),
+        mergeMap((relationshipTypes: RelationshipType[]) => from(relationshipTypes)),
         // Check each type individually, to see if it matches the provided types
         mergeMap((relationshipType: RelationshipType) => {
           if (relationshipType.leftwardType === relationshipTypeLabel) {

src/app/core/metadata/head-tag.service.ts

@@ -50,6 +50,7 @@ import { coreSelector } from '../core.selectors';
 import { CoreState } from '../core-state.model';
 import { BundleDataService } from '../data/bundle-data.service';
 import { AuthorizationDataService } from '../data/feature-authorization/authorization-data.service';
+import { FindListOptions } from '../data/find-list-options.model';
 import { PaginatedList } from '../data/paginated-list.model';
 import { RemoteData } from '../data/remote-data';
 import { RootDataService } from '../data/root-data.service';
@@ -331,6 +332,7 @@ export class HeadTagService {
         'ORIGINAL',
         true,
         true,
+        new FindListOptions(),
         followLink('primaryBitstream'),
         followLink('bitstreams', {
           findListOptions: {

src/app/item-page/edit-item-page/item-bitstreams/item-bitstreams.component.html

@@ -39,6 +39,9 @@
                                    [isFirstTable]="isFirst"
                                    aria-describedby="reorder-description">
     </ds-item-edit-bitstream-bundle>
+    <div class="d-flex justify-content-center" *ngIf="showLoadMoreLink$ | async">
+      <div class="btn btn-link py-3" (click)="loadBundles()"> {{'item.edit.bitstreams.load-more.link' | translate}}</div>
+    </div>
   </div>
   <div *ngIf="bundles?.length === 0"
        class="alert alert-info w-100 d-inline-block mt-4" role="alert">