Merge pull request DSpace#2897 from 4Science/DURACOM-247

Fixes for DSpace#2891 DSpace#2889

Author: tdonohue

src/app/core/cache/builders/link.service.spec.ts

@@ -37,9 +37,9 @@ class TestModel implements HALResource {
   successor?: TestModel;
 }
 
-const mockDataServiceMap: any = {
-  [TEST_MODEL.value]: () => import('../../../shared/testing/test-data-service.mock').then(m => m.TestDataService),
-};
+const mockDataServiceMap: any = new Map([
+  [TEST_MODEL.value, () => import('../../../shared/testing/test-data-service.mock').then(m => m.TestDataService)],
+]);
 
 let testDataService: TestDataService;
 

src/app/core/cache/builders/link.service.ts

@@ -1,7 +1,6 @@
 import {
   Inject,
   Injectable,
-  InjectionToken,
   Injector,
 } from '@angular/core';
 import {
@@ -25,7 +24,7 @@ import { FollowLinkConfig } from '../../../shared/utils/follow-link-config.model
 import { HALDataService } from '../../data/base/hal-data-service.interface';
 import { PaginatedList } from '../../data/paginated-list.model';
 import { RemoteData } from '../../data/remote-data';
-import { lazyService } from '../../lazy-service';
+import { lazyDataService } from '../../lazy-data-service';
 import { GenericConstructor } from '../../shared/generic-constructor';
 import { HALResource } from '../../shared/hal-resource.model';
 import {
@@ -43,7 +42,7 @@ export class LinkService {
 
   constructor(
     protected injector: Injector,
-    @Inject(APP_DATA_SERVICES_MAP) private map: InjectionToken<LazyDataServicesMap>,
+    @Inject(APP_DATA_SERVICES_MAP) private map: LazyDataServicesMap,
     @Inject(LINK_DEFINITION_FACTORY) private getLinkDefinition: <T extends HALResource>(source: GenericConstructor<T>, linkName: keyof T['_links']) => LinkDefinition<T>,
     @Inject(LINK_DEFINITION_MAP_FACTORY) private getLinkDefinitions: <T extends HALResource>(source: GenericConstructor<T>) => Map<keyof T['_links'], LinkDefinition<T>>,
   ) {
@@ -73,7 +72,7 @@ export class LinkService {
   public resolveLinkWithoutAttaching<T extends HALResource, U extends HALResource>(model, linkToFollow: FollowLinkConfig<T>): Observable<RemoteData<U | PaginatedList<U>>> {
     const matchingLinkDef = this.getLinkDefinition(model.constructor, linkToFollow.name);
     if (hasValue(matchingLinkDef)) {
-      const lazyProvider$: Observable<HALDataService<any>> = lazyService(this.map[matchingLinkDef.resourceType.value], this.injector);
+      const lazyProvider$: Observable<HALDataService<any>> = lazyDataService(this.map, matchingLinkDef.resourceType.value, this.injector);
       return lazyProvider$.pipe(
         switchMap((provider: HALDataService<any>) => {
           const link = model._links[matchingLinkDef.linkName];

src/app/core/data-services-map.ts

@@ -13,6 +13,7 @@ import {
   map,
   mergeMap,
   take,
+  withLatestFrom,
 } from 'rxjs/operators';
 
 import {
@@ -25,6 +26,7 @@ import { ParsedResponse } from '../cache/response.models';
 import { DSpaceSerializer } from '../dspace-rest/dspace.serializer';
 import { DspaceRestService } from '../dspace-rest/dspace-rest.service';
 import { RawRestResponse } from '../dspace-rest/raw-rest-response.model';
+import { XSRFService } from '../xsrf/xsrf.service';
 import {
   RequestActionTypes,
   RequestErrorAction,
@@ -35,6 +37,7 @@ import {
 import { RequestService } from './request.service';
 import { RequestEntry } from './request-entry.model';
 import { RequestError } from './request-error.model';
+import { RestRequestMethod } from './rest-request-method';
 import { RestRequestWithResponseParser } from './rest-request-with-response-parser.model';
 
 @Injectable()
@@ -48,7 +51,11 @@ export class RequestEffects {
       );
     }),
     filter((entry: RequestEntry) => hasValue(entry)),
-    map((entry: RequestEntry) => entry.request),
+    withLatestFrom(this.xsrfService.tokenInitialized$),
+    // If it's a GET request, or we have an XSRF token, dispatch it immediately
+    // Otherwise wait for the XSRF token first
+    filter(([entry, tokenInitialized]: [RequestEntry, boolean]) => entry.request.method === RestRequestMethod.GET || tokenInitialized === true),
+    map(([entry, tokenInitialized]: [RequestEntry, boolean]) => entry.request),
     mergeMap((request: RestRequestWithResponseParser) => {
       let body = request.body;
       if (isNotEmpty(request.body) && !request.isMultipart) {
@@ -89,6 +96,7 @@ export class RequestEffects {
     private restApi: DspaceRestService,
     private injector: Injector,
     protected requestService: RequestService,
+    protected xsrfService: XSRFService,
   ) { }
 
 }

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

@@ -17,7 +17,6 @@ import {
   getTestScheduler,
 } from 'jasmine-marbles';
 import {
-  BehaviorSubject,
   EMPTY,
   Observable,
   of as observableOf,
@@ -34,7 +33,6 @@ import { ObjectCacheService } from '../cache/object-cache.service';
 import { coreReducers } from '../core.reducers';
 import { CoreState } from '../core-state.model';
 import { UUIDService } from '../shared/uuid.service';
-import { XSRFService } from '../xsrf/xsrf.service';
 import {
   RequestConfigureAction,
   RequestExecuteAction,
@@ -62,7 +60,6 @@ describe('RequestService', () => {
   let uuidService: UUIDService;
   let store: Store<CoreState>;
   let mockStore: MockStore<CoreState>;
-  let xsrfService: XSRFService;
 
   const testUUID = '5f2a0d2a-effa-4d54-bd54-5663b960f9eb';
   const testHref = 'https://rest.api/endpoint/selfLink';
@@ -108,16 +105,11 @@ describe('RequestService', () => {
     store = TestBed.inject(Store);
     mockStore = store as MockStore<CoreState>;
     mockStore.setState(initialState);
-    xsrfService = {
-      tokenInitialized$: new BehaviorSubject(false),
-    } as XSRFService;
 
     service = new RequestService(
       objectCache,
       uuidService,
       store,
-      xsrfService,
-      undefined,
     );
     serviceAsAny = service as any;
   });

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

@@ -34,16 +34,12 @@ import { ObjectCacheService } from '../cache/object-cache.service';
 import { CommitSSBAction } from '../cache/server-sync-buffer.actions';
 import { coreSelector } from '../core.selectors';
 import { CoreState } from '../core-state.model';
-import {
-  IndexState,
-  MetaIndexState,
-} from '../index/index.reducer';
+import { IndexState } from '../index/index.reducer';
 import {
   getUrlWithoutEmbedParams,
   requestIndexSelector,
 } from '../index/index.selectors';
 import { UUIDService } from '../shared/uuid.service';
-import { XSRFService } from '../xsrf/xsrf.service';
 import {
   RequestConfigureAction,
   RequestExecuteAction,
@@ -169,9 +165,7 @@ export class RequestService {
 
   constructor(private objectCache: ObjectCacheService,
               private uuidService: UUIDService,
-              private store: Store<CoreState>,
-              protected xsrfService: XSRFService,
-              private indexStore: Store<MetaIndexState>) {
+              private store: Store<CoreState>) {
   }
 
   generateRequestId(): string {
@@ -455,17 +449,7 @@ export class RequestService {
   private dispatchRequest(request: RestRequest) {
     asapScheduler.schedule(() => {
       this.store.dispatch(new RequestConfigureAction(request));
-      // If it's a GET request, or we have an XSRF token, dispatch it immediately
-      if (request.method === RestRequestMethod.GET || this.xsrfService.tokenInitialized$.getValue() === true) {
-        this.store.dispatch(new RequestExecuteAction(request.uuid));
-      } else {
-        // Otherwise wait for the XSRF token first
-        this.xsrfService.tokenInitialized$.pipe(
-          find((hasInitialized: boolean) => hasInitialized === true),
-        ).subscribe(() => {
-          this.store.dispatch(new RequestExecuteAction(request.uuid));
-        });
-      }
+      this.store.dispatch(new RequestExecuteAction(request.uuid));
     });
   }
 

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

@@ -0,0 +1,50 @@
+import {
+  Injector,
+  Type,
+} from '@angular/core';
+import {
+  defer,
+  Observable,
+} from 'rxjs';
+
+import { LazyDataServicesMap } from '../../config/app-config.interface';
+import { HALDataService } from './data/base/hal-data-service.interface';
+
+/**
+ * Loads a service lazily. The service is loaded when the observable is subscribed to.
+ *
+ * @param dataServicesMap A map of promises returning the data services to load
+ * @param key The key of the service
+ * @param injector The injector to use to load the service. If not provided, the current injector is used.
+ * @returns An observable of the service.
+ *
+ * @example
+ * ```ts
+ * const dataService$ = lazyDataService({ 'data-service': () => import('./data-service').then((m) => m.MyService)}, 'data-service', this.injector);
+ * or
+ * const dataService$ = lazyDataService({'data-service': () => import('./data-service')}, 'data-service', this.injector);
+ * ```
+ */
+export function lazyDataService<T>(
+  dataServicesMap: LazyDataServicesMap,
+  key: string,
+  injector: Injector,
+): Observable<T> {
+  return defer(() => {
+    if (dataServicesMap.has(key) && typeof dataServicesMap.get(key) === 'function') {
+      const loader: () => Promise<Type<HALDataService<any>> | { default: HALDataService<any> }> = dataServicesMap.get(key);
+      return loader()
+        .then((serviceOrDefault) => {
+          if ('default' in serviceOrDefault) {
+            return injector!.get(serviceOrDefault.default);
+          }
+          return injector!.get(serviceOrDefault);
+        })
+        .catch((error) => {
+          throw error;
+        });
+    } else {
+      return null;
+    }
+  });
+}

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

@@ -38,9 +38,9 @@ const REINSTATE_BTN = 'reinstate';
 const SAVE_BTN = 'save';
 const DISCARD_BTN = 'discard';
 
-const mockDataServiceMap: any = {
-  [ITEM.value]: () => import('../../shared/testing/test-data-service.mock').then(m => m.TestDataService),
-};
+const mockDataServiceMap: any = new Map([
+  [ITEM.value, () => import('../../shared/testing/test-data-service.mock').then(m => m.TestDataService)],
+]);
 
 describe('DsoEditMetadataComponent', () => {
   let component: DsoEditMetadataComponent;

src/app/core/lazy-service.ts

@@ -7,7 +7,6 @@ import {
   ChangeDetectorRef,
   Component,
   Inject,
-  InjectionToken,
   Injector,
   Input,
   OnDestroy,
@@ -42,7 +41,7 @@ import {
 import { ArrayMoveChangeAnalyzer } from '../../core/data/array-move-change-analyzer.service';
 import { RemoteData } from '../../core/data/remote-data';
 import { UpdateDataService } from '../../core/data/update-data.service';
-import { lazyService } from '../../core/lazy-service';
+import { lazyDataService } from '../../core/lazy-data-service';
 import { DSpaceObject } from '../../core/shared/dspace-object.model';
 import { getFirstCompletedRemoteData } from '../../core/shared/operators';
 import { ResourceType } from '../../core/shared/resource-type';
@@ -152,7 +151,7 @@ export class DsoEditMetadataComponent implements OnInit, OnDestroy {
               protected parentInjector: Injector,
               protected arrayMoveChangeAnalyser: ArrayMoveChangeAnalyzer<number>,
               protected cdr: ChangeDetectorRef,
-              @Inject(APP_DATA_SERVICES_MAP) private dataServiceMap: InjectionToken<LazyDataServicesMap>) {
+              @Inject(APP_DATA_SERVICES_MAP) private dataServiceMap: LazyDataServicesMap) {
   }
 
   /**
@@ -186,7 +185,7 @@ export class DsoEditMetadataComponent implements OnInit, OnDestroy {
    */
   retrieveDataService(): Observable<UpdateDataService<DSpaceObject>> {
     if (hasNoValue(this.updateDataService)) {
-      const lazyProvider$: Observable<UpdateDataService<DSpaceObject>> = lazyService(this.dataServiceMap[this.dsoType], this.parentInjector);
+      const lazyProvider$: Observable<UpdateDataService<DSpaceObject>> = lazyDataService(this.dataServiceMap, this.dsoType, this.parentInjector);
       return lazyProvider$;
     } else {
       return EMPTY;