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

Merge remote-tracking branch 'remotes/origin/master' into submission

Browse Source 
# Conflicts:
#	package.json
#	src/app/+item-page/edit-item-page/item-delete/item-delete.component.spec.ts
#	src/app/+item-page/edit-item-page/item-private/item-private.component.spec.ts
#	src/app/+item-page/edit-item-page/item-public/item-public.component.spec.ts
#	src/app/+item-page/edit-item-page/item-reinstate/item-reinstate.component.spec.ts
#	src/app/+item-page/edit-item-page/item-withdraw/item-withdraw.component.spec.ts
#	src/app/+item-page/edit-item-page/simple-item-action/abstract-simple-item-action.component.spec.ts
#	src/app/+search-page/search-service/search.service.spec.ts
#	src/app/core/auth/auth-response-parsing.service.spec.ts
#	src/app/core/auth/auth-response-parsing.service.ts
#	src/app/core/cache/builders/remote-data-build.service.ts
#	src/app/core/cache/response-cache.reducer.spec.ts
#	src/app/core/cache/response-cache.service.spec.ts
#	src/app/core/cache/response.models.ts
#	src/app/core/config/config-response-parsing.service.ts
#	src/app/core/core.effects.ts
#	src/app/core/core.module.ts
#	src/app/core/core.reducers.ts
#	src/app/core/data/base-response-parsing.service.ts
#	src/app/core/data/data.service.ts
#	src/app/core/data/item-data.service.spec.ts
#	src/app/core/data/request.models.ts
#	src/app/core/data/request.service.spec.ts
#	src/app/core/data/request.service.ts
#	src/app/core/integration/integration-response-parsing.service.spec.ts
#	src/app/core/integration/integration-response-parsing.service.ts
#	src/app/core/integration/integration.service.ts
#	src/app/core/metadata/metadata.service.spec.ts
#	src/app/core/registry/registry.service.spec.ts
#	src/app/core/shared/hal-endpoint.service.ts
#	src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control.component.ts
#	src/app/shared/mocks/mock-response-cache.service.ts
#	src/app/shared/shared.module.ts
This commit is contained in:
Giuseppe Digilio
2019-02-19 17:30:33 +01:00
parent efdc351de0 34e78bd495
commit 880d9ed069
192 changed files with 4412 additions and 1690 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
src/app/core/data/data.service.ts
View File

@@ -1,37 +1,73 @@
import { distinctUntilChanged, filter, first, map } from 'rxjs/operators';
import { Observable } from 'rxjs';
import {
distinctUntilChanged,
filter,
find,
first,
map,
mergeMap,
switchMap,
take
} from 'rxjs/operators';
import { Observable } from 'rxjs';
import { Store } from '@ngrx/store';
import { hasValue, isNotEmpty } from '../../shared/empty.util';
import { hasValue, isNotEmpty, isNotEmptyOperator } from '../../shared/empty.util';
import { RemoteDataBuildService } from '../cache/builders/remote-data-build.service';
import { ResponseCacheService } from '../cache/response-cache.service';
import { CoreState } from '../core.reducers';
import { HALEndpointService } from '../shared/hal-endpoint.service';
import { URLCombiner } from '../url-combiner/url-combiner';
import { PaginatedList } from './paginated-list';
import { RemoteData } from './remote-data';
import { FindAllOptions, FindAllRequest, FindByIDRequest, GetRequest } from './request.models';
import {
CreateRequest,
DeleteByIDRequest,
FindAllOptions,
FindAllRequest,
FindByIDRequest,
GetRequest
} from './request.models';
import { RequestService } from './request.service';
import { HttpOptions } from '../dspace-rest-v2/dspace-rest-v2.service';
import { NormalizedObject } from '../cache/models/normalized-object.model';
import { SearchParam } from '../cache/models/search-param.model';
import { Operation } from 'fast-json-patch';
import { ObjectCacheService } from '../cache/object-cache.service';
import { DSpaceObject } from '../shared/dspace-object.model';
import { NotificationsService } from '../../shared/notifications/notifications.service';
import { HttpClient } from '@angular/common/http';
import { configureRequest, getResponseFromEntry } from '../shared/operators';
import { ErrorResponse, RestResponse } from '../cache/response.models';
import { NotificationOptions } from '../../shared/notifications/models/notification-options.model';
import { DSpaceRESTv2Serializer } from '../dspace-rest-v2/dspace-rest-v2.serializer';
import { NormalizedObjectFactory } from '../cache/models/normalized-object-factory';
import { CacheableObject } from '../cache/object-cache.reducer';
import { RequestEntry } from './request.reducer';
import { NormalizedObjectBuildService } from '../cache/builders/normalized-object-build.service';
import { ChangeAnalyzer } from './change-analyzer';
export abstract class DataService<TNormalized extends NormalizedObject, TDomain> {
protected abstract responseCache: ResponseCacheService;
export abstract class DataService<TNormalized extends NormalizedObject, TDomain extends CacheableObject> {
protected abstract requestService: RequestService;
protected abstract rdbService: RemoteDataBuildService;
protected abstract dataBuildService: NormalizedObjectBuildService;
protected abstract store: Store<CoreState>;
protected abstract linkPath: string;
protected abstract halService: HALEndpointService;
protected abstract forceBypassCache = false;
protected abstract objectCache: ObjectCacheService;
protected abstract notificationsService: NotificationsService;
protected abstract http: HttpClient;
protected abstract comparator: ChangeAnalyzer<TNormalized>;
public abstract getBrowseEndpoint(options: FindAllOptions): Observable<string>
public abstract getBrowseEndpoint(options: FindAllOptions, linkPath?: string): Observable<string>
protected getFindAllHref(options: FindAllOptions = {}): Observable<string> {
protected getFindAllHref(options: FindAllOptions = {}, linkPath?: string): Observable<string> {
let result: Observable<string>;
const args = [];
result = this.getBrowseEndpoint(options).pipe(distinctUntilChanged());
result = this.getBrowseEndpoint(options, linkPath).pipe(distinctUntilChanged());
return this.buildHrefFromFindOptions(result, args, options);
}
@@ -57,19 +93,15 @@ export abstract class DataService<TNormalized extends NormalizedObject, TDomain>
/* TODO: this is a temporary fix for the pagination start index (0 or 1) discrepancy between the rest and the frontend respectively */
args.push(`page=${options.currentPage - 1}`);
}
if (hasValue(options.elementsPerPage)) {
args.push(`size=${options.elementsPerPage}`);
}
if (hasValue(options.sort)) {
args.push(`sort=${options.sort.field},${options.sort.direction}`);
}
if (hasValue(options.startsWith)) {
args.push(`startsWith=${options.startsWith}`);
}
if (isNotEmpty(args)) {
return href$.pipe(map((href: string) => new URLCombiner(href, `?${args.join('&')}`).toString()));
} else {
@@ -90,16 +122,21 @@ export abstract class DataService<TNormalized extends NormalizedObject, TDomain>
return this.rdbService.buildList<TNormalized, TDomain>(hrefObs) as Observable<RemoteData<PaginatedList<TDomain>>>;
}
getFindByIDHref(endpoint, resourceID): string {
/**
* Create the HREF for a specific object based on its identifier
* @param endpoint The base endpoint for the type of object
* @param resourceID The identifier for the object
*/
getIDHref(endpoint, resourceID): string {
return `${endpoint}/${resourceID}`;
}
findById(id: string): Observable<RemoteData<TDomain>> {
const hrefObs = this.halService.getEndpoint(this.linkPath).pipe(
map((endpoint: string) => this.getFindByIDHref(endpoint, id)));
map((endpoint: string) => this.getIDHref(endpoint, id)));
hrefObs.pipe(
first((href: string) => hasValue(href)))
find((href: string) => hasValue(href)))
.subscribe((href: string) => {
const request = new FindByIDRequest(this.requestService.generateRequestId(), href, id);
this.requestService.configure(request, this.forceBypassCache);
@@ -133,21 +170,110 @@ export abstract class DataService<TNormalized extends NormalizedObject, TDomain>
return this.rdbService.buildList<TNormalized, TDomain>(hrefObs) as Observable<RemoteData<PaginatedList<TDomain>>>;
}
// TODO implement, after the structure of the REST server's POST response is finalized
// create(dso: DSpaceObject): Observable<RemoteData<TDomain>> {
// const postHrefObs = this.getEndpoint();
//
// // TODO ID is unknown at this point
// const idHrefObs = postHrefObs.map((href: string) => this.getFindByIDHref(href, dso.id));
//
// postHrefObs
// .filter((href: string) => hasValue(href))
// .take(1)
// .subscribe((href: string) => {
// const request = new RestRequest(this.requestService.generateRequestId(), href, RestRequestMethod.Post, dso);
// this.requestService.configure(request);
// });
//
// return this.rdbService.buildSingle<TNormalized, TDomain>(idHrefObs, this.normalizedResourceType);
// }
/**
* Add a new patch to the object cache to a specified object
* @param {string} href The selflink of the object that will be patched
* @param {Operation[]} operations The patch operations to be performed
*/
patch(href: string, operations: Operation[]) {
this.objectCache.addPatch(href, operations);
}
/**
* Add a new patch to the object cache
* The patch is derived from the differences between the given object and its version in the object cache
* @param {DSpaceObject} object The given object
*/
update(object: TDomain): Observable<RemoteData<TDomain>> {
const oldVersion$ = this.objectCache.getBySelfLink(object.self);
return oldVersion$.pipe(first(), mergeMap((oldVersion: TNormalized) => {
const newVersion = this.dataBuildService.normalize<TDomain, TNormalized>(object);
const operations = this.comparator.diff(oldVersion, newVersion);
if (isNotEmpty(operations)) {
this.objectCache.addPatch(object.self, operations);
}
return this.findById(object.uuid);
}
));
}
/**
* Create a new DSpaceObject on the server, and store the response
* in the object cache
*
* @param {DSpaceObject} dso
* The object to create
* @param {string} parentUUID
* The UUID of the parent to create the new object under
*/
create(dso: TDomain, parentUUID: string): Observable<RemoteData<TDomain>> {
const requestId = this.requestService.generateRequestId();
const endpoint$ = this.halService.getEndpoint(this.linkPath).pipe(
isNotEmptyOperator(),
distinctUntilChanged(),
map((endpoint: string) => parentUUID ? `${endpoint}?parent=${parentUUID}` : endpoint)
);
const normalizedObject: TNormalized = this.dataBuildService.normalize<TDomain, TNormalized>(dso);
const serializedDso = new DSpaceRESTv2Serializer(NormalizedObjectFactory.getConstructor(dso.type)).serialize(normalizedObject);
const request$ = endpoint$.pipe(
take(1),
map((endpoint: string) => new CreateRequest(requestId, endpoint, JSON.stringify(serializedDso)))
);
// Execute the post request
request$.pipe(
configureRequest(this.requestService)
).subscribe();
// Resolve self link for new object
const selfLink$ = this.requestService.getByUUID(requestId).pipe(
getResponseFromEntry(),
map((response: RestResponse) => {
if (!response.isSuccessful && response instanceof ErrorResponse) {
this.notificationsService.error('Server Error:', response.errorMessage, new NotificationOptions(-1));
} else {
return response;
}
}),
map((response: any) => {
if (isNotEmpty(response.resourceSelfLinks)) {
return response.resourceSelfLinks[0];
}
}),
distinctUntilChanged()
) as Observable<string>;
return selfLink$.pipe(
switchMap((selfLink: string) => this.findByHref(selfLink)),
)
}
/**
* Delete an existing DSpace Object on the server
* @param dso The DSpace Object to be removed
* Return an observable that emits true when the deletion was successful, false when it failed
*/
delete(dso: TDomain): Observable<boolean> {
const requestId = this.requestService.generateRequestId();
const hrefObs = this.halService.getEndpoint(this.linkPath).pipe(
map((endpoint: string) => this.getIDHref(endpoint, dso.uuid)));
hrefObs.pipe(
find((href: string) => hasValue(href)),
map((href: string) => {
const request = new DeleteByIDRequest(requestId, href, dso.uuid);
this.requestService.configure(request);
})
).subscribe();
return this.requestService.getByUUID(requestId).pipe(
find((request: RequestEntry) => request.completed),
map((request: RequestEntry) => request.response.isSuccessful)
);
}
}