openaire-library/claims/claim-utils/service/contexts.service.ts

167 lines
5.6 KiB
TypeScript

import {BehaviorSubject, from, Observable, Subscription, throwError as observableThrowError} from 'rxjs';
import {Injectable} from '@angular/core';
import {Response} from '@angular/http';
import {HttpClient} from '@angular/common/http';
import {catchError, map} from "rxjs/operators";
import {properties} from "../../../../../environments/environment";
@Injectable({ providedIn: 'root' })
export class ContextsService {
private communitiesSubject: BehaviorSubject<any> = new BehaviorSubject(null);
private promise: Promise<any>;
private sub: Subscription = null;
constructor(private http: HttpClient ) {
}
ngOnDestroy() {
if(this.sub) {
this.sub.unsubscribe();
}
}
public getCommunities( apiUrl:string):any {
let url = apiUrl + 's/';
return this.http.get(url)
.pipe(map(res => this.parseCommunities(res, true) ))
// .do(request => console.info("Get claims: offset = "))
.pipe(catchError(this.handleError));
}
public getPublicCommunities( apiUrl:string):any {
let url = apiUrl + 's/';
return this.http.get(url)
.pipe(map(res => this.parseCommunities(res, false) ));
}
public initCommunities() {
let url = properties.contextsAPI + 's/';
this.promise = new Promise<any>((resolve => {
this.sub = this.http.get((properties.useLongCache) ? (properties.cacheUrl + encodeURIComponent(url)) : url)
.pipe(map(res => this.parseCommunities(res, true) ))
.subscribe(
(communties) => {
this.communitiesSubject.next(communties);
resolve();
},
error => {
this.communitiesSubject.error(error);
resolve();
});
}));
}
async getCommunitiesByStateAsync(getAll: boolean) {
if(!this.promise) {
this.initCommunities();
}
await this.promise;
if(getAll) {
return this.communitiesSubject.getValue();
} else {
return this.communitiesSubject.getValue().filter(community => community.status != 'hidden');
}
}
getPublicCommunitiesByState(): Observable<any> {
return from(this.getCommunitiesByStateAsync(false));
}
getCommunitiesByState(): Observable<any> {
return from(this.getCommunitiesByStateAsync(true));
}
parseCommunities(data, getall){
var communities = [];
for(var i = 0; i< data.length; i++){
if(data[i].type && (data[i].type == "ri" || data[i].type == "community")){
if(getall || data[i].status!='hidden') {
communities.push(data[i]);
}
}
}
return communities;
}
public getCategories(communityId :string, apiUrl:string):any {
//console.info('ContextsService: request categories for community with id '+communityId);
let url= apiUrl + '/' + communityId ;
return this.http.get(url)
//.map(request => <any> request.json())
// .do(request => console.info("Get claims: offset = " ))
.pipe(catchError(this.handleError));
}
public getConcepts(categoryId :string, keyword: string, parsing:boolean, apiUrl:string):any {
//console.info('ContextsService: request concept for category with id '+categoryId + ' and keyword '+ keyword);
let url= apiUrl + '/category/' + categoryId;
return this.http.get(url )
.pipe(catchError(this.handleError))
.pipe(map(res => (parsing)?this.parse(res):res));
}
public getSubConcepts(subConceptID :string, keyword: string, parsing:boolean, apiUrl:string):any {
//console.info('ContextsService: request sub concept for concept with id '+subConceptID + ' and keyword '+ keyword);
let url= apiUrl + '/category/concept/' + subConceptID;
let key = url+"_parsing="+parsing;
return this.http.get(url )
.pipe(catchError(this.handleError))
.pipe(map(res => (parsing)?this.parseSubConcepts(res):res));
}
parse (data: any):any {
var array =[]
if(!Array.isArray(data) && data.id && data.label){
var value ={id:"",label:"",hasSubConcept:""};
value.id = data.id;
value.label = data.label;
value.hasSubConcept = data.hasSubConcept;
array.push(value);
}
for(var i = 0; i < data.length; i++){
var value={id:"",label:"",hasSubConcept:""};
value.id = data[i].id;
value.label = data[i].label;
value.hasSubConcept = data[i].hasSubConcept;
array.push(value);
}
return array;
}
parseSubConcepts (data: any):any {
var array = []
if(data.length >0 && data[0].concepts){
var concepts = data[0].concepts;
for(var i = 0; i < concepts.length; i++){
var value ={id:"",label:"",hasSubConcept:""};
value.id = concepts[i].id;
value.label = concepts[i].label;
value.hasSubConcept = concepts[i].hasSubConcept;
if(concepts[i].concepts){
var subconcepts = concepts[i].concepts;
for(var x = 0; x < subconcepts.length; x++){
var value ={id:"",label:"",hasSubConcept:""};
value.id = subconcepts[x].id;
value.label = subconcepts[x].label;
value.hasSubConcept = subconcepts[x].hasSubConcept;
array.push(value);
}
}
array.push(value);
}
}
return array;
}
private handleError (error: Response) {
// in a real world app, we may send the error to some remote logging infrastructure
// instead of just logging it to the console
console.log(error);
return observableThrowError(error || 'Server error');
}
}