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

import {Component, Input, Output, EventEmitter} from '@angular/core';
import {ViewChild, ChangeDetectionStrategy}     from '@angular/core';
import {ViewEncapsulation}                      from '@angular/core';
import {ActivatedRoute, Router}                 from '@angular/router';
import {Location}                               from '@angular/common';
import {Title, Meta}                            from '@angular/platform-browser';

import {Observable}                             from 'rxjs/Observable';

import "rxjs/add/observable/zip";

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

import {ConfigurationService}                   from '../openaireLibrary/utils/configuration/configuration.service';
import {CommunitiesService}                     from '../openaireLibrary/connect/communities/communities.service';
import {SubscribeService}                       from '../openaireLibrary/utils/subscribe/subscribe.service';
import {CommunityInfo}                          from '../openaireLibrary/connect/community/communityInfo';

import {PiwikService}                           from '../openaireLibrary/utils/piwik/piwik.service';
import {Session}                                from '../openaireLibrary/login/utils/helper.class';
import {StringUtils}                            from '../openaireLibrary/utils/string-utils.class';

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

@Component({
    selector: 'communities',
    templateUrl: 'communities.component.html',
})

export class CommunitiesComponent {
  public piwiksub: any;
  public subfunders: any;

  public pageTitle = "OpenAIRE"

  public communitiesResults = null;
  public communitiesToShow = null;

  public researchCommunities = [];
  public researchInitiatives = [];
  public subscriberOfCommunities = [];
  public managerOfCommunities = [];

  // Message variables
  public status: number;
  public loading: boolean = true;
  public subscriberErrorMessage: string = "";
  public errorCodes: ErrorCodes;
  private errorMessages: ErrorMessagesComponent;

  properties:EnvProperties;
  public keyword:string="";
  public type:string="all";
  constructor (
      private route: ActivatedRoute,
      private _router: Router,
      private location: Location,
      private _meta: Meta,
      private _title: Title,
      private _piwikService:PiwikService,
      private _communitiesService:CommunitiesService,
      private _subscribeService: SubscribeService,
      private config: ConfigurationService) {

          var description = "OpenAIRE - Connect, Community Dashboard, research community";
          var title = "OpenAIRE - Connect";

          this._meta.updateTag({content:description},"name='description'");
          this._meta.updateTag({content:description},"property='og:description'");
          this._meta.updateTag({content:title},"property='og:title'");
          this._title.setTitle(title);

          this.errorCodes = new ErrorCodes();
          this.errorMessages = new ErrorMessagesComponent();
          this.status = this.errorCodes.LOADING;
  }

  public ngOnInit() {
    this.route.data
          .subscribe((data: { envSpecific: EnvProperties }) => {
            this.properties = data.envSpecific;
            var url = data.envSpecific.baseLink+this._router.url
            this._meta.updateTag({content:url},"property='og:url'");
            if(this.properties.enablePiwikTrack && (typeof document !== 'undefined')){
              this.piwiksub = this._piwikService.trackView(this.properties, "OpenAIRE Connect", this.properties.piwikSiteId).subscribe();
            }

            this.getCommunities();
          });
    }

    public getCommunities() {
      this.loading = true;
      this.status = this.errorCodes.LOADING;
      this.subscriberErrorMessage = "";

      this.researchCommunities = [];
      this.researchInitiatives = [];
      this.subscriberOfCommunities = [];
      this.managerOfCommunities = [];

      this._communitiesService.getCommunities(this.properties, this.properties.communitiesAPI).subscribe(
        communitiesResults => {
          //this.communitiesResults = communitiesResults;
          //this.communitiesToShow = this.communitiesResults.slice();
          //console.log(communitiesResults);
          this.sort(communitiesResults);

          var subscribedLoading = communitiesResults.length;
          var mail = Session.getUserEmail();
          communitiesResults.forEach((community, index) => {
            let showCommunity: boolean = true;
            let isManager: boolean = false;
            let isSubscriber: boolean = false;

            if(community['status'] == "hidden"){
              showCommunity = false;
            }else {
              if(mail == null && community['status'] == "manager"){ // no user
                showCommunity = false;
              }else if(Session.isCommunityCurator() || Session.isPortalAdministrator()){
                isManager = true;
              }else if(community.managers.indexOf(mail)!=-1){
                isManager = true;
              } else if(community['status'] == "manager") {
                showCommunity = false;
              }
            }

            if(showCommunity) {
              if(community.type == "community"){
                this.researchCommunities.push(community);
              } else if(community.type == "ri") {
                this.researchInitiatives.push(community);
              }

              if(isManager) {
                community.isManager = true;
                this.managerOfCommunities.push(community);
              }
            }

            this.status = this.errorCodes.DONE;

            if(mail != null && showCommunity) {
              this._subscribeService.isSubscribedToCommunity(community.communityId, mail, this.properties.adminToolsAPIURL).subscribe (
                res => {
                  isSubscriber = res;
                  if(isSubscriber) {
                    community.isSubscribed = true;
                    if(isManager) {
                      this.subscriberOfCommunities.push(community);
                    } else {
                      this.subscriberOfCommunities.unshift(community);
                    }
                  }

                  subscribedLoading--;
                  if(subscribedLoading == 0) {
                    this.loading = false;
                  }
                },
                error => {
                  // if(this.properties.environment == "development") {
                  //   this.subscriberErrorMessage = "Error fetching communities you are subscribed to";
                  // }
                  this.handleError("Error getting response if email: "+mail+" is subscribed to community with id: "+community.communityId, error);
                  subscribedLoading--;
                  if(subscribedLoading == 0) {
                    this.loading = false;
                  }
                });
            } else {
              subscribedLoading--;
              if(subscribedLoading == 0) {
                this.loading = false;
              }
            }
          });
        },
        error => {
          this.status = this.handleError("Error getting communities", error);
          this.loading = false;
        }
      );
    }

    private sort(results: CommunityInfo[]) {
      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 {
          if (left.title > right.title) {
            return 1;
          } else if (left.title < right.title) {
            return -1;
          } else {
            return 0;
          }
        }
      })
    }

    public quote(param: string): string {
      return StringUtils.quote(param);
    }

    public ngOnDestroy() {
      if(this.piwiksub){
        this.piwiksub.unsubscribe();
      }
    }

    private handleError(message: string, error): number {
      var code = "";
      if(!error.status) {
        var error =  error.json();
        code = error.code;
      } else {
        code = error.status;
      }

      console.error("Communities (component): "+message, error);

      return this.errorMessages.getErrorCode(code);
    }
}