forked from hazza/dspace-angular
70 lines
3.3 KiB
TypeScript
70 lines
3.3 KiB
TypeScript
import { Injectable, Inject } from "@angular/core";
|
|
import { Actions, Effect } from "@ngrx/effects";
|
|
import { Store } from "@ngrx/store";
|
|
import { DSpaceRESTv2Service } from "../dspace-rest-v2/dspace-rest-v2.service";
|
|
import { ObjectCacheService } from "../cache/object-cache.service";
|
|
import { DSpaceRESTV2Response } from "../dspace-rest-v2/dspace-rest-v2-response.model";
|
|
import { DSpaceRESTv2Serializer } from "../dspace-rest-v2/dspace-rest-v2.serializer";
|
|
import { CacheableObject } from "../cache/object-cache.reducer";
|
|
import { Observable } from "rxjs";
|
|
import { Response, SuccessResponse, ErrorResponse } from "../cache/response-cache.models";
|
|
import { hasNoValue } from "../../shared/empty.util";
|
|
import { GlobalConfig, GLOBAL_CONFIG } from "../../../config";
|
|
import { RequestState, RequestEntry } from "./request.reducer";
|
|
import {
|
|
RequestActionTypes, RequestConfigureAction, RequestExecuteAction,
|
|
RequestCompleteAction
|
|
} from "./request.actions";
|
|
import { ResponseCacheService } from "../cache/response-cache.service";
|
|
|
|
@Injectable()
|
|
export class RequestEffects {
|
|
|
|
constructor(
|
|
@Inject(GLOBAL_CONFIG) private EnvConfig: GlobalConfig,
|
|
private actions$: Actions,
|
|
private restApi: DSpaceRESTv2Service,
|
|
private objectCache: ObjectCacheService,
|
|
private responseCache: ResponseCacheService,
|
|
private store: Store<RequestState>
|
|
) { }
|
|
|
|
@Effect() execute = this.actions$
|
|
.ofType(RequestActionTypes.EXECUTE)
|
|
.flatMap((action: RequestExecuteAction) => {
|
|
return this.store.select<RequestEntry>('core', 'data', 'request', action.payload)
|
|
.take(1);
|
|
})
|
|
.flatMap((entry: RequestEntry) => {
|
|
const [ifArray, ifNotArray] = this.restApi.get(entry.request.href)
|
|
.share() // share ensures restApi.get() doesn't get called twice when the partitions are used below
|
|
.partition((data: DSpaceRESTV2Response) => Array.isArray(data._embedded));
|
|
|
|
return Observable.merge(
|
|
|
|
ifArray.map((data: DSpaceRESTV2Response) => {
|
|
return new DSpaceRESTv2Serializer(entry.request.resourceType).deserializeArray(data);
|
|
}).do((cos: CacheableObject[]) => cos.forEach((t) => this.addToObjectCache(t)))
|
|
.map((cos: Array<CacheableObject>): Array<string> => cos.map(t => t.uuid)),
|
|
|
|
ifNotArray.map((data: DSpaceRESTV2Response) => {
|
|
return new DSpaceRESTv2Serializer(entry.request.resourceType).deserialize(data);
|
|
}).do((co: CacheableObject) => this.addToObjectCache(co))
|
|
.map((co: CacheableObject): Array<string> => [co.uuid])
|
|
|
|
).map((ids: Array<string>) => new SuccessResponse(ids))
|
|
.do((response: Response) => this.responseCache.add(entry.request.href, response, this.EnvConfig.cache.msToLive))
|
|
.map((response: Response) => new RequestCompleteAction(entry.request.href))
|
|
.catch((error: Error) => Observable.of(new ErrorResponse(error.message))
|
|
.do((response: Response) => this.responseCache.add(entry.request.href, response, this.EnvConfig.cache.msToLive))
|
|
.map((response: Response) => new RequestCompleteAction(entry.request.href)));
|
|
});
|
|
|
|
protected addToObjectCache(co: CacheableObject): void {
|
|
if (hasNoValue(co) || hasNoValue(co.uuid)) {
|
|
throw new Error('The server returned an invalid object');
|
|
}
|
|
this.objectCache.add(co, this.EnvConfig.cache.msToLive);
|
|
}
|
|
}
|