visualizations-data-concrete.service.ts

import { Injectable } from "@angular/core";
import { Observable, throwError } from "rxjs";
import { catchError, map } from "rxjs/operators";
import { VisualizationDataApi } from "../api/visualization-data-api.service";
import { VisualizationData } from "../models/visualization-data";
import { VisualizationsDataService } from "./visualizations-data.service";
import { ClusterVisualizationDataMapper } from "../mappers/cluster-visualization-data-mapper";
import { RadarChartDataMapper } from "../mappers/radar-chart-data-mapper";
import { Clusterables } from "../models/clusterables-enum";
import { SseDataMapper } from "../mappers/sse-data-mapper";
import { Clusterable } from "../models/clusterable";
import { TimeAfterHint } from "../models/time-after-hint";
import { WrongFlags } from "../models/wrong-flags";

@Injectable()
export class VisualizationsDataConcreteService extends VisualizationsDataService {
  private readonly messageBase =
    "VisualizationsDataService not connect to API: ";
  private _selectedFeature: Clusterables;

  set selectedFeature(value: Clusterables) {
    this._selectedFeature = value;
  }

  get selectedFeature(): Clusterables {
    return this._selectedFeature;
  }

  constructor(private visualizationApi: VisualizationDataApi) {
    super();
  }

  getData(
    trainingDefinitionId: number,
    numOfClusters: number,
    instanceIds: number[],
    level: number
  ): Observable<VisualizationData> {
    switch (this._selectedFeature) {
      case Clusterables.WrongFlags:
        return this.visualizationApi
          .getVisualizationData(
            trainingDefinitionId,
            "wrong-flags",
            numOfClusters,
            instanceIds,
            level
          )
          .pipe(
            map((data: any) => ClusterVisualizationDataMapper.fromDTO(data)),
            catchError((error) => {
              return throwError(this.messageBase + error.message);
            })
          );
      case Clusterables.TimeAfterHint:
        return this.visualizationApi
          .getVisualizationData(
            trainingDefinitionId,
            "time-after-hint",
            numOfClusters,
            instanceIds,
            level
          )
          .pipe(
            map((data: any) => ClusterVisualizationDataMapper.fromDTO(data)),
            catchError((error) => {
              return throwError(this.messageBase + error.message);
            })
          );
      default:
        return new Observable<VisualizationData>();
    }
  }

  getRadarData(
    trainingDefinitionId: number,
    numOfClusters: number,
    instanceIds: number[],
    level: number
  ): Observable<VisualizationData> {
    return this.visualizationApi
      .getRadarChartData(
        trainingDefinitionId,
        numOfClusters,
        instanceIds,
        level
      )
      .pipe(
        map((data: any) => RadarChartDataMapper.fromDTO(data)),
        catchError((error) => {
          return throwError(this.messageBase + error.message);
        })
      );
  }

  getLineData(
    trainingDefinitionId: number,
    numOfClusters: number,
    instanceIds: number[],
    level: number
  ): Observable<any> {
    switch (this._selectedFeature) {
      case Clusterables.WrongFlags:
        return this.visualizationApi
          .getFeatureSSE(
            trainingDefinitionId,
            "wrong-flags",
            numOfClusters,
            instanceIds,
            level
          )
          .pipe(
            map((data: any) => SseDataMapper.fromDTO(data)),
            catchError((error) => {
              return throwError(this.messageBase + error.message);
            })
          );
      case Clusterables.TimeAfterHint:
        return this.visualizationApi
          .getFeatureSSE(
            trainingDefinitionId,
            "time-after-hint",
            numOfClusters,
            instanceIds,
            level
          )
          .pipe(
            map((data: any) => SseDataMapper.fromDTO(data)),
            catchError((error) => {
              return throwError(this.messageBase + error.message);
            })
          );
      case Clusterables.NDimensional:
        return this.visualizationApi
          .getFeatureSSE(
            trainingDefinitionId,
            "n-dimensional",
            numOfClusters,
            instanceIds,
            level
          )
          .pipe(
            map((data: any) => SseDataMapper.fromDTO(data)),
            catchError((error) => {
              return throwError(this.messageBase + error.message);
            })
          );
    }
  }

  getOption(point: Clusterable, feature = this._selectedFeature): number {
    switch (feature) {
      case Clusterables.TimeAfterHint:
        return (point as TimeAfterHint).level;
    }
    return 0;
  }

  getX(value: any, feature = this._selectedFeature): number {
    switch (feature) {
      case Clusterables.WrongFlags:
        return (value as WrongFlags).wrongFlagsSubmittedNormalized;
      case Clusterables.TimeAfterHint:
        return (value as TimeAfterHint).timeSpentAfterHintNormalized;
      case Clusterables.NDimensional:
        break;
    }
    const tmp = value as WrongFlags;
    return tmp.wrongFlagsSubmittedNormalized;
  }

  getY(value: any, feature = this._selectedFeature): number {
    switch (feature) {
      case Clusterables.WrongFlags:
        return (value as WrongFlags).timePlayedNormalized;
      case Clusterables.TimeAfterHint:
        return (value as TimeAfterHint).wrongFlagsAfterHintNormalized;
      case Clusterables.NDimensional:
        break;
    }
    const tmp = value as WrongFlags;
    return tmp.timePlayedNormalized;
  }

  getXLabel(feature = this._selectedFeature): string {
    switch (feature) {
      case Clusterables.WrongFlags:
        return "Wrong flags submitted";
      case Clusterables.TimeAfterHint:
        return "Time spent after using hint";
    }
    return "Feature X";
  }

  getYLabel(feature = this._selectedFeature): string {
    switch (feature) {
      case Clusterables.WrongFlags:
        return "Time played";
      case Clusterables.TimeAfterHint:
        return "Wrong flags after using hint";
    }
    return "Feature Y";
  }
}