[DSpace-CRIS] Porting of authority framework functionalities (Frontend)

config/config.example.yml

@@ -237,7 +237,12 @@ submission:
         - value: default
           style: text-muted
           icon: fa-circle-xmark
-
+      # Icons to be displayed next to an authority controlled value, to give indication of the source.
+      sourceIcons:
+        # Example of configuration for authority logo based on sources.
+        # The configured icon will be displayed next to the authority value in submission and on item page or search results.
+        - source: orcid
+        - path: assets/images/orcid.logo.icon.svg
 #  Fallback language in which the UI will be rendered if the user's browser language is not an active language
 fallbackLanguage: en
 
@@ -393,6 +398,30 @@ item:
     pageSize: 5
     # Show the bitstream access status label on the item page
     showAccessStatuses: false
+  # Configuration of metadata to be displayed in the item metadata link view popover
+  metadataLinkViewPopoverData:
+    # Metdadata list to be displayed for entities without a specific configuration
+    fallbackMetdataList:
+      - dc.description.abstract
+      - dc.description.note
+    # Configuration for each entity type
+    entityDataConfig:
+      - entityType: Person
+        # Descriptive metadata (popover body)
+        metadataList:
+          - person.affiliation.name
+          - person.email
+        # Title metadata (popover header)
+        titleMetadataList:
+          - person.givenName
+          - person.familyName
+    # Configuration for identifier subtypes, based on metadata like dc.identifier.ror where ror is the subtype.
+    # This is used to map the layout of the identifier in the popover and the icon displayed next to the metadata value.
+    identifierSubtypes:
+      - name: ror
+        icon: assets/images/ror.logo.icon.svg
+        iconPosition: IdentifierSubtypesIconPositionEnum.LEFT
+        link: https://ror.org
 
 # Community Page Config
 community:
@@ -641,3 +670,62 @@ geospatialMapViewer:
 accessibility:
   # The duration in days after which the accessibility settings cookie expires
   cookieExpirationDuration: 7
+
+# Configuration for layout customization of metadata rendering in Item page
+# Currently only the authority reference config is available, more will follow with the integration of the so called CRIS layout.
+layout:
+  # Configuration of icons and styles to be used for each authority controlled link
+  authorityRef:
+    - entityType: DEFAULT
+      entityStyle:
+        default:
+          icon: fa fa-user
+          style: text-info
+    - entityType: PERSON
+      entityStyle:
+        person:
+          icon: fa fa-user
+          style: text-success
+        default:
+          icon: fa fa-user
+          style: text-info
+    - entityType: ORGUNIT
+      entityStyle:
+        default:
+          icon: fa fa-university
+          style: text-success
+    - entityType: PROJECT
+      entityStyle:
+        default:
+          icon: fas fa-project-diagram
+          style: text-success
+
+# Configuration for customization of search results
+searchResults:
+  # Metadata fields to be displayed in the search results under the standard ones
+  additionalMetadataFields:
+    - dc.contributor.author
+    - dc.date.issued
+    - dc.type
+  # Metadata fields to be displayed in the search results for the author section
+  authorMetadata:
+    - dc.contributor.author
+    - dc.creator
+    - dc.contributor.*
+  # When the search results are retrieved, for each item type the metadata with a valid authority value are inspected.
+  # Referenced items will be fetched with a find all by id strategy to avoid individual rest requests
+  # to efficiently display the search results.
+  followAuthorityMetadata:
+    - type: Publication
+      metadata: dc.contributor.author
+    - type: Product
+      metadata: dc.contributor.author
+
+  # The maximum number of item to process when following authority metadata values.
+  followAuthorityMaxItemLimit: 100
+
+  # The maximum number of metadata values to process for each metadata key
+  # when following authority metadata values.
+  followAuthorityMetadataValuesLimit: 5
+
+

src/app/browse-by/browse-by-taxonomy/browse-by-taxonomy.component.ts

@@ -128,7 +128,7 @@ export class BrowseByTaxonomyComponent implements OnInit, OnChanges, OnDestroy {
       this.selectedItems = [];
       this.facetType = browseDefinition.facetType;
       this.vocabularyName = browseDefinition.vocabulary;
-      this.vocabularyOptions = { name: this.vocabularyName, closed: true };
+      this.vocabularyOptions = { name: this.vocabularyName, metadata: null, scope: null, closed: true };
       this.description = this.translate.instant(`browse.metadata.${this.vocabularyName}.tree.description`);
     }));
     this.subs.push(this.scope$.subscribe(() => {

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

@@ -0,0 +1,151 @@
+import { Injectable } from '@angular/core';
+import { FollowAuthorityMetadata } from '@dspace/config/search-follow-metadata.interface';
+import {
+  hasValue,
+  isNotEmpty,
+} from '@dspace/shared/utils/empty.util';
+import isArray from 'lodash/isArray';
+import {
+  Observable,
+  of,
+} from 'rxjs';
+import {
+  map,
+  switchMap,
+} from 'rxjs/operators';
+import { SearchService } from 'src/app/shared/search/search.service';
+
+import { environment } from '../../../environments/environment';
+import { ItemDataService } from '../data/item-data.service';
+import { PaginatedList } from '../data/paginated-list.model';
+import { RemoteData } from '../data/remote-data';
+import { WORKFLOWITEM } from '../eperson/models/workflowitem.resource-type';
+import { WORKSPACEITEM } from '../eperson/models/workspaceitem.resource-type';
+import { DSpaceObject } from '../shared/dspace-object.model';
+import { FollowLinkConfig } from '../shared/follow-link-config.model';
+import { Item } from '../shared/item.model';
+import { ITEM } from '../shared/item.resource-type';
+import { MetadataValue } from '../shared/metadata.models';
+import { Metadata } from '../shared/metadata.utils';
+import { getFirstCompletedRemoteData } from '../shared/operators';
+import { PaginatedSearchOptions } from '../shared/search/models/paginated-search-options.model';
+import { SearchObjects } from '../shared/search/models/search-objects.model';
+import { BrowseService } from './browse.service';
+
+/**
+ * The service aims to manage browse requests and subsequent extra fetch requests.
+ */
+@Injectable({ providedIn: 'root' })
+export class SearchManager {
+
+  constructor(
+    protected itemService: ItemDataService,
+    protected browseService: BrowseService,
+    protected searchService: SearchService,
+  ) {
+  }
+
+  /**
+   * Method to retrieve a paginated list of search results from the server
+   * @param {PaginatedSearchOptions} searchOptions The configuration necessary to perform this search
+   * @param responseMsToLive The amount of milliseconds for the response to live in cache
+   * @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
+   * @returns {Observable<RemoteData<SearchObjects<T>>>} Emits a paginated list with all search results found
+   */
+  search<T extends DSpaceObject>(
+    searchOptions?: PaginatedSearchOptions,
+    responseMsToLive?: number,
+    useCachedVersionIfAvailable = true,
+    reRequestOnStale = true,
+    ...linksToFollow: FollowLinkConfig<T>[]): Observable<RemoteData<SearchObjects<T>>> {
+    return this.searchService.search(searchOptions, responseMsToLive, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow)
+      .pipe(this.completeSearchObjectsWithExtraData());
+  }
+
+
+  protected completeWithExtraData() {
+    return switchMap((itemsRD: RemoteData<PaginatedList<Item>>) => {
+      if (itemsRD.isSuccess) {
+        return this.fetchExtraData(itemsRD.payload.page).pipe(map(() => {
+          return itemsRD;
+        }));
+      }
+      return of(itemsRD);
+    });
+  }
+
+  protected completeSearchObjectsWithExtraData<T extends DSpaceObject>() {
+    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 of(searchObjectsRD);
+    });
+  }
+
+  protected fetchExtraData<T extends DSpaceObject>(objects: T[]): Observable<any> {
+
+    const items: Item[] = objects
+      .map((object: any) => {
+        if (object.type === ITEM.value) {
+          return object as Item;
+        } else if (object.type === WORKSPACEITEM.value || object.type === WORKFLOWITEM.value) {
+          return object?._embedded?.item as Item;
+        } else {
+          // Handle workflow task here, where the item is embedded in a workflowitem
+          return object?._embedded?.workflowitem?._embedded?.item as Item;
+        }
+
+      })
+      .filter((item) => hasValue(item));
+
+    const uuidList = this.extractUUID(items, environment.searchResult.followAuthorityMetadata, environment.searchResult.followAuthorityMaxItemLimit);
+
+    return uuidList.length > 0 ? this.itemService.findAllById(uuidList).pipe(
+      getFirstCompletedRemoteData(),
+      map(data => {
+        if (data.hasSucceeded) {
+          return of(data);
+        } else {
+          of(null);
+        }
+      }),
+    ) : of(null);
+  }
+
+  protected extractUUID(items: Item[], metadataToFollow: FollowAuthorityMetadata[], numberOfElementsToReturn?: number): string[] {
+    const uuidMap = {};
+
+    items.forEach((item) => {
+      metadataToFollow.forEach((followMetadata: FollowAuthorityMetadata) => {
+        if (item.entityType === followMetadata.type) {
+          if (isArray(followMetadata.metadata)) {
+            followMetadata.metadata.forEach((metadata) => {
+              Metadata.all(item.metadata, metadata, null, null, false, environment.searchResult.followAuthorityMetadataValuesLimit)
+                .filter((metadataValue: MetadataValue) => Metadata.hasValidItemAuthority(metadataValue.authority))
+                .forEach((metadataValue: MetadataValue) => uuidMap[metadataValue.authority] = metadataValue);
+            });
+          } else {
+            Metadata.all(item.metadata, followMetadata.metadata, null, null, false, environment.searchResult.followAuthorityMetadataValuesLimit)
+              .filter((metadataValue: MetadataValue) => Metadata.hasValidItemAuthority(metadataValue.authority))
+              .forEach((metadataValue: MetadataValue) => uuidMap[metadataValue.authority] = metadataValue);
+          }
+        }
+      });
+    });
+
+    if (hasValue(numberOfElementsToReturn) && numberOfElementsToReturn > 0) {
+      return Object.keys(uuidMap).slice(0, numberOfElementsToReturn);
+    }
+
+    return Object.keys(uuidMap);
+  }
+}