[Trunk|Library]: CanLoad does not work in connect guards, maybe it works in angular 6

git-svn-id: https://svn.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-services-library/trunk/ng-openaire-library/src/app@54912 d315682c-612b-4755-9ff5-7f18f6832af3

connect/communities/communities.service.ts

@@ -1,7 +1,5 @@
 import {Injectable} from '@angular/core';
-import {Http, Response}             from '@angular/http';
+import {Http} from '@angular/http';
-import {Headers, RequestOptions}    from '@angular/http';
-import {Observable}                 from 'rxjs/Rx';
 
 import {CommunityInfo} from '../community/communityInfo';
 import {EnvProperties} from '../../utils/properties/env-properties';
@@ -18,67 +16,13 @@ export class CommunitiesService {
     }
 
     parseCommunities(data: any): CommunityInfo[] {
-        let communities: CommunityInfo[] = [];
+        const communities: CommunityInfo[] = [];
 
-        let length = Array.isArray(data) ? data.length :1;
+        const length = Array.isArray(data) ? data.length : 1;
 
         for (let i = 0; i < length; i++) {
-            let resData = Array.isArray(data) ? data[i] : data;
+            const resData = Array.isArray(data) ? data[i] : data;
-
+            const result: CommunityInfo = new CommunityInfo();
-            var result: CommunityInfo = new CommunityInfo();
-            //TODO @Sofia remove this if/else
-            // if there is case to be array do with resData what you do with data (  let resData = Array.isArray(data) ? data[i] : data;)
-            //don;t repeat the same code
-            if(Array.isArray(resData)) {
-                result['title'] = resData[0].name;
-                result['shortTitle'] = resData[0].shortName;
-                result['communityId'] = resData[0].id;
-                result['queryId'] = resData[0].queryId;
-                result['logoUrl'] = resData[0].logoUrl;
-                result['description'] = resData[0].description;
-                result['date'] = resData[0].creationDate;
-                result['status'] = "all";
-                if(resData[0].hasOwnProperty('status')){
-                  result['status'] = resData[0].status;
-                  var status = ["all","hidden","manager"];
-                  if(status.indexOf(result['status']) ==-1){
-                    result['status'] = "hidden";
-                  }
-                }
-
-                if (resData[0].type != null) {
-                      result['type'] = resData[0].type;
-                }
-
-                if(resData[0].managers != null) {
-                    if(result['managers'] == undefined) {
-                      result['managers'] = new Array<string>();
-                    }
-
-                    let managers = resData[0].managers;
-                    let length = Array.isArray(managers) ? managers.length : 1;
-
-                    for(let i=0; i<length; i++) {
-                      let manager = Array.isArray(managers) ? managers[i] : managers;
-                      result.managers[i] = manager;
-                    }
-                }
-
-                if(resData[0].subjects != null) {
-                    if(result['subjects'] == undefined) {
-                      result['subjects'] = new Array<string>();
-                    }
-
-                    let subjects = resData[0].subjects;
-                    let length = Array.isArray(subjects) ? subjects.length : 1;
-
-                    for(let i=0; i<length; i++) {
-                      let subject = Array.isArray(subjects) ? subjects[i] : subjects;
-                      result.subjects[i] = subject;
-                    }
-                }
-
-            } else {
             result['title'] = resData.name;
             result['shortTitle'] = resData.shortName;
             result['communityId'] = resData.id;
@@ -86,12 +30,12 @@ export class CommunitiesService {
             result['logoUrl'] = resData.logoUrl;
             result['description'] = resData.description;
             result['date'] = resData.creationDate;
-                result['status'] = "all";
+            result['status'] = 'all';
             if (resData.hasOwnProperty('status')) {
                 result['status'] = resData.status;
-                  var status = ["all","hidden","manager"];
+                const status = ['all', 'hidden', 'manager'];
-                  if(status.indexOf(result['status']) ==-1){
+                if (status.indexOf(result['status']) === -1) {
-                    result['status'] = "hidden";
+                    result['status'] = 'hidden';
                 }
             }
             if (resData.type != null) {
@@ -99,38 +43,36 @@ export class CommunitiesService {
             }
 
             if (resData.managers != null) {
-                    if(result['managers'] == undefined) {
+                if (result['managers'] === undefined) {
                     result['managers'] = new Array<string>();
                 }
 
-                    let managers = resData.managers;
+                const managers = resData.managers;
-                    let length = Array.isArray(managers) ? managers.length : 1;
+                const lengthManagers = Array.isArray(managers) ? managers.length : 1;
 
-                    for(let i=0; i<length; i++) {
+                for (let j = 0; j < lengthManagers; j++) {
-                      let manager = Array.isArray(managers) ? managers[i] : managers;
+                    const manager = Array.isArray(managers) ? managers[j] : managers;
-                      result.managers[i] = manager;
+                    result.managers[j] = manager;
                 }
             }
 
             if (resData.subjects != null) {
-                    if(result['subjects'] == undefined) {
+                if (result['subjects'] === undefined) {
                     result['subjects'] = new Array<string>();
                 }
 
-                    let subjects = resData.subjects;
+                const subjects = resData.subjects;
-                    let length = Array.isArray(subjects) ? subjects.length : 1;
+                const lengthSubjects = Array.isArray(subjects) ? subjects.length : 1;
 
-                    for(let i=0; i<length; i++) {
+                for (let j = 0; j < lengthSubjects; j++) {
-                      let subject = Array.isArray(subjects) ? subjects[i] : subjects;
+                    const subject = Array.isArray(subjects) ? subjects[i] : subjects;
-                      result.subjects[i] = subject;
+                    result.subjects[j] = subject;
                 }
             }
-            }
+            if (result['type'] === 'community' || result['type'] === 'ri') {
-            if (result['type'] == 'community' || result['type'] == "ri") {
                 communities.push(result);
             }
         }
-
         return communities;
     }
 }

connect/communityGuard/connectAdminLoginGuard.guard.ts

@@ -12,47 +12,45 @@ import {Session} from '../../login/utils/helper.class';
 import {LoginErrorCodes} 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, CanLoad{
   constructor(private router: Router,
               private communityService: CommunityService,
-              private propertiesService:EnvironmentSpecificService,
+              private propertiesService: EnvironmentSpecificService) {}
-              private route: ActivatedRoute) {}
 
-  check(path: string): Observable<boolean> | boolean {
+  check(route: ActivatedRouteSnapshot, path: string): Observable<boolean> | boolean {
     let errorCode = LoginErrorCodes.NOT_LOGIN;
-    let community = this.route.queryParams["communityId"];
+    const community = route.queryParams['communityId'];
     if (Session.isLoggedIn()) {
       if (Session.isPortalAdministrator() || Session.isCommunityCurator()) {
         return true;
       } else {
-        let obs = this.propertiesService.subscribeEnvironment().map(res => res).mergeMap(properties => {
+        const obs = this.propertiesService.subscribeEnvironment().map(res => res).mergeMap(properties => {
-          return this.communityService.iscommunityManager(properties, properties["communityAPI"] + community, Session.getUserEmail())
+          return this.communityService.iscommunityManager(properties, properties['communityAPI'] + community, Session.getUserEmail());
         });
         obs.filter(enabled => !enabled)
             .subscribe(() => this.router.navigate(['/user-info'], {
               queryParams: {
-                "errorCode": errorCode,
+                'errorCode': errorCode,
-                "redirectUrl": path
+                'redirectUrl': path
               }
             }));
         return obs;
       }
     } else {
       errorCode = LoginErrorCodes.NOT_LOGIN;
-      this.router.navigate(['/user-info'], {queryParams: {"errorCode": errorCode, "redirectUrl": path}});
+      this.router.navigate(['/user-info'], {queryParams: {'errorCode': errorCode, 'redirectUrl': path}});
 
       return false;
     }
   }
 
   canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {
-    return this.check(state.url);
+    return this.check(route, state.url);
   }
 
   canLoad(route: Route): Observable<boolean> | Promise<boolean> | boolean {
-    return this.check('/' + route.path);
+    return this.check(null, '/' + route.path);
   }
 }

connect/communityGuard/connectRIGuard.guard.ts

@@ -16,41 +16,44 @@ import { EnvironmentSpecificService} from '../../utils/properties/environment-sp
 @Injectable()
 export class ConnectRIGuard implements  CanActivate, CanLoad {
 
-  constructor(private router: Router, private communityService: CommunityService, private propertiesService:EnvironmentSpecificService, private route:ActivatedRoute) {}
+  constructor(private router: Router,
+              private communityService: CommunityService,
+              private propertiesService: EnvironmentSpecificService) {
+  }
 
-  check(path: string) : Observable<boolean> | boolean {
+  check(route: ActivatedRouteSnapshot, path: string): Observable<boolean> | boolean {
     let errorCode = LoginErrorCodes.NOT_LOGIN;
-    let community = (this.route.queryParams["communityId"]);
+    const community = (route.queryParams['communityId']);
 
     if (Session.isLoggedIn()) {
       if (Session.isPortalAdministrator()) {
         return true;
       } else {
-        let obs = this.propertiesService.subscribeEnvironment().mergeMap(properties => {
+        const obs = this.propertiesService.subscribeEnvironment().mergeMap(properties => {
-          return this.communityService.iscommunityRI(properties, properties["communityAPI"] + community)
+          return this.communityService.iscommunityRI(properties, properties['communityAPI'] + community);
         });
         obs.filter(enabled => !enabled)
             .subscribe(() => this.router.navigate(['/user-info'], {
               queryParams: {
-                "errorCode": errorCode,
+                'errorCode': errorCode,
-                "redirectUrl": path
+                'redirectUrl': path
               }
             }));
         return obs;
       }
     } else {
       errorCode = LoginErrorCodes.NOT_LOGIN;
-      this.router.navigate(['/user-info'], { queryParams: { "errorCode": errorCode, "redirectUrl":  path } });
+      this.router.navigate(['/user-info'], {queryParams: {'errorCode': errorCode, 'redirectUrl': path}});
 
       return false;
     }
   }
 
   canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {
-    return this.check(state.url);
+    return this.check(route, state.url);
   }
 
   canLoad(route: Route): Observable<boolean> | Promise<boolean> | boolean {
-    return this.check('/' + route.path);
+    return this.check(null, '/' + route.path);
   }
 }

connect/communityGuard/connectSubscriber.guard.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core';
-import {Router, CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, ActivatedRoute} from '@angular/router';
+import {Router, CanActivate, ActivatedRouteSnapshot, RouterStateSnapshot, CanLoad, Route} from '@angular/router';
 import {Observable} from 'rxjs/Observable';
 import {Session} from '../../login/utils/helper.class';
 import {LoginErrorCodes} from '../../login/utils/guardHelper.class';
@@ -8,36 +8,42 @@ import { EnvironmentSpecificService} from '../../utils/properties/environment-sp
 import {ConnectHelper} from '../connectHelper';
 
 @Injectable()
-export class ConnectSubscriberGuard implements CanActivate {
+export class ConnectSubscriberGuard implements CanActivate, CanLoad{
   constructor(private router: Router,
               private communityService: CommunityService,
-              private propertiesService:EnvironmentSpecificService,
+              private propertiesService: EnvironmentSpecificService) {}
-              private route: ActivatedRoute) {}
 
-  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {
+   check(route: ActivatedRouteSnapshot, path: string): Observable<boolean> | boolean {
      let errorCode = LoginErrorCodes.NOT_SUBSCRIBER;
-    let community = this.route.queryParams["communityId"];
+     let community = route.queryParams['communityId'];
      if (!community && (typeof document !== 'undefined')) {
        community = ConnectHelper.getCommunityFromDomain(document.location.hostname);
      }
      if (!Session.isLoggedIn()) {
        errorCode = LoginErrorCodes.NOT_LOGIN;
-      this.router.navigate(['/user-info'], { queryParams: { "errorCode": errorCode, "redirectUrl":  state.url } });
+       this.router.navigate(['/user-info'], {queryParams: {'errorCode': errorCode, 'redirectUrl': path}});
        return false;
-    }
+     } else {
-    else {
+       const obs = this.propertiesService.subscribeEnvironment().mergeMap(properties => {
-      let obs = this.propertiesService.subscribeEnvironment().mergeMap(properties => {
+         return this.communityService.isSubscribedToCommunity(community, Session.getUserEmail(), properties['adminToolsAPIURL']);
-        return this.communityService.isSubscribedToCommunity(community, Session.getUserEmail(), properties["adminToolsAPIURL"])
        });
        obs.filter(enabled => !enabled)
            .subscribe(() => this.router.navigate(['/user-info'], {
              queryParams: {
-              "errorCode": errorCode,
+               'errorCode': errorCode,
-              "redirectUrl": state.url
+               'redirectUrl': path
              }
            }));
        return obs;
      }
    }
 
+  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {
+    return this.check(route, state.url);
+  }
+
+  canLoad(route: Route): Observable<boolean> | Promise<boolean> | boolean {
+    return this.check(null, '/' + route.path);
+  }
+
 }

connect/communityGuard/isCommunity.guard.ts

@@ -1,6 +1,5 @@
 import { Injectable } from '@angular/core';
 import {
-  ActivatedRoute,
   Router,
   CanActivate,
   ActivatedRouteSnapshot,
@@ -13,24 +12,25 @@ import 'rxjs/add/operator/filter';
 @Injectable()
 export class IsCommunity implements CanActivate, CanLoad {
 
-  constructor(private router: Router,
+  constructor(private router: Router) {
-              private route: ActivatedRoute) {}
+  }
 
-  check(): Observable<boolean> | boolean {
+  check(route: ActivatedRouteSnapshot): Observable<boolean> | boolean {
-    let community = this.route.queryParams["communityId"];
+    const community = route.queryParams['communityId'];
-    if(community && community!="undefined"){
+    console.log(community);
+    if (community && community !== 'undefined') {
       return true;
     } else {
       this.router.navigate(['errorcommunity']);
-    }
       return false;
     }
+  }
 
   canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {
-    return this.check();
+    return this.check(route);
   }
 
   canLoad(route: Route): Observable<boolean> | Promise<boolean> | boolean {
-    return this.check();
+    return this.check(null);
   }
 }

login/adminLoginGuard.guard.ts

@@ -7,7 +7,8 @@ import {LoginErrorCodes} from './utils/guardHelper.class';
 @Injectable()
 export class AdminLoginGuard implements CanActivate, CanLoad {
 
-  constructor(private router: Router) {}
+  constructor(private router: Router) {
+  }
 
   check(path: string): boolean {
     let loggedIn = false;
@@ -21,7 +22,7 @@ export class AdminLoginGuard implements CanActivate, CanLoad {
       }
     }
     if (!loggedIn || !isAdmin) {
-      this.router.navigate(['/user-info'], {queryParams: {"errorCode": errorCode, "redirectUrl": path}});
+      this.router.navigate(['/user-info'], {queryParams: {'errorCode': errorCode, 'redirectUrl': path}});
     }
     return loggedIn && isAdmin;
   }

login/claimsCuratorGuard.guard.ts

@@ -7,7 +7,8 @@ import {LoginErrorCodes} from './utils/guardHelper.class';
 @Injectable()
 export class ClaimsCuratorGuard implements CanActivate, CanLoad {
 
-  constructor(private router: Router) {}
+  constructor(private router: Router) {
+  }
 
   check(path: string): boolean {
     let loggedIn = false;
@@ -18,14 +19,12 @@ export class ClaimsCuratorGuard implements CanActivate, CanLoad {
       loggedIn = true;
       if (Session.isClaimsCurator() || Session.isPortalAdministrator()) {
         isAuthorized = true;
-      }
+      } else {
-      else {
         errorCode = LoginErrorCodes.NOT_ADMIN;
       }
     }
     if (!loggedIn || !isAuthorized) {
-      // this.guardHelper.redirect("/user-info",errorCode,state.url);
+      this.router.navigate(['/user-info'], {queryParams: {'errorCode': errorCode, 'redirectUrl': path}});
-      this.router.navigate(['/user-info'], {queryParams: {"errorCode": errorCode, "redirectUrl": path}});
     }
     return loggedIn && isAuthorized;
   }

login/freeGuard.guard.ts

@@ -13,13 +13,13 @@ import {LoginErrorCodes} from './utils/guardHelper.class';
 @Injectable()
 export class FreeGuard implements CanActivate, CanLoad {
 
-  constructor(private router: Router) {}
+  constructor(private router: Router) {
+  }
 
   check(path: string): boolean {
-    let valid = true;
+    const valid = true;
-    let errorCode = LoginErrorCodes.NOT_LOGIN;
     if (!valid) {
-      this.router.navigate(['/user-info'], {queryParams: {"errorCode": errorCode, "redirectUrl": path}});
+      this.router.navigate(['/user-info'], {queryParams: {'errorCode': LoginErrorCodes.NOT_VALID, 'redirectUrl': path}});
     }
     return valid;
   }

login/loginGuard.guard.ts

@@ -7,18 +7,16 @@ import {LoginErrorCodes} from './utils/guardHelper.class';
 @Injectable()
 export class LoginGuard implements CanActivate, CanLoad {
 
-  constructor(private router: Router) {}
+  constructor(private router: Router) {
+  }
 
   check(path: string): boolean {
     let loggedIn = false;
-    let errorCode = LoginErrorCodes.NOT_LOGIN;
-
     if (Session.isLoggedIn()) {
       loggedIn = true;
     }
     if (!loggedIn) {
-      // this.guardHelper.redirect("/user-info",errorCode,state.url);
+      this.router.navigate(['/user-info'], {queryParams: {'errorCode': LoginErrorCodes.NOT_LOGIN, path}});
-      this.router.navigate(['/user-info'], { queryParams: { "errorCode": errorCode, path} });
     }
     return loggedIn;
   }