D-Net

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

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

import {SearchResult}     from '../../openaireLibrary/utils/entities/searchResult';

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

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

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

import {SearchDataprovidersService} from '../../openaireLibrary/services/searchDataproviders.service';

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

import {StringUtils} from '../../openaireLibrary/utils/string-utils.class';

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

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

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

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

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

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

import {Subscriber} from "rxjs";

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

import {ResultPreview} from "../../openaireLibrary/utils/result-preview/result-preview";

declare var UIkit;

@Component({

    selector: 'add-content-providers',

    templateUrl: './add-content-providers.component.html',

})

export class AddContentProvidersComponent implements OnInit {

  private subscriptions: any[] = [];

  public subResults: any;

  private community: string = '';

  public routerHelper: RouterHelper = new RouterHelper();

  public properties: EnvProperties = properties;

  public errorCodes: ErrorCodes;

  public openaireSearchUtils: SearchUtilsClass = new SearchUtilsClass();

  @Output() communityContentProvidersChanged = new EventEmitter();

  @Input() communityContentProviders = [];

  public openaireContentProviders = [];

  public queryParameters: string = "";

  // public pagingLimit: number = properties.pagingLimit;

  public resultsPerPage: number = properties.resultsPerPage;

  filterForm: FormGroup;

  @ViewChild('searchInputComponent') searchInputComponent: SearchInputComponent;

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

  public body: string = "Send from page";

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

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

              private _searchContentProvidersService: SearchDataprovidersService,

              private _manageCommunityContentProvidersService: ManageCommunityContentProvidersService,

              private _fb: FormBuilder) {

    this.errorCodes = new ErrorCodes();

    this.openaireSearchUtils.status = this.errorCodes.LOADING;

  }

  ngOnInit() {

    this.subscriptions.push(this.route.params.subscribe(params => {

      this.openaireSearchUtils.status = this.errorCodes.LOADING;

      this.community = params['community'];

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

      //   + this.community + ".openaire.eu" + this.properties.searchLinkToDataProvider;

      this._getOpenaireContentProviders("", 1, this.resultsPerPage);

      this.body = "[Please write your message here]";

      this.body = StringUtils.URIEncode(this.body);

    }));

    this.openaireSearchUtils.keyword = "";

    this.filterForm = this._fb.group({

      keyword: [''],

    });

    this.subscriptions.push(this.filterForm.get('keyword').valueChanges

      .pipe(debounceTime(1000), distinctUntilChanged())

      .subscribe(value => {

        this.keywordChanged(value);

      })

    );

  }

  public ngOnDestroy() {

    this.subscriptions.forEach(sub => {

      if (sub instanceof Subscriber) {

        sub.unsubscribe();

      }

    });

    if(this.subResults){

      this.subResults.unsubscribe();

    }

  }

  public addContentProvider(contenProvider: SearchResult) {

    if (!Session.isLoggedIn()) {

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

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      this.subscriptions.push(this._manageCommunityContentProvidersService.addContentProvider(this.properties, this.community, contenProvider).subscribe(

        data => {

          this.communityContentProviders.push(data);

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

            status: 'success',

            timeout: 6000,

            pos: 'bottom-right'

          });

          this.communityContentProvidersChanged.emit({

            value: this.communityContentProviders,

          });

        },

        err => {

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

          console.error(err.status);

        }

      ));

    }

  }

  public removeContentProvider(contentProvider) {

    if (!Session.isLoggedIn()) {

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

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      let communityContentProvider = this.getCommunityContentProvider(contentProvider);

      let contentProviderId: string = communityContentProvider['id'];

      this.subscriptions.push(this._manageCommunityContentProvidersService.removeContentProvider(this.properties, this.community, contentProviderId).subscribe(

        data => {

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

          this.communityContentProviders.splice(index, 1);

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

            status: 'success',

            timeout: 6000,

            pos: 'bottom-right'

          });

          this.communityContentProvidersChanged.emit({

            value: this.communityContentProviders,

          });

        },

        err => {

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

          console.error(err);

        }

      ));

    }

  }

  public getCommunityContentProvider(contentProvider: any): string {

    let index: number = 0;

    for (let communityContentProvider of this.communityContentProviders) {

      if (communityContentProvider.openaireId == contentProvider.id) {

        return communityContentProvider;

      }

      index++;

    }

    return "";

  }

  public getResultPreview(result: SearchResult): ResultPreview {

    return ResultPreview.searchResultConvert(result, "dataprovider");

  }

  // public inCommunity(contentProvider: any): any {

  //   for(let communityContentProvider of this.communityContentProviders) {

  //     if(communityContentProvider.openaireId == contentProvider.id) {

  //       return true;

  //     }

  //   }

  //

  //   if(this.undo[contentProvider.id]) {

  //     return true;

  //   }

  //   return false;

  // }

  private _getOpenaireContentProviders(parameters: string, page: number, size: number) {

    if (!Session.isLoggedIn()) {

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

        queryParams: {

          "errorCode": LoginErrorCodes.NOT_VALID,

          "redirectUrl": this._router.url

        }

      });

    } else {

      // if (page > this.pagingLimit) {

      //   size = 0;

      // }

      if (this.openaireSearchUtils.status == this.errorCodes.LOADING) {

        this.openaireSearchUtils.status = this.errorCodes.LOADING;

        this.openaireContentProviders = [];

        this.openaireSearchUtils.totalResults = 0;

        if(this.subResults){

          this.subResults.unsubscribe();

        }

        this.subResults = this._searchContentProvidersService.searchDataproviders(parameters, null, page, size, [], this.properties).subscribe(

          data => {

            this.openaireSearchUtils.totalResults = data[0];

            this.openaireContentProviders = data[1];

            //this.searchPage.checkSelectedFilters(this.filters);

            this.openaireSearchUtils.status = this.errorCodes.DONE;

            if (this.openaireSearchUtils.totalResults == 0) {

              this.openaireSearchUtils.status = this.errorCodes.NONE;

            }

            // if (this.openaireSearchUtils.status == this.errorCodes.DONE) {

            //   // Page out of limit!!!

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

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

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

            //   }

            //   if (totalPages < page) {

            //     this.openaireSearchUtils.totalResults = 0;

            //     this.openaireSearchUtils.status = this.errorCodes.OUT_OF_BOUND;

            //   }

            // }

          },

          err => {

            console.error(err);

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

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

              this.openaireSearchUtils.status = this.errorCodes.NOT_FOUND;

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

              this.openaireSearchUtils.status = this.errorCodes.ERROR;

            } else {

              this.openaireSearchUtils.status = this.errorCodes.NOT_AVAILABLE;

            }

          }

        );

      }

    }

  }

  totalPages(): number {

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

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

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

    }

    return totalPages;

  }

  keywordChanged(keyword) {

    this.openaireSearchUtils.keyword = keyword;

    this.buildQueryParameters();

    this.goTo(1);

  }

  buildQueryParameters() {

    this.queryParameters = "";

    if (this.openaireSearchUtils.keyword) {

      this.queryParameters = "q=" + StringUtils.URIEncode(this.openaireSearchUtils.keyword);

    }

  }

  goTo(page: number = 1) {

    this.openaireSearchUtils.page = page;

    this.openaireSearchUtils.status = this.errorCodes.LOADING;

    this._getOpenaireContentProviders(this.queryParameters, page, this.resultsPerPage);

  }

  back() {

    this.toggleView.emit(null);

  }

  public onSearchClose() {

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

  }

  public resetInput() {

    this.openaireSearchUtils.keyword = null;

    this.searchInputComponent.reset()

  }

  handleError(message: string) {

    UIkit.notification(message, {

      status: 'danger',

      timeout: 6000,

      pos: 'bottom-right'

    });

  }

}