1. Community API added in env properties.

2. 'Search Projects' page gets its content by Community API - 'searchProjects' service added.
3. In 'Search Projects' page. datatable is used to show results.
4. In 'Search Projects' page, filter only by Funder. Available funders for filtering, result from Community's API response.


git-svn-id: https://svn.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-connect-portal/trunk@50990 d315682c-612b-4755-9ff5-7f18f6832af3

src/app/app.module.ts

@@ -24,6 +24,8 @@ import { AppRoutingModule } from './app-routing.module';
 import { CommunityService } from './community/community.service';
 import { CommunitiesService } from './communities/communities.service';
 
+//import { LibSearchProjectsModule } from './searchPages/simple/searchProjects.module';
+
 @NgModule({
 
   imports: [
@@ -35,7 +37,7 @@ ErrorModule,
 NavigationBarModule, FeedbackModule, BottomModule,
     CookieLawModule,
     BrowserModule.withServerTransition({appId: 'my-app'}),
-     AppRoutingModule
+     AppRoutingModule//,LibSearchProjectsModule
 
   ],
   declarations: [ AppComponent, OpenaireErrorPageComponent],

src/app/searchPages/simple/searchProjects.component.ts

@@ -1,14 +1,167 @@
 import {Component, Input, ViewChild} from '@angular/core';
+import { ActivatedRoute} from '@angular/router';
+
+import { Filter, Value} from '../../openaireLibrary/searchPages/searchUtils/searchHelperClasses.class';
+
+import {SearchDataprovidersService} from '../../openaireLibrary/services/searchDataproviders.service';
+import {SearchResult}     from '../../openaireLibrary/utils/entities/searchResult';
+import {ErrorCodes} from '../../openaireLibrary/utils/properties/errorCodes';
+import {SearchFields, FieldDetails} from '../../openaireLibrary/utils/properties/searchFields';
+import {SearchPageTableViewComponent } from '../../openaireLibrary/searchPages/searchUtils/searchPageTableView.component';
+import {SearchUtilsClass } from '../../openaireLibrary/searchPages/searchUtils/searchUtils.class';
+import {EnvProperties} from '../../openaireLibrary/utils/properties/env-properties';
+import {SearchCommunityProjectsService} from '../../services/searchProjects.service';
 
 @Component({
     selector: 'openaire-search-projects',
     template: `
 
-    <search-projects>
-    </search-projects>
-     `
+    <search-page-table    pageTitle="OpenAIRE Projects Table"
+                          type="projects" entityType="project" [(filters)] = "filters"
+                          [(results)] = "results"  [(searchUtils)] = "searchUtils"
+                          [columnNames]="columnNames"
+                          [showResultCount]=false
+                          [disableForms]="disableForms"
+                          searchFormClass="journalsTableSearchForm"
+                          formPlaceholderText="Search for Projects">
+    </search-page-table>
+    `
 
 })
 export class OpenaireSearchProjectsComponent {
-   
+  private errorCodes: ErrorCodes;
+
+  public columnNames = ['Acronym', 'Name', 'GrantId', 'Funder'];
+  public results =[];
+  public filters =[];
+  public searchUtils:SearchUtilsClass = new SearchUtilsClass();
+  public sub: any; public subResults: any;
+  public _location:Location;
+  public searchFields:SearchFields = new SearchFields();
+  public refineFields: string[] = [];// =  this.searchFields.JOURNAL_FIELDS;
+  properties:EnvProperties;
+
+  public disableForms: boolean = false;
+
+  @ViewChild (SearchPageTableViewComponent) searchPage : SearchPageTableViewComponent ;
+
+  constructor (private route: ActivatedRoute, private _searchDataprovidersService: SearchDataprovidersService, private _searchProjectsService: SearchCommunityProjectsService) {
+    this.errorCodes = new ErrorCodes();
+    this.searchUtils.status = this.errorCodes.LOADING;
+  }
+
+  public ngOnInit() {
+    this.route.data
+      .subscribe((data: { envSpecific: EnvProperties }) => {
+        this.properties = data.envSpecific;
+      });
+    //this.searchPage.refineFields = this.refineFields;
+    this.sub =  this.route.queryParams.subscribe(params => {
+      this.searchUtils.keyword = (params['keyword']?params['keyword']:'');
+      //this.filters = this.createFilters();
+      //this.searchPage.getParametersFromUrl(params);
+
+      this._getResults(params);
+    });
+  }
+
+  public ngOnDestroy() {
+    if(this.sub){
+      this.sub.unsubscribe();
+    }
+    if(this.subResults){
+      this.subResults.unsubscribe();
+    }
+  }
+    private _getResults(params){
+      this.searchUtils.status = this.errorCodes.LOADING;
+      this.disableForms = true;
+      this.results = [];
+      this.searchUtils.totalResults = 0;
+
+      let size: number = 0;
+
+      this.subResults = this._searchProjectsService.searchProjects(this.properties).subscribe(
+          data => {
+            this.filters = this.createFilters(data, params);
+
+            console.info(data);
+            this.searchUtils.totalResults = data.length;
+            console.info("search Projects [total results:"+this.searchUtils.totalResults+"]");
+            this.results = data;
+
+            this.searchPage.checkSelectedFilters(this.filters);
+
+            //var errorCodes:ErrorCodes = new ErrorCodes();
+            this.searchUtils.status = this.errorCodes.DONE;
+            if(this.searchUtils.totalResults == 0 ){
+              this.searchUtils.status = this.errorCodes.NONE;
+            }
+            this.disableForms = false;
+            this.searchPage.triggerInitialLoad();
+            this.searchPage.transform(this.results);
+          },
+          err => {
+            console.log(err);
+             //TODO check erros (service not available, bad request)
+
+            if(err.status == '404') {
+              this.searchUtils.status = this.errorCodes.NOT_FOUND;
+            } else if(err.status == '500') {
+              this.searchUtils.status = this.errorCodes.ERROR;
+            } else {
+              this.searchUtils.status = this.errorCodes.NOT_AVAILABLE;
+            }
+
+            this.disableForms = false;
+          }
+      );
+    }
+  private setFilters(){
+    //TODO set filters from
+  }
+
+  private createFilters(data, params):Filter[] {
+    let length = Array.isArray(data) ? data.length : 1;
+
+    var filter_names=["Funder"];
+    var filter_ids=["relfunder"];
+    var searchFields = new SearchFields();
+    var filter_original_ids = ["relfunder"];//searchFields.JOURNAL_FIELDS;
+
+    this.refineFields = ["relfunder"];
+    this.searchPage.refineFields = this.refineFields;
+    this.searchPage.getParametersFromUrl(params);
+
+    var value_names=[/*["Journal", "Journal Aggregator\/Publisher"]*/];
+    var value_original_ids=[/*["pubsrepository::journal", "aggregator::pubsrepository::journals"]*/];
+
+    var funders = new Set<String>();
+    var value_name = [];
+    var value_original_id = [];
+    let i;
+    for(i=0; i<length; i++) {
+      let resData = Array.isArray(data) ? data[i] : data;
+      if(resData.funder && !funders.has(resData.funder)) {
+        funders.add(resData.funder);
+        value_name.push(resData.funder);
+        value_original_id.push(resData.funder.trim());
+      }
+    }
+    value_names.push(value_name);
+    value_original_ids.push(value_original_id);
+
+    var filters: Filter[] =[];
+    for(i =0 ; i < filter_names.length;i++){
+      var values:Value[] = [];
+      for(var j =0 ; j < value_names[i].length;j++){
+        var value:Value = {name: value_names[i][j], id: value_original_ids[i][j], number:j, selected:false}
+        values.push(value);
+      }
+       var filter:Filter = {title: filter_names[i], filterId: filter_ids[i], originalFilterId:  filter_original_ids[i], values : values, countSelectedValues:0, "filterOperator": 'or' };
+       filters.push(filter);
+       console.info(filter);
+    }
+    return filters;
+  }
 }

src/app/searchPages/simple/searchProjects.module.ts

@@ -9,9 +9,16 @@ import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';
 import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';
 import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'
 import { SearchProjectsModule} from '../../openaireLibrary/searchPages/simple/searchProjects.module';
+
+import { SearchPageTableViewModule} from '../../openaireLibrary/searchPages/searchUtils/searchPageTableView.module';
+import {DataProvidersServiceModule} from '../../openaireLibrary/services/dataProvidersService.module';
+import {SearchFormModule} from  '../../openaireLibrary/searchPages/searchUtils/searchForm.module';
+import {SearchProjectsServiceModule} from '../../services/searchProjectsService.module';
+
 @NgModule({
   imports: [
-    CommonModule, FormsModule, SearchProjectsRoutingModule, SearchProjectsModule
+    CommonModule, FormsModule, SearchProjectsRoutingModule, SearchProjectsModule, SearchPageTableViewModule,
+    DataProvidersServiceModule, SearchFormModule, SearchProjectsServiceModule
 
   ],
   declarations: [

src/app/services/searchProjects.service.ts

@@ -0,0 +1,52 @@
+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 {SearchResult}     from '../openaireLibrary/utils/entities/searchResult';
+import {RefineResultsUtils} from '../openaireLibrary/services/servicesUtils/refineResults.class';
+import{EnvProperties} from '../openaireLibrary/utils/properties/env-properties';
+
+@Injectable()
+export class SearchCommunityProjectsService {
+    private sizeOfDescription: number = 270;
+
+    constructor(private http: Http ) {}
+
+    searchProjects (properties:EnvProperties ):any {
+
+        console.info("In searchProjects");
+
+        let url = properties.communityAPI+"egi/projects";
+
+        return this.http.get((properties.useCache)? (properties.cacheUrl+encodeURIComponent(url)): url)
+                    .map(res => <any> res.json())
+                    //.do(res => console.info(res))
+                    //.map(res => this.parseResults(res));
+    }
+
+/*
+    parseResults(data: any): SearchResult[] {
+        console.info(data);
+        let results = [];
+
+        let length = Array.isArray(data) ? data.length : 1;
+
+        for(let i=0; i<length; i++) {
+            let resData = Array.isArray(data) ? data[i] : data;
+
+
+            var result = {"name": '', "acronym": '', "code": '', "grantId": ''};
+            result.name = resData.name;
+            result.acronym = resData.acronym;
+            result.code = resData.code;
+            result.grantId = resData.grantId;
+
+            results.push(result);
+        }
+
+        return results;
+    }
+*/
+}

src/app/services/searchProjectsService.module.ts

@@ -0,0 +1,20 @@
+import { NgModule}            from '@angular/core';
+import { CommonModule }        from '@angular/common';
+import { FormsModule }         from '@angular/forms';
+
+import {SearchCommunityProjectsService} from './searchProjects.service';
+
+
+@NgModule({
+  imports: [
+    CommonModule, FormsModule
+  ],
+  declarations: [
+  ],
+  providers:[
+  SearchCommunityProjectsService
+],
+  exports: [
+    ]
+})
+export class SearchProjectsServiceModule { }

src/assets/env-properties.json

@@ -58,6 +58,8 @@
 
   "adminToolsCommunity" :"openaire",
 
+  "communityAPI": "https://dev-openaire.d4science.org/openaire/community/",
+
   "csvLimit":  2000,
   "pagingLimit":  20,
   "resultsPerPage":  10,