mirror of
https://github.com/DSpace/dspace-angular.git
synced 2025-10-08 02:24:11 +00:00
199 lines
6.3 KiB
TypeScript
199 lines
6.3 KiB
TypeScript
import { combineLatest as observableCombineLatest, Observable } from 'rxjs';
|
|
|
|
import { distinctUntilChanged, filter, first, map, mergeMap, take } from 'rxjs/operators';
|
|
import { Injectable } from '@angular/core';
|
|
import { MemoizedSelector, select, Store } from '@ngrx/store';
|
|
import { IndexName } from '../index/index.reducer';
|
|
|
|
import { CacheableObject, ObjectCacheEntry } from './object-cache.reducer';
|
|
import { AddToObjectCacheAction, RemoveFromObjectCacheAction } from './object-cache.actions';
|
|
import { hasNoValue } from '../../shared/empty.util';
|
|
import { GenericConstructor } from '../shared/generic-constructor';
|
|
import { coreSelector, CoreState } from '../core.reducers';
|
|
import { pathSelector } from '../shared/selectors';
|
|
import { NormalizedObjectFactory } from './models/normalized-object-factory';
|
|
import { NormalizedObject } from './models/normalized-object.model';
|
|
|
|
function selfLinkFromUuidSelector(uuid: string): MemoizedSelector<CoreState, string> {
|
|
return pathSelector<CoreState, string>(coreSelector, 'index', IndexName.OBJECT, uuid);
|
|
}
|
|
|
|
function entryFromSelfLinkSelector(selfLink: string): MemoizedSelector<CoreState, ObjectCacheEntry> {
|
|
return pathSelector<CoreState, ObjectCacheEntry>(coreSelector, 'data/object', selfLink);
|
|
}
|
|
|
|
/**
|
|
* A service to interact with the object cache
|
|
*/
|
|
@Injectable()
|
|
export class ObjectCacheService {
|
|
constructor(private store: Store<CoreState>) {
|
|
}
|
|
|
|
/**
|
|
* Add an object to the cache
|
|
*
|
|
* @param objectToCache
|
|
* The object to add
|
|
* @param msToLive
|
|
* The number of milliseconds it should be cached for
|
|
* @param requestHref
|
|
* The selfLink of the request that resulted in this object
|
|
* This isn't necessarily the same as the object's self
|
|
* link, it could have been part of a list for example
|
|
*/
|
|
add(objectToCache: CacheableObject, msToLive: number, requestHref: string): void {
|
|
this.store.dispatch(new AddToObjectCacheAction(objectToCache, new Date().getTime(), msToLive, requestHref));
|
|
}
|
|
|
|
/**
|
|
* Remove the object with the supplied UUID from the cache
|
|
*
|
|
* @param uuid
|
|
* The UUID of the object to be removed
|
|
*/
|
|
remove(uuid: string): void {
|
|
this.store.dispatch(new RemoveFromObjectCacheAction(uuid));
|
|
}
|
|
|
|
/**
|
|
* Get an observable of the object with the specified UUID
|
|
*
|
|
* The type needs to be specified as well, in order to turn
|
|
* the cached plain javascript object in to an instance of
|
|
* a class.
|
|
*
|
|
* e.g. getByUUID('c96588c6-72d3-425d-9d47-fa896255a695', Item)
|
|
*
|
|
* @param uuid
|
|
* The UUID of the object to get
|
|
* @param type
|
|
* The type of the object to get
|
|
* @return Observable<T>
|
|
* An observable of the requested object
|
|
*/
|
|
getByUUID<T extends NormalizedObject>(uuid: string): Observable<T> {
|
|
return this.store.pipe(
|
|
select(selfLinkFromUuidSelector(uuid)),
|
|
mergeMap((selfLink: string) => this.getBySelfLink(selfLink)
|
|
)
|
|
)
|
|
}
|
|
|
|
getBySelfLink<T extends NormalizedObject>(selfLink: string): Observable<T> {
|
|
return this.getEntry(selfLink).pipe(
|
|
map((entry: ObjectCacheEntry) => {
|
|
const type: GenericConstructor<NormalizedObject> = NormalizedObjectFactory.getConstructor(entry.data.type);
|
|
return Object.assign(new type(), entry.data) as T
|
|
}));
|
|
}
|
|
|
|
private getEntry(selfLink: string): Observable<ObjectCacheEntry> {
|
|
return this.store.pipe(
|
|
select(entryFromSelfLinkSelector(selfLink)),
|
|
filter((entry) => this.isValid(entry)),
|
|
distinctUntilChanged()
|
|
);
|
|
}
|
|
|
|
getRequestHrefBySelfLink(selfLink: string): Observable<string> {
|
|
return this.getEntry(selfLink).pipe(
|
|
map((entry: ObjectCacheEntry) => entry.requestHref),
|
|
distinctUntilChanged(),);
|
|
}
|
|
|
|
getRequestHrefByUUID(uuid: string): Observable<string> {
|
|
return this.store.pipe(
|
|
select(selfLinkFromUuidSelector(uuid)),
|
|
mergeMap((selfLink: string) => this.getRequestHrefBySelfLink(selfLink))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get an observable for an array of objects of the same type
|
|
* with the specified self links
|
|
*
|
|
* The type needs to be specified as well, in order to turn
|
|
* the cached plain javascript object in to an instance of
|
|
* a class.
|
|
*
|
|
* e.g. getList([
|
|
* 'http://localhost:8080/api/core/collections/c96588c6-72d3-425d-9d47-fa896255a695',
|
|
* 'http://localhost:8080/api/core/collections/cff860da-cf5f-4fda-b8c9-afb7ec0b2d9e'
|
|
* ], Collection)
|
|
*
|
|
* @param selfLinks
|
|
* An array of self links of the objects to get
|
|
* @param type
|
|
* The type of the objects to get
|
|
* @return Observable<Array<T>>
|
|
*/
|
|
getList<T extends NormalizedObject>(selfLinks: string[]): Observable<T[]> {
|
|
return observableCombineLatest(
|
|
selfLinks.map((selfLink: string) => this.getBySelfLink<T>(selfLink))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Check whether the object with the specified UUID is cached
|
|
*
|
|
* @param uuid
|
|
* The UUID of the object to check
|
|
* @return boolean
|
|
* true if the object with the specified UUID is cached,
|
|
* false otherwise
|
|
*/
|
|
hasByUUID(uuid: string): boolean {
|
|
let result: boolean;
|
|
|
|
this.store.pipe(
|
|
select(selfLinkFromUuidSelector(uuid)),
|
|
first()
|
|
).subscribe((selfLink: string) => result = this.hasBySelfLink(selfLink));
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check whether the object with the specified self link is cached
|
|
*
|
|
* @param selfLink
|
|
* The self link of the object to check
|
|
* @return boolean
|
|
* true if the object with the specified self link is cached,
|
|
* false otherwise
|
|
*/
|
|
hasBySelfLink(selfLink: string): boolean {
|
|
let result = false;
|
|
|
|
this.store.pipe(select(entryFromSelfLinkSelector(selfLink)),
|
|
first()
|
|
).subscribe((entry: ObjectCacheEntry) => result = this.isValid(entry));
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check whether an ObjectCacheEntry should still be cached
|
|
*
|
|
* @param entry
|
|
* the entry to check
|
|
* @return boolean
|
|
* false if the entry is null, undefined, or its time to
|
|
* live has been exceeded, true otherwise
|
|
*/
|
|
private isValid(entry: ObjectCacheEntry): boolean {
|
|
if (hasNoValue(entry)) {
|
|
return false;
|
|
} else {
|
|
const timeOutdated = entry.timeAdded + entry.msToLive;
|
|
const isOutDated = new Date().getTime() > timeOutdated;
|
|
if (isOutDated) {
|
|
this.store.dispatch(new RemoveFromObjectCacheAction(entry.data.self));
|
|
}
|
|
return !isOutDated;
|
|
}
|
|
}
|
|
|
|
}
|