Merge remote-tracking branch 'remotes/origin/master' into submission

# Conflicts:
#	resources/i18n/en.json
#	src/app/core/cache/builders/remote-data-build.service.ts
#	src/app/core/data/request.service.spec.ts
#	src/app/core/data/request.service.ts

src/app/core/data/request.service.ts

@@ -1,13 +1,12 @@
 import { Injectable } from '@angular/core';
 
 import { createSelector, MemoizedSelector, select, Store } from '@ngrx/store';
-import { merge as observableMerge, Observable, of as observableOf, race as observableRace } from 'rxjs';
-import { filter, map, mergeMap, switchMap, take } from 'rxjs/operators';
+import { Observable, race as observableRace } from 'rxjs';
+import { filter, mergeMap, take } from 'rxjs/operators';
 
-import { hasNoValue, hasValue, isNotEmpty } from '../../shared/empty.util';
+import { hasValue, isNotEmpty } from '../../shared/empty.util';
 import { CacheableObject } from '../cache/object-cache.reducer';
 import { ObjectCacheService } from '../cache/object-cache.service';
-import { DSOSuccessResponse, RestResponse } from '../cache/response.models';
 import { coreSelector, CoreState } from '../core.reducers';
 import { IndexName, IndexState } from '../index/index.reducer';
 import { pathSelector } from '../shared/selectors';
@@ -17,7 +16,6 @@ import { GetRequest, RestRequest } from './request.models';
 import { RequestEntry } from './request.reducer';
 import { CommitSSBAction } from '../cache/server-sync-buffer.actions';
 import { RestRequestMethod } from './rest-request-method';
-import { getResponseFromEntry } from '../shared/operators';
 import { AddToIndexAction, RemoveFromIndexBySubstringAction } from '../index/index.actions';
 
 @Injectable()
@@ -78,6 +76,9 @@ export class RequestService {
     return `client/${this.uuidService.generate()}`;
   }
 
+  /**
+   * Check if a request is currently pending
+   */
   isPending(request: GetRequest): boolean {
     // first check requests that haven't made it to the store yet
     if (this.requestsOnTheirWayToTheStore.includes(request.href)) {
@@ -91,10 +92,12 @@ export class RequestService {
       .subscribe((re: RequestEntry) => {
         isPending = (hasValue(re) && !re.completed)
       });
-
     return isPending;
   }
 
+  /**
+   * Retrieve a RequestEntry based on their uuid
+   */
   getByUUID(uuid: string): Observable<RequestEntry> {
     return observableRace(
       this.store.pipe(select(this.entryFromUUIDSelector(uuid))),
@@ -107,6 +110,9 @@ export class RequestService {
     );
   }
 
+  /**
+   * Retrieve a RequestEntry based on their href
+   */
   getByHref(href: string): Observable<RequestEntry> {
     return this.store.pipe(
       select(this.uuidFromHrefSelector(href)),
@@ -170,31 +176,11 @@ export class RequestService {
    * @param {GetRequest} request The request to check
    * @returns {boolean} True if the request is cached or still pending
    */
-  private isCachedOrPending(request: GetRequest) {
-    let isCached = this.objectCache.hasBySelfLink(request.href);
-    if (isCached) {
-      const responses: Observable<RestResponse> = this.isReusable(request.uuid).pipe(
-        filter((reusable: boolean) => reusable),
-        switchMap(() => {
-            return this.getByHref(request.href).pipe(
-              getResponseFromEntry(),
-              take(1)
-            );
-          }
-        ));
+  private isCachedOrPending(request: GetRequest): boolean {
+    const inReqCache = this.hasByHref(request.href);
+    const inObjCache = this.objectCache.hasBySelfLink(request.href);
+    const isCached = inReqCache || inObjCache;
 
-      const errorResponses = responses.pipe(filter((response) => !response.isSuccessful), map(() => true)); // TODO add a configurable number of retries in case of an error.
-      const dsoSuccessResponses = responses.pipe(
-        filter((response) => response.isSuccessful && hasValue((response as DSOSuccessResponse).resourceSelfLinks)),
-        map((response: DSOSuccessResponse) => response.resourceSelfLinks),
-        map((resourceSelfLinks: string[]) => resourceSelfLinks
-          .every((selfLink) => this.objectCache.hasBySelfLink(selfLink))
-        ));
-
-      const otherSuccessResponses = responses.pipe(filter((response) => response.isSuccessful && !hasValue((response as DSOSuccessResponse).resourceSelfLinks)), map(() => true));
-
-      observableMerge(errorResponses, otherSuccessResponses, dsoSuccessResponses).subscribe((c) => isCached = c);
-    }
     const isPending = this.isPending(request);
     return isCached || isPending;
   }
@@ -217,7 +203,7 @@ export class RequestService {
    */
   private trackRequestsOnTheirWayToTheStore(request: GetRequest) {
     this.requestsOnTheirWayToTheStore = [...this.requestsOnTheirWayToTheStore, request.href];
-    this.store.pipe(select(this.entryFromUUIDSelector(request.href)),
+    this.getByHref(request.href).pipe(
       filter((re: RequestEntry) => hasValue(re)),
       take(1)
     ).subscribe((re: RequestEntry) => {
@@ -234,31 +220,39 @@ export class RequestService {
   }
 
   /**
-   * Check whether a Response should still be cached
+   * Check whether a cached response should still be valid
    *
-   * @param uuid
-   *    the uuid of the entry to check
+   * @param entry
+   *    the entry to check
    * @return boolean
-   *    false if the uuid has no value, no entry could be found, the response was nog successful or its time to
-   *    live has exceeded, true otherwise
+   *    false if the uuid has no value, the response was not successful or its time to
+   *    live was exceeded, true otherwise
    */
-  private isReusable(uuid: string): Observable<boolean> {
-    if (hasNoValue(uuid)) {
-      return observableOf(false);
+  private isValid(entry: RequestEntry): boolean {
+    if (hasValue(entry) && entry.completed && entry.response.isSuccessful) {
+      const timeOutdated = entry.response.timeAdded + entry.request.responseMsToLive;
+      const isOutDated = new Date().getTime() > timeOutdated;
+      return !isOutDated;
     } else {
-      const requestEntry$ = this.getByUUID(uuid);
-      return requestEntry$.pipe(
-        filter((entry: RequestEntry) => hasValue(entry) && hasValue(entry.response)),
-        map((entry: RequestEntry) => {
-          if (hasValue(entry) && entry.response.isSuccessful) {
-            const timeOutdated = entry.response.timeAdded + entry.request.responseMsToLive;
-            const isOutDated = new Date().getTime() > timeOutdated;
-            return !isOutDated;
-          } else {
-            return false;
-          }
-        })
-      );
+      return false;
     }
   }
+
+  /**
+   * Check whether the request with the specified href is cached
+   *
+   * @param href
+   *    The link of the request to check
+   * @return boolean
+   *    true if the request with the specified href is cached,
+   *    false otherwise
+   */
+  hasByHref(href: string): boolean {
+    let result = false;
+    this.getByHref(href).pipe(
+      take(1)
+    ).subscribe((requestEntry: RequestEntry) => result = this.isValid(requestEntry));
+    return result;
+  }
+
 }