Merged dspace-cris-2025_02_x into task/dspace-cris-2025_02_x/DSC-2860

Author: FrancescoMolinaro

cypress/e2e/homepage-statistics.cy.ts

@@ -12,7 +12,10 @@ describe('Site Statistics Page', () => {
     cy.location('pathname').should('eq', '/statistics');
   });
 
-  it('should pass accessibility tests', () => {
+  // Skipped: this test depends on the external backend image (seeded demo entity + Solr
+  // statistics indexing). The "Most Viewed" table label loads asynchronously from that
+  // backend and intermittently stays empty in CI, which we cannot fix from the frontend.
+  it.skip('should pass accessibility tests', () => {
     // generate 2 view events on an Item's page
     cy.generateViewEvent(Cypress.env('DSPACE_TEST_ENTITY_PUBLICATION'), 'item');
     cy.generateViewEvent(Cypress.env('DSPACE_TEST_ENTITY_PUBLICATION'), 'item');

src/app/core/data/dspace-rest-response-parsing.service.spec.ts

@@ -0,0 +1,81 @@
+import { getMockObjectCacheService } from '../../shared/mocks/object-cache.service.mock';
+import { ObjectCacheService } from '../cache/object-cache.service';
+import { RawRestResponse } from '../dspace-rest/raw-rest-response.model';
+import { DspaceRestResponseParsingService } from './dspace-rest-response-parsing.service';
+import { RestRequest } from './rest-request.model';
+import { RestRequestMethod } from './rest-request-method';
+
+class TestService extends DspaceRestResponseParsingService {
+  constructor(protected objectCache: ObjectCacheService) {
+    super(objectCache);
+  }
+
+  public ensureSelfLinkForTest(request: RestRequest, response: RawRestResponse): RawRestResponse {
+    return this.ensureSelfLink(request, response);
+  }
+}
+
+describe('DspaceRestResponseParsingService', () => {
+  let service: TestService;
+
+  beforeEach(() => {
+    service = new TestService(getMockObjectCacheService());
+  });
+
+  describe('ensureSelfLink', () => {
+    let warnSpy: jasmine.Spy;
+
+    beforeEach(() => {
+      warnSpy = spyOn(console, 'warn');
+    });
+
+    it('does not replace self link when only query params differ', () => {
+      const request = {
+        uuid: 'request-id',
+        href: 'https://rest.test/server/api/core/items/f639b124-1234-1234-1234-abcdef123456?projection=preventMetadataSecurity',
+        method: RestRequestMethod.GET,
+      } as RestRequest;
+      const response: RawRestResponse = {
+        payload: {
+          _links: {
+            self: {
+              href: 'https://rest.test/server/api/core/items/f639b124-1234-1234-1234-abcdef123456',
+            },
+          },
+        },
+        statusCode: 200,
+        statusText: 'OK',
+      };
+
+      const result = service.ensureSelfLinkForTest(request, response);
+
+      expect(result.payload._links.self.href).toBe('https://rest.test/server/api/core/items/f639b124-1234-1234-1234-abcdef123456');
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('replaces self link when path differs', () => {
+      const request = {
+        uuid: 'request-id',
+        href: 'https://rest.test/server/api/core/items/f639b124-1234-1234-1234-abcdef123456',
+        method: RestRequestMethod.GET,
+      } as RestRequest;
+      const response: RawRestResponse = {
+        payload: {
+          _links: {
+            self: {
+              href: 'https://rest.test/server/api/core/items/some-other-id',
+            },
+          },
+        },
+        statusCode: 200,
+        statusText: 'OK',
+      };
+
+      const result = service.ensureSelfLinkForTest(request, response);
+
+      expect(result.payload._links.self.href).toBe('https://rest.test/server/api/core/items/f639b124-1234-1234-1234-abcdef123456');
+      expect(warnSpy).toHaveBeenCalled();
+    });
+  });
+});
+

src/app/core/data/dspace-rest-response-parsing.service.ts

@@ -60,9 +60,9 @@ export function isRestPaginatedList(halObj: any): boolean {
  * @param url the url to split
  */
 const splitUrlInParts = (url: string): string[] => {
-  return url.split('?')
-    .map((part) => part.split('&'))
-    .reduce((combined, current) => [...combined, ...current]);
+  // Compare link structure only, ignoring query params and hash fragments.
+  const normalizedUrl = url.split('?')[0].split('#')[0];
+  return normalizedUrl.split('/');
 };
 
 @Injectable({ providedIn: 'root' })

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

@@ -1,8 +1,23 @@
+import { HttpHeaders } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { Store } from '@ngrx/store';
-import { Observable } from 'rxjs';
+import {
+  map,
+  Observable,
+} from 'rxjs';
+import {
+  distinctUntilChanged,
+  take,
+  takeWhile,
+} from 'rxjs/operators';
 
+import {
+  hasValue,
+  isNotEmptyOperator,
+} from '../../shared/empty.util';
+import { NotificationOptions } from '../../shared/notifications/models/notification-options.model';
 import { NotificationsService } from '../../shared/notifications/notifications.service';
+import { getClassForType } from '../cache/builders/build-decorators';
 import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
 import { RequestParam } from '../cache/models/request-param.model';
 import { ObjectCacheService } from '../cache/object-cache.service';
@@ -12,7 +27,10 @@ import {
 } from '../data/base/create-data';
 import { IdentifiableDataService } from '../data/base/identifiable-data.service';
 import { RemoteData } from '../data/remote-data';
+import { CreateRequest } from '../data/request.models';
 import { RequestService } from '../data/request.service';
+import { DSpaceSerializer } from '../dspace-rest/dspace.serializer';
+import { HttpOptions } from '../dspace-rest/dspace-rest.service';
 import { HALEndpointService } from '../shared/hal-endpoint.service';
 import {
   getFirstSucceededRemoteData,
@@ -24,7 +42,9 @@ import { Feedback } from './models/feedback.model';
  * Service for checking and managing the feedback
  */
 @Injectable({ providedIn: 'root' })
-export class FeedbackDataService extends IdentifiableDataService<Feedback> implements CreateData<Feedback> {
+export class FeedbackDataService
+  extends IdentifiableDataService<Feedback>
+  implements CreateData<Feedback> {
   private createData: CreateDataImpl<Feedback>;
 
   constructor(
@@ -37,7 +57,15 @@ export class FeedbackDataService extends IdentifiableDataService<Feedback> imple
   ) {
     super('feedbacks', requestService, rdbService, objectCache, halService);
 
-    this.createData = new CreateDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, notificationsService, this.responseMsToLive);
+    this.createData = new CreateDataImpl(
+      this.linkPath,
+      requestService,
+      rdbService,
+      objectCache,
+      halService,
+      notificationsService,
+      this.responseMsToLive,
+    );
   }
 
   /**
@@ -51,14 +79,71 @@ export class FeedbackDataService extends IdentifiableDataService<Feedback> imple
     );
   }
 
-
   /**
    * Create a new object on the server, and store the response in the object cache
    *
    * @param object    The object to create
    * @param params    Array with additional params to combine with query string
    */
-  public create(object: Feedback, ...params: RequestParam[]): Observable<RemoteData<Feedback>> {
+  public create(
+    object: Feedback,
+    ...params: RequestParam[]
+  ): Observable<RemoteData<Feedback>> {
     return this.createData.create(object, ...params);
   }
+
+  createWithCaptcha(
+    object: Feedback,
+    captchaToken: string = null,
+    ...params: RequestParam[]
+  ): Observable<RemoteData<Feedback>> {
+    const requestId = this.requestService.generateRequestId();
+
+    const endpoint$ = this.getEndpoint().pipe(
+      isNotEmptyOperator(),
+      distinctUntilChanged(),
+      map((endpoint: string) => this.buildHrefWithParams(endpoint, params)),
+    );
+
+    const serializedObject = new DSpaceSerializer(
+      getClassForType(object.type),
+    ).serialize(object);
+
+    endpoint$.pipe(take(1)).subscribe((endpoint: string) => {
+      const options: HttpOptions = Object.create({});
+      let headers = new HttpHeaders();
+      if (captchaToken) {
+        headers = headers.set('x-recaptcha-token', captchaToken);
+      }
+      options.headers = headers;
+
+      const request = new CreateRequest(
+        requestId,
+        endpoint,
+        JSON.stringify(serializedObject),
+        options,
+      );
+
+      if (hasValue(this.responseMsToLive)) {
+        request.responseMsToLive = this.responseMsToLive;
+      }
+      this.requestService.send(request);
+    });
+
+    const result$ = this.rdbService.buildFromRequestUUID<Feedback>(requestId);
+
+    result$
+      .pipe(takeWhile((rd: RemoteData<Feedback>) => rd.isLoading, true))
+      .subscribe((rd: RemoteData<Feedback>) => {
+        if (rd.hasFailed) {
+          this.notificationsService.error(
+            'Server Error:',
+            rd.errorMessage,
+            new NotificationOptions(-1),
+          );
+        }
+      });
+
+    return result$;
+  }
 }

src/app/core/feedback/models/feedback.model.ts

@@ -30,6 +30,12 @@ export class Feedback extends DSpaceObject {
   @autoserialize
   public page: string;
 
+  /**
+   * Google reCAPTCHA token for spam protection
+   */
+  @autoserialize
+  public captcha: string;
+
   _links: {
     self: HALLink;
   };

src/app/core/google-recaptcha/google-recaptcha-base.component.ts

@@ -0,0 +1,121 @@
+import { Component } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import {
+  BehaviorSubject,
+  combineLatest,
+  Observable,
+  of,
+} from 'rxjs';
+import {
+  startWith,
+  switchMap,
+} from 'rxjs/operators';
+
+import { CookieService } from '../services/cookie.service';
+import { isNotEmpty } from './../../shared/empty.util';
+import { NotificationsService } from './../../shared/notifications/notifications.service';
+import {
+  CAPTCHA_FEEDBACK_NAME,
+  GoogleRecaptchaService,
+} from './google-recaptcha.service';
+
+@Component({
+  template: '',
+})
+export abstract class GoogleRecaptchaBaseComponent {
+
+  /**
+   * The message prefix - default value is 'submit-form'.
+   * Add translations if a different value is used.
+   */
+  MESSAGE_PREFIX = 'submit-form';
+
+  constructor(
+    public googleRecaptchaService: GoogleRecaptchaService,
+    public cookieService: CookieService,
+    public notificationsService: NotificationsService,
+    public translate: TranslateService,
+  ) {}
+
+  /**
+   * Return true if the user completed the reCaptcha verification (checkbox mode)
+   */
+  checkboxCheckedSubject$ = new BehaviorSubject<boolean>(false);
+
+  /**
+   * Disable the form until the user has completed the reCaptcha verification (checkbox mode)
+   */
+  disableUntilChecked = true;
+
+  captchaVersion(): Observable<string> {
+    return this.googleRecaptchaService.captchaVersion();
+  }
+
+  captchaMode(): Observable<string> {
+    return this.googleRecaptchaService.captchaMode();
+  }
+
+  /**
+   * Return true if the user has not completed the reCaptcha verification (checkbox mode)
+   */
+  disableUntilCheckedFcn(): Observable<boolean> {
+    const checked$ = this.checkboxCheckedSubject$.asObservable();
+    return combineLatest([
+      this.captchaVersion(),
+      this.captchaMode(),
+      checked$,
+    ]).pipe(
+      // disable if checkbox is not checked or if reCaptcha is not in v2 checkbox mode
+      switchMap(([captchaVersion, captchaMode, checked]) =>
+        captchaVersion === 'v2' && captchaMode === 'checkbox'
+          ? of(!checked)
+          : of(false),
+      ),
+      startWith(true),
+    );
+  }
+
+  /**
+   * Return true if the user has accepted the required cookies for reCaptcha
+   */
+  isRecaptchaCookieAccepted(): boolean {
+    const orejimeAnonymousCookie = this.cookieService.get('orejime-anonymous');
+    return isNotEmpty(orejimeAnonymousCookie)
+      ? orejimeAnonymousCookie[CAPTCHA_FEEDBACK_NAME]
+      : false;
+  }
+
+  /**
+   * Set the checkbox checked status to the given value
+   */
+  onCheckboxChecked(checked: boolean) {
+    this.checkboxCheckedSubject$.next(checked);
+  }
+
+  /**
+   * Show a notification to the user
+   * @param key expected values: 'expired' or 'error'
+   */
+  showNotification(key) {
+    const notificationTitle = this.translate.get(this.MESSAGE_PREFIX + '.google-recaptcha.notification.title');
+    const notificationErrorMsg = this.translate.get(this.MESSAGE_PREFIX + '.google-recaptcha.notification.message.error');
+    const notificationExpiredMsg = this.translate.get(this.MESSAGE_PREFIX + '.google-recaptcha.notification.message.expired');
+    switch (key) {
+      case 'expired':
+        this.notificationsService.warning(notificationTitle, notificationExpiredMsg);
+        break;
+      case 'error':
+        this.notificationsService.error(notificationTitle, notificationErrorMsg);
+        break;
+      default:
+        console.warn(`Unimplemented notification '${key}' from reCaptcha service`);
+    }
+  }
+
+  /**
+   * execute the captcha function
+   */
+  executeRecaptcha() {
+    this.googleRecaptchaService.executeRecaptcha();
+  }
+}