openaire-library/claims/claim-utils/claimContextSearchForm.component.ts

import {Component, Input} from '@angular/core';
import {Router} from '@angular/router';
import {ContextsService} from './service/contexts.service';
import {ClaimContext, ClaimEntity} from './claimHelper.class';
import {Session} from '../../login/utils/helper.class';
import {LoginErrorCodes} from '../../login/utils/guardHelper.class';
import {EnvProperties} from '../../utils/properties/env-properties';

declare var UIkit: any;

@Component({
  selector: 'claim-contexts-search-form',
  templateUrl: 'claimContextSearchForm.component.html'

})
export class ClaimContextSearchFormComponent {
  @Input() public results:ClaimEntity[];
  @Input() public sources;
  @Input() public properties: EnvProperties;
  @Input() communityId: string = null;
  @Input() public inlineClaim: boolean = false;
  @Input() basketLimit;

  public selectedCommunityId: string = "0";
  public selectedCategoryId: string = "0";
  public query = '';
  public communities: any;
  public selectedCommunityLabel: string = "Community:";

  public categories: any = [];
  public concepts = [];
  public conceptsClass = [];
  public conceptsClassDisplay = [];
  public conceptsCategoryLoading = [];
  public warningMessage = "";
  public infoMessage = "";
  public loading: boolean = false;
  public error: boolean = false;
  @Input() localStoragePrefix: string = "";

  keyword = "";

  ngOnInit() {
    this.getCommunities();
  }

  constructor(private _contextService: ContextsService, private router: Router) {

  }

  getCommunityClass(community) {
    let addclass = "";
    if (this.isSelected(community.id)) {
      addclass += " contextlabelSelected ";
    } else {
      addclass += " contextlabelNotSelected ";
    }
    if (this.keyword.length > 0) {
      if (community.label.toLowerCase().indexOf(this.keyword.toLowerCase()) == -1) {
        addclass += " fadeOut "
      }
    }
    return addclass + 'uk-label';
  }

  select(community) {
    this.selectedCommunityId = community.id;
    this.selectedCommunityLabel = community.label;
    this.getCategories();
    if (this.isSelected(community.id)) {

    } else {
      this.addNewContext(community.label, null, {'id': community.id, 'label': community.label});
    }
  }

  isSelected(id): boolean {
    for (let _i = 0; _i < this.results.length; _i++) {
      let item = this.results[_i];
      if (item.id == id) {
        return true;
        // this.warningMessage = "Concept already in selected list";
      }
    }
    return false;
  }

  addNewContext(community, category, concept, notify = true) {
    // if (this.results.length > 50) {
    //   UIkit.notification({
    //     message: 'Your basket exceeds the number of allowed concepts (50)',
    //     status: 'warning',
    //     timeout: 1500,
    //     pos: 'top-center'
    //   });
    //   return;
    // }
    const entity: ClaimEntity = new ClaimEntity() ;
    entity.type = "community";

    entity.context = {community: community, category: category, concept: concept};
    entity.id = entity.context.concept.id;
    this.warningMessage = "";
    if (!this.isSelected(entity.id)) {
      this.results.push(entity);
      localStorage.setItem(this.localStoragePrefix, JSON.stringify(this.results));
    }

  }

  getCommunities() {
    if (!Session.isLoggedIn()) {
      this.saveStateAndRedirectLogin();

    } else {
      this.loading = true;
      this._contextService.getPublicCommunities(this.properties.contextsAPI).subscribe(
        data => {
          this.communities = data;
          if (this.communities.length > 0) {
            this.communities.sort((n1, n2) => n1.label > n2.label);
          }
          this.loading = false;
          if (this.communityId != null) {
            //preselect community
            this.selectedCommunityId = this.communityId;
            for (let i = 0; i < this.communities.length; i++) {
              if (this.communities[i].id == this.selectedCommunityId) {
                this.selectedCommunityLabel = this.communities[i].label;
                break;
              }
            }
            this.addNewContext(this.selectedCommunityLabel, null, {
              'id': this.selectedCommunityId,
              'label': this.selectedCommunityLabel
            }, false)

          }
        },
        err => {
          //console.log(err);
          ClaimContextSearchFormComponent.handleError("Error getting communities", err);
          this.loading = false;
          this.error = true;
        }
      );
    }
  }

  getCategories() {
    this.loading = true;
    // this.categories=[];
    if (this.selectedCommunityId != '0') {
      if (!Session.isLoggedIn()) {
        this.saveStateAndRedirectLogin();


      } else {
        if (this.categories[this.selectedCommunityId]) {
          this.loading = false;
          return;
        }
        this._contextService.getCategories(this.selectedCommunityId, this.properties.contextsAPI).subscribe(
          data => {

            this.categories[this.selectedCommunityId] = data;
            this.concepts = [];
            if (this.query !== "") {
              const event = {value: ""};
              event.value = this.query;
            }
            this.loading = false;
          },
          err => {
            //console.log(err);
            ClaimContextSearchFormComponent.handleError("Error getting categories for community with id: " + this.selectedCommunityId, err);
            this.loading = false;
          }
        );
      }
    }
  }
/*
  getConcepts() {
    this.loading = true;
    if (this.selectedCategoryId != '0') {
      if (!Session.isLoggedIn()) {
        this.saveStateAndRedirectLogin();
      } else {
        this.concepts = [];

        this._contextService.getConcepts(this.selectedCategoryId, "", true, this.properties.contextsAPI).subscribe(
          data => {

            this.concepts = data;
            for (var i = 0; i < data.length; i++) {
              if (data[i].hasSubConcept == true) {
                this.getSubConcepts(data[i].id);
              }
            }
            this.addCommunityInConcepts();
            if (this.query !== "") {
              var event = {value: ""};
              event.value = this.query;
              //  this.filter(event);
            }
            this.loading = false;
          },
          err => {
            //console.log(err);
            this.handleError("Error getting concepts for category with id: " + this.selectedCategoryId, err);
            this.loading = false;
          }
        );
      }
    } else {
      this.concepts = [];
      this.loading = false;
    }
  }*/
/*
  getSubConcepts(conceptId) {
    this.loading = true;
    if (this.selectedCategoryId != '0') {
      if (!Session.isLoggedIn()) {
        this.saveStateAndRedirectLogin();
      } else {
        this._contextService.getSubConcepts(conceptId, "", true, this.properties.contextsAPI).subscribe(
          data => {
            for (var i = 0; i < data.length; i++) {
              this.concepts.push(data[i]);
            }

            if (this.query !== "") {
              var event = {value: ""};
              event.value = this.query;
              //  this.filter(event);
            }
            this.loading = false;
          },
          err => {
            //console.log(err);
            this.handleError("Error getting subconcepts for concept with id: " + conceptId, err);
            this.loading = false;
          }
        );
      }
    } else {
      this.concepts = [];
      this.loading = false;
    }
  }*/

  displaySubcategory(id) {
    if (this.conceptsClassDisplay[id] != null) {
      this.conceptsClassDisplay[id] = !this.conceptsClassDisplay[id];

    } else {
      this.conceptsClassDisplay[id] = true;
    }
  }

  browseConcepts(categoryId) {
    if (!Session.isLoggedIn()) {
      this.saveStateAndRedirectLogin();
    } else {
      if (this.conceptsClass[categoryId] != null) {
        this.conceptsClassDisplay[categoryId] = !this.conceptsClassDisplay[categoryId];
        return;
      } else {
        this.conceptsClassDisplay[categoryId] = true;
      }
      this.conceptsClass[categoryId] = [];
      this.conceptsCategoryLoading[categoryId] = true;
      this._contextService.getConcepts(categoryId, "", false, this.properties.contextsAPI).subscribe(
        data => {
          // var concepts = data;
          this.conceptsClass[categoryId] = [];
          for (let i = 0; i < data.length; i++) {
            if (data[i].hasSubConcept == true) {
              this.browseSubConcepts(categoryId, data[i].id);
            } else {
              this.conceptsClass[categoryId].push(data[i]);
            }
          }
          this.conceptsCategoryLoading[categoryId] = false;
        },
        err => {
          //console.log(err);
          ClaimContextSearchFormComponent.handleError("Error getting concepts for category with id: " + this.selectedCategoryId, err);
          this.conceptsCategoryLoading[categoryId] = false;
        }
      );
    }

  }

  browseSubConcepts(categoryId, conceptId) {

    this.conceptsCategoryLoading[categoryId] = true;
    this._contextService.getSubConcepts(conceptId, "", false, this.properties.contextsAPI).subscribe(
      data => {
        const concepts = data[0];
        this.conceptsClass[categoryId].push(concepts);
        this.conceptsCategoryLoading[categoryId] = false;
      },
      err => {
        //console.log(err);
        ClaimContextSearchFormComponent.handleError("Error getting subconcepts for concept with id: " + conceptId, err);
        this.conceptsCategoryLoading[categoryId] = false;
      }
    );


  }

  // communityChanged(){
  //   this.warningMessage = "";
  //   this.infoMessage = "";
  //   for(var i = 0; i< this.communities.length; i++){
  //     if(this.communities[i].id==this.selectedCommunityId){
  //       this.selectedCommunityLabel = this.communities[i].label;
  //       break;
  //     }
  //   }
  //   this.selectedCategoryId = "0";
  //   this.selectedCategoryLabel="Select Category:";
  //   if(this.selectedCommunityId != "0"){
  //     this.getCategories();
  //   }
  // }
  // categoryChanged(){
  //   this.warningMessage = "";
  //   this.infoMessage = "";
  //   for(var i = 0; i< this.categories.length; i++){
  //     if(this.categories[i].id==this.selectedCategoryId){
  //       this.selectedCategoryLabel = this.categories[i].label;
  //       break;
  //     }
  //   }
  //     this.getConcepts();
  // }
/*  addCommunityInConcepts() {
    this.concepts.push({"id": this.selectedCommunityId, "label": this.selectedCommunityLabel});
    // if(this.autocomplete){
    //   this.autocomplete.updateList(this.concepts);
    // }
  }*/

  saveStateAndRedirectLogin() {
    //  if(this.projects != null){
    //   localStorage.setItem(this.localStoragePrefix + "projects", JSON.stringify(this.projects));
    // }
    // localStorage.setItem(this.localStoragePrefix + "contexts", JSON.stringify(this.selectedList));
    if (this.results != null) {
      localStorage.setItem(this.localStoragePrefix + "results", JSON.stringify(this.results));
    }
    if (this.sources != null) {
      localStorage.setItem(this.localStoragePrefix + "sources", JSON.stringify(this.sources));
    }

    this.router.navigate(['/user-info'], {
      queryParams: {
        "errorCode": LoginErrorCodes.NOT_VALID,
        "redirectUrl": this.router.url
      }
    });
  }

  private static handleError(message: string, error) {
    console.error("Claim context search form (component): " + message, error);
  }
}