53029: start of filtered discovery pages

src/app/+search-page/search-filters/search-filter/search-fixed-filter.service.ts

+import { Injectable } from '@angular/core';
+import { debounceTime, distinctUntilChanged, flatMap, map } from 'rxjs/operators';
+import { SearchFiltersState, SearchFilterState } from './search-filter.reducer';
+import { createSelector, MemoizedSelector, Store } from '@ngrx/store';
+import { Observable } from 'rxjs/Observable';
+import {
+  SearchFilterCollapseAction,
+  SearchFilterDecrementPageAction, SearchFilterExpandAction,
+  SearchFilterIncrementPageAction,
+  SearchFilterInitialCollapseAction,
+  SearchFilterInitialExpandAction, SearchFilterResetPageAction,
+  SearchFilterToggleAction
+} from './search-filter.actions';
+import { hasValue, isEmpty, isNotEmpty, } from '../../../shared/empty.util';
+import { SearchFilterConfig } from '../../search-service/search-filter-config.model';
+import { SearchService } from '../../search-service/search.service';
+import { RouteService } from '../../../shared/route.service';
+import ObjectExpression from 'rollup/dist/typings/ast/nodes/ObjectExpression';
+import { SortDirection, SortOptions } from '../../../core/cache/models/sort-options.model';
+import { PaginationComponentOptions } from '../../../shared/pagination/pagination-component-options.model';
+import { SearchOptions } from '../../search-options.model';
+import { PaginatedSearchOptions } from '../../paginated-search-options.model';
+import { RemoteData } from '../../../core/data/remote-data';
+import { configureRequest } from '../../../core/shared/operators';
+import { HALEndpointService } from '../../../core/shared/hal-endpoint.service';
+import { GetRequest, RestRequest } from '../../../core/data/request.models';
+import { FacetConfigSuccessResponse } from '../../../core/cache/response-cache.models';
+import { ResponseCacheEntry } from '../../../core/cache/response-cache.reducer';
+import { RequestService } from '../../../core/data/request.service';
+import { ResponseCacheService } from '../../../core/cache/response-cache.service';
+import { SearchResponseParsingService } from '../../../core/data/search-response-parsing.service';
+import { ResponseParsingService } from '../../../core/data/parsing.service';
+import { GenericConstructor } from '../../../core/shared/generic-constructor';
+
+
+@Injectable()
+export class SearchFixedFilterService {
+  private queryByFilterPath = 'config/filtered-discovery-pages';
+
+  constructor(private routeService: RouteService,
+              protected requestService: RequestService,
+              protected responseCache: ResponseCacheService,
+              private halService: HALEndpointService) {
+
+  }
+
+  getQueryByFilterName(filterName?: string): Observable<RemoteData<SearchFilterConfig[]>> {
+    const requestObs = this.halService.getEndpoint(this.queryByFilterPath).pipe(
+      map((url: string) => {
+        url += ('/' + filterName);
+        const request = new GetRequest(this.requestService.generateRequestId(), url);
+        return Object.assign(request, {
+          getResponseParser(): GenericConstructor<ResponseParsingService> {
+            return FilterDiscoveryPageResponseParsingService;
+          }
+        });
+      }),
+    );
+
+    const requestEntryObs = requestObs.pipe(
+      flatMap((request: RestRequest) => this.requestService.getByHref(request.href))
+    );
+
+    const responseCacheObs = requestObs.pipe(
+      flatMap((request: RestRequest) => this.responseCache.get(request.href))
+    );
+
+    // get search results from response cache
+    const fixedFilterConfigObs: Observable<SearchFilterConfig[]> = responseCacheObs.pipe(
+      map((entry: ResponseCacheEntry) => entry.response),
+      map((response: FacetConfigSuccessResponse) =>
+        response.results.map((result: any) => Object.assign(new SearchFilterConfig(), result)))
+    );
+
+    return this.rdb.toRemoteDataObservable(requestEntryObs, responseCacheObs, facetConfigObs);
+  }
+
+}

src/app/core/data/base-response-parsing.service.ts

@@ -13,7 +13,7 @@ function isObjectLevel(halObj: any) {
 }
 
 function isPaginatedResponse(halObj: any) {
-  return isNotEmpty(halObj.page) && hasValue(halObj._embedded);
+  return isNotEmpty(halObj.page) /** && hasValue(halObj._embedded)**/;
 }
 
 /* tslint:disable:max-classes-per-file */

src/app/core/data/search-response-parsing.service.ts

@@ -16,7 +16,7 @@ export class SearchResponseParsingService implements ResponseParsingService {
   }
 
   parse(request: RestRequest, data: DSpaceRESTV2Response): RestResponse {
-    const payload = data.payload;
+    const payload = data.payload._embedded.searchResult;
     const hitHighlights = payload._embedded.objects
       .map((object) => object.hitHighlights)
       .map((hhObject) => {

src/app/shared/route.service.ts

 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
-import {
-  ActivatedRoute, convertToParamMap, NavigationExtras, Params,
-  Router,
-} from '@angular/router';
-import { isNotEmpty } from './empty.util';
+import { ActivatedRoute, Params, } from '@angular/router';
 
 @Injectable()
 export class RouteService {
@@ -28,16 +24,20 @@ export class RouteService {
     return this.route.queryParamMap.map((map) => map.getAll(paramName).indexOf(paramValue) > -1).distinctUntilChanged();
   }
 
+  getRouteParameterValue(paramName: string): Observable<string> {
+    return this.route.params.map((params) => params[paramName]).distinctUntilChanged();
+  }
+
   getQueryParamsWithPrefix(prefix: string): Observable<Params> {
     return this.route.queryParamMap
       .map((map) => {
-          const params = {};
-          map.keys
-            .filter((key) => key.startsWith(prefix))
-            .forEach((key) => {
-              params[key] = [...map.getAll(key)];
-            });
-          return params;
-        }).distinctUntilChanged();
+        const params = {};
+        map.keys
+          .filter((key) => key.startsWith(prefix))
+          .forEach((key) => {
+            params[key] = [...map.getAll(key)];
+          });
+        return params;
+      }).distinctUntilChanged();
   }
 }