D-Net

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

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

import {Subscriber} from 'rxjs';

import {ErrorCodes} from '../../openaireLibrary/utils/properties/errorCodes';

import {SearchUtilsClass} from '../../openaireLibrary/searchPages/searchUtils/searchUtils.class';

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

import {ManageCommunityContentProvidersService} from '../../services/manageContentProviders.service';

import {SearchCommunityDataprovidersService} from '../../openaireLibrary/connect/contentProviders/searchDataproviders.service';

import {RouterHelper} from '../../openaireLibrary/utils/routerHelper.class';

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

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

import {Criteria, SelectionCriteria} from '../../openaireLibrary/utils/entities/contentProvider';

import {properties} from "../../../environments/environment";

import {SearchInputComponent} from "../../openaireLibrary/sharedComponents/search-input/search-input.component";

import {FormBuilder, FormGroup} from "@angular/forms";

import {Option} from "../../openaireLibrary/sharedComponents/input/input.component";

import {CommunityService} from "../../openaireLibrary/connect/community/community.service";

import {CriteriaUtils} from "./criteria-utils";

declare var UIkit;

@Component({

  selector: 'remove-content-providers',

  templateUrl: './remove-content-providers.component.html'

})

export class RemoveContentProvidersComponent implements OnInit {

  public portal: string;

  public name: string;

  public routerHelper: RouterHelper = new RouterHelper();

  public contentProviderUrl = "https://" + ((properties.environment == "beta" || properties.environment == "development") ? "beta." : "") + "explore.openaire.eu" + properties.searchLinkToDataProvider;

  public previewCommunityContentProviders = [];

  public communitySearchUtils: SearchUtilsClass = new SearchUtilsClass();

  public errorCodes: ErrorCodes;

  @Input() public showLoading: boolean = true;

  @Input() public communityContentProviders = [];

  @Output() communityContentProvidersChanged = new EventEmitter();

  private properties: EnvProperties = properties;

  private subscriptions: any[] = [];

  private selectedCommunityContentProvider: any;

  @ViewChild('AlertModalDeleteCommunity') alertModalDeleteCommunity;

  /** Criteria */

  private fields = CriteriaUtils.fields;

  private verbs = CriteriaUtils.verbs;

  /** Paging */

  page: number = 1;

  resultsPerPage: number = properties.resultsPerPage;

  /** Search */

  @ViewChild('searchInputComponent') searchInputComponent: SearchInputComponent;

  filterForm: FormGroup;

  private searchText: RegExp = new RegExp('');

  public keyword: string = '';

  sortOptions: Option[] = [

    {label: "Name ", value: {sort: "name", descending: false}},

    {label: "Official Name ", value: {sort: "officialname", descending: false}}

  ];

  @Output() toggleView: EventEmitter<any> = new EventEmitter();

  @Input() public toggle: boolean = true;

  constructor(private route: ActivatedRoute, private _router: Router,

              private _fb: FormBuilder, private communityService: CommunityService,

              private _manageCommunityContentProvidersService: ManageCommunityContentProvidersService,

              private _searchCommunityContentProvidersService: SearchCommunityDataprovidersService) {

    this.errorCodes = new ErrorCodes();

    this.communitySearchUtils.status = this.errorCodes.LOADING;

  }

  ngOnInit() {

    this.communitySearchUtils.keyword = "";

    this.filterForm = this._fb.group({

      keyword: [''],

      // sort: this._fb.control(this.sortOptions[0].value)

    });

    this.subscriptions.push(this.filterForm.get('keyword').valueChanges.subscribe(value => {

      this.searchText = new RegExp(value, 'i');

      this.page = 1;

      this.applyFilters();

    }));

    // this.subscriptions.push(this.filterForm.get('sort').valueChanges.subscribe(value => {

    //   this.page = 1;

    //   this.sort();

    // }));

    this.subscriptions.push(this.communityService.getCommunityAsObservable().subscribe(community => {

      if (community) {

        this.portal = community.communityId;

        this.name = community.shortTitle;

        this.contentProviderUrl = "https://"

          + ((this.properties.environment == "beta" || this.properties.environment == "development") ? "beta." : "")

          + this.portal + ".openaire.eu" + this.properties.searchLinkToDataProvider;

        this.keyword = '';

        this._getCommunityContentProviders();

      }

    }));

  }

  public ngOnDestroy() {

    this.subscriptions.forEach(sub => {

      if (sub instanceof Subscriber) {

        sub.unsubscribe();

      }

    });

  }

  public getCriteriaLabel(selectionCriteria: SelectionCriteria): string {

    if (selectionCriteria && selectionCriteria.criteria.length > 0) {

      return (selectionCriteria.criteria.length === 1) ? '1 criterion' : (selectionCriteria.criteria.length + ' criteria')

    } else {

      return 'no criteria';

    }

  }

  // filterData(row: any, query: string) {

  //   let returnValue: boolean = false;

  //

  //   if(query) {

  //     for(var i=0; i <2; i++){

  //       var r= this.filterQuery(row[i], query);

  //       if(r) {

  //         returnValue = true;

  //         break;

  //       }

  //     }

  //

  //     if(!returnValue) {

  //       return false;

  //     }

  //   }

  //

  //   return true;

  // }

  //

  // filterQuery(data, query){

  //   if(data.toLowerCase().indexOf(query.toLowerCase()) > -1){

  //     return true;

  //   }else{

  //     return false;

  //   }

  // }

  public inCommunity(result: any): any {

    let found = false;

    for (let contentProvider of this.communityContentProviders) {

      if (contentProvider.opeaireId == result.id) {

        return true;

      }

    }

    return found;

  }

  totalPages(): number {

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

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

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

    }

    return totalPages;

  }

  getFiltersAsText(criteria: Criteria[]): string {

    let text = criteria.slice(0,3).map((criterion, index) => (index + 1) + ". " + criterion.constraint.map(constraint => {

      let field = this.fields.find(field => field.value === constraint.field).label;

      let matchCase = false;

      if(!constraint.verb.includes('_caseinsensitive')) {

        matchCase = true;

      }

      let verb = this.verbs.find(verb => verb.value === constraint.verb.replace("_caseinsensitive", "")).label;

      let value = '"' + constraint.value + '"' + (matchCase?" (Match case)":"");

      return field + " " + verb + " " + value;

    }).join(" <b>and</b> "));

    return text.join("<br>");

  }

  // goTo(page:number = 1){

  //     this.communitySearchUtils.page=page;

  //

  //     var table = $('#dpTable').DataTable();

  //     table.page( page - 1  ).draw( false );

  //

  //     var info = table.page.info();

  //     this.communitySearchUtils.totalResults = info.recordsDisplay;

  // }

  public confirmedDeleteContentProvider(data: any) {

    if (!Session.isLoggedIn()) {

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

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      this.subscriptions.push(this._manageCommunityContentProvidersService.removeContentProvider(this.properties, this.portal, this.selectedCommunityContentProvider.id).subscribe(

        data => {

          let index = this.communityContentProviders.indexOf(this.selectedCommunityContentProvider);

          this.communityContentProviders.splice(index, 1);

          this.applyFilters();

          UIkit.notification('Content Provider successfully removed!', {

            status: 'success',

            timeout: 6000,

            pos: 'bottom-right'

          });

          this.communityContentProvidersChanged.emit({

            value: this.communityContentProviders,

          });

          this.communitySearchUtils.totalResults--;

          this.communitySearchUtils.page = 1;

        },

        err => {

          this.handleError('An error has been occurred. Try again later!');

          console.error(err);

        }

      ));

    }

  }

  public removeContentProvider(communityContentProvider: any) {

    if (!Session.isLoggedIn()) {

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

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      this.selectedCommunityContentProvider = communityContentProvider;

      this.alertModalDeleteCommunity.cancelButton = true;

      this.alertModalDeleteCommunity.okButton = true;

      this.alertModalDeleteCommunity.alertTitle = "Remove content provider?";

      let title = "";

      if (communityContentProvider.name) {

        title = communityContentProvider.name;

      }

      if (communityContentProvider.name && communityContentProvider.acronym) {

        title += " (";

      }

      if (communityContentProvider.acronym) {

        title += communityContentProvider.acronym;

      }

      if (communityContentProvider.name && communityContentProvider.acronym) {

        title += ")";

      }

      this.alertModalDeleteCommunity.message = "Content Provider";

      if (title) {

        this.alertModalDeleteCommunity.message += " '" + title + "' ";

      }

      this.alertModalDeleteCommunity.message += "will be removed from your community. Are you sure?";

      this.alertModalDeleteCommunity.okButtonText = "Yes";

      this.alertModalDeleteCommunity.open();

    }

  }

  public _getCommunityContentProviders() {

    if (!Session.isLoggedIn()) {

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

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      this.communitySearchUtils.status = this.errorCodes.LOADING;

      this.communityContentProviders = [];

      this.communitySearchUtils.totalResults = 0;

      this.communitySearchUtils.page = 1;

      this.communitySearchUtils.keyword = "";

      this.subscriptions.push(this._searchCommunityContentProvidersService.searchDataproviders(this.properties, this.portal).subscribe(

        data => {

          this.communityContentProviders = data;

          this.previewCommunityContentProviders = this.communityContentProviders;

          // this.sort();

          this.communitySearchUtils.totalResults = data.length;

          this.communitySearchUtils.status = this.errorCodes.DONE;

          this.communityContentProvidersChanged.emit({

            value: this.communityContentProviders,

          });

          this.showLoading = false;

        },

        err => {

          console.error(err);

          //TODO check erros (service not available, bad request)

          if (err.status == '404') {

            this.communitySearchUtils.status = this.errorCodes.NOT_FOUND;

          } else if (err.status == '500') {

            this.communitySearchUtils.status = this.errorCodes.ERROR;

          } else {

            this.communitySearchUtils.status = this.errorCodes.NOT_AVAILABLE;

          }

          this.showLoading = false;

        }

      ));

    }

  }

  public updatePage($event) {

    this.page = $event.value;

  }

  addNew() {

    this.toggleView.emit(null);

  }

  public applyFilters() {

    this.previewCommunityContentProviders = this.communityContentProviders.filter(contentProvider => {

      return this.filterCommunityContentProviderByKeyword(contentProvider);

    });

    // check paging here!!!

    if (this.previewCommunityContentProviders.slice((this.page - 1) * this.resultsPerPage, this.page * this.resultsPerPage).length == 0) {

      this.page = 1;

    }

    // this.sort();

  }

  public filterCommunityContentProviderByKeyword(contentProvider): boolean {

    const textFlag = this.searchText.toString() === ''

      || (contentProvider.name + " " + contentProvider.officialname).match(this.searchText) != null;

    return textFlag;

  }

  private sort() {

    let sortOption: { sort: string, descending: boolean } = this.filterForm.get('sort').value;

    this.previewCommunityContentProviders.sort((left, right): number => {

      if (sortOption.sort == "name") {

        if (left.name > right.name) {

          return sortOption.descending ? -1 : 1;

        } else if (left.name < right.name) {

          return sortOption.descending ? 1 : -1;

        }

      } else if (sortOption.sort == "officialname") {

        if (left.officialname > right.officialname) {

          return sortOption.descending ? -1 : 1;

        } else if (left.officialname < right.officialname) {

          return sortOption.descending ? 1 : -1;

        }

      }

      return 0;

    });

  }

  public onSearchClose() {

    this.communitySearchUtils.keyword = this.filterForm.get('keyword').value;

  }

  public resetInput() {

    this.communitySearchUtils.keyword = null;

    this.searchInputComponent.reset()

  }

  handleError(message: string) {

    UIkit.notification(message, {

      status: 'danger',

      timeout: 6000,

      pos: 'bottom-right'

    });

  }

  goToCriteria(openaireId: string) {

    this._router.navigate([openaireId], {

      queryParams: {

        // community: this.portal,

        // provider: openaireId

      },

      relativeTo: this.route

    })

  }

}