Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

33.1 KB
Raw Blame
/*
 * Copyright 2026, OpenRemote Inc.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
import * as echarts from "echarts/core";
import { OrElement } from "@openremote/or-element";
import {
  GridComponent,
  type GridComponentOption,
  DataZoomComponent,
  type DataZoomComponentOption,
  TooltipComponent,
  type TooltipComponentOption,
  type DatasetComponentOption,
} from "echarts/components";
import { LineChart, type LineSeriesOption } from "echarts/charts";
import { UniversalTransition } from "echarts/features";
import { CanvasRenderer } from "echarts/renderers";
import debounce from "lodash.debounce";
import { css, html, type PropertyValues, type TemplateResult, unsafeCSS } from "lit";
import { customElement, property, query } from "lit/decorators.js";
import { i18next, translate } from "@openremote/or-translate";
import {
  AssetModelUtil,
  type Attribute,
  type AttributeRef,
  DatapointInterval,
  type ValueDatapoint,
  type ValueDescriptor,
} from "@openremote/model";
import manager, { DefaultColor2, DefaultColor3, DefaultColor4 } from "@openremote/core";
import "@openremote/or-components/or-panel";
import "@openremote/or-translate";
import "@openremote/or-chart";
import type { OrVaadinSelect } from "@openremote/or-vaadin-components/or-vaadin-select";
import { OrVaadinDateTimePicker } from "@openremote/or-vaadin-components/or-vaadin-date-time-picker";
import type { MDCDataTable } from "@material/data-table";
import { JSONPath } from "jsonpath-plus";
import moment from "moment";
import { isAxiosError } from "@openremote/rest";
import { styleMap } from "lit/directives/style-map.js";
import { when } from "lit/directives/when.js";
import { ifDefined } from "lit/directives/if-defined.js";
declare function require(name: string): any;

echarts.use([GridComponent, TooltipComponent, DataZoomComponent, LineChart, CanvasRenderer, UniversalTransition]);

export class OrAttributeHistoryEvent extends CustomEvent<OrAttributeHistoryEventDetail> {
  public static readonly NAME = "or-attribute-history-event";

  constructor(value?: any, previousValue?: any) {
    super(OrAttributeHistoryEvent.NAME, {
      detail: {
        value,
        previousValue,
      },
      bubbles: true,
      composed: true,
    });
  }
}

export interface OrAttributeHistoryEventDetail {
  value?: any;
  previousValue?: any;
}

declare global {
  export interface HTMLElementEventMap {
    [OrAttributeHistoryEvent.NAME]: OrAttributeHistoryEvent;
  }
}

export type TableColumnType = "timestamp" | "prop";

export interface TableColumnConfig {
  type?: TableColumnType;
  header?: string;
  numeric?: boolean;
  path?: string;
  stringify?: boolean;
  styles?: { [style: string]: string };
  headerStyles?: { [style: string]: string };
  contentProvider?: (
    datapoint: ValueDatapoint<any>,
    value: any,
    config: TableColumnConfig
  ) => TemplateResult | any | undefined;
}

export interface AssetTableConfig {
  timestampFormat?: string;
  /* Supports extracting columns automatically from the keys of object data, for strings */
  autoColumns?: boolean;
  columns?: TableColumnConfig[];
  styles?: { [style: string]: string };
}

export interface TableConfig {
  default?: AssetTableConfig;
  assetTypes?: {
    [assetType: string]: {
      attributeNames?: { [attributeName: string]: AssetTableConfig };
      attributeValueTypes?: { [attributeValueType: string]: AssetTableConfig };
    };
  };
  attributeNames?: { [attributeName: string]: AssetTableConfig };
  attributeValueTypes?: { [attributeValueType: string]: AssetTableConfig };
}

export interface ChartConfig {
  xLabel?: string;
  yLabel?: string;
}

export interface HistoryConfig {
  table?: TableConfig;
  chart?: ChartConfig;
}

export type ECAttributeHistoryOption = echarts.ComposeOption<
  LineSeriesOption | TooltipComponentOption | GridComponentOption | DatasetComponentOption | DataZoomComponentOption
>;

// TODO: Add webpack/rollup to build so consumers aren't forced to use the same tooling
const tableStyle = require("@material/data-table/dist/mdc.data-table.css");

// language=CSS
const style = css`
  :host {
    --internal-or-attribute-history-background-color: var(
      --or-attribute-history-background-color,
      var(--or-app-color2, ${unsafeCSS(DefaultColor2)})
    );
    --internal-or-attribute-history-text-color: var(
      --or-attribute-history-text-color,
      var(--or-app-color3, ${unsafeCSS(DefaultColor3)})
    );
    --internal-or-attribute-history-controls-margin: var(--or-attribute-history-controls-margin, 10px 0);
    --internal-or-attribute-history-controls-justify-content: var(
      --or-attribute-history-controls-justify-content,
      flex-end
    );
    --internal-or-attribute-history-graph-fill-color: var(
      --or-attribute-history-graph-fill-color,
      var(--or-app-color4, ${unsafeCSS(DefaultColor4)})
    );
    --internal-or-attribute-history-graph-fill-opacity: var(--or-attribute-history-graph-fill-opacity, 0.25);
    --internal-or-attribute-history-graph-line-color: var(
      --or-attribute-history-graph-line-color,
      var(--or-app-color4, ${unsafeCSS(DefaultColor4)})
    );
    --internal-or-attribute-history-graph-point-color: var(
      --or-attribute-history-graph-point-color,
      var(--or-app-color4, ${unsafeCSS(DefaultColor4)})
    );
    --internal-or-attribute-history-graph-point-border-color: var(
      --or-attribute-history-graph-point-border-color,
      var(--or-app-color4, ${unsafeCSS(DefaultColor4)})
    );
    --internal-or-attribute-history-graph-point-radius: var(--or-attribute-history-graph-point-radius, 2);
    --internal-or-attribute-history-graph-point-hit-radius: var(--or-attribute-history-graph-point-hit-radius, 20);
    --internal-or-attribute-history-graph-point-border-width: var(--or-attribute-history-graph-point-border-width, 2);
    --internal-or-attribute-history-graph-point-hover-color: var(
      --or-attribute-history-graph-point-hover-color,
      var(--or-app-color4, ${unsafeCSS(DefaultColor4)})
    );
    --internal-or-attribute-history-graph-point-hover-border-color: var(
      --or-attribute-history-graph-point-hover-border-color,
      var(--or-app-color4, ${unsafeCSS(DefaultColor4)})
    );
    --internal-or-attribute-history-graph-point-hover-radius: var(--or-attribute-history-graph-point-hover-radius, 4);
    --internal-or-attribute-history-graph-point-hover-border-width: var(
      --or-attribute-history-graph-point-hover-border-width,
      2
    );
    display: block;
  }

  :host([hidden]) {
    display: none;
  }

  #container {
    position: relative;
    display: flex;
    min-width: 0;
    width: 100%;
    height: 100%;
    flex-direction: column;
  }

  #msg {
    height: 100%;
    width: 100%;
    justify-content: center;
    align-items: center;
    text-align: center;
  }

  #msg:not([hidden]) {
    display: flex;
  }

  #controls {
    display: flex;
    flex-wrap: wrap;
    justify-content: var(--internal-or-attribute-history-controls-justify-content);
    margin: var(--internal-or-attribute-history-controls-margin);
    flex-direction: row;
  }

  #time-picker {
    width: 130px;
    padding: 0 5px;
  }

  #ending-controls {
    max-width: 100%;
    display: flex;
    flex-wrap: wrap;
    align-items: end;
    gap: 5px;
  }

  #ending-controls > * {
    padding: 0 3px;
  }

  #ending-controls > or-vaadin-date-time-picker::part(label) {
    padding-bottom: 0.5em;
  }

  #ending-date {
    width: 280px;
    padding-left: 5px;
  }

  #chart {
    width: 100%;
    height: 100%;
  }

  #chart-container {
    position: relative;
    min-height: 350px;
  }

  #table-container {
    height: 100%;
    min-height: 250px;
  }

  #table {
    width: 100%;
    margin-bottom: 10px;
  }

  #table > table {
    width: 100%;
    table-layout: fixed;
  }

  #table th,
  #table td {
    overflow: hidden;
    white-space: nowrap;
    text-overflow: ellipsis;
  }
`;

@customElement("or-attribute-history")
export class OrAttributeHistory extends translate(i18next)(OrElement) {
  public static DEFAULT_TIMESTAMP_FORMAT = "L HH:mm:ss";

  static get styles() {
    return [
      css`
        ${unsafeCSS(tableStyle)}
      `,
      style,
    ];
  }

  @property({ type: String })
  public assetType?: string;

  @property({ type: String })
  public assetId?: string;

  @property({ type: Object })
  public attribute?: Attribute<any>;

  @property({ type: Object })
  public attributeRef?: AttributeRef;

  @property({ type: String })
  public period: moment.unitOfTime.Base = "day";

  @property({ type: Number })
  public toTimestamp?: Date;

  @property({ type: Object })
  public config?: HistoryConfig;

  @property()
  protected _loading: boolean = false;

  @property()
  protected _data?: ValueDatapoint<any>[];

  @property()
  protected _tableTemplate?: TemplateResult;

  @query("#chart")
  protected _chartElem!: HTMLDivElement;

  protected _chartOptions: ECAttributeHistoryOption = {};
  @query("#table")
  protected _tableElem!: HTMLDivElement;

  protected _table?: MDCDataTable;
  protected _chart?: echarts.ECharts;
  protected _type?: ValueDescriptor;
  protected _style!: CSSStyleDeclaration;
  protected _error?: string;
  protected _startOfPeriod?: number;
  protected _endOfPeriod?: number;
  protected _queryStartOfPeriod?: number;
  protected _queryEndOfPeriod?: number;
  protected _updateTimestampTimer?: number;
  protected _dataAbortController?: AbortController;
  protected _zoomChanged: boolean = false;
  protected _zoomReset: boolean = false;
  protected _dataFirstLoaded: boolean = false;

  connectedCallback() {
    super.connectedCallback();
    this._style = window.getComputedStyle(this);
  }

  disconnectedCallback(): void {
    super.disconnectedCallback();
    this._cleanup();
  }

  shouldUpdate(_changedProperties: PropertyValues): boolean {
    const reloadData =
      _changedProperties.has("period") || _changedProperties.has("toTimestamp") || _changedProperties.has("attribute");

    if (this._dataFirstLoaded && !_changedProperties.get("_loading") && !reloadData) {
      return false;
    }

    if (!this.toTimestamp) {
      this.toTimestamp = this._getDefaultDate();
      return false;
    }

    if (_changedProperties.has("attribute")) {
      this._cleanup();
    }

    if (!this._type && this.attribute) {
      this._type = AssetModelUtil.getValueDescriptor(this.attribute.type) || {};
    }

    if (reloadData) {
      this._type = undefined;
      this._data = undefined;
      this._loadData();
      this._zoomReset = true; // Flag to avoid retrigger of loadData from zoom eventlistener triggered by next line.
      this._chart?.dispatchAction({ type: "dataZoom", start: 0, end: 100 });
    }

    return super.shouldUpdate(_changedProperties);
  }

  render() {
    const isChart = this._type && (this._type.jsonType === "number" || this._type.jsonType === "boolean");
    const disabled = !this._type;
    const periodOptions = this._getPeriodOptions().map((o) => ({ value: o, label: i18next.t(o) }));

    return html`
      <div id="container">
        <div id="controls">
          <or-vaadin-select
            id="time-picker"
            value=${this.period}
            .items=${periodOptions}
            ?disabled=${disabled}
            @change=${(ev: CustomEvent) => (this.period = (ev.currentTarget as OrVaadinSelect).value as any)}
          >
            <or-translate slot="label" value="timeframe"></or-translate>
          </or-vaadin-select>
          <div id="ending-controls">
            <or-vaadin-date-time-picker
              id="ending-date"
              value=${ifDefined(OrVaadinDateTimePicker.getLocalizedISOString(this.toTimestamp))}
              @change=${(ev: CustomEvent) => this._updateTimestamp(new Date((ev.currentTarget as OrVaadinDateTimePicker).value))}
            >
              <or-translate slot="label" value="ending"></or-translate>
            </or-vaadin-date-time-picker>
            <or-vaadin-button
              class="button-icon"
              theme="icon"
              ?disabled=${disabled}
              @click=${() => this._updateTimestamp(this.toTimestamp!, false, 0)}
            >
              <or-icon icon="chevron-left"></or-icon>
            </or-vaadin-button>
            <or-vaadin-button
              theme="icon"
              ?disabled=${disabled}
              @click=${() => this._updateTimestamp(this.toTimestamp!, true, 0)}
            >
              <or-icon icon="chevron-right"></or-icon>
            </or-vaadin-button>
            <or-vaadin-button
              theme="icon"
              ?disabled=${disabled}
              @click=${() => this._updateTimestamp(this._getDefaultDate())}
            >
              <or-icon icon="chevron-double-right"></or-icon>
            </or-vaadin-button>
          </div>
        </div>

        ${when(
          !this._type,
          () => html`
            <div id="msg">
              <or-translate value="invalidAttribute"></or-translate>
            </div>
          `,
          () =>
            when(
              this._error,
              () => html`
                <div id="msg">
                  <or-translate .value="${this._error}"></or-translate>
                </div>
              `,
              () =>
                when(
                  isChart,
                  () => html`
                    ${when(
                      this._loading && !this._data,
                      () => html`
                        <or-loading-indicator style="position: absolute; top: 50%; left: 50%;"></or-loading-indicator>
                      `
                    )}
                    <div id="chart-container" style="${this._loading ? "opacity: 0.7" : undefined}">
                      <div id="chart"></div>
                    </div>
                  `,
                  () => html`
                    <div id="table-container">
                      ${when(
                        this._loading,
                        () => html` <or-loading-indicator></or-loading-indicator> `,
                        () => this._tableTemplate
                      )}
                    </div>
                  `
                )
            )
        )}
      </div>
    `;
  }

  // Method that is executed during an update, to compute (additional) values before rendering.
  // Used instead of updated() to prevent a second render when properties get changed.
  willUpdate(changedProperties: PropertyValues) {
    super.willUpdate(changedProperties);

    if (!this._type || !this._data) {
      return;
    }

    const isChart = this._type && (this._type.jsonType === "number" || this._type.jsonType === "boolean");

    if (isChart) {
      const data = this._data.map((point) => [point.x, point.y]);

      if (!this._chart) {
        let bgColor = this._style.getPropertyValue("--internal-or-attribute-history-graph-fill-color").trim();
        const opacity = Number(
          this._style.getPropertyValue("--internal-or-attribute-history-graph-fill-opacity").trim()
        );
        if (!isNaN(opacity)) {
          if (bgColor.startsWith("#") && (bgColor.length === 4 || bgColor.length === 7)) {
            bgColor +=
              bgColor.length === 4
                ? Math.round(opacity * 255)
                    .toString(16)
                    .substr(0, 1)
                : Math.round(opacity * 255).toString(16);
          } else if (bgColor.startsWith("rgb(")) {
            bgColor = bgColor.substring(0, bgColor.length - 1) + opacity;
          }
        }

        this._chartOptions = {
          animation: false,
          grid: {
            show: true,
            backgroundColor: this._style.getPropertyValue("--internal-or-asset-viewer-panel-color"),
            borderColor: this._style.getPropertyValue("--internal-or-attribute-history-text-color"),
            left: 4,
            right: 4,
            top: 10,
            containLabel: true,
          },
          backgroundColor: this._style.getPropertyValue("--internal-or-asset-viewer-panel-color"),
          tooltip: {
            trigger: "axis",
            appendTo: "body",
            confine: true,
            extraCssText: "white-space: normal; word-wrap: break-word;",
            axisPointer: { type: "cross" },
            formatter: (params: any) => {
              if (Array.isArray(params) && params.length > 0) {
                const yValue = params[0].value[1];
                return yValue !== undefined ? yValue.toString() : "";
              }
              return "";
            },
          },
          xAxis: {
            type: "time",
            axisLine: {
              onZero: false,
              lineStyle: { color: this._style.getPropertyValue("--internal-or-attribute-history-text-color") },
            },
            splitLine: { show: true },
            min: this._startOfPeriod,
            max: this._endOfPeriod,
            axisLabel: {
              hideOverlap: true,
              fontSize: 10,
              formatter: {
                year: "1-{MMM}-{yyyy}",
                month: "1-{MMM}-'{yy}",
                day: "{d}-{MMM}",
                hour: "{HH}:{mm}",
                minute: "{HH}:{mm}",
                second: "{HH}:{mm}:{ss}",
                millisecond: "{d}-{MMM} {HH}:{mm}",
                // @ts-ignore
                none: "{MMM}-{dd} {HH}:{mm}",
              },
            },
          },
          yAxis: {
            type: "value",
            axisLine: {
              lineStyle: { color: this._style.getPropertyValue("--internal-or-attribute-history-text-color") },
            },
            boundaryGap: ["10%", "10%"],
            scale: true,
          },
          dataZoom: [
            {
              type: "inside",
              start: 0,
              end: 100,
            },
            {
              type: "slider",
              start: 0,
              end: 100,
              showDataShadow: false,
              backgroundColor: bgColor,
              fillerColor: bgColor,
              moveHandleStyle: {
                color: this._style.getPropertyValue("--internal-or-attribute-history-graph-fill-color"),
              },
              emphasis: {
                moveHandleStyle: {
                  color: this._style.getPropertyValue("--internal-or-attribute-history-graph-fill-color"),
                },
                handleLabel: {
                  show: true,
                },
              },
              handleLabel: {
                show: false,
              },
              showDetail: false,
            },
          ],
          series: [
            {
              name: "timestamp    value",
              type: "line",
              showSymbol: data.length <= 30,
              data,
              sampling: "lttb",
              itemStyle: {
                color: this._style.getPropertyValue("--internal-or-attribute-history-graph-line-color"),
              },
            },
          ],
        };
        // Initialize echarts instance
        this._chart = echarts.init(this._chartElem);
        // Set chart options to default
        this._chart.setOption(this._chartOptions);
        // Make chart size responsive
        window.addEventListener("resize", () => this._chart?.resize());
        const resizeObserver = new ResizeObserver(() => this._chart?.resize());
        resizeObserver.observe(this._chartElem);
        // Add event listener for zooming
        this._chart!.on(
          "datazoom",
          debounce((params: any) => {
            this._onZoomChange(params);
          }, 750)
        );
      } else {
        if (changedProperties.has("_data")) {
          // Update chart to data from set period
          this._updateChartData();
        }
      }
    } else {
      // Updating the table template before render, if necessary, to prevent additional update
      if (!this._tableTemplate || changedProperties.has("_data")) {
        this._tableTemplate = this._getTableTemplate();
      }
    }

    this.onCompleted().then(() => {
      this.dispatchEvent(new OrAttributeHistoryEvent("rendered"));
    });
  }

  async onCompleted() {
    await this.updateComplete;
  }

  protected _cleanup() {
    this._tableTemplate = undefined;

    if (this._chart) {
      this._chart.dispose();
      this._chart = undefined;
    }
    if (this._table) {
      this._table.destroy();
      this._table = undefined;
    }
  }

  protected _getTableTemplate(): TemplateResult {
    const assetType = this.assetType;
    const attributeName = this.attribute
      ? this.attribute.name!
      : this.attributeRef
        ? this.attributeRef!.name!
        : undefined;
    const attributeType = this.attribute ? (this.attribute.type as string) : undefined;

    if (!this._data || !assetType || !attributeName || !attributeType) {
      return html``;
    }

    let config: AssetTableConfig = {
      autoColumns: true,
    };

    if (this.config && this.config.table) {
      if (
        this.config.table.assetTypes &&
        this.config.table.assetTypes[assetType] &&
        ((this.config.table.assetTypes[assetType].attributeNames &&
          this.config.table.assetTypes[assetType].attributeNames![attributeName]) ||
          (attributeType &&
            this.config.table.assetTypes[assetType].attributeValueTypes &&
            this.config.table.assetTypes[assetType].attributeValueTypes![attributeType]))
      ) {
        config =
          (this.config.table.assetTypes[assetType].attributeNames &&
            this.config.table.assetTypes[assetType].attributeNames![attributeName]) ||
          this.config.table.assetTypes[assetType].attributeValueTypes![attributeType!];
      } else if (this.config.table.attributeNames && this.config.table.attributeNames[attributeName]) {
        config = this.config.table.attributeNames[attributeName];
      } else if (
        attributeType &&
        this.config.table.attributeValueTypes &&
        this.config.table.attributeValueTypes[attributeType]
      ) {
        config = this.config.table.attributeValueTypes[attributeType];
      } else if (this.config.table.default) {
        config = this.config.table.default;
      }

      if (!config) {
        config = {
          autoColumns: true,
        };
      }
    }

    if (config.autoColumns) {
      config = { ...config };

      config.columns = [];

      const dp = this._data!.find((dp) => dp.y !== undefined);
      if (dp) {
        if (typeof dp.y === "object" && !Array.isArray(dp.y)) {
          config.columns = Object.entries(dp.y as {}).map(([prop, value]) => {
            return {
              type: "prop",
              header: prop,
              path: "$.['" + prop + "']",
              stringify: typeof value === "object",
              numeric: !isNaN(Number(value)),
            } as TableColumnConfig;
          });
        } else {
          config.columns.push({
            type: "prop",
            header: "value",
            stringify: typeof dp.y === "object",
            numeric: typeof dp.y === "number",
          });
        }
      }

      if (config.columns.length > 0) {
        config.columns.push({
          header: "timestamp",
          type: "timestamp",
        });
      }
    }

    if (config.columns && config.columns.length > 0) {
      return html`
        <div id="table" class="mdc-data-table">
          <table
            style="${config.styles ? styleMap(config.styles) : ""}"
            class="mdc-data-table__table"
            aria-label="${attributeName + " history"}"
          >
            <thead>
              <tr class="mdc-data-table__header-row">
                ${config.columns.map((c) => html`<th style="${c.headerStyles ? styleMap(c.headerStyles) : ""}" class="mdc-data-table__header-cell ${c.numeric ? "mdc-data-table__header-cell--numeric" : ""}" role="columnheader" scope="col"><or-translate value="${c.header}"></or-translate></th>`)}
              </tr>
            </thead>
            <tbody class="mdc-data-table__content">
              ${this._data!.map((dp) => {
                return html`
                  <tr class="mdc-data-table__row">
                    ${config.columns!.map((c) => {
                      const value = this._getCellValue(dp, c, config.timestampFormat);
                      return html`<td
                        style="${c.styles ? styleMap(c.styles) : ""}"
                        class="mdc-data-table__cell ${c.numeric ? "mdc-data-table__cell--numeric" : ""}"
                        title="${value}"
                      >
                        ${value}
                      </td>`;
                    })}
                  </tr>
                `;
              })}
            </tbody>
          </table>
        </div>
      `;
    }

    console.warn("OrAttributeHistory: No columns configured so nothing to show");
    return html``;
  }

  protected _getCellValue(
    datapoint: ValueDatapoint<any>,
    config: TableColumnConfig,
    timestampFormat: string | undefined
  ): TemplateResult | string | undefined {
    switch (config.type) {
      case "timestamp":
        const value = moment(datapoint.x).format(timestampFormat || OrAttributeHistory.DEFAULT_TIMESTAMP_FORMAT);
        if (config && config.contentProvider) {
          const template = config.contentProvider(datapoint, value, config);
          if (template) {
            return template;
          }
        }
        return value;
      case "prop":
        let data = datapoint.y;

        if (config.path) {
          data = JSONPath({
            path: config.path,
            json: datapoint.y,
            wrap: false,
          });
          // TODO: Remove once JSONPath updated https://github.com/s3u/JSONPath/issues/86)
          if (Array.isArray(data) && data.length === 1) {
            data = data[0];
          }
        }

        if (config && config.contentProvider) {
          const template = config.contentProvider(datapoint, data, config);
          if (template) {
            return template;
          }
        }

        if (config.stringify) {
          return JSON.stringify(data);
        }

        return data;
    }
  }

  protected _getIntervalOptions(): [string, string][] {
    return [
      DatapointInterval.HOUR,
      DatapointInterval.DAY,
      DatapointInterval.WEEK,
      DatapointInterval.MONTH,
      DatapointInterval.YEAR,
    ].map((interval) => {
      return [interval, i18next.t(interval.toLowerCase())];
    });
  }

  protected _getPeriodOptions() {
    return [
      DatapointInterval.HOUR.toLowerCase(),
      DatapointInterval.DAY.toLowerCase(),
      DatapointInterval.WEEK.toLowerCase(),
      DatapointInterval.MONTH.toLowerCase(),
      DatapointInterval.YEAR.toLowerCase(),
    ];
  }

  protected async _loadData() {
    if (
      (this._data && !this._zoomChanged) ||
      !this.assetType ||
      !this.assetId ||
      (!this.attribute && !this.attributeRef) ||
      !this.period ||
      !this.toTimestamp
    ) {
      return;
    }

    // If a new requests comes in, we override it with this one using AbortController.
    if (this._loading) {
      if (this._dataAbortController) {
        this._dataAbortController.abort("Data request overridden");
        delete this._dataAbortController;
      } else {
        return;
      }
    }

    this._error = undefined;
    this._loading = true;

    const assetId = this.assetId!;
    const attributeName = this.attribute ? this.attribute.name! : this.attributeRef!.name!;
    this._dataAbortController = new AbortController();

    try {
      if (!this._type) {
        let attr = this.attribute;

        if (!attr) {
          const response = await manager.rest.api.AssetResource.queryAssets(
            {
              ids: [assetId],
              select: {
                attributes: [attributeName],
              },
            },
            { signal: this._dataAbortController.signal }
          );
          if (response.status === 200 && response.data.length > 0) {
            attr = response.data[0].attributes ? response.data[0].attributes[attributeName] : undefined;
          }
        }

        if (attr) {
          this._type = AssetModelUtil.getValueDescriptor(attr.type) || {};
        }
      }

      if (!this._type || !this._type.name) {
        this._loading = false;
        return;
      }

      let interval: DatapointInterval = DatapointInterval.HOUR;

      switch (this.period) {
        case "hour":
          interval = DatapointInterval.MINUTE;
          break;
        case "day":
          interval = DatapointInterval.HOUR;
          break;
        case "week":
          interval = DatapointInterval.HOUR;
          break;
        case "month":
          interval = DatapointInterval.DAY;
          break;
        case "year":
          interval = DatapointInterval.MONTH;
          break;
      }

      const lowerCaseInterval = interval.toLowerCase();

      if (!this._zoomChanged) {
        // Set start and end of period based on the selected period
        this._startOfPeriod = moment(this.toTimestamp)
          .subtract(1, this.period)
          .startOf(lowerCaseInterval as moment.unitOfTime.StartOf)
          .add(1, lowerCaseInterval as moment.unitOfTime.Base)
          .toDate()
          .getTime();
        this._endOfPeriod = moment(this.toTimestamp)
          .startOf(lowerCaseInterval as moment.unitOfTime.StartOf)
          .add(1, lowerCaseInterval as moment.unitOfTime.Base)
          .toDate()
          .getTime();
        this._queryStartOfPeriod = this._startOfPeriod;
        this._queryEndOfPeriod = this._endOfPeriod;
      }

      const isChart = this._type && (this._type.jsonType === "number" || this._type.jsonType === "boolean");
      let response;
      if (isChart) {
        response = await manager.rest.api.AssetDatapointResource.getDatapoints(
          assetId,
          attributeName,
          {
            type: "lttb",
            fromTimestamp: this._queryStartOfPeriod,
            toTimestamp: this._queryEndOfPeriod,
            amountOfPoints: 100,
          },
          { signal: this._dataAbortController.signal }
        );
      } else {
        response = await manager.rest.api.AssetDatapointResource.getDatapoints(
          assetId,
          attributeName,
          {
            type: "all",
            fromTimestamp: this._startOfPeriod,
            toTimestamp: this._endOfPeriod,
          },
          { signal: this._dataAbortController.signal }
        );
      }
      this._loading = false;
      this._zoomChanged = false;

      if (response.status === 200) {
        this._data = response.data
          .filter((value) => value.y !== null && value.y !== undefined)
          .map((point) => ({ x: point.x, y: point.y }) as ValueDatapoint<any>);
      }
    } catch (ex) {
      console.error(ex);
      if ((ex as Error)?.message === "canceled") {
        return; // If request has been canceled (using AbortController); return, and prevent _loading is set to false.
      }
      this._loading = false;

      if (isAxiosError(ex)) {
        if (ex.message.includes("timeout")) {
          this._error = "noAttributeDataTimeout";
          return;
        } else if (ex.response?.status === 413) {
          this._error = "datapointRequestTooLarge";
          return;
        }
      }
      this._error = "errorOccurred";
    }
  }

  protected _updateTimestamp(timestamp: Date, forward?: boolean, timeout = 300) {
    if (this._updateTimestampTimer) {
      window.clearTimeout(this._updateTimestampTimer);
      this._updateTimestampTimer = undefined;
    }
    this._updateTimestampTimer = window.setTimeout(() => {
      const newMoment = moment(timestamp);

      if (forward !== undefined) {
        newMoment.add(forward ? 1 : -1, this.period);
      }
      this.toTimestamp = newMoment.toDate();
    }, timeout);
  }

  protected _onZoomChange(params: any) {
    if (!this._zoomReset) {
      this._zoomChanged = true;
      const { start: zoomStartPercentage, end: zoomEndPercentage } = params.batch?.[0] ?? params; // Events triggered by scroll and zoombar return different structures
      // Define the start and end of the period based on the zoomed area
      this._queryStartOfPeriod =
        this._startOfPeriod! + ((this._endOfPeriod! - this._startOfPeriod!) * zoomStartPercentage) / 100;
      this._queryEndOfPeriod =
        this._startOfPeriod! + ((this._endOfPeriod! - this._startOfPeriod!) * zoomEndPercentage) / 100;

      this._loadData().then(() => {
        this._updateChartData();
      });
    }
    this._zoomReset = false;
  }

  protected _updateChartData() {
    const data = this._data!.map((point) => [point.x, point.y]);

    this._chart!.setOption({
      xAxis: {
        min: this._startOfPeriod,
        max: this._endOfPeriod,
      },
      series: [
        {
          data,
          showSymbol: data.length <= 30,
        },
      ],
    });
  }

  protected _getDefaultDate() {
    const date = new Date();
    date.setHours(date.getHours() + 1, 0, 0, 0); // Round to the beginning of the next hour
    return date;
  }
}