add query services

iamfaran · iamfaran · commit f2dd6a5b92f1 · 2025-04-17T22:53:03.000+05:00
diff --git a/client/packages/lowcoder/src/pages/setting/environments/services/enterprise.service.ts b/client/packages/lowcoder/src/pages/setting/environments/services/enterprise.service.ts
@@ -1,6 +1,8 @@
 import axios from "axios";
 import { message } from "antd";
 import { ManagedOrg } from "../types/enterprise.types";
+import { Query } from "../types/query.types";
+
 
 /**
  * Fetch workspaces for a specific environment
@@ -185,4 +187,93 @@ export const unconnectManagedDataSource = async (
     console.error("Error disconnecting managed data source:", error);
     throw error;
   }
-};
+};
+
+
+
+
+export async function getManagedQueries(environmentId: string): Promise<Query[]> {
+  try {
+    if (!environmentId) {
+      throw new Error('Environment ID is required');
+    }
+    
+    // Get managed queries from the enterprise endpoint
+    const response = await axios.get(`/api/plugins/enterprise/qlQuery/list`, {
+      params: {
+        environmentId
+      }
+    });
+    
+    if (!response.data || !Array.isArray(response.data)) {
+      return [];
+    }
+    
+    // Map the response to match our Query interface
+    // Note: You may need to adjust this mapping based on the actual response structure
+    return response.data.map((item: any) => ({
+      id: item.id || item.qlQueryId,
+      gid: item.qlQueryGid,
+      name: item.qlQueryName,
+      organizationId: item.orgId,
+      libraryQueryDSL: item.libraryQueryDSL || {},
+      createTime: item.createTime,
+      creatorName: item.creatorName || '',
+      managed: true // These are managed queries
+    }));
+    
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Failed to fetch managed queries';
+    message.error(errorMessage);
+    throw error;
+  }
+}
+
+
+export async function connectManagedQuery(
+  environmentId: string, 
+  queryName: string, 
+  queryGid: string
+): Promise<boolean> {
+  try {
+    if (!environmentId || !queryGid) {
+      throw new Error('Environment ID and Query GID are required');
+    }
+    
+    const response = await axios.post('/api/plugins/enterprise/qlQuery', {
+      environment_id: environmentId,
+      ql_query_name: queryName,
+      ql_query_tags: [],
+      ql_query_gid: queryGid
+    });
+    
+    return response.status === 200;
+    
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Failed to connect query';
+    message.error(errorMessage);
+    throw error;
+  }
+}
+
+
+export async function unconnectManagedQuery(queryGid: string): Promise<boolean> {
+  try {
+    if (!queryGid) {
+      throw new Error('Query GID is required');
+    }
+    
+    const response = await axios.delete(`/api/plugins/enterprise/qlQuery`, {
+      params: {
+        qlQueryGid: queryGid
+      }
+    });
+    
+    return response.status === 200;
+    
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Failed to disconnect query';
+    message.error(errorMessage);
+    throw error;
+  }
+}
diff --git a/client/packages/lowcoder/src/pages/setting/environments/services/environments.service.ts b/client/packages/lowcoder/src/pages/setting/environments/services/environments.service.ts
@@ -5,6 +5,7 @@ import { Workspace } from "../types/workspace.types";
 import { UserGroup } from "../types/userGroup.types";
 import {App} from "../types/app.types";
 import { DataSourceWithMeta } from '../types/datasource.types';
+import { Query, QueryResponse } from "../types/query.types";
 
 
 /**
@@ -335,4 +336,88 @@ export async function getWorkspaceDataSources(
     message.error(errorMessage);
     throw error;
   }
+}
+
+
+
+/**
+ * Fetch queries for a specific workspace
+ * @param workspaceId - ID of the workspace (orgId)
+ * @param apiKey - API key for the environment
+ * @param apiServiceUrl - API service URL for the environment
+ * @param options - Additional options (name filter, pagination)
+ * @returns Promise with an array of queries and metadata
+ */
+export async function getWorkspaceQueries(
+  workspaceId: string, 
+  apiKey: string,
+  apiServiceUrl: string,
+  options: {
+    name?: string;
+    pageNum?: number;
+    pageSize?: number;
+  } = {}
+): Promise<{ queries: Query[], total: number }> {
+  try {
+    // Check if required parameters are provided
+    if (!workspaceId) {
+      throw new Error('Workspace ID is required');
+    }
+    
+    if (!apiKey) {
+      throw new Error('API key is required to fetch queries');
+    }
+    
+    if (!apiServiceUrl) {
+      throw new Error('API service URL is required to fetch queries');
+    }
+    
+    // Set up headers with the Bearer token format
+    const headers = {
+      Authorization: `Bearer ${apiKey}`
+    };
+    
+    // Prepare query parameters
+    const params: any = {
+      orgId: workspaceId
+    };
+    
+    // Add optional parameters if provided
+    if (options.name) params.name = options.name;
+    if (options.pageNum !== undefined) params.pageNum = options.pageNum;
+    if (options.pageSize !== undefined) params.pageSize = options.pageSize;
+    
+    // Make the API request to get queries
+    const response = await axios.get<QueryResponse>(`${apiServiceUrl}/api/library-queries/listByOrg`, { 
+      headers,
+      params
+    });
+    
+    // Check if response is valid
+    if (!response.data || !response.data.success === false) {
+      return { queries: [], total: 0 };
+    }
+    
+    // Map the response to include id field required by DeployableItem
+    const queries = response.data.data.map(query => ({
+      ...query,
+      // Map to DeployableItem fields if not already present
+      id: query.id,
+      name: query.name,
+      managed: false // Default to unmanaged
+    }));
+
+    console.log("queries",queries);
+    
+    return { 
+      queries, 
+      total: response.data.total 
+    };
+  
+  } catch (error) {
+    // Handle and transform error
+    const errorMessage = error instanceof Error ? error.message : 'Failed to fetch queries';
+    message.error(errorMessage);
+    throw error;
+  }
 }
diff --git a/client/packages/lowcoder/src/pages/setting/environments/services/query.service.ts b/client/packages/lowcoder/src/pages/setting/environments/services/query.service.ts
@@ -0,0 +1,54 @@
+/**
+ * Get merged queries (both regular and managed) for a workspace
+ */
+import { getManagedQueries } from './enterprise.service';
+import { getWorkspaceQueries } from './environments.service';
+import { Query } from '../types/query.types';
+export interface MergedQueriesResult {
+    queries: Query[];
+    stats: {
+      total: number;
+      managed: number;
+      unmanaged: number;
+    };
+  }
+  
+  export async function getMergedWorkspaceQueries(
+    workspaceId: string,
+    environmentId: string,
+    apiKey: string,
+    apiServiceUrl: string
+  ): Promise<MergedQueriesResult> {
+    try {
+      // Fetch both regular and managed queries
+      const [regularQueries, managedQueries] = await Promise.all([
+        getWorkspaceQueries(workspaceId, apiKey, apiServiceUrl),
+        getManagedQueries(environmentId)
+      ]);
+      
+      // Create a map of managed queries by GID for quick lookup
+      const managedQueryGids = new Set(managedQueries.map(query => query.gid));
+      
+      // Mark regular queries as managed if they exist in managed queries
+      const mergedQueries = regularQueries.queries.map((query: Query ) => ({
+        ...query,
+        managed: managedQueryGids.has(query.gid)
+      }));
+      
+      // Calculate stats
+      const total = mergedQueries.length;
+      const managed = mergedQueries.filter(query => query.managed).length;
+      
+      return {
+        queries: mergedQueries,
+        stats: {
+          total,
+          managed,
+          unmanaged: total - managed
+        }
+      };
+      
+    } catch (error) {
+      throw error;
+    }
+  }
diff --git a/client/packages/lowcoder/src/pages/setting/environments/types/query.types.ts b/client/packages/lowcoder/src/pages/setting/environments/types/query.types.ts
@@ -0,0 +1,57 @@
+// types/query.types.ts
+import { DeployableItem } from './deployable-item.types';
+
+export interface LibraryQueryDSL {
+  query: {
+    compType: string;
+    comp: {
+      bodyType: string;
+      body: string;
+      httpMethod: string;
+      path: string;
+      headers: Array<{ key: string; value: string }>;
+      params: Array<{ key: string; value: string }>;
+      bodyFormData: Array<{ key: string; value: string; type: string }>;
+    };
+    id: string;
+    name: string;
+    order: number;
+    datasourceId: string;
+    triggerType: string;
+    onEvent: any[];
+    notification: {
+      showSuccess: boolean;
+      showFail: boolean;
+      fail: any[];
+    };
+    timeout: string;
+    confirmationModal: any;
+    variables: any[];
+    periodic: boolean;
+    periodicTime: string;
+    cancelPrevious: boolean;
+    depQueryName: string;
+    delayTime: string;
+  };
+}
+
+export interface Query extends DeployableItem {
+  id: string;
+  gid: string;
+  organizationId: string;
+  name: string;
+  libraryQueryDSL: LibraryQueryDSL;
+  createTime: number;
+  creatorName: string;
+  managed?: boolean;
+}
+
+export interface QueryResponse {
+  code: number;
+  message: string;
+  data: Query[];
+  pageNum: number;
+  pageSize: number;
+  total: number;
+  success: boolean;
+}
