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

Task/dspace cris 2025 02 x/DSC-1956

Approved-by: Andrea Barbasso

Author: FrancescoMolinaro

cypress/e2e/community-create.cy.ts

@@ -4,8 +4,8 @@ beforeEach(() => {
 });
 
 it('should show loading component while saving', () => {
-  cy.intercept('**/sites/**canSubmit**').as('canSubmit');
-  cy.wait('@canSubmit');
+  cy.intercept('**/api/config/properties/submit.type-bind.field').as('typeBind');
+  cy.wait('@typeBind');
 
   const title = 'Test Community Title';
   cy.get('#title').type(title);

src/app/app.effects.ts

@@ -1,4 +1,5 @@
 import { NavbarEffects } from './navbar/navbar.effects';
+import { AuthorizationEffects } from './shared/authorizations/authorization.effects';
 import { RelationshipEffects } from './shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects';
 import { NotificationsEffects } from './shared/notifications/notifications.effects';
 import { SidebarEffects } from './shared/sidebar/sidebar-effects.service';
@@ -12,4 +13,5 @@ export const appEffects = [
   SidebarEffects,
   ThemeEffects,
   RelationshipEffects,
+  AuthorizationEffects,
 ];

src/app/app.reducer.ts

@@ -33,6 +33,8 @@ import {
   editItemRelationshipsReducer,
   EditItemRelationshipsState,
 } from './edit-item-relationships/edit-item-relationships.reducer';
+import { AuthorizationsState } from './shared/authorizations/authorization.interfaces';
+import { authorizationReducer } from './shared/authorizations/authorization.reducer';
 import {
   contextHelpReducer,
   ContextHelpState,
@@ -107,6 +109,7 @@ export interface AppState {
   correlationId: string;
   contextHelp: ContextHelpState;
   editItemRelationships: EditItemRelationshipsState;
+  authorizationFeatures: AuthorizationsState;
 }
 
 export const appReducers: ActionReducerMap<AppState> = {
@@ -131,6 +134,7 @@ export const appReducers: ActionReducerMap<AppState> = {
   contextHelp: contextHelpReducer,
   statistics: StatisticsReducer,
   editItemRelationships: editItemRelationshipsReducer,
+  authorizationFeatures: authorizationReducer,
 };
 
 export const routerStateSelector = (state: AppState) => state.router;

src/app/bitstream-page/bitstream-page-authorizations.guard.spec.ts

@@ -9,9 +9,9 @@ import {
 } from 'rxjs';
 import { AuthService } from 'src/app/core/auth/auth.service';
 import { AuthorizationDataService } from 'src/app/core/data/feature-authorization/authorization-data.service';
-import { FeatureID } from 'src/app/core/data/feature-authorization/feature-id';
 
 import { BitstreamDataService } from '../core/data/bitstream-data.service';
+import { FeatureID } from '../core/data/feature-authorization/feature-id';
 import { Bitstream } from '../core/shared/bitstream.model';
 import { createSuccessfulRemoteDataObject$ } from '../shared/remote-data.utils';
 import { bitstreamPageAuthorizationsGuard } from './bitstream-page-authorizations.guard';

src/app/core/browse/search-manager.ts

@@ -1,23 +1,37 @@
-import { Injectable } from '@angular/core';
+import {
+  Inject,
+  Injectable,
+} from '@angular/core';
 import isArray from 'lodash/isArray';
 import {
+  combineLatest,
   Observable,
   of,
 } from 'rxjs';
 import {
+  filter,
   map,
   switchMap,
+  take,
 } from 'rxjs/operators';
+import { SearchOptions } from 'src/app/shared/search/models/search-options.model';
 
+import {
+  APP_CONFIG,
+  AppConfig,
+} from '../../../config/app-config.interface';
 import { FollowAuthorityMetadata } from '../../../config/search-follow-metadata.interface';
 import { environment } from '../../../environments/environment';
+import { AuthorizationService } from '../../shared/authorizations/authorization.service';
 import {
   hasValue,
   isNotEmpty,
 } from '../../shared/empty.util';
 import { PaginatedSearchOptions } from '../../shared/search/models/paginated-search-options.model';
 import { SearchObjects } from '../../shared/search/models/search-objects.model';
 import { FollowLinkConfig } from '../../shared/utils/follow-link-config.model';
+import { getRequestIdFromParams } from '../data/feature-authorization/authorization-utils';
+import { FeatureID } from '../data/feature-authorization/feature-id';
 import { ItemDataService } from '../data/item-data.service';
 import { PaginatedList } from '../data/paginated-list.model';
 import { RemoteData } from '../data/remote-data';
@@ -43,6 +57,8 @@ export class SearchManager {
     protected itemService: ItemDataService,
     protected browseService: BrowseService,
     protected searchService: SearchService,
+    protected authorizationService: AuthorizationService,
+    @Inject(APP_CONFIG) protected appConfig: AppConfig,
   ) {
   }
 
@@ -79,7 +95,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));
   }
 
 
@@ -94,19 +110,111 @@ 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 requestsIds = [];
+
+    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;
+      const hrefs = objects.map(dso => dso.self);
+      this.authorizationService.initStateForObjects(uuidList, type, features, hrefs);
+      requestsIds.push(getRequestIdFromParams(type, uuidList, features));
+    });
+
+    return combineLatest(requestsIds.map(id => this.authorizationService.isRequestLoading(id))).pipe(
+      filter(loadingItems => loadingItems.every(loading => !loading)),
+      take(1),
+      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/core/browse/search.manager.spec.ts

@@ -3,13 +3,15 @@ import { of } from 'rxjs';
 import { TestScheduler } from 'rxjs/testing';
 import { v4 as uuidv4 } from 'uuid';
 
+import { AppConfig } from '../../../config/app-config.interface';
 import { toRemoteData } from '../../browse-by/browse-by-metadata/browse-by-metadata.component.spec';
 import {
   createSuccessfulRemoteDataObject,
   createSuccessfulRemoteDataObject$,
 } from '../../shared/remote-data.utils';
 import { createPaginatedList } from '../../shared/testing/utils.test';
 import { FollowLinkConfig } from '../../shared/utils/follow-link-config.model';
+import { FeatureID } from '../data/feature-authorization/feature-id';
 import { FindListOptions } from '../data/find-list-options.model';
 import { Item } from '../shared/item.model';
 import { ITEM } from '../shared/item.resource-type';
@@ -97,6 +99,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]),
@@ -114,8 +130,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(() => {