Merged in task/dspace-cris-2023_02_x/DSC-1956 (pull request DSpace#2401)

Task/dspace cris 2023 02 x/DSC-1956

Approved-by: Giuseppe Digilio

Author: FrancescoMolinaro

src/app/app.effects.ts

@@ -4,12 +4,14 @@ import { NavbarEffects } from './navbar/navbar.effects';
 import { SidebarEffects } from './shared/sidebar/sidebar-effects.service';
 import { RelationshipEffects } from './shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects';
 import { ThemeEffects } from './shared/theme-support/theme.effects';
+import { AuthorizationEffects } from './core/data/feature-authorization/authorization.effects';
 
 export const appEffects = [
   StoreEffects,
   NavbarEffects,
   NotificationsEffects,
   SidebarEffects,
   ThemeEffects,
-  RelationshipEffects
+  RelationshipEffects,
+  AuthorizationEffects
 ];

src/app/app.reducer.ts

@@ -53,6 +53,8 @@ import {
   editItemRelationshipsReducer,
   EditItemRelationshipsState
 } from './edit-item-relationships/edit-item-relationships.reducer';
+import { AuthorizationsState } from './core/data/feature-authorization/authorization.interfaces';
+import { authorizationReducer} from './core/data/feature-authorization/authorization.reducer';
 
 export interface AppState {
   router: RouterReducerState;
@@ -76,6 +78,7 @@ export interface AppState {
   correlationId: string;
   contextHelp: ContextHelpState;
   editItemRelationships: EditItemRelationshipsState;
+  authorizationFeatures: AuthorizationsState;
 }
 
 export const appReducers: ActionReducerMap<AppState> = {
@@ -99,7 +102,8 @@ export const appReducers: ActionReducerMap<AppState> = {
   correlationId: correlationIdReducer,
   contextHelp: contextHelpReducer,
   statistics: StatisticsReducer,
-  editItemRelationships: editItemRelationshipsReducer
+  editItemRelationships: editItemRelationshipsReducer,
+  authorizationFeatures: authorizationReducer
 };
 
 export const routerStateSelector = (state: AppState) => state.router;

src/app/breadcrumbs/breadcrumb/breadcrumb-tooltip.pipe.ts

@@ -1,6 +1,6 @@
-import { Injectable } from '@angular/core';
+import { Inject, Injectable } from '@angular/core';
 import { Observable, of } from 'rxjs';
-import { map, switchMap } from 'rxjs/operators';
+import { filter, map, switchMap } from 'rxjs/operators';
 import { PaginatedList } from '../data/paginated-list.model';
 import { RemoteData } from '../data/remote-data';
 import { Item } from '../shared/item.model';
@@ -22,6 +22,12 @@ import isArray from 'lodash/isArray';
 import { WORKSPACEITEM } from '../eperson/models/workspaceitem.resource-type';
 import { WORKFLOWITEM } from '../eperson/models/workflowitem.resource-type';
 import { ITEM } from '../shared/item.resource-type';
+import { APP_CONFIG, AppConfig } from '../../../config/app-config.interface';
+import { FeatureID } from '../data/feature-authorization/feature-id';
+import { SearchOptions } from '../../shared/search/models/search-options.model';
+
+
+import { AuthorizationService } from '../data/feature-authorization/authorization.service';
 
 /**
  * The service aims to manage browse requests and subsequent extra fetch requests.
@@ -33,6 +39,8 @@ export class SearchManager {
     protected itemService: ItemDataService,
     protected browseService: BrowseService,
     protected searchService: SearchService,
+    protected authorizationService: AuthorizationService,
+    @Inject(APP_CONFIG) protected appConfig: AppConfig
   ) {
   }
 
@@ -69,7 +77,7 @@ export class SearchManager {
     ...linksToFollow: FollowLinkConfig<T>[]): Observable<RemoteData<SearchObjects<T>>> {
     const optionsWithDefaultProjection = Object.assign(new PaginatedSearchOptions({}), searchOptions, { projection: searchOptions.projection ?? 'preventMetadataSecurity' });
     return this.searchService.search(optionsWithDefaultProjection, responseMsToLive, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow)
-      .pipe(this.completeSearchObjectsWithExtraData());
+      .pipe(this.completeSearchObjectsWithExtraData(optionsWithDefaultProjection));
   }
 
 
@@ -84,19 +92,107 @@ export class SearchManager {
     });
   }
 
-  protected completeSearchObjectsWithExtraData<T extends DSpaceObject>() {
+  protected completeSearchObjectsWithExtraData<T extends DSpaceObject>(searchOptions: SearchOptions) {
     return switchMap((searchObjectsRD: RemoteData<SearchObjects<T>>) => {
       if (searchObjectsRD.isSuccess) {
         const items: Item[] = searchObjectsRD.payload.page
           .map((searchResult) => isNotEmpty(searchResult?._embedded?.indexableObject) ? searchResult._embedded.indexableObject : searchResult.indexableObject) as any;
-        return this.fetchExtraData(items).pipe(map(() => {
-          return searchObjectsRD;
-        }));
+        return this.fetchExtraData(items).pipe(
+          switchMap(() => this.fetchConfiguredAuthorizations(searchObjectsRD, searchOptions.configuration ?? 'default')),
+          map(() => {
+            return searchObjectsRD;
+          }),
+        );
       }
       return of(searchObjectsRD);
     });
   }
 
+  /**
+   * Retrieve configured authorizations related to current discovery configuration
+   *
+   * @param searchObjects
+   * @param configuration
+   * @protected
+   */
+  protected fetchConfiguredAuthorizations<T extends DSpaceObject>(searchObjects: RemoteData<SearchObjects<T>>, configuration: string): Observable<any> {
+    const objects = searchObjects.payload.page.map((searchResult) => searchResult.indexableObject) as any;
+    const mappedObjects = this.getConfiguredAuthorizationsMap(objects, configuration);
+
+    if ([...mappedObjects.keys()].length === 0) {
+      return of(searchObjects);
+    }
+
+    const uiidListsMappedToAuthorizations = this.groupItemsUuidsByAuthorizations(objects, mappedObjects);
+    [...uiidListsMappedToAuthorizations.keys()].forEach((features) => {
+      const uuidList = uiidListsMappedToAuthorizations.get(features);
+      const type = objects.find(object => object.id === uuidList[0]).uniqueType;
+
+      this.authorizationService.initStateForObjects(uuidList, type, features);
+    });
+
+    return this.authorizationService.isLoading().pipe(
+      filter(loading => !loading),
+      map(() => {
+        return searchObjects;
+      }),
+    );
+  }
+
+  /**
+   * Group items by authorization ID in a map
+   *
+   * @param objects
+   * @param mappedEntities
+   * @private
+   */
+  private groupItemsUuidsByAuthorizations<T extends DSpaceObject>(objects: T[], mappedEntities: Map<string, FeatureID[]>): Map<FeatureID[], string[]> {
+    const mappedUuidListsToFeatures = new Map();
+
+    objects.forEach(object => {
+      const objectType = object.uniqueType;
+      const features = mappedEntities.get(objectType);
+
+      if (hasValue(features) && hasValue(mappedUuidListsToFeatures.get(features))) {
+        mappedUuidListsToFeatures.set(features, [...mappedUuidListsToFeatures.get(features), object.id]);
+      } else if (hasValue(features)) {
+        mappedUuidListsToFeatures.set(features, [object.id]);
+      }
+    });
+
+    return mappedUuidListsToFeatures;
+  }
+
+  /**
+   * Map entity types oe unique type to required authorizations so that we can group the items by feature
+   *
+   * @param objects
+   * @param configuration
+   * @private
+   */
+  private getConfiguredAuthorizationsMap<T extends DSpaceObject>(objects: T[], configuration: string): Map<string, FeatureID[]> {
+    const configuredAuthorizationsForDiscovery =
+      this.appConfig.discoveryAuthorizationFeaturesConfig[configuration] ?? this.appConfig.discoveryAuthorizationFeaturesConfig.default;
+    const configuredAuthorizationsToType = new Map();
+
+    if (!hasValue(configuredAuthorizationsForDiscovery)) {
+      return configuredAuthorizationsToType;
+    }
+
+    const objectUniqueTypes =  [...new Set(objects.map(dso => dso?.uniqueType))];
+
+    objectUniqueTypes.forEach((entity) => {
+      const config = configuredAuthorizationsForDiscovery[entity];
+
+      if (hasValue(config)) {
+        configuredAuthorizationsToType.set(entity, config);
+      }
+    });
+
+    return configuredAuthorizationsToType;
+  }
+
+
   protected fetchExtraData<T extends DSpaceObject>(objects: T[]): Observable<any> {
 
     const items: Item[] = objects

src/app/breadcrumbs/breadcrumb/truncate-breadcrumb-item-characters.pipe.ts

@@ -13,6 +13,8 @@ import { MetadataValue } from '../shared/metadata.models';
 import { v4 as uuidv4 } from 'uuid';
 import { AUTHORITY_REFERENCE } from '../shared/metadata.utils';
 import { ITEM } from '../shared/item.resource-type';
+import { AppConfig } from '../../../config/app-config.interface';
+import { FeatureID } from '../data/feature-authorization/feature-id';
 
 describe('SearchManager', () => {
   let scheduler: TestScheduler;
@@ -93,6 +95,20 @@ describe('SearchManager', () => {
     type: ITEM.value
   });
 
+  const appConfig: Partial<AppConfig> = {
+    discoveryAuthorizationFeaturesConfig: {},
+    followAuthorityMetadata:  [
+      {
+        type: 'Publication',
+        metadata: ['dc.contributor.author']
+      },
+      {
+        type: 'Product',
+        metadata: ['dc.contributor.author']
+      }
+    ]
+  };
+
   const mockBrowseService: any = {
     getBrowseItemsFor: (options: BrowseEntrySearchOptions) =>
       toRemoteData([firstPublication, secondPublication, firstProject]),
@@ -110,8 +126,13 @@ describe('SearchManager', () => {
       of(createSuccessfulRemoteDataObject(createPaginatedList([])))
   };
 
+  const mockAuthorizationService: any = {
+    getObjectsAuthorizations: (uuidList: string[], uniqueType: string, featuresId?: FeatureID[]) =>
+      of([])
+  };
+
   function initTestService() {
-    return new SearchManager(mockItemService, mockBrowseService, mockSearchService);
+    return new SearchManager(mockItemService, mockBrowseService, mockSearchService, mockAuthorizationService, appConfig as AppConfig);
   }
 
   beforeEach(() => {