D-Net

export class PersonInfo {

    fullname: string;

    firstname: string;

    secondnames: string;

    country: string;

    publications: any;

    researchData: any;

}

import {PersonInfo} from './personInfo';

   "resultbestlicense", "instancetypename", "resultlanguagename", "community","collectedfrom"];

     "resultdateofacceptance","resultbestlicense","pid","resulthostingdatasourceid","collectedfromdatasourceid","relpersonid"];

         ["relpersonid"]:{name:"Person", type:"entity", param:"person", equalityOperator: " exact "},

        //PERSON

        public PERSON_REFINE_FIELDS:string[] = [];

          public PERSON_ADVANCED_FIELDS:string[] = ["q","personsecondnames","personfirstname","personfullname"];

      public PERSON_FIELDS: { [key:string]:FieldDetails}={

          ["q"]:{name:"All fields", type:"keyword", param:"q", equalityOperator: "="},

          ["personsecondnames"]:{name:"Surname", type:"keyword", param:"surname", equalityOperator: "="},

          ["personfirstname"]:{name:"First Name",type:"keyword", param:"name", equalityOperator: "="},

          ["personfullname"]:{name:"Full name", type:"keyword", param:"fullname", equalityOperator: "="}

        };

    private static searchLinkToPerson = "search/person?personId=";

    public static getsearchLinkToPerson():string{

      return this.baseSearchLink + this.searchLinkToPerson;

    }

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

        return  this.searchEntity(keyword,"people","oaf:person","person");

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

        return  this.fetchEntity(id,"people","oaf:person","person");

import {SearchPeopleService} from '../../services/searchPeople.service';

import { ErrorCodes} from '../../utils/properties/openaireProperties';

import {SearchFields} from '../../utils/properties/searchFields';

import {SearchUtilsClass } from '../../searchPages/searchUtils/searchUtils.class';

export class FetchPeople {

  public results =[];

  public searchUtils:SearchUtilsClass = new SearchUtilsClass();

  public sub: any;

   public searchFields:SearchFields = new SearchFields();

  constructor ( private _searchPeopleService: SearchPeopleService ) {

    var errorCodes:ErrorCodes = new ErrorCodes();

    this.searchUtils.status =errorCodes.LOADING;

  }

  public ngOnDestroy() {

    this.sub.unsubscribe();

  }

public getResultsByKeyword(keyword:string, page: number, size: number){

  var parameters = "";

  if(keyword.length > 0){

    parameters = "q=" + keyword;

  }

  var errorCodes:ErrorCodes = new ErrorCodes();

  this.searchUtils.status = errorCodes.LOADING;

  this._searchPeopleService.searchPeople(parameters, null, page, size,[]).subscribe(

      data => {

          this.searchUtils.totalResults = data[0];

          console.info("search People: [Parameters:"+parameters+" ]  [total results:"+this.searchUtils.totalResults+"]");

          this.results = data[1];

          var errorCodes:ErrorCodes = new ErrorCodes();

          this.searchUtils.status = errorCodes.DONE;

          if(this.searchUtils.totalResults == 0 ){

            this.searchUtils.status = errorCodes.NONE;

          }

       },

      err => {

          console.log(err);

           //TODO check erros (service not available, bad request)

          // if( ){

          //   this.searchUtils.status = ErrorCodes.ERROR;

          // }

          var errorCodes:ErrorCodes = new ErrorCodes();

          this.searchUtils.status = errorCodes.ERROR;

       }

  );

}

}

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

    parameters = "people/"+id;

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

    parameters = "people/"+id;

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

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

import {Observable}     from 'rxjs/Observable';

import 'rxjs/add/observable/of';

import 'rxjs/add/operator/do';

import 'rxjs/add/operator/share';

import { CacheService  } from '../shared/cache.service';

import {OpenaireProperties} from '../utils/properties/openaireProperties';

import {SearchResult}     from '../utils/entities/searchResult';

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

@Injectable()

export class SearchPeopleService {

    constructor(private http: Http, public _cache: CacheService) {}

    searchPeople (params: string, refineParams:string, page: number, size: number, refineFields:string[] ):any {

        console.info("In searchProjects");

        let link = OpenaireProperties.getSearchAPIURLLast()+"people";

        let url = link+"?";

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

            url += params;

        }

        if(refineParams!= null && params != ''  ) {

            url += refineParams;

        }

        url += "&page="+(page-1)+"&size="+size + "&format=json";

        let key = url;

        if (this._cache.has(key)) {

          return Observable.of(this._cache.get(key)).map(res => [res['meta'].total, this.parseResults(res['results']),RefineResultsUtils.parse(res['refineResults'],refineFields, "person")]);

        }

        return this.http.get(url)

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

                    //.do(res => console.info(res))

                    .do(res => {

                      this._cache.set(key, res);

                    })

                    .map(res => [res['meta'].total, this.parseResults(res['results']),RefineResultsUtils.parse(res['refineResults'],refineFields, "person")]);

    }

    advancedSearchPeople (params: string, page: number, size: number ):any {

      let url = OpenaireProperties.getSearchResourcesAPIURL();

      var basicQuery = "(oaftype exact person) "

      url += "?query=";

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

        url +=" ( "+basicQuery+ " ) " +" and (" + params + ")";

      }else{

        url +=" ( "+basicQuery+ " ) ";

      }

      url += "&page="+(page-1)+"&size="+size;

      url += "&format=json";

      let key = url;

      if (this._cache.has(key)) {

        return Observable.of(this._cache.get(key)).map(res => [res['meta'].total, this.parseResults(res['results'])]);

      }

      return this.http.get(url)

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

      //.do(res => console.info(res))

      .do(res => {

        this._cache.set(key, res);

      })

      .map(res => [res['meta'].total, this.parseResults(res['results'])]);

    }

    parseResults(data: any): SearchResult[] {

        let results: SearchResult[] = [];

        let length = Array.isArray(data) ? data.length : 1;

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

            let resData = Array.isArray(data) ? data[i]['result']['metadata']['oaf:entity']['oaf:person'] : data['result']['metadata']['oaf:entity']['oaf:person'];

            var result: SearchResult = new SearchResult();

            result['title'] = {"name": '', "accessMode": '', "sc39": ''};

            result['title'].name = resData.fullname;

            //result['title'].url = OpenaireProperties.getsearchLinkToPerson();

            //result['title'].url +=  Array.isArray(data) ? data[i]['result']['header']['dri:objIdentifier'] : data['result']['header']['dri:objIdentifier'];

            result['id'] =  Array.isArray(data) ? data[i]['result']['header']['dri:objIdentifier'] : data['result']['header']['dri:objIdentifier'];

            results.push(result);

        }

        return results;

    }

    numOfEntityPeople(id: string, entity: string):any {

        //OpenaireProperties.getSearchAPIURLLast()

        //"http://rudie.di.uoa.gr:8080/dnet-functionality-services-2.0.0-SNAPSHOT/rest/v2/api/"

        let url = OpenaireProperties.getSearchAPIURLLast()+entity+id+"/people/count"+ "?format=json";

        let key = url;

        if (this._cache.has(key)) {

          return Observable.of(this._cache.get(key));

        }

        return this.http.get(url)

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

                    .map(res => res.total)

                    .do(res => {

                      this._cache.set(key, res);

                    });

    }

    numOfSearchPeople(params: string):any {

        //OpenaireProperties.getSearchAPIURLLast()

        //"http://rudie.di.uoa.gr:8080/dnet-functionality-services-2.0.0-SNAPSHOT/rest/v2/api/"

        let url = OpenaireProperties.getSearchAPIURLLast()+"people/count?q="  + params +  "&format=json";

        let key = url;

        if (this._cache.has(key)) {

          return Observable.of(this._cache.get(key));

        }

        return this.http.get(url)

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

                    .map(res => res.total)

                    .do(res => {

                      this._cache.set(key, res);

                    });

    }

}

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

import { CommonModule }        from '@angular/common';

import { FormsModule }         from '@angular/forms';

import {SearchPeopleService} from './searchPeople.service';

@NgModule({

  imports: [

    CommonModule, FormsModule

  ],

  declarations: [

  ],

  providers:[

  SearchPeopleService

],

  exports: [

    ]

})

export class PeopleServiceModule { }

import {PeopleServiceModule} from '../../services/peopleService.module';

    PublicationsServiceModule, OrganizationsServiceModule, PeopleServiceModule,

import { FetchPeople } from '../../utils/fetchEntitiesClasses/fetchPeople.class';

import {SearchPeopleService} from '../../services/searchPeople.service';

                   <li (click)="searchPeople()" >

                       <a>

                           People

                           <span *ngIf = "fetchPeople.searchUtils.status == errorCodes.LOADING && keyword.length > 0" class="uk-icon-spinner uk-icon-spin"></span>

                           <span *ngIf = "fetchPeople.searchUtils.status != errorCodes.LOADING && keyword.length > 0"  class="uk-badge uk-badge-notification"> {{((keyword.length > 0)? fetchPeople.searchUtils.totalResults :'')}}</span>

                       </a>

                   </li>

                   <li (click)="searchPeople()" >

                       <a>

                           People

                           <span *ngIf = "fetchPeople.searchUtils.status == errorCodes.LOADING && keyword.length > 0" class="uk-icon-spinner uk-icon-spin"></span>

                           <span *ngIf = "fetchPeople.searchUtils.status != errorCodes.LOADING && keyword.length > 0"  class="uk-badge uk-badge-notification"> {{((keyword.length > 0)? fetchPeople.searchUtils.totalResults :'')}}</span>

                       </a>

                   </li>

                    <li>

                      <div *ngIf = "keyword.length > 0" class ="uk-animation-fade">

                        <div class = "uk-text-right" *ngIf = "fetchPeople.searchUtils.totalResults> 10">

							<!--a [href] = "linkToSearchPeople"-->

                            <a  [queryParams]="routerHelper.createQueryParam('keyword', keyword)"

                                routerLinkActive="router-link-active" [routerLink]="linkToSearchPeople">

								View all {{fetchPeople.searchUtils.totalResults}} results <span uk-icon="icon: chevron-right"></span>

							</a>

						</div>

                        <search-result  [(results)]="fetchPeople.results"

                                        [(status)]= "fetchPeople.searchUtils.status" showLoading = true

                                        type="person" urlParam="personId">

                        </search-result>

                      </div>

                      <div *ngIf = "keyword.length == 0 && activeTab=='people'" class ="uk-animation-fade">

                          <div   class="uk-alert uk-alert-primary " role="alert">No person statistics found</div>

                      </div>

                    </li>

  public reloadPeople: boolean;

  public people:string[];

  public linkToSearchPeople = "";

  public fetchPeople: FetchPeople;

public subPub;public subData;public subProjects;public subOrg;public subPeople; public subDataPr;

      private _searchPeopleService: SearchPeopleService,

    this.fetchPeople = new FetchPeople(this._searchPeopleService);

        if(this.subPeople){

          this.subPeople.unsubscribe();

        }

   public  searchPeople() {

     this.activeTab = "people";

     if(this.reloadPeople) {

         this.reloadPeople = false;

         this.fetchPeople.getResultsByKeyword(this.keyword,  1, 10);

         this.linkToSearchPeople = OpenaireProperties.getLinkToSearchPeople();// + "?keyword="  + this.keyword;

     }

   }

    if(this.activeTab == "people") {

        this.searchPeople();

    }

        if(this.activeTab != "people"){

        this.fetchPeople.searchUtils.status = this.errorCodes.LOADING;

        this.subPeople =  this._searchPeopleService.numOfSearchPeople(this.keyword).subscribe(

             data => {

                 this.fetchPeople.searchUtils.totalResults = data;

                 this.fetchPeople.searchUtils.status = this.errorCodes.DONE;

             },

             err => {

                 console.log(err);

                 this.fetchPeople.searchUtils.status = this.errorCodes.ERROR;

              }

           );

         }

       this.reloadPeople = true;

import {Component, Input, ViewChild} from '@angular/core';

import {Observable}       from 'rxjs/Observable';

import { Router, ActivatedRoute} from '@angular/router';

import {Filter, Value,AdvancedField} from '../searchUtils/searchHelperClasses.class';

import {SearchPeopleService} from '../../services/searchPeople.service';

import {SearchResult}     from '../../utils/entities/searchResult';

import {OpenaireProperties, ErrorCodes} from '../../utils/properties/openaireProperties';

import {AdvancedSearchPageComponent} from '../searchUtils/advancedSearchPage.component';

import {SearchFields} from '../../utils/properties/searchFields';

import {SearchUtilsClass } from '../searchUtils/searchUtils.class';

@Component({

    selector: 'advanced-search-organizations',

    template: `

    <advanced-search-page pageTitle="Advanced Search People" entityType="person"

                 type = "people"

                 [(results)] = "results"

                 [(searchUtils)] = "searchUtils"

                 [(fieldIds)]="fieldIds" [(fieldIdsMap)]="fieldIdsMap"   [(selectedFields)]="selectedFields"

                 (queryChange)="queryChanged($event)"

                 [csvParams]="csvParams" csvPath="resources" simpleSearchLink="/search/find/people"

                 [disableForms]="disableForms">

    </advanced-search-page>

    `

 })

export class AdvancedSearchPeopleComponent {

  public results =[];

  public filters =[];

  public searchUtils:SearchUtilsClass = new SearchUtilsClass();

  public searchFields:SearchFields = new SearchFields();

  public fieldIds: string[] = this.searchFields.PERSON_ADVANCED_FIELDS;

  public fieldIdsMap  = this.searchFields.PERSON_FIELDS;

  public selectedFields:AdvancedField[] = [];

  @ViewChild (AdvancedSearchPageComponent) searchPage : AdvancedSearchPageComponent ;

  public resourcesQuery = "(oaftype exact person)";

  public csvParams: string;

  public disableForms: boolean = false;

  constructor (private route: ActivatedRoute, private _searchPeopleService: SearchPeopleService ) {

    this.results =[];

    var errorCodes:ErrorCodes = new ErrorCodes();

    this.searchUtils.status =errorCodes.LOADING;

    this.searchUtils.baseUrl = OpenaireProperties.searchLinkToAdvancedPeople;

  }

  ngOnInit() {

    var errorCodes:ErrorCodes = new ErrorCodes();

    this.searchUtils.status =errorCodes.LOADING;

   this.sub =  this.route.queryParams.subscribe(params => {

      let page = (params['page']=== undefined)?1:+params['page'];

      this.searchUtils.page = ( page <= 0 ) ? 1 : page;

      this.searchPage.fieldIds = this.fieldIds;

      this.selectedFields =[];

      this.searchPage.selectedFields = this.selectedFields;

      this.searchPage.fieldIdsMap = this.fieldIdsMap;

      this.searchPage.getSelectedFiltersFromUrl(params);

      this.getResults(this.searchPage.createQueryParameters(),  this.searchUtils.page, this.searchUtils.size);

    });

  }

  ngOnDestroy() {

    this.sub.unsubscribe();

  }

  sub: any;

  public getResults(parameters:string, page: number, size: number){

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

        this.csvParams ="&type=people&query=( "+this.resourcesQuery + "and (" + parameters + "))";

      }else{

        this.csvParams ="&type=people&query="+this.resourcesQuery;

      }

    var errorCodes:ErrorCodes = new ErrorCodes();

    this.searchUtils.status = errorCodes.LOADING;

    //this.searchPage.openLoading();

    this.disableForms = true;

    this.results = [];

    this.searchUtils.totalResults = 0;

    console.info("Advanced Search People: Execute search query "+parameters);

     this._searchPeopleService.advancedSearchPeople(parameters, page, size).subscribe(

        data => {

            this.searchUtils.totalResults = data[0];

            console.info("search People total="+this.searchUtils.totalResults);

            this.results = data[1];

            this.searchPage.updateBaseUrlWithParameters();

            var errorCodes:ErrorCodes = new ErrorCodes();

             this.searchUtils.status = errorCodes.DONE;

            if(this.searchUtils.totalResults == 0 ){

              this.searchUtils.status = errorCodes.NONE;

            }

            //this.searchPage.closeLoading();

            this.disableForms = false;

        },

        err => {

            console.log(err);

            console.info("error");

            //TODO check erros (service not available, bad request)

            // if( ){

            //   this.searchUtils.status = errorCodes.ERROR;

            // }

            var errorCodes:ErrorCodes = new ErrorCodes();

            this.searchUtils.status = errorCodes.NOT_AVAILABLE;

            //this.searchPage.closeLoading();

            this.disableForms = false;

        }

    );

  }

  private setFilters(){

    //TODO set filters from

  }

  public queryChanged($event) {

    var parameters = $event.value;

    this.getResults(parameters, this.searchUtils.page,this.searchUtils.size);

    console.info("queryChanged: Execute search query "+parameters);

  }

}

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

import { RouterModule } from '@angular/router';

import{AdvancedSearchPeopleComponent} from './advancedSearchPeople.component';

import {FreeGuard} from'../../login/freeGuard.guard';

@NgModule({

  imports: [

    RouterModule.forChild([

     	{ path: '', component: AdvancedSearchPeopleComponent, canActivate: [FreeGuard] }

    ])

  ]

})

export class AdvancedSearchPeopleRoutingModule { }

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

import { CommonModule }        from '@angular/common';

import { FormsModule }         from '@angular/forms';

import{ AdvancedSearchPeopleRoutingModule} from './advancedSearchPeople-routing.module';

import{AdvancedSearchPeopleComponent} from './advancedSearchPeople.component';

import {PeopleServiceModule} from '../../services/peopleService.module';

 import {AdvancedSearchPageModule} from '../searchUtils/advancedSearchPage.module';

 import {FreeGuard} from'../../login/freeGuard.guard';

@NgModule({

  imports: [

    CommonModule, FormsModule,

    PeopleServiceModule,

   AdvancedSearchPeopleRoutingModule, AdvancedSearchPageModule

  ],

  declarations: [

    AdvancedSearchPeopleComponent

   ],

  providers:[FreeGuard

    ],

  exports: [

    AdvancedSearchPeopleComponent

     ]

})

export class AdvancedSearchPeopleModule { }

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

          this.urlParam = "personId";

      } else {

                        <a [queryParams]="{personId: author.id}" routerLinkActive="router-link-active" routerLink="/search/person">

    constructor () {

                        <a [queryParams]="{personId: author.id}" routerLinkActive="router-link-active" routerLink="/search/person">

                            {{author['name']}};

                        </a>

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

          this.urlParam = "personId";

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

import { CommonModule }        from '@angular/common';

import { FormsModule }         from '@angular/forms';

import{ SearchPeopleRoutingModule} from './searchPeople-routing.module';

import{SearchPeopleComponent} from './searchPeople.component';

import {SearchResultsModule } from '../searchUtils/searchResults.module';

import {PeopleServiceModule} from '../../services/peopleService.module';

import {SearchFormModule} from  '../searchUtils/searchForm.module';

//import {SearchFilterModalModule} from '../searchUtils/searchFilterModal.module';

import {SearchPageModule} from '../searchUtils/searchPage.module';

import {FreeGuard} from'../../login/freeGuard.guard';

@NgModule({

  imports: [

    CommonModule, FormsModule,

    PeopleServiceModule,

     SearchFormModule, SearchResultsModule, SearchPeopleRoutingModule, SearchPageModule//, SearchFilterModalModule

  ],

  declarations: [

    SearchPeopleComponent

   ],

  providers:[FreeGuard

    ],

  exports: [

    SearchPeopleComponent

     ]

})

export class SearchPeopleModule { }

import {Component, Input, ViewChild} from '@angular/core';

import { ActivatedRoute} from '@angular/router';

import {Location} from '@angular/common';

import { Filter, Value} from '../searchUtils/searchHelperClasses.class';

import {SearchPeopleService} from '../../services/searchPeople.service';

import {SearchResult}     from '../../utils/entities/searchResult';

import {OpenaireProperties, ErrorCodes} from '../../utils/properties/openaireProperties';

import {SearchFields} from '../../utils/properties/searchFields';

import {SearchPageComponent } from '../searchUtils/searchPage.component';

import {SearchUtilsClass } from '../searchUtils/searchUtils.class';

@Component({

    selector: 'search-people',

    template: `

    <search-page pageTitle="Search People"

                 type="people" entityType="person" [(filters)] = "filters"

                 [(results)] = "results" [(searchUtils)] = "searchUtils"

                 [baseUrl] = "baseUrl" (queryChange)="queryChanged($event)" [showRefine]=false

                 [csvParams]="csvParams" csvPath="people" advancedSearchLink="/search/advanced/people"

                 [disableForms]="disableForms">

    </search-page>

    `

})

export class SearchPeopleComponent {

  public results =[];

  public filters =[];

   public baseUrl:string;

  public searchUtils:SearchUtilsClass = new SearchUtilsClass();

  public sub: any;

  public _location:Location;

  public searchFields:SearchFields = new SearchFields();

  public refineFields = this.searchFields.PERSON_REFINE_FIELDS;

  public csvParams: string;

  public disableForms: boolean = false;

  @ViewChild (SearchPageComponent) searchPage : SearchPageComponent ;

  constructor (private route: ActivatedRoute, private _searchPeopleService: SearchPeopleService ) {

    //this.results =[];

    //this.filters =[];

    var errorCodes:ErrorCodes = new ErrorCodes();

    this.searchUtils.status =errorCodes.LOADING;

    this.baseUrl = OpenaireProperties.getLinkToSearchPeople();

    //get refine field filters  from url parameters

    // if(!this.searchPage){

    //   this.searchPage = new SearchPageComponent(this._location);

    // }

  }

  public ngOnInit() {

    this.searchPage.refineFields = this.refineFields; //TODO make it work as a directive

    this.sub =  this.route.queryParams.subscribe(params => {

    this.searchUtils.keyword = (params['keyword']?params['keyword']:'');

    this.searchUtils.page = (params['page']=== undefined)?1:+params['page'];

              this.getResults(this.searchUtils.keyword, false, this.searchUtils.page, this.searchUtils.size);

    });

  }

  public ngOnDestroy() {

    this.sub.unsubscribe();

  }

public getResults(keyword:string,refine:boolean, page: number, size: number){

  var parameters = "";

  if(keyword.length > 0){

    parameters = "q="+ keyword;

  }

  this._getResults(parameters,refine,page,this.searchUtils.size);

}

private _getResults(parameters:string,refine:boolean, page: number, size: number){

    this.csvParams = parameters;

  var errorCodes:ErrorCodes = new ErrorCodes();

  this.searchUtils.status = errorCodes.LOADING;

  //this.searchPage.openLoading();

  this.disableForms = true;

  this.results = [];

  this.searchUtils.totalResults = 0;

  this._searchPeopleService.searchPeople(parameters,(refine)?this.searchPage.getRefineFieldsQuery():null, page, size, this.searchPage.getFields()).subscribe(

      data => {

          this.searchUtils.totalResults = data[0];

          console.info("search People: [Parameters:"+parameters+" ]  [total results:"+this.searchUtils.totalResults+"]");

          this.results = data[1];

            this.filters = this.searchPage.checkSelectedFilters(data[2]);

            this.searchPage.updateBaseUrlWithParameters(this.filters);

          var errorCodes:ErrorCodes = new ErrorCodes();

          this.searchUtils.status = errorCodes.DONE;

          if(this.searchUtils.totalResults == 0 ){

            this.searchUtils.status = errorCodes.NONE;

          }

          //this.searchPage.closeLoading();

          this.disableForms = false;

      },

      err => {

          console.log(err);

           //TODO check erros (service not available, bad request)

          // if( ){

          //   this.searchUtils.status = ErrorCodes.ERROR;

          // }

          var errorCodes:ErrorCodes = new ErrorCodes();

          this.searchUtils.status = errorCodes.ERROR;

          //this.searchPage.closeLoading();

          this.disableForms = false;

      }

  );

}

  private setFilters(){

    //TODO set filters from

  }

  public queryChanged($event) {

    var parameters = $event.value;

    console.info("queryChanged: Execute search query "+parameters);

    this._getResults(parameters, true, this.searchUtils.page, this.searchUtils.size);

  }

}

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

import { RouterModule } from '@angular/router';

import{SearchPeopleComponent} from './searchPeople.component';

import {FreeGuard} from'../../login/freeGuard.guard';

@NgModule({

  imports: [

    RouterModule.forChild([

     	{ path: '', component: SearchPeopleComponent, canActivate: [FreeGuard]  }

    ])

  ]

})

export class SearchPeopleRoutingModule { }

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

    parameters = "people/"+id;

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

    parameters = "people/"+id;

  }

import {Component, Input, Output, EventEmitter} from '@angular/core';

    template: `<button   (click)="startOver()"  class="uk-button uk-button-danger uk-align-right"  > <span uk-icon="icon: refresh"></span> Clear All</button>`,

    console.log("projects:"+this.projects.length +" contexts:"+this.contexts.length + " results:"+this.results.length );

    SharedModule, CommonModule

                              <option   [value]="'publication'"  >Publication</option>

                              <option   [value]="'dataset'"  >Dataset</option>

           this.confirmOpen();

           this.confirmOpen();

   confirmOpen(){

     this.alertApplyAll.alertTitle = "Change access rights";

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

        if(this.results[i].source != 'openaire' ){

          this.results[i].accessRights = this.commonAccessRights;

          if(this.commonAccessRights == "EMBARGO"){

            this.results[i].embargoEndDate = this.commonEmbargoEndDate;

      }

                  <h3 > Selected Projects ({{projects.length}}) </h3>

          <li [class]="(show=='claim')?'uk-active':''" (click)="canProceedToMetadata();"><a [class]="(results.length == 0)?'uk-disabled':''"  (click)="show='claim';" > Complete metadata</a></li>

              <div class="uk-clearfix">

                  <a  class="uk-float-right" uk-toggle="target: #linkingInfo; animation:  uk-animation-fade"><span uk-icon="icon: info"></span> What is linking about? </a>

              </div>

              <div id="linkingInfo" class="uk-card uk-card-default uk-card-body uk-margin-small" hidden>

                  <a uk-toggle="target: #uploadInfo; animation:  uk-animation-fade" class="uk-float-right"><span uk-icon="icon: close"></span></a>

                   <div class="uk-text-bold"><span uk-icon="icon: info"></span> Linking Functioanlity:</div>

                   <p>TODO: Put some useful information here... </p>

               </div>

            <li *ngIf="show != 'claim' " (click)="canProceedToMetadata()"  class="uk-margin-auto-left"><a> Review Metadata <span class="uk-margin-small-left" uk-pagination-next></span></a></li>

import {PersonInfo} from '../utils/entities/personInfo';

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

import { RouterModule } from '@angular/router';

import { PersonComponent } from './person.component';

import {FreeGuard} from'../../login/freeGuard.guard';

@NgModule({

 imports: [

  RouterModule.forChild([

    { path: '', component: PersonComponent, canActivate: [FreeGuard] }

  ])

]

})

export class PersonRoutingModule { }

<div class="uk-container uk-margin-top person">

    <div *ngIf="warningMessage.length > 0" class="uk-alert uk-alert-warning" role="alert">{{warningMessage}}</div>

    <div *ngIf="errorMessage.length > 0" class="uk-alert uk-alert-danger" role="alert">{{errorMessage}}</div>

    <div *ngIf="personInfo != null" uk-grid>

        <div class="uk-width-3-4@l uk-width-3-4@xl uk-width-3-4@m uk-width-1-1@s">

            <h2>{{personInfo.fullname}}</h2>

            <dl class="uk-description-list">

                <dt *ngIf="personInfo.secondnames != undefined && personInfo.secondnames != ''">Last name: </dt>

                <dd *ngIf="personInfo.secondnames != undefined && personInfo.secondnames != ''">{{personInfo.secondnames}}</dd>

                <dt *ngIf="personInfo.firstname != undefined && personInfo.firstname != ''">First name: </dt>

                <dd *ngIf="personInfo.firstname != undefined && personInfo.firstname != ''">{{personInfo.firstname}}</dd>

                <dt *ngIf="personInfo.country != undefined && personInfo.country != ''">Country: </dt>

                <dd *ngIf="personInfo.country != undefined && personInfo.country != ''">{{personInfo.country}}</dd>

            </dl>

            <ul *ngIf="showTabs" class="uk-tab" data-uk-switcher="{connect:'#tab-content'}">

                <li class="uk-active">

                    <a>

                        Publications

                        <span class="uk-badge uk-badge-notification">

                            {{fetchPublications.searchUtils.totalResults}}

                        </span>

                    </a>

                </li>

                <li (click)="searchDatasetsInit()">

                    <a>

                        Research Data

                        <span class="uk-badge uk-badge-notification">

                            {{fetchDatasets.searchUtils.totalResults}}

                        </span>

                    </a>

                </li>

            </ul>

            <ul *ngIf="showTabs" id="tab-content" class="uk-switcher uk-margin custom-tab-content">

                <li class="uk-animation-fade">

                    <div *ngIf="fetchPublications.searchUtils.totalResults == 0" class = "uk-alert  uk-alert-primary">

                        There are no publications

                    </div>

                    <div *ngIf="fetchPublications.searchUtils.totalResults > 0">

                        <div class = "uk-text-right" *ngIf = "fetchPublications.searchUtils.totalResults > 10" >

                            <a [queryParams]="{personId: personId, pe: 'and'}" routerLinkActive="router-link-active" [routerLink]="linkToSearchPublications">

                                View all {{fetchPublications.searchUtils.totalResults}} results

                            </a>

                        </div>

                        <tab-result [(results)]="fetchPublications.results"

                                    [(status)]= "fetchPublications.searchUtils.status"

                                    type="publication" urlParam="articleId">

                        </tab-result>

                    </div>

                </li>

                <li class="uk-animation-fade">

                    <div *ngIf="fetchDatasets.searchUtils.totalResults == 0" class = "uk-alert  uk-alert-primary">

                        There are no research data

                    </div>

                    <div *ngIf="fetchDatasets.searchUtils.totalResults > 0">

                        <div class = "uk-text-right" *ngIf = "fetchDatasets.searchUtils.totalResults > 10" >

                            <a [queryParams]="{personId: personId, pe: 'and'}" routerLinkActive="router-link-active" [routerLink]="linkToSearchDatasets">

                                View all {{fetchDatasets.searchUtils.totalResults}} results

                            </a>

                        </div>

                        <tab-result [(results)]="fetchDatasets.results"

                                    [(status)]= "fetchDatasets.status"

                                    type="dataset" urlParam="datasetId">

                        </tab-result>

                    </div>

                </li>

            </ul>

        </div>

        <div class="uk-width-1-4@l uk-width-1-4@xl uk-width-1-4@m uk-width-1-1@s">

            <ul class="uk-list uk-list-striped">

                <li>

                  <dl class="uk-description-list-line">

                      <dt  >Share - Bookmark

                      </dt>

                      <dd>

                        <addThis ></addThis>

                      </dd>

                  </dl>

                </li>

            </ul>

        </div>

    </div>

</div>

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

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

import {Observable}     from 'rxjs/Observable';

import 'rxjs/add/observable/of';

import 'rxjs/add/operator/do';

import 'rxjs/add/operator/share';

import { CacheService  } from '../../shared/cache.service';

import {PersonInfo} from '../../utils/entities/personInfo';

import {OpenaireProperties} from '../../utils/properties/openaireProperties'

export function hashCodeString(str: string): string {

  let hash = 0;

  if (str.length === 0) {

    return hash + '';

  }

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

    let char = str.charCodeAt(i);

    hash = ((hash << 5) - hash) + char;

    hash = hash & hash; // Convert to 32bit integer

  }

  return hash + '';

}

@Injectable()

export class PersonService {

    constructor(private http: Http, public _cache: CacheService) {}

    personInfo: PersonInfo;

    getPersonInfo (id: string):any {

        console.info("getPersonInfo in service");

        let url = OpenaireProperties. getSearchAPIURLLast()+'people/'+id+"?format=json";

        let key = url;

        if (this._cache.has(key)) {

          return Observable.of(this._cache.get(key)).map(res => this.parsePersonInfo(res));

        }

        return this.http.get(url)

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

                    .map(res => res['result']['metadata']['oaf:entity']['oaf:person'])

                    .do(res => {

                      this._cache.set(key, res);

                    })

                    .map(res => this.parsePersonInfo(res));