D-Net

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

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

import {SearchCrossrefService} from '../../services/searchCrossref.service';

import {SearchOrcidService} from '../../services/searchOrcid.service';

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

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

import {ClaimResult} from '../../utils/entities/claimEntities.class';

import{DOI} from '../../utils/string-utils.class';

@Component({

    selector: 'claim-publication',

    templateUrl: 'claimPublication.component.html',

})

export class ClaimPublicationComponent {

  constructor (private _searchCrossrefService: SearchCrossrefService,private _searchOrcidService: SearchOrcidService, private _searchPublicationsService: SearchPublicationsService,

  private route: ActivatedRoute) {

    var myDate = new Date();

    this.todayDate = myDate.getFullYear()+ "-" +(myDate.getMonth() + 1) + "-" + myDate.getDate() ;

    this.nextDate =  (myDate.getFullYear()+100)+ "-01-01" ;

  }

  ngOnInit() {

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

       if(this.keyword !=null && this.keyword.length > 0){

        this.search(this.keyword);

      }

    });

}

ngOnDestroy() {

  this.sub.unsubscribe();

}

@Input() public keyword:string = "";

@Input() public select:boolean = true ;

@Input() public selectedPublications = [] ;

@Output() publicationsChange = new EventEmitter();

  sub: any;

  size:number = 10;

  source: string = "crossref";

  type : string = "publication";

  errorCodes:ErrorCodes = new ErrorCodes();

  crossrefResults=[];

  crossrefResultsNum : number = null;

  crossrefPage : number = 1;

  crossrefStatus:number = this.errorCodes.NONE;

  openaireResults = [];

  openaireResultsNum: number ;

  openairePage : number = 1;

  openaireStatus:number = this.errorCodes.NONE;

  orcidResults: string[];

  orcidResultsNum: number ;

  totalPages: number;

  orcidResultsToShow: string[];

  orcidPage : number = 1;

  orcidStatus:number = this.errorCodes.NONE;

  authorId: string;

  authorGivenName: string;

  authorFamilyName: string;

  authorIds: string[];

  authorGivenNames: string[];

  authorFamilyNames: string[];

  authorsNum : number ;

  public warningMessage = "";

  public infoMessage = "";

    todayDate = '';

    nextDate = '';

private DOIs:string[] = [];

public search(term: string){

  this.warningMessage = "";

  this.infoMessage = "";

  this.DOIs = DOI.getDOIsFromString(term);

  this.getCrossrefResults(term, this.size,1);

  this.searchOrcid(term);

  this.searchOpenaire(term, this.size, 1);

}

private   getCrossrefResults (term: string, size : number, page : number)  {

    this.crossrefStatus = this.errorCodes.LOADING;

    if( this.DOIs.length > 0 ){

      this._searchCrossrefService.searchCrossrefByDOIs(this.DOIs).subscribe(

        data => {

            if(data != null) {

                this.crossrefResults = data.items;

                this.crossrefPage=page;

                this.crossrefResultsNum = data['total-results'];

                if(data.items == 0){

                    this._searchCrossrefService.searchCrossrefResults(term, size, page).subscribe(

                        data => {

                            if(data != null) {

                                this.crossrefResults = data.items;

                                this.crossrefPage=page;

                                this.crossrefResultsNum = data['total-results'];

                                this.crossrefStatus = this.errorCodes.DONE;

                            }else{

                              this.crossrefStatus = this.errorCodes.ERROR;

                            }

                        },

                        err =>{

                           console.log(err.status);

                           this.crossrefStatus = this.errorCodes.ERROR;

                         }

                    );

                }else{

                  this.crossrefStatus = this.errorCodes.DONE;

                }

            }

         },

        err => {

          //console.log(err);

          this._searchCrossrefService.searchCrossrefResults(term, size, page).subscribe(

            data => {

              this.crossrefResults = data.items;

              this.crossrefPage=page;

              this.crossrefResultsNum = data['total-results'];

              this.crossrefStatus = this.errorCodes.DONE;

             },

            err => {

              console.log(err.status);

              this.crossrefStatus = this.errorCodes.ERROR;

            }

          );

        }

      );

    }else{

      this._searchCrossrefService.searchCrossrefResults(term, size, page).subscribe(

        data => {

            if(data != null) {

                this.crossrefResults = data.items;

                this.crossrefPage=page;

                this.crossrefResultsNum = data['total-results'];

                this.crossrefStatus = this.errorCodes.DONE;

            }else{

              this.crossrefStatus = this.errorCodes.ERROR;

            }

         },

        err => {

          console.log(err.status);

          this.crossrefStatus = this.errorCodes.ERROR;

          }

      );

    }

  }

  private searchOpenaire(term: string, size : number, page : number)  {

          if(this.DOIs.length > 0 ){

            this.openaireStatus = this.errorCodes.LOADING;

            this._searchPublicationsService.searchPublicationsByDois(this.DOIs, null, page, size, []).subscribe(

              data => {

                  if(data != null) {

                      this.openairePage=page;

                      this.openaireResultsNum = data[0];

                      this.openaireResults = data[1];

                      this.openaireStatus = this.errorCodes.DONE;

                      if(this.openaireResultsNum == 0){

                        this.openaireStatus = this.errorCodes.NONE;

                      }

                  }else {

                    this.openaireStatus = this.errorCodes.ERROR;

                  }

               },

              err => {

                this.openaireStatus = this.errorCodes.ERROR;

                console.log(err.status);

              }

            );

          }else{

            this.openaireStatus = this.errorCodes.LOADING;

            this._searchPublicationsService.searchPublications('q="'+term+'"', null, page, size, []).subscribe(

              data => {

                  if(data != null) {

                      this.openairePage=page;

                      this.openaireResultsNum = data[0];

                      this.openaireResults = data[1];

                      this.openaireStatus = this.errorCodes.DONE;

                      if(this.openaireResultsNum == 0){

                        this.openaireStatus = this.errorCodes.NONE;

                      }

                  }else {

                    this.openaireStatus = this.errorCodes.ERROR;

                  }

               },

              err => {

                this.openaireStatus = this.errorCodes.ERROR;

                console.log(err.status);

              }

            );

          }

  }

  private searchOrcid (term: string) {

    if(this.DOIs.length > 0){

      this.orcidStatus = this.errorCodes.NONE;

      return;

    }

    this.orcidStatus = this.errorCodes.LOADING;

    this.authorIds = new Array<string>();

    this.authorGivenNames = new Array<string>();

    this.authorFamilyNames = new Array<string>();

    this.getOrcidAuthor(term);

    console.info('searchOrcid in searchOrcid file');

   }

  private readData(data: any) {

    this.authorIds.push(data[2].path);

    if(data[0] != null) {

      this.authorGivenNames.push(data[0].value);

    } else {

      this.authorGivenNames.push("");

    }

    if(data[1] != null) {

      this.authorFamilyNames.push(data[1].value);

    } else {

      this.authorFamilyNames.push("");

    }

  }

  private  getOrcidAuthor (term: string)  {

    this.orcidResultsNum = null;

    //passing structures in order to fill them in service

    this._searchOrcidService.searchOrcidAuthor(term, this.authorIds,

      this.authorGivenNames, this.authorFamilyNames).subscribe(

        data => {

          if(data != null && data == true) {

            this.getOrcidResultsById(0);

          }

          this.orcidStatus = this.errorCodes.NONE;

        },

        err => this.errorHandler(err, term)

      );

    }

    private  errorHandler(err: any, term: string) {

      if(err.status == 404){

        this.getOrcidAuthors(term);

      } else {

        this.orcidStatus = this.errorCodes.ERROR;

        console.log(err.status);

      }

    }

    private  getOrcidAuthors (term: string)  {

      this.orcidResultsNum = null;

      //passing structures in order to fill them in service

      this._searchOrcidService.searchOrcidAuthors(term, this.authorIds,

        this.authorGivenNames, this.authorFamilyNames).subscribe(

          data => {

            if(data != null && data == true) {

              this.getOrcidResultsById(0);

            }else{

              this.orcidStatus = this.errorCodes.ERROR;

            }

          },

          err => {

            this.orcidStatus = this.errorCodes.ERROR;

            console.log(err.status);

          }

        );

      }

      private    getOrcidResultsById (index:number) {

        if(this.authorIds.length > index) {

          let id = this.authorIds[index];

          console.info("getOrcidResultsById: "+id);

          this._searchOrcidService.searchOrcidPublications(id).subscribe(

            data => {

              if(data != null) {

                this.orcidResults=data['orcid-work'];

                this.orcidResultsNum = data['orcid-work'].length;

                this.orcidPage = 1;

                if((this.orcidResultsNum % this.size) == 0){

                  this.totalPages=parseInt(''+(this.orcidResultsNum/this.size));

                } else{

                  this.totalPages=parseInt(''+(this.orcidResultsNum/this.size+1));

                }

                this.orcidResultsToShow = this.orcidResults.slice(0,10);

                this.orcidStatus = this.errorCodes.DONE;

                if(this.orcidResultsNum == 0){

                  this.orcidStatus = this.errorCodes.NONE;

                }

              } else {

                this.orcidResultsNum = 0;

                this.totalPages=0;

                this.orcidStatus = this.errorCodes.NONE;

              }

              this.authorGivenName = this.authorGivenNames[index];

              this.authorFamilyName = this.authorFamilyNames[index];

              this.authorId = id;

            },

            err => {

              console.log(err.status);

              this.orcidStatus = this.errorCodes.ERROR;

            }

          );

        }

      }

  private  add(item, id, itemSource, itemType, itemUrl, itemTitle,  date, accessMode){

     var result: ClaimResult ;

      if(itemSource == 'crossref'){

        date = (date == null) ? null : date.substring(0,10);

        result = {id: id, type :itemType, source : itemSource, title: itemTitle,url: itemUrl, result: item, accessRights: 'OPEN', embargoEndDate: this.nextDate, date};

      }else if (itemSource == 'orcid'){

        date = (date == null) ? null : date + "-01.-01"

          result = {id:id, type :itemType, source : itemSource, title: itemTitle,url: itemUrl, result: item, accessRights: 'OPEN', embargoEndDate: this.nextDate, date};

      }else if (itemSource == 'openaire'){

        //TODO put right access rights

        result = {id:id, type :itemType, source : itemSource, title: itemTitle,url: itemUrl, result: item, accessRights: accessMode, embargoEndDate: null, date};

      }

      console.info("Added result:"+result.date);

        var found:boolean = this.isSelected(result.id);

        this.warningMessage = "";

        if (!found) {

          this.selectedPublications.push(result);

          this.publicationsChange.emit({

             value: this.selectedPublications

           });

        }else{

            this.warningMessage = "Publication already in selected list";

        }

   }

  private  remove(item){

     this.warningMessage = "";

     this.infoMessage = "";

        var index:number =this.selectedPublications.indexOf(item);

        item.selected=false;

         if (index > -1) {

            this.selectedPublications.splice(index, 1);

            this.publicationsChange.emit({

              value: this.selectedPublications

            });

        }

   }

private crossrefPageChange($event) {

     this.crossrefPage=$event.value;

     this.crossrefResults=[];

     console.log("Crossref chaenged "+this.crossrefPage);

     this.getCrossrefResults(this.keyword,this.size,this.crossrefPage);

}

private orcidPageChange($event) {

     this.orcidPage=$event.value;

     this.orcidResultsToShow=[];

     this.orcidResultsToShow = this.orcidResults.slice(($event.value-1)*this.size, $event.value*this.size);

}

private openairePageChange($event) {

     this.openairePage=$event.value;

     this.searchOpenaire(this.keyword,this.size,this.openairePage);

}

  private   isSelected(id:string){

      var found:boolean = false;

      this.warningMessage = "";

      for (var _i = 0; _i < this.selectedPublications.length; _i++) {

          let item = this.selectedPublications[_i];

          if(item.id == id){

                found=true;

                this.warningMessage = "Publication already in selected list";

          }

       }

       return found;

    }

}