Merge pull request DSpace#5467 from 4Science/task/main/DURACOM-469

Fix DSpace#5410:  fix issue with missing update on CMS metadata and end user agreement

Author: tdonohue

src/app/core/data/site-data.service.spec.ts

@@ -5,11 +5,15 @@ import {
 import { TestScheduler } from 'rxjs/testing';
 
 import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
+import { RequestParam } from '../cache/models/request-param.model';
 import { ObjectCacheService } from '../cache/object-cache.service';
 import { HALEndpointService } from '../shared/hal-endpoint.service';
 import { Site } from '../shared/site.model';
 import { createPaginatedList } from '../testing/utils.test';
-import { createSuccessfulRemoteDataObject } from '../utilities/remote-data.utils';
+import {
+  createFailedRemoteDataObject,
+  createSuccessfulRemoteDataObject,
+} from '../utilities/remote-data.utils';
 import { testFindAllDataImplementation } from './base/find-all-data.spec';
 import { DefaultChangeAnalyzer } from './default-change-analyzer.service';
 import { FindListOptions } from './find-list-options.model';
@@ -78,14 +82,45 @@ describe('SiteDataService', () => {
   });
 
   describe('find', () => {
-    it('should return the Site object', () => {
-
-      spyOn(service, 'findAll').and.returnValue(cold('a', {
+    it('should call findAll with allLanguages projection searchParam and return the first Site object', () => {
+      const findAllSpy = spyOn(service, 'findAll').and.returnValue(cold('a', {
         a: createSuccessfulRemoteDataObject(createPaginatedList([testObject])),
       }));
 
+      const result = service.find(options);
       const expected = cold('(b|)', { b: testObject });
-      const result = service.find();
+
+      expect(result).toBeObservable(expected);
+
+      const calledOptions: FindListOptions = findAllSpy.calls.mostRecent().args[0];
+      const projectionParam = calledOptions.searchParams?.find((p: RequestParam) => p.fieldName === 'projection');
+      expect(projectionParam).toBeDefined();
+      expect(projectionParam.fieldValue).toBe('allLanguages');
+    });
+
+    it('should fall back to findAll without searchParams when first call fails, and return the Site object', () => {
+      const findAllSpy = spyOn(service, 'findAll').and.returnValues(
+        cold('a', { a: createFailedRemoteDataObject<any>('Error', 500) }),
+        cold('b', { b: createSuccessfulRemoteDataObject(createPaginatedList([testObject])) }),
+      );
+
+      const result = service.find(options);
+      const expected = cold('(b|)', { b: testObject });
+
+      expect(result).toBeObservable(expected);
+
+      // Second call should use original options (without injected searchParams)
+      const fallbackOptions: FindListOptions = findAllSpy.calls.argsFor(1)[0];
+      expect(fallbackOptions).toEqual(options);
+    });
+
+    it('should return null when both findAll calls fail', () => {
+      spyOn(service, 'findAll').and.returnValue(
+        cold('a', { a: createFailedRemoteDataObject<any>('Error', 500) }),
+      );
+
+      const result = service.find(options);
+      const expected = cold('(b|)', { b: null });
 
       expect(result).toBeObservable(expected);
     });

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

@@ -1,13 +1,20 @@
 import { Injectable } from '@angular/core';
 import { FollowLinkConfig } from '@dspace/core/shared/follow-link-config.model';
 import { Operation } from 'fast-json-patch/module/core';
-import { Observable } from 'rxjs';
-import { map } from 'rxjs/operators';
+import {
+  Observable,
+  of,
+} from 'rxjs';
+import {
+  map,
+  switchMap,
+} from 'rxjs/operators';
 
 import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
+import { RequestParam } from '../cache/models/request-param.model';
 import { ObjectCacheService } from '../cache/object-cache.service';
 import { HALEndpointService } from '../shared/hal-endpoint.service';
-import { getFirstSucceededRemoteData } from '../shared/operators';
+import { getFirstCompletedRemoteData } from '../shared/operators';
 import { Site } from '../shared/site.model';
 import { BaseDataService } from './base/base-data.service';
 import {
@@ -48,12 +55,32 @@ export class SiteDataService extends BaseDataService<Site> implements FindAllDat
 
   /**
    * Retrieve the Site Object
+   *
+   * @param options                     Find list options object
+   * @param useCachedVersionIfAvailable If this is true, the request will only be sent if there's
+   *                                    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 linksToFollow               List of {@link FollowLinkConfig} that indicate which
+   *                                    {@link HALLink}s should be automatically resolved
+   * @return {Observable<RemoteData<PaginatedList<T>>>}
+   *    Return an observable that emits object list
    */
-  find(): Observable<Site> {
-    return this.findAll().pipe(
-      getFirstSucceededRemoteData(),
-      map((remoteData: RemoteData<PaginatedList<Site>>) => remoteData.payload),
-      map((list: PaginatedList<Site>) => list.page[0]),
+  find(options?: FindListOptions, useCachedVersionIfAvailable?: boolean, reRequestOnStale?: boolean, ...linksToFollow: FollowLinkConfig<Site>[]): Observable<Site> {
+    const searchParams: RequestParam[] = [new RequestParam('projection', 'allLanguages')];
+    const findOptions = Object.assign(new FindListOptions(), options, { searchParams });
+    return this.findAll(findOptions, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow).pipe(
+      getFirstCompletedRemoteData(),
+      switchMap((remoteData: RemoteData<PaginatedList<Site>>) => {
+        if (remoteData.hasSucceeded) {
+          return of(remoteData.payload.page[0]);
+        } else {
+          return this.findAll(options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow).pipe(
+            getFirstCompletedRemoteData(),
+            map((rd: RemoteData<PaginatedList<Site>>) => rd.hasSucceeded ? rd.payload.page[0] : null),
+          );
+        }
+      }),
     );
   }