{{ 'collection.edit.template.head' | translate:{ collection: collection?.name } }}
-
+
diff --git a/src/app/community-list-page/community-list-page.module.ts b/src/app/community-list-page/community-list-page.module.ts
index 18c28068be..15946b2e89 100644
--- a/src/app/community-list-page/community-list-page.module.ts
+++ b/src/app/community-list-page/community-list-page.module.ts
@@ -6,6 +6,7 @@ import { CommunityListPageRoutingModule } from './community-list-page.routing.mo
import { CommunityListComponent } from './community-list/community-list.component';
import { ThemedCommunityListPageComponent } from './themed-community-list-page.component';
import { ThemedCommunityListComponent } from './community-list/themed-community-list.component';
+import { CdkTreeModule } from '@angular/cdk/tree';
const DECLARATIONS = [
@@ -21,13 +22,15 @@ const DECLARATIONS = [
imports: [
CommonModule,
SharedModule,
- CommunityListPageRoutingModule
+ CommunityListPageRoutingModule,
+ CdkTreeModule,
],
declarations: [
...DECLARATIONS
],
exports: [
...DECLARATIONS,
+ CdkTreeModule,
],
})
export class CommunityListPageModule {
diff --git a/src/app/core/auth/auth.interceptor.ts b/src/app/core/auth/auth.interceptor.ts
index e55d0c0ff9..672879f436 100644
--- a/src/app/core/auth/auth.interceptor.ts
+++ b/src/app/core/auth/auth.interceptor.ts
@@ -196,7 +196,24 @@ export class AuthInterceptor implements HttpInterceptor {
authStatus.token = new AuthTokenInfo(accessToken);
} else {
authStatus.authenticated = false;
- authStatus.error = isNotEmpty(error) ? ((typeof error === 'string') ? JSON.parse(error) : error) : null;
+ if (isNotEmpty(error)) {
+ if (typeof error === 'string') {
+ try {
+ authStatus.error = JSON.parse(error);
+ } catch (e) {
+ console.error('Unknown auth error "', error, '" caused ', e);
+ authStatus.error = {
+ error: 'Unknown',
+ message: 'Unknown auth error',
+ status: 500,
+ timestamp: Date.now(),
+ path: ''
+ };
+ }
+ } else {
+ authStatus.error = error;
+ }
+ }
}
return authStatus;
}
diff --git a/src/app/core/breadcrumbs/dso-name.service.ts b/src/app/core/breadcrumbs/dso-name.service.ts
index d56f4a00eb..64f37baa65 100644
--- a/src/app/core/breadcrumbs/dso-name.service.ts
+++ b/src/app/core/breadcrumbs/dso-name.service.ts
@@ -2,6 +2,7 @@ import { Injectable } from '@angular/core';
import { hasValue, isEmpty } from '../../shared/empty.util';
import { DSpaceObject } from '../shared/dspace-object.model';
import { TranslateService } from '@ngx-translate/core';
+import { Metadata } from '../shared/metadata.utils';
/**
* Returns a name for a {@link DSpaceObject} based
@@ -67,4 +68,45 @@ export class DSONameService {
return name;
}
+ /**
+ * Gets the Hit highlight
+ *
+ * @param object
+ * @param dso
+ *
+ * @returns {string} html embedded hit highlight.
+ */
+ getHitHighlights(object: any, dso: DSpaceObject): string {
+ const types = dso.getRenderTypes();
+ const entityType = types
+ .filter((type) => typeof type === 'string')
+ .find((type: string) => (['Person', 'OrgUnit']).includes(type)) as string;
+ if (entityType === 'Person') {
+ const familyName = this.firstMetadataValue(object, dso, 'person.familyName');
+ const givenName = this.firstMetadataValue(object, dso, 'person.givenName');
+ if (isEmpty(familyName) && isEmpty(givenName)) {
+ return this.firstMetadataValue(object, dso, 'dc.title') || dso.name;
+ } else if (isEmpty(familyName) || isEmpty(givenName)) {
+ return familyName || givenName;
+ }
+ return `${familyName}, ${givenName}`;
+ } else if (entityType === 'OrgUnit') {
+ return this.firstMetadataValue(object, dso, 'organization.legalName');
+ }
+ return this.firstMetadataValue(object, dso, 'dc.title') || dso.name || this.translateService.instant('dso.name.untitled');
+ }
+
+ /**
+ * Gets the first matching metadata string value from hitHighlights or dso metadata, preferring hitHighlights.
+ *
+ * @param object
+ * @param dso
+ * @param {string|string[]} keyOrKeys The metadata key(s) in scope. Wildcards are supported; see [[Metadata]].
+ *
+ * @returns {string} the first matching string value, or `undefined`.
+ */
+ firstMetadataValue(object: any, dso: DSpaceObject, keyOrKeys: string | string[]): string {
+ return Metadata.firstValue([object.hitHighlights, dso.metadata], keyOrKeys);
+ }
+
}
diff --git a/src/app/core/data/array-move-change-analyzer.service.spec.ts b/src/app/core/data/array-move-change-analyzer.service.spec.ts
index 5f5388d935..025791d6dc 100644
--- a/src/app/core/data/array-move-change-analyzer.service.spec.ts
+++ b/src/app/core/data/array-move-change-analyzer.service.spec.ts
@@ -41,21 +41,28 @@ describe('ArrayMoveChangeAnalyzer', () => {
], new MoveTest(0, 3));
testMove([
+ { op: 'move', from: '/2', path: '/3' },
{ op: 'move', from: '/0', path: '/3' },
- { op: 'move', from: '/2', path: '/1' }
], new MoveTest(0, 3), new MoveTest(1, 2));
testMove([
+ { op: 'move', from: '/3', path: '/4' },
{ op: 'move', from: '/0', path: '/1' },
- { op: 'move', from: '/3', path: '/4' }
], new MoveTest(0, 1), new MoveTest(3, 4));
testMove([], new MoveTest(0, 4), new MoveTest(4, 0));
testMove([
+ { op: 'move', from: '/2', path: '/3' },
{ op: 'move', from: '/0', path: '/3' },
- { op: 'move', from: '/2', path: '/1' }
], new MoveTest(0, 4), new MoveTest(1, 3), new MoveTest(2, 4));
+
+ testMove([
+ { op: 'move', from: '/3', path: '/4' },
+ { op: 'move', from: '/2', path: '/4' },
+ { op: 'move', from: '/1', path: '/3' },
+ { op: 'move', from: '/0', path: '/3' },
+ ], new MoveTest(4, 1), new MoveTest(4, 2), new MoveTest(0, 3));
});
describe('when some values are undefined (index 2 and 3)', () => {
diff --git a/src/app/core/data/array-move-change-analyzer.service.ts b/src/app/core/data/array-move-change-analyzer.service.ts
index f6e07608f6..36744e9f96 100644
--- a/src/app/core/data/array-move-change-analyzer.service.ts
+++ b/src/app/core/data/array-move-change-analyzer.service.ts
@@ -16,22 +16,31 @@ export class ArrayMoveChangeAnalyzer
{
* @param array2 The custom array to compare with the original
*/
diff(array1: T[], array2: T[]): MoveOperation[] {
- const result = [];
- const moved = [...array1];
- array1.forEach((value: T, index: number) => {
- if (hasValue(value)) {
- const otherIndex = array2.indexOf(value);
- const movedIndex = moved.indexOf(value);
- if (index !== otherIndex && movedIndex !== otherIndex) {
- moveItemInArray(moved, movedIndex, otherIndex);
- result.push(Object.assign({
- op: 'move',
- from: '/' + movedIndex,
- path: '/' + otherIndex
- }) as MoveOperation);
- }
+ return this.getMoves(array1, array2).map((move) => Object.assign({
+ op: 'move',
+ from: '/' + move[0],
+ path: '/' + move[1],
+ }) as MoveOperation);
+ }
+
+ /**
+ * Determine a set of moves required to transform array1 into array2
+ * The moves are returned as an array of pairs of numbers where the first number is the original index and the second
+ * is the new index
+ * It is assumed the operations are executed in the order they're returned (and not simultaneously)
+ * @param array1
+ * @param array2
+ */
+ private getMoves(array1: any[], array2: any[]): number[][] {
+ const moved = [...array2];
+
+ return array1.reduce((moves, item, index) => {
+ if (hasValue(item) && item !== moved[index]) {
+ const last = moved.lastIndexOf(item);
+ moveItemInArray(moved, last, index);
+ moves.unshift([index, last]);
}
- });
- return result;
+ return moves;
+ }, []);
}
}
diff --git a/src/app/core/data/feature-authorization/feature-id.ts b/src/app/core/data/feature-authorization/feature-id.ts
index 3cb18bf515..9e73ca9a2b 100644
--- a/src/app/core/data/feature-authorization/feature-id.ts
+++ b/src/app/core/data/feature-authorization/feature-id.ts
@@ -29,5 +29,7 @@ export enum FeatureID {
CanViewUsageStatistics = 'canViewUsageStatistics',
CanSendFeedback = 'canSendFeedback',
CanClaimItem = 'canClaimItem',
- CanSynchronizeWithORCID = 'canSynchronizeWithORCID'
+ CanSynchronizeWithORCID = 'canSynchronizeWithORCID',
+ CanSubmit = 'canSubmit',
+ CanEditItem = 'canEditItem',
}
diff --git a/src/app/core/data/object-updates/patch-operation-service/operations/metadata/metadata-patch-move-operation.model.ts b/src/app/core/data/object-updates/patch-operation-service/operations/metadata/metadata-patch-move-operation.model.ts
new file mode 100644
index 0000000000..962d53dfee
--- /dev/null
+++ b/src/app/core/data/object-updates/patch-operation-service/operations/metadata/metadata-patch-move-operation.model.ts
@@ -0,0 +1,33 @@
+import { MetadataPatchOperation } from './metadata-patch-operation.model';
+import { Operation } from 'fast-json-patch';
+
+/**
+ * Wrapper object for a metadata patch move Operation
+ */
+export class MetadataPatchMoveOperation extends MetadataPatchOperation {
+ static operationType = 'move';
+
+ /**
+ * The original place of the metadata value to move
+ */
+ from: number;
+
+ /**
+ * The new place to move the metadata value to
+ */
+ to: number;
+
+ constructor(field: string, from: number, to: number) {
+ super(MetadataPatchMoveOperation.operationType, field);
+ this.from = from;
+ this.to = to;
+ }
+
+ /**
+ * Transform the MetadataPatchOperation into a fast-json-patch Operation by constructing its path and other properties
+ * using the information provided.
+ */
+ toOperation(): Operation {
+ return { op: this.op as any, from: `/metadata/${this.field}/${this.from}`, path: `/metadata/${this.field}/${this.to}` };
+ }
+}
diff --git a/src/app/core/data/relationship-data.service.spec.ts b/src/app/core/data/relationship-data.service.spec.ts
index 39aa7cbd58..4432d5213a 100644
--- a/src/app/core/data/relationship-data.service.spec.ts
+++ b/src/app/core/data/relationship-data.service.spec.ts
@@ -10,13 +10,19 @@ import { DeleteRequest } from './request.models';
import { RelationshipDataService } from './relationship-data.service';
import { RequestService } from './request.service';
import { HALEndpointServiceStub } from '../../shared/testing/hal-endpoint-service.stub';
-import { createSuccessfulRemoteDataObject, createSuccessfulRemoteDataObject$ } from '../../shared/remote-data.utils';
+import {
+ createFailedRemoteDataObject$,
+ createSuccessfulRemoteDataObject,
+ createSuccessfulRemoteDataObject$
+} from '../../shared/remote-data.utils';
import { getMockRemoteDataBuildServiceHrefMap } from '../../shared/mocks/remote-data-build.service.mock';
import { getMockRequestService } from '../../shared/mocks/request.service.mock';
import { createPaginatedList } from '../../shared/testing/utils.test';
import { RequestEntry } from './request-entry.model';
import { FindListOptions } from './find-list-options.model';
import { testSearchDataImplementation } from './base/search-data.spec';
+import { MetadataValue } from '../shared/metadata.models';
+import { MetadataRepresentationType } from '../shared/metadata-representation/metadata-representation.model';
describe('RelationshipDataService', () => {
let service: RelationshipDataService;
@@ -233,4 +239,152 @@ describe('RelationshipDataService', () => {
});
});
});
+
+ describe('resolveMetadataRepresentation', () => {
+ const parentItem: Item = Object.assign(new Item(), {
+ id: 'parent-item',
+ metadata: {
+ 'dc.contributor.author': [
+ Object.assign(new MetadataValue(), {
+ language: null,
+ value: 'Related Author with authority',
+ authority: 'virtual::related-author',
+ place: 2
+ }),
+ Object.assign(new MetadataValue(), {
+ language: null,
+ value: 'Author without authority',
+ place: 1
+ }),
+ ],
+ 'dc.creator': [
+ Object.assign(new MetadataValue(), {
+ language: null,
+ value: 'Related Creator with authority',
+ authority: 'virtual::related-creator',
+ place: 3,
+ }),
+ Object.assign(new MetadataValue(), {
+ language: null,
+ value: 'Related Creator with authority - unauthorized',
+ authority: 'virtual::related-creator-unauthorized',
+ place: 4,
+ }),
+ ],
+ 'dc.title': [
+ Object.assign(new MetadataValue(), {
+ language: null,
+ value: 'Parent Item'
+ }),
+ ]
+ }
+ });
+ const relatedAuthor: Item = Object.assign(new Item(), {
+ id: 'related-author',
+ metadata: {
+ 'dc.title': [
+ Object.assign(new MetadataValue(), {
+ language: null,
+ value: 'Related Author'
+ }),
+ ]
+ }
+ });
+ const relatedCreator: Item = Object.assign(new Item(), {
+ id: 'related-creator',
+ metadata: {
+ 'dc.title': [
+ Object.assign(new MetadataValue(), {
+ language: null,
+ value: 'Related Creator'
+ }),
+ ],
+ 'dspace.entity.type': 'Person',
+ }
+ });
+ const authorRelation: Relationship = Object.assign(new Relationship(), {
+ leftItem: createSuccessfulRemoteDataObject$(parentItem),
+ rightItem: createSuccessfulRemoteDataObject$(relatedAuthor)
+ });
+ const creatorRelation: Relationship = Object.assign(new Relationship(), {
+ leftItem: createSuccessfulRemoteDataObject$(parentItem),
+ rightItem: createSuccessfulRemoteDataObject$(relatedCreator),
+ });
+ const creatorRelationUnauthorized: Relationship = Object.assign(new Relationship(), {
+ leftItem: createSuccessfulRemoteDataObject$(parentItem),
+ rightItem: createFailedRemoteDataObject$('Unauthorized', 401),
+ });
+
+ let metadatum: MetadataValue;
+
+ beforeEach(() => {
+ service.findById = (id: string) => {
+ if (id === 'related-author') {
+ return createSuccessfulRemoteDataObject$(authorRelation);
+ }
+ if (id === 'related-creator') {
+ return createSuccessfulRemoteDataObject$(creatorRelation);
+ }
+ if (id === 'related-creator-unauthorized') {
+ return createSuccessfulRemoteDataObject$(creatorRelationUnauthorized);
+ }
+ };
+ });
+
+ describe('when the metadata isn\'t virtual', () => {
+ beforeEach(() => {
+ metadatum = parentItem.metadata['dc.contributor.author'][1];
+ });
+
+ it('should return a plain text MetadatumRepresentation', (done) => {
+ service.resolveMetadataRepresentation(metadatum, parentItem, 'Person').subscribe((result) => {
+ expect(result.representationType).toEqual(MetadataRepresentationType.PlainText);
+ done();
+ });
+ });
+ });
+
+ describe('when the metadata is a virtual author', () => {
+ beforeEach(() => {
+ metadatum = parentItem.metadata['dc.contributor.author'][0];
+ });
+
+ it('should return a ItemMetadataRepresentation with the correct value', (done) => {
+ service.resolveMetadataRepresentation(metadatum, parentItem, 'Person').subscribe((result) => {
+ expect(result.representationType).toEqual(MetadataRepresentationType.Item);
+ expect(result.getValue()).toEqual(metadatum.value);
+ expect((result as any).id).toEqual(relatedAuthor.id);
+ done();
+ });
+ });
+ });
+
+ describe('when the metadata is a virtual creator', () => {
+ beforeEach(() => {
+ metadatum = parentItem.metadata['dc.creator'][0];
+ });
+
+ it('should return a ItemMetadataRepresentation with the correct value', (done) => {
+ service.resolveMetadataRepresentation(metadatum, parentItem, 'Person').subscribe((result) => {
+ expect(result.representationType).toEqual(MetadataRepresentationType.Item);
+ expect(result.getValue()).toEqual(metadatum.value);
+ expect((result as any).id).toEqual(relatedCreator.id);
+ done();
+ });
+ });
+ });
+
+ describe('when the metadata refers to a relationship leading to an error response', () => {
+ beforeEach(() => {
+ metadatum = parentItem.metadata['dc.creator'][1];
+ });
+
+ it('should return an authority controlled MetadatumRepresentation', (done) => {
+ service.resolveMetadataRepresentation(metadatum, parentItem, 'Person').subscribe((result) => {
+ expect(result.representationType).toEqual(MetadataRepresentationType.AuthorityControlled);
+ done();
+ });
+ });
+ });
+ });
});
diff --git a/src/app/core/data/relationship-data.service.ts b/src/app/core/data/relationship-data.service.ts
index 85adeff754..46a51a2d01 100644
--- a/src/app/core/data/relationship-data.service.ts
+++ b/src/app/core/data/relationship-data.service.ts
@@ -1,7 +1,7 @@
import { HttpHeaders } from '@angular/common/http';
import { Inject, Injectable } from '@angular/core';
import { MemoizedSelector, select, Store } from '@ngrx/store';
-import { combineLatest as observableCombineLatest, Observable } from 'rxjs';
+import { combineLatest as observableCombineLatest, Observable, of as observableOf } from 'rxjs';
import { distinctUntilChanged, filter, map, mergeMap, startWith, switchMap, take, tap } from 'rxjs/operators';
import {
compareArraysUsingIds, PAGINATED_RELATIONS_TO_ITEMS_OPERATOR,
@@ -46,6 +46,11 @@ import { PutData, PutDataImpl } from './base/put-data';
import { IdentifiableDataService } from './base/identifiable-data.service';
import { dataService } from './base/data-service.decorator';
import { itemLinksToFollow } from '../../shared/utils/relation-query.utils';
+import { MetadataValue } from '../shared/metadata.models';
+import { MetadataRepresentation } from '../shared/metadata-representation/metadata-representation.model';
+import { MetadatumRepresentation } from '../shared/metadata-representation/metadatum/metadatum-representation.model';
+import { ItemMetadataRepresentation } from '../shared/metadata-representation/item/item-metadata-representation.model';
+import { DSpaceObject } from '../shared/dspace-object.model';
const relationshipListsStateSelector = (state: AppState) => state.relationshipLists;
@@ -550,4 +555,40 @@ export class RelationshipDataService extends IdentifiableDataService[]): Observable>> {
return this.searchData.searchBy(searchMethod, options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
}
+
+ /**
+ * Resolve a {@link MetadataValue} into a {@link MetadataRepresentation} of the correct type
+ * @param metadatum {@link MetadataValue} to resolve
+ * @param parentItem Parent dspace object the metadata value belongs to
+ * @param itemType The type of item this metadata value represents (will only be used when no related item can be found, as a fallback)
+ */
+ resolveMetadataRepresentation(metadatum: MetadataValue, parentItem: DSpaceObject, itemType: string): Observable {
+ if (metadatum.isVirtual) {
+ return this.findById(metadatum.virtualValue, true, false, followLink('leftItem'), followLink('rightItem')).pipe(
+ getFirstSucceededRemoteData(),
+ switchMap((relRD: RemoteData) =>
+ observableCombineLatest(relRD.payload.leftItem, relRD.payload.rightItem).pipe(
+ filter(([leftItem, rightItem]) => leftItem.hasCompleted && rightItem.hasCompleted),
+ map(([leftItem, rightItem]) => {
+ if (!leftItem.hasSucceeded || !rightItem.hasSucceeded) {
+ return null;
+ } else if (rightItem.hasSucceeded && leftItem.payload.id === parentItem.id) {
+ return rightItem.payload;
+ } else if (rightItem.payload.id === parentItem.id) {
+ return leftItem.payload;
+ }
+ }),
+ map((item: Item) => {
+ if (hasValue(item)) {
+ return Object.assign(new ItemMetadataRepresentation(metadatum), item);
+ } else {
+ return Object.assign(new MetadatumRepresentation(itemType), metadatum);
+ }
+ })
+ )
+ ));
+ } else {
+ return observableOf(Object.assign(new MetadatumRepresentation(itemType), metadatum));
+ }
+ }
}
diff --git a/src/app/core/metadata/metadata.service.spec.ts b/src/app/core/metadata/metadata.service.spec.ts
index 66d9b9921c..553b437d71 100644
--- a/src/app/core/metadata/metadata.service.spec.ts
+++ b/src/app/core/metadata/metadata.service.spec.ts
@@ -8,7 +8,12 @@ import { Observable, of as observableOf, of } from 'rxjs';
import { RemoteData } from '../data/remote-data';
import { Item } from '../shared/item.model';
-import { ItemMock, MockBitstream1, MockBitstream3 } from '../../shared/mocks/item.mock';
+import {
+ ItemMock,
+ MockBitstream1,
+ MockBitstream3,
+ MockBitstream2
+} from '../../shared/mocks/item.mock';
import { createSuccessfulRemoteDataObject, createSuccessfulRemoteDataObject$ } from '../../shared/remote-data.utils';
import { PaginatedList } from '../data/paginated-list.model';
import { Bitstream } from '../shared/bitstream.model';
@@ -24,6 +29,7 @@ import { HardRedirectService } from '../services/hard-redirect.service';
import { getMockStore } from '@ngrx/store/testing';
import { AddMetaTagAction, ClearMetaTagAction } from './meta-tag.actions';
import { AuthorizationDataService } from '../data/feature-authorization/authorization-data.service';
+import { AppConfig } from '../../../config/app-config.interface';
describe('MetadataService', () => {
let metadataService: MetadataService;
@@ -44,6 +50,8 @@ describe('MetadataService', () => {
let router: Router;
let store;
+ let appConfig: AppConfig;
+
const initialState = { 'core': { metaTag: { tagsInUse: ['title', 'description'] }}};
@@ -86,6 +94,14 @@ describe('MetadataService', () => {
store = getMockStore({ initialState });
spyOn(store, 'dispatch');
+ appConfig = {
+ item: {
+ bitstream: {
+ pageSize: 5
+ }
+ }
+ } as any;
+
metadataService = new MetadataService(
router,
translateService,
@@ -98,6 +114,7 @@ describe('MetadataService', () => {
rootService,
store,
hardRedirectService,
+ appConfig,
authorizationService
);
});
@@ -358,29 +375,66 @@ describe('MetadataService', () => {
});
}));
- it('should link to first Bitstream with allowed format', fakeAsync(() => {
- const bitstreams = [MockBitstream3, MockBitstream3, MockBitstream1];
- (bundleDataService.findByItemAndName as jasmine.Spy).and.returnValue(mockBundleRD$(bitstreams));
- (bitstreamDataService.findListByHref as jasmine.Spy).and.returnValues(
- ...mockBitstreamPages$(bitstreams).map(bp => createSuccessfulRemoteDataObject$(bp)),
- );
+ describe(`when there's a bitstream with an allowed format on the first page`, () => {
+ let bitstreams;
- (metadataService as any).processRouteChange({
- data: {
- value: {
- dso: createSuccessfulRemoteDataObject(ItemMock),
+ beforeEach(() => {
+ bitstreams = [MockBitstream2, MockBitstream3, MockBitstream1];
+ (bundleDataService.findByItemAndName as jasmine.Spy).and.returnValue(mockBundleRD$(bitstreams));
+ (bitstreamDataService.findListByHref as jasmine.Spy).and.returnValues(
+ ...mockBitstreamPages$(bitstreams).map(bp => createSuccessfulRemoteDataObject$(bp)),
+ );
+ });
+
+ it('should link to first Bitstream with allowed format', fakeAsync(() => {
+ (metadataService as any).processRouteChange({
+ data: {
+ value: {
+ dso: createSuccessfulRemoteDataObject(ItemMock),
+ }
}
- }
- });
- tick();
- expect(meta.addTag).toHaveBeenCalledWith({
- name: 'citation_pdf_url',
- content: 'https://request.org/bitstreams/cf9b0c8e-a1eb-4b65-afd0-567366448713/download'
- });
- }));
+ });
+ tick();
+ expect(meta.addTag).toHaveBeenCalledWith({
+ name: 'citation_pdf_url',
+ content: 'https://request.org/bitstreams/99b00f3c-1cc6-4689-8158-91965bee6b28/download'
+ });
+ }));
+
+ });
+
});
});
+ describe(`when there's no bitstream with an allowed format on the first page`, () => {
+ let bitstreams;
+
+ beforeEach(() => {
+ bitstreams = [MockBitstream1, MockBitstream3, MockBitstream2];
+ (bundleDataService.findByItemAndName as jasmine.Spy).and.returnValue(mockBundleRD$(bitstreams));
+ (bitstreamDataService.findListByHref as jasmine.Spy).and.returnValues(
+ ...mockBitstreamPages$(bitstreams).map(bp => createSuccessfulRemoteDataObject$(bp)),
+ );
+ });
+
+ it(`shouldn't add a citation_pdf_url meta tag`, fakeAsync(() => {
+ (metadataService as any).processRouteChange({
+ data: {
+ value: {
+ dso: createSuccessfulRemoteDataObject(ItemMock),
+ }
+ }
+ });
+ tick();
+ expect(meta.addTag).not.toHaveBeenCalledWith({
+ name: 'citation_pdf_url',
+ content: 'https://request.org/bitstreams/99b00f3c-1cc6-4689-8158-91965bee6b28/download'
+ });
+ }));
+
+ });
+
+
describe('tagstore', () => {
beforeEach(fakeAsync(() => {
(metadataService as any).processRouteChange({
diff --git a/src/app/core/metadata/metadata.service.ts b/src/app/core/metadata/metadata.service.ts
index 9d5ee80bba..204c925e6b 100644
--- a/src/app/core/metadata/metadata.service.ts
+++ b/src/app/core/metadata/metadata.service.ts
@@ -1,14 +1,21 @@
-import { Injectable } from '@angular/core';
+import { Injectable, Inject } from '@angular/core';
import { Meta, MetaDefinition, Title } from '@angular/platform-browser';
import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
import { TranslateService } from '@ngx-translate/core';
-import { BehaviorSubject, combineLatest, EMPTY, Observable, of as observableOf } from 'rxjs';
-import { expand, filter, map, switchMap, take } from 'rxjs/operators';
+import {
+ BehaviorSubject,
+ combineLatest,
+ Observable,
+ of as observableOf,
+ concat as observableConcat,
+ EMPTY
+} from 'rxjs';
+import { filter, map, switchMap, take, mergeMap } from 'rxjs/operators';
-import { hasNoValue, hasValue } from '../../shared/empty.util';
+import { hasNoValue, hasValue, isNotEmpty } from '../../shared/empty.util';
import { DSONameService } from '../breadcrumbs/dso-name.service';
import { BitstreamDataService } from '../data/bitstream-data.service';
import { BitstreamFormatDataService } from '../data/bitstream-format-data.service';
@@ -37,6 +44,7 @@ import { coreSelector } from '../core.selectors';
import { CoreState } from '../core-state.model';
import { AuthorizationDataService } from '../data/feature-authorization/authorization-data.service';
import { getDownloadableBitstream } from '../shared/bitstream.operators';
+import { APP_CONFIG, AppConfig } from '../../../config/app-config.interface';
/**
* The base selector function to select the metaTag section in the store
@@ -87,6 +95,7 @@ export class MetadataService {
private rootService: RootDataService,
private store: Store,
private hardRedirectService: HardRedirectService,
+ @Inject(APP_CONFIG) private appConfig: AppConfig,
private authorizationService: AuthorizationDataService
) {
}
@@ -298,7 +307,13 @@ export class MetadataService {
true,
true,
followLink('primaryBitstream'),
- followLink('bitstreams', {}, followLink('format')),
+ followLink('bitstreams', {
+ findListOptions: {
+ // limit the number of bitstreams used to find the citation pdf url to the number
+ // shown by default on an item page
+ elementsPerPage: this.appConfig.item.bitstream.pageSize
+ }
+ }, followLink('format')),
).pipe(
getFirstSucceededRemoteDataPayload(),
switchMap((bundle: Bundle) =>
@@ -363,64 +378,45 @@ export class MetadataService {
}
/**
- * For Items with more than one Bitstream (and no primary Bitstream), link to the first Bitstream with a MIME type
+ * For Items with more than one Bitstream (and no primary Bitstream), link to the first Bitstream
+ * with a MIME type.
+ *
+ * Note this will only check the current page (page size determined item.bitstream.pageSize in the
+ * config) of bitstreams for performance reasons.
+ * See https://github.com/DSpace/DSpace/issues/8648 for more info
+ *
* included in {@linkcode CITATION_PDF_URL_MIMETYPES}
* @param bitstreamRd
* @private
*/
private getFirstAllowedFormatBitstreamLink(bitstreamRd: RemoteData>): Observable {
- return observableOf(bitstreamRd.payload).pipe(
- // Because there can be more than one page of bitstreams, this expand operator
- // will retrieve them in turn. Due to the take(1) at the bottom, it will only
- // retrieve pages until a match is found
- expand((paginatedList: PaginatedList) => {
- if (hasNoValue(paginatedList.next)) {
- // If there's no next page, stop.
- return EMPTY;
- } else {
- // Otherwise retrieve the next page
- return this.bitstreamDataService.findListByHref(
- paginatedList.next,
- undefined,
- true,
- true,
- followLink('format')
- ).pipe(
- getFirstCompletedRemoteData(),
- map((next: RemoteData>) => {
- if (hasValue(next.payload)) {
- return next.payload;
- } else {
- return EMPTY;
- }
- })
- );
- }
- }),
- // Return the array of bitstreams inside each paginated list
- map((paginatedList: PaginatedList) => paginatedList.page),
- // Emit the bitstreams in the list one at a time
- switchMap((bitstreams: Bitstream[]) => bitstreams),
- // Retrieve the format for each bitstream
- switchMap((bitstream: Bitstream) => bitstream.format.pipe(
- getFirstSucceededRemoteDataPayload(),
- // Keep the original bitstream, because it, not the format, is what we'll need
- // for the link at the end
- map((format: BitstreamFormat) => [bitstream, format])
- )),
- // Check if bitstream downloadable
- switchMap(([bitstream, format]: [Bitstream, BitstreamFormat]) => observableOf(bitstream).pipe(
- getDownloadableBitstream(this.authorizationService),
- map((bit: Bitstream) => [bit, format])
- )),
- // Filter out only pairs with whitelisted formats and non-null bitstreams, null from download check
- filter(([bitstream, format]: [Bitstream, BitstreamFormat]) =>
- hasValue(format) && hasValue(bitstream) && this.CITATION_PDF_URL_MIMETYPES.includes(format.mimetype)),
- // We only need 1
- take(1),
- // Emit the link of the match
- map(([bitstream, ]: [Bitstream, BitstreamFormat]) => getBitstreamDownloadRoute(bitstream))
- );
+ if (hasValue(bitstreamRd.payload) && isNotEmpty(bitstreamRd.payload.page)) {
+ // Retrieve the formats of all bitstreams in the page sequentially
+ return observableConcat(
+ ...bitstreamRd.payload.page.map((bitstream: Bitstream) => bitstream.format.pipe(
+ getFirstSucceededRemoteDataPayload(),
+ // Keep the original bitstream, because it, not the format, is what we'll need
+ // for the link at the end
+ map((format: BitstreamFormat) => [bitstream, format])
+ ))
+ ).pipe(
+ // Verify that the bitstream is downloadable
+ mergeMap(([bitstream, format]: [Bitstream, BitstreamFormat]) => observableOf(bitstream).pipe(
+ getDownloadableBitstream(this.authorizationService),
+ map((bit: Bitstream) => [bit, format])
+ )),
+ // Filter out only pairs with whitelisted formats and non-null bitstreams, null from download check
+ filter(([bitstream, format]: [Bitstream, BitstreamFormat]) =>
+ hasValue(format) && hasValue(bitstream) && this.CITATION_PDF_URL_MIMETYPES.includes(format.mimetype)),
+ // We only need 1
+ take(1),
+ // Emit the link of the match
+ // tap((v) => console.log('result', v)),
+ map(([bitstream, ]: [Bitstream, BitstreamFormat]) => getBitstreamDownloadRoute(bitstream))
+ );
+ } else {
+ return EMPTY;
+ }
}
/**
diff --git a/src/app/core/shared/media-viewer-item.model.ts b/src/app/core/shared/media-viewer-item.model.ts
index cd3a31bd0b..1cf4948408 100644
--- a/src/app/core/shared/media-viewer-item.model.ts
+++ b/src/app/core/shared/media-viewer-item.model.ts
@@ -14,6 +14,11 @@ export class MediaViewerItem {
*/
format: string;
+ /**
+ * Incoming Bitsream format mime type
+ */
+ mimetype: string;
+
/**
* Incoming Bitsream thumbnail
*/
diff --git a/src/app/core/shared/operators.ts b/src/app/core/shared/operators.ts
index 32610c82fd..94ca25235b 100644
--- a/src/app/core/shared/operators.ts
+++ b/src/app/core/shared/operators.ts
@@ -226,7 +226,7 @@ export const metadataFieldsToString = () =>
map((schema: MetadataSchema) => ({ field, schema }))
);
});
- return observableCombineLatest(fieldSchemaArray);
+ return isNotEmpty(fieldSchemaArray) ? observableCombineLatest(fieldSchemaArray) : [[]];
}),
map((fieldSchemaArray: { field: MetadataField, schema: MetadataSchema }[]): string[] => {
return fieldSchemaArray.map((fieldSchema: { field: MetadataField, schema: MetadataSchema }) => fieldSchema.schema.prefix + '.' + fieldSchema.field.toString());
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.html b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.html
new file mode 100644
index 0000000000..9f74216d54
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.html
@@ -0,0 +1,15 @@
+
+
+
+
+
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.scss b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.scss
new file mode 100644
index 0000000000..6b52c4f4b3
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.scss
@@ -0,0 +1,7 @@
+.ds-drop-list {
+ background-color: var(--bs-gray-500);
+
+ &.disabled {
+ opacity: 0.3;
+ }
+}
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.spec.ts b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.spec.ts
new file mode 100644
index 0000000000..3ca0dba3b6
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.spec.ts
@@ -0,0 +1,135 @@
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { VarDirective } from '../../../shared/utils/var.directive';
+import { TranslateModule } from '@ngx-translate/core';
+import { RouterTestingModule } from '@angular/router/testing';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { DsoEditMetadataFieldValuesComponent } from './dso-edit-metadata-field-values.component';
+import { DsoEditMetadataForm } from '../dso-edit-metadata-form';
+import { DSpaceObject } from '../../../core/shared/dspace-object.model';
+import { MetadataValue } from '../../../core/shared/metadata.models';
+import { of } from 'rxjs/internal/observable/of';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { By } from '@angular/platform-browser';
+
+describe('DsoEditMetadataFieldValuesComponent', () => {
+ let component: DsoEditMetadataFieldValuesComponent;
+ let fixture: ComponentFixture;
+
+ let form: DsoEditMetadataForm;
+ let dso: DSpaceObject;
+ let mdField: string;
+ let draggingMdField$: BehaviorSubject;
+
+ beforeEach(waitForAsync(() => {
+ dso = Object.assign(new DSpaceObject(), {
+ metadata: {
+ 'dc.title': [
+ Object.assign(new MetadataValue(), {
+ value: 'Test Title',
+ language: 'en',
+ place: 0,
+ }),
+ ],
+ 'dc.subject': [
+ Object.assign(new MetadataValue(), {
+ value: 'Subject One',
+ language: 'en',
+ place: 0,
+ }),
+ Object.assign(new MetadataValue(), {
+ value: 'Subject Two',
+ language: 'en',
+ place: 1,
+ }),
+ Object.assign(new MetadataValue(), {
+ value: 'Subject Three',
+ language: 'en',
+ place: 2,
+ }),
+ ],
+ },
+ });
+ form = new DsoEditMetadataForm(dso.metadata);
+ mdField = 'dc.subject';
+ draggingMdField$ = new BehaviorSubject(null);
+
+ TestBed.configureTestingModule({
+ declarations: [DsoEditMetadataFieldValuesComponent, VarDirective],
+ imports: [TranslateModule.forRoot(), RouterTestingModule.withRoutes([])],
+ providers: [
+ ],
+ schemas: [NO_ERRORS_SCHEMA]
+ }).compileComponents();
+ }));
+
+ beforeEach(() => {
+ fixture = TestBed.createComponent(DsoEditMetadataFieldValuesComponent);
+ component = fixture.componentInstance;
+ component.dso = dso;
+ component.form = form;
+ component.mdField = mdField;
+ component.saving$ = of(false);
+ component.draggingMdField$ = draggingMdField$;
+ fixture.detectChanges();
+ });
+
+ describe('when draggingMdField$ emits a value equal to mdField', () => {
+ beforeEach(() => {
+ draggingMdField$.next(mdField);
+ fixture.detectChanges();
+ });
+
+ it('should not disable the list', () => {
+ expect(fixture.debugElement.query(By.css('.ds-drop-list.disabled'))).toBeNull();
+ });
+ });
+
+ describe('when draggingMdField$ emits a value different to mdField', () => {
+ beforeEach(() => {
+ draggingMdField$.next(`${mdField}.fake`);
+ fixture.detectChanges();
+ });
+
+ it('should disable the list', () => {
+ expect(fixture.debugElement.query(By.css('.ds-drop-list.disabled'))).toBeTruthy();
+ });
+ });
+
+ describe('when draggingMdField$ emits null', () => {
+ beforeEach(() => {
+ draggingMdField$.next(null);
+ fixture.detectChanges();
+ });
+
+ it('should not disable the list', () => {
+ expect(fixture.debugElement.query(By.css('.ds-drop-list.disabled'))).toBeNull();
+ });
+ });
+
+ describe('dropping a value on a different index', () => {
+ beforeEach(() => {
+ component.drop(Object.assign({
+ previousIndex: 0,
+ currentIndex: 2,
+ }));
+ });
+
+ it('should physically move the relevant metadata value within the form', () => {
+ expect(form.fields[mdField][0].newValue.value).toEqual('Subject Two');
+ expect(form.fields[mdField][1].newValue.value).toEqual('Subject Three');
+ expect(form.fields[mdField][2].newValue.value).toEqual('Subject One');
+ });
+
+ it('should update the metadata values their new place to match the new physical order', () => {
+ expect(form.fields[mdField][0].newValue.place).toEqual(0);
+ expect(form.fields[mdField][1].newValue.place).toEqual(1);
+ expect(form.fields[mdField][2].newValue.place).toEqual(2);
+ });
+
+ it('should maintain the metadata values their original place in their original value so it can be used later to determine the patch operations', () => {
+ expect(form.fields[mdField][0].originalValue.place).toEqual(1);
+ expect(form.fields[mdField][1].originalValue.place).toEqual(2);
+ expect(form.fields[mdField][2].originalValue.place).toEqual(0);
+ });
+ });
+});
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.ts b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.ts
new file mode 100644
index 0000000000..2702e0ba1f
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-field-values/dso-edit-metadata-field-values.component.ts
@@ -0,0 +1,81 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { DsoEditMetadataChangeType, DsoEditMetadataForm, DsoEditMetadataValue } from '../dso-edit-metadata-form';
+import { Observable } from 'rxjs/internal/Observable';
+import { DSpaceObject } from '../../../core/shared/dspace-object.model';
+import { BehaviorSubject } from 'rxjs/internal/BehaviorSubject';
+import { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';
+
+@Component({
+ selector: 'ds-dso-edit-metadata-field-values',
+ styleUrls: ['./dso-edit-metadata-field-values.component.scss'],
+ templateUrl: './dso-edit-metadata-field-values.component.html',
+})
+/**
+ * Component displaying table rows for each value for a certain metadata field within a form
+ */
+export class DsoEditMetadataFieldValuesComponent {
+ /**
+ * The parent {@link DSpaceObject} to display a metadata form for
+ * Also used to determine metadata-representations in case of virtual metadata
+ */
+ @Input() dso: DSpaceObject;
+ /**
+ * A dynamic form object containing all information about the metadata and the changes made to them, see {@link DsoEditMetadataForm}
+ */
+ @Input() form: DsoEditMetadataForm;
+
+ /**
+ * Metadata field to display values for
+ */
+ @Input() mdField: string;
+
+ /**
+ * Type of DSO we're displaying values for
+ * Determines i18n messages
+ */
+ @Input() dsoType: string;
+
+ /**
+ * Observable to check if the form is being saved or not
+ */
+ @Input() saving$: Observable;
+
+ /**
+ * Tracks for which metadata-field a drag operation is taking place
+ * Null when no drag is currently happening for any field
+ */
+ @Input() draggingMdField$: BehaviorSubject;
+
+ /**
+ * Emit when the value has been saved within the form
+ */
+ @Output() valueSaved: EventEmitter = new EventEmitter();
+
+ /**
+ * The DsoEditMetadataChangeType enumeration for access in the component's template
+ * @type {DsoEditMetadataChangeType}
+ */
+ public DsoEditMetadataChangeTypeEnum = DsoEditMetadataChangeType;
+
+ /**
+ * Drop a value into a new position
+ * Update the form's value array for the current field to match the dropped position
+ * Update the values their place property to match the new order
+ * Send an update to the parent
+ * @param event
+ */
+ drop(event: CdkDragDrop) {
+ const dragIndex = event.previousIndex;
+ const dropIndex = event.currentIndex;
+ // Move the value within its field
+ moveItemInArray(this.form.fields[this.mdField], dragIndex, dropIndex);
+ // Update all the values in this field their place property
+ this.form.fields[this.mdField].forEach((value: DsoEditMetadataValue, index: number) => {
+ value.newValue.place = index;
+ value.confirmChanges();
+ });
+ // Update the form statuses
+ this.form.resetReinstatable();
+ this.valueSaved.emit();
+ }
+}
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-form.spec.ts b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-form.spec.ts
new file mode 100644
index 0000000000..5f8680088a
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-form.spec.ts
@@ -0,0 +1,275 @@
+import { DsoEditMetadataChangeType, DsoEditMetadataForm } from './dso-edit-metadata-form';
+import { DSpaceObject } from '../../core/shared/dspace-object.model';
+import { MetadataValue } from '../../core/shared/metadata.models';
+
+describe('DsoEditMetadataForm', () => {
+ let form: DsoEditMetadataForm;
+ let dso: DSpaceObject;
+
+ beforeEach(() => {
+ dso = Object.assign(new DSpaceObject(), {
+ metadata: {
+ 'dc.title': [
+ Object.assign(new MetadataValue(), {
+ value: 'Test Title',
+ language: 'en',
+ place: 0,
+ }),
+ ],
+ 'dc.subject': [
+ Object.assign(new MetadataValue(), {
+ value: 'Subject One',
+ language: 'en',
+ place: 0,
+ }),
+ Object.assign(new MetadataValue(), {
+ value: 'Subject Two',
+ language: 'en',
+ place: 1,
+ }),
+ Object.assign(new MetadataValue(), {
+ value: 'Subject Three',
+ language: 'en',
+ place: 2,
+ }),
+ ],
+ },
+ });
+ form = new DsoEditMetadataForm(dso.metadata);
+ });
+
+
+ describe('adding a new value', () => {
+ beforeEach(() => {
+ form.add();
+ });
+
+ it('should add an empty value to \"newValue\" with no place yet and editing set to true', () => {
+ expect(form.newValue).toBeDefined();
+ expect(form.newValue.originalValue.place).toBeUndefined();
+ expect(form.newValue.newValue.place).toBeUndefined();
+ expect(form.newValue.editing).toBeTrue();
+ });
+
+ it('should not mark the form as changed yet', () => {
+ expect(form.hasChanges()).toEqual(false);
+ });
+
+ describe('and assigning a value and metadata field to it', () => {
+ let mdField: string;
+ let value: string;
+ let expectedPlace: number;
+
+ beforeEach(() => {
+ mdField = 'dc.subject';
+ value = 'Subject Four';
+ form.newValue.newValue.value = value;
+ form.setMetadataField(mdField);
+ expectedPlace = form.fields[mdField].length - 1;
+ });
+
+ it('should add the new value to the values of the relevant field', () => {
+ expect(form.fields[mdField][expectedPlace].newValue.value).toEqual(value);
+ });
+
+ it('should set its editing flag to false', () => {
+ expect(form.fields[mdField][expectedPlace].editing).toBeFalse();
+ });
+
+ it('should set both its original and new place to match its position in the value array', () => {
+ expect(form.fields[mdField][expectedPlace].newValue.place).toEqual(expectedPlace);
+ expect(form.fields[mdField][expectedPlace].originalValue.place).toEqual(expectedPlace);
+ });
+
+ it('should clear \"newValue\"', () => {
+ expect(form.newValue).toBeUndefined();
+ });
+
+ it('should mark the form as changed', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+
+ describe('discard', () => {
+ beforeEach(() => {
+ form.discard();
+ });
+
+ it('should remove the new value', () => {
+ expect(form.fields[mdField][expectedPlace]).toBeUndefined();
+ });
+
+ it('should mark the form as unchanged again', () => {
+ expect(form.hasChanges()).toEqual(false);
+ });
+
+ describe('reinstate', () => {
+ beforeEach(() => {
+ form.reinstate();
+ });
+
+ it('should re-add the new value', () => {
+ expect(form.fields[mdField][expectedPlace].newValue.value).toEqual(value);
+ });
+
+ it('should mark the form as changed once again', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+ });
+ });
+ });
+ });
+
+ describe('removing a value entirely (not just marking deleted)', () => {
+ it('should remove the value on the correct index', () => {
+ form.remove('dc.subject', 1);
+ expect(form.fields['dc.subject'].length).toEqual(2);
+ expect(form.fields['dc.subject'][0].newValue.value).toEqual('Subject One');
+ expect(form.fields['dc.subject'][1].newValue.value).toEqual('Subject Three');
+ });
+ });
+
+ describe('moving a value', () => {
+ beforeEach(() => {
+ form.fields['dc.subject'][0].newValue.place = form.fields['dc.subject'][1].originalValue.place;
+ form.fields['dc.subject'][1].newValue.place = form.fields['dc.subject'][0].originalValue.place;
+ form.fields['dc.subject'][0].confirmChanges();
+ form.fields['dc.subject'][1].confirmChanges();
+ });
+
+ it('should mark the value as changed', () => {
+ expect(form.fields['dc.subject'][0].hasChanges()).toEqual(true);
+ expect(form.fields['dc.subject'][1].hasChanges()).toEqual(true);
+ });
+
+ it('should mark the form as changed', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+
+ describe('discard', () => {
+ beforeEach(() => {
+ form.discard();
+ });
+
+ it('should reset the moved values their places to their original values', () => {
+ expect(form.fields['dc.subject'][0].newValue.place).toEqual(form.fields['dc.subject'][0].originalValue.place);
+ expect(form.fields['dc.subject'][1].newValue.place).toEqual(form.fields['dc.subject'][1].originalValue.place);
+ });
+
+ it('should mark the form as unchanged again', () => {
+ expect(form.hasChanges()).toEqual(false);
+ });
+
+ describe('reinstate', () => {
+ beforeEach(() => {
+ form.reinstate();
+ });
+
+ it('should move the values to their new places again', () => {
+ expect(form.fields['dc.subject'][0].newValue.place).toEqual(form.fields['dc.subject'][1].originalValue.place);
+ expect(form.fields['dc.subject'][1].newValue.place).toEqual(form.fields['dc.subject'][0].originalValue.place);
+ });
+
+ it('should mark the form as changed once again', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+ });
+ });
+ });
+
+ describe('marking a value deleted', () => {
+ beforeEach(() => {
+ form.fields['dc.title'][0].change = DsoEditMetadataChangeType.REMOVE;
+ });
+
+ it('should mark the value as changed', () => {
+ expect(form.fields['dc.title'][0].hasChanges()).toEqual(true);
+ });
+
+ it('should mark the form as changed', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+
+ describe('discard', () => {
+ beforeEach(() => {
+ form.discard();
+ });
+
+ it('should remove the deleted mark from the value', () => {
+ expect(form.fields['dc.title'][0].change).toBeUndefined();
+ });
+
+ it('should mark the form as unchanged again', () => {
+ expect(form.hasChanges()).toEqual(false);
+ });
+
+ describe('reinstate', () => {
+ beforeEach(() => {
+ form.reinstate();
+ });
+
+ it('should re-mark the value as deleted', () => {
+ expect(form.fields['dc.title'][0].change).toEqual(DsoEditMetadataChangeType.REMOVE);
+ });
+
+ it('should mark the form as changed once again', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+ });
+ });
+ });
+
+ describe('editing a value', () => {
+ const value = 'New title';
+
+ beforeEach(() => {
+ form.fields['dc.title'][0].editing = true;
+ form.fields['dc.title'][0].newValue.value = value;
+ });
+
+ it('should not mark the form as changed yet', () => {
+ expect(form.hasChanges()).toEqual(false);
+ });
+
+ describe('and confirming the changes', () => {
+ beforeEach(() => {
+ form.fields['dc.title'][0].confirmChanges(true);
+ });
+
+ it('should mark the value as changed', () => {
+ expect(form.fields['dc.title'][0].hasChanges()).toEqual(true);
+ });
+
+ it('should mark the form as changed', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+
+ describe('discard', () => {
+ beforeEach(() => {
+ form.discard();
+ });
+
+ it('should reset the changed value to its original value', () => {
+ expect(form.fields['dc.title'][0].newValue.value).toEqual(form.fields['dc.title'][0].originalValue.value);
+ });
+
+ it('should mark the form as unchanged again', () => {
+ expect(form.hasChanges()).toEqual(false);
+ });
+
+ describe('reinstate', () => {
+ beforeEach(() => {
+ form.reinstate();
+ });
+
+ it('should put the changed value back in place', () => {
+ expect(form.fields['dc.title'][0].newValue.value).toEqual(value);
+ });
+
+ it('should mark the form as changed once again', () => {
+ expect(form.hasChanges()).toEqual(true);
+ });
+ });
+ });
+ });
+ });
+});
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-form.ts b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-form.ts
new file mode 100644
index 0000000000..8206ec9135
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-form.ts
@@ -0,0 +1,453 @@
+/* eslint-disable max-classes-per-file */
+import { MetadataMap, MetadataValue } from '../../core/shared/metadata.models';
+import { hasNoValue, hasValue, isEmpty, isNotEmpty } from '../../shared/empty.util';
+import { MoveOperation, Operation } from 'fast-json-patch';
+import { MetadataPatchReplaceOperation } from '../../core/data/object-updates/patch-operation-service/operations/metadata/metadata-patch-replace-operation.model';
+import { MetadataPatchRemoveOperation } from '../../core/data/object-updates/patch-operation-service/operations/metadata/metadata-patch-remove-operation.model';
+import { MetadataPatchAddOperation } from '../../core/data/object-updates/patch-operation-service/operations/metadata/metadata-patch-add-operation.model';
+import { ArrayMoveChangeAnalyzer } from '../../core/data/array-move-change-analyzer.service';
+import { MetadataPatchMoveOperation } from '../../core/data/object-updates/patch-operation-service/operations/metadata/metadata-patch-move-operation.model';
+
+/**
+ * Enumeration for the type of change occurring on a metadata value
+ */
+export enum DsoEditMetadataChangeType {
+ UPDATE = 1,
+ ADD = 2,
+ REMOVE = 3
+}
+
+/**
+ * Class holding information about a metadata value and its changes within an edit form
+ */
+export class DsoEditMetadataValue {
+ /**
+ * The original metadata value (should stay the same!) used to compare changes with
+ */
+ originalValue: MetadataValue;
+
+ /**
+ * The new value, dynamically changing
+ */
+ newValue: MetadataValue;
+
+ /**
+ * A value that can be used to undo any discarding that took place
+ */
+ reinstatableValue: MetadataValue;
+
+ /**
+ * Whether or not this value is currently being edited or not
+ */
+ editing = false;
+
+ /**
+ * The type of change that's taking place on this metadata value
+ * Empty if no changes are made
+ */
+ change: DsoEditMetadataChangeType;
+
+ /**
+ * A flag to keep track if the value has been reordered (place has changed)
+ */
+ reordered = false;
+
+ /**
+ * A type or change that can be used to undo any discarding that took place
+ */
+ reinstatableChange: DsoEditMetadataChangeType;
+
+ constructor(value: MetadataValue, added = false) {
+ this.originalValue = value;
+ this.newValue = Object.assign(new MetadataValue(), value);
+ if (added) {
+ this.change = DsoEditMetadataChangeType.ADD;
+ this.editing = true;
+ }
+ }
+
+ /**
+ * Save the current changes made to the metadata value
+ * This will set the type of change to UPDATE if the new metadata value's value and/or language are different from
+ * the original value
+ * It will also set the editing flag to false
+ */
+ confirmChanges(finishEditing = false) {
+ this.reordered = this.originalValue.place !== this.newValue.place;
+ if (hasNoValue(this.change) || this.change === DsoEditMetadataChangeType.UPDATE) {
+ if ((this.originalValue.value !== this.newValue.value || this.originalValue.language !== this.newValue.language)) {
+ this.change = DsoEditMetadataChangeType.UPDATE;
+ } else {
+ this.change = undefined;
+ }
+ }
+ if (finishEditing) {
+ this.editing = false;
+ }
+ }
+
+ /**
+ * Returns if the current value contains changes or not
+ * If the metadata value contains changes, but they haven't been confirmed yet through confirmChanges(), this might
+ * return false (which is desired)
+ */
+ hasChanges(): boolean {
+ return hasValue(this.change) || this.reordered;
+ }
+
+ /**
+ * Discard the current changes and mark the value and change type re-instatable by storing them in their relevant
+ * properties
+ */
+ discardAndMarkReinstatable(): void {
+ if (this.change === DsoEditMetadataChangeType.UPDATE || this.reordered) {
+ this.reinstatableValue = this.newValue;
+ }
+ this.reinstatableChange = this.change;
+ this.discard(false);
+ }
+
+ /**
+ * Discard the current changes
+ * Call discardAndMarkReinstatable() instead, if the discard should be re-instatable
+ */
+ discard(keepPlace = true): void {
+ this.change = undefined;
+ const place = this.newValue.place;
+ this.newValue = Object.assign(new MetadataValue(), this.originalValue);
+ if (keepPlace) {
+ this.newValue.place = place;
+ }
+ this.confirmChanges(true);
+ }
+
+ /**
+ * Re-instate (undo) the last discard by replacing the value and change type with their reinstate properties (if present)
+ */
+ reinstate(): void {
+ if (hasValue(this.reinstatableValue)) {
+ this.newValue = this.reinstatableValue;
+ this.reinstatableValue = undefined;
+ }
+ if (hasValue(this.reinstatableChange)) {
+ this.change = this.reinstatableChange;
+ this.reinstatableChange = undefined;
+ }
+ this.confirmChanges();
+ }
+
+ /**
+ * Returns if either the value or change type have a re-instatable property
+ * This will be the case if a discard has taken place that undid changes to the value or type
+ */
+ isReinstatable(): boolean {
+ return hasValue(this.reinstatableValue) || hasValue(this.reinstatableChange);
+ }
+
+ /**
+ * Reset the state of the re-instatable properties
+ */
+ resetReinstatable() {
+ this.reinstatableValue = undefined;
+ this.reinstatableChange = undefined;
+ }
+}
+
+/**
+ * Class holding information about the metadata of a DSpaceObject and its changes within an edit form
+ */
+export class DsoEditMetadataForm {
+ /**
+ * List of original metadata field keys (before any changes took place)
+ */
+ originalFieldKeys: string[];
+
+ /**
+ * List of current metadata field keys (includes new fields for values added by the user)
+ */
+ fieldKeys: string[];
+
+ /**
+ * Current state of the form
+ * Key: Metadata field
+ * Value: List of {@link DsoEditMetadataValue}s for the metadata field
+ */
+ fields: {
+ [mdField: string]: DsoEditMetadataValue[],
+ };
+
+ /**
+ * A map of previously added metadata values before a discard of the form took place
+ * This can be used to re-instate the entire form to before the discard taking place
+ */
+ reinstatableNewValues: {
+ [mdField: string]: DsoEditMetadataValue[],
+ };
+
+ /**
+ * A (temporary) new metadata value added by the user, not belonging to a metadata field yet
+ * This value will be finalised and added to a field using setMetadataField()
+ */
+ newValue: DsoEditMetadataValue;
+
+ constructor(metadata: MetadataMap) {
+ this.originalFieldKeys = [];
+ this.fieldKeys = [];
+ this.fields = {};
+ this.reinstatableNewValues = {};
+ Object.entries(metadata).forEach(([mdField, values]: [string, MetadataValue[]]) => {
+ this.originalFieldKeys.push(mdField);
+ this.fieldKeys.push(mdField);
+ this.setValuesForFieldSorted(mdField, values.map((value: MetadataValue) => new DsoEditMetadataValue(value)));
+ });
+ this.sortFieldKeys();
+ }
+
+ /**
+ * Add a new temporary value for the user to edit
+ */
+ add(): void {
+ if (hasNoValue(this.newValue)) {
+ this.newValue = new DsoEditMetadataValue(new MetadataValue(), true);
+ }
+ }
+
+ /**
+ * Add the temporary value to a metadata field
+ * Clear the temporary value afterwards
+ * @param mdField
+ */
+ setMetadataField(mdField: string): void {
+ this.newValue.editing = false;
+ this.addValueToField(this.newValue, mdField);
+ // Set the place property to match the new value's position within its field
+ const place = this.fields[mdField].length - 1;
+ this.fields[mdField][place].originalValue.place = place;
+ this.fields[mdField][place].newValue.place = place;
+ this.newValue = undefined;
+ }
+
+ /**
+ * Add a value to a metadata field within the map
+ * @param value
+ * @param mdField
+ * @private
+ */
+ private addValueToField(value: DsoEditMetadataValue, mdField: string): void {
+ if (isEmpty(this.fields[mdField])) {
+ this.fieldKeys.push(mdField);
+ this.sortFieldKeys();
+ this.fields[mdField] = [];
+ }
+ this.fields[mdField].push(value);
+ }
+
+ /**
+ * Remove a value from a metadata field on a given index (this actually removes the value, not just marking it deleted)
+ * @param mdField
+ * @param index
+ */
+ remove(mdField: string, index: number): void {
+ if (isNotEmpty(this.fields[mdField])) {
+ this.fields[mdField].splice(index, 1);
+ if (this.fields[mdField].length === 0) {
+ this.fieldKeys.splice(this.fieldKeys.indexOf(mdField), 1);
+ delete this.fields[mdField];
+ }
+ }
+ }
+
+ /**
+ * Returns if at least one value within the form contains a change
+ */
+ hasChanges(): boolean {
+ return Object.values(this.fields).some((values: DsoEditMetadataValue[]) => values.some((value: DsoEditMetadataValue) => value.hasChanges()));
+ }
+
+ /**
+ * Check if a metadata field contains changes within its order (place property of values)
+ * @param mdField
+ */
+ hasOrderChanges(mdField: string): boolean {
+ return this.fields[mdField].some((value: DsoEditMetadataValue) => value.originalValue.place !== value.newValue.place);
+ }
+
+ /**
+ * Discard all changes within the form and store their current values within re-instatable properties so they can be
+ * undone afterwards
+ */
+ discard(): void {
+ this.resetReinstatable();
+ // Discard changes from each value from each field
+ Object.entries(this.fields).forEach(([field, values]: [string, DsoEditMetadataValue[]]) => {
+ let removeFromIndex = -1;
+ values.forEach((value: DsoEditMetadataValue, index: number) => {
+ if (value.change === DsoEditMetadataChangeType.ADD) {
+ if (isEmpty(this.reinstatableNewValues[field])) {
+ this.reinstatableNewValues[field] = [];
+ }
+ this.reinstatableNewValues[field].push(value);
+ if (removeFromIndex === -1) {
+ removeFromIndex = index;
+ }
+ } else {
+ value.discardAndMarkReinstatable();
+ }
+ });
+ if (removeFromIndex > -1) {
+ this.fields[field].splice(removeFromIndex, this.fields[field].length - removeFromIndex);
+ }
+ });
+ // Delete new metadata fields
+ this.fieldKeys.forEach((field: string) => {
+ if (this.originalFieldKeys.indexOf(field) < 0) {
+ delete this.fields[field];
+ }
+ });
+ this.fieldKeys = [...this.originalFieldKeys];
+ this.sortFieldKeys();
+ // Reset the order of values within their fields to match their place property
+ this.fieldKeys.forEach((field: string) => {
+ this.setValuesForFieldSorted(field, this.fields[field]);
+ });
+ }
+
+ /**
+ * Reset the order of values within a metadata field to their original places
+ * Update the actual array to match the place properties
+ * @param mdField
+ */
+ resetOrder(mdField: string) {
+ this.fields[mdField].forEach((value: DsoEditMetadataValue) => {
+ value.newValue.place = value.originalValue.place;
+ value.confirmChanges();
+ });
+ this.setValuesForFieldSorted(mdField, this.fields[mdField]);
+ }
+
+ /**
+ * Sort fieldKeys alphabetically
+ * Should be called whenever a field is added to ensure the alphabetical order is kept
+ */
+ sortFieldKeys() {
+ this.fieldKeys.sort((a: string, b: string) => a.localeCompare(b));
+ }
+
+ /**
+ * Undo any previously discarded changes
+ */
+ reinstate(): void {
+ // Reinstate each value
+ Object.values(this.fields).forEach((values: DsoEditMetadataValue[]) => {
+ values.forEach((value: DsoEditMetadataValue) => {
+ value.reinstate();
+ });
+ });
+ // Re-add new values
+ Object.entries(this.reinstatableNewValues).forEach(([field, values]: [string, DsoEditMetadataValue[]]) => {
+ values.forEach((value: DsoEditMetadataValue) => {
+ this.addValueToField(value, field);
+ });
+ });
+ // Reset the order of values within their fields to match their place property
+ this.fieldKeys.forEach((field: string) => {
+ this.setValuesForFieldSorted(field, this.fields[field]);
+ });
+ this.reinstatableNewValues = {};
+ }
+
+ /**
+ * Returns if at least one value contains a re-instatable property, meaning a discard can be reversed
+ */
+ isReinstatable(): boolean {
+ return isNotEmpty(this.reinstatableNewValues) ||
+ Object.values(this.fields)
+ .some((values: DsoEditMetadataValue[]) => values
+ .some((value: DsoEditMetadataValue) => value.isReinstatable()));
+ }
+
+ /**
+ * Reset the state of the re-instatable properties and values
+ */
+ resetReinstatable(): void {
+ this.reinstatableNewValues = {};
+ Object.values(this.fields).forEach((values: DsoEditMetadataValue[]) => {
+ values.forEach((value: DsoEditMetadataValue) => {
+ value.resetReinstatable();
+ });
+ });
+ }
+
+ /**
+ * Set the values of a metadata field and sort them by their newValue's place property
+ * @param mdField
+ * @param values
+ */
+ private setValuesForFieldSorted(mdField: string, values: DsoEditMetadataValue[]) {
+ this.fields[mdField] = values.sort((a: DsoEditMetadataValue, b: DsoEditMetadataValue) => a.newValue.place - b.newValue.place);
+ }
+
+ /**
+ * Get the json PATCH operations for the current changes within this form
+ * For each metadata field, it'll return operations in the following order: replace, remove (from last to first place), add and move
+ * This order is important, as each operation is executed in succession of the previous one
+ */
+ getOperations(moveAnalyser: ArrayMoveChangeAnalyzer): Operation[] {
+ const operations: Operation[] = [];
+ Object.entries(this.fields).forEach(([field, values]: [string, DsoEditMetadataValue[]]) => {
+ const replaceOperations: MetadataPatchReplaceOperation[] = [];
+ const removeOperations: MetadataPatchRemoveOperation[] = [];
+ const addOperations: MetadataPatchAddOperation[] = [];
+ [...values]
+ .sort((a: DsoEditMetadataValue, b: DsoEditMetadataValue) => a.originalValue.place - b.originalValue.place)
+ .forEach((value: DsoEditMetadataValue) => {
+ if (hasValue(value.change)) {
+ if (value.change === DsoEditMetadataChangeType.UPDATE) {
+ // Only changes to value or language are considered "replace" operations. Changes to place are considered "move", which is processed below.
+ if (value.originalValue.value !== value.newValue.value || value.originalValue.language !== value.newValue.language) {
+ replaceOperations.push(new MetadataPatchReplaceOperation(field, value.originalValue.place, {
+ value: value.newValue.value,
+ language: value.newValue.language,
+ }));
+ }
+ } else if (value.change === DsoEditMetadataChangeType.REMOVE) {
+ removeOperations.push(new MetadataPatchRemoveOperation(field, value.originalValue.place));
+ } else if (value.change === DsoEditMetadataChangeType.ADD) {
+ addOperations.push(new MetadataPatchAddOperation(field, {
+ value: value.newValue.value,
+ language: value.newValue.language,
+ }));
+ } else {
+ console.warn('Illegal metadata change state detected for', value);
+ }
+ }
+ });
+
+ operations.push(...replaceOperations
+ .map((operation: MetadataPatchReplaceOperation) => operation.toOperation()));
+ operations.push(...removeOperations
+ // Sort remove operations backwards first, because they get executed in order. This avoids one removal affecting the next.
+ .sort((a: MetadataPatchRemoveOperation, b: MetadataPatchRemoveOperation) => b.place - a.place)
+ .map((operation: MetadataPatchRemoveOperation) => operation.toOperation()));
+ operations.push(...addOperations
+ .map((operation: MetadataPatchAddOperation) => operation.toOperation()));
+ });
+ // Calculate and add the move operations that need to happen in order to move value from their old place to their new within the field
+ // This uses an ArrayMoveChangeAnalyzer
+ Object.entries(this.fields).forEach(([field, values]: [string, DsoEditMetadataValue[]]) => {
+ // Exclude values marked for removal, because operations are executed in order (remove first, then move)
+ const valuesWithoutRemoved = values.filter((value: DsoEditMetadataValue) => value.change !== DsoEditMetadataChangeType.REMOVE);
+ const moveOperations = moveAnalyser
+ .diff(
+ [...valuesWithoutRemoved]
+ .sort((a: DsoEditMetadataValue, b: DsoEditMetadataValue) => a.originalValue.place - b.originalValue.place)
+ .map((value: DsoEditMetadataValue) => value.originalValue.place),
+ [...valuesWithoutRemoved]
+ .sort((a: DsoEditMetadataValue, b: DsoEditMetadataValue) => a.newValue.place - b.newValue.place)
+ .map((value: DsoEditMetadataValue) => value.originalValue.place))
+ .map((operation: MoveOperation) => new MetadataPatchMoveOperation(field, +operation.from.substr(1), +operation.path.substr(1)).toOperation());
+ operations.push(...moveOperations);
+ });
+ return operations;
+ }
+}
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.html b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.html
new file mode 100644
index 0000000000..ecaf2aa744
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.html
@@ -0,0 +1,10 @@
+
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.scss b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.scss
new file mode 100644
index 0000000000..d46751d4b0
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.scss
@@ -0,0 +1,12 @@
+.lbl-cell {
+ min-width: var(--ds-dso-edit-field-width);
+ max-width: var(--ds-dso-edit-field-width);
+ background-color: var(--bs-gray-100);
+ font-weight: bold;
+ padding: 1rem;
+ border: 1px solid var(--bs-gray-200);
+}
+
+.ds-header-row {
+ background-color: var(--bs-gray-100);
+}
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.spec.ts b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.spec.ts
new file mode 100644
index 0000000000..a0a1da1f1e
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.spec.ts
@@ -0,0 +1,32 @@
+import { DsoEditMetadataHeadersComponent } from './dso-edit-metadata-headers.component';
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { VarDirective } from '../../../shared/utils/var.directive';
+import { TranslateModule } from '@ngx-translate/core';
+import { RouterTestingModule } from '@angular/router/testing';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { By } from '@angular/platform-browser';
+
+describe('DsoEditMetadataHeadersComponent', () => {
+ let component: DsoEditMetadataHeadersComponent;
+ let fixture: ComponentFixture;
+
+ beforeEach(waitForAsync(() => {
+ TestBed.configureTestingModule({
+ declarations: [DsoEditMetadataHeadersComponent, VarDirective],
+ imports: [TranslateModule.forRoot(), RouterTestingModule.withRoutes([])],
+ providers: [
+ ],
+ schemas: [NO_ERRORS_SCHEMA]
+ }).compileComponents();
+ }));
+
+ beforeEach(() => {
+ fixture = TestBed.createComponent(DsoEditMetadataHeadersComponent);
+ component = fixture.componentInstance;
+ fixture.detectChanges();
+ });
+
+ it('should display three headers', () => {
+ expect(fixture.debugElement.queryAll(By.css('.ds-flex-cell')).length).toEqual(3);
+ });
+});
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.ts b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.ts
new file mode 100644
index 0000000000..9c21c8ac9e
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-headers/dso-edit-metadata-headers.component.ts
@@ -0,0 +1,17 @@
+import { Component, Input } from '@angular/core';
+
+@Component({
+ selector: 'ds-dso-edit-metadata-headers',
+ styleUrls: ['./dso-edit-metadata-headers.component.scss', '../dso-edit-metadata-shared/dso-edit-metadata-cells.scss'],
+ templateUrl: './dso-edit-metadata-headers.component.html',
+})
+/**
+ * Component displaying the header table row for DSO edit metadata page
+ */
+export class DsoEditMetadataHeadersComponent {
+ /**
+ * Type of DSO we're displaying values for
+ * Determines i18n messages
+ */
+ @Input() dsoType: string;
+}
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-shared/dso-edit-metadata-cells.scss b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-shared/dso-edit-metadata-cells.scss
new file mode 100644
index 0000000000..20d479ac88
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-shared/dso-edit-metadata-cells.scss
@@ -0,0 +1,49 @@
+.ds-field-row {
+ border: 1px solid var(--bs-gray-400);
+}
+
+.ds-flex-cell {
+ padding: 1rem;
+ border: 1px solid var(--bs-gray-200);
+}
+
+.ds-lang-cell {
+ min-width: var(--ds-dso-edit-lang-width);
+ max-width: var(--ds-dso-edit-lang-width);
+}
+
+.ds-edit-cell {
+ min-width: var(--ds-dso-edit-actions-width);
+}
+
+.ds-value-row {
+ background-color: white;
+
+ &:active {
+ cursor: grabbing;
+ }
+
+ &.ds-warning {
+ background-color: var(--bs-warning-bg);
+
+ .ds-flex-cell {
+ border: 1px solid var(--bs-warning);
+ }
+ }
+
+ &.ds-danger {
+ background-color: var(--bs-danger-bg);
+
+ .ds-flex-cell {
+ border: 1px solid var(--bs-danger);
+ }
+ }
+
+ &.ds-success {
+ background-color: var(--bs-success-bg);
+
+ .ds-flex-cell {
+ border: 1px solid var(--bs-success);
+ }
+ }
+}
diff --git a/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-value-headers/dso-edit-metadata-value-headers.component.html b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-value-headers/dso-edit-metadata-value-headers.component.html
new file mode 100644
index 0000000000..2c3fb54600
--- /dev/null
+++ b/src/app/dso-shared/dso-edit-metadata/dso-edit-metadata-value-headers/dso-edit-metadata-value-headers.component.html
@@ -0,0 +1,5 @@
+
+
{{ dsoType + '.edit.metadata.headers.value' | translate }}
+
{{ dsoType + '.edit.metadata.headers.language' | translate }}
+
{{ dsoType + '.edit.metadata.headers.edit' | translate }}
+
+
+
{{ mdValue.newValue.value }}
+
+
+
+
+
{{ mdValue.newValue.language }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{{ dsoType + '.edit.metadata.metadatafield.invalid' | translate }}
+
+
diff --git a/src/app/entity-groups/journal-entities/item-pages/journal-issue/journal-issue.component.scss b/src/app/entity-groups/journal-entities/item-pages/journal-issue/journal-issue.component.scss
index 3575cae797..b810d2ddd4 100644
--- a/src/app/entity-groups/journal-entities/item-pages/journal-issue/journal-issue.component.scss
+++ b/src/app/entity-groups/journal-entities/item-pages/journal-issue/journal-issue.component.scss
@@ -1 +1,2 @@
@import '../../../../../styles/variables.scss';
+
diff --git a/src/app/entity-groups/journal-entities/item-pages/journal-volume/journal-volume.component.html b/src/app/entity-groups/journal-entities/item-pages/journal-volume/journal-volume.component.html
index b370431a27..010b5ee5b5 100644
--- a/src/app/entity-groups/journal-entities/item-pages/journal-volume/journal-volume.component.html
+++ b/src/app/entity-groups/journal-entities/item-pages/journal-volume/journal-volume.component.html
@@ -1,3 +1,4 @@
+
diff --git a/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.html b/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.html
index 27ee373237..88ed9e17dd 100644
--- a/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.html
+++ b/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.html
@@ -1,3 +1,4 @@
+
diff --git a/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.spec.ts b/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.spec.ts
index 4469a2ac29..7e20edca6b 100644
--- a/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.spec.ts
+++ b/src/app/entity-groups/journal-entities/item-pages/journal/journal.component.spec.ts
@@ -34,6 +34,7 @@ import { VersionHistoryDataService } from '../../../../core/data/version-history
import { VersionDataService } from '../../../../core/data/version-data.service';
import { WorkspaceitemDataService } from '../../../../core/submission/workspaceitem-data.service';
import { SearchService } from '../../../../core/shared/search/search.service';
+import { mockRouteService } from '../../../../item-page/simple/item-types/shared/item.component.spec';
let comp: JournalComponent;
let fixture: ComponentFixture
;
@@ -99,7 +100,7 @@ describe('JournalComponent', () => {
{ provide: BitstreamDataService, useValue: mockBitstreamDataService },
{ provide: WorkspaceitemDataService, useValue: {} },
{ provide: SearchService, useValue: {} },
- { provide: RouteService, useValue: {} }
+ { provide: RouteService, useValue: mockRouteService }
],
schemas: [NO_ERRORS_SCHEMA]
diff --git a/src/app/entity-groups/journal-entities/journal-entities.module.ts b/src/app/entity-groups/journal-entities/journal-entities.module.ts
index 3bf861e10d..07585d4d16 100644
--- a/src/app/entity-groups/journal-entities/journal-entities.module.ts
+++ b/src/app/entity-groups/journal-entities/journal-entities.module.ts
@@ -20,6 +20,7 @@ import { JournalVolumeSidebarSearchListElementComponent } from './item-list-elem
import { JournalIssueSidebarSearchListElementComponent } from './item-list-elements/sidebar-search-list-elements/journal-issue/journal-issue-sidebar-search-list-element.component';
import { JournalSidebarSearchListElementComponent } from './item-list-elements/sidebar-search-list-elements/journal/journal-sidebar-search-list-element.component';
import { ItemSharedModule } from '../../item-page/item-shared.module';
+import { ResultsBackButtonModule } from '../../shared/results-back-button/results-back-button.module';
const ENTRY_COMPONENTS = [
// put only entry components that use custom decorator
@@ -47,7 +48,8 @@ const ENTRY_COMPONENTS = [
imports: [
CommonModule,
ItemSharedModule,
- SharedModule
+ SharedModule,
+ ResultsBackButtonModule
],
declarations: [
...ENTRY_COMPONENTS
diff --git a/src/app/entity-groups/research-entities/item-pages/org-unit/org-unit.component.html b/src/app/entity-groups/research-entities/item-pages/org-unit/org-unit.component.html
index ac92e4ad6d..d8b3815f6e 100644
--- a/src/app/entity-groups/research-entities/item-pages/org-unit/org-unit.component.html
+++ b/src/app/entity-groups/research-entities/item-pages/org-unit/org-unit.component.html
@@ -1,3 +1,4 @@
+
diff --git a/src/app/entity-groups/research-entities/item-pages/person/person.component.html b/src/app/entity-groups/research-entities/item-pages/person/person.component.html
index a73236006b..20e458a906 100644
--- a/src/app/entity-groups/research-entities/item-pages/person/person.component.html
+++ b/src/app/entity-groups/research-entities/item-pages/person/person.component.html
@@ -1,3 +1,4 @@
+
diff --git a/src/app/entity-groups/research-entities/item-pages/project/project.component.html b/src/app/entity-groups/research-entities/item-pages/project/project.component.html
index 3fb5e2d520..ee75abaae8 100644
--- a/src/app/entity-groups/research-entities/item-pages/project/project.component.html
+++ b/src/app/entity-groups/research-entities/item-pages/project/project.component.html
@@ -1,3 +1,4 @@
+
diff --git a/src/app/entity-groups/research-entities/research-entities.module.ts b/src/app/entity-groups/research-entities/research-entities.module.ts
index 721a22be08..e3525cc881 100644
--- a/src/app/entity-groups/research-entities/research-entities.module.ts
+++ b/src/app/entity-groups/research-entities/research-entities.module.ts
@@ -29,6 +29,7 @@ import { OrgUnitSidebarSearchListElementComponent } from './item-list-elements/s
import { PersonSidebarSearchListElementComponent } from './item-list-elements/sidebar-search-list-elements/person/person-sidebar-search-list-element.component';
import { ProjectSidebarSearchListElementComponent } from './item-list-elements/sidebar-search-list-elements/project/project-sidebar-search-list-element.component';
import { ItemSharedModule } from '../../item-page/item-shared.module';
+import { ResultsBackButtonModule } from '../../shared/results-back-button/results-back-button.module';
const ENTRY_COMPONENTS = [
// put only entry components that use custom decorator
@@ -69,7 +70,8 @@ const COMPONENTS = [
CommonModule,
ItemSharedModule,
SharedModule,
- NgbTooltipModule
+ NgbTooltipModule,
+ ResultsBackButtonModule
],
declarations: [
...COMPONENTS,
diff --git a/src/app/entity-groups/research-entities/submission/item-list-elements/org-unit/org-unit-search-result-list-submission-element.component.ts b/src/app/entity-groups/research-entities/submission/item-list-elements/org-unit/org-unit-search-result-list-submission-element.component.ts
index 7a38a02cf4..954f7bc591 100644
--- a/src/app/entity-groups/research-entities/submission/item-list-elements/org-unit/org-unit-search-result-list-submission-element.component.ts
+++ b/src/app/entity-groups/research-entities/submission/item-list-elements/org-unit/org-unit-search-result-list-submission-element.component.ts
@@ -61,7 +61,7 @@ export class OrgUnitSearchResultListSubmissionElementComponent extends SearchRes
this.useNameVariants = this.context === Context.EntitySearchModalWithNameVariants;
if (this.useNameVariants) {
- const defaultValue = this.dsoTitle;
+ const defaultValue = this.dso ? this.dsoNameService.getName(this.dso) : undefined;
const alternatives = this.allMetadataValues(this.alternativeField);
this.allSuggestions = [defaultValue, ...alternatives];
diff --git a/src/app/entity-groups/research-entities/submission/item-list-elements/person/person-search-result-list-submission-element.component.ts b/src/app/entity-groups/research-entities/submission/item-list-elements/person/person-search-result-list-submission-element.component.ts
index 7d761c42dd..305407f8d2 100644
--- a/src/app/entity-groups/research-entities/submission/item-list-elements/person/person-search-result-list-submission-element.component.ts
+++ b/src/app/entity-groups/research-entities/submission/item-list-elements/person/person-search-result-list-submission-element.component.ts
@@ -55,7 +55,7 @@ export class PersonSearchResultListSubmissionElementComponent extends SearchResu
ngOnInit() {
super.ngOnInit();
- const defaultValue = this.dsoTitle;
+ const defaultValue = this.dso ? this.dsoNameService.getName(this.dso) : undefined;
const alternatives = this.allMetadataValues(this.alternativeField);
this.allSuggestions = [defaultValue, ...alternatives];
diff --git a/src/app/footer/footer.component.html b/src/app/footer/footer.component.html
index 88236d381e..97265d7a23 100644
--- a/src/app/footer/footer.component.html
+++ b/src/app/footer/footer.component.html
@@ -64,7 +64,7 @@