connect/src/app/searchPages/communities/searchCommunities.component.ts

import {Component, ElementRef, ViewChild} from "@angular/core";
import {SearchUtilsClass} from "../../openaireLibrary/searchPages/searchUtils/searchUtils.class";
import {ErrorMessagesComponent} from "../../openaireLibrary/utils/errorMessages.component";
import {ErrorCodes} from "../../openaireLibrary/utils/properties/errorCodes";
import {EnvProperties} from "../../openaireLibrary/utils/properties/env-properties";
import {SearchPageComponent} from "../../openaireLibrary/searchPages/searchUtils/searchPage.component";
import {ActivatedRoute} from "@angular/router";
import {Filter, Value} from "../../openaireLibrary/searchPages/searchUtils/searchHelperClasses.class";
import {SearchFields} from "../../openaireLibrary/utils/properties/searchFields";
import {CommunitiesService} from "../../openaireLibrary/connect/communities/communities.service";
import {Session} from "../../openaireLibrary/login/utils/helper.class";
import {CommunityInfo} from "../../openaireLibrary/connect/community/communityInfo";
import {SearchResult} from "../../openaireLibrary/utils/entities/searchResult";
import {SubscribeService} from "../../openaireLibrary/utils/subscribe/subscribe.service";
import {Observable} from "rxjs";
import {StringUtils} from "../../openaireLibrary/utils/string-utils.class";
import {PiwikService} from "../../openaireLibrary/utils/piwik/piwik.service";

@Component({
  selector: 'search-communities',
  template: `
      <search-page pageTitle="OpenAIRE Connect|Search Communities"
                   formPlaceholderText="Search for Research Communities and Initiatives"
                   type="communities" entityType="community" [filters]="filters"
                   [results]="results" [searchUtils]="searchUtils"
                   [showResultCount]=true [baseUrl]="baseUrl"
                   (queryChange)="queryChanged($event)"
                   [disableForms]="disableForms"
                   [lastIndex]=false [sort]=true
                   searchFormClass="communitiesSearchForm">
      </search-page>
  `
})
export class SearchCommunitiesComponent {
  public piwiksub: any;
  private errorCodes: ErrorCodes;
  private errorMessages: ErrorMessagesComponent;
  public results: CommunityInfo[] = [];
  public totalResults: CommunityInfo[] = [];
  public sub: any; public subResults: any;
  public filters = [];
  public searchFields:SearchFields = new SearchFields();
  public searchUtils:SearchUtilsClass = new SearchUtilsClass();
  public disableForms: boolean = false;
  public baseUrl: string = null;
  public refineFields: string[] =  this.searchFields.COMMUNITIES_SEARCH_FIELDS;
  properties:EnvProperties;
  @ViewChild (SearchPageComponent) searchPage : SearchPageComponent ;

  constructor (private route: ActivatedRoute,
               private _communitiesService: CommunitiesService,
               private _subscribeService: SubscribeService,
               private element: ElementRef,
               private _piwikService: PiwikService) {
    this.errorCodes = new ErrorCodes();
    this.errorMessages = new ErrorMessagesComponent();
    this.searchUtils.status = this.errorCodes.LOADING;
  }

  public ngOnInit() {
    this.route.data
        .subscribe((data: { envSpecific: EnvProperties }) => {
          this.properties = data.envSpecific;
          this.baseUrl = data.envSpecific.searchLinkToCommunities;
          if(this.properties.enablePiwikTrack && (typeof document !== 'undefined')){
            this.piwiksub = this._piwikService.trackView(this.properties, "OpenAIRE Connect|Search Communities", this.properties.piwikSiteId).subscribe();
          }
        });
    this.sub =  this.route.queryParams.subscribe(params => {
      this.searchPage.resultsPerPage = 5;
      this.searchUtils.keyword = (params['keyword']?params['keyword']:'');
      this.searchUtils.page = (params['page'] === undefined) ? 1: + params['page'];
      this.searchUtils.sortBy = (params['sortBy'] === undefined)? '' : params['sortBy'];
      this.searchUtils.size = (params['size'] === undefined) ? this.searchPage.resultsPerPage: + params['size'];
      if(this.searchUtils.size != 5 && this.searchUtils.size != 10 && this.searchUtils.size != 20 && this.searchUtils.size != 50) {
        this.searchUtils.size = this.searchPage.resultsPerPage;
      }
      if(this.searchUtils.sortBy && this.searchUtils.sortBy != "creationdate,descending" && this.searchUtils.sortBy != "creationdate,ascending") {
        this.searchUtils.sortBy = "";
      }
      this.searchPage.refineFields = this.refineFields;
      let queryParams = this.searchPage.getQueryParamsFromUrl(params);
      this.filters = this.createFilters();

      this.initCommunities(queryParams);
    });
  }

  public ngOnDestroy() {
    if(this.sub){
      this.sub.unsubscribe();
    }
    if(this.subResults){
      this.subResults.unsubscribe();
    }
  }

  /**
   * Initialize communities from Communities APIs
   *
   * @param params
   */
  private initCommunities(params: Map<string, string>) {
    this.subResults = this._communitiesService.getCommunities(this.properties, this.properties.communitiesAPI).subscribe(
        data => {
          let observables: Observable<boolean>[] = [];
          for(let i = 0; i < data.length; i++) {
            this.totalResults[i] = data[i];
            // For Test do not delete them.
            //this.results[i].description = "EGI is a federated e-Infrastructure set up to provide advanced computing services for research and innovation.EGI is a federated e-Infrastructure set up to provide advanced computing services for research and innovation.EGI is a federated e-Infrastructure set up to provide advanced computing services for research and innovation."
            //this.results[i].date = new Date(new Date(2012, 0, 1).getTime() + Math.random() * (new Date().getTime() - new Date(2012, 0, 1).getTime()));
            observables.push(this._subscribeService.isSubscribedToCommunity(this.totalResults[i].communityId, Session.getUserEmail(), this.properties["adminToolsAPIURL"]));
            this.totalResults[i].isManager = this.isCommunityManager(this.results[i]);
          }
          Observable.forkJoin(observables).subscribe(
              res => {
                for(let i = 0; i < res.length; i++) {
                  this.totalResults[i].isSubscribed = res[i];
                }
                this._getResults(params, this.errorCodes.DONE);
              },
              err => {
                this.handleError('Error getting if user is subscribed', err);
                this._getResults(params, this.errorCodes.MISSING_CONTENT);
              }
          );
        },
        err => {
          //console.log(err);
          this.handleError('Error getting communities', err);
          this.searchUtils.status = this.errorMessages.getErrorCode(err.status);
          this.disableForms = false;
          this.scroll();
        }
    );
  }


  /**
   * Get all communities from Communities API and apply permission access validator,
   * keyword searching, filter, paging and sorting.
   *
   * @param params, status
   * @private
   */
  private _getResults(params: Map<string, string>, status: number){
    this.searchUtils.status = this.errorCodes.LOADING;
    this.disableForms = true;
    this.results = this.totalResults;
    this.searchUtils.totalResults = 0;
    this.applyParams(params, status);
  }

  /**
   * Return the communities in which user has permission to view or manage.
   */
  private showCommunities() {
    let ret: CommunityInfo[] = [];
    for(let result of this.results) {
      if (result.status == 'hidden') {
        continue;
      } else if (result.status == "manager") {
        let mail = Session.getUserEmail();
        if (mail == null) { // no user
          continue;
        } else if (Session.isCommunityCurator() || Session.isPortalAdministrator()) {
          ret.push(result);
        } else if (result.managers.indexOf(mail) != -1) {
          ret.push(result);
        }
        continue;
      }
      ret.push(result);
    }
    this.results = ret;
  }

  /**
   * Apply permission access validator,
   * keyword searching, filter, paging and sorting.
   *
   * @param params
   * @param status
   */
  public applyParams(params: Map<string, string>, status: number) {
    this.showCommunities();
    if(this.searchUtils.keyword && this.searchUtils.keyword != '') {
      this.searchForKeywords();
    }
    this.checkFilters(params);
    this.sort();
    this.searchUtils.totalResults = this.results.length;
    this.searchPage.checkSelectedFilters(this.filters);
    this.searchPage.updateBaseUrlWithParameters(this.filters);
    this.results = this.results.slice((this.searchUtils.page-1)*this.searchUtils.size, (this.searchUtils.page*this.searchUtils.size));
    this.searchUtils.status = status;
    if(this.searchUtils.totalResults == 0 ){
      this.searchUtils.status = this.errorCodes.NONE;
    }
    else if(this.searchUtils.totalResults == 1 ){
      this.searchPage.type = this.searchPage.entityType;
    }
    this.disableForms = false;
    if(this.searchUtils.status == status) {
      // Page out of limit!!!
      let totalPages:any = this.searchUtils.totalResults/(this.searchUtils.size);
      if(!(Number.isInteger(totalPages))) {
        totalPages = (parseInt(totalPages, 10) + 1);
      }
      if(totalPages < this.searchUtils.page) {
        this.searchUtils.totalResults = 0;
        this.searchUtils.status = this.errorCodes.OUT_OF_BOUND;
      }
    }
    this.scroll();
  }


  /**
   * Parse the given keywords into array and check if any of the requirements field of a community includes
   * one of the given words.
   */
  private searchForKeywords() {
      let ret: CommunityInfo[] = [];
      let keywords: string[] = this.searchUtils.keyword.split(/,(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/,-1);
      for(let i = 0; i < this.results.length; i++) {
          for(let keyword of keywords) {
              if (keyword != '' && (this.results[i].title.includes(keyword) || this.results[i].shortTitle.includes(keyword) ||
                  this.results[i].communityId.includes(keyword) || this.results[i].description.includes(keyword))) {
                  ret.push(this.results[i]);
                  break;
              }
          }
      }
      this.results = ret;
  }

  /**
   * Check the current results if they satisfy the values of each filter category and
   * update the number of possible results in each value.
   *
   * @param params
   */
  private checkFilters(params: Map<string, string>) {
    let typeResults: CommunityInfo[] = this.applyFilter('type', params);
    let statusResults: CommunityInfo[] = this.applyFilter('status' , params);
    let roleResults: CommunityInfo[] = this.applyFilter('role', params);
    this.resetFilterNumbers('status');
    this.updateFilterNumbers(typeResults.filter(value => {
      return roleResults.includes(value);
    }), 'status');
    this.resetFilterNumbers('type');
    this.updateFilterNumbers(statusResults.filter(value => {
      return roleResults.includes(value);
    }), 'type');
    this.resetFilterNumbers('role');
    this.updateFilterNumbers(statusResults.filter(value => {
      return typeResults.includes(value);
    }), 'role');
    this.results = statusResults.filter(value => {
      return typeResults.includes(value);
    })
    this.results = this.results.filter(value => {
      return roleResults.includes(value);
    });
  }

  /**
   * Apply filter with filterId and return the results
   *
   * @param filterId
   * @param params
   */
  private applyFilter(filterId: string, params: Map<string, string>): CommunityInfo[] {
    let results:CommunityInfo[] = [];
    let values: string[] = [];
    if(params.get(filterId) != undefined) {
      values = (StringUtils.URIDecode(params.get(filterId))).split(/,(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/,-1);
    }
    if(filterId == 'type') {
      for (let i = 0; i < this.results.length; i++) {
        if (values.length == 0) {
          results.push(this.results[i]);
        } else {
          for (let value of values) {
            if (this.results[i].type == value.replace(/["']/g, "")) {
              results.push(this.results[i]);
              break;
            }
          }
        }
      }
    }
    else if(filterId == 'status') {
      for (let i = 0; i < this.results.length; i++) {
        if (values.length == 0) {
          results.push(this.results[i]);
        } else {
          for (let value of values) {
            if (value.replace(/["']/g, "") == 'subscribed') {
              if (this.results[i].isSubscribed) {
                results.push(this.results[i]);
                break;
              }
            } else if (value.replace(/["']/g, "") == 'nonsubscribed') {
              if (!this.results[i].isSubscribed) {
                results.push(this.results[i]);
                break;
              }
            }
          }
        }
      }
    }
    else if(filterId == 'role') {
      for (let i = 0; i < this.results.length; i++) {
        if (values.length == 0) {
          results.push(this.results[i]);
        } else {
          for (let value of values) {
            if (value.replace(/["']/g, "") == 'manager') {
              if (this.results[i].isManager) {
                results.push(this.results[i]);
                break;
              }
            }
          }
        }
      }
    }
    return results;
  }

    /**
     * Reset the values of filter with id filterId with zero.
     *
     * @param filterId
     */
  private resetFilterNumbers(filterId: string) {
    for (let i = 0; i < this.filters.length; i++) {
      if(this.filters[i].filterId == filterId) {
        for (let j = 0; j < this.filters[i].values.length; j++) {
          this.filters[i].values[j].number = 0;
        }
        break;
      }
    }
  }

    /**
     * Update the values of filter with id filterId based on
     * results.
     *
     * @param results
     * @param filterId
     */
  private updateFilterNumbers(results: CommunityInfo[], filterId: string) {
    for(let k = 0; k < results.length; k++) {
      for (let i = 0; i < this.filters.length; i++) {
        if(this.filters[i].filterId == filterId) {
            if (this.filters[i].filterId == 'type') {
                for (let j = 0; j < this.filters[i].values.length; j++) {
                    if (results[k].type == this.filters[i].values[j].id) {
                        this.filters[i].values[j].number++;
                    }
                }
            }
            if (this.filters[i].filterId == 'status') {
                if (results[k].isSubscribed) {
                    this.filters[i].values[0].number++;
                } else {
                    this.filters[i].values[1].number++;
                }
            }
            if (this.filters[i].filterId == 'role') {
                if (results[k].isManager) {
                  this.filters[i].values[0].number++;
                }
            }
            break;
        }
      }
    }
  }

    /**
     * Sorting results based on sortBy.
     */
  private sort() {
    if(this.searchUtils.sortBy == '') {
      this.results.sort((left, right): number => {
        if (left.title > right.title) {
          return 1;
        } else if (left.title < right.title) {
          return -1;
        } else {
          return 0;
        }
      })
    } else if(this.searchUtils.sortBy == 'creationdate,descending') {
      this.results.sort((left, right): number => {
        if (!right.date || left.date > right.date) {
          return -1;
        } else if (!left.date || left.date < right.date) {
          return 1;
        } else {
          return 0;
        }
      })
    } else if(this.searchUtils.sortBy == 'creationdate,ascending') {
      this.results.sort((left, right): number => {
        if (!right.date || left.date > right.date) {
          return 1;
        } else if (!left.date || left.date < right.date) {
          return -1;
        } else {
          return 0;
        }
      })
    }
  }


  private isCommunityManager(community: CommunityInfo): boolean {
    return Session.isCommunityCurator() || community.managers.indexOf(Session.getUserEmail()) != -1;
  }

  public queryChanged($event) {
    this._getResults($event.params, this.errorCodes.DONE);
  }

    /**
     * Create Search Communities filters.
     *
     */
  private createFilters(): Filter[] {
    let filter_names=["Type"];
    let filter_ids=["type"];
    let searchFields = new SearchFields();
    let filter_original_ids = searchFields.COMMUNITIES_SEARCH_FIELDS;
    let value_names = [
      [ "Research Communities", "Research Initiatives" ]
    ];
    let value_original_ids=[
      ["community","ri"]
    ];
    if(Session.isLoggedIn()) {
      filter_names[1] = "Status";
      filter_ids[1] = "status";
      value_names[1] = [ "Subscribed", "Non-subscribed"];
      value_original_ids[1] = ["subscribed", "nonsubscribed"];
      filter_names[2] = "Role";
      filter_ids[2] = "role";
      value_names[2] = [ "Manager" ];
      value_original_ids[2] = ["manager"];
    }
    let filters: Filter[] = [];
    for(let  i =0 ; i < filter_names.length; i++){
      let values: Value[] = [];
      for(let j =0 ; j < value_names[i].length; j++){
        let value: Value = {name: value_names[i][j], id: value_original_ids[i][j], number:0, selected:false};
        values.push(value);
      }
      let filter: Filter = {title: filter_names[i], filterId: filter_ids[i], originalFilterId:  filter_original_ids[i], values : values, countSelectedValues:0, "filterOperator": 'or', valueIsExact: true };
      filters.push(filter);
    }
    return filters;
  }

  private handleError(message: string, error) {
    console.error('Communities Search Page: ' + message, error);
  }

  public scroll() {
    if (typeof document !== 'undefined') {
      this.element.nativeElement.scrollIntoView();
    }
  }
}