107671: Fix handle theme not working with canonical prefix https://hdl.handle.net/

Author: alexandrevryghem

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

@@ -1,4 +1,3 @@
-/* eslint-disable max-classes-per-file */
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';

src/app/curation-form/curation-form.component.spec.ts

@@ -1,4 +1,4 @@
-import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { ComponentFixture, TestBed, waitForAsync, fakeAsync, flush } from '@angular/core/testing';
 import { TranslateModule } from '@ngx-translate/core';
 import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
 import { CurationFormComponent } from './curation-form.component';
@@ -16,6 +16,7 @@ import { ConfigurationDataService } from '../core/data/configuration-data.servic
 import { ConfigurationProperty } from '../core/shared/configuration-property.model';
 import { getProcessDetailRoute } from '../process-page/process-page-routing.paths';
 import { HandleService } from '../shared/handle.service';
+import { of as observableOf } from 'rxjs';
 
 describe('CurationFormComponent', () => {
   let comp: CurationFormComponent;
@@ -54,7 +55,7 @@ describe('CurationFormComponent', () => {
     });
 
     handleService = {
-      normalizeHandle: (a) => a
+      normalizeHandle: (a: string) => observableOf(a),
     } as any;
 
     notificationsService = new NotificationsServiceStub();
@@ -151,12 +152,13 @@ describe('CurationFormComponent', () => {
     ], []);
   });
 
-  it(`should show an error notification and return when an invalid dsoHandle is provided`, () => {
+  it(`should show an error notification and return when an invalid dsoHandle is provided`, fakeAsync(() => {
     comp.dsoHandle = 'test-handle';
-    spyOn(handleService, 'normalizeHandle').and.returnValue(null);
+    spyOn(handleService, 'normalizeHandle').and.returnValue(observableOf(null));
     comp.submit();
+    flush();
 
     expect(notificationsService.error).toHaveBeenCalled();
     expect(scriptDataService.invoke).not.toHaveBeenCalled();
-  });
+  }));
 });

src/app/curation-form/curation-form.component.ts

@@ -1,30 +1,30 @@
-import { ChangeDetectorRef, Component, Input, OnInit } from '@angular/core';
+import { ChangeDetectorRef, Component, Input, OnDestroy, OnInit } from '@angular/core';
 import { ScriptDataService } from '../core/data/processes/script-data.service';
 import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
-import { getFirstCompletedRemoteData } from '../core/shared/operators';
-import { find, map } from 'rxjs/operators';
+import { getFirstCompletedRemoteData, getFirstSucceededRemoteDataPayload } from '../core/shared/operators';
+import { map } from 'rxjs/operators';
 import { NotificationsService } from '../shared/notifications/notifications.service';
 import { TranslateService } from '@ngx-translate/core';
 import { hasValue, isEmpty, isNotEmpty } from '../shared/empty.util';
 import { RemoteData } from '../core/data/remote-data';
 import { Router } from '@angular/router';
-import { ProcessDataService } from '../core/data/processes/process-data.service';
 import { Process } from '../process-page/processes/process.model';
 import { ConfigurationDataService } from '../core/data/configuration-data.service';
 import { ConfigurationProperty } from '../core/shared/configuration-property.model';
-import { Observable } from 'rxjs';
+import { Observable, Subscription } from 'rxjs';
 import { getProcessDetailRoute } from '../process-page/process-page-routing.paths';
 import { HandleService } from '../shared/handle.service';
 
 export const CURATION_CFG = 'plugin.named.org.dspace.curate.CurationTask';
+
 /**
  * Component responsible for rendering the Curation Task form
  */
 @Component({
   selector: 'ds-curation-form',
   templateUrl: './curation-form.component.html'
 })
-export class CurationFormComponent implements OnInit {
+export class CurationFormComponent implements OnDestroy, OnInit {
 
   config: Observable<RemoteData<ConfigurationProperty>>;
   tasks: string[];
@@ -33,10 +33,11 @@ export class CurationFormComponent implements OnInit {
   @Input()
   dsoHandle: string;
 
+  subs: Subscription[] = [];
+
   constructor(
     private scriptDataService: ScriptDataService,
     private configurationDataService: ConfigurationDataService,
-    private processDataService: ProcessDataService,
     private notificationsService: NotificationsService,
     private translateService: TranslateService,
     private handleService: HandleService,
@@ -45,23 +46,26 @@ export class CurationFormComponent implements OnInit {
   ) {
   }
 
+  ngOnDestroy(): void {
+    this.subs.forEach((sub: Subscription) => sub.unsubscribe());
+  }
+
   ngOnInit(): void {
     this.form = new UntypedFormGroup({
       task: new UntypedFormControl(''),
       handle: new UntypedFormControl('')
     });
 
     this.config = this.configurationDataService.findByPropertyName(CURATION_CFG);
-    this.config.pipe(
-      find((rd: RemoteData<ConfigurationProperty>) => rd.hasSucceeded),
-      map((rd: RemoteData<ConfigurationProperty>) => rd.payload)
-    ).subscribe((configProperties) => {
+    this.subs.push(this.config.pipe(
+      getFirstSucceededRemoteDataPayload(),
+    ).subscribe((configProperties: ConfigurationProperty) => {
       this.tasks = configProperties.values
         .filter((value) => isNotEmpty(value) && value.includes('='))
         .map((value) => value.split('=')[1].trim());
       this.form.get('task').patchValue(this.tasks[0]);
       this.cdr.detectChanges();
-    });
+    }));
   }
 
   /**
@@ -77,33 +81,41 @@ export class CurationFormComponent implements OnInit {
    */
   submit() {
     const taskName = this.form.get('task').value;
-    let handle;
+    let handle$: Observable<string | null>;
     if (this.hasHandleValue()) {
-      handle = this.handleService.normalizeHandle(this.dsoHandle);
-      if (isEmpty(handle)) {
-        this.notificationsService.error(this.translateService.get('curation.form.submit.error.head'),
-          this.translateService.get('curation.form.submit.error.invalid-handle'));
-        return;
-      }
+      handle$ = this.handleService.normalizeHandle(this.dsoHandle).pipe(
+        map((handle: string | null) => {
+          if (isEmpty(handle)) {
+            this.notificationsService.error(this.translateService.get('curation.form.submit.error.head'),
+              this.translateService.get('curation.form.submit.error.invalid-handle'));
+          }
+          return handle;
+        }),
+      );
     } else {
-      handle = this.handleService.normalizeHandle(this.form.get('handle').value);
-      if (isEmpty(handle)) {
-        handle = 'all';
-      }
+      handle$ = this.handleService.normalizeHandle(this.form.get('handle').value).pipe(
+        map((handle: string | null) => isEmpty(handle) ? 'all' : handle),
+      );
     }
 
-    this.scriptDataService.invoke('curate', [
-      { name: '-t', value: taskName },
-      { name: '-i', value: handle },
-    ], []).pipe(getFirstCompletedRemoteData()).subscribe((rd: RemoteData<Process>) => {
-      if (rd.hasSucceeded) {
-        this.notificationsService.success(this.translateService.get('curation.form.submit.success.head'),
-          this.translateService.get('curation.form.submit.success.content'));
-        this.router.navigateByUrl(getProcessDetailRoute(rd.payload.processId));
-      } else {
-        this.notificationsService.error(this.translateService.get('curation.form.submit.error.head'),
-          this.translateService.get('curation.form.submit.error.content'));
+    this.subs.push(handle$.subscribe((handle: string) => {
+      if (hasValue(handle)) {
+        this.subs.push(this.scriptDataService.invoke('curate', [
+          { name: '-t', value: taskName },
+          { name: '-i', value: handle },
+        ], []).pipe(
+          getFirstCompletedRemoteData(),
+        ).subscribe((rd: RemoteData<Process>) => {
+          if (rd.hasSucceeded) {
+            this.notificationsService.success(this.translateService.get('curation.form.submit.success.head'),
+              this.translateService.get('curation.form.submit.success.content'));
+            void this.router.navigateByUrl(getProcessDetailRoute(rd.payload.processId));
+          } else {
+            this.notificationsService.error(this.translateService.get('curation.form.submit.error.head'),
+              this.translateService.get('curation.form.submit.error.content'));
+          }
+        }));
       }
-    });
+    }));
   }
 }

src/app/shared/handle.service.spec.ts

@@ -1,47 +1,79 @@
 import { HandleService } from './handle.service';
+import { TestBed } from '@angular/core/testing';
+import { ConfigurationDataServiceStub } from './testing/configuration-data.service.stub';
+import { ConfigurationDataService } from '../core/data/configuration-data.service';
+import { of as observableOf } from 'rxjs';
 
 describe('HandleService', () => {
   let service: HandleService;
 
+  let configurationService: ConfigurationDataServiceStub;
+
   beforeEach(() => {
-    service = new HandleService();
+    configurationService = new ConfigurationDataServiceStub();
+
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: ConfigurationDataService, useValue: configurationService },
+      ],
+    });
+    service = TestBed.inject(HandleService);
   });
 
   describe(`normalizeHandle`, () => {
-    it(`should simply return an already normalized handle`, () => {
-      let input, output;
-
-      input = '123456789/123456';
-      output = service.normalizeHandle(input);
-      expect(output).toEqual(input);
+    it('should normalize a handle url with custom conical prefix with trailing slash', (done: DoneFn) => {
+      service.canonicalPrefix$ = observableOf('https://hdl.handle.net/');
 
-      input = '12.3456.789/123456';
-      output = service.normalizeHandle(input);
-      expect(output).toEqual(input);
+      service.normalizeHandle('https://hdl.handle.net/123456789/123456').subscribe((handle: string | null) => {
+        expect(handle).toBe('123456789/123456');
+        done();
+      });
     });
 
-    it(`should normalize a handle url`, () => {
-      let input, output;
+    it('should normalize a handle url with custom conical prefix without trailing slash', (done: DoneFn) => {
+      service.canonicalPrefix$ = observableOf('https://hdl.handle.net');
 
-      input = 'https://hdl.handle.net/handle/123456789/123456';
-      output = service.normalizeHandle(input);
-      expect(output).toEqual('123456789/123456');
+      service.normalizeHandle('https://hdl.handle.net/123456789/123456').subscribe((handle: string | null) => {
+        expect(handle).toBe('123456789/123456');
+        done();
+      });
+    });
+
+    describe('should simply return an already normalized handle', () => {
+      it('123456789/123456', (done: DoneFn) => {
+        service.normalizeHandle('123456789/123456').subscribe((handle: string | null) => {
+          expect(handle).toBe('123456789/123456');
+          done();
+        });
+      });
 
-      input = 'https://rest.api/server/handle/123456789/123456';
-      output = service.normalizeHandle(input);
-      expect(output).toEqual('123456789/123456');
+      it('12.3456.789/123456', (done: DoneFn) => {
+        service.normalizeHandle('12.3456.789/123456').subscribe((handle: string | null) => {
+          expect(handle).toBe('12.3456.789/123456');
+          done();
+        });
+      });
     });
 
-    it(`should return null if the input doesn't contain a handle`, () => {
-      let input, output;
+    it('should normalize handle urls starting with handle', (done: DoneFn) => {
+      service.normalizeHandle('https://rest.api/server/handle/123456789/123456').subscribe((handle: string | null) => {
+        expect(handle).toBe('123456789/123456');
+        done();
+      });
+    });
 
-      input = 'https://hdl.handle.net/handle/123456789';
-      output = service.normalizeHandle(input);
-      expect(output).toBeNull();
+    it('should return null if the input doesn\'t contain a valid handle', (done: DoneFn) => {
+      service.normalizeHandle('https://hdl.handle.net/123456789').subscribe((handle: string | null) => {
+        expect(handle).toBeNull();
+        done();
+      });
+    });
 
-      input = 'something completely different';
-      output = service.normalizeHandle(input);
-      expect(output).toBeNull();
+    it('should return null if the input doesn\'t contain a handle', (done: DoneFn) => {
+      service.normalizeHandle('something completely different').subscribe((handle: string | null) => {
+        expect(handle).toBeNull();
+        done();
+      });
     });
   });
 });