create folders for components;

components/control_center/src/app/app-routing.module.ts

@@ -0,0 +1,10 @@
+import { NgModule } from '@angular/core';
+import { Routes, RouterModule } from '@angular/router';
+
+const routes: Routes = [];
+
+@NgModule({
+  imports: [RouterModule.forRoot(routes)],
+  exports: [RouterModule]
+})
+export class AppRoutingModule { }

components/control_center/src/app/app.module.ts

@@ -0,0 +1,49 @@
+import {BrowserModule} from '@angular/platform-browser';
+import {NgModule} from '@angular/core';
+
+import {AppRoutingModule} from './app-routing.module';
+import {LandingComponent} from './component/landing/landing.component';
+import {RestService} from './services/rest.service';
+import {HTTP_INTERCEPTORS, HttpClientModule} from '@angular/common/http';
+import {InterceptorService} from './services/interceptor.service';
+import {WebsocketService} from './services/websocket.service';
+import {LoggerModule, NgxLoggerLevel} from 'ngx-logger';
+import {environment} from '../environments/environment';
+import {TestSubCompComponent} from './component/testsubcomp/test-sub-comp.component';
+import {FormsModule, ReactiveFormsModule} from '@angular/forms';
+import {MatFormFieldModule} from '@angular/material/form-field';
+import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
+import {MatButtonModule} from '@angular/material/button';
+import {MatInputModule} from '@angular/material/input';
+import {MatSlideToggleModule} from '@angular/material/slide-toggle';
+import {MatSliderModule} from "@angular/material/slider";
+
+@NgModule({
+  declarations: [LandingComponent, TestSubCompComponent],
+  imports: [
+    ReactiveFormsModule,
+    BrowserModule,
+    BrowserAnimationsModule,
+    AppRoutingModule,
+    LoggerModule.forRoot({level: environment.log_level, serverLogLevel: NgxLoggerLevel.ERROR}),
+    HttpClientModule,
+    MatFormFieldModule,
+    FormsModule,
+    MatButtonModule,
+    MatInputModule,
+    MatSlideToggleModule,
+    MatSliderModule
+  ],
+  // enables injecting
+  providers: [
+    RestService,
+    WebsocketService,
+    {
+      provide: HTTP_INTERCEPTORS, useClass: InterceptorService, multi: true
+    },
+
+  ],
+  bootstrap: [LandingComponent]
+})
+export class AppModule {
+}

components/control_center/src/app/component/landing/landing.component.html

@@ -0,0 +1,33 @@
+<h1>landing works!</h1>
+
+<mat-slider min="1" max="5" step="0.5" [value]="myValue"></mat-slider>
+
+
+<h2>Two way data binding, passing data, triggering child event...</h2>
+<mat-form-field *ngIf="true">
+  <input
+         type="text"
+         placeholder="Placeholder"
+         matInput
+         [(ngModel)]="exampleInputText"
+  >
+</mat-form-field>
+
+<app-test-sub-comp [message]="exampleInputText" (buttonClickedEvent)="alert()"
+                   [anotherInput]=""
+></app-test-sub-comp>
+
+
+
+<h2>Hide display with *ngIf</h2>
+<mat-slide-toggle [(ngModel)]="showPar">Show paragraph</mat-slide-toggle>
+<p *ngIf="showPar">Toggle me</p>
+<app-test-sub-comp *ngIf="showPar"
+  [message]="exampleInputText" (buttonClickedEvent)="alert()"
+                   [anotherInput]=""
+></app-test-sub-comp>
+
+
+
+<h2>Display a test list with *ngFor</h2>
+<span *ngFor="let dict of testList">{{dict.value}}; </span>

components/control_center/src/app/component/landing/landing.component.ts

@@ -0,0 +1,88 @@
+import {Component, OnInit} from '@angular/core';
+import {RestService} from '../../services/rest.service';
+import {WebsocketService} from '../../services/websocket.service';
+import {NGXLogger} from 'ngx-logger';
+import {Subscription} from 'rxjs';
+
+@Component({
+  selector: 'app-landing',
+  templateUrl: './landing.component.html',
+  styleUrls: ['./landing.component.css']
+})
+export class LandingComponent implements OnInit {
+
+  private wsSubscription: Subscription;
+  private wsMessageCounter: number;
+  exampleInputText: string;
+  showPar = false;
+  testList = [{'value': 1}, {'value': 2}, {'value': 3}];
+  myValue: any = 15;
+
+  constructor(
+    private logger: NGXLogger,
+    private restService: RestService,
+    private wsService: WebsocketService
+  ) {
+  }
+
+  ngOnInit(): void {
+    // perform test rest call as observable
+    this.observableCall();
+
+    // perform test rest call as promise (shorter - will only be executed exactly once)
+    this.promiseCall();
+
+    // perform test ws send / receive
+    setTimeout(() => {
+        this.wsCall();
+      },
+      1000);
+  }
+
+  private observableCall(): void {
+
+    const subscription = this.restService.testCall(1).subscribe(
+      // subscribe with lambda function
+      response => {
+        this.logger.debug('Execute obs test call', response);
+        subscription.unsubscribe();
+      },
+      error => {
+        this.logger.error('Error while executing obs test call', error);
+        subscription.unsubscribe();
+      }
+    );
+  }
+
+  private promiseCall(): void {
+    this.restService.testCall(2).toPromise()
+      // lambda for success
+      .then(response => {
+        this.logger.debug('Execute obs test call', response);
+      })
+      // lambda for fail
+      .catch(error => {
+        this.logger.error('Error while executing obs test call', error);
+      });
+  }
+
+  private wsCall(): void {
+    this.wsMessageCounter = 0;
+    this.wsSubscription = this.wsService.wsTestCall('Test message').message.subscribe(
+      result => {
+        this.logger.debug('ws call result', result);
+        if (this.wsMessageCounter >= 2) {
+          this.wsSubscription.unsubscribe();
+        }
+      },
+      error => {
+        this.logger.error('ws call error', error);
+        this.wsSubscription.unsubscribe();
+      }
+    );
+  }
+
+  alert() {
+    alert(this.exampleInputText);
+  }
+}

components/control_center/src/app/component/testsubcomp/test-sub-comp.component.html

@@ -0,0 +1 @@
+<p>{{message}} <button mat-raised-button (click)="buttonClickedEvent.emit()">Click me</button></p>

components/control_center/src/app/component/testsubcomp/test-sub-comp.component.ts

@@ -0,0 +1,24 @@
+import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+
+@Component({
+  selector: 'app-test-sub-comp',
+  templateUrl: './test-sub-comp.component.html',
+  styleUrls: ['./test-sub-comp.component.css']
+})
+export class TestSubCompComponent implements OnInit {
+  @Input()
+  message: string;
+  @Input()
+  anotherInput: string;
+
+  @Output()
+  buttonClickedEvent: EventEmitter<void> = new EventEmitter<void>();
+
+  constructor() {
+  }
+
+  ngOnInit(): void {
+    this.message;
+  }
+
+}

components/control_center/src/app/interfaces/interface.ts

@@ -0,0 +1,7 @@
+import {Observable} from 'rxjs';
+
+export interface WSEvents {
+  message: Observable<Event>;
+  error: Observable<Event>;
+  close: Observable<Event>;
+}

components/control_center/src/app/services/interceptor.service.ts

@@ -0,0 +1,52 @@
+import {HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpResponse} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {Observable} from 'rxjs';
+import {tap} from 'rxjs/operators';
+import {NGXLogger} from 'ngx-logger';
+
+@Injectable({
+  providedIn: 'root'
+})
+/**
+ * The InterceptorService intercepts EVERY http event.
+ */
+export class InterceptorService implements HttpInterceptor {
+
+  constructor(private logger: NGXLogger) {
+  }
+
+  /**
+   * Intercepts every HTTP request and for example adds a token
+   * @param req   http request
+   * @param next  http response handler
+   */
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    // TODO get the real token
+    const token = 'A_TOKEN';
+
+    // the original request is immutable, so we need to clone it
+    req = req.clone({
+      setHeaders: {
+        // FIXME e.g. if Bearer is used
+        Authorization: `Bearer ${token}`
+      }
+    });
+
+    this.logger.debug('Interceptor works');
+
+    // pipe the response observable
+    return next.handle(req).pipe(
+      // perform a side effect for every emission on the source Observable
+      // return an Observable that is identical to the source
+      tap(event => {
+        // check if it is the response message
+        if (event instanceof HttpResponse) {
+          // TODO so something if necessary
+        }
+      }, error => {
+        // TODO handle error here
+        this.logger.error('HTTP Response interception error', error);
+      })
+    );
+  }
+}

components/control_center/src/app/services/rest.service.ts

@@ -0,0 +1,22 @@
+import {HttpClient} from '@angular/common/http';
+import {Injectable} from '@angular/core';
+import {NGXLogger} from 'ngx-logger';
+import {environment} from '../../environments/environment';
+import {Observable} from 'rxjs';
+
+@Injectable()
+export class RestService {
+  private currentLocation = 'http://' + environment.location + ':' + environment.port + '/';
+
+  constructor(
+    private logger: NGXLogger,
+    private http: HttpClient
+  ) {
+  }
+
+  testCall(i: number): Observable<string> {
+    const url = this.currentLocation + 'test/';
+    this.logger.debug('Performing ' + i + '. test rest call on', url);
+    return this.http.get<string>(url);
+  }
+}

components/control_center/src/app/services/websocket.service.ts

@@ -0,0 +1,52 @@
+import {Injectable} from '@angular/core';
+import {NGXLogger} from 'ngx-logger';
+import {fromEvent, interval, Observable} from 'rxjs';
+
+import {environment} from '../../environments/environment';
+import {WSEvents} from '../interfaces/interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class WebsocketService {
+  private wsEndpoint = environment.ws_location + ':' + environment.ws_port + '/test-ws-endpoint/';
+  private readonly ws: WebSocket;
+  private wsEvents: WSEvents;
+
+  constructor(private logger: NGXLogger) {
+    this.logger.debug('Initiating ws connection on', this.wsEndpoint);
+    this.ws = new WebSocket(this.wsEndpoint);
+
+    interval(5000).subscribe(() => {
+      // continuously check if the connection is still open
+      if (this.ws.readyState !== WebSocket.OPEN) {
+        this.logger.error('Lost websocket connection ...', this.ws);
+      }
+    });
+
+  }
+
+  wsTestCall(msg: string): WSEvents {
+    this.logger.debug(
+      'Performing ws test call',
+      'current ws ready state ==', this.ws.readyState + ',',
+      'expected == 1 == open');
+
+    if (this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(msg);
+    } else {
+      return undefined;
+    }
+
+    if (!this.wsEvents) {
+      this.wsEvents = {
+        message: fromEvent(this.ws, 'message'),
+        error: fromEvent(this.ws, 'error'),
+        close: fromEvent(this.ws, 'close')
+      };
+    }
+
+    return this.wsEvents;
+  }
+
+}

components/control_center/src/environments/environment.prod.ts

@@ -0,0 +1,9 @@
+import {NgxLoggerLevel} from 'ngx-logger';
+
+export const environment = {
+  production: true,
+  location: window.location.hostname,
+  port: 8000,
+  ws_url_root: 'ws://' + window.location.hostname + ':' + window.location.port + '/',
+  log_level: NgxLoggerLevel.WARN,
+};

components/control_center/src/environments/environment.ts

@@ -0,0 +1,23 @@
+// This file can be replaced during build by using the `fileReplacements` array.
+// `ng build --prod` replaces `environment.ts` with `environment.prod.ts`.
+// The list of file replacements can be found in `angular.json`.
+
+import {NgxLoggerLevel} from 'ngx-logger';
+
+export const environment = {
+  production: false,
+  location: 'localhost',
+  port: 8000,
+  ws_location: 'ws://127.0.0.1',
+  ws_port: 8000,
+  log_level: NgxLoggerLevel.DEBUG,
+};
+
+/*
+ * For easier debugging in development mode, you can import the following file
+ * to ignore zone related error stack frames such as `zone.run`, `zoneDelegate.invokeTask`.
+ *
+ * This import should be commented out in production mode because it will have a negative impact
+ * on performance if an error is thrown.
+ */
+// import 'zone.js/dist/zone-error';  // Included with Angular CLI.

components/control_center/src/index.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>AppFe</title>
+  <base href="/">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" type="image/x-icon" href="favicon.ico">
+</head>
+<body>
+  <app-landing></app-landing>
+</body>
+</html>
+
+<!--<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"></script>-->
+<!--<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js"></script>-->
+<!--<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"></script>-->

components/control_center/src/main.ts

@@ -0,0 +1,12 @@
+import { enableProdMode } from '@angular/core';
+import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+
+import { AppModule } from './app/app.module';
+import { environment } from './environments/environment';
+
+if (environment.production) {
+  enableProdMode();
+}
+
+platformBrowserDynamic().bootstrapModule(AppModule)
+  .catch(err => console.error(err));

components/control_center/src/polyfills.ts

@@ -0,0 +1,79 @@
+/**
+ * This file includes polyfills needed by Angular and is loaded before the app.
+ * You can add your own extra polyfills to this file.
+ *
+ * This file is divided into 2 sections:
+ *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
+ *   2. Application imports. Files imported after ZoneJS that should be loaded before your main
+ *      file.
+ *
+ * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
+ * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
+ * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
+ *
+ * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html
+ */
+
+/***************************************************************************************************
+ * BROWSER POLYFILLS
+ */
+
+(window as any).global = window;
+
+/** IE9, IE10 and IE11 requires all of the following polyfills. **/
+// import 'core-js/es6/symbol';
+// import 'core-js/es6/object';
+// import 'core-js/es6/function';
+// import 'core-js/es6/parse-int';
+// import 'core-js/es6/parse-float';
+// import 'core-js/es6/number';
+// import 'core-js/es6/math';
+// import 'core-js/es6/string';
+// import 'core-js/es6/date';
+// import 'core-js/es6/array';
+// import 'core-js/es6/regexp';
+// import 'core-js/es6/map';
+// import 'core-js/es6/weak-map';
+// import 'core-js/es6/set';
+
+/** IE10 and IE11 requires the following for NgClass support on SVG elements */
+// import 'classlist.js';  // Run `npm install --save classlist.js`.
+
+/** IE10 and IE11 requires the following for the Reflect API. */
+// import 'core-js/es6/reflect';
+
+
+/** Evergreen browsers require these. **/
+// Used for reflect-metadata in JIT. If you use AOT (and only Angular decorators), you can remove.
+// import 'core-js/es7/reflect';
+
+
+/**
+ * Required to support Web Animations `@angular/platform-browser/animations`.
+ * Needed for: All but Chrome, Firefox and Opera. http://caniuse.com/#feat=web-animation
+ **/
+// import 'web-animations-js';  // Run `npm install --save web-animations-js`.
+
+/**
+ * By default, zone.js will patch all possible macroTask and DomEvents
+ * user can disable parts of macroTask/DomEvents patch by setting following flags
+ */
+
+// (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame
+// (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick
+// (window as any).__zone_symbol__BLACK_LISTED_EVENTS = ['scroll', 'mousemove']; // disable patch specified eventNames
+
+/**
+ * in IE/Edge developer tools, the addEventListener will also be wrapped by zone.js
+ * with the following flag, it will bypass `zone.js` patch for IE/Edge
+ */
+// (window as any).__Zone_enable_cross_context_check = true;
+
+/***************************************************************************************************
+ * Zone JS is required by default for Angular itself.
+ */
+import 'zone.js/dist/zone'; // Included with Angular CLI.
+/***************************************************************************************************
+ * APPLICATION IMPORTS
+ */
+import '@angular/localize/init';

components/control_center/src/styles.css

@@ -0,0 +1,9 @@
+/* You can add global styles to this file, and also import other style files */
+
+@import "~@angular/material/prebuilt-themes/indigo-pink.css";
+@import '~bootstrap/dist/css/bootstrap.min.css';
+
+body {
+  width: 95%;
+  margin: auto;
+}

components/control_center/src/test.ts

@@ -0,0 +1,25 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js/dist/zone-testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: {
+  context(path: string, deep?: boolean, filter?: RegExp): {
+    keys(): string[];
+    <T>(id: string): T;
+  };
+};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

components/control_center/src/theme.scss

@@ -0,0 +1,20 @@
+@import '~@angular/material/theming';
+
+@include mat-core();
+
+$my-app-primary: mat-palette($mat-grey);
+$my-app-accent: mat-palette($mat-amber, 500, 900, A100);
+$my-app-warn: mat-palette($mat-red, 700, 900);
+
+$my-app-theme: mat-light-theme($my-app-primary, $my-app-accent, $my-app-warn);
+
+@include angular-material-theme($my-app-theme);
+
+.alternate-theme {
+  $alternate-primary: mat-palette($mat-light-blue);
+  $alternate-accent: mat-palette($mat-yellow, 400);
+
+  $alternate-theme: mat-light-theme($alternate-primary, $alternate-accent);
+
+  @include angular-material-theme($alternate-theme);
+}