D-Net

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

import {Location} from '@angular/common';

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

import {Subject} from 'rxjs';

import { debounceTime, distinctUntilChanged } from 'rxjs/operators';

import {ClaimsService} from '../service/claims.service';

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

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

import {Session} from '../../../login/utils/helper.class';

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

import {LoginErrorCodes} from '../../../login/utils/guardHelper.class';

import {SEOService} from '../../../sharedComponents/SEO/SEO.service';

import {IndexInfoService} from "../../../utils/indexInfo.service";

import {ClaimDBRecord} from "../claimHelper.class";

import {Dates} from "../../../utils/string-utils.class";

@Component({

  selector: 'displayClaims',

  templateUrl: 'displayClaims.component.html',

  // providers: [ClaimsService]

})

export class DisplayClaimsComponent {

  properties: EnvProperties;

  public searchTermStream = new Subject<string>();

  sub: any;

  //string because comes as input from component directive

  @Input() enableDelete: boolean = false;

  @Input() showUserEmail: boolean = true;

  @Input() myClaims: boolean = false;

  @Input() isAdmin: boolean = false;

  page: number=1;

  size: number=10;

  sizes = [10, 20, 30, 50];

  keyword: string; // the keyword string to give to the request as parameter

  inputkeyword: string; // the string written in the input field (keyword=inputkeyword when its length is bigger than 3 and the user stops typing)

  types = ["All", "Project", "Context", "Result", "User"];

  @Input() fetchBy: string;

  @Input() fetchId: string;

  resultsNum: number;

  claims: ClaimDBRecord[];

  @Input() externalPortalUrl: string = null;

  @Input() claimsInfoURL: string;// ="https://www.openaire.eu/linking";

  lastIndexDate = null;

  @ViewChild(ModalLoading) loading: ModalLoading;

  //checkboxes:

  publicationCB = false;

  datasetCB = false;

  softwareCB = false;

  otherCB = false;

  contextCB = false;

  projectCB = false;

  entityTypes: string[] = [];

  descending = true;

  sortby = "date";

  selected = [];

  deleteMessage: string = "";

  showErrorMessage: boolean = false;

  showForbiddenMessage: boolean = false;

  userValidMessage: string = "";

  //params for pagingFormatter to use when navigate to page

  params;

  @ViewChild(AlertModal) alert;

  claimsDeleted: number = 0;

  @Input() communityId: string = null;

  url = null;

  constructor(private _claimService: ClaimsService, private route: ActivatedRoute, private _router: Router, private location: Location,

              private seoService: SEOService, private indexInfoService:IndexInfoService) {

  }

  ngOnInit() {

    this.route.data

      .subscribe((data: { envSpecific: EnvProperties }) => {

        this.properties = data.envSpecific;

        this.url = data.envSpecific.baseLink + this._router.url;

        this.indexInfoService.getLastIndexDate(this.properties).subscribe(res => {

          this.lastIndexDate = res;

        });

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

          this.seoService.createLinkForCanonicalURL(this.properties.baseLink + this._router.url, false);

          if (this.myClaims) {

            this.fetchBy = "User";

            this.fetchId = Session.getUserEmail();

          } else {

            this.fetchBy = (this.fetchBy) ? this.fetchBy : params['fetchBy'];

            this.fetchBy = (this.types.indexOf(this.fetchBy) != -1) ? this.fetchBy : 'All';

            this.fetchId = (this.fetchId) ? this.fetchId : params['fetchId'];

            this.fetchId = this.fetchId ? this.fetchId : '';

          }

          let page = (params['page'] === undefined) ? 1 : +params['page'];

          let size = (params['size'] === undefined) ? 10 : +params['size'];

          this.keyword = (params['keyword'] ? params['keyword'] : "");

          this.inputkeyword = this.keyword;

          this.page = (page <= 0) ? 1 : page;

          this.size = (size <= 0) ? 10 : size;

          this.entityTypes = [];//(params['types']?params['types']:[]);

          this.setTypes(params['types']); // check the appropriate checkboxes

          this.setSortby(params['sort']);

          this.getClaims();

          this.searchTermStream

            .pipe(debounceTime(300),distinctUntilChanged())

            .subscribe((term: string) => {

              this.keyword = term;

              this.page = 1;

              this.goTo();

            });

        });

      });

  }

  ngOnDestroy() {

    this.sub.unsubscribe();

    //this.searchTermStreamSub.unsubscribe();

  }

  getClaims() {

    if (!Session.isLoggedIn()) {

      this.userValidMessage = "User session has expired. Please login again.";

      this._router.navigate(['/user-info'], {

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      this.selected = [];

      let types = '';

      this.showErrorMessage = false;

      this.showForbiddenMessage = false;

      for (let type of this.entityTypes) {

        types += (types.length > 0 ? '&' : '') + "types=" + type;

      }

      if (this.fetchBy == "Project") {

        this._claimService.getClaimsByProject(this.size, this.page, this.fetchId, this.keyword, this.sortby, this.descending, types, this.properties.claimsAPIURL).subscribe(

          data => {

            this.manageAPIData(data);

          },

          err => {

            this.handleErrors(err);

            DisplayClaimsComponent.handleError("Error getting claims for project with id: " + this.fetchId, err);

          }

        );

      } else if (this.fetchBy == "User") {

        this._claimService.getClaimsByUser(this.size, this.page, this.fetchId, this.keyword, this.sortby, this.descending, types, this.properties.claimsAPIURL).subscribe(

          data => {

            this.manageAPIData(data);

          },

          err => {

            this.handleErrors(err);

            DisplayClaimsComponent.handleError("Error getting claims for user with id: " + this.fetchId, err);

          }

        );

      } else if (this.fetchBy == "Result") {

        this._claimService.getClaimsByResult(this.size, this.page, this.fetchId, this.keyword, this.sortby, this.descending, types, this.properties.claimsAPIURL).subscribe(

          data => {

            this.manageAPIData(data);

          },

          err => {

            this.handleErrors(err);

            DisplayClaimsComponent.handleError("Error getting claims for entity with id: " + this.fetchId, err);

          }

        );

      } else if (this.fetchBy == "Context") {

        this._claimService.getClaimsBycontext(this.size, this.page, this.fetchId, this.keyword, this.sortby, this.descending, types, this.properties.claimsAPIURL).subscribe(

          data => {

            this.manageAPIData(data);

          },

          err => {

            this.handleErrors(err);

            DisplayClaimsComponent.handleError("Error getting claims for context with id: " + this.fetchId, err);

          }

        );

      } else {

        this._claimService.getClaims(this.size, this.page, this.keyword, this.sortby, this.descending, types, this.properties.claimsAPIURL).subscribe(

          data => {

            this.manageAPIData(data);

          },

          err => {

            this.handleErrors(err);

            DisplayClaimsComponent.handleError("Error getting claims", err);

          }

        );

      }

    }

  }

  manageAPIData(data) {

    // let d = new Date();

    // let dateTomillis = d.getTime();

    // let millis24h: number = 24 * 3600000;

    // if(this.showLatestClaims && this.recentClaims.length == 0){

    //   this.recentClaims = [];

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

    //     var claimDate = new Date(data.data[i].date);

    //     var claimDateToMillis = claimDate.getTime()

    //     // console.log("Claim Date is:"+claimDateToMillis + " "+(dateTomillis - claimDateToMillis));

    //     if((dateTomillis - claimDateToMillis)<millis24h){

    //       // console.log("Claim in:"+  " "+(dateTomillis - claimDateToMillis)+" < " +(millis24h));

    //       this.recentClaims.push(data.data[i]);

    //     }

    //   }

    // }

    this.claims = data.data;

    this.resultsNum = data.total;

  }

  handleErrors(err) {

    this.showErrorMessage = true;

    try {

      let error = err.json();

      let code = error.code;

      if (code == 403) {

        this.showErrorMessage = false;

        this.showForbiddenMessage = true;

      }

    } catch (e) {

      //console.log("Couldn't parse answer as json")

      DisplayClaimsComponent.handleError("Error parsing answer as json", e);

      this.showErrorMessage = true;

    }

  }

  private static handleError(message: string, error) {

    console.error("Dispaly Claims (component): " + message, error);

  }

  goTo(page: number = 1) {

    this.page = page;

    this.location.go(location.pathname, this.getParametersString());

    this.getClaims();

  }

/*

  getParameters() {

    var params = {}

    if (this.myClaims) {

      params = {

        page: this.page,

        size: this.size,

        types: this.entityTypes,

        keyword: this.keyword,

        sort: this.getSortby()

      };

    } else {

      params = {

        page: this.page,

        size: this.size,

        types: this.entityTypes,

        fetchBy: this.fetchBy,

        fetchId: this.fetchId,

        keyword: this.keyword,

        sort: this.getSortby()

      };

    }

    return params;

  }*/

  getParametersString() {

    let params = '';

    params += (this.page == 1 ? "" : (params.length > 0 ? '&' : '') + "page=" + this.page);

    params += (this.size == 10 ? "" : (params.length > 0 ? '&' : '') + "size=" + this.size);

    // params+=(this.validEntityTypes==''?"":(params.length>0?'&':'')+"types="+this.validEntityTypes);

    let types = "";

    for (let type of this.entityTypes) {

      types += (types.length > 0 ? ',' : '') + type;

    }

    params += (types.length > 0) ? "types=" + types : "";

    if (this.isAdmin) {

      params += (this.fetchBy == 'All' ? "" : (params.length > 0 ? '&' : '') + "fetchBy=" + this.fetchBy);

      params += (this.fetchId == '' ? "" : (params.length > 0 ? '&' : '') + "fetchId=" + this.fetchId);

    }

    params += (this.getSortby() == 'datedesc' ? "" : (params.length > 0 ? '&' : '') + "sort=" + this.getSortby());

    params += (this.keyword == '' ? "" : (params.length > 0 ? '&' : '') + "keyword=" + this.keyword);

    if (this.communityId != null) {

      params += "&communityId=" + this.communityId;

    }

    return params;

  }

  changeSize() {

    this.goTo();

  }

  changeOrderby(sortby: string) {

    if (sortby == this.sortby) {

      this.descending = !this.descending;

    } else {

      this.sortby = sortby;

      this.descending = false;

    }

    this.goTo();

  }

  setSortby(sortby: string) {

    if (!sortby || sortby == "datedesc") {

      this.descending = true;

      this.sortby = "date";

    } else if (sortby == "dateasc") {

      this.descending = false;

      this.sortby = "date";

    } else if (sortby == "userasc") {

      this.descending = false;

      this.sortby = "user";

    } else if (sortby == "userdesc") {

      this.descending = true;

      this.sortby = "user";

    }

    if (sortby == "sourceasc") {

      this.descending = false;

      this.sortby = "source";

    } else if (sortby == "sourcedesc") {

      this.descending = true;

      this.sortby = "source";

    } else if (sortby == "targetasc") {

      this.descending = false;

      this.sortby = "target";

    } else if (sortby == "targetdesc") {

      this.descending = true;

      this.sortby = "target";

    }

  }

  getSortby(): string {

    if (this.descending) {

      return this.sortby + "desc";

    } else {

      return this.sortby + "asc";

    }

  }

  changeType() {

    this.entityTypes = [];

    if (this.publicationCB) {

      this.entityTypes.push('publication');

    }

    if (this.datasetCB) {

      this.entityTypes.push('dataset');

    }

    if (this.softwareCB) {

      this.entityTypes.push('software');

    }

    if (this.otherCB) {

      this.entityTypes.push('other');

    }

    if (this.projectCB) {

      this.entityTypes.push('project');

    }

    if (this.contextCB) {

      this.entityTypes.push('context');

    }

    this.goTo();

  }

  setTypes(types: string) {

    if (!types) {

      return;

    }

    if (types.length > 0) {

      this.entityTypes = [];

      if (types.indexOf("publication") != -1) {

        this.publicationCB = true;

        this.entityTypes.push("publication");

      }

      if (types.indexOf("dataset") != -1) {

        this.datasetCB = true;

        this.entityTypes.push("dataset");

      }

      if (types.indexOf("software") != -1) {

        this.softwareCB = true;

        this.entityTypes.push("software");

      }

      if (types.indexOf("other") != -1) {

        this.otherCB = true;

        this.entityTypes.push("other");

      }

      if (types.indexOf("project") != -1) {

        this.projectCB = true;

        this.entityTypes.push("project");

      }

      if (types.indexOf("context") != -1) {

        this.contextCB = true;

        this.entityTypes.push("context");

      }

    }

    if (this.publicationCB && this.datasetCB && this.softwareCB && this.otherCB && this.contextCB && this.projectCB) {

      this.entityTypes = [];

    }

  }

  changekeyword() {

    if (this.inputkeyword.length >= 3 || this.inputkeyword.length == 0) {

      this.searchTermStream.next(this.inputkeyword);

    }

  }

  select(item: any, event) {

    this.deleteMessage = "";

    let value = event.currentTarget.checked;

    if (value) {

      this.selected.push(item);

    } else {

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

        let claim = this.selected[_i];

        if (claim['id'] == item.id) {

          this.selected.splice(_i, 1);

        }

      }

    }

  }

  selectAll(event) {

    let value = event.currentTarget.checked;

    if (value) {

      this.selected = [];

      for (let _i = 0; _i < this.claims.length; _i++) {

        let claim = this.claims[_i];

        this.selected.push(claim);

      }

      this.deleteMessage = "";

    } else {

      this.selected = [];

      this.deleteMessage = "";

    }

  }

  isSelected(id: string) {

    for (let _i = 0; _i < this.selected.length; _i++) {

      let claim = this.selected[_i];

      if (claim['id'] == id) {

        return true;

      }

    }

    return false;

  }

  confirmOpen() {

    if (this.selected.length <= 0) {

    } else {

      this.alert.cancelButton = true;

      this.alert.okButton = true;

      this.alert.alertTitle ="";// "Delete " + this.selected.length + " links(s)";

      this.alert.okButtonLeft = false;

      // this.alert.message = this.selected.length + " links will be deleted. Do you want to proceed? ";

      this.alert.okButtonText = "Delete";

      this.alert.cancelButtonText = "Cancel";

      this.alert.open();

    }

  }

  confirmClose() {

    this.delete();

  }

  delete() {

    this.deleteMessage = "";

    this.loading.open();

    this.claimsDeleted = 0;

    let ids = [];

    for (let i = 0; i < this.selected.length; i++) {

      let id = this.selected[i].id;

      ids.push(id);

    }

    this.batchDeleteById(ids);

  }

  batchDeleteById(ids: string[]) {

    if (!Session.isLoggedIn()) {

      this.userValidMessage = "User session has expired. Please login again.";

      this._router.navigate(['/user-info'], {

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      //console.warn("Deleting claim with ids:"+ids);

      this._claimService.deleteBulk(ids, this.properties.claimsAPIURL).subscribe(

        res => {

          //console.info('Delete response'+res.code );

          //console.warn("Deleted ids:"+ res.deletedIds);

          //console.warn("Not found ids:"+ res.notFoundIds);

          //remove this claim from the

          let newClaims = this.claims;

          for (let id of res.deletedIds) {

            for (let _i = 0; _i < this.claims.length; _i++) {

              let claim = this.claims[_i];

              if (claim['id'] == id) {

                newClaims.splice(_i, 1);

              }

            }

            for (let _i = 0; _i < this.selected.length; _i++) {

              let claim = this.selected[_i];

              if (claim['id'] == id) {

                this.selected.splice(_i, 1);

              }

            }

          }

          this.claims = newClaims;

          this.resultsNum = this.resultsNum - res.deletedIds.length;

          this.loading.close();

          if (res.deletedIds.length > 0) {

            this.deleteMessage = this.deleteMessage + '<div class = "uk-alert uk-alert-primary " >' + res.deletedIds.length + ' link(s) successfully deleted.</div>';

          }

          if (res.notFoundIds.length > 0) {

            this.deleteMessage = this.deleteMessage + '<div class = "uk-alert uk-alert-warning " >' + res.notFoundIds.length + ' link(s) couldn\'t be deleted.</div>';

          }

          let goToPage = this.page;

          if(this.totalPages(this.resultsNum)< this.page && this.page>0){

            goToPage = this.page -1;

          }

          this.goTo(goToPage);

        }, err => {

          //console.log(err);

          DisplayClaimsComponent.handleError("Error deleting claims with ids: " + ids, err);

          this.showErrorMessage = true;

          this.loading.close();

        });

    }

  }

  pageChange($event) {

    let page: number = +$event.value;

    this.goTo(page);

  }

  isClaimAvailable(claim:ClaimDBRecord): boolean {

  //claim.target.collectedFrom == "infrastruct_::openaire" &&

    let lastUpdateDate = new Date( (this.lastIndexDate != null)?this.lastIndexDate:this.properties.lastIndexUpdate);

    let lastUpdateDateStr = Dates.getDateToString(lastUpdateDate);

    let claimDate = new Date( claim.date);

    let claimDateStr = Dates.getDateToString(claimDate);

    if (claimDateStr< lastUpdateDateStr) {

      return true;

    } else {

      if(claim.target.collectedFrom != "infrastruct_::openaire" && claim.indexed){

      //  check if direct index succeded

      return true

      }

    }

    return false;

  }

  totalPages(totalResults: number): number {

    let totalPages:any = totalResults/(this.size);

    if(!(Number.isInteger(totalPages))) {

      totalPages = (parseInt(totalPages, 10) + 1);

    }

    return totalPages;

  }

}