+
+
+
+
+
+
diff --git a/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.scss b/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.scss
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.spec.ts b/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.spec.ts
new file mode 100644
index 0000000000..6b5f2d8593
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.spec.ts
@@ -0,0 +1,336 @@
+import { ChangeDetectionStrategy, NO_ERRORS_SCHEMA } from '@angular/core';
+import { ComponentFixture, fakeAsync, TestBed, waitForAsync } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { By } from '@angular/platform-browser';
+
+import { getTestScheduler } from 'jasmine-marbles';
+import { NgbAccordionModule } from '@ng-bootstrap/ng-bootstrap';
+import { of } from 'rxjs';
+import { TestScheduler } from 'rxjs/testing';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+
+import { ResearcherProfileService } from '../../../core/profile/researcher-profile.service';
+import { createFailedRemoteDataObject$, createSuccessfulRemoteDataObject$ } from '../../../shared/remote-data.utils';
+import { Item } from '../../../core/shared/item.model';
+import { createPaginatedList } from '../../../shared/testing/utils.test';
+import { TranslateLoaderMock } from '../../../shared/mocks/translate-loader.mock';
+import { OrcidAuthComponent } from './orcid-auth.component';
+import { NativeWindowService } from '../../../core/services/window.service';
+import { NativeWindowMockFactory } from '../../../shared/mocks/mock-native-window-ref';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { NotificationsServiceStub } from '../../../shared/testing/notifications-service.stub';
+import { ResearcherProfile } from '../../../core/profile/model/researcher-profile.model';
+
+describe('OrcidAuthComponent test suite', () => {
+ let comp: OrcidAuthComponent;
+ let fixture: ComponentFixture;
+ let scheduler: TestScheduler;
+ let researcherProfileService: jasmine.SpyObj;
+ let nativeWindowRef;
+ let notificationsService;
+
+ const orcidScopes = [
+ '/authenticate',
+ '/read-limited',
+ '/activities/update',
+ '/person/update'
+ ];
+
+ const partialOrcidScopes = [
+ '/authenticate',
+ '/read-limited',
+ ];
+
+ const mockItemUnlinkedToOrcid: Item = Object.assign(new Item(), {
+ bundles: createSuccessfulRemoteDataObject$(createPaginatedList([])),
+ metadata: {
+ 'dc.title': [{
+ value: 'test person'
+ }],
+ 'dspace.entity.type': [{
+ 'value': 'Person'
+ }]
+ }
+ });
+
+ const mockItemLinkedToOrcid: Item = Object.assign(new Item(), {
+ bundles: createSuccessfulRemoteDataObject$(createPaginatedList([])),
+ metadata: {
+ 'dc.title': [{
+ value: 'test person'
+ }],
+ 'dspace.entity.type': [{
+ 'value': 'Person'
+ }],
+ 'dspace.object.owner': [{
+ 'value': 'test person',
+ 'language': null,
+ 'authority': 'deced3e7-68e2-495d-bf98-7c44fc33b8ff',
+ 'confidence': 600,
+ 'place': 0
+ }],
+ 'dspace.orcid.authenticated': [{
+ 'value': '2022-06-10T15:15:12.952872',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }],
+ 'dspace.orcid.scope': [{
+ 'value': '/authenticate',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }, {
+ 'value': '/read-limited',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 1
+ }, {
+ 'value': '/activities/update',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 2
+ }, {
+ 'value': '/person/update',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 3
+ }],
+ 'person.identifier.orcid': [{
+ 'value': 'orcid-id',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }]
+ }
+ });
+
+ beforeEach(waitForAsync(() => {
+ researcherProfileService = jasmine.createSpyObj('researcherProfileService', {
+ getOrcidAuthorizationScopes: jasmine.createSpy('getOrcidAuthorizationScopes'),
+ getOrcidAuthorizationScopesByItem: jasmine.createSpy('getOrcidAuthorizationScopesByItem'),
+ getOrcidAuthorizeUrl: jasmine.createSpy('getOrcidAuthorizeUrl'),
+ isLinkedToOrcid: jasmine.createSpy('isLinkedToOrcid'),
+ onlyAdminCanDisconnectProfileFromOrcid: jasmine.createSpy('onlyAdminCanDisconnectProfileFromOrcid'),
+ ownerCanDisconnectProfileFromOrcid: jasmine.createSpy('ownerCanDisconnectProfileFromOrcid'),
+ unlinkOrcidByItem: jasmine.createSpy('unlinkOrcidByItem')
+ });
+
+ void TestBed.configureTestingModule({
+ imports: [
+ NgbAccordionModule,
+ TranslateModule.forRoot({
+ loader: {
+ provide: TranslateLoader,
+ useClass: TranslateLoaderMock
+ }
+ }),
+ RouterTestingModule.withRoutes([])
+ ],
+ declarations: [OrcidAuthComponent],
+ providers: [
+ { provide: NativeWindowService, useFactory: NativeWindowMockFactory },
+ { provide: NotificationsService, useClass: NotificationsServiceStub },
+ { provide: ResearcherProfileService, useValue: researcherProfileService }
+ ],
+ schemas: [NO_ERRORS_SCHEMA]
+ }).overrideComponent(OrcidAuthComponent, {
+ set: { changeDetection: ChangeDetectionStrategy.Default }
+ }).compileComponents();
+ }));
+
+ beforeEach(waitForAsync(() => {
+ scheduler = getTestScheduler();
+ fixture = TestBed.createComponent(OrcidAuthComponent);
+ comp = fixture.componentInstance;
+ researcherProfileService.getOrcidAuthorizationScopes.and.returnValue(of(orcidScopes));
+ }));
+
+ describe('when orcid profile is not linked', () => {
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemUnlinkedToOrcid;
+ researcherProfileService.getOrcidAuthorizationScopesByItem.and.returnValue([]);
+ researcherProfileService.isLinkedToOrcid.and.returnValue(false);
+ researcherProfileService.onlyAdminCanDisconnectProfileFromOrcid.and.returnValue(of(false));
+ researcherProfileService.ownerCanDisconnectProfileFromOrcid.and.returnValue(of(true));
+ researcherProfileService.getOrcidAuthorizeUrl.and.returnValue(of('oarcidUrl'));
+ fixture.detectChanges();
+ }));
+
+ it('should create', fakeAsync(() => {
+ const orcidLinked = fixture.debugElement.query(By.css('[data-test="orcidLinked"]'));
+ const orcidNotLinked = fixture.debugElement.query(By.css('[data-test="orcidNotLinked"]'));
+ expect(orcidLinked).toBeFalsy();
+ expect(orcidNotLinked).toBeTruthy();
+ }));
+
+ it('should change location on link', () => {
+ nativeWindowRef = (comp as any)._window;
+ scheduler.schedule(() => comp.linkOrcid());
+ scheduler.flush();
+
+ expect(nativeWindowRef.nativeWindow.location.href).toBe('oarcidUrl');
+ });
+
+ });
+
+ describe('when orcid profile is linked', () => {
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ researcherProfileService.isLinkedToOrcid.and.returnValue(true);
+ }));
+
+ describe('', () => {
+
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ notificationsService = (comp as any).notificationsService;
+ researcherProfileService.getOrcidAuthorizationScopesByItem.and.returnValue([...orcidScopes]);
+ researcherProfileService.isLinkedToOrcid.and.returnValue(true);
+ researcherProfileService.onlyAdminCanDisconnectProfileFromOrcid.and.returnValue(of(false));
+ researcherProfileService.ownerCanDisconnectProfileFromOrcid.and.returnValue(of(true));
+ }));
+
+ describe('and unlink is successfully', () => {
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ researcherProfileService.unlinkOrcidByItem.and.returnValue(createSuccessfulRemoteDataObject$(new ResearcherProfile()));
+ spyOn(comp.unlink, 'emit');
+ fixture.detectChanges();
+ }));
+
+ it('should show success notification', () => {
+ scheduler.schedule(() => comp.unlinkOrcid());
+ scheduler.flush();
+
+ expect(notificationsService.success).toHaveBeenCalled();
+ expect(comp.unlink.emit).toHaveBeenCalled();
+ });
+ });
+
+ describe('and unlink is failed', () => {
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ researcherProfileService.unlinkOrcidByItem.and.returnValue(createFailedRemoteDataObject$());
+ fixture.detectChanges();
+ }));
+
+ it('should show success notification', () => {
+ scheduler.schedule(() => comp.unlinkOrcid());
+ scheduler.flush();
+
+ expect(notificationsService.error).toHaveBeenCalled();
+ });
+ });
+ });
+
+ describe('and has orcid authorization scopes', () => {
+
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ researcherProfileService.getOrcidAuthorizationScopesByItem.and.returnValue([...orcidScopes]);
+ researcherProfileService.isLinkedToOrcid.and.returnValue(true);
+ researcherProfileService.onlyAdminCanDisconnectProfileFromOrcid.and.returnValue(of(false));
+ researcherProfileService.ownerCanDisconnectProfileFromOrcid.and.returnValue(of(true));
+ fixture.detectChanges();
+ }));
+
+ it('should create', fakeAsync(() => {
+ const orcidLinked = fixture.debugElement.query(By.css('[data-test="orcidLinked"]'));
+ const orcidNotLinked = fixture.debugElement.query(By.css('[data-test="orcidNotLinked"]'));
+ expect(orcidLinked).toBeTruthy();
+ expect(orcidNotLinked).toBeFalsy();
+ }));
+
+ it('should display orcid authorizations', fakeAsync(() => {
+ const orcidAuthorizations = fixture.debugElement.query(By.css('[data-test="hasOrcidAuthorizations"]'));
+ const noMissingOrcidAuthorizations = fixture.debugElement.query(By.css('[data-test="noMissingOrcidAuthorizations"]'));
+ const orcidAuthorizationsList = fixture.debugElement.queryAll(By.css('[data-test="orcidAuthorization"]'));
+
+ expect(orcidAuthorizations).toBeTruthy();
+ expect(noMissingOrcidAuthorizations).toBeTruthy();
+ expect(orcidAuthorizationsList.length).toBe(4);
+ }));
+ });
+
+ describe('and has missing orcid authorization scopes', () => {
+
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ researcherProfileService.getOrcidAuthorizationScopesByItem.and.returnValue([...partialOrcidScopes]);
+ researcherProfileService.isLinkedToOrcid.and.returnValue(true);
+ researcherProfileService.onlyAdminCanDisconnectProfileFromOrcid.and.returnValue(of(false));
+ researcherProfileService.ownerCanDisconnectProfileFromOrcid.and.returnValue(of(true));
+ fixture.detectChanges();
+ }));
+
+ it('should create', fakeAsync(() => {
+ const orcidLinked = fixture.debugElement.query(By.css('[data-test="orcidLinked"]'));
+ const orcidNotLinked = fixture.debugElement.query(By.css('[data-test="orcidNotLinked"]'));
+ expect(orcidLinked).toBeTruthy();
+ expect(orcidNotLinked).toBeFalsy();
+ }));
+
+ it('should display orcid authorizations', fakeAsync(() => {
+ const orcidAuthorizations = fixture.debugElement.query(By.css('[data-test="hasOrcidAuthorizations"]'));
+ const missingOrcidAuthorizations = fixture.debugElement.query(By.css('[data-test="missingOrcidAuthorizations"]'));
+ const orcidAuthorizationsList = fixture.debugElement.queryAll(By.css('[data-test="orcidAuthorization"]'));
+ const missingOrcidAuthorizationsList = fixture.debugElement.queryAll(By.css('[data-test="missingOrcidAuthorization"]'));
+
+ expect(orcidAuthorizations).toBeTruthy();
+ expect(missingOrcidAuthorizations).toBeTruthy();
+ expect(orcidAuthorizationsList.length).toBe(2);
+ expect(missingOrcidAuthorizationsList.length).toBe(2);
+ }));
+ });
+
+ describe('and only admin can unlink scopes', () => {
+
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ researcherProfileService.getOrcidAuthorizationScopesByItem.and.returnValue([...orcidScopes]);
+ researcherProfileService.isLinkedToOrcid.and.returnValue(true);
+ researcherProfileService.onlyAdminCanDisconnectProfileFromOrcid.and.returnValue(of(true));
+ researcherProfileService.ownerCanDisconnectProfileFromOrcid.and.returnValue(of(false));
+ fixture.detectChanges();
+ }));
+
+ it('should display warning panel', fakeAsync(() => {
+ const unlinkOnlyAdmin = fixture.debugElement.query(By.css('[data-test="unlinkOnlyAdmin"]'));
+ const unlinkOwner = fixture.debugElement.query(By.css('[data-test="unlinkOwner"]'));
+ expect(unlinkOnlyAdmin).toBeTruthy();
+ expect(unlinkOwner).toBeFalsy();
+ }));
+
+ });
+
+ describe('and owner can unlink scopes', () => {
+
+ beforeEach(waitForAsync(() => {
+ comp.item = mockItemLinkedToOrcid;
+ researcherProfileService.getOrcidAuthorizationScopesByItem.and.returnValue([...orcidScopes]);
+ researcherProfileService.isLinkedToOrcid.and.returnValue(true);
+ researcherProfileService.onlyAdminCanDisconnectProfileFromOrcid.and.returnValue(of(true));
+ researcherProfileService.ownerCanDisconnectProfileFromOrcid.and.returnValue(of(true));
+ fixture.detectChanges();
+ }));
+
+ it('should display warning panel', fakeAsync(() => {
+ const unlinkOnlyAdmin = fixture.debugElement.query(By.css('[data-test="unlinkOnlyAdmin"]'));
+ const unlinkOwner = fixture.debugElement.query(By.css('[data-test="unlinkOwner"]'));
+ expect(unlinkOnlyAdmin).toBeFalsy();
+ expect(unlinkOwner).toBeTruthy();
+ }));
+
+ });
+
+ });
+
+
+});
diff --git a/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.ts b/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.ts
new file mode 100644
index 0000000000..b052fdedd8
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-auth/orcid-auth.component.ts
@@ -0,0 +1,219 @@
+import { Component, EventEmitter, Inject, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';
+
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { ResearcherProfileService } from '../../../core/profile/researcher-profile.service';
+import { NativeWindowRef, NativeWindowService } from '../../../core/services/window.service';
+import { Item } from '../../../core/shared/item.model';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { RemoteData } from '../../../core/data/remote-data';
+import { ResearcherProfile } from '../../../core/profile/model/researcher-profile.model';
+import { getFirstCompletedRemoteData } from '../../../core/shared/operators';
+
+@Component({
+ selector: 'ds-orcid-auth',
+ templateUrl: './orcid-auth.component.html',
+ styleUrls: ['./orcid-auth.component.scss']
+})
+export class OrcidAuthComponent implements OnInit, OnChanges {
+
+ /**
+ * The item for which showing the orcid settings
+ */
+ @Input() item: Item;
+
+ /**
+ * The list of exposed orcid authorization scopes for the orcid profile
+ */
+ profileAuthorizationScopes: BehaviorSubject = new BehaviorSubject([]);
+
+ /**
+ * The list of all orcid authorization scopes missing in the orcid profile
+ */
+ missingAuthorizationScopes: BehaviorSubject = new BehaviorSubject([]);
+
+ /**
+ * The list of all orcid authorization scopes available
+ */
+ orcidAuthorizationScopes: BehaviorSubject = new BehaviorSubject([]);
+
+ /**
+ * A boolean representing if unlink operation is processing
+ */
+ unlinkProcessing: BehaviorSubject = new BehaviorSubject(false);
+
+ /**
+ * A boolean representing if orcid profile is linked
+ */
+ private isOrcidLinked$: BehaviorSubject = new BehaviorSubject(false);
+
+ /**
+ * A boolean representing if only admin can disconnect orcid profile
+ */
+ private onlyAdminCanDisconnectProfileFromOrcid$: BehaviorSubject = new BehaviorSubject(false);
+
+ /**
+ * A boolean representing if owner can disconnect orcid profile
+ */
+ private ownerCanDisconnectProfileFromOrcid$: BehaviorSubject = new BehaviorSubject(false);
+
+ /**
+ * An event emitted when orcid profile is unliked successfully
+ */
+ @Output() unlink: EventEmitter = new EventEmitter();
+
+ constructor(
+ private researcherProfileService: ResearcherProfileService,
+ private translateService: TranslateService,
+ private notificationsService: NotificationsService,
+ @Inject(NativeWindowService) private _window: NativeWindowRef,
+ ) {
+ }
+
+ ngOnInit() {
+ this.researcherProfileService.getOrcidAuthorizationScopes().subscribe((scopes: string[]) => {
+ this.orcidAuthorizationScopes.next(scopes);
+ this.initOrcidAuthSettings();
+ });
+ }
+
+ ngOnChanges(changes: SimpleChanges): void {
+ if (!changes.item.isFirstChange() && changes.item.currentValue !== changes.item.previousValue) {
+ this.initOrcidAuthSettings();
+ }
+ }
+
+ /**
+ * Check if the list of exposed orcid authorization scopes for the orcid profile has values
+ */
+ hasOrcidAuthorizations(): Observable {
+ return this.profileAuthorizationScopes.asObservable().pipe(
+ map((scopes: string[]) => scopes.length > 0)
+ );
+ }
+
+ /**
+ * Return the list of exposed orcid authorization scopes for the orcid profile
+ */
+ getOrcidAuthorizations(): Observable {
+ return this.profileAuthorizationScopes.asObservable();
+ }
+
+ /**
+ * Check if the list of exposed orcid authorization scopes for the orcid profile has values
+ */
+ hasMissingOrcidAuthorizations(): Observable {
+ return this.missingAuthorizationScopes.asObservable().pipe(
+ map((scopes: string[]) => scopes.length > 0)
+ );
+ }
+
+ /**
+ * Return the list of exposed orcid authorization scopes for the orcid profile
+ */
+ getMissingOrcidAuthorizations(): Observable {
+ return this.profileAuthorizationScopes.asObservable();
+ }
+
+ /**
+ * Return a boolean representing if orcid profile is linked
+ */
+ isLinkedToOrcid(): Observable {
+ return this.isOrcidLinked$.asObservable();
+ }
+
+ getOrcidNotLinkedMessage(): Observable {
+ const orcid = this.item.firstMetadataValue('person.identifier.orcid');
+ if (orcid) {
+ return this.translateService.get('person.page.orcid.orcid-not-linked-message', { 'orcid': orcid });
+ } else {
+ return this.translateService.get('person.page.orcid.no-orcid-message');
+ }
+ }
+
+ /**
+ * Get label for a given orcid authorization scope
+ *
+ * @param scope
+ */
+ getAuthorizationDescription(scope: string) {
+ return 'person.page.orcid.scope.' + scope.substring(1).replace('/', '-');
+ }
+
+ /**
+ * Return a boolean representing if only admin can disconnect orcid profile
+ */
+ onlyAdminCanDisconnectProfileFromOrcid(): Observable {
+ return this.onlyAdminCanDisconnectProfileFromOrcid$.asObservable();
+ }
+
+ /**
+ * Return a boolean representing if owner can disconnect orcid profile
+ */
+ ownerCanDisconnectProfileFromOrcid(): Observable {
+ return this.ownerCanDisconnectProfileFromOrcid$.asObservable();
+ }
+
+ /**
+ * Link existing person profile with orcid
+ */
+ linkOrcid(): void {
+ this.researcherProfileService.getOrcidAuthorizeUrl(this.item).subscribe((authorizeUrl) => {
+ this._window.nativeWindow.location.href = authorizeUrl;
+ });
+ }
+
+ /**
+ * Unlink existing person profile from orcid
+ */
+ unlinkOrcid(): void {
+ this.unlinkProcessing.next(true);
+ this.researcherProfileService.unlinkOrcidByItem(this.item).pipe(
+ getFirstCompletedRemoteData()
+ ).subscribe((remoteData: RemoteData) => {
+ this.unlinkProcessing.next(false);
+ if (remoteData.isSuccess) {
+ this.notificationsService.success(this.translateService.get('person.page.orcid.unlink.success'));
+ this.unlink.emit();
+ } else {
+ this.notificationsService.error(this.translateService.get('person.page.orcid.unlink.error'));
+ }
+ });
+ }
+
+ /**
+ * initialize all Orcid authentication settings
+ * @private
+ */
+ private initOrcidAuthSettings(): void {
+
+ this.setOrcidAuthorizationsFromItem();
+
+ this.setMissingOrcidAuthorizations();
+
+ this.researcherProfileService.onlyAdminCanDisconnectProfileFromOrcid().subscribe((result) => {
+ this.onlyAdminCanDisconnectProfileFromOrcid$.next(result);
+ });
+
+ this.researcherProfileService.ownerCanDisconnectProfileFromOrcid().subscribe((result) => {
+ this.ownerCanDisconnectProfileFromOrcid$.next(result);
+ });
+
+ this.isOrcidLinked$.next(this.researcherProfileService.isLinkedToOrcid(this.item));
+ }
+
+ private setMissingOrcidAuthorizations(): void {
+ const profileScopes = this.researcherProfileService.getOrcidAuthorizationScopesByItem(this.item);
+ const orcidScopes = this.orcidAuthorizationScopes.value;
+ const missingScopes = orcidScopes.filter((scope) => !profileScopes.includes(scope));
+
+ this.missingAuthorizationScopes.next(missingScopes);
+ }
+
+ private setOrcidAuthorizationsFromItem(): void {
+ this.profileAuthorizationScopes.next(this.researcherProfileService.getOrcidAuthorizationScopesByItem(this.item));
+ }
+
+}
diff --git a/src/app/item-page/orcid-page/orcid-page.component.html b/src/app/item-page/orcid-page/orcid-page.component.html
new file mode 100644
index 0000000000..9c19d0b66e
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-page.component.html
@@ -0,0 +1,18 @@
+
+
diff --git a/src/app/item-page/orcid-page/orcid-page.component.scss b/src/app/item-page/orcid-page/orcid-page.component.scss
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/app/item-page/orcid-page/orcid-page.component.spec.ts b/src/app/item-page/orcid-page/orcid-page.component.spec.ts
new file mode 100644
index 0000000000..a4af5edf5c
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-page.component.spec.ts
@@ -0,0 +1,220 @@
+import { NO_ERRORS_SCHEMA, PLATFORM_ID } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { ComponentFixture, fakeAsync, TestBed, waitForAsync } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { By } from '@angular/platform-browser';
+
+import { of as observableOf } from 'rxjs';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { TestScheduler } from 'rxjs/testing';
+import { getTestScheduler } from 'jasmine-marbles';
+
+import { AuthService } from '../../core/auth/auth.service';
+import { ActivatedRouteStub } from '../../shared/testing/active-router.stub';
+import { ResearcherProfileService } from '../../core/profile/researcher-profile.service';
+import { OrcidPageComponent } from './orcid-page.component';
+import {
+ createFailedRemoteDataObject$,
+ createSuccessfulRemoteDataObject,
+ createSuccessfulRemoteDataObject$
+} from '../../shared/remote-data.utils';
+import { Item } from '../../core/shared/item.model';
+import { createPaginatedList } from '../../shared/testing/utils.test';
+import { TranslateLoaderMock } from '../../shared/mocks/translate-loader.mock';
+import { ItemDataService } from '../../core/data/item-data.service';
+import { ResearcherProfile } from '../../core/profile/model/researcher-profile.model';
+
+describe('OrcidPageComponent test suite', () => {
+ let comp: OrcidPageComponent;
+ let fixture: ComponentFixture;
+ let scheduler: TestScheduler;
+ let authService: jasmine.SpyObj;
+ let routeStub: jasmine.SpyObj;
+ let routeData: any;
+ let itemDataService: jasmine.SpyObj;
+ let researcherProfileService: jasmine.SpyObj;
+
+ const mockResearcherProfile: ResearcherProfile = Object.assign(new ResearcherProfile(), {
+ id: 'test-id',
+ visible: true,
+ type: 'profile',
+ _links: {
+ item: {
+ href: 'https://rest.api/rest/api/profiles/test-id/item'
+ },
+ self: {
+ href: 'https://rest.api/rest/api/profiles/test-id'
+ },
+ }
+ });
+ const mockItem: Item = Object.assign(new Item(), {
+ id: 'test-id',
+ bundles: createSuccessfulRemoteDataObject$(createPaginatedList([])),
+ metadata: {
+ 'dc.title': [
+ {
+ language: 'en_US',
+ value: 'test item'
+ }
+ ]
+ }
+ });
+ const mockItemLinkedToOrcid: Item = Object.assign(new Item(), {
+ id: 'test-id',
+ bundles: createSuccessfulRemoteDataObject$(createPaginatedList([])),
+ metadata: {
+ 'dc.title': [
+ {
+ value: 'test item'
+ }
+ ],
+ 'dspace.orcid.authenticated': [
+ {
+ value: 'true'
+ }
+ ]
+ }
+ });
+
+ beforeEach(waitForAsync(() => {
+ authService = jasmine.createSpyObj('authService', {
+ isAuthenticated: jasmine.createSpy('isAuthenticated'),
+ navigateByUrl: jasmine.createSpy('navigateByUrl')
+ });
+
+ routeData = {
+ dso: createSuccessfulRemoteDataObject(mockItem),
+ };
+
+ routeStub = new ActivatedRouteStub({}, routeData);
+
+ researcherProfileService = jasmine.createSpyObj('researcherProfileService', {
+ isLinkedToOrcid: jasmine.createSpy('isLinkedToOrcid'),
+ linkOrcidByItem: jasmine.createSpy('linkOrcidByItem'),
+ });
+
+ itemDataService = jasmine.createSpyObj('ItemDataService', {
+ findById: jasmine.createSpy('findById')
+ });
+
+ void TestBed.configureTestingModule({
+ imports: [
+ TranslateModule.forRoot({
+ loader: {
+ provide: TranslateLoader,
+ useClass: TranslateLoaderMock
+ }
+ }),
+ RouterTestingModule.withRoutes([])
+ ],
+ declarations: [OrcidPageComponent],
+ providers: [
+ { provide: ActivatedRoute, useValue: routeStub },
+ { provide: ResearcherProfileService, useValue: researcherProfileService },
+ { provide: AuthService, useValue: authService },
+ { provide: ItemDataService, useValue: itemDataService },
+ { provide: PLATFORM_ID, useValue: 'browser' },
+ ],
+
+ schemas: [NO_ERRORS_SCHEMA]
+ }).compileComponents();
+ }));
+
+ beforeEach(waitForAsync(() => {
+ scheduler = getTestScheduler();
+ fixture = TestBed.createComponent(OrcidPageComponent);
+ comp = fixture.componentInstance;
+ authService.isAuthenticated.and.returnValue(observableOf(true));
+ }));
+
+ describe('whn has no query param', () => {
+ beforeEach(waitForAsync(() => {
+ fixture.detectChanges();
+ }));
+
+ it('should create', () => {
+ const btn = fixture.debugElement.queryAll(By.css('[data-test="back-button"]'));
+ const auth = fixture.debugElement.query(By.css('[data-test="orcid-auth"]'));
+ const settings = fixture.debugElement.query(By.css('[data-test="orcid-sync-setting"]'));
+ expect(comp).toBeTruthy();
+ expect(btn.length).toBe(1);
+ expect(auth).toBeTruthy();
+ expect(settings).toBeTruthy();
+ expect(comp.itemId).toBe('test-id');
+ });
+
+ it('should call isLinkedToOrcid', () => {
+ comp.isLinkedToOrcid();
+
+ expect(researcherProfileService.isLinkedToOrcid).toHaveBeenCalledWith(comp.item.value);
+ });
+
+ it('should update item', fakeAsync(() => {
+ itemDataService.findById.and.returnValue(createSuccessfulRemoteDataObject$(mockItemLinkedToOrcid));
+ scheduler.schedule(() => comp.updateItem());
+ scheduler.flush();
+
+ expect(comp.item.value).toEqual(mockItemLinkedToOrcid);
+ }));
+ });
+
+ describe('when query param contains orcid code', () => {
+ beforeEach(waitForAsync(() => {
+ spyOn(comp, 'updateItem').and.callThrough();
+ routeStub.testParams = {
+ code: 'orcid-code'
+ };
+ }));
+
+ describe('and linking to orcid profile is successfully', () => {
+ beforeEach(waitForAsync(() => {
+ researcherProfileService.linkOrcidByItem.and.returnValue(createSuccessfulRemoteDataObject$(mockResearcherProfile));
+ itemDataService.findById.and.returnValue(createSuccessfulRemoteDataObject$(mockItemLinkedToOrcid));
+ fixture.detectChanges();
+ }));
+
+ it('should call linkOrcidByItem', () => {
+ expect(researcherProfileService.linkOrcidByItem).toHaveBeenCalledWith(mockItem, 'orcid-code');
+ expect(comp.updateItem).toHaveBeenCalled();
+ });
+
+ it('should create', () => {
+ const btn = fixture.debugElement.queryAll(By.css('[data-test="back-button"]'));
+ const auth = fixture.debugElement.query(By.css('[data-test="orcid-auth"]'));
+ const settings = fixture.debugElement.query(By.css('[data-test="orcid-sync-setting"]'));
+ expect(comp).toBeTruthy();
+ expect(btn.length).toBe(1);
+ expect(auth).toBeTruthy();
+ expect(settings).toBeTruthy();
+ expect(comp.itemId).toBe('test-id');
+ });
+
+ });
+
+ describe('and linking to orcid profile is failed', () => {
+ beforeEach(waitForAsync(() => {
+ researcherProfileService.linkOrcidByItem.and.returnValue(createFailedRemoteDataObject$());
+ itemDataService.findById.and.returnValue(createSuccessfulRemoteDataObject$(mockItemLinkedToOrcid));
+ fixture.detectChanges();
+ }));
+
+ it('should call linkOrcidByItem', () => {
+ expect(researcherProfileService.linkOrcidByItem).toHaveBeenCalledWith(mockItem, 'orcid-code');
+ expect(comp.updateItem).not.toHaveBeenCalled();
+ });
+
+ it('should create', () => {
+ const btn = fixture.debugElement.queryAll(By.css('[data-test="back-button"]'));
+ const auth = fixture.debugElement.query(By.css('[data-test="orcid-auth"]'));
+ const settings = fixture.debugElement.query(By.css('[data-test="orcid-sync-setting"]'));
+ const error = fixture.debugElement.query(By.css('[data-test="error-box"]'));
+ expect(comp).toBeTruthy();
+ expect(btn.length).toBe(1);
+ expect(error).toBeTruthy();
+ expect(auth).toBeFalsy();
+ expect(settings).toBeFalsy();
+ });
+
+ });
+ });
+});
diff --git a/src/app/item-page/orcid-page/orcid-page.component.ts b/src/app/item-page/orcid-page/orcid-page.component.ts
new file mode 100644
index 0000000000..6c1de3d100
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-page.component.ts
@@ -0,0 +1,145 @@
+import { Component, Inject, OnInit, PLATFORM_ID } from '@angular/core';
+import { ActivatedRoute, ParamMap, Router } from '@angular/router';
+
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+
+import { ResearcherProfileService } from '../../core/profile/researcher-profile.service';
+import { getFirstCompletedRemoteData, getFirstSucceededRemoteDataPayload } from '../../core/shared/operators';
+import { RemoteData } from '../../core/data/remote-data';
+import { Item } from '../../core/shared/item.model';
+import { getItemPageRoute } from '../item-page-routing-paths';
+import { AuthService } from '../../core/auth/auth.service';
+import { redirectOn4xx } from '../../core/shared/authorized.operators';
+import { ItemDataService } from '../../core/data/item-data.service';
+import { isNotEmpty } from '../../shared/empty.util';
+import { ResearcherProfile } from '../../core/profile/model/researcher-profile.model';
+import { isPlatformBrowser } from '@angular/common';
+
+/**
+ * A component that represents the orcid settings page
+ */
+@Component({
+ selector: 'ds-orcid-page',
+ templateUrl: './orcid-page.component.html',
+ styleUrls: ['./orcid-page.component.scss']
+})
+export class OrcidPageComponent implements OnInit {
+
+ /**
+ * A boolean representing if the connection operation with orcid profile is in progress
+ */
+ connectionStatus: BehaviorSubject = new BehaviorSubject(false);
+
+ /**
+ * The item for which showing the orcid settings
+ */
+ item: BehaviorSubject- = new BehaviorSubject
- (null);
+
+ /**
+ * The item id for which showing the orcid settings
+ */
+ itemId: string;
+
+ /**
+ * A boolean representing if the connection operation with orcid profile is in progress
+ */
+ processingConnection: BehaviorSubject
= new BehaviorSubject(true);
+
+ constructor(
+ @Inject(PLATFORM_ID) private platformId: any,
+ private authService: AuthService,
+ private itemService: ItemDataService,
+ private researcherProfileService: ResearcherProfileService,
+ private route: ActivatedRoute,
+ private router: Router
+ ) {
+ }
+
+ /**
+ * Retrieve the item for which showing the orcid settings
+ */
+ ngOnInit(): void {
+ if (isPlatformBrowser(this.platformId)) {
+ const codeParam$ = this.route.queryParamMap.pipe(
+ take(1),
+ map((paramMap: ParamMap) => paramMap.get('code')),
+ );
+
+ const item$ = this.route.data.pipe(
+ map((data) => data.dso as RemoteData- ),
+ redirectOn4xx(this.router, this.authService),
+ getFirstSucceededRemoteDataPayload()
+ );
+
+ combineLatest([codeParam$, item$]).subscribe(([codeParam, item]) => {
+ this.itemId = item.id;
+ /**
+ * Check if code is present in the query param. If so it means this page is loaded after attempting to
+ * link the person to the ORCID profile, otherwise the person is already linked to ORCID profile
+ */
+ if (isNotEmpty(codeParam)) {
+ this.linkProfileToOrcid(item, codeParam);
+ } else {
+ this.item.next(item);
+ this.processingConnection.next(false);
+ this.connectionStatus.next(true);
+ }
+ });
+ }
+ }
+
+ /**
+ * Check if the current item is linked to an ORCID profile.
+ *
+ * @returns the check result
+ */
+ isLinkedToOrcid(): boolean {
+ return this.researcherProfileService.isLinkedToOrcid(this.item.value);
+ }
+
+ /**
+ * Get the route to an item's page
+ */
+ getItemPage(): string {
+ return getItemPageRoute(this.item.value);
+ }
+
+ /**
+ * Retrieve the updated profile item
+ */
+ updateItem(): void {
+ this.itemService.findById(this.itemId, false).pipe(
+ getFirstCompletedRemoteData()
+ ).subscribe((itemRD: RemoteData
- ) => {
+ if (itemRD.hasSucceeded) {
+ this.item.next(itemRD.payload);
+ }
+ });
+ }
+
+ /**
+ * Link person item to ORCID profile by using the code received after redirect from ORCID.
+ *
+ * @param person The person item to link to ORCID profile
+ * @param code The auth-code received from ORCID
+ */
+ private linkProfileToOrcid(person: Item, code: string) {
+ this.researcherProfileService.linkOrcidByItem(person, code).pipe(
+ getFirstCompletedRemoteData()
+ ).subscribe((profileRD: RemoteData
) => {
+ this.processingConnection.next(false);
+ if (profileRD.hasSucceeded) {
+ this.connectionStatus.next(true);
+ this.updateItem();
+ } else {
+ this.item.next(person);
+ this.connectionStatus.next(false);
+ }
+
+ // update route removing the code from query params
+ const redirectUrl = this.router.url.split('?')[0];
+ this.router.navigate([redirectUrl]);
+ });
+ }
+}
diff --git a/src/app/item-page/orcid-page/orcid-page.guard.ts b/src/app/item-page/orcid-page/orcid-page.guard.ts
new file mode 100644
index 0000000000..97c528e9ae
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-page.guard.ts
@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';
+import { Observable, of as observableOf } from 'rxjs';
+import { AuthService } from '../../core/auth/auth.service';
+import { AuthorizationDataService } from '../../core/data/feature-authorization/authorization-data.service';
+import { DsoPageSingleFeatureGuard } from '../../core/data/feature-authorization/feature-authorization-guard/dso-page-single-feature.guard';
+import { FeatureID } from '../../core/data/feature-authorization/feature-id';
+import { Item } from '../../core/shared/item.model';
+import { ItemPageResolver } from '../item-page.resolver';
+
+@Injectable({
+ providedIn: 'root'
+})
+/**
+ * Guard for preventing unauthorized access to certain {@link Item} pages requiring administrator rights
+ */
+export class OrcidPageGuard extends DsoPageSingleFeatureGuard- {
+ constructor(protected resolver: ItemPageResolver,
+ protected authorizationService: AuthorizationDataService,
+ protected router: Router,
+ protected authService: AuthService) {
+ super(resolver, authorizationService, router, authService);
+ }
+
+ /**
+ * Check administrator authorization rights
+ */
+ getFeatureID(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable
{
+ return observableOf(FeatureID.CanSynchronizeWithORCID);
+ }
+}
diff --git a/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.html b/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.html
new file mode 100644
index 0000000000..ee9a15268a
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.html
@@ -0,0 +1,106 @@
+;
+ let scheduler: TestScheduler;
+ let researcherProfileService: jasmine.SpyObj;
+ let notificationsService;
+ let formGroup: FormGroup;
+
+ const mockResearcherProfile: ResearcherProfile = Object.assign(new ResearcherProfile(), {
+ id: 'test-id',
+ visible: true,
+ type: 'profile',
+ _links: {
+ item: {
+ href: 'https://rest.api/rest/api/profiles/test-id/item'
+ },
+ self: {
+ href: 'https://rest.api/rest/api/profiles/test-id'
+ },
+ }
+ });
+
+ const mockItemLinkedToOrcid: Item = Object.assign(new Item(), {
+ bundles: createSuccessfulRemoteDataObject$(createPaginatedList([])),
+ metadata: {
+ 'dc.title': [{
+ value: 'test person'
+ }],
+ 'dspace.entity.type': [{
+ 'value': 'Person'
+ }],
+ 'dspace.object.owner': [{
+ 'value': 'test person',
+ 'language': null,
+ 'authority': 'deced3e7-68e2-495d-bf98-7c44fc33b8ff',
+ 'confidence': 600,
+ 'place': 0
+ }],
+ 'dspace.orcid.authenticated': [{
+ 'value': '2022-06-10T15:15:12.952872',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }],
+ 'dspace.orcid.scope': [{
+ 'value': '/authenticate',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }, {
+ 'value': '/read-limited',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 1
+ }, {
+ 'value': '/activities/update',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 2
+ }, {
+ 'value': '/person/update',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 3
+ }],
+ 'dspace.orcid.sync-mode': [{
+ 'value': 'MANUAL',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }],
+ 'dspace.orcid.sync-profile': [{
+ 'value': 'BIOGRAPHICAL',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }, {
+ 'value': 'IDENTIFIERS',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 1
+ }],
+ 'dspace.orcid.sync-publications': [{
+ 'value': 'ALL',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }],
+ 'person.identifier.orcid': [{
+ 'value': 'orcid-id',
+ 'language': null,
+ 'authority': null,
+ 'confidence': -1,
+ 'place': 0
+ }]
+ }
+ });
+
+ beforeEach(waitForAsync(() => {
+ researcherProfileService = jasmine.createSpyObj('researcherProfileService', {
+ findByRelatedItem: jasmine.createSpy('findByRelatedItem'),
+ updateByOrcidOperations: jasmine.createSpy('updateByOrcidOperations')
+ });
+
+ void TestBed.configureTestingModule({
+ imports: [
+ FormsModule,
+ NgbAccordionModule,
+ ReactiveFormsModule,
+ TranslateModule.forRoot({
+ loader: {
+ provide: TranslateLoader,
+ useClass: TranslateLoaderMock
+ }
+ }),
+ RouterTestingModule.withRoutes([])
+ ],
+ declarations: [OrcidSyncSettingsComponent],
+ providers: [
+ { provide: NotificationsService, useClass: NotificationsServiceStub },
+ { provide: ResearcherProfileService, useValue: researcherProfileService }
+ ],
+ schemas: [NO_ERRORS_SCHEMA]
+ }).overrideComponent(OrcidSyncSettingsComponent, {
+ set: { changeDetection: ChangeDetectionStrategy.Default }
+ }).compileComponents();
+ }));
+
+ beforeEach(waitForAsync(() => {
+ scheduler = getTestScheduler();
+ fixture = TestBed.createComponent(OrcidSyncSettingsComponent);
+ comp = fixture.componentInstance;
+ comp.item = mockItemLinkedToOrcid;
+ fixture.detectChanges();
+ }));
+
+ it('should create cards properly', () => {
+ const modes = fixture.debugElement.query(By.css('[data-test="sync-mode"]'));
+ const publication = fixture.debugElement.query(By.css('[data-test="sync-mode-publication"]'));
+ const funding = fixture.debugElement.query(By.css('[data-test="sync-mode-funding"]'));
+ const preferences = fixture.debugElement.query(By.css('[data-test="profile-preferences"]'));
+ expect(modes).toBeTruthy();
+ expect(publication).toBeTruthy();
+ expect(funding).toBeTruthy();
+ expect(preferences).toBeTruthy();
+ });
+
+ it('should init sync modes properly', () => {
+ expect(comp.currentSyncMode).toBe('MANUAL');
+ expect(comp.currentSyncPublications).toBe('ALL');
+ expect(comp.currentSyncFunding).toBe('DISABLED');
+ });
+
+ describe('form submit', () => {
+ beforeEach(() => {
+ scheduler = getTestScheduler();
+ notificationsService = (comp as any).notificationsService;
+ formGroup = new FormGroup({
+ syncMode: new FormControl('MANUAL'),
+ syncFundings: new FormControl('ALL'),
+ syncPublications: new FormControl('ALL'),
+ syncProfile_BIOGRAPHICAL: new FormControl(true),
+ syncProfile_IDENTIFIERS: new FormControl(true),
+ });
+ spyOn(comp.settingsUpdated, 'emit');
+ });
+
+ it('should call updateByOrcidOperations properly', () => {
+ researcherProfileService.findByRelatedItem.and.returnValue(createSuccessfulRemoteDataObject$(mockResearcherProfile));
+ researcherProfileService.updateByOrcidOperations.and.returnValue(createSuccessfulRemoteDataObject$(mockResearcherProfile));
+ const expectedOps: Operation[] = [
+ {
+ path: '/orcid/mode',
+ op: 'replace',
+ value: 'MANUAL'
+ }, {
+ path: '/orcid/publications',
+ op: 'replace',
+ value: 'ALL'
+ }, {
+ path: '/orcid/fundings',
+ op: 'replace',
+ value: 'ALL'
+ }, {
+ path: '/orcid/profile',
+ op: 'replace',
+ value: 'BIOGRAPHICAL,IDENTIFIERS'
+ }
+ ];
+
+ scheduler.schedule(() => comp.onSubmit(formGroup));
+ scheduler.flush();
+
+ expect(researcherProfileService.updateByOrcidOperations).toHaveBeenCalledWith(mockResearcherProfile, expectedOps);
+ });
+
+ it('should show notification on success', () => {
+ researcherProfileService.findByRelatedItem.and.returnValue(createSuccessfulRemoteDataObject$(mockResearcherProfile));
+ researcherProfileService.updateByOrcidOperations.and.returnValue(createSuccessfulRemoteDataObject$(mockResearcherProfile));
+
+ scheduler.schedule(() => comp.onSubmit(formGroup));
+ scheduler.flush();
+
+ expect(notificationsService.success).toHaveBeenCalled();
+ expect(comp.settingsUpdated.emit).toHaveBeenCalled();
+ });
+
+ it('should show notification on error', () => {
+ researcherProfileService.findByRelatedItem.and.returnValue(createFailedRemoteDataObject$());
+
+ scheduler.schedule(() => comp.onSubmit(formGroup));
+ scheduler.flush();
+
+ expect(notificationsService.error).toHaveBeenCalled();
+ expect(comp.settingsUpdated.emit).not.toHaveBeenCalled();
+ });
+
+ it('should show notification on error', () => {
+ researcherProfileService.findByRelatedItem.and.returnValue(createSuccessfulRemoteDataObject$(mockResearcherProfile));
+ researcherProfileService.updateByOrcidOperations.and.returnValue(createFailedRemoteDataObject$());
+
+ scheduler.schedule(() => comp.onSubmit(formGroup));
+ scheduler.flush();
+
+ expect(notificationsService.error).toHaveBeenCalled();
+ expect(comp.settingsUpdated.emit).not.toHaveBeenCalled();
+ });
+ });
+
+});
diff --git a/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.ts b/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.ts
new file mode 100644
index 0000000000..6e8b0c8216
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.ts
@@ -0,0 +1,196 @@
+import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+
+import { TranslateService } from '@ngx-translate/core';
+import { Operation } from 'fast-json-patch';
+import { of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+
+import { RemoteData } from '../../../core/data/remote-data';
+import { ResearcherProfileService } from '../../../core/profile/researcher-profile.service';
+import { Item } from '../../../core/shared/item.model';
+import { getFirstCompletedRemoteData } from '../../../core/shared/operators';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { ResearcherProfile } from '../../../core/profile/model/researcher-profile.model';
+
+@Component({
+ selector: 'ds-orcid-sync-setting',
+ templateUrl: './orcid-sync-settings.component.html',
+ styleUrls: ['./orcid-sync-settings.component.scss']
+})
+export class OrcidSyncSettingsComponent implements OnInit {
+
+ /**
+ * The item for which showing the orcid settings
+ */
+ @Input() item: Item;
+
+ /**
+ * The prefix used for i18n keys
+ */
+ messagePrefix = 'person.page.orcid';
+
+ /**
+ * The current synchronization mode
+ */
+ currentSyncMode: string;
+
+ /**
+ * The current synchronization mode for publications
+ */
+ currentSyncPublications: string;
+
+ /**
+ * The current synchronization mode for funding
+ */
+ currentSyncFunding: string;
+
+ /**
+ * The synchronization options
+ */
+ syncModes: { value: string, label: string }[];
+
+ /**
+ * The synchronization options for publications
+ */
+ syncPublicationOptions: { value: string, label: string }[];
+
+ /**
+ * The synchronization options for funding
+ */
+ syncFundingOptions: { value: string, label: string }[];
+
+ /**
+ * The profile synchronization options
+ */
+ syncProfileOptions: { value: string, label: string, checked: boolean }[];
+
+ /**
+ * An event emitted when settings are updated
+ */
+ @Output() settingsUpdated: EventEmitter = new EventEmitter();
+
+ constructor(private researcherProfileService: ResearcherProfileService,
+ private notificationsService: NotificationsService,
+ private translateService: TranslateService) {
+ }
+
+ /**
+ * Init orcid settings form
+ */
+ ngOnInit() {
+ this.syncModes = [
+ {
+ label: this.messagePrefix + '.synchronization-mode.batch',
+ value: 'BATCH'
+ },
+ {
+ label: this.messagePrefix + '.synchronization-mode.manual',
+ value: 'MANUAL'
+ }
+ ];
+
+ this.syncPublicationOptions = ['DISABLED', 'ALL']
+ .map((value) => {
+ return {
+ label: this.messagePrefix + '.sync-publications.' + value.toLowerCase(),
+ value: value,
+ };
+ });
+
+ this.syncFundingOptions = ['DISABLED', 'ALL']
+ .map((value) => {
+ return {
+ label: this.messagePrefix + '.sync-fundings.' + value.toLowerCase(),
+ value: value,
+ };
+ });
+
+ const syncProfilePreferences = this.item.allMetadataValues('dspace.orcid.sync-profile');
+
+ this.syncProfileOptions = ['BIOGRAPHICAL', 'IDENTIFIERS']
+ .map((value) => {
+ return {
+ label: this.messagePrefix + '.sync-profile.' + value.toLowerCase(),
+ value: value,
+ checked: syncProfilePreferences.includes(value)
+ };
+ });
+
+ this.currentSyncMode = this.getCurrentPreference('dspace.orcid.sync-mode', ['BATCH', 'MANUAL'], 'MANUAL');
+ this.currentSyncPublications = this.getCurrentPreference('dspace.orcid.sync-publications', ['DISABLED', 'ALL'], 'DISABLED');
+ this.currentSyncFunding = this.getCurrentPreference('dspace.orcid.sync-fundings', ['DISABLED', 'ALL'], 'DISABLED');
+ }
+
+ /**
+ * Generate path operations to save orcid synchronization preferences
+ *
+ * @param form The form group
+ */
+ onSubmit(form: FormGroup): void {
+ const operations: Operation[] = [];
+ this.fillOperationsFor(operations, '/orcid/mode', form.value.syncMode);
+ this.fillOperationsFor(operations, '/orcid/publications', form.value.syncPublications);
+ this.fillOperationsFor(operations, '/orcid/fundings', form.value.syncFundings);
+
+ const syncProfileValue = this.syncProfileOptions
+ .map((syncProfileOption => syncProfileOption.value))
+ .filter((value) => form.value['syncProfile_' + value])
+ .join(',');
+
+ this.fillOperationsFor(operations, '/orcid/profile', syncProfileValue);
+
+ if (operations.length === 0) {
+ return;
+ }
+
+ this.researcherProfileService.findByRelatedItem(this.item).pipe(
+ getFirstCompletedRemoteData(),
+ switchMap((profileRD: RemoteData) => {
+ if (profileRD.hasSucceeded) {
+ return this.researcherProfileService.updateByOrcidOperations(profileRD.payload, operations).pipe(
+ getFirstCompletedRemoteData()
+ );
+ } else {
+ return of(profileRD);
+ }
+ }),
+ ).subscribe((remoteData: RemoteData) => {
+ if (remoteData.isSuccess) {
+ this.notificationsService.success(this.translateService.get(this.messagePrefix + '.synchronization-settings-update.success'));
+ this.settingsUpdated.emit();
+ } else {
+ this.notificationsService.error(this.translateService.get(this.messagePrefix + '.synchronization-settings-update.error'));
+ }
+ });
+ }
+
+ /**
+ * Retrieve setting saved in the item's metadata
+ *
+ * @param metadataField The metadata name that contains setting
+ * @param allowedValues The allowed values
+ * @param defaultValue The default value
+ * @private
+ */
+ private getCurrentPreference(metadataField: string, allowedValues: string[], defaultValue: string): string {
+ const currentPreference = this.item.firstMetadataValue(metadataField);
+ return (currentPreference && allowedValues.includes(currentPreference)) ? currentPreference : defaultValue;
+ }
+
+ /**
+ * Generate a replace patch operation
+ *
+ * @param operations
+ * @param path
+ * @param currentValue
+ */
+ private fillOperationsFor(operations: Operation[], path: string, currentValue: string): void {
+ operations.push({
+ path: path,
+ op: 'replace',
+ value: currentValue
+ });
+ }
+
+}
diff --git a/src/app/page-error/page-error.component.html b/src/app/page-error/page-error.component.html
new file mode 100644
index 0000000000..9a5f02600a
--- /dev/null
+++ b/src/app/page-error/page-error.component.html
@@ -0,0 +1,10 @@
+;
+ const activatedRouteStub = Object.assign(new ActivatedRouteStub(), {
+ queryParams: observableOf({
+ status: 401,
+ code: 'orcid.generic-error'
+ })
+ });
+ beforeEach(waitForAsync(() => {
+ TestBed.configureTestingModule({
+ declarations: [ PageErrorComponent ],
+ imports: [
+ TranslateModule.forRoot({
+ loader: {
+ provide: TranslateLoader,
+ useClass: TranslateLoaderMock
+ }
+ })
+ ],
+ providers: [
+ { provide: ActivatedRoute, useValue: activatedRouteStub },
+ ]
+ }).compileComponents();
+
+ fixture = TestBed.createComponent(PageErrorComponent);
+ component = fixture.componentInstance;
+ fixture.detectChanges();
+ }));
+
+ it('should create', () => {
+ expect(component).toBeTruthy();
+ });
+
+ it('should show error for 401 unauthorized', () => {
+ const statusElement = fixture.debugElement.query(By.css('[data-test="status"]')).nativeElement;
+ expect(statusElement.innerHTML).toEqual('401');
+ });
+});
diff --git a/src/app/page-error/page-error.component.ts b/src/app/page-error/page-error.component.ts
new file mode 100644
index 0000000000..dea1b68407
--- /dev/null
+++ b/src/app/page-error/page-error.component.ts
@@ -0,0 +1,27 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+
+/**
+ * This component representing the `PageError` DSpace page.
+ */
+@Component({
+ selector: 'ds-page-error',
+ styleUrls: ['./page-error.component.scss'],
+ templateUrl: './page-error.component.html',
+ changeDetection: ChangeDetectionStrategy.Default
+})
+export class PageErrorComponent {
+ status: number;
+ code: string;
+ /**
+ * Initialize instance variables
+ *
+ * @param {ActivatedRoute} activatedRoute
+ */
+ constructor(private activatedRoute: ActivatedRoute) {
+ this.activatedRoute.queryParams.subscribe((params) => {
+ this.status = params.status;
+ this.code = params.code;
+ });
+ }
+}
diff --git a/src/app/page-error/themed-page-error.component.ts b/src/app/page-error/themed-page-error.component.ts
new file mode 100644
index 0000000000..34d29fb2a9
--- /dev/null
+++ b/src/app/page-error/themed-page-error.component.ts
@@ -0,0 +1,26 @@
+import { Component } from '@angular/core';
+import { ThemedComponent } from '../shared/theme-support/themed.component';
+import { PageErrorComponent } from './page-error.component';
+
+/**
+ * Themed wrapper for PageErrorComponent
+ */
+@Component({
+ selector: 'ds-themed-search-page',
+ styleUrls: [],
+ templateUrl: '../shared/theme-support/themed.component.html',
+})
+export class ThemedPageErrorComponent extends ThemedComponent {
+
+ protected getComponentName(): string {
+ return 'PageErrorComponent';
+ }
+
+ protected importThemedComponent(themeName: string): Promise {
+ return import(`../../themes/${themeName}/app/page-error/page-error.component`);
+ }
+
+ protected importUnthemedComponent(): Promise {
+ return import(`src/app/page-error/page-error.component`);
+ }
+}
diff --git a/src/app/root.module.ts b/src/app/root.module.ts
index e5a8aad949..8577f0d728 100644
--- a/src/app/root.module.ts
+++ b/src/app/root.module.ts
@@ -40,6 +40,8 @@ import {
import {
PageInternalServerErrorComponent
} from './page-internal-server-error/page-internal-server-error.component';
+import { ThemedPageErrorComponent } from './page-error/themed-page-error.component';
+import { PageErrorComponent } from './page-error/page-error.component';
const IMPORTS = [
CommonModule,
@@ -74,7 +76,9 @@ const DECLARATIONS = [
ThemedForbiddenComponent,
IdleModalComponent,
ThemedPageInternalServerErrorComponent,
- PageInternalServerErrorComponent
+ PageInternalServerErrorComponent,
+ ThemedPageErrorComponent,
+ PageErrorComponent
];
const EXPORTS = [
diff --git a/src/app/shared/dso-page/dso-page-edit-button/dso-page-edit-button.component.scss b/src/app/shared/dso-page/dso-page-edit-button/dso-page-edit-button.component.scss
index e8b7d689a3..8b13789179 100644
--- a/src/app/shared/dso-page/dso-page-edit-button/dso-page-edit-button.component.scss
+++ b/src/app/shared/dso-page/dso-page-edit-button/dso-page-edit-button.component.scss
@@ -1,3 +1 @@
-.btn-dark {
- background-color: var(--ds-admin-sidebar-bg);
-}
+
diff --git a/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.html b/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.html
new file mode 100644
index 0000000000..305900ae33
--- /dev/null
+++ b/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.html
@@ -0,0 +1,6 @@
+
+
diff --git a/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.scss b/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.scss
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.spec.ts b/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.spec.ts
new file mode 100644
index 0000000000..c70ec4b808
--- /dev/null
+++ b/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.spec.ts
@@ -0,0 +1,76 @@
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { DSpaceObject } from '../../../core/shared/dspace-object.model';
+import { Item } from '../../../core/shared/item.model';
+import { AuthorizationDataService } from '../../../core/data/feature-authorization/authorization-data.service';
+import { of as observableOf } from 'rxjs';
+import { TranslateModule } from '@ngx-translate/core';
+import { RouterTestingModule } from '@angular/router/testing';
+import { FeatureID } from '../../../core/data/feature-authorization/feature-id';
+import { By } from '@angular/platform-browser';
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+import { DsoPageOrcidButtonComponent } from './dso-page-orcid-button.component';
+
+describe('DsoPageOrcidButtonComponent', () => {
+ let component: DsoPageOrcidButtonComponent;
+ let fixture: ComponentFixture;
+
+ let authorizationService: AuthorizationDataService;
+ let dso: DSpaceObject;
+
+ beforeEach(waitForAsync(() => {
+ dso = Object.assign(new Item(), {
+ id: 'test-item',
+ _links: {
+ self: { href: 'test-item-selflink' }
+ }
+ });
+ authorizationService = jasmine.createSpyObj('authorizationService', {
+ isAuthorized: observableOf(true)
+ });
+ TestBed.configureTestingModule({
+ declarations: [DsoPageOrcidButtonComponent],
+ imports: [TranslateModule.forRoot(), RouterTestingModule.withRoutes([]), NgbModule],
+ providers: [
+ { provide: AuthorizationDataService, useValue: authorizationService }
+ ]
+ }).compileComponents();
+ }));
+
+ beforeEach(() => {
+ fixture = TestBed.createComponent(DsoPageOrcidButtonComponent);
+ component = fixture.componentInstance;
+ component.dso = dso;
+ component.pageRoute = 'test';
+ fixture.detectChanges();
+ });
+
+ it('should check the authorization of the current user', () => {
+ expect(authorizationService.isAuthorized).toHaveBeenCalledWith(FeatureID.CanSynchronizeWithORCID, dso.self);
+ });
+
+ describe('when the user is authorized', () => {
+ beforeEach(() => {
+ (authorizationService.isAuthorized as jasmine.Spy).and.returnValue(observableOf(true));
+ component.ngOnInit();
+ fixture.detectChanges();
+ });
+
+ it('should render a link', () => {
+ const link = fixture.debugElement.query(By.css('a'));
+ expect(link).not.toBeNull();
+ });
+ });
+
+ describe('when the user is not authorized', () => {
+ beforeEach(() => {
+ (authorizationService.isAuthorized as jasmine.Spy).and.returnValue(observableOf(false));
+ component.ngOnInit();
+ fixture.detectChanges();
+ });
+
+ it('should not render a link', () => {
+ const link = fixture.debugElement.query(By.css('a'));
+ expect(link).toBeNull();
+ });
+ });
+});
diff --git a/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.ts b/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.ts
new file mode 100644
index 0000000000..c345d8cbdc
--- /dev/null
+++ b/src/app/shared/dso-page/dso-page-orcid-button/dso-page-orcid-button.component.ts
@@ -0,0 +1,39 @@
+import { Component, Input, OnInit } from '@angular/core';
+
+import { BehaviorSubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+
+import { AuthorizationDataService } from '../../../core/data/feature-authorization/authorization-data.service';
+import { FeatureID } from '../../../core/data/feature-authorization/feature-id';
+import { DSpaceObject } from '../../../core/shared/dspace-object.model';
+
+@Component({
+ selector: 'ds-dso-page-orcid-button',
+ templateUrl: './dso-page-orcid-button.component.html',
+ styleUrls: ['./dso-page-orcid-button.component.scss']
+})
+export class DsoPageOrcidButtonComponent implements OnInit {
+ /**
+ * The DSpaceObject to display a button to the edit page for
+ */
+ @Input() dso: DSpaceObject;
+
+ /**
+ * The prefix of the route to the edit page (before the object's UUID, e.g. "items")
+ */
+ @Input() pageRoute: string;
+
+ /**
+ * Whether or not the current user is authorized to edit the DSpaceObject
+ */
+ isAuthorized: BehaviorSubject = new BehaviorSubject(false);
+
+ constructor(protected authorizationService: AuthorizationDataService) { }
+
+ ngOnInit() {
+ this.authorizationService.isAuthorized(FeatureID.CanSynchronizeWithORCID, this.dso.self).pipe(take(1)).subscribe((isAuthorized: boolean) => {
+ this.isAuthorized.next(isAuthorized);
+ });
+ }
+
+}
diff --git a/src/app/shared/dso-page/person-page-claim-button/person-page-claim-button.component.html b/src/app/shared/dso-page/person-page-claim-button/person-page-claim-button.component.html
index 12d5d2b47d..c4bba286bf 100644
--- a/src/app/shared/dso-page/person-page-claim-button/person-page-claim-button.component.html
+++ b/src/app/shared/dso-page/person-page-claim-button/person-page-claim-button.component.html
@@ -1 +1,7 @@
-
+
diff --git a/src/app/shared/log-in/methods/log-in-external-provider.component.ts b/src/app/shared/log-in/methods/log-in-external-provider.component.ts
new file mode 100644
index 0000000000..037fc40e90
--- /dev/null
+++ b/src/app/shared/log-in/methods/log-in-external-provider.component.ts
@@ -0,0 +1,110 @@
+import { Component, Inject, OnInit, } from '@angular/core';
+
+import { Observable } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { select, Store } from '@ngrx/store';
+
+import { AuthMethod } from '../../../core/auth/models/auth.method';
+
+import { isAuthenticated, isAuthenticationLoading } from '../../../core/auth/selectors';
+import { NativeWindowRef, NativeWindowService } from '../../../core/services/window.service';
+import { isEmpty, isNotNull } from '../../empty.util';
+import { AuthService } from '../../../core/auth/auth.service';
+import { HardRedirectService } from '../../../core/services/hard-redirect.service';
+import { URLCombiner } from '../../../core/url-combiner/url-combiner';
+import { CoreState } from '../../../core/core-state.model';
+
+@Component({
+ selector: 'ds-log-in-external-provider',
+ template: ''
+
+})
+export abstract class LogInExternalProviderComponent implements OnInit {
+
+ /**
+ * The authentication method data.
+ * @type {AuthMethod}
+ */
+ public authMethod: AuthMethod;
+
+ /**
+ * True if the authentication is loading.
+ * @type {boolean}
+ */
+ public loading: Observable;
+
+ /**
+ * The shibboleth authentication location url.
+ * @type {string}
+ */
+ public location: string;
+
+ /**
+ * Whether user is authenticated.
+ * @type {Observable}
+ */
+ public isAuthenticated: Observable;
+
+ /**
+ * @constructor
+ * @param {AuthMethod} injectedAuthMethodModel
+ * @param {boolean} isStandalonePage
+ * @param {NativeWindowRef} _window
+ * @param {AuthService} authService
+ * @param {HardRedirectService} hardRedirectService
+ * @param {Store} store
+ */
+ constructor(
+ @Inject('authMethodProvider') public injectedAuthMethodModel: AuthMethod,
+ @Inject('isStandalonePage') public isStandalonePage: boolean,
+ @Inject(NativeWindowService) protected _window: NativeWindowRef,
+ private authService: AuthService,
+ private hardRedirectService: HardRedirectService,
+ private store: Store
+ ) {
+ this.authMethod = injectedAuthMethodModel;
+ }
+
+ ngOnInit(): void {
+ // set isAuthenticated
+ this.isAuthenticated = this.store.pipe(select(isAuthenticated));
+
+ // set loading
+ this.loading = this.store.pipe(select(isAuthenticationLoading));
+
+ // set location
+ this.location = decodeURIComponent(this.injectedAuthMethodModel.location);
+
+ }
+
+ /**
+ * Redirect to the external provider url for login
+ */
+ redirectToExternalProvider() {
+ this.authService.getRedirectUrl().pipe(take(1)).subscribe((redirectRoute) => {
+ if (!this.isStandalonePage) {
+ redirectRoute = this.hardRedirectService.getCurrentRoute();
+ } else if (isEmpty(redirectRoute)) {
+ redirectRoute = '/';
+ }
+ const correctRedirectUrl = new URLCombiner(this._window.nativeWindow.origin, redirectRoute).toString();
+
+ let externalServerUrl = this.location;
+ const myRegexp = /\?redirectUrl=(.*)/g;
+ const match = myRegexp.exec(this.location);
+ const redirectUrlFromServer = (match && match[1]) ? match[1] : null;
+
+ // Check whether the current page is different from the redirect url received from rest
+ if (isNotNull(redirectUrlFromServer) && redirectUrlFromServer !== correctRedirectUrl) {
+ // change the redirect url with the current page url
+ const newRedirectUrl = `?redirectUrl=${correctRedirectUrl}`;
+ externalServerUrl = this.location.replace(/\?redirectUrl=(.*)/g, newRedirectUrl);
+ }
+
+ // redirect to shibboleth authentication url
+ this.hardRedirectService.redirect(externalServerUrl);
+ });
+
+ }
+
+}
diff --git a/src/app/shared/log-in/methods/oidc/log-in-oidc.component.ts b/src/app/shared/log-in/methods/oidc/log-in-oidc.component.ts
index 38cedf91ec..882996b207 100644
--- a/src/app/shared/log-in/methods/oidc/log-in-oidc.component.ts
+++ b/src/app/shared/log-in/methods/oidc/log-in-oidc.component.ts
@@ -1,110 +1,21 @@
-import { Component, Inject, OnInit, } from '@angular/core';
-
-import { Observable } from 'rxjs';
-import { select, Store } from '@ngrx/store';
+import { Component, } from '@angular/core';
import { renderAuthMethodFor } from '../log-in.methods-decorator';
import { AuthMethodType } from '../../../../core/auth/models/auth.method-type';
-import { AuthMethod } from '../../../../core/auth/models/auth.method';
-
-import { isAuthenticated, isAuthenticationLoading } from '../../../../core/auth/selectors';
-import { NativeWindowRef, NativeWindowService } from '../../../../core/services/window.service';
-import { isNotNull, isEmpty } from '../../../empty.util';
-import { AuthService } from '../../../../core/auth/auth.service';
-import { HardRedirectService } from '../../../../core/services/hard-redirect.service';
-import { take } from 'rxjs/operators';
-import { URLCombiner } from '../../../../core/url-combiner/url-combiner';
-import { CoreState } from '../../../../core/core-state.model';
+import { LogInExternalProviderComponent } from '../log-in-external-provider.component';
@Component({
selector: 'ds-log-in-oidc',
templateUrl: './log-in-oidc.component.html',
})
@renderAuthMethodFor(AuthMethodType.Oidc)
-export class LogInOidcComponent implements OnInit {
+export class LogInOidcComponent extends LogInExternalProviderComponent {
/**
- * The authentication method data.
- * @type {AuthMethod}
+ * Redirect to orcid authentication url
*/
- public authMethod: AuthMethod;
-
- /**
- * True if the authentication is loading.
- * @type {boolean}
- */
- public loading: Observable;
-
- /**
- * The oidc authentication location url.
- * @type {string}
- */
- public location: string;
-
- /**
- * Whether user is authenticated.
- * @type {Observable}
- */
- public isAuthenticated: Observable;
-
- /**
- * @constructor
- * @param {AuthMethod} injectedAuthMethodModel
- * @param {boolean} isStandalonePage
- * @param {NativeWindowRef} _window
- * @param {AuthService} authService
- * @param {HardRedirectService} hardRedirectService
- * @param {Store} store
- */
- constructor(
- @Inject('authMethodProvider') public injectedAuthMethodModel: AuthMethod,
- @Inject('isStandalonePage') public isStandalonePage: boolean,
- @Inject(NativeWindowService) protected _window: NativeWindowRef,
- private authService: AuthService,
- private hardRedirectService: HardRedirectService,
- private store: Store
- ) {
- this.authMethod = injectedAuthMethodModel;
- }
-
- ngOnInit(): void {
- // set isAuthenticated
- this.isAuthenticated = this.store.pipe(select(isAuthenticated));
-
- // set loading
- this.loading = this.store.pipe(select(isAuthenticationLoading));
-
- // set location
- this.location = decodeURIComponent(this.injectedAuthMethodModel.location);
-
- }
-
redirectToOidc() {
-
- this.authService.getRedirectUrl().pipe(take(1)).subscribe((redirectRoute) => {
- if (!this.isStandalonePage) {
- redirectRoute = this.hardRedirectService.getCurrentRoute();
- } else if (isEmpty(redirectRoute)) {
- redirectRoute = '/';
- }
- const correctRedirectUrl = new URLCombiner(this._window.nativeWindow.origin, redirectRoute).toString();
-
- let oidcServerUrl = this.location;
- const myRegexp = /\?redirectUrl=(.*)/g;
- const match = myRegexp.exec(this.location);
- const redirectUrlFromServer = (match && match[1]) ? match[1] : null;
-
- // Check whether the current page is different from the redirect url received from rest
- if (isNotNull(redirectUrlFromServer) && redirectUrlFromServer !== correctRedirectUrl) {
- // change the redirect url with the current page url
- const newRedirectUrl = `?redirectUrl=${correctRedirectUrl}`;
- oidcServerUrl = this.location.replace(/\?redirectUrl=(.*)/g, newRedirectUrl);
- }
-
- // redirect to oidc authentication url
- this.hardRedirectService.redirect(oidcServerUrl);
- });
-
+ this.redirectToExternalProvider();
}
}
diff --git a/src/app/shared/log-in/methods/orcid/log-in-orcid.component.html b/src/app/shared/log-in/methods/orcid/log-in-orcid.component.html
new file mode 100644
index 0000000000..6f5453fd60
--- /dev/null
+++ b/src/app/shared/log-in/methods/orcid/log-in-orcid.component.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/src/app/shared/log-in/methods/orcid/log-in-orcid.component.spec.ts b/src/app/shared/log-in/methods/orcid/log-in-orcid.component.spec.ts
new file mode 100644
index 0000000000..001f0a4959
--- /dev/null
+++ b/src/app/shared/log-in/methods/orcid/log-in-orcid.component.spec.ts
@@ -0,0 +1,155 @@
+import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+
+import { provideMockStore } from '@ngrx/store/testing';
+import { Store, StoreModule } from '@ngrx/store';
+import { TranslateModule } from '@ngx-translate/core';
+
+import { EPerson } from '../../../../core/eperson/models/eperson.model';
+import { EPersonMock } from '../../../testing/eperson.mock';
+import { authReducer } from '../../../../core/auth/auth.reducer';
+import { AuthService } from '../../../../core/auth/auth.service';
+import { AuthServiceStub } from '../../../testing/auth-service.stub';
+import { storeModuleConfig } from '../../../../app.reducer';
+import { AuthMethod } from '../../../../core/auth/models/auth.method';
+import { AuthMethodType } from '../../../../core/auth/models/auth.method-type';
+import { LogInOrcidComponent } from './log-in-orcid.component';
+import { NativeWindowService } from '../../../../core/services/window.service';
+import { RouterStub } from '../../../testing/router.stub';
+import { ActivatedRouteStub } from '../../../testing/active-router.stub';
+import { NativeWindowMockFactory } from '../../../mocks/mock-native-window-ref';
+import { HardRedirectService } from '../../../../core/services/hard-redirect.service';
+
+
+describe('LogInOrcidComponent', () => {
+
+ let component: LogInOrcidComponent;
+ let fixture: ComponentFixture;
+ let page: Page;
+ let user: EPerson;
+ let componentAsAny: any;
+ let setHrefSpy;
+ let orcidBaseUrl;
+ let location;
+ let initialState: any;
+ let hardRedirectService: HardRedirectService;
+
+ beforeEach(() => {
+ user = EPersonMock;
+ orcidBaseUrl = 'dspace-rest.test/orcid?redirectUrl=';
+ location = orcidBaseUrl + 'http://dspace-angular.test/home';
+
+ hardRedirectService = jasmine.createSpyObj('hardRedirectService', {
+ getCurrentRoute: {},
+ redirect: {}
+ });
+
+ initialState = {
+ core: {
+ auth: {
+ authenticated: false,
+ loaded: false,
+ blocking: false,
+ loading: false,
+ authMethods: []
+ }
+ }
+ };
+ });
+
+ beforeEach(waitForAsync(() => {
+ // refine the test module by declaring the test component
+ TestBed.configureTestingModule({
+ imports: [
+ StoreModule.forRoot({ auth: authReducer }, storeModuleConfig),
+ TranslateModule.forRoot()
+ ],
+ declarations: [
+ LogInOrcidComponent
+ ],
+ providers: [
+ { provide: AuthService, useClass: AuthServiceStub },
+ { provide: 'authMethodProvider', useValue: new AuthMethod(AuthMethodType.Orcid, location) },
+ { provide: 'isStandalonePage', useValue: true },
+ { provide: NativeWindowService, useFactory: NativeWindowMockFactory },
+ { provide: Router, useValue: new RouterStub() },
+ { provide: ActivatedRoute, useValue: new ActivatedRouteStub() },
+ { provide: HardRedirectService, useValue: hardRedirectService },
+ provideMockStore({ initialState }),
+ ],
+ schemas: [
+ CUSTOM_ELEMENTS_SCHEMA
+ ]
+ })
+ .compileComponents();
+
+ }));
+
+ beforeEach(() => {
+ // create component and test fixture
+ fixture = TestBed.createComponent(LogInOrcidComponent);
+
+ // get test component from the fixture
+ component = fixture.componentInstance;
+ componentAsAny = component;
+
+ // create page
+ page = new Page(component, fixture);
+ setHrefSpy = spyOnProperty(componentAsAny._window.nativeWindow.location, 'href', 'set').and.callThrough();
+
+ });
+
+ it('should set the properly a new redirectUrl', () => {
+ const currentUrl = 'http://dspace-angular.test/collections/12345';
+ componentAsAny._window.nativeWindow.location.href = currentUrl;
+
+ fixture.detectChanges();
+
+ expect(componentAsAny.injectedAuthMethodModel.location).toBe(location);
+ expect(componentAsAny._window.nativeWindow.location.href).toBe(currentUrl);
+
+ component.redirectToOrcid();
+
+ expect(setHrefSpy).toHaveBeenCalledWith(currentUrl);
+
+ });
+
+ it('should not set a new redirectUrl', () => {
+ const currentUrl = 'http://dspace-angular.test/home';
+ componentAsAny._window.nativeWindow.location.href = currentUrl;
+
+ fixture.detectChanges();
+
+ expect(componentAsAny.injectedAuthMethodModel.location).toBe(location);
+ expect(componentAsAny._window.nativeWindow.location.href).toBe(currentUrl);
+
+ component.redirectToOrcid();
+
+ expect(setHrefSpy).toHaveBeenCalledWith(currentUrl);
+
+ });
+
+});
+
+/**
+ * I represent the DOM elements and attach spies.
+ *
+ * @class Page
+ */
+class Page {
+
+ public emailInput: HTMLInputElement;
+ public navigateSpy: jasmine.Spy;
+ public passwordInput: HTMLInputElement;
+
+ constructor(private component: LogInOrcidComponent, private fixture: ComponentFixture) {
+ // use injector to get services
+ const injector = fixture.debugElement.injector;
+ const store = injector.get(Store);
+
+ // add spies
+ this.navigateSpy = spyOn(store, 'dispatch');
+ }
+
+}
diff --git a/src/app/shared/log-in/methods/orcid/log-in-orcid.component.ts b/src/app/shared/log-in/methods/orcid/log-in-orcid.component.ts
new file mode 100644
index 0000000000..e0b1da3db5
--- /dev/null
+++ b/src/app/shared/log-in/methods/orcid/log-in-orcid.component.ts
@@ -0,0 +1,21 @@
+import { Component, } from '@angular/core';
+
+import { renderAuthMethodFor } from '../log-in.methods-decorator';
+import { AuthMethodType } from '../../../../core/auth/models/auth.method-type';
+import { LogInExternalProviderComponent } from '../log-in-external-provider.component';
+
+@Component({
+ selector: 'ds-log-in-orcid',
+ templateUrl: './log-in-orcid.component.html',
+})
+@renderAuthMethodFor(AuthMethodType.Orcid)
+export class LogInOrcidComponent extends LogInExternalProviderComponent {
+
+ /**
+ * Redirect to orcid authentication url
+ */
+ redirectToOrcid() {
+ this.redirectToExternalProvider();
+ }
+
+}
diff --git a/src/app/shared/log-in/methods/shibboleth/log-in-shibboleth.component.ts b/src/app/shared/log-in/methods/shibboleth/log-in-shibboleth.component.ts
index d218a7ca4e..dcfb3ccfc3 100644
--- a/src/app/shared/log-in/methods/shibboleth/log-in-shibboleth.component.ts
+++ b/src/app/shared/log-in/methods/shibboleth/log-in-shibboleth.component.ts
@@ -1,21 +1,8 @@
-import { Component, Inject, OnInit, } from '@angular/core';
-
-import { Observable } from 'rxjs';
-import { select, Store } from '@ngrx/store';
+import { Component, } from '@angular/core';
import { renderAuthMethodFor } from '../log-in.methods-decorator';
import { AuthMethodType } from '../../../../core/auth/models/auth.method-type';
-import { AuthMethod } from '../../../../core/auth/models/auth.method';
-
-import { isAuthenticated, isAuthenticationLoading } from '../../../../core/auth/selectors';
-import { RouteService } from '../../../../core/services/route.service';
-import { NativeWindowRef, NativeWindowService } from '../../../../core/services/window.service';
-import { isNotNull, isEmpty } from '../../../empty.util';
-import { AuthService } from '../../../../core/auth/auth.service';
-import { HardRedirectService } from '../../../../core/services/hard-redirect.service';
-import { take } from 'rxjs/operators';
-import { URLCombiner } from '../../../../core/url-combiner/url-combiner';
-import { CoreState } from '../../../../core/core-state.model';
+import { LogInExternalProviderComponent } from '../log-in-external-provider.component';
@Component({
selector: 'ds-log-in-shibboleth',
@@ -24,92 +11,13 @@ import { CoreState } from '../../../../core/core-state.model';
})
@renderAuthMethodFor(AuthMethodType.Shibboleth)
-export class LogInShibbolethComponent implements OnInit {
+export class LogInShibbolethComponent extends LogInExternalProviderComponent {
/**
- * The authentication method data.
- * @type {AuthMethod}
+ * Redirect to shibboleth authentication url
*/
- public authMethod: AuthMethod;
-
- /**
- * True if the authentication is loading.
- * @type {boolean}
- */
- public loading: Observable;
-
- /**
- * The shibboleth authentication location url.
- * @type {string}
- */
- public location: string;
-
- /**
- * Whether user is authenticated.
- * @type {Observable}
- */
- public isAuthenticated: Observable;
-
- /**
- * @constructor
- * @param {AuthMethod} injectedAuthMethodModel
- * @param {boolean} isStandalonePage
- * @param {NativeWindowRef} _window
- * @param {RouteService} route
- * @param {AuthService} authService
- * @param {HardRedirectService} hardRedirectService
- * @param {Store} store
- */
- constructor(
- @Inject('authMethodProvider') public injectedAuthMethodModel: AuthMethod,
- @Inject('isStandalonePage') public isStandalonePage: boolean,
- @Inject(NativeWindowService) protected _window: NativeWindowRef,
- private route: RouteService,
- private authService: AuthService,
- private hardRedirectService: HardRedirectService,
- private store: Store
- ) {
- this.authMethod = injectedAuthMethodModel;
- }
-
- ngOnInit(): void {
- // set isAuthenticated
- this.isAuthenticated = this.store.pipe(select(isAuthenticated));
-
- // set loading
- this.loading = this.store.pipe(select(isAuthenticationLoading));
-
- // set location
- this.location = decodeURIComponent(this.injectedAuthMethodModel.location);
-
- }
-
redirectToShibboleth() {
-
- this.authService.getRedirectUrl().pipe(take(1)).subscribe((redirectRoute) => {
- if (!this.isStandalonePage) {
- redirectRoute = this.hardRedirectService.getCurrentRoute();
- } else if (isEmpty(redirectRoute)) {
- redirectRoute = '/';
- }
- const correctRedirectUrl = new URLCombiner(this._window.nativeWindow.origin, redirectRoute).toString();
-
- let shibbolethServerUrl = this.location;
- const myRegexp = /\?redirectUrl=(.*)/g;
- const match = myRegexp.exec(this.location);
- const redirectUrlFromServer = (match && match[1]) ? match[1] : null;
-
- // Check whether the current page is different from the redirect url received from rest
- if (isNotNull(redirectUrlFromServer) && redirectUrlFromServer !== correctRedirectUrl) {
- // change the redirect url with the current page url
- const newRedirectUrl = `?redirectUrl=${correctRedirectUrl}`;
- shibbolethServerUrl = this.location.replace(/\?redirectUrl=(.*)/g, newRedirectUrl);
- }
-
- // redirect to shibboleth authentication url
- this.hardRedirectService.redirect(shibbolethServerUrl);
- });
-
+ this.redirectToExternalProvider();
}
}
diff --git a/src/app/shared/mocks/router.mock.ts b/src/app/shared/mocks/router.mock.ts
index eb260af6b4..98a63363b6 100644
--- a/src/app/shared/mocks/router.mock.ts
+++ b/src/app/shared/mocks/router.mock.ts
@@ -29,4 +29,8 @@ export class RouterMock {
createUrlTree(commands, navExtras = {}) {
return {};
}
+
+ get url() {
+ return this.routerState.snapshot.url;
+ }
}
diff --git a/src/app/shared/notifications/notification/notification.component.html b/src/app/shared/notifications/notification/notification.component.html
index e8b3d37b5f..befa84cfc0 100644
--- a/src/app/shared/notifications/notification/notification.component.html
+++ b/src/app/shared/notifications/notification/notification.component.html
@@ -1,4 +1,4 @@
-
+
+
+{{'person.orcid.registry.auth' | translate}}
+
+
+ {{ 'person.page.orcid.remove-orcid-message' | translate}}
+
+
+
+
+
+
+
+
+ {{ 'person.page.orcid.granted-authorizations'| translate }}
+
+
+
+
+ -
+
- + {{getAuthorizationDescription(auth) | translate}} + +
+
+
+
+ {{ 'person.page.orcid.missing-authorizations'| translate }}
+
+
+
+
+ {{'person.page.orcid.no-missing-authorizations-message' | translate}}
+
+
+ {{'person.page.orcid.missing-authorizations-message' | translate}}
+
+
+ -
+
- + {{getAuthorizationDescription(auth) | translate }} + +
+
+
+
+
+
+
+
+
+ 
+
+
+ {{ getOrcidNotLinkedMessage() | async }}
+
+
+
+
+
+
+
+
+
+
+
+ {{'person.page.orcid.link.error.message' | translate}}
+
+
+
diff --git a/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.scss b/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.scss
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.spec.ts b/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.spec.ts
new file mode 100644
index 0000000000..4312d35be9
--- /dev/null
+++ b/src/app/item-page/orcid-page/orcid-sync-settings/orcid-sync-settings.component.spec.ts
@@ -0,0 +1,261 @@
+import { ChangeDetectionStrategy, NO_ERRORS_SCHEMA } from '@angular/core';
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { FormControl, FormGroup, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { RouterTestingModule } from '@angular/router/testing';
+import { By } from '@angular/platform-browser';
+
+import { getTestScheduler } from 'jasmine-marbles';
+import { NgbAccordionModule } from '@ng-bootstrap/ng-bootstrap';
+import { TestScheduler } from 'rxjs/testing';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { Operation } from 'fast-json-patch';
+
+import { ResearcherProfileService } from '../../../core/profile/researcher-profile.service';
+import { createFailedRemoteDataObject$, createSuccessfulRemoteDataObject$ } from '../../../shared/remote-data.utils';
+import { Item } from '../../../core/shared/item.model';
+import { createPaginatedList } from '../../../shared/testing/utils.test';
+import { TranslateLoaderMock } from '../../../shared/mocks/translate-loader.mock';
+import { NotificationsService } from '../../../shared/notifications/notifications.service';
+import { NotificationsServiceStub } from '../../../shared/testing/notifications-service.stub';
+import { OrcidSyncSettingsComponent } from './orcid-sync-settings.component';
+import { ResearcherProfile } from '../../../core/profile/model/researcher-profile.model';
+
+describe('OrcidAuthComponent test suite', () => {
+ let comp: OrcidSyncSettingsComponent;
+ let fixture: ComponentFixture{{'person.orcid.sync.setting' | translate}}
+ +
+
+
+ +
diff --git a/src/app/page-error/page-error.component.scss b/src/app/page-error/page-error.component.scss
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/app/page-error/page-error.component.spec.ts b/src/app/page-error/page-error.component.spec.ts
new file mode 100644
index 0000000000..0f876f3196
--- /dev/null
+++ b/src/app/page-error/page-error.component.spec.ts
@@ -0,0 +1,48 @@
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { PageErrorComponent } from './page-error.component';
+import { ActivatedRoute } from '@angular/router';
+import { ActivatedRouteStub } from '../shared/testing/active-router.stub';
+import { of as observableOf } from 'rxjs';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { By } from '@angular/platform-browser';
+import { TranslateLoaderMock } from '../shared/testing/translate-loader.mock';
+
+describe('PageErrorComponent', () => {
+ let component: PageErrorComponent;
+ let fixture: ComponentFixture{{status}}
+{{"error-page.description." + status | translate}}
++
{{"error-page." + code | translate}}
++ +
diff --git a/src/app/shared/notifications/notification/notification.component.scss b/src/app/shared/notifications/notification/notification.component.scss
index 0321644585..06c46b0f5d 100644
--- a/src/app/shared/notifications/notification/notification.component.scss
+++ b/src/app/shared/notifications/notification/notification.component.scss
@@ -1,4 +1,4 @@
-.alert {
+.notification {
display: inline-block;
min-width: var(--bs-modal-sm);
text-align: left;
diff --git a/src/app/shared/search/search-export-csv/search-export-csv.component.html b/src/app/shared/search/search-export-csv/search-export-csv.component.html
new file mode 100644
index 0000000000..7bf8704300
--- /dev/null
+++ b/src/app/shared/search/search-export-csv/search-export-csv.component.html
@@ -0,0 +1,7 @@
+
\ No newline at end of file
diff --git a/src/app/shared/search/search-export-csv/search-export-csv.component.scss b/src/app/shared/search/search-export-csv/search-export-csv.component.scss
new file mode 100644
index 0000000000..4b0ab3c44a
--- /dev/null
+++ b/src/app/shared/search/search-export-csv/search-export-csv.component.scss
@@ -0,0 +1,4 @@
+.export-button {
+ background: var(--ds-admin-sidebar-bg);
+ border-color: var(--ds-admin-sidebar-bg);
+}
\ No newline at end of file
diff --git a/src/app/shared/search/search-export-csv/search-export-csv.component.spec.ts b/src/app/shared/search/search-export-csv/search-export-csv.component.spec.ts
new file mode 100644
index 0000000000..82c15feeac
--- /dev/null
+++ b/src/app/shared/search/search-export-csv/search-export-csv.component.spec.ts
@@ -0,0 +1,182 @@
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { of as observableOf } from 'rxjs';
+import { TranslateModule } from '@ngx-translate/core';
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+import { AuthorizationDataService } from '../../../core/data/feature-authorization/authorization-data.service';
+import { SearchExportCsvComponent } from './search-export-csv.component';
+import { ScriptDataService } from '../../../core/data/processes/script-data.service';
+import { createFailedRemoteDataObject$, createSuccessfulRemoteDataObject$ } from '../../remote-data.utils';
+import { Script } from '../../../process-page/scripts/script.model';
+import { Process } from '../../../process-page/processes/process.model';
+import { NotificationsServiceStub } from '../../testing/notifications-service.stub';
+import { NotificationsService } from '../../notifications/notifications.service';
+import { Router } from '@angular/router';
+import { By } from '@angular/platform-browser';
+import { getProcessDetailRoute } from '../../../process-page/process-page-routing.paths';
+import { SearchFilter } from '../models/search-filter.model';
+import { PaginatedSearchOptions } from '../models/paginated-search-options.model';
+
+describe('SearchExportCsvComponent', () => {
+ let component: SearchExportCsvComponent;
+ let fixture: ComponentFixture;
+
+ let scriptDataService: ScriptDataService;
+ let authorizationDataService: AuthorizationDataService;
+ let notificationsService;
+ let router;
+
+ const script = Object.assign(new Script(), {id: 'metadata-export-search', name: 'metadata-export-search'});
+ const process = Object.assign(new Process(), {processId: 5, scriptName: 'metadata-export-search'});
+
+ const searchConfig = new PaginatedSearchOptions({
+ configuration: 'test-configuration',
+ scope: 'test-scope',
+ query: 'test-query',
+ filters: [
+ new SearchFilter('f.filter1', ['filter1value1,equals', 'filter1value2,equals']),
+ new SearchFilter('f.filter2', ['filter2value1,contains']),
+ new SearchFilter('f.filter3', ['[2000 TO 2001]'], 'equals')
+ ]
+ });
+
+ function initBeforeEachAsync() {
+ scriptDataService = jasmine.createSpyObj('scriptDataService', {
+ findById: createSuccessfulRemoteDataObject$(script),
+ invoke: createSuccessfulRemoteDataObject$(process)
+ });
+ authorizationDataService = jasmine.createSpyObj('authorizationService', {
+ isAuthorized: observableOf(true)
+ });
+
+ notificationsService = new NotificationsServiceStub();
+
+ router = jasmine.createSpyObj('authorizationService', ['navigateByUrl']);
+ TestBed.configureTestingModule({
+ declarations: [SearchExportCsvComponent],
+ imports: [TranslateModule.forRoot(), NgbModule],
+ providers: [
+ {provide: ScriptDataService, useValue: scriptDataService},
+ {provide: AuthorizationDataService, useValue: authorizationDataService},
+ {provide: NotificationsService, useValue: notificationsService},
+ {provide: Router, useValue: router},
+ ]
+ }).compileComponents();
+ }
+
+ function initBeforeEach() {
+ fixture = TestBed.createComponent(SearchExportCsvComponent);
+ component = fixture.componentInstance;
+ component.searchConfig = searchConfig;
+ fixture.detectChanges();
+ }
+
+ describe('init', () => {
+ describe('comp', () => {
+ beforeEach(waitForAsync(() => {
+ initBeforeEachAsync();
+ }));
+ beforeEach(() => {
+ initBeforeEach();
+ });
+ it('should init the comp', () => {
+ expect(component).toBeTruthy();
+ });
+ });
+ describe('when the user is an admin and the metadata-export-search script is present ', () => {
+ beforeEach(waitForAsync(() => {
+ initBeforeEachAsync();
+ }));
+ beforeEach(() => {
+ initBeforeEach();
+ });
+ it('should add the button', () => {
+ const debugElement = fixture.debugElement.query(By.css('button.export-button'));
+ expect(debugElement).toBeDefined();
+ });
+ });
+ describe('when the user is not an admin', () => {
+ beforeEach(waitForAsync(() => {
+ initBeforeEachAsync();
+ (authorizationDataService.isAuthorized as jasmine.Spy).and.returnValue(observableOf(false));
+ }));
+ beforeEach(() => {
+ initBeforeEach();
+ });
+ it('should not add the button', () => {
+ const debugElement = fixture.debugElement.query(By.css('button.export-button'));
+ expect(debugElement).toBeNull();
+ });
+ });
+ describe('when the metadata-export-search script is not present', () => {
+ beforeEach(waitForAsync(() => {
+ initBeforeEachAsync();
+ (scriptDataService.findById as jasmine.Spy).and.returnValue(createFailedRemoteDataObject$('Not found', 404));
+ }));
+ beforeEach(() => {
+ initBeforeEach();
+ });
+ it('should should not add the button', () => {
+ const debugElement = fixture.debugElement.query(By.css('button.export-button'));
+ expect(debugElement).toBeNull();
+ });
+ });
+ });
+ describe('export', () => {
+ beforeEach(waitForAsync(() => {
+ initBeforeEachAsync();
+ }));
+ beforeEach(() => {
+ initBeforeEach();
+ });
+ it('should call the invoke script method with the correct parameters', () => {
+ component.export();
+ expect(scriptDataService.invoke).toHaveBeenCalledWith('metadata-export-search',
+ [
+ {name: '-q', value: searchConfig.query},
+ {name: '-s', value: searchConfig.scope},
+ {name: '-c', value: searchConfig.configuration},
+ {name: '-f', value: 'filter1,equals=filter1value1'},
+ {name: '-f', value: 'filter1,equals=filter1value2'},
+ {name: '-f', value: 'filter2,contains=filter2value1'},
+ {name: '-f', value: 'filter3,equals=[2000 TO 2001]'},
+ ], []);
+
+ component.searchConfig = null;
+ fixture.detectChanges();
+
+ component.export();
+ expect(scriptDataService.invoke).toHaveBeenCalledWith('metadata-export-search', [], []);
+
+ });
+ it('should show a success message when the script was invoked successfully and redirect to the corresponding process page', () => {
+ component.export();
+
+ expect(notificationsService.success).toHaveBeenCalled();
+ expect(router.navigateByUrl).toHaveBeenCalledWith(getProcessDetailRoute(process.processId));
+ });
+ it('should show an error message when the script was not invoked successfully and stay on the current page', () => {
+ (scriptDataService.invoke as jasmine.Spy).and.returnValue(createFailedRemoteDataObject$('Error', 500));
+
+ component.export();
+
+ expect(notificationsService.error).toHaveBeenCalled();
+ expect(router.navigateByUrl).not.toHaveBeenCalled();
+ });
+ });
+ describe('clicking the button', () => {
+ beforeEach(waitForAsync(() => {
+ initBeforeEachAsync();
+ }));
+ beforeEach(() => {
+ initBeforeEach();
+ });
+ it('should trigger the export function', () => {
+ spyOn(component, 'export');
+
+ const debugElement = fixture.debugElement.query(By.css('button.export-button'));
+ debugElement.triggerEventHandler('click', null);
+
+ expect(component.export).toHaveBeenCalled();
+ });
+ });
+});
diff --git a/src/app/shared/search/search-export-csv/search-export-csv.component.ts b/src/app/shared/search/search-export-csv/search-export-csv.component.ts
new file mode 100644
index 0000000000..6ad105342f
--- /dev/null
+++ b/src/app/shared/search/search-export-csv/search-export-csv.component.ts
@@ -0,0 +1,110 @@
+import { Component, Input, OnInit } from '@angular/core';
+import { combineLatest as observableCombineLatest, Observable } from 'rxjs';
+import { ScriptDataService } from '../../../core/data/processes/script-data.service';
+import { getFirstCompletedRemoteData } from '../../../core/shared/operators';
+import { map } from 'rxjs/operators';
+import { FeatureID } from '../../../core/data/feature-authorization/feature-id';
+import { AuthorizationDataService } from '../../../core/data/feature-authorization/authorization-data.service';
+import { hasValue, isNotEmpty } from '../../empty.util';
+import { RemoteData } from '../../../core/data/remote-data';
+import { Process } from '../../../process-page/processes/process.model';
+import { getProcessDetailRoute } from '../../../process-page/process-page-routing.paths';
+import { NotificationsService } from '../../notifications/notifications.service';
+import { TranslateService } from '@ngx-translate/core';
+import { Router } from '@angular/router';
+import { PaginatedSearchOptions } from '../models/paginated-search-options.model';
+
+@Component({
+ selector: 'ds-search-export-csv',
+ styleUrls: ['./search-export-csv.component.scss'],
+ templateUrl: './search-export-csv.component.html',
+})
+/**
+ * Display a button to export the current search results as csv
+ */
+export class SearchExportCsvComponent implements OnInit {
+
+ /**
+ * The current configuration of the search
+ */
+ @Input() searchConfig: PaginatedSearchOptions;
+
+ /**
+ * Observable used to determine whether the button should be shown
+ */
+ shouldShowButton$: Observable;
+
+ /**
+ * The message key used for the tooltip of the button
+ */
+ tooltipMsg = 'metadata-export-search.tooltip';
+
+ constructor(private scriptDataService: ScriptDataService,
+ private authorizationDataService: AuthorizationDataService,
+ private notificationsService: NotificationsService,
+ private translateService: TranslateService,
+ private router: Router
+ ) {
+ }
+
+ ngOnInit(): void {
+ const scriptExists$ = this.scriptDataService.findById('metadata-export-search').pipe(
+ getFirstCompletedRemoteData(),
+ map((rd) => rd.isSuccess && hasValue(rd.payload))
+ );
+
+ const isAuthorized$ = this.authorizationDataService.isAuthorized(FeatureID.AdministratorOf);
+
+ this.shouldShowButton$ = observableCombineLatest([scriptExists$, isAuthorized$]).pipe(
+ map(([scriptExists, isAuthorized]: [boolean, boolean]) => scriptExists && isAuthorized)
+ );
+ }
+
+ /**
+ * Start the export of the items based on the current search configuration
+ */
+ export() {
+ const parameters = [];
+ if (hasValue(this.searchConfig)) {
+ if (isNotEmpty(this.searchConfig.query)) {
+ parameters.push({name: '-q', value: this.searchConfig.query});
+ }
+ if (isNotEmpty(this.searchConfig.scope)) {
+ parameters.push({name: '-s', value: this.searchConfig.scope});
+ }
+ if (isNotEmpty(this.searchConfig.configuration)) {
+ parameters.push({name: '-c', value: this.searchConfig.configuration});
+ }
+ if (isNotEmpty(this.searchConfig.filters)) {
+ this.searchConfig.filters.forEach((filter) => {
+ if (hasValue(filter.values)) {
+ filter.values.forEach((value) => {
+ let operator;
+ let filterValue;
+ if (hasValue(filter.operator)) {
+ operator = filter.operator;
+ filterValue = value;
+ } else {
+ operator = value.substring(value.lastIndexOf(',') + 1);
+ filterValue = value.substring(0, value.lastIndexOf(','));
+ }
+ const valueToAdd = `${filter.key.substring(2)},${operator}=${filterValue}`;
+ parameters.push({name: '-f', value: valueToAdd});
+ });
+ }
+ });
+ }
+ }
+
+ this.scriptDataService.invoke('metadata-export-search', parameters, []).pipe(
+ getFirstCompletedRemoteData()
+ ).subscribe((rd: RemoteData) => {
+ if (rd.hasSucceeded) {
+ this.notificationsService.success(this.translateService.get('metadata-export-search.submit.success'));
+ this.router.navigateByUrl(getProcessDetailRoute(rd.payload.processId));
+ } else {
+ this.notificationsService.error(this.translateService.get('metadata-export-search.submit.error'));
+ }
+ });
+ }
+}
diff --git a/src/app/shared/search/search-results/search-results.component.html b/src/app/shared/search/search-results/search-results.component.html
index c383a2fa1a..e506fd2b8e 100644
--- a/src/app/shared/search/search-results/search-results.component.html
+++ b/src/app/shared/search/search-results/search-results.component.html
@@ -1,4 +1,7 @@
+
+
+ {{ 'item.truncatable-part.show-more' | translate }}
+
+
+ {{ 'item.truncatable-part.show-less' | translate }}
+
diff --git a/src/assets/i18n/en.json5 b/src/assets/i18n/en.json5
index 1d8fddd673..cb664e19f7 100644
--- a/src/assets/i18n/en.json5
+++ b/src/assets/i18n/en.json5
@@ -27,6 +27,16 @@
"404.page-not-found": "page not found",
+ "error-page.description.401": "unauthorized",
+
+ "error-page.description.403": "forbidden",
+
+ "error-page.description.500": "Service Unavailable",
+
+ "error-page.description.404": "page not found",
+
+ "error-page.orcid.generic-error": "An error occurred during login via ORCID. Make sure you have shared your ORCID account email address with DSpace. If the error persists, contact the administrator",
+
"access-status.embargo.listelement.badge": "Embargo",
"access-status.metadata.only.listelement.badge": "Metadata only",
@@ -2125,6 +2135,7 @@
"item.edit.withdraw.success": "The item was withdrawn successfully",
+ "item.orcid.return": "Back",
"item.listelement.badge": "Item",
@@ -2185,6 +2196,10 @@
"item.page.link.simple": "Simple item page",
+ "item.page.orcid.title": "ORCID",
+
+ "item.page.orcid.tooltip": "Open ORCID setting page",
+
"item.page.person.search.title": "Articles by this author",
"item.page.related-items.view-more": "Show {{ amount }} more",
@@ -2219,6 +2234,8 @@
"item.page.claim.button": "Claim",
+ "item.page.claim.tooltip": "Claim this item as profile",
+
"item.preview.dc.identifier.uri": "Identifier:",
"item.preview.dc.contributor.author": "Authors:",
@@ -2506,6 +2523,8 @@
"login.form.oidc": "Log in with OIDC",
+ "login.form.orcid": "Log in with ORCID",
+
"login.form.password": "Password",
"login.form.shibboleth": "Log in with Shibboleth",
@@ -2704,6 +2723,11 @@
"menu.section.workflow": "Administer Workflow",
+ "metadata-export-search.tooltip": "Export search results as CSV",
+ "metadata-export-search.submit.success": "The export was started successfully",
+ "metadata-export-search.submit.error": "Starting the export has failed",
+
+
"mydspace.breadcrumbs": "MyDSpace",
"mydspace.description": "",
@@ -4485,4 +4509,205 @@
"researcherprofile.success.claim.body" : "Profile claimed with success",
"researcherprofile.success.claim.title" : "Success",
+
+ "person.page.orcid": "ORCID",
+
+ "person.page.orcid.create": "Create an ORCID ID",
+
+ "person.page.orcid.granted-authorizations": "Granted authorizations",
+
+ "person.page.orcid.grant-authorizations" : "Grant authorizations",
+
+ "person.page.orcid.link": "Connect to ORCID ID",
+
+ "person.page.orcid.link.processing": "Linking profile to ORCID...",
+
+ "person.page.orcid.link.error.message": "Something went wrong while connecting the profile with ORCID. If the problem persists, contact the administrator.",
+
+ "person.page.orcid.orcid-not-linked-message": "The ORCID iD of this profile ({{ orcid }}) has not yet been connected to an account on the ORCID registry or the connection is expired.",
+
+ "person.page.orcid.unlink": "Disconnect from ORCID",
+
+ "person.page.orcid.unlink.processing": "Processing...",
+
+ "person.page.orcid.missing-authorizations": "Missing authorizations",
+
+ "person.page.orcid.missing-authorizations-message": "The following authorizations are missing:",
+
+ "person.page.orcid.no-missing-authorizations-message": "Great! This box is empty, so you have granted all access rights to use all functions offers by your institution.",
+
+ "person.page.orcid.no-orcid-message": "No ORCID iD associated yet. By clicking on the button below it is possible to link this profile with an ORCID account.",
+
+ "person.page.orcid.profile-preferences": "Profile preferences",
+
+ "person.page.orcid.funding-preferences": "Funding preferences",
+
+ "person.page.orcid.publications-preferences": "Publication preferences",
+
+ "person.page.orcid.remove-orcid-message": "If you need to remove your ORCID, please contact the repository administrator",
+
+ "person.page.orcid.save.preference.changes": "Update settings",
+
+ "person.page.orcid.sync-profile.affiliation" : "Affiliation",
+
+ "person.page.orcid.sync-profile.biographical" : "Biographical data",
+
+ "person.page.orcid.sync-profile.education" : "Education",
+
+ "person.page.orcid.sync-profile.identifiers" : "Identifiers",
+
+ "person.page.orcid.sync-fundings.all" : "All fundings",
+
+ "person.page.orcid.sync-fundings.mine" : "My fundings",
+
+ "person.page.orcid.sync-fundings.my_selected" : "Selected fundings",
+
+ "person.page.orcid.sync-fundings.disabled" : "Disabled",
+
+ "person.page.orcid.sync-publications.all" : "All publications",
+
+ "person.page.orcid.sync-publications.mine" : "My publications",
+
+ "person.page.orcid.sync-publications.my_selected" : "Selected publications",
+
+ "person.page.orcid.sync-publications.disabled" : "Disabled",
+
+ "person.page.orcid.sync-queue.discard" : "Discard the change and do not synchronize with the ORCID registry",
+
+ "person.page.orcid.sync-queue.discard.error": "The discarding of the ORCID queue record failed",
+
+ "person.page.orcid.sync-queue.discard.success": "The ORCID queue record have been discarded successfully",
+
+ "person.page.orcid.sync-queue.empty-message": "The ORCID queue registry is empty",
+
+ "person.page.orcid.sync-queue.description" : "Description",
+
+ "person.page.orcid.sync-queue.description.affiliation": "Affiliations",
+
+ "person.page.orcid.sync-queue.description.country": "Country",
+
+ "person.page.orcid.sync-queue.description.education": "Educations",
+
+ "person.page.orcid.sync-queue.description.external_ids": "External ids",
+
+ "person.page.orcid.sync-queue.description.other_names": "Other names",
+
+ "person.page.orcid.sync-queue.description.qualification": "Qualifications",
+
+ "person.page.orcid.sync-queue.description.researcher_urls": "Researcher urls",
+
+ "person.page.orcid.sync-queue.description.keywords": "Keywords",
+
+ "person.page.orcid.sync-queue.tooltip.insert": "Add a new entry in the ORCID registry",
+
+ "person.page.orcid.sync-queue.tooltip.update": "Update this entry on the ORCID registry",
+
+ "person.page.orcid.sync-queue.tooltip.delete": "Remove this entry from the ORCID registry",
+
+ "person.page.orcid.sync-queue.tooltip.publication": "Publication",
+
+ "person.page.orcid.sync-queue.tooltip.funding": "Funding",
+
+ "person.page.orcid.sync-queue.tooltip.affiliation": "Affiliation",
+
+ "person.page.orcid.sync-queue.tooltip.education": "Education",
+
+ "person.page.orcid.sync-queue.tooltip.qualification": "Qualification",
+
+ "person.page.orcid.sync-queue.tooltip.other_names": "Other name",
+
+ "person.page.orcid.sync-queue.tooltip.country": "Country",
+
+ "person.page.orcid.sync-queue.tooltip.keywords": "Keyword",
+
+ "person.page.orcid.sync-queue.tooltip.external_ids": "External identifier",
+
+ "person.page.orcid.sync-queue.tooltip.researcher_urls": "Researcher url",
+
+ "person.page.orcid.sync-queue.send" : "Synchronize with ORCID registry",
+
+ "person.page.orcid.sync-queue.send.unauthorized-error.title": "The submission to ORCID failed for missing authorizations.",
+
+ "person.page.orcid.sync-queue.send.unauthorized-error.content": "Click here to grant again the required permissions. If the problem persists, contact the administrator",
+
+ "person.page.orcid.sync-queue.send.bad-request-error": "The submission to ORCID failed because the resource sent to ORCID registry is not valid",
+
+ "person.page.orcid.sync-queue.send.error": "The submission to ORCID failed",
+
+ "person.page.orcid.sync-queue.send.conflict-error": "The submission to ORCID failed because the resource is already present on the ORCID registry",
+
+ "person.page.orcid.sync-queue.send.not-found-warning": "The resource does not exists anymore on the ORCID registry.",
+
+ "person.page.orcid.sync-queue.send.success": "The submission to ORCID was completed successfully",
+
+ "person.page.orcid.sync-queue.send.validation-error": "The data that you want to synchronize with ORCID is not valid",
+
+ "person.page.orcid.sync-queue.send.validation-error.amount-currency.required": "The amount's currency is required",
+
+ "person.page.orcid.sync-queue.send.validation-error.external-id.required": "The resource to be sent requires at least one identifier",
+
+ "person.page.orcid.sync-queue.send.validation-error.title.required": "The title is required",
+
+ "person.page.orcid.sync-queue.send.validation-error.type.required": "The type is required",
+
+ "person.page.orcid.sync-queue.send.validation-error.start-date.required": "The start date is required",
+
+ "person.page.orcid.sync-queue.send.validation-error.funder.required": "The funder is required",
+
+ "person.page.orcid.sync-queue.send.validation-error.organization.required": "The organization is required",
+
+ "person.page.orcid.sync-queue.send.validation-error.organization.name-required": "The organization's name is required",
+
+ "person.page.orcid.sync-queue.send.validation-error.organization.address-required": "The organization to be sent requires an address",
+
+ "person.page.orcid.sync-queue.send.validation-error.organization.city-required": "The address of the organization to be sent requires a city",
+
+ "person.page.orcid.sync-queue.send.validation-error.organization.country-required": "The address of the organization to be sent requires a country",
+
+ "person.page.orcid.sync-queue.send.validation-error.disambiguated-organization.required": "An identifier to disambiguate organizations is required. Supported ids are GRID, Ringgold, Legal Entity identifiers (LEIs) and Crossref Funder Registry identifiers",
+
+ "person.page.orcid.sync-queue.send.validation-error.disambiguated-organization.value-required": "The organization's identifiers requires a value",
+
+ "person.page.orcid.sync-queue.send.validation-error.disambiguation-source.required": "The organization's identifiers requires a source",
+
+ "person.page.orcid.sync-queue.send.validation-error.disambiguation-source.invalid": "The source of one of the organization identifiers is invalid. Supported sources are RINGGOLD, GRID, LEI and FUNDREF",
+
+ "person.page.orcid.synchronization-mode": "Synchronization mode",
+
+ "person.page.orcid.synchronization-mode.batch": "Batch",
+
+ "person.page.orcid.synchronization-mode.label": "Synchronization mode",
+
+ "person.page.orcid.synchronization-mode-message": "Please select how you would like synchronization to ORCID to occur. The options include \"Manual\" (you must send your data to ORCID manually), or \"Batch\" (the system will send your data to ORCID via a scheduled script).",
+
+ "person.page.orcid.synchronization-mode-funding-message": "Select whether to send your linked Project entities to your ORCID record's list of funding information.",
+
+ "person.page.orcid.synchronization-mode-publication-message": "Select whether to send your linked Publication entities to your ORCID record's list of works.",
+
+ "person.page.orcid.synchronization-mode-profile-message": "Select whether to send your biographical data or personal identifiers to your ORCID record.",
+
+ "person.page.orcid.synchronization-settings-update.success": "The synchronization settings have been updated successfully",
+
+ "person.page.orcid.synchronization-settings-update.error": "The update of the synchronization settings failed",
+
+ "person.page.orcid.synchronization-mode.manual": "Manual",
+
+ "person.page.orcid.scope.authenticate": "Get your ORCID iD",
+
+ "person.page.orcid.scope.read-limited": "Read your information with visibility set to Trusted Parties",
+
+ "person.page.orcid.scope.activities-update": "Add/update your research activities",
+
+ "person.page.orcid.scope.person-update": "Add/update other information about you",
+
+ "person.page.orcid.unlink.success": "The disconnection between the profile and the ORCID registry was successful",
+
+ "person.page.orcid.unlink.error": "An error occurred while disconnecting between the profile and the ORCID registry. Try again",
+
+ "person.orcid.sync.setting": "ORCID Synchronization settings",
+
+ "person.orcid.registry.queue": "ORCID Registry Queue",
+
+ "person.orcid.registry.auth": "ORCID Authorizations",
+
}
diff --git a/src/assets/i18n/fi.json5 b/src/assets/i18n/fi.json5
index 02f020a45d..860062fa67 100644
--- a/src/assets/i18n/fi.json5
+++ b/src/assets/i18n/fi.json5
@@ -107,7 +107,7 @@
"admin.registries.bitstream-formats.edit.head": "Tiedostoformaatti: {{ format }}",
// "admin.registries.bitstream-formats.edit.internal.hint": "Formats marked as internal are hidden from the user, and used for administrative purposes.",
- "admin.registries.bitstream-formats.edit.internal.hint": "Sisäisiksi merkittyjä formaatteja käytetään hallinnollisiin tarkoituksiin, ja ne on piilotettu käyttäjiltä.",
+ "admin.registries.bitstream-formats.edit.internal.hint": "Sisäisiksi merkittyjä formaatteja käytetään ylläpitotarkoituksiin, ja ne on piilotettu käyttäjiltä.",
// "admin.registries.bitstream-formats.edit.internal.label": "Internal",
"admin.registries.bitstream-formats.edit.internal.label": "Sisäinen",
@@ -662,7 +662,7 @@
// "admin.search.breadcrumbs": "Administrative Search",
- "admin.search.breadcrumbs": "Hallinnollinen haku",
+ "admin.search.breadcrumbs": "Ylläpitäjän haku",
// "admin.search.collection.edit": "Edit",
"admin.search.collection.edit": "Muokkaa",
@@ -692,19 +692,19 @@
"admin.search.item.withdraw": "Poista käytöstä",
// "admin.search.title": "Administrative Search",
- "admin.search.title": "Hallinnollinen haku",
+ "admin.search.title": "Ylläpitäjän haku",
// "administrativeView.search.results.head": "Administrative Search",
- "administrativeView.search.results.head": "Hallinnollinen haku",
+ "administrativeView.search.results.head": "Ylläpitäjän haku",
// "admin.workflow.breadcrumbs": "Administer Workflow",
- "admin.workflow.breadcrumbs": "Hallinnointityönkulku",
+ "admin.workflow.breadcrumbs": "Hallinnoi työnkulkua",
// "admin.workflow.title": "Administer Workflow",
- "admin.workflow.title": "Hallinnointityönkulku",
+ "admin.workflow.title": "Hallinnoi työnkulkua",
// "admin.workflow.item.workflow": "Workflow",
"admin.workflow.item.workflow": "Työnkulku",
@@ -2954,7 +2954,7 @@
// "menu.section.admin_search": "Admin Search",
- "menu.section.admin_search": "Admin-haku",
+ "menu.section.admin_search": "Ylläpitäjän haku",
@@ -3033,7 +3033,7 @@
"menu.section.icon.access_control": "Pääsyoikeudet",
// "menu.section.icon.admin_search": "Admin search menu section",
- "menu.section.icon.admin_search": "Admin-haku",
+ "menu.section.icon.admin_search": "Ylläpitäjän haku",
// "menu.section.icon.control_panel": "Control Panel menu section",
"menu.section.icon.control_panel": "Hallintapaneeli",
@@ -3168,7 +3168,7 @@
// "menu.section.workflow": "Administer Workflow",
- "menu.section.workflow": "Hallinnointityönkulku",
+ "menu.section.workflow": "Hallinnoi työnkulkua",
// "mydspace.description": "",
@@ -5079,7 +5079,7 @@
// "workflowAdmin.search.results.head": "Administer Workflow",
- "workflowAdmin.search.results.head": "Hallinnointityönkulku",
+ "workflowAdmin.search.results.head": "Hallinnoi työnkulkua",
diff --git a/src/assets/images/orcid.logo.icon.svg b/src/assets/images/orcid.logo.icon.svg
new file mode 100644
index 0000000000..8aec5959e5
--- /dev/null
+++ b/src/assets/images/orcid.logo.icon.svg
@@ -0,0 +1,21 @@
+
+
\ No newline at end of file
diff --git a/src/styles/_global-styles.scss b/src/styles/_global-styles.scss
index b78e67a6a8..89d1d76e9a 100644
--- a/src/styles/_global-styles.scss
+++ b/src/styles/_global-styles.scss
@@ -116,9 +116,25 @@ ngb-modal-backdrop {
margin-left: var(--ds-gap);
}
+.custom-accordion .card-header button {
+ -webkit-box-shadow: none!important;
+ box-shadow: none!important;
+ width: 100%;
+}
+.custom-accordion .card:first-of-type {
+ border-bottom: var(--bs-card-border-width) solid var(--bs-card-border-color) !important;
+ border-bottom-left-radius: var(--bs-card-border-radius) !important;
+ border-bottom-right-radius: var(--bs-card-border-radius) !important;
+}
+
ds-dynamic-form-control-container.d-none {
/* Ensures that form-control containers hidden and disabled by type binding collapse and let other fields in
the same row expand accordingly
*/
visibility: collapse;
}
+
+/* Used for dso administrative functionality */
+.btn-dark {
+ background-color: var(--ds-admin-sidebar-bg);
+}