D-Net

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(this.sub){

      this.sub.unsubscribe();

    }

    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 subscriptions 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');

  }

}