frontend-tutorial-framework/src/app/dashboard/dashboard.component.ts

// Copyright (C) 2018 Avatao.com Innovative Learning Kft.
// All Rights Reserved. See LICENSE file for details.

import { Component, OnDestroy, OnInit, ChangeDetectorRef, ElementRef, ViewChild } from '@angular/core';
import { DeploymentNotificationService } from '../services/deployment-notification.service';
import { Subscription } from 'rxjs';
import { WebSocketService } from '../services/websocket.service';
import { HideMessagesCommand, LayoutCommand, TerminalMenuItemCommand } from '../message-types/dashboard-commands';
import { config } from '../config';
import { ProcessLogService } from '../services/processlog.service';
import { LogMessage } from '../message-types/log-message';
import { CommandMessage } from '../message-types/command-message';
import { HttpClient } from '@angular/common/http';
import { delay, retryWhen, tap } from 'rxjs/operators';

@Component({
  selector: 'app-dashboard',
  templateUrl: './dashboard.component.html',
  styleUrls: ['./dashboard.component.scss']
})
export class DashboardComponent implements OnInit, OnDestroy {
  deploying = false;
  polling = false;
  deploymentNotificationSubscription: Subscription;
  @ViewChild('webiframe') webiframe: ElementRef;
  @ViewChild('tfwmessages') messages: ElementRef;
  @ViewChild('urlbar') urlbar: ElementRef;

  layout: string = config.dashboard.currentLayout;
  hideMessages: boolean = config.dashboard.hideMessages;
  iframeUrl: string = config.dashboard.iframeUrl;
  showUrlBar = config.dashboard.showUrlBar;
  actualIframeUrl: string = this.iframeUrl;
  selectedTerminalMenuItem: string = config.dashboard.terminalOrConsole;
  iframeReloadSubscription: Subscription;

  command_handlers = {
    'layout':           this.layoutHandler.bind(this),
    'hideMessages':     this.hideMessagesHandler.bind(this),
    'terminalMenuItem': this.terminalMenuItemHandler.bind(this),
    'reloadFrontend':   this.reloadFrontendHandlder.bind(this),
    'reloadIframe':     this.reloadIframeHandler.bind(this)
  };

  constructor(private deploymentNotificationService: DeploymentNotificationService,
              private webSocketService: WebSocketService,
              private changeDetectorRef: ChangeDetectorRef,
              private processLogService: ProcessLogService,
              private http: HttpClient) {}

  ngOnInit() {
    this.webSocketService.connect();
    this.initCommandHandling();
    this.initDeploymentNotifications();
    this.recoverIfNeeded();
    this.triggerFirstFSMStepIfNeeded();
  }

  initCommandHandling() {
    this.webSocketService.observeKey<CommandMessage>('dashboard').subscribe((event) => {
      this.command_handlers[event.data.command](event.data);
      this.changeDetectorRef.detectChanges();
    });
  }

  initDeploymentNotifications() {
    this.deploymentNotificationSubscription = this.deploymentNotificationService.deploying.subscribe(
      (deploying) => {
        this.deploying = deploying;
        if (!deploying && config.ide.reloadIframeOnDeploy) {
          if (this.polling) {
            this.iframeReloadSubscription.unsubscribe();
          }
          this.pollingServerForIframeReload();
        }
      });
  }

  triggerFirstFSMStepIfNeeded() {
    if (config.dashboard.triggerFirstFSMStep) {
      setTimeout(() => {
        this.webSocketService.sendJSON({
          'key': 'fsm',
          'data': {
            'command': 'trigger',
            'value': config.dashboard.triggerFirstFSMStep
          }
        });
      });
    }
  }

  recoverIfNeeded() {
    if (config.dashboard.recoverAfterPageReload) {
      setTimeout(() => this.webSocketService.sendJSON({'key': 'recover'}));
    }
  }

  layoutHandler(data: LayoutCommand) {
    if (config.dashboard.enabledLayouts.includes(data.value)) {
      this.setLayout(data.value);
    } else {
      console.log('Invalid ide layout "' + data.value + '" received!');
    }
  }

  hideMessagesHandler(data: HideMessagesCommand) {
    this.hideMessages = data.value;
  }

  terminalMenuItemHandler(data: TerminalMenuItemCommand) {
    this.selectTerminalMenuItem(data.value);
  }

  reloadFrontendHandlder(data: CommandMessage) {
    setTimeout(() => window.location.reload(), 2000);
  }

  reloadIframeHandler(data: CommandMessage) {
    setTimeout(() => this.reloadIframeNoSubmit(), 200);
  }

  setLayout(layout: string) {
    this.layout = layout;
    // We need to trigger a 'resize' event manually, otherwise editor stays collapsed
    // editor 'resize' event listener requires a parameter of force=true
    setTimeout(() => window.dispatchEvent(new Event('resize', {force: true} as any)), 0);
  }

  reloadIframe() {
    setTimeout(() => {
      this.webiframe.nativeElement.contentWindow.location.reload(true);
    });
  }

  reloadIframeNoSubmit() {
    // Sometimes it is needed to reload the iframe without resending the previous form data
    setTimeout(() => {
      this.webiframe.nativeElement.contentWindow.location = this.webiframe.nativeElement.contentWindow.location.href;
    })
  }

  selectTerminalMenuItem(item: string) {
    if (!item.match('(terminal|console)')) {
      return;
    }
    this.selectedTerminalMenuItem = item;
  }

  setConsoleContentIfNoLiveLogs(logs: LogMessage) {
    this.processLogService.emitNewLogsIfNoLiveLogs(logs);
    if (config.ide.showConsoleOnDeploy) {
      this.selectTerminalMenuItem('console');
    }
  }

  scrollMessagesToBottom(): void {
    const element = this.messages.nativeElement;
    // This must be done in the Angular event loop to avoid messing up
    // change detection (not in the template like ConsoleComponent does)
    element.scrollTop = element.scrollHeight;
  }

  iframeLoad(): void {
    if (this.webiframe) {
      const href = this.webiframe.nativeElement.contentWindow.frames.location.href;
      const niceURL = href.match(/.*?\/\/.*?(\/.*)/)[1];
      this.actualIframeUrl = niceURL;
    }
  }

  changeIframeURL() {
    const userGivenValue = this.urlbar.nativeElement.value.trim();
    if(
        userGivenValue == '/' ||
        userGivenValue.startsWith('dashboard') ||
        userGivenValue.startsWith('/dashboard')
    )
      return;
    this.webiframe.nativeElement.contentWindow.frames.location.href = this.urlbar.nativeElement.value;
  }

  pollingServerForIframeReload() {
    this.polling = true;
    this.iframeReloadSubscription = this.http.get(this.actualIframeUrl, {observe: 'response'}).pipe(
      retryWhen(errors =>
        errors.pipe(
          tap(
            response => {
              if (response.status === 200) {
                this.iframeReloadSubscription.unsubscribe();
                this.polling = false;
                this.reloadIframe();
              }
            }
          ),
          delay(1000)
        )
      )
    ).subscribe();
  }

  ngOnDestroy() {
    if (this.deploymentNotificationSubscription) {
      this.deploymentNotificationSubscription.unsubscribe();
    }

    if (this.iframeReloadSubscription) {
      this.iframeReloadSubscription.unsubscribe();
    }
  }
}