D-Net

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

import {Observable}       from 'rxjs/Observable';

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

import {OrganizationService} from '../../services/organization.service';

import {OrganizationInfo} from '../../utils/entities/organizationInfo';

import {ReportsService} from '../../services/reports.service';

import {FetchPublications} from '../../utils/fetchEntitiesClasses/fetchPublications.class';

import {FetchProjects} from '../../utils/fetchEntitiesClasses/fetchProjects.class';

import {FetchDataproviders} from '../../utils/fetchEntitiesClasses/fetchDataproviders.class';

import {SearchPublicationsService} from '../../services/searchPublications.service';

import {SearchDataprovidersService} from '../../services/searchDataproviders.service';

import {SearchProjectsService} from '../../services/searchProjects.service';

import { Meta} from '../../../angular2-meta';

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

import {SearchingProjectsTabComponent} from '../searchingProjectsInTab.component';

import {RouterHelper} from '../../utils/routerHelper.class';

import {ModalLoading} from '../../utils/modal/loading.component';

import {AlertModal} from '../../utils/modal/alert';

@Component({

    selector: 'organization',

    templateUrl: 'organization.component.html',

})

export class OrganizationComponent {

    organizationInfo: OrganizationInfo;

    //private metrics: string;

    private organizationId: string;

    private projectsNum: number = 0;

    private fundersSet: Set<string>;

    private emptyFundersSet: boolean = true;

    public warningMessage = "";

    public errorMessage = "";

    public downloadURLAPI: string;

    public csvProjectParamsHead: string;

    public csvPublicationParamsHead: string;

    public csvParamsTail: string;

    sub: any;

    subDataproviders: any;

    subDataprovidersCount: any;

    public projectsClicked: boolean = false;

    public fetchPublications: FetchPublications;

    public linkToSearchPublications: string = "";

    public fetchProjects: FetchProjects;

    public fetchDataproviders : FetchDataproviders;

    public linkToSearchDataproviders:string = "";

    @ViewChild (SearchingProjectsTabComponent) searchingProjectsTabComponent : SearchingProjectsTabComponent ;

    public projectFunders:string[] = [];

    public routerHelper:RouterHelper = new RouterHelper();

    @ViewChild (ModalLoading) loading : ModalLoading ;

    @ViewChild('AlertModalApplyAll') alertApplyAll;

    @ViewChild('AlertModalCsvError') alertCsvError;

    public funder: string;

    public funderId: string;

    public count: number;

    public errorCodes:ErrorCodes = new ErrorCodes();

    constructor (private element: ElementRef,

                 private _organizationService: OrganizationService,

                 private  route: ActivatedRoute,

                 private _searchDataprovidersService: SearchDataprovidersService,

                 private _reportsService: ReportsService,

                 private _searchPublicationsService: SearchPublicationsService,

                 private _searchProjectsService: SearchProjectsService, private _meta: Meta,

                 private _router: Router) {

            this.fetchPublications = new FetchPublications(this._searchPublicationsService);

            this.fetchProjects = new FetchProjects(this._searchProjectsService);

            this.fetchDataproviders = new FetchDataproviders(this._searchDataprovidersService);

            this.updateUrl(OpenaireProperties.getBaseLink()+this._router.url);

    }

    ngOnInit() {

        console.info('organization init');

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

            this.organizationInfo=null;

            this.updateTitle("Organization");

            this.updateDescription("Organization, country, projects,  search, repositories, open access");

            this.organizationId = params['organizationId'];

            console.info("Id is :"+this.organizationId);

            if(this.organizationId){

                this.getOrganizationInfo();

            }else{

                this.warningMessage="No valid organization id";

            }

            if (typeof document !== 'undefined') {

               this.element.nativeElement.scrollIntoView();

            }

            this.csvParamsTail = '" and relorganizationid exact "'+this.organizationId+'" ))';

        });

        this.downloadURLAPI = OpenaireProperties.getCsvAPIURL();

        this.csvProjectParamsHead = 'format=csv&type=projects&page=0&query=( (oaftype exact project)and (funderid exact "';

        //this.csvPublicationParamsHead = 'format=csv-special&type=publications&page=0&query=((((oaftype exact result) and (resulttypeid exact publication)) and (funderid exact ';

/*

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

            this._searchDataprovidersService.numOfDataproviders("organizations/"+this.organizationId+"/datasources/count").subscribe(

              data => {

                  this.fetchDataproviders.searchUtils.totalResults = data;

                  console.info("this.fetchDataproviders.searchUtils.totalResults = "+this.fetchDataproviders.searchUtils.totalResults);

              },

              err => {

        		    console.log(err);

        		 }

            );

        })

*/

    }

    ngOnDestroy() {

      this.sub.unsubscribe();

      if(this.subDataproviders != undefined) {

          this.subDataproviders.unsubscribe();

      }

      //this.subDataprovidersCount.unsubscribe();

    }

    private getOrganizationInfo ()  {

        this.warningMessage = '';

        this.errorMessage=""

        this._organizationService.getOrganizationInfo(this.organizationId).subscribe(

            data => {

                if(data == null) {

                    this.errorMessage = 'No organization found';

                } else {

                    this.organizationInfo = data;

                    this.updateTitle(this.organizationInfo.title.name);

                    this.updateDescription("Organization, country, projects,  search, repositories, open access"+this.organizationInfo.title.name);

                    this.fetchPublications.getResultsForEntity("organization", this.organizationId, 1, 10);

                    this.linkToSearchPublications = OpenaireProperties.getLinkToAdvancedSearchPublications();

                    //this.fetchProjects.getNumForEntity("organization", this.organizationId);

                    var refineFields:string [] = ["funderid"];

                    this.fetchProjects.getResultsForOrganizations(this.organizationId, "", 1, 0,refineFields);

                    this.fetchDataproviders.getNumForEntity("organization", this.organizationId);

                    /*let projectsNum = 0;

                    if(this.organizationInfo.projects != undefined) {

                         this.fundersSet = new Set<string>();

                        this.organizationInfo.projects.forEach(function (value, key, map) {

                            projectsNum += value.length;

                            this.fundersSet.add(key);

                        }.bind(this));

                    }

                    this.projectsNum = projectsNum;*/

                }

            },

            err => {

                console.log(err)

                this.errorMessage = 'No organization found';

            }

        );

    }

/*

    private getMetrics() {

        console.info("getOrganizationMetrics: component");

        this._organizationService.getMetrics(this.organizationId).subscribe(

         data => {

             this.metrics = data;

         },

         err => {

           console.log(err);

         }

       );

    }

*/

    private handleClick(funder: string) {

         if(this.emptyFundersSet) {

             this.fundersSet.clear();

             this.emptyFundersSet = false;

         }

         if(this.fundersSet.has(funder)) {

             this.fundersSet.delete(funder);

             if(this.fundersSet.size == 0) {

                 this.organizationInfo.projects.forEach(function (value, key, map) {

                     this.fundersSet.add(key);

                 }.bind(this));

                 this.emptyFundersSet = true;

             }

             console.info(funder+" funder deleted");

         } else {

             this.fundersSet.add(funder);

             console.info(funder+" funder added");

         }

     }

     //private getProjectsData(key: string): any {

         //return this.projectsData;

     //}

     private searchDataproviders() {

       this.fetchDataproviders.getResultsForEntity("organization", this.organizationId, 1, 10);

       this.linkToSearchDataproviders = OpenaireProperties.getLinkToAdvancedSearchDataProviders();

     }

     private searchDataprovidersInit() {

         if(this.subDataproviders == undefined && this.fetchDataproviders.searchUtils.totalResults > 0) {

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

                 this.searchDataproviders();

             });

         }

     }

     downloadFile(url:string){

       console.log("Downloading file: "+ url);

       this.openLoading();

       this.setMessageLoading("Downloading CSV file");

       this._reportsService.downloadCSVFile(url).subscribe(

           data => {

               this.closeLoading();

               window.open(window.URL.createObjectURL(data));

           },

           error => {

             console.log("Error downloading the file.");

             this.closeLoading();

             this.confirmOpenCsvError();

           },

           () => console.log('Completed file download.'));

     }

     downloadPublicationsFile(funder: string, funderId:string, count:number){

       console.log("Downloading publications file");

       this.openLoading();

       this.setMessageLoading("Downloading CSV file");

       let response: string[] = [];

       let totalResponse: string = "";

       let projects = [];

       let counter: number = count;

       let title: boolean = false;

       this._searchProjectsService.getProjectsForOrganizations(this.organizationId,' and (funderid exact '+ funderId + ' ) ',1,count,[]).subscribe(

           data =>

               {

                 projects = data[1];

                  for(let index=0; index < projects.length; index++) {

                      this._searchPublicationsService.numOfEntityPublications(projects[index].id, "projects/").subscribe(

                          data =>

                              {

                                  // let index: number = this.organizationInfo.projects.get(funder).indexOf(project);

                                  let url: string;

                                  if(index == 0 || !title) {

                                      url = this.downloadURLAPI+"projects/"+projects[index].id+"/publications?format=csv-special&size="+data;

                                  } else {

                                      url = this.downloadURLAPI+"projects/"+projects[index].id+"/publications?format=csv-special-notitle&size="+data;

                                  }

                                  if(data == 0) {   // if no publications for this project

                                      counter--;

                                      response[index] = "";

                                      if(counter == 0) {

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

                                              if(response[i] != "") {

                                                  totalResponse += response[i];

                                              }

                                          }

                                          this.closeLoading();

                                          window.open(window.URL.createObjectURL(new Blob([totalResponse], { type: 'text/csv' })));

                                      }

                                  } else if(counter == 1 && !title) {

                                      title = true;

                                      this._reportsService.getCSVResponse(url).subscribe(

                                          data =>

                                              {

                                                  counter--;

                                                  response[index] = data;

                                                  if(counter == 0) {

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

                                                          if(response[i] != "") {

                                                              totalResponse += response[i];

                                                          }

                                                          console.info("2response "+i+": "+response[i]);

                                                      }

                                                      console.info(totalResponse);

                                                      this.closeLoading();

                                                      window.open(window.URL.createObjectURL(new Blob([totalResponse], { type: 'text/csv' })));

                                                  }

                                              },

                                          error => {

                                            console.log("Error downloading the file.");

                                            this.closeLoading();

                                            this.confirmOpenCsvError();

                                          },

                                          () => console.log('Completed file download.')

                                      );

                                  }

                              },

                          error => console.log("Error getting number of publications for project."));

                  }//);

               },

           error => {

            console.log("Error getting projects project.");

            this.closeLoading();

            this.confirmOpenCsvError();

          }

        );

      //  let counter: number = this.organizationInfo.projects.get(funder).length;

       //

      //  for(let project of this.organizationInfo.projects.get(funder)) {

      //       this._searchPublicationsService.numOfEntityPublications(project.id, "projects/").subscribe(

      //           data =>

      //               {

      //                   let index: number = this.organizationInfo.projects.get(funder).indexOf(project);

       //

      //                   let url: string;

      //                   if(index == 0) {

      //                       url = this.downloadURLAPI+"projects/"+project.id+"/publications?format=csv-special&size="+data;

      //                   } else {

      //                       url = this.downloadURLAPI+"projects/"+project.id+"/publications?format=csv-special-notitle&size="+data;

      //                   }

       //

      //                   this._reportsService.getCSVResponse(url).subscribe(

      //                       data =>

      //                           {

      //                               counter--;

       //

      //                               response[index] = data;

       //

      //                               if(counter == 0) {

      //                                   for(let i=0; i<this.organizationInfo.projects.get(funder).length; i++) {

      //                                       totalResponse += response[i]+"\n";

      //                                   }

      //                                   window.open(window.URL.createObjectURL(new Blob([totalResponse], { type: 'text/csv' })));

      //                               }

      //                           },

      //                       error => console.log("Error downloading the file."),

      //                       () => console.log('Completed file download.'));

      //               },

      //           error => console.log("Error getting number of publications for project."));

        // }//);

    }

    updateDescription(description:string){

      this._meta.updateMeta("description", description);

      this._meta.updateProperty("og:description", description);

    }

    updateTitle(title:string){

      var _suffix ="| OpenAIRE";

      var _title = ((title.length> 50 ) ?title.substring(0,50):title) + _suffix;

      this._meta.setTitle(_title );

      this._meta.updateProperty("og:title",_title);

    }

    updateUrl(url:string){

      this._meta.updateProperty("og:url", url);

    }

    public openLoading(){

      if(this.loading){

        this.loading.open();

      }

    }

    public closeLoading(){

      if(this.loading){

        this.loading.close();

      }

    }

    public setMessageLoading(message: string){

      if(this.loading){

        this.loading.message = message;

      }

    }

    confirmOpenApplyAll(funder: string, funderId:string, count:number){

      this.alertApplyAll.cancelButton = true;

      this.alertApplyAll.okButton = true;

      this.alertApplyAll.alertTitle = "CSV FILE";

      this.alertApplyAll.message = "Do you wish to download a CSV file? Note that this process may take a while.";

      this.alertApplyAll.okButtonText = "Yes";

      this.alertApplyAll.cancelButtonText = "No";

      this.alertApplyAll.open();

      this.funder = funder;

      this.funderId = funderId;

      this.count = count;

    }

    confirmCloseApplyAll(data){

         this.downloadPublicationsFile(this.funder, this.funderId, this.count);

    }

    confirmOpenCsvError(){

      this.alertCsvError.cancelButton = false;

      this.alertCsvError.okButton = true;

      this.alertCsvError.alertTitle = "ERROR DOWNLOADING CSV FILE";

      this.alertCsvError.message = "There was an error in csv downloading. Please try again later.";

      this.alertCsvError.okButtonText = "OK";

      this.alertCsvError.open();

    }

}