D-Net

import {Injectable} from '@angular/core';

import {Http, Response} from '@angular/http';

import {HttpClient, HttpErrorResponse} from "@angular/common/http";

import {Observable, throwError} from 'rxjs';

import {AutoCompleteValue} from '../searchPages/searchUtils/searchHelperClasses.class';

import {RefineResultsUtils} from './servicesUtils/refineResults.class';

import{EnvProperties} from '../utils/properties/env-properties';

import {map} from "rxjs/operators";

@Injectable()

export class RefineFieldResultsService {

     constructor(private http: HttpClient ) {}

     getRefineFieldsResultsByEntityName(fields:string[], entityName:string, properties:EnvProperties, communityQuery=null):any{

        let url = properties.searchAPIURLLAst + this.getSearchAPIURLForEntity(entityName)+"?format=json&refine=true&page=1&size=0";

        for(var i=0; i < fields.length; i++){

            url += "&fields="+fields[i];

        }

        if(communityQuery!= null && communityQuery != ''  ) {

            url += communityQuery;

        }

        return this.http.get((properties.useCache)? (properties.cacheUrl+encodeURIComponent(url)): url)

                    //.map(res => <any> res.json())

                    .pipe(map(res =>   [res['meta'].total, RefineResultsUtils.parse(res['refineResults'],fields, entityName)]));

     }

    getRefineFieldResultsByFieldName(fieldName:string, entityName:string, properties:EnvProperties):any{

       let link = properties.searchAPIURLLAst +this.getSearchAPIURLForEntity(entityName)+"?fields="+fieldName + "&format=json";

        return  this.getField(link,fieldName, properties);

    }

    getField (link:string,fieldName:string, properties:EnvProperties):any{

      let url = link+"&refine=true&page=1&size=0";

      return this.http.get((properties.useCache)? (properties.cacheUrl+encodeURIComponent(url)): url)

                  //.map(res => <any> res.json())

                  .pipe(map(res => res['refineResults']))

                  .pipe(map(res =>  this.parse(res,fieldName)));

    }

    parse(data: any,fieldName:string):any {

      var values:AutoCompleteValue[] = [];

      if(data){

          let field = data[fieldName];

          for(let i=0; i<field.length; i++) {

            var value:AutoCompleteValue = new AutoCompleteValue();

            value.label = field[i].name;

            value.label = RefineResultsUtils.inParenthesisThePartAfterCharacters(field[i],"||");

            value.id = field[i].id;

            values.push(value);

        }

    }

    return values;

    }

    getSearchAPIURLForEntity(entityType:string):string{

      var suffix = "";

      if(entityType == "project"){

        suffix="projects/";

      }else if(entityType == "publication"){

        suffix="publications/";

      }else if(entityType == "dataset"){

        suffix="datasets/";

      } else if(entityType == "software"){

        suffix="software/";

      } else if(entityType == "other"){

        suffix="other/";

      }else if(entityType == "organization"){

        suffix="organizations/";

      }else if(entityType == "dataprovider"){

        suffix="datasources/";

      }else if(entityType == "person"){

        suffix="people/";

      }

      return  suffix;

    }

    private handleError (error: HttpErrorResponse) {

      // 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 throwError(error  || 'Server error');

    }

}