D-Net

    iscommunityManager(url: string, manager:string){

      return this.http.get(url).map(res => <any> res.json()).map(res => this.parseCommunity(res)).map(community => community.managers.indexOf(manager)!=-1);

    }

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

import { Location } from '@angular/common';

import { Meta} from '../../sharedComponents/metaService';

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

@Component({

    selector: 'community-error',

    template: `

    <div id="tm-main" class=" uk-section  uk-margin-small-top tm-middle"   >

      <div uk-grid uk-grid>

       <div class="tm-main uk-width-1-1@s uk-width-1-1@m  uk-width-1-1@l uk-row-first ">

        <div class="uk-container">

            <h2>

                There is no community selected!

            </h2>

            <br>

            <p>

                If you are a community manager, click to manage from user menu.

            </p>

        </div>

      </div>

     </div>

  </div>

    `

})

export class CommunityErrorPageComponent {

    public page: string;

    constructor (private _location: Location, private _meta: Meta,private route: ActivatedRoute) {

        this._meta.setTitle("OpenAIRE | Error page");

        this.page = _location.path(true);

        //this.page = _router.url;

        //this.page = location.href;

    }

    ngOnInit() {

         this.route.queryParams.subscribe(data => {

            this.page = data['page'];

            if(!this.page){

              this.page = this._location.path(true);

            }

          });

    }

}

import { Injectable } from '@angular/core';

import { Router,CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot} from '@angular/router';

import {Observable}       from 'rxjs/Observable';

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

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

import {CommunityService} from '../community/community.service';

import { EnvironmentSpecificService} from '../../utils/properties/environment-specific.service';

import { mergeMap } from 'rxjs/operators';

@Injectable()

export class ConnectAdminLoginGuard implements CanActivate {

  constructor(private router: Router, private communityService: CommunityService, private propertiesService:EnvironmentSpecificService ) {}

  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {

    console.log("aaa");

    console.log(state.url);

    var user;

    var loggedIn = false;

    var isAdmin = false;

    var errorCode = ErrorCodes.NOT_LOGGIN;

    let community = (route.queryParams["communityId"]);

    if(Session.isLoggedIn()){

      loggedIn = true;

      if(!Session.isValidAndRemove()){

        loggedIn = false;

        errorCode = ErrorCodes.NOT_VALID;

        this.router.navigate(['/user-info'], { queryParams: { "errorCode": errorCode, "redirectUrl":  state.url } });

        return false;

      }else if(Session.isPortalAdministrator()) {

        console.log("is Admin");

        isAdmin = true;

        return true;

      }else {

// let first = Observable.timer(10,500).map(r => { return {source:1,value:r}; }).take(4);

 // let second = Observable.timer(10,500).map(r => { return {source:2,value:r}; }).take(4);

 // first.merge(second).subscribe(res => this.mergeStream.push(res));

        let obs = this.propertiesService.subscribeEnvironment().map(res=>res["communityAPI"]).mergeMap(url => {

          return this.communityService.iscommunityManager(url+community,Session.getUserEmail())});

        obs.filter(enabled => !enabled)

        .subscribe(() => this.router.navigate(['/user-info'], { queryParams: { "errorCode": errorCode, "redirectUrl":  state.url } }));

        return obs;

       }

    }else{

      errorCode =ErrorCodes.NOT_LOGGIN;

      this.router.navigate(['/user-info'], { queryParams: { "errorCode": errorCode, "redirectUrl":  state.url } });

      return false;

    }

    // if(!loggedIn){

    //   // this.guardHelper.redirect("/user-info",errorCode,state.url);

    //   this.router.navigate(['/user-info'], { queryParams: { "errorCode": errorCode, "redirectUrl":  state.url } });

    //

    //   return false;

    // }else{

    //   return true;

    // }

  }

  /*

  constructor(private route: ActivatedRoute,private router: Router, private config: ConfigurationService) {}

  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {

         let customRedirect = route.data['redirect'];

         let api  = route.data['api'];

         let community  = route.data['community']

         if(!community){

           community = (route.queryParams["communityId"])?route.queryParams["communityId"]:route.queryParams["community"];

         }

         if(community){

           let isEnabled = this.config.isPageEnabled(api, community,"/"+state.url.split("?")[0].substring(1));

           let redirect = !!customRedirect ? customRedirect : '/error';

           isEnabled.filter(enabled => !enabled)

           .subscribe(() => this.router.navigate([redirect], { queryParams: { "page": state.url } }));

           return isEnabled;

         }

         return true;

      }

  */

}

import { Injectable } from '@angular/core';

import {ActivatedRoute, Router,CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot} from '@angular/router';

import {Observable}       from 'rxjs/Observable';

import 'rxjs/add/operator/filter';

@Injectable()

export class IsCommunity implements CanActivate {

  constructor(private route: ActivatedRoute,private router: Router) {}

  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {

      let community = (route.queryParams["communityId"]);

        if(community && community!="undefined"){

        return true;

      }else{

        this.router.navigate(['errorcommunity']);

      }

      return false;

    }

  }

import { NgModule}            from '@angular/core';

import { CommonModule }        from '@angular/common';

import { FormsModule }         from '@angular/forms';

import {CommunityErrorPageComponent } from './communityErrorPage.component';

import {MetaModule} from '../../sharedComponents/metaService.module';

@NgModule({

  imports: [

    CommonModule, FormsModule, MetaModule

  ],

  providers:[],

  declarations: [

    CommunityErrorPageComponent

], exports:[CommunityErrorPageComponent]

})

export class CommunityErrorModule { }

  public subscribeEnvironment() {

      // Only want to do this once - if root page is revisited, it calls this again.

      if (this.envSpecific === null || this.envSpecific === undefined) {

        console.log('Loading env-properties.json');

        return this.http.get(this.propertiesUrl)

            .map((data) => data.json());

      }

      return Observable.of(this.envSpecific);

  }

  public static isPortalAdministrator():boolean {

  { path: '', component:  SearchComponent, resolve: { envSpecific: EnvironmentSpecificResolver  }, canActivate: [ ]},

  { path: 'search/find/publications', component: SearchPublicationsComponent , resolve: { envSpecific: EnvironmentSpecificResolver  }, canActivate: [ ] },