D-Net

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

import {Observable}       from 'rxjs/Observable';

import {SearchCrossrefService} from '../../claim-utils/service/searchCrossref.service';

import {SearchDataciteService} from '../../claim-utils/service/searchDatacite.service';

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

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

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

import{EnvProperties} from '../../../utils/properties/env-properties';

declare var UIkit:any;

@Component({

    selector: 'bulk-claim',

    template: `

    <div class="uk-animation  " style=" ">

      <form class=" uk-padding uk-padding-medium uk-padding-remove-left uk-margin-left uk-margin-small-top ">

      <div class="uk-grid">

        <div class="uk-width-expand">

          <div class="uk-text-lead">Upload a DOI csv file <helper  div="link-result-bulk" tooltip=true ></helper></div>

          <!--h3 for="exampleInputFile">Or upload a DOI csv file:</h3-->

          <label for="exampleInputFile">Select a file: </label>

          <div class="js-upload" uk-form-custom>

            <input id="exampleInputFile" class="uk-width-medium" type="file"  (change)="fileChangeEvent($event)"/>

            <button class="uk-button  portal-button" type="button" tabindex="-1" [class.disabled]="!enableUpload" ><span class="uk-margin-small-right uk-icon"  >

            <svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"> <polyline fill="none" stroke="#000" points="5 8 9.5 3.5 14 8 "></polyline> <rect x="3" y="17" width="13" height="1"></rect>

             <line fill="none" stroke="#000" x1="9.5" y1="15" x2="9.5" y2="4"></line></svg></span> Select</button>

            <!--button class="uk-button uk-button-small" [class.disabled]="!enableUpload" type="button" (click)="upload()">Upload</button-->

        </div>

          <div *ngIf="showReport"  uk-alert  class="uk-alert uk-alert-primary" role="alert" >

            <a class="uk-alert-close" uk-close></a>

            <div>Uploaded file contains {{allIds.length}} {{((allIds.length==1)?'DOI':'DOIs')}}.

              <span *ngIf="allIds.length > 0">{{foundIds.length}} {{((foundIds.length==1)?'result was':'results were')}} succefully  fetched from CrossRef and Datacite.</span>

            </div>

            <div *ngIf ="duplicateIds.length > 0"  >{{duplicateIds.length | number}} duplicate DOIs in {{((duplicateIds.length==1)?'line':'lines')}} {{duplicateIdsRow}}.</div>

            <div *ngIf = "notFoundIds.length > 0"   >Couldn't be found:

              <ul class="">

                <li *ngFor="let id of notFoundIds; let i = index">"{{id}}" in line {{notFoundIdsRow[i]}}</li>

               </ul>

            </div>

            <div *ngIf = "noValidIds.length > 0"   >No valid DOIs:

              <ul class="">

                <li *ngFor="let id of noValidIds; let i = index">"{{id}}" in line {{noValidIdsRow[i]}}</li>

               </ul>

            </div>

            <div *ngIf = "allIds.length == 0 || foundIds.length == 0"   > Please make sure that the uploaded file, is a csv file with the proper format. </div>

          </div>

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

          <modal-loading [message]= "'Uploading, reading your documet and fetching results. Please give us a moment..'"></modal-loading>

        </div>

        <!--helper  div="link-result-bulk" ></helper-->

      </div>

    </form>

</div>

    `

})

//[(ngModel)]="date"

export class BulkClaimComponent {

  filesToUpload: Array<File>;

  navigateTo: string = "Search";

  source: string = "crossref";

  type : string = "publication";

  resultsFromSearch:number;

  @Input() public select:boolean = true ;

  @Input() public results;

  @Input() public properties:EnvProperties;

  allIds:string[] = [];

  foundIds:string[] = [];

  duplicateIds:string[] = [];

  duplicateIdsRow:number[] = [];

  notFoundIds:string[] = [];

  notFoundIdsRow:number[] = [];

  noValidIds:string[] = [];

  noValidIdsRow:number[] = [];

  showReport:boolean = false;

  showInfo :boolean = false;

  @ViewChild (ModalLoading) loading : ModalLoading ;

  errorMessage = "";

  infoMEssage = "";

  enableUpload:boolean = true;

  @Input() localStoragePrefix:string="";

  exceedsLimit = false;

  limit =150;

  constructor(private _searchCrossrefService: SearchCrossrefService, private _searchDataciteService: SearchDataciteService) {

      this.filesToUpload = [];

  }

  ngOnInit() {}

  upload() {

    this.enableUpload = false;

    this.showReport = false;

    this.errorMessage = "";

    if(this.filesToUpload.length == 0){

      this.errorMessage = "There is no selected file to upload.";

      return ;

    }else{

       if(this.filesToUpload[0].name.indexOf(".csv") == -1 || this.filesToUpload[0].type != "text/csv"){

        this.errorMessage = "No valid file type. The required type is CSV";

        return ;

      }

    }

    this.loading.open();

    this.makeFileRequest(this.properties.uploadService, [], this.filesToUpload).then((result) => {

          var rows = (result as any).split('\n');  // I have used space, you can use any thing.

          this.exceedsLimit = false;

          var i = 0;

          var invalid_rows = 0;

          this.duplicateIds = [];

          this.allIds = [];

          this.foundIds = [];

          this.noValidIds = [];

          this.results.slice(0,this.results.length);

          this.notFoundIds = [];

          if(rows.length +  this.results.length > this.limit){

            this.exceedsLimit = true;

              UIkit.notification({

                  message : 'Your basket exceeds the number of allowed results (150)',

                  status  : 'warning',

                  timeout : 1500,

                  pos     : 'top-center'

              });

          }

          for(i=0;i<((rows.length>this.limit-this.results.length)?(this.limit-this.results.length):rows.length);i++){

            if(rows[i] && rows[i] != null ){

              var values = rows[i].split(',');

              var id=this.removeDoubleQuotes(values[0]);

              if(DOI.isValidDOI(id)){

                var accessMode = (values[1] != undefined) ? this.removeDoubleQuotes(values[1]):"OPEN";

                accessMode = (this.validateAccessMode(accessMode)?accessMode:"OPEN");

                var embargoDate =(values[2] != undefined) ? this.removeDoubleQuotes(values[2]):Dates.getDateToday();

                embargoDate = (Dates.isValidDate(embargoDate)?embargoDate:Dates.getDateToday());

                if(this.allIds.indexOf(id)>-1){

                  this.duplicateIds.push(id);

                  this.duplicateIdsRow.push(i+1);

                }else{

                  this.allIds.push(id);

                  this.fetchResult(id,accessMode,embargoDate,i+1);

                }

             }else{

               this.noValidIds.push(id);

               this.noValidIdsRow.push(i+1);

             }

           }else{

             invalid_rows++;

           }

         }

         if(rows.length == 0 || rows.length == invalid_rows || rows.length == (invalid_rows + this.noValidIds.length) || this.limit == this.results.length ){

           this.endOfFetching();

         }

       }, (error) => {

         this.enableUpload = true;

          console.log(error);

          this.loading.close();

          //this.errorMessage = "An error occured while uploading...";

          this.handleError("Error uploading file", error);

      });

  }

  private removeDoubleQuotes(value){

     if(value.indexOf('"')== 0){

        value = value.substring(1,value.length);

      }

      var index =+value.indexOf('"');

      if(index == (value.length - 1) || index == (value.length - 2) ){

        value = value.substring(0,index);

      }

      return value;

  }

  private validateAccessMode(value){

    var accessModes = ["OPEN", "CLOSED", "EMBARGO"];

     if(accessModes.indexOf(value) > -1){

        return true;

      }

      return false;

  }

  fileChangeEvent(fileInput: any){

      this.filesToUpload = <Array<File>> fileInput.target.files;

      this.upload();

  }

  makeFileRequest(url: string, params: Array<string>, files: Array<File>) {

      return new Promise((resolve, reject) => {

          var formData: any = new FormData();

          var xhr = new XMLHttpRequest();

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

              formData.append("uploads[]", files[i], files[i].name);

          }

          xhr.onreadystatechange = function () {

              if (xhr.readyState == 4) {

                  if (xhr.status == 200) {

                      resolve(xhr.response);

                  } else {

                      reject(xhr.response);

                  }

              }

          }

          xhr.open("POST", url, true);

          xhr.send(formData);

      });

  }

  fetchResult(id:string,accessMode:string,date:string, row:number){

        this._searchCrossrefService.searchCrossrefByDOIs([id], this.properties.searchCrossrefAPIURL, true).subscribe(

          data => {

            var result = data[0];

            if(data.length > 0){

              this.foundIds.push(id);

              result.embargoEndDate = date;

              this.results.push(result);

              this.endOfFetching();

            }else{

              this.searchInDatacite(id,accessMode,date, row);

              // this.notFoundIds.push(id);

            }

           },

          err => {

            //console.log(err);

            this.handleError("Error getting crossref by DOIs: "+id, err);

            this.notFoundIds.push(id);

            this.notFoundIdsRow.push(row);

            this.endOfFetching();

          }

        );

  }

  searchInDatacite(id:string,accessMode:string,date:string, row:number){

        this._searchDataciteService.getDataciteResultByDOI(id,this.properties,true).subscribe(

          items => {

            if(items.length > 0){

              var result = items[0];

              this.foundIds.push(id);

              result.embargoEndDate = date;

              this.results.push(result);

            }else{

              this.notFoundIds.push(id);

              this.notFoundIdsRow.push(row);

            }

            this.endOfFetching();

           },

          err => {

            //console.log(err);

            this.handleError("Error getting datacite result by DOI: "+id, err);

            this.notFoundIds.push(id);

            this.notFoundIdsRow.push(row);

            this.endOfFetching();

          }

        );

  }

  endOfFetching(){

    if(this.limit == this.results.length){

      this.enableUpload = true;

      this.loading.close();

      return;

    }

    if(this.allIds.length == this.foundIds.length+this.notFoundIds.length ){

      this.showReport = true;

      this.enableUpload = true;

      this.loading.close();

      if(this.results != null){

            localStorage.setItem(this.localStoragePrefix + "results", JSON.stringify(this.results));

          }

    }

  }

  private handleError(message: string, error) {

      console.error("Bulk Claim (component): "+message, error);

  }

}