aswi2021codebakers-gitlab/src/app/unit/components/unit.component.ts @ b5525aef

import {Component, OnInit} from '@angular/core';
import {ActivatedRoute} from '@angular/router';
import {AnalyticsService} from '../../shared/api/endpoints/services/analytics.service';
import {map, tap} from 'rxjs/operators';
import {AggregationModel} from '../../shared/models/aggregationModel';
import * as moment from 'moment-timezone';
import {GraphLoader} from '../../shared/graph-loading/graphloader';
import {SensorsService} from '../../shared/api/endpoints/services/sensors.service';
import {HttpResponse} from '@angular/common/http';
import {ToastService} from '../../shared/services/toast.service';
import {Sensor} from '../../shared/api/endpoints/models/sensor';

declare var require: any

@Component({
  selector: 'app-unit',
  templateUrl: './unit.component.html',
  styleUrls: ['./unit.component.scss']
})
export class UnitComponent implements OnInit {

  preselectedSensors: string;
  unitId: number;
  viewCount = 0;
  data = [];
  time = [];
  from: Date;
  to: Date;
  today: Date;
  sensorGroups = [];
  selectedSensors = [];
  sensors: Sensor[];
  showAggregation = false;
  aggregationFunction: AggregationModel[];
  selectedAggregationFunction = 'HOUR';

  constructor(
    private activatedRoute: ActivatedRoute,
    private analyticsService: AnalyticsService,
    private sensorService: SensorsService,
    private toastService: ToastService
  ) {
    this.unitId = parseInt(this.activatedRoute.snapshot.paramMap.get('unitId'), 10);
    this.aggregationFunction = [
      {name: 'Hour', code: 'HOUR'},
      {name: 'Day', code: 'DAY'},
      {name: 'Month', code: 'MONTH'},
      {name: 'Year', code: 'YEAR'}
    ];
    this.today = moment().toDate();
    this.sensorService.getUnitSensors({unit_id: this.unitId}).subscribe(
      sensors => {
        this.sensors = sensors;
        if (sensors) {
          sensors.forEach(sensor => {
            const sensorType = sensor.sensorId.toString().slice(0, 5);
            if (!this.sensorGroups.some(group => group === sensorType)) {
              this.sensorGroups.push(sensorType);
            }
            if (!this.selectedSensors.some(sens => sens.toString().slice(0, 5) === sensorType)) {
              this.selectedSensors.push(sensor.sensorId);
            }
          })
        }
      }
    )
  }

  ngOnInit(): void {
    setTimeout(() => {
      this.showGraph();
    }, 0);
  }

  showGraph() {
    const range: Date[] = [moment().subtract(6, 'months').toDate(), moment().toDate()];

    if (this.from && !this.to || !this.from && this.to) {
      return;
    }

    if (this.from && this.to) {
      range[0] = this.from;
      range[1] = this.to;
    }

    if (moment(range[1]).diff(moment(range[0]), 'days') > 7) {
      this.showAggregation = true;
      this.getAnalytics(range);
    } else {
      this.showAggregation = false;
      // this.getObservations(range);
    }
  }

  getAnalytics(range: Date[]) {
    this.analyticsService.getAnalytics$Response({unit_id: this.unitId, sensor_id: null,
      from: moment(range[0]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3),
      to: moment(range[1]).format('yyyy-MM-DD HH:mm:ssZ').slice(0, -3), interval: this.selectedAggregationFunction}).pipe(
      map((response: HttpResponse<any>) => {
        if (response.status === 200) {
          return response.body;
        } else if (response.status === 204) {
          this.toastService.showWarningNoData();
          return response.body;
        } else {
          return false;
        }
      })
    ).subscribe(data => {
        const objectKeys = Object.keys(data);
        for(const key of objectKeys ) {
          if (data[key].data) {
            const view = '#vega_container_' + key.slice(0, 5);
            if (this.selectedSensors.some(sens => sens.toString() === key)) {
              GraphLoader.getGraph(key, data[key].data, data[key].interval, view);
            }
          }
        }
      });
  }
}