feat: 移除 FinOps 模块并为查询任务添加可见性设置

Author: OSpoon

backend/app/controllers/ai_fin_ops_controller.ts

@@ -6,90 +6,118 @@ import User from '#models/user'
 import { DateTime } from 'luxon'
 
 export default class DashboardController {
-  async index({ response }: HttpContext) {
-    const stats = {
-      totalDataSources: await DataSource.query()
+  async index({ request, response, auth }: HttpContext) {
+    const user = auth.user!
+    await user.load('roles')
+    const isGlobalView = user.isAdmin
+
+    const timeRange = request.input('timeRange', '7d')
+    const daysMap: Record<string, number> = { '7d': 7, '30d': 30, '90d': 90, 'all': 90 }
+    const days = daysMap[timeRange] || 7
+
+    const stats: any = {
+      totalQueries: await QueryLog.query()
+        .if(!isGlobalView, q => q.where('user_id', user.id))
         .count('* as total')
         .first()
         .then(r => Number(r?.$extras.total || 0)),
-      totalTasks: await QueryTask.query()
+    }
+
+    if (isGlobalView) {
+      stats.totalDataSources = await DataSource.query()
         .count('* as total')
         .first()
-        .then(r => Number(r?.$extras.total || 0)),
-      totalQueries: await QueryLog.query()
+        .then(r => Number(r?.$extras.total || 0))
+      stats.totalTasks = await QueryTask.query()
         .count('* as total')
         .first()
-        .then(r => Number(r?.$extras.total || 0)),
-      totalUsers: await User.query()
+        .then(r => Number(r?.$extras.total || 0))
+      stats.totalUsers = await User.query()
         .count('* as total')
         .first()
-        .then(r => Number(r?.$extras.total || 0)),
+        .then(r => Number(r?.$extras.total || 0))
     }
 
-    // Get recent 7 days query activity (Success vs Failure)
-    const trend = []
-    for (let i = 6; i >= 0; i--) {
-      const targetDate = DateTime.local().minus({ days: i })
-      const startOfDay = targetDate.startOf('day').toSQL()
-      const endOfDay = targetDate.endOf('day').toSQL()
-
-      const counts = await QueryLog.query()
-        .whereBetween('created_at', [startOfDay, endOfDay])
-        .select('status')
-        .count('* as total')
-        .groupBy('status')
+    const startDate = DateTime.local().minus({ days: days - 1 }).startOf('day').toSQL()!
 
-      let success = 0
-      let failed = 0
+    // Efficient Trend JS Aggregation
+    const trendQuery = QueryLog.query().where('created_at', '>=', startDate).select('created_at', 'status')
+    if (!isGlobalView) {
+      trendQuery.where('user_id', user.id)
+    }
+    const rawTrend = await trendQuery
 
-      counts.forEach((c) => {
-        if (c.status === 'success')
-          success = Number(c.$extras.total)
-        else failed = Number(c.$extras.total)
-      })
+    const trendMap = new Map()
+    for (let i = days - 1; i >= 0; i--) {
+      trendMap.set(DateTime.local().minus({ days: i }).toISODate(), { success: 0, failed: 0, total: 0 })
+    }
 
-      trend.push({ date: targetDate.toISODate(), success, failed, total: success + failed })
+    // rawTrend created_at is a luxon DateTime in Lucid
+    for (const log of rawTrend) {
+      const d = log.createdAt.toISODate()
+      if (d && trendMap.has(d)) {
+        const obj = trendMap.get(d)
+        if (log.status === 'success')
+          obj.success++
+        else obj.failed++
+        obj.total++
+      }
     }
 
+    const trend = Array.from(trendMap.entries()).map(([date, data]) => ({ date, ...data as any }))
+
     // Top 5 Data Sources
-    const topSources = await QueryLog.query()
+    const topSourcesQuery = QueryLog.query()
+      .where('query_logs.created_at', '>=', startDate)
       .leftJoin('data_sources', 'query_logs.data_source_id', 'data_sources.id')
       .select('data_sources.name')
       .count('* as total')
       .groupBy('data_sources.name')
       .orderBy('total', 'desc')
       .limit(5)
-      .then(rows =>
-        rows.map(r => ({
-          name: r.$extras.name || 'Unknown',
-          total: Number(r.$extras.total),
-        })),
-      )
+    if (!isGlobalView)
+      topSourcesQuery.where('query_logs.user_id', user.id)
+
+    const topSources = await topSourcesQuery.then(rows =>
+      rows.map(r => ({
+        name: r.$extras.name || 'Unknown',
+        total: Number(r.$extras.total),
+      })),
+    )
 
     // Top 5 Users
-    const topUsers = await QueryLog.query()
-      .join('users', 'query_logs.user_id', 'users.id')
-      .select('users.full_name')
-      .count('* as total')
-      .groupBy('users.full_name')
-      .orderBy('total', 'desc')
-      .limit(5)
-      .then(rows =>
-        rows.map(r => ({ name: r.$extras.full_name, total: Number(r.$extras.total) })),
-      )
+    let topUsers: any[] = []
+    if (isGlobalView) {
+      topUsers = await QueryLog.query()
+        .where('query_logs.created_at', '>=', startDate)
+        .join('users', 'query_logs.user_id', 'users.id')
+        .select('users.full_name')
+        .count('* as total')
+        .groupBy('users.full_name')
+        .orderBy('total', 'desc')
+        .limit(5)
+        .then(rows =>
+          rows.map(r => ({ name: r.$extras.full_name, total: Number(r.$extras.total) })),
+        )
+    }
 
-    const recentLogs = await QueryLog.query()
+    const recentLogsQuery = QueryLog.query()
       .preload('user')
       .preload('task')
       .orderBy('createdAt', 'desc')
       .limit(5)
+    if (!isGlobalView) {
+      recentLogsQuery.where('user_id', user.id)
+    }
+    const recentLogs = await recentLogsQuery
 
     return response.ok({
       stats,
       trend,
       topSources,
       topUsers,
       recentLogs,
+      isGlobalView, // Return this so frontend knows what to render
     })
   }
 }

backend/app/controllers/dashboard_controller.ts

@@ -1,6 +1,7 @@
 import type { HttpContext } from '@adonisjs/core/http'
 import QueryTask from '#models/query_task'
 import QueryExecutionService from '#services/query_execution_service'
+import { PERMISSIONS } from '@nexquery/shared'
 
 export default class ExecutionController {
   private executionService: QueryExecutionService
@@ -10,7 +11,18 @@ export default class ExecutionController {
   }
 
   async execute({ params, request, response, auth }: HttpContext) {
+    const user = auth.user!
     const task = await QueryTask.query().where('id', params.id).preload('dataSource').firstOrFail()
+
+    const hasManageTasks = await user.hasPermission(PERMISSIONS.MANAGE_TASKS)
+
+    // Authorization: Block execution if private and not creator
+    if (!hasManageTasks) {
+      if (task.visibility !== 'public' && task.createdBy !== user.id) {
+        return response.forbidden({ message: 'Not authorized to execute this task' })
+      }
+    }
+
     const inputParams = request.input('params', {})
 
     try {

backend/app/controllers/execution_controller.ts

@@ -1,20 +1,31 @@
 import type { HttpContext } from '@adonisjs/core/http'
 import QueryTask from '#models/query_task'
 import { createQueryTaskValidator, updateQueryTaskValidator } from '#validators/query_task'
+import { PERMISSIONS } from '@nexquery/shared'
 
 export default class QueryTasksController {
   /**
    * Display a list of resource
    */
-  async index({ request, response }: HttpContext) {
+  async index({ request, response, auth }: HttpContext) {
     const search = request.input('search')
     const tag = request.input('tag')
+    const user = auth.user!
 
     const query = QueryTask.query()
       .preload('dataSource')
       .preload('creator')
       .orderBy('createdAt', 'desc')
 
+    const hasManageTasks = await user.hasPermission(PERMISSIONS.MANAGE_TASKS)
+
+    // Always enforce visibility rules
+    if (!hasManageTasks) {
+      query.where((q) => {
+        q.where('visibility', 'public').orWhere('createdBy', user.id)
+      })
+    }
+
     if (search && search !== '' && search !== 'undefined') {
       query.where((q) => {
         q.where('name', 'like', `%${search}%`).orWhere('description', 'like', `%${search}%`)
@@ -44,6 +55,7 @@ export default class QueryTasksController {
       formSchema: payload.formSchema || null,
       dataSourceId: payload.dataSourceId,
       storeResults: payload.storeResults ?? false,
+      visibility: payload.visibility ?? 'private',
       tags: payload.tags || null,
       createdBy: user.id,
     })
@@ -54,20 +66,38 @@ export default class QueryTasksController {
   /**
    * Show individual record
    */
-  async show({ params, response }: HttpContext) {
+  async show({ params, response, auth }: HttpContext) {
+    const user = auth.user!
     const task = await QueryTask.query()
       .where('id', params.id)
       .preload('dataSource')
       .preload('creator')
       .firstOrFail()
+
+    const hasManageTasks = await user.hasPermission(PERMISSIONS.MANAGE_TASKS)
+    if (!hasManageTasks) {
+      if (task.visibility !== 'public' && task.createdBy !== user.id) {
+        return response.forbidden({ message: 'Not authorized to view this task' })
+      }
+    }
+
     return response.ok(task)
   }
 
   /**
    * Handle form submission for the edit action
    */
-  async update({ params, request, response }: HttpContext) {
+  async update({ params, request, response, auth }: HttpContext) {
+    const user = auth.user!
     const task = await QueryTask.findOrFail(params.id)
+
+    const hasManageTasks = await user.hasPermission(PERMISSIONS.MANAGE_TASKS)
+
+    // Only creators or admins can edit
+    if (!hasManageTasks && task.createdBy !== user.id) {
+      return response.forbidden({ message: 'You can only edit your own query tasks' })
+    }
+
     const payload = await request.validateUsing(updateQueryTaskValidator)
 
     if (payload.name !== undefined)
@@ -82,6 +112,8 @@ export default class QueryTasksController {
       task.dataSourceId = payload.dataSourceId
     if (payload.storeResults !== undefined)
       task.storeResults = payload.storeResults
+    if (payload.visibility !== undefined)
+      task.visibility = payload.visibility
     if (payload.tags !== undefined)
       task.tags = payload.tags
 
@@ -93,8 +125,17 @@ export default class QueryTasksController {
   /**
    * Delete record
    */
-  async destroy({ params, response }: HttpContext) {
+  async destroy({ params, response, auth }: HttpContext) {
+    const user = auth.user!
     const task = await QueryTask.findOrFail(params.id)
+
+    const hasManageTasks = await user.hasPermission(PERMISSIONS.MANAGE_TASKS)
+
+    // Only creators or admins can delete
+    if (!hasManageTasks && task.createdBy !== user.id) {
+      return response.forbidden({ message: 'You can only delete your own query tasks' })
+    }
+
     await task.delete()
     return response.noContent()
   }

backend/app/controllers/query_tasks_controller.ts

@@ -17,6 +17,9 @@ export default class QueryTask extends BaseModel {
   @column()
   declare sqlTemplate: string
 
+  @column()
+  declare visibility: 'private' | 'public'
+
   @column({
     columnName: 'form_schema',
     prepare: (value: any) => (value ? JSON.stringify(value) : null),