D-Net

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

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 {EnvProperties} from '../../../utils/properties/env-properties';

declare var UIkit: any;

@Component({

  selector: 'bulk-claim',

  template: `

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

      <form class=" ">

        <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>

            <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)"/>

              <span class="uk-link">Upload a DOI's CSV file </span>

              <!--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-->

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

            </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>

  `

})

export class BulkClaimComponent {

  filesToUpload: Array<File>;

  source: string = "crossref";

  type: string = "publication";

  @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;

  @ViewChild(ModalLoading) loading: ModalLoading;

  errorMessage = "";

  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) => {

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

      this.exceedsLimit = false;

      let 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 (let i = 0; i < ((rows.length > this.limit - this.results.length) ? (this.limit - this.results.length) : rows.length); i++) {

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

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

          const id = BulkClaimComponent.removeDoubleQuotes(values[0]);

          if (DOI.isValidDOI(id)) {

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

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

            let embargoDate = (values[2] != undefined) ? BulkClaimComponent.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...";

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

    });

  }

  private static removeDoubleQuotes(value) {

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

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

    }

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

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

      value = value.substring(0, index);

    }

    return value;

  }

  private static validateAccessMode(value) {

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

    return accessModes.indexOf(value) > -1;

  }

  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) => {

      const formData: any = new FormData();

      const xhr = new XMLHttpRequest();

      for (let 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 => {

        const result = data[1][0];

        if (data[1].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);

        BulkClaimComponent.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[1].length > 0) {

          var result = items[1][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);

        BulkClaimComponent.handleError("Error getting datacite resultentityI: " + 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, JSON.stringify(this.results));

      }

    }

  }

  private static handleError(message: string, error) {

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

  }

}