D-Net

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

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

import {ContextsService} from './service/contexts.service';

import {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';

import {Subscriber} from "rxjs";

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 = "";

  subscriptions = [];

  ngOnInit() {

    this.getCommunities();

  }

  ngOnDestroy() {

    this.subscriptions.forEach(subscription => {

      if (subscription instanceof Subscriber) {

        subscription.unsubscribe();

      }

    });

  }

  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.subscriptions.push(this._contextService.getPublicCommunitiesByState().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.subscriptions.push(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.subscriptions.push(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.subscriptions.push(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);

  }

}