Merger: porting of authority framework functionalities

config/config.example.yml

@@ -235,6 +235,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
 
@@ -629,3 +635,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/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.findById(nonUuid).subscribe();
+
+      expect(itemDataService.findByCustomUrl).toHaveBeenCalledWith(nonUuid, true, true, []);
+      expect(itemDataService.findByHref).not.toHaveBeenCalled();
+    });
+  });
+
+
 });

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

@@ -24,6 +24,7 @@ import {
   switchMap,
   take,
 } from 'rxjs/operators';
+import { validate as uuidValidate } from 'uuid';
 
 import { BrowseService } from '../browse/browse.service';
 import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
@@ -34,6 +35,7 @@ import { NotificationsService } from '../notification-system/notifications.servi
 import { Bundle } from '../shared/bundle.model';
 import { Collection } from '../shared/collection.model';
 import { ExternalSourceEntry } from '../shared/external-source-entry.model';
+import { FollowLinkConfig } from '../shared/follow-link-config.model';
 import { GenericConstructor } from '../shared/generic-constructor';
 import { HALEndpointService } from '../shared/hal-endpoint.service';
 import { Item } from '../shared/item.model';
@@ -58,6 +60,7 @@ import {
   PatchData,
   PatchDataImpl,
 } from './base/patch-data';
+import { SearchDataImpl } from './base/search-data';
 import { BundleDataService } from './bundle-data.service';
 import { DSOChangeAnalyzer } from './dso-change-analyzer.service';
 import { FindListOptions } from './find-list-options.model';
@@ -83,6 +86,7 @@ export abstract class BaseItemDataService extends IdentifiableDataService<Item>
   private createData: CreateData<Item>;
   private patchData: PatchData<Item>;
   private deleteData: DeleteData<Item>;
+  private searchData: SearchDataImpl<Item>;
 
   protected constructor(
     protected linkPath,
@@ -101,6 +105,7 @@ export abstract class BaseItemDataService extends IdentifiableDataService<Item>
     this.createData = new CreateDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, notificationsService, this.responseMsToLive);
     this.patchData = new PatchDataImpl<Item>(this.linkPath, requestService, rdbService, objectCache, halService, comparator, this.responseMsToLive, this.constructIdEndpoint);
     this.deleteData = new DeleteDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, notificationsService, this.responseMsToLive, this.constructIdEndpoint);
+    this.searchData = new SearchDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, this.responseMsToLive);
   }
 
   /**
@@ -425,6 +430,57 @@ export abstract class BaseItemDataService extends IdentifiableDataService<Item>
     return this.createData.create(object, ...params);
   }
 
+  /**
+   * Returns an observable of {@link RemoteData} of an object, based on its CustomURL or ID, with a list of
+   * {@link FollowLinkConfig}, to automatically resolve {@link HALLink}s of the object
+   * @param id                          CustomUrl or UUID of object we want to retrieve
+   * @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
+   * @param projections                 List of {@link projections} used to pass as parameters
+   */
+  public findByCustomUrl(id: string, useCachedVersionIfAvailable = true, reRequestOnStale = true, linksToFollow: FollowLinkConfig<Item>[], projections: string[] = []): Observable<RemoteData<Item>> {
+    const searchHref = 'findByCustomURL';
+
+    const options = Object.assign({}, {
+      searchParams: [
+        new RequestParam('q', id),
+      ],
+    });
+
+    projections.forEach((projection) => {
+      options.searchParams.push(new RequestParam('projection', projection));
+    });
+
+    const hrefObs = this.searchData.getSearchByHref(searchHref, options, ...linksToFollow);
+
+    return this.findByHref(hrefObs, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
+  }
+
+  /**
+   * Returns an observable of {@link RemoteData} of an object, based on its ID, with a list of
+   * {@link FollowLinkConfig}, to automatically resolve {@link HALLink}s of the object
+   * @param id                          ID of object we want to retrieve
+   * @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
+   */
+  public findById(id: string, useCachedVersionIfAvailable = true, reRequestOnStale = true, ...linksToFollow: FollowLinkConfig<Item>[]): Observable<RemoteData<Item>> {
+
+    if (uuidValidate(id)) {
+      const href$ = this.getIDHrefObs(encodeURIComponent(id), ...linksToFollow);
+      return this.findByHref(href$, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
+    } else {
+      return this.findByCustomUrl(id, useCachedVersionIfAvailable, reRequestOnStale, linksToFollow);
+    }
+  }
+
 }
 
 /**

src/app/core/provide-core.ts

@@ -4,6 +4,7 @@ import {
   makeEnvironmentProviders,
 } from '@angular/core';
 import { APP_CONFIG } from '@dspace/config/app-config.interface';
+import { SubmissionCustomUrl } from '@dspace/core/submission/models/submission-custom-url.model';
 
 import { AuthStatus } from './auth/models/auth-status.model';
 import { ShortLivedToken } from './auth/models/short-lived-token.model';
@@ -228,4 +229,5 @@ export const models =
     StatisticsEndpoint,
     CorrectionType,
     SupervisionOrder,
+    SubmissionCustomUrl,
   ];

src/app/core/router/utils/dso-route.utils.ts

@@ -31,9 +31,16 @@ export function getCommunityPageRoute(communityId: string) {
  */
 export function getItemPageRoute(item: Item) {
   const type = item.firstMetadataValue('dspace.entity.type');
-  return getEntityPageRoute(type, item.uuid);
+  let url = item.uuid;
+
+  if (isNotEmpty(item.metadata) && item.hasMetadata('dspace.customurl')) {
+    url = item.firstMetadataValue('dspace.customurl');
+  }
+
+  return getEntityPageRoute(type, url);
 }
 
+
 export function getEntityPageRoute(entityType: string, itemId: string) {
   if (isNotEmpty(entityType)) {
     return new URLCombiner(`/${ENTITY_MODULE_PATH}`, encodeURIComponent(entityType.toLowerCase()), itemId).toString();

src/app/core/shared/dspace-object.model.ts

@@ -126,6 +126,20 @@ export class DSpaceObject extends ListableObject implements CacheableObject {
     return Metadata.all(this.metadata, keyOrKeys, undefined, valueFilter, escapeHTML);
   }
 
+
+  /**
+   * Gets all matching metadata in this DSpaceObject, up to a limit.
+   *
+   * @param {string|string[]} keyOrKeys The metadata key(s) in scope. Wildcards are supported; see [[Metadata]].
+   * @param {number} limit The maximum number of results to return.
+   * @param {MetadataValueFilter} valueFilter The value filter to use. If unspecified, no filtering will be done.
+   * @returns {MetadataValue[]} the matching values or an empty array.
+   */
+  limitedMetadata(keyOrKeys: string | string[], limit: number, valueFilter?: MetadataValueFilter): MetadataValue[] {
+    return Metadata.all(this.metadata, keyOrKeys, null, valueFilter, false, limit);
+  }
+
+
   /**
    * Like [[allMetadata]], but only returns string values.
    *