Merge branch 'task/main/DURACOM-444' into task/main/DURACOM-453

Author: FrancescoMolinaro

config/config.example.yml

@@ -238,6 +238,12 @@ submission:
           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 condigured 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
 
@@ -642,3 +648,98 @@ geospatialMapViewer:
 accessibility:
   # The duration in days after which the accessibility settings cookie expires
   cookieExpirationDuration: 7
+
+# Configuration for custom 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
+
+# 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
+
+# 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.*
+
+# 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
+
+# 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;
+
+# 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

scripts/sync-i18n-files.ts

@@ -37,14 +37,11 @@ function parseCliInput() {
     .option('-o, --output-file <output>', 'where output of script ends up; mutually exclusive with -i')
     .usage('([-d <output-dir>] [-s <source-file>]) || (-t <target-file> (-i | -o <output>) [-s <source-file>])')
     .parse(process.argv);
-
-  const sourceFile = program.opts().sourceFile;
-
-    if (!program.targetFile) {
+  if (!program.targetFile) {
     fs.readdirSync(projectRoot(LANGUAGE_FILES_LOCATION)).forEach(file => {
-      if (!sourceFile.toString().endsWith(file)) {
+      if (program.opts().sourceFile && !program.opts().sourceFile.toString().endsWith(file)) {
         const targetFileLocation = projectRoot(LANGUAGE_FILES_LOCATION + "/" + file);
-        console.log('Syncing file at: ' + targetFileLocation + ' with source file at: ' + sourceFile);
+        console.log('Syncing file at: ' + targetFileLocation + ' with source file at: ' + program.opts().sourceFile);
         if (program.outputDir) {
           if (!fs.existsSync(program.outputDir)) {
             fs.mkdirSync(program.outputDir);
@@ -69,7 +66,7 @@ function parseCliInput() {
       console.log(program.outputHelp());
       process.exit(1);
     }
-    if (!checkIfFileExists(sourceFile)) {
+    if (!checkIfFileExists(program.opts().sourceFile)) {
       console.error('Path of source file is not valid.');
       console.log(program.outputHelp());
       process.exit(1);

src/app/audit-page/object-audit-overview/object-audit-logs.component.spec.ts

@@ -60,9 +60,9 @@ describe('ObjectAuditLogsComponent', () => {
       { findOwningCollectionFor: createSuccessfulRemoteDataObject$(createPaginatedList([{ id : 'collectionId' }])) },
     );
     activatedRoute = new MockActivatedRoute({ objectId: mockItemId });
-    activatedRoute.paramMap = of({
-      get: () => mockItemId,
-    });
+    activatedRoute.data = of({ dso: {
+      payload: mockItem,
+    } });
     locationStub = jasmine.createSpyObj('location', {
       back: jasmine.createSpy('back'),
     });

src/app/audit-page/object-audit-overview/object-audit-logs.component.ts

@@ -8,7 +8,7 @@ import {
 } from '@angular/core';
 import {
   ActivatedRoute,
-  ParamMap,
+  Data,
   Router,
   RouterLink,
 } from '@angular/router';
@@ -111,9 +111,8 @@ export class ObjectAuditLogsComponent implements OnInit {
   ) {}
 
   ngOnInit(): void {
-    this.objectId$ = this.route.paramMap.pipe(
-      map((paramMap: ParamMap) => paramMap.get('id')),
-      switchMap((id: string) => this.dSpaceObjectDataService.findById(id, true, true)),
+    this.objectId$ = this.route.data.pipe(
+      switchMap((data: Data) => this.dSpaceObjectDataService.findById(data.dso.payload.id, true, true)),
       getFirstSucceededRemoteDataPayload(),
       tap((object) => {
         this.objectRoute = getDSORoute(object);

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/breadcrumbs/dso-breadcrumb.resolver.ts

@@ -7,6 +7,7 @@ import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 
 import { IdentifiableDataService } from '../data/base/identifiable-data.service';
+import { ItemDataService } from '../data/item-data.service';
 import { getDSORoute } from '../router/utils/dso-route.utils';
 import { DSpaceObject } from '../shared/dspace-object.model';
 import { FollowLinkConfig } from '../shared/follow-link-config.model';
@@ -55,7 +56,9 @@ export const DSOBreadcrumbResolverByUuid: (route: ActivatedRouteSnapshot, state:
   dataService: IdentifiableDataService<DSpaceObject>,
   ...linksToFollow: FollowLinkConfig<DSpaceObject>[]
 ): Observable<BreadcrumbConfig<DSpaceObject>> => {
-  return dataService.findById(uuid, true, false, ...linksToFollow).pipe(
+  const isItemDataService = dataService instanceof ItemDataService;
+  const findMethod = isItemDataService ? dataService.findByIdOrCustomUrl.bind(dataService) : dataService.findById.bind(dataService);
+  return findMethod(uuid, true, false, ...linksToFollow).pipe(
     getFirstCompletedRemoteData(),
     getRemoteDataPayload(),
     map((object: DSpaceObject) => {

src/app/core/data/external-source-data.service.ts

@@ -66,6 +66,17 @@ export class ExternalSourceDataService extends IdentifiableDataService<ExternalS
     );
   }
 
+  /**
+   * Get the endpoint for an external source's entryValues by given entry id
+   * @param externalSourceId  The id of the external source to fetch entry for
+   * @param entryId           The id of the external source entry to retrieve
+   */
+  getEntryIDHref(externalSourceId: string, entryId: string): Observable<string> {
+    return this.getBrowseEndpoint().pipe(
+      map((href) => href + '/' + externalSourceId + '/entryValues/' + entryId),
+    );
+  }
+
   /**
    * Get the entries for an external source
    * @param externalSourceId            The id of the external source to fetch entries for
@@ -111,4 +122,18 @@ export class ExternalSourceDataService extends IdentifiableDataService<ExternalS
   public searchBy(searchMethod: string, options?: FindListOptions, useCachedVersionIfAvailable?: boolean, reRequestOnStale?: boolean, ...linksToFollow: FollowLinkConfig<ExternalSource>[]): Observable<RemoteData<PaginatedList<ExternalSource>>> {
     return this.searchData.searchBy(searchMethod, options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
   }
+
+  /**
+   * Get an entry for an external source by given entry id
+   * @param externalSourceId  The id of the external source to fetch entries for
+   * @param entryId           The id of the entry to retrieve
+   */
+  getExternalSourceEntryById(externalSourceId: string, entryId: string): Observable<RemoteData<ExternalSourceEntry>> {
+    const href$ = this.getEntryIDHref(externalSourceId, entryId).pipe(
+      isNotEmptyOperator(),
+      distinctUntilChanged(),
+    );
+
+    return this.findByHref(href$) as any;
+  }
 }

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

@@ -1,4 +1,5 @@
 import { HttpClient } from '@angular/common/http';
+import { createSuccessfulRemoteDataObject$ } from '@dspace/core/utilities/remote-data.utils';
 import { Store } from '@ngrx/store';
 import {
   cold,
@@ -13,6 +14,7 @@ import { RestResponse } from '../cache/response.models';
 import { CoreState } from '../core-state.model';
 import { NotificationsService } from '../notification-system/notifications.service';
 import { ExternalSourceEntry } from '../shared/external-source-entry.model';
+import { Item } from '../shared/item.model';
 import { HALEndpointServiceStub } from '../testing/hal-endpoint-service.stub';
 import { getMockRemoteDataBuildService } from '../testing/remote-data-build.service.mock';
 import { getMockRequestService } from '../testing/request.service.mock';
@@ -209,4 +211,93 @@ describe('ItemDataService', () => {
     });
   });
 
+  describe('findByCustomUrl', () => {
+    let itemDataService: ItemDataService;
+    let searchData: any;
+    let findByHrefSpy: jasmine.Spy;
+    let getSearchByHrefSpy: jasmine.Spy;
+    const id = 'custom-id';
+    const fakeHrefObs = of('https://rest.api/core/items/search/findByCustomURL?q=custom-id');
+    const linksToFollow = [];
+    const projections = ['full', 'detailed'];
+
+    beforeEach(() => {
+      searchData = jasmine.createSpyObj('searchData', ['getSearchByHref']);
+      getSearchByHrefSpy = searchData.getSearchByHref.and.returnValue(fakeHrefObs);
+      itemDataService = new ItemDataService(
+        requestService,
+        rdbService,
+        objectCache,
+        halEndpointService,
+        notificationsService,
+        comparator,
+        browseService,
+        bundleService,
+      );
+
+      (itemDataService as any).searchData = searchData;
+      findByHrefSpy = spyOn(itemDataService, 'findByHref').and.returnValue(createSuccessfulRemoteDataObject$(new Item()));
+    });
+
+    it('should call searchData.getSearchByHref with correct parameters', () => {
+      itemDataService.findByCustomUrl(id, true, true, linksToFollow, projections).subscribe();
+
+      expect(getSearchByHrefSpy).toHaveBeenCalledWith(
+        'findByCustomURL',
+        jasmine.objectContaining({
+          searchParams: jasmine.arrayContaining([
+            jasmine.objectContaining({ fieldName: 'q', fieldValue: id }),
+            jasmine.objectContaining({ fieldName: 'projection', fieldValue: 'full' }),
+            jasmine.objectContaining({ fieldName: 'projection', fieldValue: 'detailed' }),
+          ]),
+        }),
+        ...linksToFollow,
+      );
+    });
+
+    it('should call findByHref with the href observable returned from getSearchByHref', () => {
+      itemDataService.findByCustomUrl(id, true, false, linksToFollow, projections).subscribe();
+
+      expect(findByHrefSpy).toHaveBeenCalledWith(fakeHrefObs, true, false, ...linksToFollow);
+    });
+  });
+
+  describe('findById', () => {
+    let itemDataService: ItemDataService;
+
+    beforeEach(() => {
+      itemDataService = new ItemDataService(
+        requestService,
+        rdbService,
+        objectCache,
+        halEndpointService,
+        notificationsService,
+        comparator,
+        browseService,
+        bundleService,
+      );
+      spyOn(itemDataService, 'findByCustomUrl').and.returnValue(createSuccessfulRemoteDataObject$(new Item()));
+      spyOn(itemDataService, 'findByHref').and.returnValue(createSuccessfulRemoteDataObject$(new Item()));
+      spyOn(itemDataService as any, 'getIDHrefObs').and.returnValue(of('uuid-href'));
+    });
+
+    it('should call findByHref when given a valid UUID', () => {
+      const validUuid = '4af28e99-6a9c-4036-a199-e1b587046d39';
+      itemDataService.findById(validUuid).subscribe();
+
+      expect((itemDataService as any).getIDHrefObs).toHaveBeenCalledWith(encodeURIComponent(validUuid));
+      expect(itemDataService.findByHref).toHaveBeenCalled();
+      expect(itemDataService.findByCustomUrl).not.toHaveBeenCalled();
+    });
+
+    it('should call findByCustomUrl when given a non-UUID id', () => {
+      const nonUuid = 'custom-url';
+      itemDataService.findByIdOrCustomUrl(nonUuid).subscribe();
+
+      expect(itemDataService.findByCustomUrl).toHaveBeenCalledWith(nonUuid, true, true, []);
+      expect(itemDataService.findByHref).not.toHaveBeenCalled();
+    });
+  });
+
+
 });