hazza/dspace-angular
1
0
Fork 1
mirror of https://github.com/DSpace/dspace-angular.git synced 2025-10-18 07:23:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3087 from DSpace/backport-3062-to-dspace-7_x

Browse Source 
[Port dspace-7_x] Made legacy bitstream URLs redirect with 301 status code
This commit is contained in:
Tim Donohue
2024-05-29 15:00:44 -05:00
committed by GitHub
parent 975e9fd356 c332600633
commit a3a298f51e
7 changed files with 248 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/app/bitstream-page/bitstream-page-routing.module.ts
View File

@@ -8,7 +8,7 @@ import { ResourcePolicyCreateComponent } from '../shared/resource-policies/creat
import { ResourcePolicyResolver } from '../shared/resource-policies/resolvers/resource-policy.resolver';
import { ResourcePolicyEditComponent } from '../shared/resource-policies/edit/resource-policy-edit.component';
import { BitstreamAuthorizationsComponent } from './bitstream-authorizations/bitstream-authorizations.component';
import { LegacyBitstreamUrlResolver } from './legacy-bitstream-url.resolver';
import { legacyBitstreamURLRedirectGuard } from './legacy-bitstream-url-redirect.guard';
import { BitstreamBreadcrumbResolver } from '../core/breadcrumbs/bitstream-breadcrumb.resolver';
import { BitstreamBreadcrumbsService } from '../core/breadcrumbs/bitstream-breadcrumbs.service';
import { I18nBreadcrumbResolver } from '../core/breadcrumbs/i18n-breadcrumb.resolver';
@@ -27,17 +27,13 @@ const EDIT_BITSTREAM_AUTHORIZATIONS_PATH = ':id/authorizations';
// Resolve XMLUI bitstream download URLs
path: 'handle/:prefix/:suffix/:filename',
component: BitstreamDownloadPageComponent,
resolve: {
bitstream: LegacyBitstreamUrlResolver
},
canActivate: [legacyBitstreamURLRedirectGuard],
},
{
// Resolve JSPUI bitstream download URLs
path: ':prefix/:suffix/:sequence_id/:filename',
component: BitstreamDownloadPageComponent,
resolve: {
bitstream: LegacyBitstreamUrlResolver
},
canActivate: [legacyBitstreamURLRedirectGuard],
},
{
// Resolve angular bitstream download URLs

158
src/app/bitstream-page/legacy-bitstream-url-redirect.guard.spec.ts Normal file
View File

@@ -0,0 +1,158 @@
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 { legacyBitstreamURLRedirectGuard } from './legacy-bitstream-url-redirect.guard';
describe('legacyBitstreamURLRedirectGuard', () => {
let resolver: any;
let bitstreamDataService: BitstreamDataService;
let remoteDataMocks: { [type: string]: RemoteData<any> };
let route;
let state;
let hardRedirectService: HardRedirectService;
let router: RouterStub;
let bitstream: Bitstream;
beforeEach(() => {
route = {
params: {},
queryParams: {}
};
router = new RouterStub();
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, 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),
};
bitstreamDataService = {
findByItemHandle: () => undefined
} as any;
resolver = legacyBitstreamURLRedirectGuard;
});
describe(`resolve`, () => {
describe(`For JSPUI-style URLs`, () => {
beforeEach(() => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(EMPTY);
route = Object.assign({}, route, {
params: {
prefix: '123456789',
suffix: '1234',
filename: 'some-file.pdf',
sequence_id: '5'
}
});
});
it(`should call findByItemHandle with the handle, sequence id, and filename from the route`, () => {
resolver(route, state, bitstreamDataService, hardRedirectService, router);
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
`${route.params.prefix}/${route.params.suffix}`,
route.params.sequence_id,
route.params.filename
);
});
});
describe(`For XMLUI-style URLs`, () => {
describe(`when there is a sequenceId query parameter`, () => {
beforeEach(() => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(EMPTY);
route = Object.assign({}, route, {
params: {
prefix: '123456789',
suffix: '1234',
filename: 'some-file.pdf',
},
queryParams: {
sequenceId: '5'
}
});
});
it(`should call findByItemHandle with the handle and filename from the route, and the sequence ID from the queryParams`, () => {
resolver(route, state, bitstreamDataService, hardRedirectService, router);
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
`${route.params.prefix}/${route.params.suffix}`,
route.queryParams.sequenceId,
route.params.filename
);
});
});
describe(`when there's no sequenceId query parameter`, () => {
beforeEach(() => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(EMPTY);
route = Object.assign({}, route, {
params: {
prefix: '123456789',
suffix: '1234',
filename: 'some-file.pdf',
},
});
});
it(`should call findByItemHandle with the handle, and filename from the route`, () => {
resolver(route, state, bitstreamDataService, hardRedirectService, router);
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
`${route.params.prefix}/${route.params.suffix}`,
undefined,
route.params.filename
);
});
});
});
describe('should return and complete after the RemoteData has...', () => {
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, hardRedirectService, router).subscribe(() => {
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalled();
expect(router.createUrlTree).toHaveBeenCalledWith([PAGE_NOT_FOUND_PATH]);
});
});
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, hardRedirectService, router).subscribe(() => {
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalled();
expect(router.createUrlTree).toHaveBeenCalledWith([PAGE_NOT_FOUND_PATH]);
});
});
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, hardRedirectService, router).subscribe(() => {
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalled();
expect(hardRedirectService.redirect).toHaveBeenCalledWith(new URL(`/bitstreams/${bitstream.uuid}/download`, window.location.origin).href, 301);
});
});
});
});
});

56
src/app/bitstream-page/legacy-bitstream-url-redirect.guard.ts Normal file
View File

@@ -0,0 +1,56 @@
import { inject } from '@angular/core';
import {
ActivatedRouteSnapshot,
CanActivateFn,
Router,
RouterStateSnapshot,
UrlTree,
} from '@angular/router';
import { Observable } from 'rxjs';
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 { 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.
*
* @returns Observable<UrlTree> Returns a URL to redirect the user to the new URL format
*/
export const legacyBitstreamURLRedirectGuard: CanActivateFn = (
route: ActivatedRouteSnapshot,
state: RouterStateSnapshot,
bitstreamDataService: BitstreamDataService = inject(BitstreamDataService),
serverHardRedirectService: HardRedirectService = inject(HardRedirectService),
router: Router = inject(Router),
): Observable<UrlTree | boolean> => {
const prefix = route.params.prefix;
const suffix = route.params.suffix;
const filename = route.params.filename;
let sequenceId = route.params.sequence_id;
if (hasNoValue(sequenceId)) {
sequenceId = route.queryParams.sequenceId;
}
return bitstreamDataService.findByItemHandle(
`${prefix}/${suffix}`,
sequenceId,
filename,
).pipe(
getFirstCompletedRemoteData(),
map((rd: RemoteData<Bitstream>) => {
if (rd.hasSucceeded && !rd.hasNoContent) {
serverHardRedirectService.redirect(new URL(`/bitstreams/${rd.payload.uuid}/download`, serverHardRedirectService.getCurrentOrigin()).href, 301);
return false;
} else {
return router.createUrlTree([PAGE_NOT_FOUND_PATH]);
}
})
);
};

145
src/app/bitstream-page/legacy-bitstream-url.resolver.spec.ts
View File

@@ -1,145 +0,0 @@
import { LegacyBitstreamUrlResolver } from './legacy-bitstream-url.resolver';
import { EMPTY } from 'rxjs';
import { BitstreamDataService } from '../core/data/bitstream-data.service';
import { RemoteData } from '../core/data/remote-data';
import { TestScheduler } from 'rxjs/testing';
import { RequestEntryState } from '../core/data/request-entry-state.model';
describe(`LegacyBitstreamUrlResolver`, () => {
let resolver: LegacyBitstreamUrlResolver;
let bitstreamDataService: BitstreamDataService;
let testScheduler;
let remoteDataMocks;
let route;
let state;
beforeEach(() => {
testScheduler = new TestScheduler((actual, expected) => {
expect(actual).toEqual(expected);
});
route = {
params: {},
queryParams: {}
};
state = {};
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, {}, 200),
Error: new RemoteData(0, 0, 0, RequestEntryState.Error, 'Internal server error', undefined, 500),
};
bitstreamDataService = {
findByItemHandle: () => undefined
} as any;
resolver = new LegacyBitstreamUrlResolver(bitstreamDataService);
});
describe(`resolve`, () => {
describe(`For JSPUI-style URLs`, () => {
beforeEach(() => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(EMPTY);
route = Object.assign({}, route, {
params: {
prefix: '123456789',
suffix: '1234',
filename: 'some-file.pdf',
sequence_id: '5'
}
});
});
it(`should call findByItemHandle with the handle, sequence id, and filename from the route`, () => {
testScheduler.run(() => {
resolver.resolve(route, state);
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
`${route.params.prefix}/${route.params.suffix}`,
route.params.sequence_id,
route.params.filename
);
});
});
});
describe(`For XMLUI-style URLs`, () => {
describe(`when there is a sequenceId query parameter`, () => {
beforeEach(() => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(EMPTY);
route = Object.assign({}, route, {
params: {
prefix: '123456789',
suffix: '1234',
filename: 'some-file.pdf',
},
queryParams: {
sequenceId: '5'
}
});
});
it(`should call findByItemHandle with the handle and filename from the route, and the sequence ID from the queryParams`, () => {
testScheduler.run(() => {
resolver.resolve(route, state);
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
`${route.params.prefix}/${route.params.suffix}`,
route.queryParams.sequenceId,
route.params.filename
);
});
});
});
describe(`when there's no sequenceId query parameter`, () => {
beforeEach(() => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(EMPTY);
route = Object.assign({}, route, {
params: {
prefix: '123456789',
suffix: '1234',
filename: 'some-file.pdf',
},
});
});
it(`should call findByItemHandle with the handle, and filename from the route`, () => {
testScheduler.run(() => {
resolver.resolve(route, state);
expect(bitstreamDataService.findByItemHandle).toHaveBeenCalledWith(
`${route.params.prefix}/${route.params.suffix}`,
undefined,
route.params.filename
);
});
});
});
});
describe(`should return and complete after the remotedata has...`, () => {
it(`...failed`, () => {
testScheduler.run(({ cold, expectObservable }) => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(cold('a-b-c', {
a: remoteDataMocks.RequestPending,
b: remoteDataMocks.ResponsePending,
c: remoteDataMocks.Error,
}));
const expected = '----(c|)';
const values = {
c: remoteDataMocks.Error,
};
expectObservable(resolver.resolve(route, state)).toBe(expected, values);
});
});
it(`...succeeded`, () => {
testScheduler.run(({ cold, expectObservable }) => {
spyOn(bitstreamDataService, 'findByItemHandle').and.returnValue(cold('a-b-c', {
a: remoteDataMocks.RequestPending,
b: remoteDataMocks.ResponsePending,
c: remoteDataMocks.Success,
}));
const expected = '----(c|)';
const values = {
c: remoteDataMocks.Success,
};
expectObservable(resolver.resolve(route, state)).toBe(expected, values);
});
});
});
});
});

48
src/app/bitstream-page/legacy-bitstream-url.resolver.ts
View File

@@ -1,48 +0,0 @@
import { Injectable } from '@angular/core';
import { ActivatedRouteSnapshot, Resolve, RouterStateSnapshot } from '@angular/router';
import { Observable } from 'rxjs';
import { RemoteData } from '../core/data/remote-data';
import { Bitstream } from '../core/shared/bitstream.model';
import { getFirstCompletedRemoteData } from '../core/shared/operators';
import { hasNoValue } from '../shared/empty.util';
import { BitstreamDataService } from '../core/data/bitstream-data.service';
/**
* This class resolves a bitstream based on the DSpace 6 XMLUI or JSPUI bitstream download URLs
*/
@Injectable({
providedIn: 'root'
})
export class LegacyBitstreamUrlResolver implements Resolve<RemoteData<Bitstream>> {
constructor(protected bitstreamDataService: BitstreamDataService) {
}
/**
* Resolve a bitstream based on the handle of the item, and the sequence id or the filename of the
* bitstream
*
* @param {ActivatedRouteSnapshot} route The current ActivatedRouteSnapshot
* @param {RouterStateSnapshot} state The current RouterStateSnapshot
* @returns Observable<<RemoteData<Item>> Emits the found bitstream based on the parameters in
* current route, or an error if something went wrong
*/
resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot):
Observable<RemoteData<Bitstream>> {
const prefix = route.params.prefix;
const suffix = route.params.suffix;
const filename = route.params.filename;
let sequenceId = route.params.sequence_id;
if (hasNoValue(sequenceId)) {
sequenceId = route.queryParams.sequenceId;
}
return this.bitstreamDataService.findByItemHandle(
`${prefix}/${suffix}`,
sequenceId,
filename,
).pipe(
getFirstCompletedRemoteData()
);
}
}

2
src/app/core/data/bitstream-data.service.ts
View File

@@ -171,7 +171,7 @@ export class BitstreamDataService extends IdentifiableDataService<Bitstream> imp
searchParams.push(new RequestParam('sequenceId', sequenceId));
}
if (hasValue(filename)) {
searchParams.push(new RequestParam('filename', filename));
searchParams.push(new RequestParam('filename', encodeURIComponent(filename)));
}
const hrefObs = this.getSearchByHref(

30
src/app/shared/testing/server-response-service.stub.ts Normal file
View File

@@ -0,0 +1,30 @@
/* eslint-disable no-empty,@typescript-eslint/no-empty-function */
/**
* Stub class of {@link ServerResponseService}
*/
export class ServerResponseServiceStub {
setStatus(_code: number, _message?: string): this {
return this;
}
setUnauthorized(_message = 'Unauthorized'): this {
return this;
}
setForbidden(_message = 'Forbidden'): this {
return this;
}
setNotFound(_message = 'Not found'): this {
return this;
}
setInternalServerError(_message = 'Internal Server Error'): this {
return this;
}
setHeader(_header: string, _content: string): void {
}
}