fix(settings): Inactivity timeout fixed for user that does not refresh the page after logging in.

Author: zolotyx

src/app/app.component.ts

@@ -10,6 +10,9 @@ import { AuthService, ErrorService, LanguageService, LayoutService, Notification
 import { RouterUtilsService } from './shared/services/router-utils.service';
 import { StyleService } from './shared/services/style.service';
 import { ZoneService } from './shared/services/zone.service';
+import { StorageService } from './shared/services/storage.service';
+import { AsyncJobService } from './shared/services/async-job.service';
+import { CacheService } from './shared/services/cache.service';
 
 
 @Component({
@@ -35,6 +38,9 @@ export class AppComponent implements OnInit, AfterViewInit {
     private router: Router,
     private error: ErrorService,
     private languageService: LanguageService,
+    private asyncJobService: AsyncJobService,
+    private cacheService: CacheService,
+    private storage: StorageService,
     private layoutService: LayoutService,
     private mdlDialogService: MdlDialogService,
     private notification: NotificationService,
@@ -58,13 +64,19 @@ export class AppComponent implements OnInit, AfterViewInit {
     this.loadSettings();
 
     this.error.subscribe(e => this.handleError(e));
-    this.auth.loggedIn.subscribe(loggedIn => {
-      this.loggedIn = loggedIn;
+    this.auth.loggedIn.subscribe(isLoggedIn => {
+      this.loggedIn = isLoggedIn;
       this.updateAccount(this.loggedIn);
-      if (loggedIn) {
+      if (isLoggedIn) {
+        this.auth.startInactivityCounter();
         this.loadSettings();
         this.zoneService.areAllZonesBasic().subscribe(basic => this.disableSecurityGroups = basic);
+      } else {
+        this.auth.clearInactivityTimer();
       }
+      this.asyncJobService.completeAllJobs();
+      this.cacheService.invalidateAll();
+      this.storage.resetInMemoryStorage();
     });
 
     this.layoutService.drawerToggled.subscribe(() => {

src/app/shared/services/auth.service.spec.ts

@@ -215,7 +215,7 @@ describe('Auth service session', () => {
     const inactivityTimeout = 10;
     const logout = spyOn(router, 'navigate').and.callThrough();
     const refresh = spyOn(authService, 'sendRefreshRequest');
-
+    authService.startInactivityCounter();
     authService.setInactivityTimeout(inactivityTimeout).subscribe();
 
     tick(getRefreshInterval() * (inactivityTimeout - 1) * 60 / refreshInterval);

src/app/shared/services/auth.service.ts

@@ -8,7 +8,6 @@ import { BaseModelStub } from '../models';
 import { AsyncJobService } from './async-job.service';
 
 import { BaseBackendService } from './base-backend.service';
-import { CacheService } from './cache.service';
 import { ConfigService } from './config.service';
 import { RouterUtilsService } from './router-utils.service';
 import { StorageService } from './storage.service';
@@ -33,7 +32,6 @@ export class AuthService extends BaseBackendService<BaseModelStub> {
 
   constructor(
     protected asyncJobService: AsyncJobService,
-    protected cacheService: CacheService,
     protected configService: ConfigService,
     protected storage: StorageService,
     protected router: Router,
@@ -45,31 +43,27 @@ export class AuthService extends BaseBackendService<BaseModelStub> {
     this.loggedIn = new BehaviorSubject<boolean>(!!this.userId);
 
     debounce(this.refreshSession, 1000, { leading: true });
-    debounce(this.resetTimer, 1000, { leading: true });
+    debounce(this.resetInactivityTimer, 1000, { leading: true });
+  }
 
+  public startInactivityCounter() {
     Observable.forkJoin(
       this.getInactivityTimeout(),
       this.getSessionRefreshInterval()
     )
       .subscribe(([inactivityTimeout, sessionRefreshInterval]) => {
         this.inactivityTimeout = inactivityTimeout;
         this.sessionRefreshInterval = sessionRefreshInterval;
-        this.resetTimer();
+        this.resetInactivityTimer();
         this.addEventListeners();
       });
-
-    this.loggedIn.subscribe(() => {
-      this.asyncJobService.completeAllJobs();
-      this.cacheService.invalidateAll();
-      this.storage.resetInMemoryStorage();
-    });
   }
 
   public setInactivityTimeout(value: number): Observable<void> {
     return this.userService.writeTag('sessionTimeout', value.toString())
       .map(() => {
         this.inactivityTimeout = value;
-        this.resetTimer();
+        this.resetInactivityTimer();
       });
   }
 
@@ -174,7 +168,7 @@ export class AuthService extends BaseBackendService<BaseModelStub> {
 
   private refreshSession(): void {
     if (++this.numberOfRefreshes * this.sessionRefreshInterval >= this.inactivityTimeout * 60) {
-      this.clearTimer();
+      this.clearInactivityTimer();
       this.zone.run(() => this.router.navigate(['/logout'], this.routerUtilsService.getRedirectionQueryParams()));
     } else {
       this.sendRefreshRequest();
@@ -185,23 +179,23 @@ export class AuthService extends BaseBackendService<BaseModelStub> {
     const events = 'mousemove keydown DOMMouseScroll mousewheel mousedown touchstart touchmove scroll'.split(' ');
     const observables = events.map(event => Observable.fromEvent(document, event));
     this.zone.runOutsideAngular(() => {
-      Observable.merge(...observables).subscribe(() => this.resetTimer());
+      Observable.merge(...observables).subscribe(() => this.resetInactivityTimer());
     });
   }
 
-  private resetTimer(): void {
-    this.clearTimer();
+  private resetInactivityTimer(): void {
+    this.clearInactivityTimer();
     this.numberOfRefreshes = 0;
     if (this.inactivityTimeout) {
-      this.setTimer();
+      this.setInactivityTimer();
     }
   }
 
-  private clearTimer(): void {
+  public clearInactivityTimer(): void {
     clearInterval(this.refreshTimer);
   }
 
-  private setTimer(): void {
+  private setInactivityTimer(): void {
     if (this.sessionRefreshInterval && this.inactivityTimeout) {
       this.refreshTimer = setInterval(this.refreshSession.bind(this), this.sessionRefreshInterval * 1000);
     }

src/app/shared/services/user.service.ts

@@ -47,7 +47,7 @@ export class UserService extends BaseBackendService<User> {
   }
 
   public removeTag(key: string): Observable<void> {
-    let userId = this.storageService.read('userId');
+    const userId = this.storageService.read('userId');
     if (!userId) {
       return;
     }