openaire-library/searchPages/find/search.component.ts

import {Component, Input, Output}     from '@angular/core';
import {EventEmitter, ViewChild}      from '@angular/core';
import {ChangeDetectionStrategy}      from '@angular/core';
import {ViewEncapsulation}            from '@angular/core';
import {ActivatedRoute, Router}       from '@angular/router';
import {Location}                     from '@angular/common';
import {Title, Meta}                  from '@angular/platform-browser';

import {Observable}                   from 'rxjs';

import {FetchPublications}            from '../../utils/fetchEntitiesClasses/fetchPublications.class';
import {FetchDataproviders}           from  '../../utils/fetchEntitiesClasses/fetchDataproviders.class';
import {FetchProjects}                from  '../../utils/fetchEntitiesClasses/fetchProjects.class';
import {FetchDatasets}                from '../../utils/fetchEntitiesClasses/fetchDatasets.class';
import {FetchSoftware}                from '../../utils/fetchEntitiesClasses/fetchSoftware.class';
import {FetchOrps}                    from '../../utils/fetchEntitiesClasses/fetchOrps.class';
import {FetchOrganizations}           from '../../utils/fetchEntitiesClasses/fetchOrganizations.class';

import {SearchPublicationsService}    from '../../services/searchPublications.service';
import {SearchDataprovidersService}   from '../../services/searchDataproviders.service';
import {SearchProjectsService}        from '../../services/searchProjects.service';
import {SearchDatasetsService}        from '../../services/searchDatasets.service';
import {SearchSoftwareService}        from '../../services/searchSoftware.service';
import {SearchOrpsService}        from '../../services/searchOrps.service';
import {SearchOrganizationsService}   from '../../services/searchOrganizations.service';

import {SearchFields, FieldDetails}   from '../../utils/properties/searchFields';
import {ErrorCodes}                   from '../../utils/properties/errorCodes';
import {RouterHelper}                 from '../../utils/routerHelper.class';
import {RefineFieldResultsService}    from '../../services/refineFieldResults.service';
import {PiwikService}                 from '../../utils/piwik/piwik.service';
import {ConfigurationService}         from '../../utils/configuration/configuration.service';
import {EnvProperties}                from '../../utils/properties/env-properties';
import { SEOService } from '../../sharedComponents/SEO/SEO.service';
import {StringUtils}             from '../../utils/string-utils.class';

@Component({
  changeDetection: ChangeDetectionStrategy.Default,
  encapsulation: ViewEncapsulation.Emulated,
    selector: 'search-find',
    templateUrl: 'search.component.html'
})
export class SearchComponent {
  public sub: any; piwiksub: any;
  public reloadPublications: boolean;
  public reloadDatasets: boolean;
  public reloadSoftware: boolean;
  public reloadOrps: boolean;
  public reloadProjects: boolean;
  public reloadDataproviders: boolean;
  public reloadOrganizations: boolean;


  public pageTitle = "Search in OpenAIRE"
  public keyword:string = "";
  public publications:string[];
  public datasets:string[];
  public software:string[];
  public orps:string[];
  public projectsTab:string[];
  public dataproviders:string[];
  public organizations:string[];

  public activeTab = "publications";
  public linkToSearchPublications = "";
  public linkToSearchProjects = "";
  public linkToSearchDataproviders = "";
  public linkToSearchDatasets = "";
  public linkToSearchSoftware = "";
  public linkToSearchOrps = "";
  public linkToSearchOrganizations = "";

  public fetchPublications : FetchPublications;
  public fetchDataproviders : FetchDataproviders;
  public fetchProjects : FetchProjects;
  public fetchDatasets: FetchDatasets;
  public fetchSoftware: FetchSoftware;
  public fetchOrps: FetchOrps;
  public fetchOrganizations: FetchOrganizations;

  public searchFields:SearchFields = new SearchFields();
  public errorCodes:ErrorCodes = new ErrorCodes();
  public routerHelper:RouterHelper = new RouterHelper();

  public publicationsSize:any = null;
  public datasetsSize:any = null;
  public softwareSize:any = null;
  public oprsSize:any = null;
  public fundersSize:any = null;
  public projectsSize:any = null;
  public datasourcesSize:any = null;
  showPublications:boolean= false;
  showDatasets:boolean= false;
  showSoftware:boolean=false;
  showOrps:boolean=false;
  showProjects:boolean= false;
  showDataProviders:boolean= false;
  showOrganizations:boolean= false;
  advancedSearchLink:string ="/search/advanced/publications";
  properties: EnvProperties;
  @Input() logoURL;
  @Input() name;
  @Input() connectCommunityId =null;
  @Input() piwikSiteId = null;
  @Input() formPlaceholderText = "Search for research results, projects, content providers & organizations in OpenAIRE";


public subPub;public subData; public subSoftware; public subOrps; public subProjects;public subOrg; public subDataPr;
  constructor ( private route: ActivatedRoute,
      private _router: Router,
      private _searchPublicationsService: SearchPublicationsService,
      private _searchDataprovidersService: SearchDataprovidersService,
      private _searchProjectsService: SearchProjectsService,
      private _searchDatasetsService: SearchDatasetsService,
      private _searchSoftwareService: SearchSoftwareService,
      private _searchOrpsService: SearchOrpsService,
      private _searchOrganizationsService: SearchOrganizationsService,
      private _refineFieldResultsService:RefineFieldResultsService,
      private location: Location,
      private _meta: Meta,
      private _title: Title,
      private _piwikService:PiwikService,
      private config: ConfigurationService,
    private seoService: SEOService ) {
          this.fetchPublications = new FetchPublications(this._searchPublicationsService);
          this.fetchDataproviders = new FetchDataproviders(this._searchDataprovidersService);
          this.fetchProjects = new FetchProjects(this._searchProjectsService);
          this.fetchDatasets = new FetchDatasets( this._searchDatasetsService);
          this.fetchSoftware = new FetchSoftware(this._searchSoftwareService);
          this.fetchOrps = new FetchOrps( this._searchOrpsService);
          this.fetchOrganizations = new FetchOrganizations( this._searchOrganizationsService);

  }

  public ngOnInit() {
    this.route.data
      .subscribe((data: { envSpecific: EnvProperties }) => {

        var description = "open access, research, scientific publication, European Commission, EC, FP7, ERC, Horizon 2020, H2020, search, projects ";
        var title = "OpenAIRE | Search publications, research data, projects... | OpenAIRE";
        this.properties = data.envSpecific;
        var url = data.envSpecific.baseLink+this._router.url;
        this._title.setTitle(title);
        this._meta.updateTag({content:description},"name='description'");
        this._meta.updateTag({content:description},"property='og:description'");
        this._meta.updateTag({content:title},"property='og:title'");
        this._meta.updateTag({content:url},"property='og:url'");
        this.seoService.createLinkForCanonicalURL(this.properties.baseLink+this._router.url,false);
        if(this.properties.enablePiwikTrack && (typeof document !== 'undefined')){
          this.piwiksub = this._piwikService.trackView(this.properties, "OpenAIRE |Search publications, research data, projects...", this.piwikSiteId).subscribe();

        }



      this.config.getCommunityInformation(this.properties, (this.connectCommunityId)?this.connectCommunityId:this.properties.adminToolsCommunity ).subscribe(data => {
          var showEntity = {};
          for(var i=0; i< data['entities'].length; i++){

            showEntity[""+data['entities'][i]["pid"]+""] = data['entities'][i]["isEnabled"];
          }
          this.showPublications =  showEntity["publication"];
          this.showDatasets =   showEntity["dataset"];
          this.showProjects =   showEntity["project"];
          this.showOrganizations =   showEntity["organization"];
          this.showDataProviders =   showEntity["datasource"];
          this.showSoftware =  showEntity["software"];
          this.showOrps =   showEntity["orp"];
          if(this.connectCommunityId){
            this.showProjects = false;
            this.showOrganizations = false;
            this.showDataProviders = false;
          }

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

                this.reloadTabs();
                this.keyword = (params['keyword'])?params['keyword']:"";
                if(this.keyword !=null && this.keyword.length > 0){
                  //if showPublications == false will set another entity as the first
                  if(this.showPublications){
                    this.activeTab = "publications";
                    this.searchPublications();
                  }else if(this.showDatasets){
                    this.activeTab = "research data";
                    this.searchDatasets();
                  }else if(this.showSoftware){
                    this.activeTab = "software";
                    this.searchSoftware();
                  }else if(this.showOrps){
                    this.activeTab = "other research products";
                    this.searchOrps();
                  }else if(this.showProjects){
                    this.activeTab = "projects";
                    this.searchProjects();
                  }else if(this.showDataProviders){
                    this.activeTab = "content providers";
                    this.searchDataProviders();
                  }else if(this.showOrganizations){
                    this.activeTab = "organizations";
                    this.searchOrganizations();
                  }
                  this.count();
                }
              });
        });
          });
      }




  public ngOnDestroy() {
    if(this.sub){
      this.sub.unsubscribe();
    }
    if(this.piwiksub){
        this.piwiksub.unsubscribe();
      }
    if(this.keyword !=null && this.keyword.length > 0){
        if(this.subPub){
          this.subPub.unsubscribe();
        }
        if(this.subData){
          this.subData.unsubscribe();
        }
        if(this.subSoftware){
          this.subSoftware.unsubscribe();
        }
        if(this.subOrps){
          this.subOrps.unsubscribe();
        }
        if(this.subProjects){
          this.subProjects.unsubscribe();
        }
        if(this.subOrg){
          this.subOrg.unsubscribe();
        }
        if(this.subDataPr){
          this.subDataPr.unsubscribe();
        }

    }
  }
  public searchPublications() {
    this.activeTab = "publications";
    this.advancedSearchLink ="/search/advanced/publications";
    if( this.reloadPublications &&
         this.fetchPublications.searchUtils.status != this.errorCodes.NONE /*&&
        this.fetchPublications.searchUtils.status != this.errorCodes.ERROR*/) {
      this.reloadPublications = false;
      this.fetchPublications.getResultsByKeyword(this.keyword,  1, 10,this.properties, this.connectCommunityId);
      this.linkToSearchPublications = this.properties.searchLinkToPublications;// + "?keyword="  + this.keyword;
    }
   }
   public searchDatasets() {
     this.activeTab = "research data";
     this.advancedSearchLink ="/search/advanced/datasets";
     if(this.reloadDatasets &&
        this.fetchDatasets.searchUtils.status != this.errorCodes.NONE /*&&
        this.fetchDatasets.searchUtils.status != this.errorCodes.ERROR*/) {
       this.reloadDatasets = false;
       this.fetchDatasets.getResultsByKeyword(this.keyword,  1, 10,this.properties, this.connectCommunityId);
       this.linkToSearchDatasets =this.properties.searchLinkToDatasets;// + "?keyword="  + this.keyword;
     }
   }
   public searchSoftware() {

     this.activeTab = "software";
     this.advancedSearchLink ="/search/advanced/software";
     if(this.reloadSoftware
       && this.fetchSoftware.searchUtils.status != this.errorCodes.NONE/* &&
        ( this.fetchSoftware.searchUtils.status == this.errorCodes.LOADING ||
          this.fetchSoftware.searchUtils.status == this.errorCodes.DONE )*/) {
       this.reloadSoftware = false;
       this.fetchSoftware.getResultsByKeyword(this.keyword,  1, 10,this.properties, this.connectCommunityId);
       this.linkToSearchSoftware = this.properties.searchLinkToSoftware;// + "?keyword="  + this.keyword;
     }
   }
   public searchOrps() {
     this.activeTab = "other research products";
     this.advancedSearchLink ="/search/advanced/other";
     if(this.reloadOrps &&
        this.fetchOrps.searchUtils.status != this.errorCodes.NONE /*&&
        this.fetchOrps.searchUtils.status != this.errorCodes.ERROR*/) {
       this.reloadOrps = false;
       this.fetchOrps.getResultsByKeyword(this.keyword,  1, 10,this.properties, this.connectCommunityId);
       this.linkToSearchOrps =this.properties.searchLinkToOrps;
     }
   }
   public  searchProjects() {
     this.activeTab = "projects";
     this.advancedSearchLink ="/search/advanced/projects";
     if(this.reloadProjects &&
        this.fetchProjects.searchUtils.status != this.errorCodes.NONE /*&&
        this.fetchProjects.searchUtils.status != this.errorCodes.ERROR*/) {
       this.reloadProjects = false;
       this.fetchProjects.getResultsByKeyword(this.keyword,  1, 10,this.properties);
       this.linkToSearchProjects = this.properties.searchLinkToProjects;// + "?keyword="  + this.keyword;
     }
   }
   public  searchDataProviders() {
     this.activeTab = "content providers";
     this.advancedSearchLink ="/search/advanced/dataproviders";
     if( this.reloadDataproviders &&
         this.fetchDataproviders.searchUtils.status != this.errorCodes.NONE /*&&
         this.fetchDataproviders.searchUtils.status != this.errorCodes.ERROR*/) {
       this.reloadDataproviders = false;
       this.fetchDataproviders.getResultsByKeyword(this.keyword, 1, 10,this.properties);
       this.linkToSearchDataproviders = this.properties.searchLinkToDataProviders;// + "?keyword="  + this.keyword;
     }
   }
   public searchOrganizations() {
     this.activeTab = "organizations";
     this.advancedSearchLink ="/search/advanced/organizations";
     if( this.reloadOrganizations &&
         this.fetchOrganizations.searchUtils.status != this.errorCodes.NONE /*&&
         this.fetchOrganizations.searchUtils.status != this.errorCodes.ERROR*/) {
       this.reloadOrganizations = false;
       this.fetchOrganizations.getResultsByKeyword(this.keyword,  1, 10,this.properties);
       this.linkToSearchOrganizations = this.properties.searchLinkToOrganizations;// + "?keyword="  + this.keyword;
     }
   }


   public keywordChanged($event){

    this.keyword = $event.value;
    //console.info("Search Find: search with keyword \"" +  this.keyword + "\"" );
      this.location.go(location.pathname,"?keyword="  + this.keyword);
    this.reloadTabs();
    if(this.activeTab == "publications") {
      this.searchPublications();
    }
    if(this.activeTab == "projects") {
      this.searchProjects();
    }
    if(this.activeTab == "content providers") {
      this.searchDataProviders();
    }
    if(this.activeTab == "research data") {
      this.searchDatasets();
    }
    if(this.activeTab == "software") {
      this.searchSoftware();
    }
    if(this.activeTab == "other research products") {
      this.searchOrps();
    }
    if(this.activeTab == "organizations") {
      this.searchOrganizations();
    }

    this.count();
   }

   private count() {
     var refineParams = this.connectCommunityId?("&fq="+StringUtils.URIEncode("communityId exact " + StringUtils.quote((this.connectCommunityId )))):null;
     if(this.activeTab != "publications" && this.showPublications){
      this.fetchPublications.searchUtils.status = this.errorCodes.LOADING;
      this.fetchPublications.results = [];

      this.subPub = this._searchPublicationsService.numOfSearchPublications(this.keyword,this.properties, refineParams).subscribe(
             data => {
                 this.fetchPublications.searchUtils.totalResults = data;
                 this.fetchPublications.searchUtils.status = this.errorCodes.DONE;
                 if(this.fetchPublications.searchUtils.totalResults == 0) {
                   this.fetchPublications.searchUtils.status = this.errorCodes.NONE;
                 }
             },
             err => {
       		    //console.log(err);
              this.handleError("Error getting number of Publications", err);
              this.fetchPublications.searchUtils.status = this.errorCodes.ERROR;
       		 }
      );
    }
    if(this.activeTab != "research data" && this.showDatasets){
       this.fetchDatasets.searchUtils.status = this.errorCodes.LOADING;
       this.fetchDatasets.results = [];
       this.subData = this._searchDatasetsService.numOfSearchDatasets(this.keyword,this.properties, refineParams).subscribe(
             data => {
                 this.fetchDatasets.searchUtils.totalResults = data;
                 this.fetchDatasets.searchUtils.status = this.errorCodes.DONE;
                 if(this.fetchDatasets.searchUtils.totalResults == 0) {
                   this.fetchDatasets.searchUtils.status = this.errorCodes.NONE;
                 }
             },
             err => {
                 //console.log(err);
                 this.handleError("Error getting number of Research Data", err);
                 this.fetchDatasets.searchUtils.status = this.errorCodes.ERROR;
              }
       );
    }
    if(this.activeTab != "software" && this.showSoftware){
       this.fetchSoftware.searchUtils.status = this.errorCodes.LOADING;
       this.fetchSoftware.results = [];
       this.subSoftware = this._searchSoftwareService.numOfSearchSoftware(this.keyword,this.properties, refineParams).subscribe(
             data => {
                 this.fetchSoftware.searchUtils.totalResults = data;
                 this.fetchSoftware.searchUtils.status = this.errorCodes.DONE;
                 if(this.fetchSoftware.searchUtils.totalResults == 0) {
                   this.fetchSoftware.searchUtils.status = this.errorCodes.NONE;
                 }
             },
             err => {
                this.handleError("Error getting number of Software", err);
                 /*console.log(err);
                 if(err.status == '404') {
                   this.fetchSoftware.searchUtils.status = this.errorCodes.NOT_FOUND;
                 } else if(err.status == '500') {
                   this.fetchSoftware.searchUtils.status = this.errorCodes.ERROR;
                 } else {
                   this.fetchSoftware.searchUtils.status = this.errorCodes.NOT_AVAILABLE;
                 }*/
                 this.fetchSoftware.searchUtils.status = this.errorCodes.ERROR;
              }
       );
    }
    if(this.activeTab != "other research products" && this.showOrps){
       this.fetchOrps.searchUtils.status = this.errorCodes.LOADING;
       this.fetchOrps.results = [];
       this.subOrps = this._searchOrpsService.numOfSearchOrps(this.keyword,this.properties, refineParams).subscribe(
             data => {
                 this.fetchOrps.searchUtils.totalResults = data;
                 this.fetchOrps.searchUtils.status = this.errorCodes.DONE;
                 if(this.fetchOrps.searchUtils.totalResults == 0) {
                   this.fetchOrps.searchUtils.status = this.errorCodes.NONE;
                 }
             },
             err => {
                 //console.log(err);
                 this.handleError("Error getting number of Other Research Products", err);
                 this.fetchOrps.searchUtils.status = this.errorCodes.ERROR;
              }
       );
    }
    if(this.activeTab != "projects" && this.showProjects){
      this.fetchProjects.searchUtils.status = this.errorCodes.LOADING;
      this.fetchProjects.results = [];
      this.subProjects = this._searchProjectsService.numOfSearchProjects(this.keyword,this.properties).subscribe(
             data => {
                 this.fetchProjects.searchUtils.totalResults = data;
                 this.fetchProjects.searchUtils.status = this.errorCodes.DONE;
                 if(this.fetchProjects.searchUtils.totalResults == 0) {
                   this.fetchProjects.searchUtils.status = this.errorCodes.NONE;
                 }
             },
             err => {
                 //console.log(err);
                 this.handleError("Error getting number of Projects", err);
                 this.fetchProjects.searchUtils.status = this.errorCodes.ERROR;
              }
       );
     }
     if(this.activeTab != "content providers" && this.showDataProviders){
       this.fetchDataproviders.results = [];
       this.fetchDataproviders.getNumForSearch(this.keyword,this.properties);
     }
      if(this.activeTab != "organizations" && this.showOrganizations){
       this.fetchOrganizations.searchUtils.status = this.errorCodes.LOADING;
       this.fetchOrganizations.results = [];
       this.subOrg = this._searchOrganizationsService.numOfSearchOrganizations(this.keyword,this.properties).subscribe(
             data => {
                 this.fetchOrganizations.searchUtils.totalResults = data;
                 this.fetchOrganizations.searchUtils.status = this.errorCodes.DONE;
                 if(this.fetchOrganizations.searchUtils.totalResults == 0) {
                   this.fetchOrganizations.searchUtils.status = this.errorCodes.NONE;
                 }
             },
             err => {
                 //console.log(err);
                 this.handleError("Error getting number of Organizations", err);
                 this.fetchOrganizations.searchUtils.status = this.errorCodes.ERROR;

              }
         );
       }


   }

   private reloadTabs() {
       this.reloadPublications = true;
       this.reloadDatasets = true;
       this.reloadSoftware = true;
       this.reloadOrps = true;
       this.reloadProjects = true;
       this.reloadDataproviders = true;
       this.reloadOrganizations = true;
       this.fetchOrganizations.searchUtils.status = null;
       this.fetchDataproviders.searchUtils.status = null;
       this.fetchProjects.searchUtils.status = null;
       this.fetchPublications.searchUtils.status = null;
       this.fetchDatasets.searchUtils.status = null;
       this.fetchSoftware.searchUtils.status = null;
       this.fetchOrps.searchUtils.status = null;
   }

   private handleError(message: string, error) {
     console.error("General Search Page: "+message, error);
   }
}