Users/manisha/use systems cache

src/core/utils.ts

@@ -176,6 +176,35 @@ export async function queryInBatches<T>(
   };
 }
 
+export async function queryUntilComplete<T>(
+  queryRecord: (take: number, continuationToken?: string) => Promise<QueryResponse<T>>,
+  { maxTakePerRequest, requestsPerSecond }: BatchQueryConfig,
+): Promise<QueryResponse<T>> {
+  const data: T[] = [];
+  let token: string | undefined | null;
+
+  do {
+    const start = Date.now();
+
+    for (let i = 0; i < requestsPerSecond; i++) {
+      const response: QueryResponse<T> = await queryRecord(maxTakePerRequest, token!);
+      data.push(...response.data);
+      token = response.continuationToken;
+
+      if (!token) {
+        break;
+      }
+    }
+
+    const elapsed = Date.now() - start;
+    if (token && elapsed < 1000) {
+      await delay(1000 - elapsed);
+    }
+  } while(token);
+
+  return { data, totalCount: data.length };
+}
+
 async function delay(timeout: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, timeout));
 }

src/datasources/work-orders/WorkOrdersDataSource.ts

@@ -2,8 +2,10 @@ import { DataSourceInstanceSettings, DataQueryRequest, DataFrameDTO, FieldType,
 import { BackendSrv, TemplateSrv, getBackendSrv, getTemplateSrv } from '@grafana/runtime';
 import { DataSourceBase } from 'core/DataSourceBase';
 import { WorkOrdersQuery, OutputType, WorkOrderPropertiesOptions, OrderByOptions, WorkOrder, WorkOrderProperties, QueryWorkOrdersRequestBody, WorkOrdersResponse } from './types';
+import { Users } from 'shared/Users';
 
 export class WorkOrdersDataSource extends DataSourceBase<WorkOrdersQuery> {
+  readonly usersObj = new Users(this.instanceSettings, this.backendSrv)
   constructor(
     readonly instanceSettings: DataSourceInstanceSettings,
     readonly backendSrv: BackendSrv = getBackendSrv(),
@@ -57,16 +59,25 @@ export class WorkOrdersDataSource extends DataSourceBase<WorkOrdersQuery> {
       query.descending
     );
 
-    const mappedFields = query.properties?.map(property => {
-      const field = WorkOrderProperties[property];
-      const fieldType = this.isTimeField(field.value) ? FieldType.time : FieldType.string;
-      const fieldName = field.label;
-
-      // TODO: Add mapping for other field types
-      const fieldValue = workOrders.map(data => data[field.field as unknown as keyof WorkOrder]);
-
-      return { name: fieldName, values: fieldValue, type: fieldType };
-    });
+    const mappedFields = await Promise.all(query.properties?.map(async property => {
+        const field = WorkOrderProperties[property];
+        const fieldType = this.isTimeField(field.value) ? FieldType.time : FieldType.string;
+        const fieldName = field.label;
+
+        const fieldValues = await Promise.all(workOrders.map(async workOrder => {
+            switch (field.value) {
+              case WorkOrderPropertiesOptions.ASSIGNED_TO:
+              case WorkOrderPropertiesOptions.CREATED_BY:
+              case WorkOrderPropertiesOptions.REQUESTED_BY:
+              case WorkOrderPropertiesOptions.UPDATED_BY:
+                return await this.getUserName(workOrder[field.field] as string).then(name => name || workOrder[field.field] || '');
+              default:
+                return workOrder[field.field] ?? '';
+            }
+          })
+        )
+        return { name: fieldName, values: fieldValues, type: fieldType };
+      }) ?? [])
 
     return {
       refId: query.refId,
@@ -75,6 +86,15 @@ export class WorkOrdersDataSource extends DataSourceBase<WorkOrdersQuery> {
     };
   }
 
+  async getUserName(userId: string): Promise<string> {
+    if (!userId) {
+      return '';
+    }
+    const usersMap = await this.usersObj.usersMapCache;
+    const userName = usersMap.get(userId);
+    return userName ?? userId;
+  }
+
   async queryWorkordersData(
     filter?: string,
     projection?: string[],

src/datasources/work-orders/components/WorkOrdersQueryEditor.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
 import { QueryEditorProps, SelectableValue } from '@grafana/data';
 import { WorkOrdersDataSource } from '../WorkOrdersDataSource';
 import { OrderBy, OutputType, WorkOrderProperties, WorkOrderPropertiesOptions, WorkOrdersQuery } from '../types';
@@ -11,11 +11,23 @@ import {
   VerticalGroup
 } from '@grafana/ui';
 import './WorkOrdersQueryEditor.scss';
+import { User } from 'shared/types/QueryUsers.types';
 
 type Props = QueryEditorProps<WorkOrdersDataSource, WorkOrdersQuery>;
 
 export function WorkOrdersQueryEditor({ query, onChange, onRunQuery, datasource }: Props) {
   query = datasource.prepareQuery(query);
+  const [users, setUsers] = useState<User[]|null>(null);
+
+  useEffect(() => {
+    const loadUsers = async () => {
+      const usersList = await datasource.usersObj.usersCache;
+      setUsers(usersList);
+    };
+
+    loadUsers();
+  }, [datasource.usersObj]);
+
 
   useEffect(() => {
     handleQueryChange(query, true);
@@ -92,6 +104,7 @@ export function WorkOrdersQueryEditor({ query, onChange, onRunQuery, datasource
             <WorkOrdersQueryBuilder
               filter={query.queryBy} 
               globalVariableOptions={[]}
+              users={users}
               onChange={(event: any) => onQueryByChange(event.detail.linq)}
             ></WorkOrdersQueryBuilder>
           </InlineField>

src/datasources/work-orders/components/query-builder/WorkOrdersQueryBuilder.tsx

@@ -2,25 +2,83 @@ import { SlQueryBuilder } from "core/components/SlQueryBuilder/SlQueryBuilder";
 import { queryBuilderMessages, QueryBuilderOperations } from "core/query-builder.constants";
 import { expressionBuilderCallback, expressionReaderCallback } from "core/query-builder.utils";
 import { QBField, QueryBuilderOption } from "core/types";
-import { WorkOrdersQueryBuilderStaticFields } from "datasources/work-orders/constants/WorkOrdersQueryBuilder.constants";
-import React, { useState, useEffect } from "react";
+import { WorkOrdersQueryBuilderFields, WorkOrdersQueryBuilderStaticFields } from "datasources/work-orders/constants/WorkOrdersQueryBuilder.constants";
+import React, { useState, useEffect, useMemo } from "react";
+import { User } from "shared/types/QueryUsers.types";
+import { Users } from "shared/Users";
 import { QueryBuilderCustomOperation, QueryBuilderProps } from "smart-webcomponents-react/querybuilder";
 
 type WorkOrdersQueryBuilderProps = QueryBuilderProps & React.HTMLAttributes<Element> & {
   filter?: string;
+  users?: User[] | null;
   globalVariableOptions: QueryBuilderOption[];
 };
 
 export const WorkOrdersQueryBuilder: React.FC<WorkOrdersQueryBuilderProps> = ({
   filter,
+  users,
   onChange,
   globalVariableOptions,
 }) => {
   const [fields, setFields] = useState<QBField[]>([]);
   const [operations, setOperations] = useState<QueryBuilderCustomOperation[]>([]);
 
+  const usersField = useMemo(() => {
+    if (!users) {
+      return null;
+    }
+    const assignedTo = WorkOrdersQueryBuilderFields.ASSIGNED_TO;
+    const createdBy = WorkOrdersQueryBuilderFields.CREATED_BY;
+    const requestedBy = WorkOrdersQueryBuilderFields.REQUESTED_BY;
+    const updatedBy = WorkOrdersQueryBuilderFields.UPDATED_BY;
+
+    const usersMap = users.map(user => ({ label: Users.getUserNameAndEmail(user), value: user.id }));
+
+
+    return [{
+      ...assignedTo,
+      lookup: {
+        ...assignedTo.lookup,
+        dataSource: [
+          ...(assignedTo.lookup?.dataSource || []),
+          ...usersMap,
+        ],
+      }},{
+      ...createdBy,
+      lookup: {
+        ...createdBy.lookup,
+        dataSource: [
+          ...(createdBy.lookup?.dataSource || []),
+          ...usersMap,
+        ],
+      },
+    }, {
+      ...requestedBy,
+      lookup: {
+        ...requestedBy.lookup,
+        dataSource: [
+          ...(requestedBy.lookup?.dataSource || []),
+          ...usersMap,
+        ],
+      },
+    }, {
+      ...updatedBy,
+      lookup: {
+        ...updatedBy.lookup,
+        dataSource: [
+          ...(updatedBy.lookup?.dataSource || []),
+          ...usersMap,
+        ],
+      },
+    }];
+  }, [users])
+
   useEffect(() => {
-    const updatedFields = WorkOrdersQueryBuilderStaticFields
+    if(!usersField) {
+      return;
+    }
+
+    const updatedFields = [...WorkOrdersQueryBuilderStaticFields, ...usersField]
 
     setFields(updatedFields);
 
@@ -59,7 +117,7 @@ export const WorkOrdersQueryBuilder: React.FC<WorkOrdersQueryBuilderProps> = ({
 
     setOperations(customOperations);
 
-  }, [globalVariableOptions]);
+  }, [globalVariableOptions, usersField]);
 
   return (
     <SlQueryBuilder

src/datasources/work-orders/constants/WorkOrdersQueryBuilder.constants.ts

@@ -162,9 +162,5 @@ export const WorkOrdersQueryBuilderStaticFields = [
     WorkOrdersQueryBuilderFields.EARLIEST_START_DATE,
     WorkOrdersQueryBuilderFields.DUE_DATE,
     WorkOrdersQueryBuilderFields.CREATED_AT,
-    WorkOrdersQueryBuilderFields.UPDATED_AT,
-    WorkOrdersQueryBuilderFields.ASSIGNED_TO,
-    WorkOrdersQueryBuilderFields.REQUESTED_BY,
-    WorkOrdersQueryBuilderFields.CREATED_BY,
-    WorkOrdersQueryBuilderFields.UPDATED_BY
+    WorkOrdersQueryBuilderFields.UPDATED_AT
 ];

src/shared/Users.ts

@@ -0,0 +1,79 @@
+import { DataSourceInstanceSettings } from '@grafana/data';
+import { BackendSrv } from '@grafana/runtime';
+import { queryUntilComplete } from 'core/utils';
+import { QueryResponse } from 'core/types';
+import { User, QueryUsersRequest, QueryUsersResponse } from './types/QueryUsers.types';
+
+export class Users {
+  private static _usersCache: Promise<User[]> | null = null;
+  private static _usersMapCache: Promise<Map<string, string>> | null = null;
+
+  get usersCache(): Promise<User[]> {
+    return this.loadUsers()
+  }
+
+  get usersMapCache(): Promise<Map<string, string>> {
+    if (Users._usersMapCache) {
+      return Users._usersMapCache;
+    }
+    return this.usersCache.then(users => {
+      const userMap = new Map<string, string>();
+      users.forEach(user => {
+        const fullName = Users.getUserFullName(user);
+        userMap.set(user.id, fullName);
+      });
+      return userMap;
+    });
+
+  }
+  constructor(readonly instanceSettings: DataSourceInstanceSettings, readonly backendSrv: BackendSrv) {
+    this.loadUsers();
+  }
+
+  public static getUserFullName(user: User): string {   
+    return `${user.firstName} ${user.lastName}`;
+  }
+
+  public static getUserNameAndEmail(user: User): string {
+    return `${user?.firstName ?? ''} ${user?.lastName ?? ''} (${user?.email ?? ''})`;
+  }
+
+  private async loadUsers(): Promise<User[]> {
+    if (Users._usersCache) {
+      return Users._usersCache;
+    }
+    Users._usersCache = this.queryUsersInBatches({}).then(response => response.users);
+    return Users._usersCache;
+  }
+
+  private async queryUsersInBatches(body: QueryUsersRequest): Promise<QueryUsersResponse> {
+    const queryRecord = async (currentTake: number, token?: string | null): Promise<QueryResponse<User>> => {
+      const response = await this.queryUsers({
+        ...body,
+        take: 100,
+        continuationToken: token ?? undefined,
+      });
+
+      return {
+        data: response.users,
+        continuationToken: response.continuationToken,
+      };
+    };
+
+    const batchQueryConfig = {
+      maxTakePerRequest: 100,
+      requestsPerSecond: 5,
+    };
+
+    const response = await queryUntilComplete(queryRecord, batchQueryConfig);
+
+    return {
+      users: response.data,
+      continuationToken: response.continuationToken ?? undefined,
+    };
+  }
+
+  private queryUsers(body: QueryUsersRequest): Promise<QueryUsersResponse> {
+    return this.backendSrv.post<QueryUsersResponse>(`${this.instanceSettings.url}/niuser/v1/users/query`, body);
+  }
+}

src/shared/types/QueryUsers.types.ts

@@ -0,0 +1,25 @@
+export interface QueryUsersRequest {
+  take?: number;
+  filter?: string;
+  continuationToken?: string;
+}
+
+export interface QueryUsersResponse {
+  users: User[];
+  continuationToken?: string;
+  totalCount?: number;
+}
+
+export interface User {
+    id: string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    properties: {
+        [key: string]: string
+    };
+    keywords: string[];
+    created: string;
+    updated: string;
+    orgId: string;
+}