feat(asset): add the query type and group by buttons for calibration forecast

src/datasources/asset/AssetDataSource.test.ts

@@ -9,10 +9,13 @@ import {
 } from "test/fixtures";
 import { AssetDataSource } from "./AssetDataSource";
 import {
+  AssetCalibrationForecastGroupByType,
+  AssetCalibrationForecastQuery,
+  AssetMetadataQuery,
   AssetPresenceWithSystemConnectionModel,
-  AssetQuery,
   AssetQueryType,
   AssetsResponse,
+  CalibrationForecastResponse,
 } from "./types";
 
 let ds: AssetDataSource, backendSrv: MockProxy<BackendSrv>
@@ -208,19 +211,45 @@ const assetsResponseMock: AssetsResponse =
     "totalCount": 4
   }
 
-const assetUtilizationQueryMock: AssetQuery = {
-  type: AssetQueryType.Metadata,
+const calibrationForecastResponseMock: CalibrationForecastResponse = {
+  calibrationSummary: {
+    totalAssets: 10,
+    assetsApproachingCalibration: 6,
+    assetsPastDueCalibration: 4,
+  },
+  calibrationForecast: {
+    columns: [
+      { name: 'Month', values: ['2024-03', '2024-04', '2024-05', '2024-06', '2024-07', '2024-08', '2024-09', '2024-10', '2024-11', '2024-12'] },
+      { name: 'Approaching Calibration', values: [1, 2, 3, 4, 5, 6, 5, 4, 3, 2] },
+      { name: 'Past Due Calibration', values: [0, 1, 2, 3, 4, 4, 3, 2, 1, 0] },
+    ],
+  }
+}
+
+const assetMetadataQueryMock: AssetMetadataQuery = {
+  queryKind: AssetQueryType.Metadata,
   workspace: '',
   refId: '',
-  minionIds: ['123'],
+  minionIds: ['123']
+}
+
+const calibrationForecastQueryMock: AssetCalibrationForecastQuery = {
+  queryKind: AssetQueryType.CalibrationForecast,
+  refId: null!,
+  groupBy: [AssetCalibrationForecastGroupByType.Month]
 }
 
-const buildQuery = getQueryBuilder<AssetQuery>()({
-  type: AssetQueryType.Metadata,
+const buildMetadataQuery = getQueryBuilder<AssetMetadataQuery>()({
+  queryKind: AssetQueryType.Metadata,
   workspace: '',
   minionIds: [],
 });
 
+const buildCalibrationForecastQuery = getQueryBuilder<AssetCalibrationForecastQuery>()({
+  queryKind: AssetQueryType.CalibrationForecast,
+  groupBy: [AssetCalibrationForecastGroupByType.Month]
+});
+
 describe('testDatasource', () => {
   test('returns success', async () => {
     backendSrv.fetch
@@ -247,16 +276,34 @@ describe('queries', () => {
       .calledWith(requestMatching({ url: '/niapm/v1/query-assets' }))
       .mockReturnValue(createFetchResponse(assetsResponseMock as AssetsResponse))
 
-    const result = await ds.query(buildQuery(assetUtilizationQueryMock))
+    const result = await ds.query(buildMetadataQuery(assetMetadataQueryMock))
 
     expect(result.data).toMatchSnapshot()
   })
 
-  test('handles query error', async () => {
+  test('handles metadata query error', async () => {
     backendSrv.fetch
       .calledWith(requestMatching({ url: '/niapm/v1/query-assets' }))
       .mockReturnValue(createFetchError(418))
 
-    await expect(ds.query(buildQuery(assetUtilizationQueryMock))).rejects.toThrow()
+    await expect(ds.query(buildMetadataQuery(assetMetadataQueryMock))).rejects.toThrow()
+  })
+
+  test('run calibration forecast query', async () => {
+    backendSrv.fetch
+      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
+      .mockReturnValue(createFetchResponse(calibrationForecastResponseMock as CalibrationForecastResponse))
+
+    const result = await ds.query(buildCalibrationForecastQuery(calibrationForecastQueryMock))
+
+    expect(result.data).toMatchSnapshot()
+  })
+
+  test('handles calibration forecast query error', async () => {
+    backendSrv.fetch
+      .calledWith(requestMatching({ url: '/niapm/v1/assets/calibration-forecast' }))
+      .mockReturnValue(createFetchError(418))
+
+    await expect(ds.query(buildCalibrationForecastQuery(calibrationForecastQueryMock))).rejects.toThrow()
   })
 })

src/datasources/asset/AssetDataSource.ts

@@ -7,10 +7,14 @@ import {
 import { BackendSrv, getBackendSrv, getTemplateSrv, TemplateSrv } from '@grafana/runtime';
 import { DataSourceBase } from 'core/DataSourceBase';
 import {
+  AssetCalibrationForecastQuery,
   AssetFilterProperties,
-  AssetModel, AssetQuery,
+  AssetMetadataQuery,
+  AssetModel,
+  AssetQuery,
   AssetQueryType,
   AssetsResponse,
+  CalibrationForecastResponse,
 } from './types';
 import { getWorkspaceName, replaceVariables } from "../../core/utils";
 import { SystemMetadata } from "../system/types";
@@ -28,16 +32,24 @@ export class AssetDataSource extends DataSourceBase<AssetQuery> {
   baseUrl = this.instanceSettings.url + '/niapm/v1';
 
   defaultQuery = {
-    type: AssetQueryType.Metadata,
+    queryKind: AssetQueryType.Metadata,
     workspace: '',
     minionIds: [],
+    groupBy: []
   };
 
   async runQuery(query: AssetQuery, options: DataQueryRequest): Promise<DataFrameDTO> {
-    return await this.processMetadataQuery(query)
+    switch (query.queryKind) {
+      case AssetQueryType.Metadata:
+        return await this.processMetadataQuery(query as AssetMetadataQuery); 
+      case AssetQueryType.CalibrationForecast:
+        return await this.processCalibrationForecastQuery(query as AssetCalibrationForecastQuery, options);
+      default:
+        throw new Error(`Unknown query type: ${query.queryKind}`);
+    }
   }
 
-  async processMetadataQuery(query: AssetQuery) {
+  async processMetadataQuery(query: AssetMetadataQuery) {
     const result: DataFrameDTO = { refId: query.refId, fields: [] };
     const minionIds = replaceVariables(query.minionIds, this.templateSrv);
     let workspaceId = this.templateSrv.replace(query.workspace);
@@ -70,6 +82,17 @@ export class AssetDataSource extends DataSourceBase<AssetQuery> {
     return result;
   }
 
+  async processCalibrationForecastQuery(query: AssetCalibrationForecastQuery, options: DataQueryRequest) {
+    const result: DataFrameDTO = { refId: query.refId, fields: [] };
+    const from = options.range!.from.toISOString();
+    const to = options.range!.to.toISOString();
+
+    const calibrationForecastResponse: CalibrationForecastResponse = await this.queryCalibrationForecast(query.groupBy, from, to);
+
+    result.fields = calibrationForecastResponse.calibrationForecast.columns || [];
+
+    return result;
+  }
 
   shouldRunQuery(_: AssetQuery): boolean {
     return true;
@@ -85,6 +108,16 @@ export class AssetDataSource extends DataSourceBase<AssetQuery> {
     }
   }
 
+  async queryCalibrationForecast(groupBy: string[], startDate: string, endDate: string, filter = ''): Promise<CalibrationForecastResponse> {
+    let data = { groupBy, startDate, endDate, filter };
+    try {
+      let response = await this.post<CalibrationForecastResponse>(this.baseUrl + '/assets/calibration-forecast', data);
+      return response;
+    } catch (error) {
+      throw new Error(`An error occurred while querying assets calibration forecast: ${error}`);
+    }
+  }
+
   async querySystems(filter = '', projection = defaultProjection): Promise<SystemMetadata[]> {
     try {
       let response = await this.getSystems({

src/datasources/asset/__snapshots__/AssetDataSource.test.ts.snap

@@ -1,5 +1,60 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`queries run calibration forecast query 1`] = `
+[
+  {
+    "fields": [
+      {
+        "name": "Month",
+        "values": [
+          "2024-03",
+          "2024-04",
+          "2024-05",
+          "2024-06",
+          "2024-07",
+          "2024-08",
+          "2024-09",
+          "2024-10",
+          "2024-11",
+          "2024-12",
+        ],
+      },
+      {
+        "name": "Approaching Calibration",
+        "values": [
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          5,
+          4,
+          3,
+          2,
+        ],
+      },
+      {
+        "name": "Past Due Calibration",
+        "values": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          4,
+          3,
+          2,
+          1,
+          0,
+        ],
+      },
+    ],
+    "refId": "A",
+  },
+]
+`;
+
 exports[`queries run metadata query 1`] = `
 [
   {

src/datasources/asset/components/AssetQueryCalibrationForecastEditor.test.tsx

@@ -0,0 +1,84 @@
+import { screen, waitFor } from '@testing-library/react';
+import { setupRenderer } from '../../../test/fixtures';
+import { SystemMetadata } from '../../system/types';
+import { AssetDataSource } from '../AssetDataSource';
+import { AssetQueryEditor } from './AssetQueryEditor';
+import { AssetCalibrationForecastGroupByType, AssetCalibrationForecastQuery, AssetQueryLabel, AssetQueryType } from '../types';
+import { select } from 'react-select-event';
+
+const fakeSystems: SystemMetadata[] = [
+  {
+    id: '1',
+    state: 'CONNECTED',
+    workspace: '1',
+  },
+  {
+    id: '2',
+    state: 'CONNECTED',
+    workspace: '2',
+  },
+];
+
+class FakeAssetDataSource extends AssetDataSource {
+  querySystems(filter?: string, projection?: string[]): Promise<SystemMetadata[]> {
+    return Promise.resolve(fakeSystems);
+  }
+}
+
+const render = setupRenderer(AssetQueryEditor, FakeAssetDataSource);
+
+it('renders with query type calibration forecast', async () => {
+  render({ queryKind: AssetQueryType.CalibrationForecast } as AssetCalibrationForecastQuery);
+
+  expect(screen.getByRole('radio', { name: AssetQueryLabel.CalibrationForecast })).toBeChecked();
+  const groupBy = screen.getAllByRole('combobox')[0];
+  expect(groupBy).not.toBeNull();
+});
+
+it('renders with query type calibration forecast and updates group by', async () => {
+  const [onChange] = render({
+    queryKind: AssetQueryType.CalibrationForecast,
+    groupBy: [AssetCalibrationForecastGroupByType.Month],
+  } as AssetCalibrationForecastQuery);
+
+  expect(screen.getByRole('radio', { name: AssetQueryLabel.CalibrationForecast })).toBeChecked();
+
+  // User selects group by day
+  const groupBy = screen.getAllByRole('combobox')[0];
+  await select(groupBy, AssetCalibrationForecastGroupByType.Day, { container: document.body });
+  await waitFor(() => {
+    expect(onChange).toHaveBeenCalledWith(
+      expect.objectContaining({ groupBy: [AssetCalibrationForecastGroupByType.Day] })
+    );
+  });
+
+  // User selects group by location
+  await select(groupBy, AssetCalibrationForecastGroupByType.Location, { container: document.body });
+  await waitFor(() => {
+    expect(onChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        groupBy: [AssetCalibrationForecastGroupByType.Location, AssetCalibrationForecastGroupByType.Day],
+      })
+    );
+  });
+
+  // User selects group by location and week, overrides time
+  await select(groupBy, AssetCalibrationForecastGroupByType.Week, { container: document.body });
+  await waitFor(() => {
+    expect(onChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        groupBy: [AssetCalibrationForecastGroupByType.Location, AssetCalibrationForecastGroupByType.Week],
+      })
+    );
+  });
+
+  // User selects group by location and month, overrides time
+  await select(groupBy, AssetCalibrationForecastGroupByType.Month, { container: document.body });
+  await waitFor(() => {
+    expect(onChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        groupBy: [AssetCalibrationForecastGroupByType.Location, AssetCalibrationForecastGroupByType.Month],
+      })
+    );
+  });
+});

src/datasources/asset/components/AssetQueryCalibrationForecastEditor.tsx

@@ -0,0 +1,57 @@
+import { SelectableValue, toOption } from '@grafana/data';
+import { AssetDataSource } from '../AssetDataSource';
+import { AssetCalibrationForecastGroupByType, AssetCalibrationForecastQuery, AssetQuery } from '../types';
+import { InlineField, MultiSelect } from '@grafana/ui';
+import React from 'react';
+import { enumToOptions } from '../../../core/utils';
+import _ from 'lodash';
+
+type Props = {
+  query: AssetCalibrationForecastQuery;
+  handleQueryChange: (value: AssetQuery, runQuery: boolean) => void;
+  datasource: AssetDataSource;
+};
+
+export function QueryCalibrationForecastEditor({ query, handleQueryChange, datasource }: Props) {
+  query = datasource.prepareQuery(query) as AssetCalibrationForecastQuery;
+  const handleGroupByChange = (items?: Array<SelectableValue<string>>): void => {
+    if (!items || _.isEqual(query.groupBy, items)) {
+      return;
+    }
+
+    let groupBy = [];
+    let locationIndex = items.findIndex(item => item.value === AssetCalibrationForecastGroupByType.Location);
+    if (locationIndex !== -1) {
+      groupBy.push(AssetCalibrationForecastGroupByType.Location);
+      items.splice(locationIndex, 1);
+    }
+
+    if (items.length) {
+      groupBy.push(items[items.length - 1].value!);
+    }
+
+    if (!_.isEqual(query.groupBy, groupBy)) {
+      handleQueryChange({ ...query, groupBy: groupBy }, true);
+    }
+  };
+
+  return (
+    <>
+      <InlineField label="Group by" tooltip={tooltips.calibrationForecast.groupBy} labelWidth={22}>
+        <MultiSelect
+          isClearable
+          options={enumToOptions(AssetCalibrationForecastGroupByType)}
+          onChange={handleGroupByChange}
+          width={85}
+          value={query.groupBy.map(toOption) || []}
+        />
+      </InlineField>
+    </>
+  );
+}
+
+const tooltips = {
+  calibrationForecast: {
+    groupBy: `Group the calibration forecast by day, week, month or location. Only one time based grouping is allowed.`
+  },
+};