50632: Replaced mock registry service with implementation and added pagination

src/app/+admin/admin-registries/admin-registries.module.ts

@@ -6,10 +6,12 @@ import { MetadataSchemaComponent } from './metadata-schema/metadata-schema.compo
 import { RouterModule } from '@angular/router';
 import { TranslateModule } from '@ngx-translate/core';
 import { BitstreamFormatsComponent } from './bitstream-formats/bitstream-formats.component';
+import { SharedModule } from '../../shared/shared.module';
 
 @NgModule({
   imports: [
     CommonModule,
+    SharedModule,
     RouterModule,
     TranslateModule,
     AdminRegistriesRoutingModule

src/app/+admin/admin-registries/bitstream-formats/bitstream-formats.component.html

@@ -6,6 +6,14 @@
 
       <p id="description" class="pb-2">{{'admin.registries.bitstream-formats.description' | translate}}</p>
 
+      <ds-pagination
+        *ngIf="(bitstreamFormats | async)?.payload"
+        [paginationOptions]="config"
+        [pageInfoState]="(bitstreamFormats | async)?.payload"
+        [collectionSize]="(bitstreamFormats | async)?.payload?.totalElements"
+        [hideGear]="true"
+        [hidePagerWhenSinglePage]="false"
+        (pageChange)="onPageChange($event)">
         <div class="table-responsive">
           <table id="formats" class="table table-striped table-hover">
             <thead>
@@ -24,6 +32,7 @@
             </tbody>
           </table>
         </div>
+      </ds-pagination>
 
     </div>
   </div>

src/app/+admin/admin-registries/bitstream-formats/bitstream-formats.component.ts

@@ -4,6 +4,7 @@ import { Observable } from 'rxjs/Observable';
 import { RemoteData } from '../../../core/data/remote-data';
 import { PaginatedList } from '../../../core/data/paginated-list';
 import { BitstreamFormat } from '../../../core/registry/mock-bitstream-format.model';
+import { PaginationComponentOptions } from '../../../shared/pagination/pagination-component-options.model';
 
 @Component({
   selector: 'ds-bitstream-formats',
@@ -12,8 +13,21 @@ import { BitstreamFormat } from '../../../core/registry/mock-bitstream-format.mo
 export class BitstreamFormatsComponent {
 
   bitstreamFormats: Observable<RemoteData<PaginatedList<BitstreamFormat>>>;
+  config: PaginationComponentOptions = Object.assign(new PaginationComponentOptions(), {
+    id: 'registry-bitstreamformats-pagination',
+    pageSize: 20
+  });
 
-  constructor(registryService: RegistryService) {
+  constructor(private registryService: RegistryService) {
-    this.bitstreamFormats = registryService.getBitstreamFormats();
+    this.updateFormats();
+  }
+
+  onPageChange(event) {
+    this.config.currentPage = event;
+    this.updateFormats();
+  }
+
+  private updateFormats() {
+    this.bitstreamFormats = this.registryService.getBitstreamFormats(this.config);
   }
 }

src/app/+admin/admin-registries/metadata-registry/metadata-registry.component.html

@@ -6,6 +6,14 @@
 
       <p id="description" class="pb-2">{{'admin.registries.metadata.description' | translate}}</p>
 
+      <ds-pagination
+        *ngIf="(metadataSchemas | async)?.payload"
+        [paginationOptions]="config"
+        [pageInfoState]="(metadataSchemas | async)?.payload"
+        [collectionSize]="(metadataSchemas | async)?.payload?.totalElements"
+        [hideGear]="true"
+        [hidePagerWhenSinglePage]="false"
+        (pageChange)="onPageChange($event)">
         <div class="table-responsive">
           <table id="metadata-schemas" class="table table-striped table-hover">
             <thead>
@@ -24,6 +32,7 @@
             </tbody>
           </table>
         </div>
+      </ds-pagination>
 
     </div>
   </div>

src/app/+admin/admin-registries/metadata-registry/metadata-registry.component.ts

@@ -4,6 +4,7 @@ import { Observable } from 'rxjs/Observable';
 import { RemoteData } from '../../../core/data/remote-data';
 import { PaginatedList } from '../../../core/data/paginated-list';
 import { MetadataSchema } from '../../../core/metadata/metadataschema.model';
+import { PaginationComponentOptions } from '../../../shared/pagination/pagination-component-options.model';
 
 @Component({
   selector: 'ds-metadata-registry',
@@ -12,9 +13,22 @@ import { MetadataSchema } from '../../../core/metadata/metadataschema.model';
 export class MetadataRegistryComponent {
 
   metadataSchemas: Observable<RemoteData<PaginatedList<MetadataSchema>>>;
+  config: PaginationComponentOptions = Object.assign(new PaginationComponentOptions(), {
+    id: 'registry-metadataschemas-pagination',
+    pageSize: 10
+  });
 
   constructor(private registryService: RegistryService) {
-    this.metadataSchemas = this.registryService.getMetadataSchemas();
+    this.updateSchemas();
+  }
+
+  onPageChange(event) {
+    this.config.currentPage = event;
+    this.updateSchemas();
+  }
+
+  private updateSchemas() {
+    this.metadataSchemas = this.registryService.getMetadataSchemas(this.config);
   }
 
 }

src/app/+admin/admin-registries/metadata-schema/metadata-schema.component.html

@@ -7,6 +7,14 @@
       <p id="description" class="pb-2">{{'admin.registries.schema.description' | translate:namespace }}</p>
 
       <h3>{{'admin.registries.schema.fields.head' | translate}}</h3>
+      <ds-pagination
+        *ngIf="(metadataFields | async)?.payload"
+        [paginationOptions]="config"
+        [pageInfoState]="(metadataFields | async)?.payload"
+        [collectionSize]="(metadataFields | async)?.payload?.totalElements"
+        [hideGear]="true"
+        [hidePagerWhenSinglePage]="false"
+        (pageChange)="onPageChange($event)">
         <div class="table-responsive">
           <table id="metadata-fields" class="table table-striped table-hover">
             <thead>
@@ -18,11 +26,12 @@
             <tbody>
               <tr *ngFor="let field of (metadataFields | async)?.payload?.page">
                 <td>{{(metadataSchema | async)?.payload?.prefix}}.{{field.element}}<label *ngIf="field.qualifier">.</label>{{field.qualifier}}</td>
-              <td>{{field.scopenote}}</td>
+                <td>{{field.scopeNote}}</td>
               </tr>
             </tbody>
           </table>
         </div>
+      </ds-pagination>
 
     </div>
   </div>

src/app/+admin/admin-registries/metadata-schema/metadata-schema.component.ts

@@ -6,6 +6,8 @@ import { RemoteData } from '../../../core/data/remote-data';
 import { PaginatedList } from '../../../core/data/paginated-list';
 import { MetadataField } from '../../../core/metadata/metadatafield.model';
 import { MetadataSchema } from '../../../core/metadata/metadataschema.model';
+import { PaginationComponentOptions } from '../../../shared/pagination/pagination-component-options.model';
+import { SortOptions } from '../../../core/cache/models/sort-options.model';
 
 @Component({
   selector: 'ds-metadata-schema',
@@ -17,6 +19,10 @@ export class MetadataSchemaComponent implements OnInit {
 
   metadataSchema: Observable<RemoteData<MetadataSchema>>;
   metadataFields: Observable<RemoteData<PaginatedList<MetadataField>>>;
+  config: PaginationComponentOptions = Object.assign(new PaginationComponentOptions(), {
+    id: 'registry-metadatafields-pagination',
+    pageSize: 20
+  });
 
   constructor(private registryService: RegistryService, private route: ActivatedRoute) {
 
@@ -30,10 +36,19 @@ export class MetadataSchemaComponent implements OnInit {
 
   initialize(params) {
     this.metadataSchema = this.registryService.getMetadataSchemaByName(params.schemaName);
-    this.metadataSchema.subscribe((value) => {
+    this.updateFields();
-      const schema = value.payload;
+  }
-      // this.metadataFields = this.registryService.getMetadataFieldsBySchema(schema);
+
-      this.namespace = { namespace: value.payload.namespace };
+  onPageChange(event) {
+    this.config.currentPage = event;
+    this.updateFields();
+  }
+
+  private updateFields() {
+    this.metadataSchema.subscribe((schemaData) => {
+      const schema = schemaData.payload;
+      this.metadataFields = this.registryService.getMetadataFieldsBySchema(schema, this.config);
+      this.namespace = { namespace: schemaData.payload.namespace };
     });
   }
 

src/app/core/cache/response-cache.models.ts

@@ -7,6 +7,8 @@ import { FacetValue } from '../../+search-page/search-service/facet-value.model'
 import { SearchFilterConfig } from '../../+search-page/search-service/search-filter-config.model';
 import { RegistryMetadataschemasResponse } from '../registry/registry-metadataschemas-response.model';
 import { MetadataSchema } from '../metadata/metadataschema.model';
+import { RegistryMetadatafieldsResponse } from '../registry/registry-metadatafields-response.model';
+import { RegistryBitstreamformatsResponse } from '../registry/registry-bitstreamformats-response.model';
 
 /* tslint:disable:max-classes-per-file */
 export class RestResponse {
@@ -36,6 +38,26 @@ export class RegistryMetadataschemasSuccessResponse extends RestResponse {
   }
 }
 
+export class RegistryMetadatafieldsSuccessResponse extends RestResponse {
+  constructor(
+    public metadatafieldsResponse: RegistryMetadatafieldsResponse,
+    public statusCode: string,
+    public pageInfo?: PageInfo
+  ) {
+    super(true, statusCode);
+  }
+}
+
+export class RegistryBitstreamformatsSuccessResponse extends RestResponse {
+  constructor(
+    public bitstreamformatsResponse: RegistryBitstreamformatsResponse,
+    public statusCode: string,
+    public pageInfo?: PageInfo
+  ) {
+    super(true, statusCode);
+  }
+}
+
 export class MetadataschemaSuccessResponse extends RestResponse {
   constructor(
     public metadataschema: MetadataSchema,

src/app/core/core.module.ts

@@ -47,6 +47,8 @@ import { FacetConfigResponseParsingService } from './data/facet-config-response-
 import { RegistryService } from './registry/registry.service';
 import { RegistryMetadataschemasResponseParsingService } from './data/registry-metadataschemas-response-parsing.service';
 import { MetadataschemaParsingService } from './data/metadataschema-parsing.service';
+import { RegistryMetadatafieldsResponseParsingService } from './data/registry-metadatafields-response-parsing.service';
+import { RegistryBitstreamformatsResponseParsingService } from './data/registry-bitstreamformats-response-parsing.service';
 
 const IMPORTS = [
   CommonModule,
@@ -83,6 +85,8 @@ const PROVIDERS = [
   FacetValueMapResponseParsingService,
   FacetConfigResponseParsingService,
   RegistryMetadataschemasResponseParsingService,
+  RegistryMetadatafieldsResponseParsingService,
+  RegistryBitstreamformatsResponseParsingService,
   MetadataschemaParsingService,
   DebugResponseParsingService,
   SearchResponseParsingService,

src/app/core/data/registry-bitstreamformats-response-parsing.service.ts

@@ -0,0 +1,25 @@
+import { RegistryBitstreamformatsSuccessResponse, RestResponse } from '../cache/response-cache.models';
+import { RegistryBitstreamformatsResponse } from '../registry/registry-bitstreamformats-response.model';
+import { DSpaceRESTv2Serializer } from '../dspace-rest-v2/dspace-rest-v2.serializer';
+import { DSpaceRESTV2Response } from '../dspace-rest-v2/dspace-rest-v2-response.model';
+import { RestRequest } from './request.models';
+import { DSOResponseParsingService } from './dso-response-parsing.service';
+import { ResponseParsingService } from './parsing.service';
+import { Injectable } from '@angular/core';
+
+@Injectable()
+export class RegistryBitstreamformatsResponseParsingService implements ResponseParsingService {
+  constructor(private dsoParser: DSOResponseParsingService) {
+  }
+
+  parse(request: RestRequest, data: DSpaceRESTV2Response): RestResponse {
+    const payload = data.payload;
+
+    const bitstreamformats = payload._embedded.bitstreamformats;
+    payload.bitstreamformats = bitstreamformats;
+
+    const deserialized = new DSpaceRESTv2Serializer(RegistryBitstreamformatsResponse).deserialize(payload);
+    return new RegistryBitstreamformatsSuccessResponse(deserialized, data.statusCode, this.dsoParser.processPageInfo(data.payload.page));
+  }
+
+}

src/app/core/data/registry-metadatafields-response-parsing.service.ts

@@ -0,0 +1,34 @@
+import {
+  RegistryMetadatafieldsSuccessResponse, RegistryMetadataschemasSuccessResponse,
+  RestResponse
+} from '../cache/response-cache.models';
+import { DSpaceRESTV2Response } from '../dspace-rest-v2/dspace-rest-v2-response.model';
+import { RestRequest } from './request.models';
+import { ResponseParsingService } from './parsing.service';
+import { RegistryMetadataschemasResponse } from '../registry/registry-metadataschemas-response.model';
+import { DSpaceRESTv2Serializer } from '../dspace-rest-v2/dspace-rest-v2.serializer';
+import { DSOResponseParsingService } from './dso-response-parsing.service';
+import { Injectable } from '@angular/core';
+import { forEach } from '@angular/router/src/utils/collection';
+import { RegistryMetadatafieldsResponse } from '../registry/registry-metadatafields-response.model';
+
+@Injectable()
+export class RegistryMetadatafieldsResponseParsingService implements ResponseParsingService {
+  constructor(private dsoParser: DSOResponseParsingService) {
+  }
+
+  parse(request: RestRequest, data: DSpaceRESTV2Response): RestResponse {
+    const payload = data.payload;
+
+    const metadatafields = payload._embedded.metadatafields;
+    metadatafields.forEach((field) => {
+      field.schema = field._embedded.schema;
+    });
+
+    payload.metadatafields = metadatafields;
+
+    const deserialized = new DSpaceRESTv2Serializer(RegistryMetadatafieldsResponse).deserialize(payload);
+    return new RegistryMetadatafieldsSuccessResponse(deserialized, data.statusCode, this.dsoParser.processPageInfo(data.payload.page));
+  }
+
+}

src/app/core/metadata/metadatafield.model.ts

@@ -1,9 +1,20 @@
 import { MetadataSchema } from './metadataschema.model';
+import { autoserialize } from 'cerialize';
+import { ListableObject } from '../../shared/object-collection/shared/listable-object.model';
 
-export class MetadataField {
+export class MetadataField implements ListableObject {
+  @autoserialize
   self: string;
+
+  @autoserialize
   element: string;
+
+  @autoserialize
   qualifier: string;
-  scopenote: string;
+
+  @autoserialize
+  scopeNote: string;
+
+  @autoserialize
   schema: MetadataSchema;
 }

src/app/core/registry/registry-bitstreamformats-response.model.ts

@@ -0,0 +1,14 @@
+import { autoserialize, autoserializeAs } from 'cerialize';
+import { PageInfo } from '../shared/page-info.model';
+import { BitstreamFormat } from '../shared/bitstream-format.model';
+
+export class RegistryBitstreamformatsResponse {
+  @autoserializeAs(BitstreamFormat)
+  bitstreamformats: BitstreamFormat[];
+
+  @autoserialize
+  page: PageInfo;
+
+  @autoserialize
+  self: string;
+}

src/app/core/registry/registry-metadatafields-response.model.ts

@@ -0,0 +1,14 @@
+import { PageInfo } from '../shared/page-info.model';
+import { autoserialize, autoserializeAs } from 'cerialize';
+import { MetadataField } from '../metadata/metadatafield.model';
+
+export class RegistryMetadatafieldsResponse {
+  @autoserializeAs(MetadataField)
+  metadatafields: MetadataField[];
+
+  @autoserialize
+  page: PageInfo;
+
+  @autoserialize
+  self: string;
+}

src/app/core/registry/registry.service.ts

@@ -16,18 +16,27 @@ import { RequestService } from '../data/request.service';
 import { ResponseCacheService } from '../cache/response-cache.service';
 import { RegistryMetadataschemasResponse } from './registry-metadataschemas-response.model';
 import { ResponseCacheEntry } from '../cache/response-cache.reducer';
-import { MetadataschemaSuccessResponse, RegistryMetadataschemasSuccessResponse } from '../cache/response-cache.models';
+import {
+  MetadataschemaSuccessResponse, RegistryBitstreamformatsSuccessResponse, RegistryMetadatafieldsSuccessResponse,
+  RegistryMetadataschemasSuccessResponse
+} from '../cache/response-cache.models';
 import { HALEndpointService } from '../shared/hal-endpoint.service';
 import { MetadataschemaParsingService } from '../data/metadataschema-parsing.service';
+import { Res } from 'awesome-typescript-loader/dist/checker/protocol';
+import { RegistryMetadatafieldsResponseParsingService } from '../data/registry-metadatafields-response-parsing.service';
+import { RegistryMetadatafieldsResponse } from './registry-metadatafields-response.model';
+import { isNotEmpty } from '../../shared/empty.util';
+import { URLCombiner } from '../url-combiner/url-combiner';
+import { PaginationComponentOptions } from '../../shared/pagination/pagination-component-options.model';
+import { RegistryBitstreamformatsResponseParsingService } from '../data/registry-bitstreamformats-response-parsing.service';
+import { RegistryBitstreamformatsResponse } from './registry-bitstreamformats-response.model';
 
 @Injectable()
 export class RegistryService {
 
   private metadataSchemasPath = 'metadataschemas';
-
+  private metadataFieldsPath = 'metadatafields';
-  metadataSchemas: MetadataSchema[];
+  private bitstreamFormatsPath = 'bitstreamformats';
-  metadataFields: MetadataField[];
-  bitstreamFormats: BitstreamFormat[];
 
   constructor(protected responseCache: ResponseCacheService,
               protected requestService: RequestService,
@@ -36,18 +45,8 @@ export class RegistryService {
 
   }
 
-  public getMetadataSchemas(): Observable<RemoteData<PaginatedList<MetadataSchema>>> {
+  public getMetadataSchemas(pagination: PaginationComponentOptions): Observable<RemoteData<PaginatedList<MetadataSchema>>> {
-    const requestObs = this.halService.getEndpoint(this.metadataSchemasPath).pipe(
+    const requestObs = this.getMetadataSchemasRequestObs(pagination);
-      map((url: string) => {
-        const request = new GetRequest(this.requestService.generateRequestId(), url);
-        return Object.assign(request, {
-          getResponseParser(): GenericConstructor<ResponseParsingService> {
-            return RegistryMetadataschemasResponseParsingService;
-          }
-        });
-      }),
-      tap((request: RestRequest) => this.requestService.configure(request)),
-    );
 
     const requestEntryObs = requestObs.pipe(
       flatMap((request: RestRequest) => this.requestService.getByHref(request.href))
@@ -79,17 +78,12 @@ export class RegistryService {
   }
 
   public getMetadataSchemaByName(schemaName: string): Observable<RemoteData<MetadataSchema>> {
-    const requestObs = this.halService.getEndpoint(this.metadataSchemasPath).pipe(
+    // Temporary pagination to get ALL metadataschemas until there's a rest api endpoint for fetching a specific schema
-      map((url: string) => {
+    const pagination: PaginationComponentOptions = Object.assign(new PaginationComponentOptions(), {
-        const request = new GetRequest(this.requestService.generateRequestId(), url);
+      id: 'all-metadatafields-pagination',
-        return Object.assign(request, {
+      pageSize: 10000
-          getResponseParser(): GenericConstructor<ResponseParsingService> {
-            return RegistryMetadataschemasResponseParsingService;
-          }
     });
-      }),
+    const requestObs = this.getMetadataSchemasRequestObs(pagination);
-      tap((request: RestRequest) => this.requestService.configure(request)),
-    );
 
     const requestEntryObs = requestObs.pipe(
       flatMap((request: RestRequest) => this.requestService.getByHref(request.href))
@@ -112,24 +106,129 @@ export class RegistryService {
     return this.rdb.toRemoteDataObservable(requestEntryObs, responseCacheObs, metadataschemaObs);
   }
 
-  public getMetadataFieldsBySchema(schema: MetadataSchema): Observable<RemoteData<PaginatedList<MetadataField>>> {
+  public getMetadataFieldsBySchema(schema: MetadataSchema, pagination: PaginationComponentOptions): Observable<RemoteData<PaginatedList<MetadataField>>> {
-    const pageInfo = new PageInfo();
+    const requestObs = this.getMetadataFieldsRequestObs(pagination);
-    pageInfo.elementsPerPage = 10;
-    pageInfo.currentPage = 1;
 
-    const payload = new PaginatedList(pageInfo, this.metadataFields.filter((value) => value.schema === schema));
+    const requestEntryObs = requestObs.pipe(
-    const remoteData = new RemoteData(false, false, true, undefined, payload);
+      flatMap((request: RestRequest) => this.requestService.getByHref(request.href))
-    return Observable.of(remoteData);
+    );
+
+    const responseCacheObs = requestObs.pipe(
+      flatMap((request: RestRequest) => this.responseCache.get(request.href))
+    );
+
+    const rmrObs: Observable<RegistryMetadatafieldsResponse> = responseCacheObs.pipe(
+      map((entry: ResponseCacheEntry) => entry.response),
+      map((response: RegistryMetadatafieldsSuccessResponse) => response.metadatafieldsResponse)
+    );
+
+    const metadatafieldsObs: Observable<MetadataField[]> = rmrObs.pipe(
+      map((rmr: RegistryMetadatafieldsResponse) => rmr.metadatafields),
+      map((metadataFields: MetadataField[]) => metadataFields.filter((field) => field.schema.id === schema.id))
+    );
+
+    const pageInfoObs: Observable<PageInfo> = responseCacheObs.pipe(
+      map((entry: ResponseCacheEntry) => entry.response),
+      map((response: RegistryMetadatafieldsSuccessResponse) => response.pageInfo)
+    );
+
+    const payloadObs = Observable.combineLatest(metadatafieldsObs, pageInfoObs, (metadatafields, pageInfo) => {
+      return new PaginatedList(pageInfo, metadatafields);
+    });
+
+    return this.rdb.toRemoteDataObservable(requestEntryObs, responseCacheObs, payloadObs);
   }
 
-  public getBitstreamFormats(): Observable<RemoteData<PaginatedList<BitstreamFormat>>> {
+  public getBitstreamFormats(pagination: PaginationComponentOptions): Observable<RemoteData<PaginatedList<BitstreamFormat>>> {
-    const pageInfo = new PageInfo();
+    const requestObs = this.getBitstreamFormatsRequestObs(pagination);
-    pageInfo.elementsPerPage = 10;
-    pageInfo.currentPage = 1;
 
-    const payload = new PaginatedList(pageInfo, this.bitstreamFormats);
+    const requestEntryObs = requestObs.pipe(
-    const remoteData = new RemoteData(false, false, true, undefined, payload);
+      flatMap((request: RestRequest) => this.requestService.getByHref(request.href))
-    return Observable.of(remoteData);
+    );
+
+    const responseCacheObs = requestObs.pipe(
+      flatMap((request: RestRequest) => this.responseCache.get(request.href))
+    );
+
+    const rbrObs: Observable<RegistryBitstreamformatsResponse> = responseCacheObs.pipe(
+      map((entry: ResponseCacheEntry) => entry.response),
+      map((response: RegistryBitstreamformatsSuccessResponse) => response.bitstreamformatsResponse)
+    );
+
+    const bitstreamformatsObs: Observable<BitstreamFormat[]> = rbrObs.pipe(
+      map((rbr: RegistryBitstreamformatsResponse) => rbr.bitstreamformats)
+    );
+
+    const pageInfoObs: Observable<PageInfo> = responseCacheObs.pipe(
+      map((entry: ResponseCacheEntry) => entry.response),
+      map((response: RegistryBitstreamformatsSuccessResponse) => response.pageInfo)
+    );
+
+    const payloadObs = Observable.combineLatest(bitstreamformatsObs, pageInfoObs, (bitstreamformats, pageInfo) => {
+      return new PaginatedList(pageInfo, bitstreamformats);
+    });
+
+    return this.rdb.toRemoteDataObservable(requestEntryObs, responseCacheObs, payloadObs);
+  }
+
+  private getMetadataSchemasRequestObs(pagination: PaginationComponentOptions): Observable<RestRequest> {
+    return this.halService.getEndpoint(this.metadataSchemasPath).pipe(
+      map((url: string) => {
+        const args: string[] = [];
+        args.push(`size=${pagination.pageSize}`);
+        args.push(`page=${pagination.currentPage - 1}`);
+        if (isNotEmpty(args)) {
+          url = new URLCombiner(url, `?${args.join('&')}`).toString();
+        }
+        const request = new GetRequest(this.requestService.generateRequestId(), url);
+        return Object.assign(request, {
+          getResponseParser(): GenericConstructor<ResponseParsingService> {
+            return RegistryMetadataschemasResponseParsingService;
+          }
+        });
+      }),
+      tap((request: RestRequest) => this.requestService.configure(request)),
+    );
+  }
+
+  private getMetadataFieldsRequestObs(pagination: PaginationComponentOptions): Observable<RestRequest> {
+    return this.halService.getEndpoint(this.metadataFieldsPath).pipe(
+      map((url: string) => {
+        const args: string[] = [];
+        args.push(`size=${pagination.pageSize}`);
+        args.push(`page=${pagination.currentPage - 1}`);
+        if (isNotEmpty(args)) {
+          url = new URLCombiner(url, `?${args.join('&')}`).toString();
+        }
+        const request = new GetRequest(this.requestService.generateRequestId(), url);
+        return Object.assign(request, {
+          getResponseParser(): GenericConstructor<ResponseParsingService> {
+            return RegistryMetadatafieldsResponseParsingService;
+          }
+        });
+      }),
+      tap((request: RestRequest) => this.requestService.configure(request)),
+    );
+  }
+
+  private getBitstreamFormatsRequestObs(pagination: PaginationComponentOptions): Observable<RestRequest> {
+    return this.halService.getEndpoint(this.bitstreamFormatsPath).pipe(
+      map((url: string) => {
+        const args: string[] = [];
+        args.push(`size=${pagination.pageSize}`);
+        args.push(`page=${pagination.currentPage - 1}`);
+        if (isNotEmpty(args)) {
+          url = new URLCombiner(url, `?${args.join('&')}`).toString();
+        }
+        const request = new GetRequest(this.requestService.generateRequestId(), url);
+        return Object.assign(request, {
+          getResponseParser(): GenericConstructor<ResponseParsingService> {
+            return RegistryBitstreamformatsResponseParsingService;
+          }
+        });
+      }),
+      tap((request: RestRequest) => this.requestService.configure(request)),
+    );
   }
 
 }

src/app/shared/pagination/pagination.component.ts

@@ -207,8 +207,10 @@ export class PaginationComponent implements OnDestroy, OnInit {
     this.pageSizeOptions = this.paginationOptions.pageSizeOptions;
     this.currentPage = this.paginationOptions.currentPage;
     this.pageSize = this.paginationOptions.pageSize;
+    if (this.sortOptions) {
       this.sortDirection = this.sortOptions.direction;
       this.sortField = this.sortOptions.field;
+    }
     this.currentQueryParams = {
       pageId: this.id,
       page: this.currentPage,