Merge branch 'refs/heads/legacy-bitstream-redirect-7.6' into legacy-bitstream-redirect_contribute-main

# Conflicts:
#	src/app/bitstream-page/legacy-bitstream-url-redirect.guard.spec.ts
#	src/app/bitstream-page/legacy-bitstream-url-redirect.guard.ts

Author: alexandrevryghem

src/app/bitstream-page/bitstream-page-routes.ts

@@ -23,13 +23,11 @@ export const ROUTES: Route[] = [
   {
     // Resolve XMLUI bitstream download URLs
     path: 'handle/:prefix/:suffix/:filename',
-    component: BitstreamDownloadPageComponent,
     canActivate: [legacyBitstreamURLRedirectGuard],
   },
   {
     // Resolve JSPUI bitstream download URLs
     path: ':prefix/:suffix/:sequence_id/:filename',
-    component: BitstreamDownloadPageComponent,
     canActivate: [legacyBitstreamURLRedirectGuard],
   },
   {

src/app/bitstream-page/legacy-bitstream-url-redirect.guard.spec.ts

@@ -1,14 +1,14 @@
-import { fakeAsync } from '@angular/core/testing';
 import { cold } from 'jasmine-marbles';
 import { EMPTY } from 'rxjs';
 
 import { PAGE_NOT_FOUND_PATH } from '../app-routing-paths';
 import { BitstreamDataService } from '../core/data/bitstream-data.service';
 import { RemoteData } from '../core/data/remote-data';
 import { RequestEntryState } from '../core/data/request-entry-state.model';
+import { BrowserHardRedirectService } from '../core/services/browser-hard-redirect.service';
+import { HardRedirectService } from '../core/services/hard-redirect.service';
 import { Bitstream } from '../core/shared/bitstream.model';
 import { RouterStub } from '../shared/testing/router.stub';
-import { ServerResponseServiceStub } from '../shared/testing/server-response-service.stub';
 import { legacyBitstreamURLRedirectGuard } from './legacy-bitstream-url-redirect.guard';
 
 describe('legacyBitstreamURLRedirectGuard', () => {
@@ -17,21 +17,26 @@ describe('legacyBitstreamURLRedirectGuard', () => {
   let remoteDataMocks: { [type: string]: RemoteData<Bitstream> };
   let route;
   let state;
-  let serverResponseService: ServerResponseServiceStub;
+  let hardRedirectService: HardRedirectService;
   let router: RouterStub;
 
+  let bitstream: Bitstream;
+
   beforeEach(() => {
     route = {
       params: {},
       queryParams: {},
     };
     router = new RouterStub();
-    serverResponseService = new ServerResponseServiceStub();
+    hardRedirectService = new BrowserHardRedirectService(window.location);
     state = {};
+    bitstream = Object.assign(new Bitstream(), {
+      uuid: 'bitstream-id',
+    });
     remoteDataMocks = {
       RequestPending: new RemoteData(undefined, 0, 0, RequestEntryState.RequestPending, undefined, undefined, undefined),
       ResponsePending: new RemoteData(undefined, 0, 0, RequestEntryState.ResponsePending, undefined, undefined, undefined),
-      Success: new RemoteData(0, 0, 0, RequestEntryState.Success, undefined, new Bitstream(), 200),
+      Success: new RemoteData(0, 0, 0, RequestEntryState.Success, undefined, bitstream, 200),
       NoContent: new RemoteData(0, 0, 0, RequestEntryState.Success, undefined, undefined, 204),
       Error: new RemoteData(0, 0, 0, RequestEntryState.Error, 'Internal server error', undefined, 500),
     };
@@ -55,7 +60,7 @@ describe('legacyBitstreamURLRedirectGuard', () => {
         });
       });
       it(`should call findByItemHandle with the handle, sequence id, and filename from the route`, () => {
-        resolver(route, state, bitstreamDataService, serverResponseService, router);
+        resolver(route, state, bitstreamDataService, hardRedirectService, router);
         expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
           `${route.params.prefix}/${route.params.suffix}`,
           route.params.sequence_id,
@@ -80,7 +85,7 @@ describe('legacyBitstreamURLRedirectGuard', () => {
           });
         });
         it(`should call findByItemHandle with the handle and filename from the route, and the sequence ID from the queryParams`, () => {
-          resolver(route, state, bitstreamDataService, serverResponseService, router);
+          resolver(route, state, bitstreamDataService, hardRedirectService, router);
           expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
             `${route.params.prefix}/${route.params.suffix}`,
             route.queryParams.sequenceId,
@@ -100,7 +105,7 @@ describe('legacyBitstreamURLRedirectGuard', () => {
           });
         });
         it(`should call findByItemHandle with the handle, and filename from the route`, () => {
-          resolver(route, state, bitstreamDataService, serverResponseService, router);
+          resolver(route, state, bitstreamDataService, hardRedirectService, router);
           expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
             `${route.params.prefix}/${route.params.suffix}`,
             undefined,
@@ -110,45 +115,44 @@ describe('legacyBitstreamURLRedirectGuard', () => {
       });
     });
     describe('should return and complete after the RemoteData has...', () => {
-      it('...failed', fakeAsync(() => {
+      it('...failed', () => {
         spyOn(router, 'createUrlTree').and.callThrough();
         spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(cold('a-b-c', {
           a: remoteDataMocks.RequestPending,
           b: remoteDataMocks.ResponsePending,
           c: remoteDataMocks.Error,
         }));
-        resolver(route, state, bitstreamDataService, serverResponseService, router).subscribe(() => {
+        resolver(route, state, bitstreamDataService, hardRedirectService, router).subscribe(() => {
           expect(bitstreamDataService.findByItemHandle).toHaveBeenCalled();
           expect(router.createUrlTree).toHaveBeenCalledWith([PAGE_NOT_FOUND_PATH]);
         });
-      }));
+      });
 
-      it('...succeeded without content', fakeAsync(() => {
+      it('...succeeded without content', () => {
         spyOn(router, 'createUrlTree').and.callThrough();
         spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(cold('a-b-c', {
           a: remoteDataMocks.RequestPending,
           b: remoteDataMocks.ResponsePending,
           c: remoteDataMocks.NoContent,
         }));
-        resolver(route, state, bitstreamDataService, serverResponseService, router).subscribe(() => {
+        resolver(route, state, bitstreamDataService, hardRedirectService, router).subscribe(() => {
           expect(bitstreamDataService.findByItemHandle).toHaveBeenCalled();
           expect(router.createUrlTree).toHaveBeenCalledWith([PAGE_NOT_FOUND_PATH]);
         });
-      }));
+      });
 
-      it('...succeeded', fakeAsync(() => {
-        spyOn(serverResponseService, 'setStatus').and.callThrough();
+      it('...succeeded', () => {
+        spyOn(hardRedirectService, 'redirect');
         spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(cold('a-b-c', {
           a: remoteDataMocks.RequestPending,
           b: remoteDataMocks.ResponsePending,
           c: remoteDataMocks.Success,
         }));
-        resolver(route, state, bitstreamDataService, serverResponseService, router).subscribe(() => {
+        resolver(route, state, bitstreamDataService, hardRedirectService, router).subscribe(() => {
           expect(bitstreamDataService.findByItemHandle).toHaveBeenCalled();
-          expect(serverResponseService.setStatus).toHaveBeenCalledWith(301);
-          expect(router.parseUrl).toHaveBeenCalled();
+          expect(hardRedirectService.redirect).toHaveBeenCalledWith(new URL(`/bitstreams/${bitstream.uuid}/download`, window.location.origin).href, 301);
         });
-      }));
+      });
     });
   });
 });

src/app/bitstream-page/legacy-bitstream-url-redirect.guard.ts

@@ -7,33 +7,31 @@ import {
   UrlTree,
 } from '@angular/router';
 import { Observable } from 'rxjs';
-import {
-  map,
-  tap,
-} from 'rxjs/operators';
+import { map } from 'rxjs/operators';
 
 import { PAGE_NOT_FOUND_PATH } from '../app-routing-paths';
 import { BitstreamDataService } from '../core/data/bitstream-data.service';
 import { RemoteData } from '../core/data/remote-data';
-import { ServerResponseService } from '../core/services/server-response.service';
+import { HardRedirectService } from '../core/services/hard-redirect.service';
 import { Bitstream } from '../core/shared/bitstream.model';
 import { getFirstCompletedRemoteData } from '../core/shared/operators';
 import { hasNoValue } from '../shared/empty.util';
 
 /**
  * Redirects to a bitstream based on the handle of the item, and the sequence id or the filename of the
  * bitstream. In production mode the status code will also be set the status code to 301 marking it as a permanent URL
- * redirect for bots.
+ * redirect for bots to the regular bitstream download Page.
  *
- * @returns Observable<UrlTree> Returns a URL to redirect the user to the new URL format
+ * @returns Either a {@link UrlTree} to the 404 page when the url isn't a valid format or false in order to make the
+ * user wait until the {@link HardRedirectService#redirect} was performed
  */
 export const legacyBitstreamURLRedirectGuard: CanActivateFn = (
   route: ActivatedRouteSnapshot,
   state: RouterStateSnapshot,
   bitstreamDataService: BitstreamDataService = inject(BitstreamDataService),
-  serverResponseService: ServerResponseService = inject(ServerResponseService),
+  serverHardRedirectService: HardRedirectService = inject(HardRedirectService),
   router: Router = inject(Router),
-): Observable<UrlTree> => {
+): Observable<UrlTree | false> => {
   const prefix = route.params.prefix;
   const suffix = route.params.suffix;
   const filename = route.params.filename;
@@ -47,14 +45,10 @@ export const legacyBitstreamURLRedirectGuard: CanActivateFn = (
     filename,
   ).pipe(
     getFirstCompletedRemoteData(),
-    tap((rd: RemoteData<Bitstream>) => {
-      if (rd.hasSucceeded && !rd.hasNoContent) {
-        serverResponseService.setStatus(301);
-      }
-    }),
     map((rd: RemoteData<Bitstream>) => {
       if (rd.hasSucceeded && !rd.hasNoContent) {
-        return router.parseUrl(`/bitstreams/${rd.payload.uuid}/download`);
+        serverHardRedirectService.redirect(new URL(`/bitstreams/${rd.payload.uuid}/download`, serverHardRedirectService.getCurrentOrigin()).href, 301);
+        return false;
       } else {
         return router.createUrlTree([PAGE_NOT_FOUND_PATH]);
       }