{{ 'collection.edit.template.head' | translate:{ collection: collection?.name } }}
-
+
diff --git a/src/app/core/auth/auth-request.service.spec.ts b/src/app/core/auth/auth-request.service.spec.ts
index 704922c5b5..063aad612f 100644
--- a/src/app/core/auth/auth-request.service.spec.ts
+++ b/src/app/core/auth/auth-request.service.spec.ts
@@ -11,6 +11,7 @@ import { HttpOptions } from '../dspace-rest/dspace-rest.service';
import objectContaining = jasmine.objectContaining;
import { AuthStatus } from './models/auth-status.model';
import { RestRequestMethod } from '../data/rest-request-method';
+import { Observable, of as observableOf } from 'rxjs';
describe(`AuthRequestService`, () => {
let halService: HALEndpointService;
@@ -34,8 +35,8 @@ describe(`AuthRequestService`, () => {
super(hes, rs, rdbs);
}
- protected createShortLivedTokenRequest(href: string): PostRequest {
- return new PostRequest(this.requestService.generateRequestId(), href);
+ protected createShortLivedTokenRequest(href: string): Observable
{
+ return observableOf(new PostRequest(this.requestService.generateRequestId(), href));
}
}
diff --git a/src/app/core/auth/auth-request.service.ts b/src/app/core/auth/auth-request.service.ts
index 5c0c3340c7..7c1f17dec2 100644
--- a/src/app/core/auth/auth-request.service.ts
+++ b/src/app/core/auth/auth-request.service.ts
@@ -100,14 +100,12 @@ export abstract class AuthRequestService {
);
}
/**
- * Factory function to create the request object to send. This needs to be a POST client side and
- * a GET server side. Due to CSRF validation, the server isn't allowed to send a POST, so we allow
- * only the server IP to send a GET to this endpoint.
+ * Factory function to create the request object to send.
*
* @param href The href to send the request to
* @protected
*/
- protected abstract createShortLivedTokenRequest(href: string): GetRequest | PostRequest;
+ protected abstract createShortLivedTokenRequest(href: string): Observable;
/**
* Send a request to retrieve a short-lived token which provides download access of restricted files
@@ -117,7 +115,7 @@ export abstract class AuthRequestService {
filter((href: string) => isNotEmpty(href)),
distinctUntilChanged(),
map((href: string) => new URLCombiner(href, this.shortlivedtokensEndpoint).toString()),
- map((endpointURL: string) => this.createShortLivedTokenRequest(endpointURL)),
+ switchMap((endpointURL: string) => this.createShortLivedTokenRequest(endpointURL)),
tap((request: RestRequest) => this.requestService.send(request)),
switchMap((request: RestRequest) => this.rdbService.buildFromRequestUUID(request.uuid)),
getFirstCompletedRemoteData(),
diff --git a/src/app/core/auth/browser-auth-request.service.spec.ts b/src/app/core/auth/browser-auth-request.service.spec.ts
index 18d27340af..b41d981bcf 100644
--- a/src/app/core/auth/browser-auth-request.service.spec.ts
+++ b/src/app/core/auth/browser-auth-request.service.spec.ts
@@ -1,6 +1,8 @@
import { AuthRequestService } from './auth-request.service';
import { RequestService } from '../data/request.service';
import { BrowserAuthRequestService } from './browser-auth-request.service';
+import { Observable } from 'rxjs';
+import { PostRequest } from '../data/request.models';
describe(`BrowserAuthRequestService`, () => {
let href: string;
@@ -16,14 +18,20 @@ describe(`BrowserAuthRequestService`, () => {
});
describe(`createShortLivedTokenRequest`, () => {
- it(`should return a PostRequest`, () => {
- const result = (service as any).createShortLivedTokenRequest(href);
- expect(result.constructor.name).toBe('PostRequest');
+ it(`should return a PostRequest`, (done) => {
+ const obs = (service as any).createShortLivedTokenRequest(href) as Observable;
+ obs.subscribe((result: PostRequest) => {
+ expect(result.constructor.name).toBe('PostRequest');
+ done();
+ });
});
- it(`should return a request with the given href`, () => {
- const result = (service as any).createShortLivedTokenRequest(href);
- expect(result.href).toBe(href) ;
+ it(`should return a request with the given href`, (done) => {
+ const obs = (service as any).createShortLivedTokenRequest(href) as Observable;
+ obs.subscribe((result: PostRequest) => {
+ expect(result.href).toBe(href);
+ done();
+ });
});
});
});
diff --git a/src/app/core/auth/browser-auth-request.service.ts b/src/app/core/auth/browser-auth-request.service.ts
index 85d5f54340..485e2ef9c4 100644
--- a/src/app/core/auth/browser-auth-request.service.ts
+++ b/src/app/core/auth/browser-auth-request.service.ts
@@ -4,6 +4,7 @@ import { PostRequest } from '../data/request.models';
import { HALEndpointService } from '../shared/hal-endpoint.service';
import { RequestService } from '../data/request.service';
import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
+import { Observable, of as observableOf } from 'rxjs';
/**
* Client side version of the service to send authentication requests
@@ -20,15 +21,13 @@ export class BrowserAuthRequestService extends AuthRequestService {
}
/**
- * Factory function to create the request object to send. This needs to be a POST client side and
- * a GET server side. Due to CSRF validation, the server isn't allowed to send a POST, so we allow
- * only the server IP to send a GET to this endpoint.
+ * Factory function to create the request object to send.
*
* @param href The href to send the request to
* @protected
*/
- protected createShortLivedTokenRequest(href: string): PostRequest {
- return new PostRequest(this.requestService.generateRequestId(), href);
+ protected createShortLivedTokenRequest(href: string): Observable {
+ return observableOf(new PostRequest(this.requestService.generateRequestId(), href));
}
}
diff --git a/src/app/core/auth/server-auth-request.service.spec.ts b/src/app/core/auth/server-auth-request.service.spec.ts
index 69053fbb3a..df6d78256b 100644
--- a/src/app/core/auth/server-auth-request.service.spec.ts
+++ b/src/app/core/auth/server-auth-request.service.spec.ts
@@ -1,34 +1,68 @@
import { AuthRequestService } from './auth-request.service';
import { RequestService } from '../data/request.service';
import { ServerAuthRequestService } from './server-auth-request.service';
+import { HttpClient, HttpHeaders, HttpResponse } from '@angular/common/http';
+import { Observable, of as observableOf } from 'rxjs';
+import { HALEndpointService } from '../shared/hal-endpoint.service';
+import { PostRequest } from '../data/request.models';
+import {
+ XSRF_REQUEST_HEADER,
+ XSRF_RESPONSE_HEADER
+} from '../xsrf/xsrf.interceptor';
describe(`ServerAuthRequestService`, () => {
let href: string;
let requestService: RequestService;
let service: AuthRequestService;
+ let httpClient: HttpClient;
+ let httpResponse: HttpResponse;
+ let halService: HALEndpointService;
+ const mockToken = 'mock-token';
beforeEach(() => {
href = 'https://rest.api/auth/shortlivedtokens';
requestService = jasmine.createSpyObj('requestService', {
'generateRequestId': '8bb0582d-5013-4337-af9c-763beb25aae2'
});
- service = new ServerAuthRequestService(null, requestService, null);
+ let headers = new HttpHeaders();
+ headers = headers.set(XSRF_RESPONSE_HEADER, mockToken);
+ httpResponse = {
+ body: { bar: false },
+ headers: headers,
+ statusText: '200'
+ } as HttpResponse;
+ httpClient = jasmine.createSpyObj('httpClient', {
+ get: observableOf(httpResponse),
+ });
+ halService = jasmine.createSpyObj('halService', {
+ 'getRootHref': '/api'
+ });
+ service = new ServerAuthRequestService(halService, requestService, null, httpClient);
});
describe(`createShortLivedTokenRequest`, () => {
- it(`should return a GetRequest`, () => {
- const result = (service as any).createShortLivedTokenRequest(href);
- expect(result.constructor.name).toBe('GetRequest');
+ it(`should return a PostRequest`, (done) => {
+ const obs = (service as any).createShortLivedTokenRequest(href) as Observable;
+ obs.subscribe((result: PostRequest) => {
+ expect(result.constructor.name).toBe('PostRequest');
+ done();
+ });
});
- it(`should return a request with the given href`, () => {
- const result = (service as any).createShortLivedTokenRequest(href);
- expect(result.href).toBe(href) ;
+ it(`should return a request with the given href`, (done) => {
+ const obs = (service as any).createShortLivedTokenRequest(href) as Observable;
+ obs.subscribe((result: PostRequest) => {
+ expect(result.href).toBe(href);
+ done();
+ });
});
- it(`should have a responseMsToLive of 2 seconds`, () => {
- const result = (service as any).createShortLivedTokenRequest(href);
- expect(result.responseMsToLive).toBe(2 * 1000) ;
+ it(`should return a request with a xsrf header`, (done) => {
+ const obs = (service as any).createShortLivedTokenRequest(href) as Observable;
+ obs.subscribe((result: PostRequest) => {
+ expect(result.options.headers.get(XSRF_REQUEST_HEADER)).toBe(mockToken);
+ done();
+ });
});
});
});
diff --git a/src/app/core/auth/server-auth-request.service.ts b/src/app/core/auth/server-auth-request.service.ts
index 751389f71d..d6302081bc 100644
--- a/src/app/core/auth/server-auth-request.service.ts
+++ b/src/app/core/auth/server-auth-request.service.ts
@@ -1,9 +1,21 @@
import { Injectable } from '@angular/core';
import { AuthRequestService } from './auth-request.service';
-import { GetRequest } from '../data/request.models';
+import { PostRequest } from '../data/request.models';
import { HALEndpointService } from '../shared/hal-endpoint.service';
import { RequestService } from '../data/request.service';
import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
+import {
+ HttpHeaders,
+ HttpClient,
+ HttpResponse
+} from '@angular/common/http';
+import {
+ XSRF_REQUEST_HEADER,
+ XSRF_RESPONSE_HEADER,
+ DSPACE_XSRF_COOKIE
+} from '../xsrf/xsrf.interceptor';
+import { map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
/**
* Server side version of the service to send authentication requests
@@ -14,23 +26,42 @@ export class ServerAuthRequestService extends AuthRequestService {
constructor(
halService: HALEndpointService,
requestService: RequestService,
- rdbService: RemoteDataBuildService
+ rdbService: RemoteDataBuildService,
+ protected httpClient: HttpClient,
) {
super(halService, requestService, rdbService);
}
/**
- * Factory function to create the request object to send. This needs to be a POST client side and
- * a GET server side. Due to CSRF validation, the server isn't allowed to send a POST, so we allow
- * only the server IP to send a GET to this endpoint.
+ * Factory function to create the request object to send.
*
* @param href The href to send the request to
* @protected
*/
- protected createShortLivedTokenRequest(href: string): GetRequest {
- return Object.assign(new GetRequest(this.requestService.generateRequestId(), href), {
- responseMsToLive: 2 * 1000 // A short lived token is only valid for 2 seconds.
- });
+ protected createShortLivedTokenRequest(href: string): Observable {
+ // First do a call to the root endpoint in order to get an XSRF token
+ return this.httpClient.get(this.halService.getRootHref(), { observe: 'response' }).pipe(
+ // retrieve the XSRF token from the response header
+ map((response: HttpResponse) => response.headers.get(XSRF_RESPONSE_HEADER)),
+ // Use that token to create an HttpHeaders object
+ map((xsrfToken: string) => new HttpHeaders()
+ .set('Content-Type', 'application/json; charset=utf-8')
+ // set the token as the XSRF header
+ .set(XSRF_REQUEST_HEADER, xsrfToken)
+ // and as the DSPACE-XSRF-COOKIE
+ .set('Cookie', `${DSPACE_XSRF_COOKIE}=${xsrfToken}`)),
+ map((headers: HttpHeaders) =>
+ // Create a new PostRequest using those headers and the given href
+ new PostRequest(
+ this.requestService.generateRequestId(),
+ href,
+ {},
+ {
+ headers: headers,
+ },
+ )
+ )
+ );
}
}
diff --git a/src/app/core/browse/browse-definition-data.service.spec.ts b/src/app/core/browse/browse-definition-data.service.spec.ts
index 9377dc715f..f321c2551c 100644
--- a/src/app/core/browse/browse-definition-data.service.spec.ts
+++ b/src/app/core/browse/browse-definition-data.service.spec.ts
@@ -2,27 +2,66 @@ import { BrowseDefinitionDataService } from './browse-definition-data.service';
import { followLink } from '../../shared/utils/follow-link-config.model';
import { EMPTY } from 'rxjs';
import { FindListOptions } from '../data/find-list-options.model';
+import { getMockRemoteDataBuildService } from '../../shared/mocks/remote-data-build.service.mock';
+import { RequestService } from '../data/request.service';
+import { HALEndpointServiceStub } from '../../shared/testing/hal-endpoint-service.stub';
+import { getMockObjectCacheService } from '../../shared/mocks/object-cache.service.mock';
describe(`BrowseDefinitionDataService`, () => {
+ let requestService: RequestService;
let service: BrowseDefinitionDataService;
- const findAllDataSpy = jasmine.createSpyObj('findAllData', {
- findAll: EMPTY,
- });
+ let findAllDataSpy;
+ let searchDataSpy;
+ const browsesEndpointURL = 'https://rest.api/browses';
+ const halService: any = new HALEndpointServiceStub(browsesEndpointURL);
+
const options = new FindListOptions();
const linksToFollow = [
followLink('entries'),
followLink('items')
];
+ function initTestService() {
+ return new BrowseDefinitionDataService(
+ requestService,
+ getMockRemoteDataBuildService(),
+ getMockObjectCacheService(),
+ halService,
+ );
+ }
+
beforeEach(() => {
- service = new BrowseDefinitionDataService(null, null, null, null);
+ service = initTestService();
+ findAllDataSpy = jasmine.createSpyObj('findAllData', {
+ findAll: EMPTY,
+ });
+ searchDataSpy = jasmine.createSpyObj('searchData', {
+ searchBy: EMPTY,
+ getSearchByHref: EMPTY,
+ });
(service as any).findAllData = findAllDataSpy;
+ (service as any).searchData = searchDataSpy;
});
+ describe('findByFields', () => {
+ it(`should call searchByHref on searchData`, () => {
+ service.findByFields(['test'], true, false, ...linksToFollow);
+ expect(searchDataSpy.getSearchByHref).toHaveBeenCalled();
+ });
+ });
+ describe('searchBy', () => {
+ it(`should call searchBy on searchData`, () => {
+ service.searchBy('test', options, true, false, ...linksToFollow);
+ expect(searchDataSpy.searchBy).toHaveBeenCalledWith('test', options, true, false, ...linksToFollow);
+ });
+ });
describe(`findAll`, () => {
it(`should call findAll on findAllData`, () => {
service.findAll(options, true, false, ...linksToFollow);
expect(findAllDataSpy.findAll).toHaveBeenCalledWith(options, true, false, ...linksToFollow);
});
});
+
+
+
});
diff --git a/src/app/core/browse/browse-definition-data.service.ts b/src/app/core/browse/browse-definition-data.service.ts
index 32c3b44e14..88d070000e 100644
--- a/src/app/core/browse/browse-definition-data.service.ts
+++ b/src/app/core/browse/browse-definition-data.service.ts
@@ -13,6 +13,8 @@ import { FindListOptions } from '../data/find-list-options.model';
import { IdentifiableDataService } from '../data/base/identifiable-data.service';
import { FindAllData, FindAllDataImpl } from '../data/base/find-all-data';
import { dataService } from '../data/base/data-service.decorator';
+import { RequestParam } from '../cache/models/request-param.model';
+import { SearchData, SearchDataImpl } from '../data/base/search-data';
/**
* Data service responsible for retrieving browse definitions from the REST server
@@ -21,8 +23,9 @@ import { dataService } from '../data/base/data-service.decorator';
providedIn: 'root',
})
@dataService(BROWSE_DEFINITION)
-export class BrowseDefinitionDataService extends IdentifiableDataService implements FindAllData {
+export class BrowseDefinitionDataService extends IdentifiableDataService implements FindAllData, SearchData {
private findAllData: FindAllDataImpl;
+ private searchData: SearchDataImpl;
constructor(
protected requestService: RequestService,
@@ -31,7 +34,7 @@ export class BrowseDefinitionDataService extends IdentifiableDataService[]): Observable>> {
return this.findAllData.findAll(options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
}
+
+ /**
+ * Make a new FindListRequest with given search method
+ *
+ * @param searchMethod The search method for the object
+ * @param options The [[FindListOptions]] object
+ * @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
+ * @return {Observable>}
+ * Return an observable that emits response from the server
+ */
+ public searchBy(searchMethod: string, options?: FindListOptions, useCachedVersionIfAvailable?: boolean, reRequestOnStale?: boolean, ...linksToFollow: FollowLinkConfig[]): Observable>> {
+ return this.searchData.searchBy(searchMethod, options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
+ }
+
+ /**
+ * Create the HREF for a specific object's search method with given options object
+ *
+ * @param searchMethod The search method for the object
+ * @param options The [[FindListOptions]] object
+ * @return {Observable}
+ * Return an observable that emits created HREF
+ * @param linksToFollow List of {@link FollowLinkConfig} that indicate which {@link HALLink}s should be automatically resolved
+ */
+ public getSearchByHref(searchMethod: string, options?: FindListOptions, ...linksToFollow: FollowLinkConfig[]): Observable {
+ return this.searchData.getSearchByHref(searchMethod, options, ...linksToFollow);
+ }
+
+ /**
+ * Get the browse URL by providing a list of metadata keys. The first matching browse index definition
+ * for any of the fields is returned. This is used in eg. item page field component, which can be configured
+ * with several fields for a component like 'Author', and needs to know if and how to link the values
+ * to configured browse indices.
+ *
+ * @param fields an array of field strings, eg. ['dc.contributor.author', 'dc.creator']
+ * @param useCachedVersionIfAvailable Override the data service useCachedVersionIfAvailable parameter (default: true)
+ * @param reRequestOnStale Override the data service reRequestOnStale parameter (default: true)
+ * @param linksToFollow Override the data service linksToFollow parameter (default: empty array)
+ */
+ findByFields(
+ fields: string[],
+ useCachedVersionIfAvailable = true,
+ reRequestOnStale = true,
+ ...linksToFollow: FollowLinkConfig[]
+ ): Observable> {
+ const searchParams = [];
+ searchParams.push(new RequestParam('fields', fields));
+
+ const hrefObs = this.getSearchByHref(
+ 'byFields',
+ { searchParams },
+ ...linksToFollow
+ );
+
+ return this.findByHref(
+ hrefObs,
+ useCachedVersionIfAvailable,
+ reRequestOnStale,
+ ...linksToFollow,
+ );
+ }
+
}
diff --git a/src/app/core/browse/browse.service.ts b/src/app/core/browse/browse.service.ts
index 2fab189254..be28015069 100644
--- a/src/app/core/browse/browse.service.ts
+++ b/src/app/core/browse/browse.service.ts
@@ -19,9 +19,9 @@ import {
} from '../shared/operators';
import { URLCombiner } from '../url-combiner/url-combiner';
import { BrowseEntrySearchOptions } from './browse-entry-search-options.model';
-import { BrowseDefinitionDataService } from './browse-definition-data.service';
import { HrefOnlyDataService } from '../data/href-only-data.service';
import { followLink, FollowLinkConfig } from '../../shared/utils/follow-link-config.model';
+import { BrowseDefinitionDataService } from './browse-definition-data.service';
export const BROWSE_LINKS_TO_FOLLOW: FollowLinkConfig[] = [
@@ -35,7 +35,7 @@ export const BROWSE_LINKS_TO_FOLLOW: FollowLinkConfig[] = [
export class BrowseService {
protected linkPath = 'browses';
- private static toSearchKeyArray(metadataKey: string): string[] {
+ public static toSearchKeyArray(metadataKey: string): string[] {
const keyParts = metadataKey.split('.');
const searchFor = [];
searchFor.push('*');
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/eperson-registration.service.ts b/src/app/core/data/eperson-registration.service.ts
index bfbecdaecb..499d05af38 100644
--- a/src/app/core/data/eperson-registration.service.ts
+++ b/src/app/core/data/eperson-registration.service.ts
@@ -14,6 +14,7 @@ import { RemoteData } from './remote-data';
import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
import { HttpOptions } from '../dspace-rest/dspace-rest.service';
import { HttpHeaders } from '@angular/common/http';
+import { HttpParams } from '@angular/common/http';
@Injectable({
providedIn: 'root',
@@ -55,7 +56,7 @@ export class EpersonRegistrationService {
* @param email
* @param captchaToken the value of x-recaptcha-token header
*/
- registerEmail(email: string, captchaToken: string = null): Observable> {
+ registerEmail(email: string, captchaToken: string = null, type?: string): Observable> {
const registration = new Registration();
registration.email = email;
@@ -70,6 +71,11 @@ export class EpersonRegistrationService {
}
options.headers = headers;
+ if (hasValue(type)) {
+ options.params = type ?
+ new HttpParams({ fromString: 'accountRequestType=' + type }) : new HttpParams();
+ }
+
href$.pipe(
find((href: string) => hasValue(href)),
map((href: string) => {
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/services/server-xhr.service.ts b/src/app/core/services/server-xhr.service.ts
new file mode 100644
index 0000000000..69ae741402
--- /dev/null
+++ b/src/app/core/services/server-xhr.service.ts
@@ -0,0 +1,16 @@
+import { XhrFactory } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { prototype, XMLHttpRequest } from 'xhr2';
+
+/**
+ * Overrides the default XhrFactory server side, to allow us to set cookies in requests to the
+ * backend. This was added to be able to perform a working XSRF request from the node server, as it
+ * needs to set a cookie for the XSRF token
+ */
+@Injectable()
+export class ServerXhrService implements XhrFactory {
+ build(): XMLHttpRequest {
+ prototype._restrictedHeaders.cookie = false;
+ return new XMLHttpRequest();
+ }
+}
diff --git a/src/app/core/shared/metadata-representation/metadata-representation.model.ts b/src/app/core/shared/metadata-representation/metadata-representation.model.ts
index 06387966f7..379a3d1be8 100644
--- a/src/app/core/shared/metadata-representation/metadata-representation.model.ts
+++ b/src/app/core/shared/metadata-representation/metadata-representation.model.ts
@@ -1,11 +1,14 @@
/**
* An Enum defining the representation type of metadata
*/
+import { BrowseDefinition } from '../browse-definition.model';
+
export enum MetadataRepresentationType {
None = 'none',
Item = 'item',
AuthorityControlled = 'authority_controlled',
- PlainText = 'plain_text'
+ PlainText = 'plain_text',
+ BrowseLink = 'browse_link'
}
/**
@@ -24,8 +27,14 @@ export interface MetadataRepresentation {
*/
representationType: MetadataRepresentationType;
+ /**
+ * The browse definition (optional)
+ */
+ browseDefinition?: BrowseDefinition;
+
/**
* Fetches the value to be displayed
*/
getValue(): string;
+
}
diff --git a/src/app/core/shared/metadata-representation/metadatum/metadatum-representation.model.ts b/src/app/core/shared/metadata-representation/metadatum/metadatum-representation.model.ts
index 595147f3e6..a09de12ae4 100644
--- a/src/app/core/shared/metadata-representation/metadatum/metadatum-representation.model.ts
+++ b/src/app/core/shared/metadata-representation/metadatum/metadatum-representation.model.ts
@@ -1,6 +1,7 @@
import { MetadataRepresentation, MetadataRepresentationType } from '../metadata-representation.model';
import { hasValue } from '../../../../shared/empty.util';
import { MetadataValue } from '../../metadata.models';
+import { BrowseDefinition } from '../../browse-definition.model';
/**
* This class defines the way the metadatum it extends should be represented
@@ -12,9 +13,15 @@ export class MetadatumRepresentation extends MetadataValue implements MetadataRe
*/
itemType: string;
- constructor(itemType: string) {
+ /**
+ * The browse definition ID passed in with the metadatum, if any
+ */
+ browseDefinition?: BrowseDefinition;
+
+ constructor(itemType: string, browseDefinition?: BrowseDefinition) {
super();
this.itemType = itemType;
+ this.browseDefinition = browseDefinition;
}
/**
@@ -23,6 +30,8 @@ export class MetadatumRepresentation extends MetadataValue implements MetadataRe
get representationType(): MetadataRepresentationType {
if (hasValue(this.authority)) {
return MetadataRepresentationType.AuthorityControlled;
+ } else if (hasValue(this.browseDefinition)) {
+ return MetadataRepresentationType.BrowseLink;
} else {
return MetadataRepresentationType.PlainText;
}
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/core/xsrf/xsrf.interceptor.ts b/src/app/core/xsrf/xsrf.interceptor.ts
index d527924a28..cded432397 100644
--- a/src/app/core/xsrf/xsrf.interceptor.ts
+++ b/src/app/core/xsrf/xsrf.interceptor.ts
@@ -19,6 +19,8 @@ export const XSRF_REQUEST_HEADER = 'X-XSRF-TOKEN';
export const XSRF_RESPONSE_HEADER = 'DSPACE-XSRF-TOKEN';
// Name of cookie where we store the XSRF token
export const XSRF_COOKIE = 'XSRF-TOKEN';
+// Name of cookie the backend expects the XSRF token to be in
+export const DSPACE_XSRF_COOKIE = 'DSPACE-XSRF-COOKIE';
/**
* Custom Http Interceptor intercepting Http Requests & Responses to
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 }}
+
+