#224 update to master

Author: Vladimir Shakhov

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/events/event-list.component.ts

@@ -66,9 +66,12 @@ export class EventListComponent implements OnInit {
   }
 
   public getEvents(params = { reload: false }): void {
-    if (params.reload) { this.loading = true; }
+    if (params.reload) {
+      this.loading = true;
+    }
     this.getEventsObservable(params)
-      .subscribe(() => this.loading = false);
+      .finally(() => this.loading = false)
+      .subscribe();
   }
 
   public getEventsObservable(params: { reload: boolean }): Observable<Array<Event>> {
@@ -109,7 +112,9 @@ export class EventListComponent implements OnInit {
   }
 
   private filterBySearch(events: Array<Event>): Array<Event> {
-    if (!this.query) { return events; }
+    if (!this.query) {
+      return events;
+    }
 
     const queryLower = this.query.toLowerCase();
     return events.filter((event: Event) => {
@@ -169,12 +174,19 @@ export class EventListComponent implements OnInit {
   }
 
   private getEventTypes(events: Array<Event>): Array<string> {
-    return events.reduce((acc, event) => {
+    const types = events.reduce((acc, event) => {
       if (!acc.includes(event.type)) {
         acc.push(event.type);
       }
       return acc;
     }, []);
+
+    return this.selectedTypes.reduce((acc, type) => {
+      if (!acc.includes(type)) {
+        acc.push(type);
+      }
+      return acc;
+    }, types);
   }
 
   private initTableModel(translations: any): void {

src/app/shared/components/color-picker/color-picker.component.html

@@ -1,12 +1,17 @@
-<div class="color-preview-container" (click)="popover.toggle($event)">
+<div
+  class="color-preview-container"
+  [class.disabled]="disabled"
+  (click)="toggle($event)"
+>
   <div
     class="color-preview"
     [style.background-color]="selectedColor?.value"
   ></div>
 </div>
 <mdl-textfield
   [value]="selectedColor?.value"
-  (click)="popover.toggle($event)"
+  [disabled]="disabled"
+  (click)="toggle($event)"
   readonly
 ></mdl-textfield>
 

src/app/shared/components/color-picker/color-picker.component.scss

@@ -24,6 +24,10 @@ $input-margin: 10px;
     width: 100%;
     height: 100%;
   }
+  
+  &.disabled {
+    cursor: not-allowed;
+  }
 }
 
 :host mdl-textfield {
@@ -32,6 +36,10 @@ $input-margin: 10px;
   /deep/ input {
     cursor: pointer;
   }
+  
+  /deep/ input:disabled {
+    cursor: not-allowed;
+  }
 }
 
 .popover-container {

src/app/shared/components/color-picker/color-picker.component.ts

@@ -11,6 +11,7 @@ import {
 import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
 import { MdlPopoverComponent } from '@angular-mdl/popover';
 import { Color } from '../../models';
+import { toBoolean } from '@angular-mdl/core/components/common/boolean-property';
 
 
 @Component({
@@ -35,6 +36,15 @@ export class ColorPickerComponent implements OnChanges, ControlValueAccessor {
   public colorWidth: number;
 
   private _selectedColor: Color;
+  private _disabled: boolean;
+
+  @Input() public get disabled(): boolean {
+    return this._disabled;
+  };
+
+  public set disabled(value) {
+    this._disabled = toBoolean(value);
+  }
 
   public ngOnChanges(changes: SimpleChanges): void {
     if ('colors' in changes) {
@@ -52,6 +62,12 @@ export class ColorPickerComponent implements OnChanges, ControlValueAccessor {
     this.propagateChange(this._selectedColor);
   }
 
+  public toggle(event: Event): void {
+    if (!this._disabled) {
+      this.popover.toggle(event);
+    }
+  }
+
   public selectColor(color: Color): void {
     this.selectedColor = color;
     this.popover.hide();

src/app/shared/components/vm-statistics/vm-statistics.component.html

@@ -110,3 +110,6 @@ <h2 mdl-card-title-text>{{ 'STORAGE' | translate }}</h2>
   </div>
   <mdl-card-actions class="stat-collapse"></mdl-card-actions>
 </mdl-card>
+<mdl-tooltip #refreshStatistics="mdlTooltip">
+  {{ 'REFRESH' | translate }}
+</mdl-tooltip>

src/app/shared/services/async-job.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
+import { Observer } from 'rxjs/Observer';
 import { Subject } from 'rxjs/Subject';
 
 import { AsyncJob } from '../models';
@@ -35,21 +36,25 @@ export class AsyncJobService extends BaseBackendService<AsyncJob<any>> {
 
   public queryJob(job: any, entity = '', entityModel: any = null): Observable<typeof entityModel> {
     const jobId = this.getJobId(job);
-    const jobSubject = new Subject<AsyncJob<typeof entityModel>>();
-    this.jobs.push(jobSubject);
+    const jobObservable = Observable.create(observer => {
+      let interval;
+      setTimeout(() => {
+        this._queryJob(jobId, observer, entity, entityModel);
+        interval = setInterval(() => {
+          if (jobObservable.isStopped) {
+            clearInterval(interval);
+            return;
+          }
+          this._queryJob(jobId, observer, entity, entityModel, interval);
+        }, this.pollingInterval);
+        this.timerIds.push(interval);
+      }, this.immediatePollingInterval);
 
-    setTimeout(() => {
-      this._queryJob(jobId, jobSubject, entity, entityModel);
-      let interval = setInterval(() => {
-        if (jobSubject.isStopped) {
-          clearInterval(interval);
-          return;
-        }
-        this._queryJob(jobId, jobSubject, entity, entityModel, interval);
-      }, this.pollingInterval);
-      this.timerIds.push(interval);
-    }, this.immediatePollingInterval);
-    return jobSubject;
+      return () => clearInterval(interval);
+    });
+    this.jobs.push(jobObservable);
+
+    return jobObservable;
   }
 
   public completeAllJobs(): void {
@@ -61,7 +66,7 @@ export class AsyncJobService extends BaseBackendService<AsyncJob<any>> {
 
   private _queryJob(
     jobId: string,
-    jobSubject: Subject<AsyncJob<any>>,
+    observer: Observer<AsyncJob<any>>,
     entity: string,
     entityModel: any,
     interval?: any
@@ -73,10 +78,10 @@ export class AsyncJobService extends BaseBackendService<AsyncJob<any>> {
           case JobStatus.InProgress:
             return;
           case JobStatus.Completed:
-            jobSubject.next(this.getResult(asyncJob, entity, entityModel));
+            observer.next(this.getResult(asyncJob, entity, entityModel));
             break;
           case JobStatus.Failed: {
-            jobSubject.error(ErrorService.parseError(this.getResponse({ error: asyncJob.result })));
+            observer.error(ErrorService.parseError(this.getResponse({ error: asyncJob.result })));
             break;
           }
         }
@@ -85,7 +90,7 @@ export class AsyncJobService extends BaseBackendService<AsyncJob<any>> {
           clearInterval(interval);
           this.timerIds.filter(id => interval !== id);
         }
-        jobSubject.complete();
+        observer.complete();
         this.event.next(asyncJob);
       });
   }

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,15 +8,11 @@ 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';
 import { UserService } from './user.service';
 
-import debounce = require('lodash/debounce');
-
-
 const DEFAULT_SESSION_REFRESH_INTERVAL = 60;
 
 @Injectable()
@@ -33,7 +29,6 @@ export class AuthService extends BaseBackendService<BaseModelStub> {
 
   constructor(
     protected asyncJobService: AsyncJobService,
-    protected cacheService: CacheService,
     protected configService: ConfigService,
     protected storage: StorageService,
     protected router: Router,
@@ -43,33 +38,26 @@ export class AuthService extends BaseBackendService<BaseModelStub> {
   ) {
     super();
     this.loggedIn = new BehaviorSubject<boolean>(!!this.userId);
+  }
 
-    debounce(this.refreshSession, 1000, { leading: true });
-    debounce(this.resetTimer, 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 +162,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 +173,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/notification.service.ts

@@ -22,7 +22,7 @@ export class NotificationService implements NotificationService {
   }
 
   public message(message: string | ParametrizedTranslation): Observable<MdlSnackbarComponent> {
-    let obs = new Subject<MdlSnackbarComponent>();
+    const obs = new Subject<MdlSnackbarComponent>();
     this.getTranslatedMessage(message)
       .switchMap(translatedMessage => {
         return this.snackbar.showSnackbar({
@@ -40,7 +40,7 @@ export class NotificationService implements NotificationService {
       handler: () => {},
       text: 'OK'
     }): Observable<MdlSnackbarComponent> {
-    let obs = new Subject<MdlSnackbarComponent>();
+    const obs = new Subject<MdlSnackbarComponent>();
     this.getTranslatedMessage(message)
       .switchMap(translatedMessage => {
         return this.snackbar.showSnackbar({message: translatedMessage, action});
@@ -60,7 +60,7 @@ export class NotificationService implements NotificationService {
       handler: () => {},
       text: 'OK'
     }): Observable<MdlSnackbarComponent> {
-    let obs = new Subject<MdlSnackbarComponent>();
+    const obs = new Subject<MdlSnackbarComponent>();
     this.getTranslatedMessage(message)
       .switchMap(translatedMessage => {
         return this.snackbar.showSnackbar({