github/claude-relay-service
1
0
Fork 0
mirror of https://github.com/Wei-Shaw/claude-relay-service.git synced 2026-01-23 09:38:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'f3n9/main' into main-um-8

Browse Source
This commit is contained in:
Feng Yue
2025-09-03 15:40:28 +08:00
parent bec9cf565b a5361c15a1
commit 6aeb05f685
22 changed files with 2247 additions and 683 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.1.125 1.1.126

379
scripts/test-multi-group.js
View File

@@ -1,379 +0,0 @@
/**
* 多分组功能测试脚本
* 测试一个账户可以属于多个分组的功能
*/
require('dotenv').config()
const redis = require('../src/models/redis')
const accountGroupService = require('../src/services/accountGroupService')
const claudeAccountService = require('../src/services/claudeAccountService')
// 测试配置
const TEST_PREFIX = 'multi_group_test_'
const CLEANUP_ON_FINISH = true
// 测试数据存储
const testData = {
groups: [],
accounts: []
}
// 颜色输出
const colors = {
green: '\x1b[32m',
red: '\x1b[31m',
yellow: '\x1b[33m',
blue: '\x1b[34m',
reset: '\x1b[0m'
}
function log(message, type = 'info') {
const color =
{
success: colors.green,
error: colors.red,
warning: colors.yellow,
info: colors.blue
}[type] || colors.reset
console.log(`${color}${message}${colors.reset}`)
}
async function sleep(ms) {
return new Promise((resolve) => setTimeout(resolve, ms))
}
// 清理测试数据
async function cleanup() {
log('\n🧹 清理测试数据...', 'info')
// 删除测试账户
for (const account of testData.accounts) {
try {
await claudeAccountService.deleteAccount(account.id)
log(`✅ 删除测试账户: ${account.name}`, 'success')
} catch (error) {
log(`❌ 删除账户失败: ${error.message}`, 'error')
}
}
// 删除测试分组
for (const group of testData.groups) {
try {
// 先移除所有成员
const members = await accountGroupService.getGroupMembers(group.id)
for (const memberId of members) {
await accountGroupService.removeAccountFromGroup(memberId, group.id)
}
await accountGroupService.deleteGroup(group.id)
log(`✅ 删除测试分组: ${group.name}`, 'success')
} catch (error) {
log(`❌ 删除分组失败: ${error.message}`, 'error')
}
}
}
// 测试1: 创建测试数据
async function test1_createTestData() {
log('\n📝 测试1: 创建测试数据', 'info')
try {
// 创建3个测试分组
const group1 = await accountGroupService.createGroup({
name: `${TEST_PREFIX}高优先级组`,
platform: 'claude',
description: '高优先级账户分组'
})
testData.groups.push(group1)
log(`✅ 创建分组1: ${group1.name}`, 'success')
const group2 = await accountGroupService.createGroup({
name: `${TEST_PREFIX}备用组`,
platform: 'claude',
description: '备用账户分组'
})
testData.groups.push(group2)
log(`✅ 创建分组2: ${group2.name}`, 'success')
const group3 = await accountGroupService.createGroup({
name: `${TEST_PREFIX}专用组`,
platform: 'claude',
description: '专用账户分组'
})
testData.groups.push(group3)
log(`✅ 创建分组3: ${group3.name}`, 'success')
// 创建测试账户
const account1 = await claudeAccountService.createAccount({
name: `${TEST_PREFIX}测试账户1`,
email: 'test1@example.com',
refreshToken: 'test_refresh_token_1',
accountType: 'group'
})
testData.accounts.push(account1)
log(`✅ 创建测试账户1: ${account1.name}`, 'success')
const account2 = await claudeAccountService.createAccount({
name: `${TEST_PREFIX}测试账户2`,
email: 'test2@example.com',
refreshToken: 'test_refresh_token_2',
accountType: 'group'
})
testData.accounts.push(account2)
log(`✅ 创建测试账户2: ${account2.name}`, 'success')
log(`✅ 测试数据创建完成: 3个分组, 2个账户`, 'success')
} catch (error) {
log(`❌ 测试1失败: ${error.message}`, 'error')
throw error
}
}
// 测试2: 账户加入多个分组
async function test2_addAccountToMultipleGroups() {
log('\n📝 测试2: 账户加入多个分组', 'info')
try {
const [group1, group2, group3] = testData.groups
const [account1, account2] = testData.accounts
// 账户1加入分组1和分组2
await accountGroupService.addAccountToGroup(account1.id, group1.id, 'claude')
log(`✅ 账户1加入分组1: ${group1.name}`, 'success')
await accountGroupService.addAccountToGroup(account1.id, group2.id, 'claude')
log(`✅ 账户1加入分组2: ${group2.name}`, 'success')
// 账户2加入分组2和分组3
await accountGroupService.addAccountToGroup(account2.id, group2.id, 'claude')
log(`✅ 账户2加入分组2: ${group2.name}`, 'success')
await accountGroupService.addAccountToGroup(account2.id, group3.id, 'claude')
log(`✅ 账户2加入分组3: ${group3.name}`, 'success')
log(`✅ 多分组关系建立完成`, 'success')
} catch (error) {
log(`❌ 测试2失败: ${error.message}`, 'error')
throw error
}
}
// 测试3: 验证多分组关系
async function test3_verifyMultiGroupRelationships() {
log('\n📝 测试3: 验证多分组关系', 'info')
try {
const [group1, group2, group3] = testData.groups
const [account1, account2] = testData.accounts
// 验证账户1的分组关系
const account1Groups = await accountGroupService.getAccountGroup(account1.id)
log(`📊 账户1所属分组数量: ${account1Groups.length}`, 'info')
const account1GroupNames = account1Groups.map((g) => g.name).sort()
const expectedAccount1Groups = [group1.name, group2.name].sort()
if (JSON.stringify(account1GroupNames) === JSON.stringify(expectedAccount1Groups)) {
log(`✅ 账户1分组关系正确: [${account1GroupNames.join(', ')}]`, 'success')
} else {
throw new Error(
`账户1分组关系错误，期望: [${expectedAccount1Groups.join(', ')}], 实际: [${account1GroupNames.join(', ')}]`
)
}
// 验证账户2的分组关系
const account2Groups = await accountGroupService.getAccountGroup(account2.id)
log(`📊 账户2所属分组数量: ${account2Groups.length}`, 'info')
const account2GroupNames = account2Groups.map((g) => g.name).sort()
const expectedAccount2Groups = [group2.name, group3.name].sort()
if (JSON.stringify(account2GroupNames) === JSON.stringify(expectedAccount2Groups)) {
log(`✅ 账户2分组关系正确: [${account2GroupNames.join(', ')}]`, 'success')
} else {
throw new Error(
`账户2分组关系错误，期望: [${expectedAccount2Groups.join(', ')}], 实际: [${account2GroupNames.join(', ')}]`
)
}
log(`✅ 多分组关系验证通过`, 'success')
} catch (error) {
log(`❌ 测试3失败: ${error.message}`, 'error')
throw error
}
}
// 测试4: 验证分组成员关系
async function test4_verifyGroupMemberships() {
log('\n📝 测试4: 验证分组成员关系', 'info')
try {
const [group1, group2, group3] = testData.groups
const [account1, account2] = testData.accounts
// 验证分组1的成员
const group1Members = await accountGroupService.getGroupMembers(group1.id)
if (group1Members.includes(account1.id) && group1Members.length === 1) {
log(`✅ 分组1成员正确: [${account1.name}]`, 'success')
} else {
throw new Error(`分组1成员错误，期望: [${account1.id}], 实际: [${group1Members.join(', ')}]`)
}
// 验证分组2的成员（应该包含两个账户）
const group2Members = await accountGroupService.getGroupMembers(group2.id)
const expectedGroup2Members = [account1.id, account2.id].sort()
const actualGroup2Members = group2Members.sort()
if (JSON.stringify(actualGroup2Members) === JSON.stringify(expectedGroup2Members)) {
log(`✅ 分组2成员正确: [${account1.name}, ${account2.name}]`, 'success')
} else {
throw new Error(
`分组2成员错误，期望: [${expectedGroup2Members.join(', ')}], 实际: [${actualGroup2Members.join(', ')}]`
)
}
// 验证分组3的成员
const group3Members = await accountGroupService.getGroupMembers(group3.id)
if (group3Members.includes(account2.id) && group3Members.length === 1) {
log(`✅ 分组3成员正确: [${account2.name}]`, 'success')
} else {
throw new Error(`分组3成员错误，期望: [${account2.id}], 实际: [${group3Members.join(', ')}]`)
}
log(`✅ 分组成员关系验证通过`, 'success')
} catch (error) {
log(`❌ 测试4失败: ${error.message}`, 'error')
throw error
}
}
// 测试5: 从部分分组中移除账户
async function test5_removeFromPartialGroups() {
log('\n📝 测试5: 从部分分组中移除账户', 'info')
try {
const [group1, group2] = testData.groups
const [account1] = testData.accounts
// 将账户1从分组1中移除（但仍在分组2中）
await accountGroupService.removeAccountFromGroup(account1.id, group1.id)
log(`✅ 从分组1中移除账户1`, 'success')
// 验证账户1现在只属于分组2
const account1Groups = await accountGroupService.getAccountGroup(account1.id)
if (account1Groups.length === 1 && account1Groups[0].id === group2.id) {
log(`✅ 账户1现在只属于分组2: ${account1Groups[0].name}`, 'success')
} else {
const groupNames = account1Groups.map((g) => g.name)
throw new Error(`账户1分组状态错误，期望只在分组2中，实际: [${groupNames.join(', ')}]`)
}
// 验证分组1现在为空
const group1Members = await accountGroupService.getGroupMembers(group1.id)
if (group1Members.length === 0) {
log(`✅ 分组1现在为空`, 'success')
} else {
throw new Error(`分组1应该为空，但还有成员: [${group1Members.join(', ')}]`)
}
// 验证分组2仍有两个成员
const group2Members = await accountGroupService.getGroupMembers(group2.id)
if (group2Members.length === 2) {
log(`✅ 分组2仍有两个成员`, 'success')
} else {
throw new Error(`分组2应该有2个成员，实际: ${group2Members.length}个`)
}
log(`✅ 部分移除测试通过`, 'success')
} catch (error) {
log(`❌ 测试5失败: ${error.message}`, 'error')
throw error
}
}
// 测试6: 账户完全移除时的分组清理
async function test6_accountDeletionGroupCleanup() {
log('\n📝 测试6: 账户删除时的分组清理', 'info')
try {
const [, group2, group3] = testData.groups // 跳过第一个元素
const [account1, account2] = testData.accounts
// 记录删除前的状态
const beforeGroup2Members = await accountGroupService.getGroupMembers(group2.id)
const beforeGroup3Members = await accountGroupService.getGroupMembers(group3.id)
log(`📊 删除前分组2成员数: ${beforeGroup2Members.length}`, 'info')
log(`📊 删除前分组3成员数: ${beforeGroup3Members.length}`, 'info')
// 删除账户2（这应该会触发从所有分组中移除的逻辑）
await claudeAccountService.deleteAccount(account2.id)
log(`✅ 删除账户2: ${account2.name}`, 'success')
// 从测试数据中移除，避免cleanup时重复删除
testData.accounts = testData.accounts.filter((acc) => acc.id !== account2.id)
// 等待一下确保删除操作完成
await sleep(500)
// 验证分组2现在只有账户1
const afterGroup2Members = await accountGroupService.getGroupMembers(group2.id)
if (afterGroup2Members.length === 1 && afterGroup2Members[0] === account1.id) {
log(`✅ 分组2现在只有账户1`, 'success')
} else {
throw new Error(`分组2成员状态错误，期望只有账户1，实际: [${afterGroup2Members.join(', ')}]`)
}
// 验证分组3现在为空
const afterGroup3Members = await accountGroupService.getGroupMembers(group3.id)
if (afterGroup3Members.length === 0) {
log(`✅ 分组3现在为空`, 'success')
} else {
throw new Error(`分组3应该为空，但还有成员: [${afterGroup3Members.join(', ')}]`)
}
log(`✅ 账户删除的分组清理测试通过`, 'success')
} catch (error) {
log(`❌ 测试6失败: ${error.message}`, 'error')
throw error
}
}
// 主测试函数
async function runTests() {
log('\n🚀 开始多分组功能测试\n', 'info')
try {
// 连接Redis
await redis.connect()
log('✅ Redis连接成功', 'success')
// 执行测试
await test1_createTestData()
await test2_addAccountToMultipleGroups()
await test3_verifyMultiGroupRelationships()
await test4_verifyGroupMemberships()
await test5_removeFromPartialGroups()
await test6_accountDeletionGroupCleanup()
log('\n🎉 所有测试通过！多分组功能工作正常', 'success')
} catch (error) {
log(`\n❌ 测试失败: ${error.message}`, 'error')
console.error(error)
} finally {
// 清理测试数据
if (CLEANUP_ON_FINISH) {
await cleanup()
} else {
log('\n⚠️ 测试数据未清理，请手动清理', 'warning')
}
// 关闭Redis连接
await redis.disconnect()
process.exit(0)
}
}
// 运行测试
runTests()

398
src/routes/admin.js
View File

@@ -749,6 +749,9 @@ router.put('/api-keys/batch', authenticateAdmin, async (req, res) => {
if (updates.tokenLimit !== undefined) { if (updates.tokenLimit !== undefined) {
finalUpdates.tokenLimit = updates.tokenLimit finalUpdates.tokenLimit = updates.tokenLimit
} }
if (updates.rateLimitCost !== undefined) {
finalUpdates.rateLimitCost = updates.rateLimitCost
}
if (updates.concurrencyLimit !== undefined) { if (updates.concurrencyLimit !== undefined) {
finalUpdates.concurrencyLimit = updates.concurrencyLimit finalUpdates.concurrencyLimit = updates.concurrencyLimit
} }
@@ -1235,7 +1238,7 @@ router.get('/api-keys/deleted', authenticateAdmin, async (req, res) => {
deletedAt: key.deletedAt, deletedAt: key.deletedAt,
deletedBy: key.deletedBy, deletedBy: key.deletedBy,
deletedByType: key.deletedByType, deletedByType: key.deletedByType,
canRestore: false // Deleted keys cannot be restored per requirement canRestore: true // 已删除的API Key可以恢复
})) }))
logger.success(`📋 Admin retrieved ${enrichedKeys.length} deleted API keys`) logger.success(`📋 Admin retrieved ${enrichedKeys.length} deleted API keys`)
@@ -1248,6 +1251,123 @@ router.get('/api-keys/deleted', authenticateAdmin, async (req, res) => {
} }
}) })
// 🔄 恢复已删除的API Key
router.post('/api-keys/:keyId/restore', authenticateAdmin, async (req, res) => {
try {
const { keyId } = req.params
const adminUsername = req.session?.admin?.username || 'unknown'
// 调用服务层的恢复方法
const result = await apiKeyService.restoreApiKey(keyId, adminUsername, 'admin')
if (result.success) {
logger.success(`✅ Admin ${adminUsername} restored API key: ${keyId}`)
return res.json({
success: true,
message: 'API Key 已成功恢复',
apiKey: result.apiKey
})
} else {
return res.status(400).json({
success: false,
error: 'Failed to restore API key'
})
}
} catch (error) {
logger.error('❌ Failed to restore API key:', error)
// 根据错误类型返回适当的响应
if (error.message === 'API key not found') {
return res.status(404).json({
success: false,
error: 'API Key 不存在'
})
} else if (error.message === 'API key is not deleted') {
return res.status(400).json({
success: false,
error: '该 API Key 未被删除，无需恢复'
})
}
return res.status(500).json({
success: false,
error: '恢复 API Key 失败',
message: error.message
})
}
})
// 🗑️ 彻底删除API Key（物理删除）
router.delete('/api-keys/:keyId/permanent', authenticateAdmin, async (req, res) => {
try {
const { keyId } = req.params
const adminUsername = req.session?.admin?.username || 'unknown'
// 调用服务层的彻底删除方法
const result = await apiKeyService.permanentDeleteApiKey(keyId)
if (result.success) {
logger.success(`🗑️ Admin ${adminUsername} permanently deleted API key: ${keyId}`)
return res.json({
success: true,
message: 'API Key 已彻底删除'
})
}
} catch (error) {
logger.error('❌ Failed to permanently delete API key:', error)
if (error.message === 'API key not found') {
return res.status(404).json({
success: false,
error: 'API Key 不存在'
})
} else if (error.message === '只能彻底删除已经删除的API Key') {
return res.status(400).json({
success: false,
error: '只能彻底删除已经删除的API Key'
})
}
return res.status(500).json({
success: false,
error: '彻底删除 API Key 失败',
message: error.message
})
}
})
// 🧹 清空所有已删除的API Keys
router.delete('/api-keys/deleted/clear-all', authenticateAdmin, async (req, res) => {
try {
const adminUsername = req.session?.admin?.username || 'unknown'
// 调用服务层的清空方法
const result = await apiKeyService.clearAllDeletedApiKeys()
logger.success(
`🧹 Admin ${adminUsername} cleared deleted API keys: ${result.successCount}/${result.total}`
)
return res.json({
success: true,
message: `成功清空 ${result.successCount} 个已删除的 API Keys`,
details: {
total: result.total,
successCount: result.successCount,
failedCount: result.failedCount,
errors: result.errors
}
})
} catch (error) {
logger.error('❌ Failed to clear all deleted API keys:', error)
return res.status(500).json({
success: false,
error: '清空已删除的 API Keys 失败',
message: error.message
})
}
})
// 👥 账户分组管理 // 👥 账户分组管理
// 创建账户分组 // 创建账户分组
@@ -1620,15 +1740,18 @@ router.get('/claude-accounts', authenticateAdmin, async (req, res) => {
if (groupId && groupId !== 'all') { if (groupId && groupId !== 'all') {
if (groupId === 'ungrouped') { if (groupId === 'ungrouped') {
// 筛选未分组账户 // 筛选未分组账户
accounts = accounts.filter( const filteredAccounts = []
(account) => !account.groupInfos || account.groupInfos.length === 0 for (const account of accounts) {
) const groups = await accountGroupService.getAccountGroups(account.id)
if (!groups || groups.length === 0) {
filteredAccounts.push(account)
}
}
accounts = filteredAccounts
} else { } else {
// 筛选特定分组的账户 // 筛选特定分组的账户
accounts = accounts.filter( const groupMembers = await accountGroupService.getGroupMembers(groupId)
(account) => accounts = accounts.filter((account) => groupMembers.includes(account.id))
account.groupInfos && account.groupInfos.some((group) => group.id === groupId)
)
} }
} }
@@ -1637,7 +1760,7 @@ router.get('/claude-accounts', authenticateAdmin, async (req, res) => {
accounts.map(async (account) => { accounts.map(async (account) => {
try { try {
const usageStats = await redis.getAccountUsageStats(account.id) const usageStats = await redis.getAccountUsageStats(account.id)
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
// 获取会话窗口使用统计（仅对有活跃窗口的账户） // 获取会话窗口使用统计（仅对有活跃窗口的账户）
let sessionWindowUsage = null let sessionWindowUsage = null
@@ -1695,7 +1818,7 @@ router.get('/claude-accounts', authenticateAdmin, async (req, res) => {
logger.warn(`⚠️ Failed to get usage stats for account ${account.id}:`, statsError.message) logger.warn(`⚠️ Failed to get usage stats for account ${account.id}:`, statsError.message)
// 如果获取统计失败，返回空统计 // 如果获取统计失败，返回空统计
try { try {
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
return { return {
...account, ...account,
groupInfos, groupInfos,
@@ -1748,6 +1871,7 @@ router.post('/claude-accounts', authenticateAdmin, async (req, res) => {
platform = 'claude', platform = 'claude',
priority, priority,
groupId, groupId,
groupIds,
autoStopOnWarning autoStopOnWarning
} = req.body } = req.body
@@ -1762,9 +1886,11 @@ router.post('/claude-accounts', authenticateAdmin, async (req, res) => {
.json({ error: 'Invalid account type. Must be "shared", "dedicated" or "group"' }) .json({ error: 'Invalid account type. Must be "shared", "dedicated" or "group"' })
} }
// 如果是分组类型，验证groupId // 如果是分组类型，验证groupId或groupIds
if (accountType === 'group' && !groupId) { if (accountType === 'group' && !groupId && (!groupIds || groupIds.length === 0)) {
return res.status(400).json({ error: 'Group ID is required for group type accounts' }) return res
.status(400)
.json({ error: 'Group ID or Group IDs are required for group type accounts' })
} }
// 验证priority的有效性 // 验证priority的有效性
@@ -1790,9 +1916,15 @@ router.post('/claude-accounts', authenticateAdmin, async (req, res) => {
}) })
// 如果是分组类型，将账户添加到分组 // 如果是分组类型，将账户添加到分组
if (accountType === 'group' && groupId) { if (accountType === 'group') {
if (groupIds && groupIds.length > 0) {
// 使用多分组设置
await accountGroupService.setAccountGroups(newAccount.id, groupIds, newAccount.platform)
} else if (groupId) {
// 兼容单分组模式
await accountGroupService.addAccountToGroup(newAccount.id, groupId, newAccount.platform) await accountGroupService.addAccountToGroup(newAccount.id, groupId, newAccount.platform)
} }
}
logger.success(`🏢 Admin created new Claude account: ${name} (${accountType || 'shared'})`) logger.success(`🏢 Admin created new Claude account: ${name} (${accountType || 'shared'})`)
return res.json({ success: true, data: newAccount }) return res.json({ success: true, data: newAccount })
@@ -1825,9 +1957,15 @@ router.put('/claude-accounts/:accountId', authenticateAdmin, async (req, res) =>
.json({ error: 'Invalid account type. Must be "shared", "dedicated" or "group"' }) .json({ error: 'Invalid account type. Must be "shared", "dedicated" or "group"' })
} }
// 如果更新为分组类型，验证groupId // 如果更新为分组类型，验证groupId或groupIds
if (updates.accountType === 'group' && !updates.groupId) { if (
return res.status(400).json({ error: 'Group ID is required for group type accounts' }) updates.accountType === 'group' &&
!updates.groupId &&
(!updates.groupIds || updates.groupIds.length === 0)
) {
return res
.status(400)
.json({ error: 'Group ID or Group IDs are required for group type accounts' })
} }
// 获取账户当前信息以处理分组变更 // 获取账户当前信息以处理分组变更
@@ -1840,18 +1978,26 @@ router.put('/claude-accounts/:accountId', authenticateAdmin, async (req, res) =>
if (updates.accountType !== undefined) { if (updates.accountType !== undefined) {
// 如果之前是分组类型，需要从所有分组中移除 // 如果之前是分组类型，需要从所有分组中移除
if (currentAccount.accountType === 'group') { if (currentAccount.accountType === 'group') {
const oldGroups = await accountGroupService.getAccountGroup(accountId) await accountGroupService.removeAccountFromAllGroups(accountId)
for (const oldGroup of oldGroups) {
await accountGroupService.removeAccountFromGroup(accountId, oldGroup.id)
}
} }
// 如果新类型是分组，添加到新分组 // 如果新类型是分组，添加到新分组
if (updates.accountType === 'group' && updates.groupId) { if (updates.accountType === 'group') {
// 从路由知道这是 Claude OAuth 账户，平台为 'claude' // 处理多分组/单分组的兼容性
if (Object.prototype.hasOwnProperty.call(updates, 'groupIds')) {
if (updates.groupIds && updates.groupIds.length > 0) {
// 使用多分组设置
await accountGroupService.setAccountGroups(accountId, updates.groupIds, 'claude')
} else {
// groupIds 为空数组，从所有分组中移除
await accountGroupService.removeAccountFromAllGroups(accountId)
}
} else if (updates.groupId) {
// 兼容单分组模式
await accountGroupService.addAccountToGroup(accountId, updates.groupId, 'claude') await accountGroupService.addAccountToGroup(accountId, updates.groupId, 'claude')
} }
} }
}
await claudeAccountService.updateAccount(accountId, updates) await claudeAccountService.updateAccount(accountId, updates)
@@ -2023,15 +2169,18 @@ router.get('/claude-console-accounts', authenticateAdmin, async (req, res) => {
if (groupId && groupId !== 'all') { if (groupId && groupId !== 'all') {
if (groupId === 'ungrouped') { if (groupId === 'ungrouped') {
// 筛选未分组账户 // 筛选未分组账户
accounts = accounts.filter( const filteredAccounts = []
(account) => !account.groupInfos || account.groupInfos.length === 0 for (const account of accounts) {
) const groups = await accountGroupService.getAccountGroups(account.id)
if (!groups || groups.length === 0) {
filteredAccounts.push(account)
}
}
accounts = filteredAccounts
} else { } else {
// 筛选特定分组的账户 // 筛选特定分组的账户
accounts = accounts.filter( const groupMembers = await accountGroupService.getGroupMembers(groupId)
(account) => accounts = accounts.filter((account) => groupMembers.includes(account.id))
account.groupInfos && account.groupInfos.some((group) => group.id === groupId)
)
} }
} }
@@ -2040,7 +2189,7 @@ router.get('/claude-console-accounts', authenticateAdmin, async (req, res) => {
accounts.map(async (account) => { accounts.map(async (account) => {
try { try {
const usageStats = await redis.getAccountUsageStats(account.id) const usageStats = await redis.getAccountUsageStats(account.id)
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
return { return {
...account, ...account,
@@ -2059,7 +2208,7 @@ router.get('/claude-console-accounts', authenticateAdmin, async (req, res) => {
statsError.message statsError.message
) )
try { try {
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
return { return {
...account, ...account,
// 转换schedulable为布尔值 // 转换schedulable为布尔值
@@ -2153,7 +2302,7 @@ router.post('/claude-console-accounts', authenticateAdmin, async (req, res) => {
// 如果是分组类型，将账户添加到分组 // 如果是分组类型，将账户添加到分组
if (accountType === 'group' && groupId) { if (accountType === 'group' && groupId) {
await accountGroupService.addAccountToGroup(newAccount.id, groupId, 'claude') await accountGroupService.addAccountToGroup(newAccount.id, groupId)
} }
logger.success(`🎮 Admin created Claude Console account: ${name}`) logger.success(`🎮 Admin created Claude Console account: ${name}`)
@@ -2199,17 +2348,28 @@ router.put('/claude-console-accounts/:accountId', authenticateAdmin, async (req,
if (updates.accountType !== undefined) { if (updates.accountType !== undefined) {
// 如果之前是分组类型，需要从所有分组中移除 // 如果之前是分组类型，需要从所有分组中移除
if (currentAccount.accountType === 'group') { if (currentAccount.accountType === 'group') {
const oldGroups = await accountGroupService.getAccountGroup(accountId) const oldGroups = await accountGroupService.getAccountGroups(accountId)
for (const oldGroup of oldGroups) { for (const oldGroup of oldGroups) {
await accountGroupService.removeAccountFromGroup(accountId, oldGroup.id) await accountGroupService.removeAccountFromGroup(accountId, oldGroup.id)
} }
} }
// 如果新类型是分组，添加到新分组 // 如果新类型是分组，处理多分组支持
if (updates.accountType === 'group' && updates.groupId) { if (updates.accountType === 'group') {
// Claude Console 账户在分组中被视为 'claude' 平台 if (Object.prototype.hasOwnProperty.call(updates, 'groupIds')) {
// 如果明确提供了 groupIds 参数（包括空数组）
if (updates.groupIds && updates.groupIds.length > 0) {
// 设置新的多分组
await accountGroupService.setAccountGroups(accountId, updates.groupIds, 'claude')
} else {
// groupIds 为空数组，从所有分组中移除
await accountGroupService.removeAccountFromAllGroups(accountId)
}
} else if (updates.groupId) {
// 向后兼容：仅当没有 groupIds 但有 groupId 时使用单分组逻辑
await accountGroupService.addAccountToGroup(accountId, updates.groupId, 'claude') await accountGroupService.addAccountToGroup(accountId, updates.groupId, 'claude')
} }
} }
}
await claudeConsoleAccountService.updateAccount(accountId, updates) await claudeConsoleAccountService.updateAccount(accountId, updates)
@@ -2341,15 +2501,18 @@ router.get('/bedrock-accounts', authenticateAdmin, async (req, res) => {
if (groupId && groupId !== 'all') { if (groupId && groupId !== 'all') {
if (groupId === 'ungrouped') { if (groupId === 'ungrouped') {
// 筛选未分组账户 // 筛选未分组账户
accounts = accounts.filter( const filteredAccounts = []
(account) => !account.groupInfos || account.groupInfos.length === 0 for (const account of accounts) {
) const groups = await accountGroupService.getAccountGroups(account.id)
if (!groups || groups.length === 0) {
filteredAccounts.push(account)
}
}
accounts = filteredAccounts
} else { } else {
// 筛选特定分组的账户 // 筛选特定分组的账户
accounts = accounts.filter( const groupMembers = await accountGroupService.getGroupMembers(groupId)
(account) => accounts = accounts.filter((account) => groupMembers.includes(account.id))
account.groupInfos && account.groupInfos.some((group) => group.id === groupId)
)
} }
} }
@@ -2358,7 +2521,7 @@ router.get('/bedrock-accounts', authenticateAdmin, async (req, res) => {
accounts.map(async (account) => { accounts.map(async (account) => {
try { try {
const usageStats = await redis.getAccountUsageStats(account.id) const usageStats = await redis.getAccountUsageStats(account.id)
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
return { return {
...account, ...account,
@@ -2375,7 +2538,7 @@ router.get('/bedrock-accounts', authenticateAdmin, async (req, res) => {
statsError.message statsError.message
) )
try { try {
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
return { return {
...account, ...account,
groupInfos, groupInfos,
@@ -2788,15 +2951,18 @@ router.get('/gemini-accounts', authenticateAdmin, async (req, res) => {
if (groupId && groupId !== 'all') { if (groupId && groupId !== 'all') {
if (groupId === 'ungrouped') { if (groupId === 'ungrouped') {
// 筛选未分组账户 // 筛选未分组账户
accounts = accounts.filter( const filteredAccounts = []
(account) => !account.groupInfos || account.groupInfos.length === 0 for (const account of accounts) {
) const groups = await accountGroupService.getAccountGroups(account.id)
if (!groups || groups.length === 0) {
filteredAccounts.push(account)
}
}
accounts = filteredAccounts
} else { } else {
// 筛选特定分组的账户 // 筛选特定分组的账户
accounts = accounts.filter( const groupMembers = await accountGroupService.getGroupMembers(groupId)
(account) => accounts = accounts.filter((account) => groupMembers.includes(account.id))
account.groupInfos && account.groupInfos.some((group) => group.id === groupId)
)
} }
} }
@@ -2805,7 +2971,7 @@ router.get('/gemini-accounts', authenticateAdmin, async (req, res) => {
accounts.map(async (account) => { accounts.map(async (account) => {
try { try {
const usageStats = await redis.getAccountUsageStats(account.id) const usageStats = await redis.getAccountUsageStats(account.id)
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
return { return {
...account, ...account,
@@ -2823,7 +2989,7 @@ router.get('/gemini-accounts', authenticateAdmin, async (req, res) => {
) )
// 如果获取统计失败，返回空统计 // 如果获取统计失败，返回空统计
try { try {
const groupInfos = await accountGroupService.getAccountGroup(account.id) const groupInfos = await accountGroupService.getAccountGroups(account.id)
return { return {
...account, ...account,
groupInfos, groupInfos,
@@ -2927,16 +3093,28 @@ router.put('/gemini-accounts/:accountId', authenticateAdmin, async (req, res) =>
if (updates.accountType !== undefined) { if (updates.accountType !== undefined) {
// 如果之前是分组类型，需要从所有分组中移除 // 如果之前是分组类型，需要从所有分组中移除
if (currentAccount.accountType === 'group') { if (currentAccount.accountType === 'group') {
const oldGroups = await accountGroupService.getAccountGroup(accountId) const oldGroups = await accountGroupService.getAccountGroups(accountId)
for (const oldGroup of oldGroups) { for (const oldGroup of oldGroups) {
await accountGroupService.removeAccountFromGroup(accountId, oldGroup.id) await accountGroupService.removeAccountFromGroup(accountId, oldGroup.id)
} }
} }
// 如果新类型是分组，添加到新分组 // 如果新类型是分组，处理多分组支持
if (updates.accountType === 'group' && updates.groupId) { if (updates.accountType === 'group') {
if (Object.prototype.hasOwnProperty.call(updates, 'groupIds')) {
// 如果明确提供了 groupIds 参数（包括空数组）
if (updates.groupIds && updates.groupIds.length > 0) {
// 设置新的多分组
await accountGroupService.setAccountGroups(accountId, updates.groupIds, 'gemini')
} else {
// groupIds 为空数组，从所有分组中移除
await accountGroupService.removeAccountFromAllGroups(accountId)
}
} else if (updates.groupId) {
// 向后兼容：仅当没有 groupIds 但有 groupId 时使用单分组逻辑
await accountGroupService.addAccountToGroup(accountId, updates.groupId, 'gemini') await accountGroupService.addAccountToGroup(accountId, updates.groupId, 'gemini')
} }
} }
}
const updatedAccount = await geminiAccountService.updateAccount(accountId, updates) const updatedAccount = await geminiAccountService.updateAccount(accountId, updates)
@@ -5299,15 +5477,18 @@ router.get('/openai-accounts', authenticateAdmin, async (req, res) => {
if (groupId && groupId !== 'all') { if (groupId && groupId !== 'all') {
if (groupId === 'ungrouped') { if (groupId === 'ungrouped') {
// 筛选未分组账户 // 筛选未分组账户
accounts = accounts.filter( const filteredAccounts = []
(account) => !account.groupInfos || account.groupInfos.length === 0 for (const account of accounts) {
) const groups = await accountGroupService.getAccountGroups(account.id)
if (!groups || groups.length === 0) {
filteredAccounts.push(account)
}
}
accounts = filteredAccounts
} else { } else {
// 筛选特定分组的账户 // 筛选特定分组的账户
accounts = accounts.filter( const groupMembers = await accountGroupService.getGroupMembers(groupId)
(account) => accounts = accounts.filter((account) => groupMembers.includes(account.id))
account.groupInfos && account.groupInfos.some((group) => group.id === groupId)
)
} }
} }
@@ -5628,10 +5809,81 @@ router.put(
// 获取所有 Azure OpenAI 账户 // 获取所有 Azure OpenAI 账户
router.get('/azure-openai-accounts', authenticateAdmin, async (req, res) => { router.get('/azure-openai-accounts', authenticateAdmin, async (req, res) => {
try { try {
const accounts = await azureOpenaiAccountService.getAllAccounts() const { platform, groupId } = req.query
let accounts = await azureOpenaiAccountService.getAllAccounts()
// 根据查询参数进行筛选
if (platform && platform !== 'all' && platform !== 'azure_openai') {
// 如果指定了其他平台，返回空数组
accounts = []
}
// 如果指定了分组筛选
if (groupId && groupId !== 'all') {
if (groupId === 'ungrouped') {
// 筛选未分组账户
const filteredAccounts = []
for (const account of accounts) {
const groups = await accountGroupService.getAccountGroups(account.id)
if (!groups || groups.length === 0) {
filteredAccounts.push(account)
}
}
accounts = filteredAccounts
} else {
// 筛选特定分组的账户
const groupMembers = await accountGroupService.getGroupMembers(groupId)
accounts = accounts.filter((account) => groupMembers.includes(account.id))
}
}
// 为每个账户添加使用统计信息和分组信息
const accountsWithStats = await Promise.all(
accounts.map(async (account) => {
try {
const usageStats = await redis.getAccountUsageStats(account.id)
const groupInfos = await accountGroupService.getAccountGroups(account.id)
return {
...account,
groupInfos,
usage: {
daily: usageStats.daily,
total: usageStats.total,
averages: usageStats.averages
}
}
} catch (error) {
logger.debug(`Failed to get usage stats for Azure OpenAI account ${account.id}:`, error)
try {
const groupInfos = await accountGroupService.getAccountGroups(account.id)
return {
...account,
groupInfos,
usage: {
daily: { requests: 0, tokens: 0, allTokens: 0 },
total: { requests: 0, tokens: 0, allTokens: 0 },
averages: { rpm: 0, tpm: 0 }
}
}
} catch (groupError) {
logger.debug(`Failed to get group info for account ${account.id}:`, groupError)
return {
...account,
groupInfos: [],
usage: {
daily: { requests: 0, tokens: 0, allTokens: 0 },
total: { requests: 0, tokens: 0, allTokens: 0 },
averages: { rpm: 0, tpm: 0 }
}
}
}
}
})
)
res.json({ res.json({
success: true, success: true,
data: accounts data: accountsWithStats
}) })
} catch (error) { } catch (error) {
logger.error('Failed to fetch Azure OpenAI accounts:', error) logger.error('Failed to fetch Azure OpenAI accounts:', error)
@@ -5657,6 +5909,7 @@ router.post('/azure-openai-accounts', authenticateAdmin, async (req, res) => {
supportedModels, supportedModels,
proxy, proxy,
groupId, groupId,
groupIds,
priority, priority,
isActive, isActive,
schedulable schedulable
@@ -5736,6 +5989,17 @@ router.post('/azure-openai-accounts', authenticateAdmin, async (req, res) => {
schedulable: schedulable !== false schedulable: schedulable !== false
}) })
// 如果是分组类型，将账户添加到分组
if (accountType === 'group') {
if (groupIds && groupIds.length > 0) {
// 使用多分组设置
await accountGroupService.setAccountGroups(account.id, groupIds, 'azure_openai')
} else if (groupId) {
// 兼容单分组模式
await accountGroupService.addAccountToGroup(account.id, groupId, 'azure_openai')
}
}
res.json({ res.json({
success: true, success: true,
data: account, data: account,

311
src/routes/apiStats.js
View File

@@ -407,6 +407,317 @@ router.post('/api/user-stats', async (req, res) => {
} }
}) })
// 📊 批量查询统计数据接口
router.post('/api/batch-stats', async (req, res) => {
try {
const { apiIds } = req.body
// 验证输入
if (!apiIds || !Array.isArray(apiIds) || apiIds.length === 0) {
return res.status(400).json({
error: 'Invalid input',
message: 'API IDs array is required'
})
}
// 限制最多查询 30 个
if (apiIds.length > 30) {
return res.status(400).json({
error: 'Too many keys',
message: 'Maximum 30 API keys can be queried at once'
})
}
// 验证所有 ID 格式
const uuidRegex = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i
const invalidIds = apiIds.filter((id) => !uuidRegex.test(id))
if (invalidIds.length > 0) {
return res.status(400).json({
error: 'Invalid API ID format',
message: `Invalid API IDs: ${invalidIds.join(', ')}`
})
}
const individualStats = []
const aggregated = {
totalKeys: apiIds.length,
activeKeys: 0,
usage: {
requests: 0,
inputTokens: 0,
outputTokens: 0,
cacheCreateTokens: 0,
cacheReadTokens: 0,
allTokens: 0,
cost: 0,
formattedCost: '$0.000000'
},
dailyUsage: {
requests: 0,
inputTokens: 0,
outputTokens: 0,
cacheCreateTokens: 0,
cacheReadTokens: 0,
allTokens: 0,
cost: 0,
formattedCost: '$0.000000'
},
monthlyUsage: {
requests: 0,
inputTokens: 0,
outputTokens: 0,
cacheCreateTokens: 0,
cacheReadTokens: 0,
allTokens: 0,
cost: 0,
formattedCost: '$0.000000'
}
}
// 并行查询所有 API Key 数据（复用单key查询逻辑）
const results = await Promise.allSettled(
apiIds.map(async (apiId) => {
const keyData = await redis.getApiKey(apiId)
if (!keyData || Object.keys(keyData).length === 0) {
return { error: 'Not found', apiId }
}
// 检查是否激活
if (keyData.isActive !== 'true') {
return { error: 'Disabled', apiId }
}
// 检查是否过期
if (keyData.expiresAt && new Date() > new Date(keyData.expiresAt)) {
return { error: 'Expired', apiId }
}
// 复用单key查询的逻辑：获取使用统计
const usage = await redis.getUsageStats(apiId)
// 获取费用统计（与单key查询一致）
const costStats = await redis.getCostStats(apiId)
return {
apiId,
name: keyData.name,
description: keyData.description || '',
isActive: true,
createdAt: keyData.createdAt,
usage: usage.total || {},
dailyStats: {
...usage.daily,
cost: costStats.daily
},
monthlyStats: {
...usage.monthly,
cost: costStats.monthly
},
totalCost: costStats.total
}
})
)
// 处理结果并聚合
results.forEach((result) => {
if (result.status === 'fulfilled' && result.value && !result.value.error) {
const stats = result.value
aggregated.activeKeys++
// 聚合总使用量
if (stats.usage) {
aggregated.usage.requests += stats.usage.requests || 0
aggregated.usage.inputTokens += stats.usage.inputTokens || 0
aggregated.usage.outputTokens += stats.usage.outputTokens || 0
aggregated.usage.cacheCreateTokens += stats.usage.cacheCreateTokens || 0
aggregated.usage.cacheReadTokens += stats.usage.cacheReadTokens || 0
aggregated.usage.allTokens += stats.usage.allTokens || 0
}
// 聚合总费用
aggregated.usage.cost += stats.totalCost || 0
// 聚合今日使用量
aggregated.dailyUsage.requests += stats.dailyStats.requests || 0
aggregated.dailyUsage.inputTokens += stats.dailyStats.inputTokens || 0
aggregated.dailyUsage.outputTokens += stats.dailyStats.outputTokens || 0
aggregated.dailyUsage.cacheCreateTokens += stats.dailyStats.cacheCreateTokens || 0
aggregated.dailyUsage.cacheReadTokens += stats.dailyStats.cacheReadTokens || 0
aggregated.dailyUsage.allTokens += stats.dailyStats.allTokens || 0
aggregated.dailyUsage.cost += stats.dailyStats.cost || 0
// 聚合本月使用量
aggregated.monthlyUsage.requests += stats.monthlyStats.requests || 0
aggregated.monthlyUsage.inputTokens += stats.monthlyStats.inputTokens || 0
aggregated.monthlyUsage.outputTokens += stats.monthlyStats.outputTokens || 0
aggregated.monthlyUsage.cacheCreateTokens += stats.monthlyStats.cacheCreateTokens || 0
aggregated.monthlyUsage.cacheReadTokens += stats.monthlyStats.cacheReadTokens || 0
aggregated.monthlyUsage.allTokens += stats.monthlyStats.allTokens || 0
aggregated.monthlyUsage.cost += stats.monthlyStats.cost || 0
// 添加到个体统计
individualStats.push({
apiId: stats.apiId,
name: stats.name,
isActive: true,
usage: stats.usage,
dailyUsage: {
...stats.dailyStats,
formattedCost: CostCalculator.formatCost(stats.dailyStats.cost || 0)
},
monthlyUsage: {
...stats.monthlyStats,
formattedCost: CostCalculator.formatCost(stats.monthlyStats.cost || 0)
}
})
}
})
// 格式化费用显示
aggregated.usage.formattedCost = CostCalculator.formatCost(aggregated.usage.cost)
aggregated.dailyUsage.formattedCost = CostCalculator.formatCost(aggregated.dailyUsage.cost)
aggregated.monthlyUsage.formattedCost = CostCalculator.formatCost(aggregated.monthlyUsage.cost)
logger.api(`📊 Batch stats query for ${apiIds.length} keys from ${req.ip || 'unknown'}`)
return res.json({
success: true,
data: {
aggregated,
individual: individualStats
}
})
} catch (error) {
logger.error('❌ Failed to process batch stats query:', error)
return res.status(500).json({
error: 'Internal server error',
message: 'Failed to retrieve batch statistics'
})
}
})
// 📊 批量模型统计查询接口
router.post('/api/batch-model-stats', async (req, res) => {
try {
const { apiIds, period = 'daily' } = req.body
// 验证输入
if (!apiIds || !Array.isArray(apiIds) || apiIds.length === 0) {
return res.status(400).json({
error: 'Invalid input',
message: 'API IDs array is required'
})
}
// 限制最多查询 30 个
if (apiIds.length > 30) {
return res.status(400).json({
error: 'Too many keys',
message: 'Maximum 30 API keys can be queried at once'
})
}
const client = redis.getClientSafe()
const tzDate = redis.getDateInTimezone()
const today = redis.getDateStringInTimezone()
const currentMonth = `${tzDate.getFullYear()}-${String(tzDate.getMonth() + 1).padStart(2, '0')}`
const modelUsageMap = new Map()
// 并行查询所有 API Key 的模型统计
await Promise.all(
apiIds.map(async (apiId) => {
const pattern =
period === 'daily'
? `usage:${apiId}:model:daily:*:${today}`
: `usage:${apiId}:model:monthly:*:${currentMonth}`
const keys = await client.keys(pattern)
for (const key of keys) {
const match = key.match(
period === 'daily'
? /usage:.+:model:daily:(.+):\d{4}-\d{2}-\d{2}$/
: /usage:.+:model:monthly:(.+):\d{4}-\d{2}$/
)
if (!match) {
continue
}
const model = match[1]
const data = await client.hgetall(key)
if (data && Object.keys(data).length > 0) {
if (!modelUsageMap.has(model)) {
modelUsageMap.set(model, {
requests: 0,
inputTokens: 0,
outputTokens: 0,
cacheCreateTokens: 0,
cacheReadTokens: 0,
allTokens: 0
})
}
const modelUsage = modelUsageMap.get(model)
modelUsage.requests += parseInt(data.requests) || 0
modelUsage.inputTokens += parseInt(data.inputTokens) || 0
modelUsage.outputTokens += parseInt(data.outputTokens) || 0
modelUsage.cacheCreateTokens += parseInt(data.cacheCreateTokens) || 0
modelUsage.cacheReadTokens += parseInt(data.cacheReadTokens) || 0
modelUsage.allTokens += parseInt(data.allTokens) || 0
}
}
})
)
// 转换为数组并计算费用
const modelStats = []
for (const [model, usage] of modelUsageMap) {
const usageData = {
input_tokens: usage.inputTokens,
output_tokens: usage.outputTokens,
cache_creation_input_tokens: usage.cacheCreateTokens,
cache_read_input_tokens: usage.cacheReadTokens
}
const costData = CostCalculator.calculateCost(usageData, model)
modelStats.push({
model,
requests: usage.requests,
inputTokens: usage.inputTokens,
outputTokens: usage.outputTokens,
cacheCreateTokens: usage.cacheCreateTokens,
cacheReadTokens: usage.cacheReadTokens,
allTokens: usage.allTokens,
costs: costData.costs,
formatted: costData.formatted,
pricing: costData.pricing
})
}
// 按总 token 数降序排列
modelStats.sort((a, b) => b.allTokens - a.allTokens)
logger.api(`📊 Batch model stats query for ${apiIds.length} keys, period: ${period}`)
return res.json({
success: true,
data: modelStats,
period
})
} catch (error) {
logger.error('❌ Failed to process batch model stats query:', error)
return res.status(500).json({
error: 'Internal server error',
message: 'Failed to retrieve batch model statistics'
})
}
})
// 📊 用户模型统计查询接口 - 安全的自查询接口 // 📊 用户模型统计查询接口 - 安全的自查询接口
router.post('/api/user-model-stats', async (req, res) => { router.post('/api/user-model-stats', async (req, res) => {
try { try {

71
src/services/accountGroupService.js
View File

@@ -13,7 +13,7 @@ class AccountGroupService {
* 创建账户分组 * 创建账户分组
* @param {Object} groupData - 分组数据 * @param {Object} groupData - 分组数据
* @param {string} groupData.name - 分组名称 * @param {string} groupData.name - 分组名称
* @param {string} groupData.platform - 平台类型 (claude/gemini) * @param {string} groupData.platform - 平台类型 (claude/gemini/openai)
* @param {string} groupData.description - 分组描述 * @param {string} groupData.description - 分组描述
* @returns {Object} 创建的分组 * @returns {Object} 创建的分组
*/ */
@@ -327,12 +327,36 @@ class AccountGroupService {
} }
} }
/**
* 根据账户ID获取其所属的分组（兼容性方法，返回单个分组）
* @param {string} accountId - 账户ID
* @returns {Object|null} 分组信息
*/
async getAccountGroup(accountId) {
try {
const client = redis.getClientSafe()
const allGroupIds = await client.smembers(this.GROUPS_KEY)
for (const groupId of allGroupIds) {
const isMember = await client.sismember(`${this.GROUP_MEMBERS_PREFIX}${groupId}`, accountId)
if (isMember) {
return await this.getGroup(groupId)
}
}
return null
} catch (error) {
logger.error('❌ 获取账户所属分组失败:', error)
throw error
}
}
/** /**
* 根据账户ID获取其所属的所有分组 * 根据账户ID获取其所属的所有分组
* @param {string} accountId - 账户ID * @param {string} accountId - 账户ID
* @returns {Array} 分组信息数组 * @returns {Array} 分组信息数组
*/ */
async getAccountGroup(accountId) { async getAccountGroups(accountId) {
try { try {
const client = redis.getClientSafe() const client = redis.getClientSafe()
const allGroupIds = await client.smembers(this.GROUPS_KEY) const allGroupIds = await client.smembers(this.GROUPS_KEY)
@@ -357,6 +381,49 @@ class AccountGroupService {
throw error throw error
} }
} }
/**
* 批量设置账户的分组
* @param {string} accountId - 账户ID
* @param {Array} groupIds - 分组ID数组
* @param {string} accountPlatform - 账户平台
*/
async setAccountGroups(accountId, groupIds, accountPlatform) {
try {
// 首先移除账户的所有现有分组
await this.removeAccountFromAllGroups(accountId)
// 然后添加到新的分组中
for (const groupId of groupIds) {
await this.addAccountToGroup(accountId, groupId, accountPlatform)
}
logger.success(`✅ 批量设置账户分组成功: ${accountId} -> [${groupIds.join(', ')}]`)
} catch (error) {
logger.error('❌ 批量设置账户分组失败:', error)
throw error
}
}
/**
* 从所有分组中移除账户
* @param {string} accountId - 账户ID
*/
async removeAccountFromAllGroups(accountId) {
try {
const client = redis.getClientSafe()
const allGroupIds = await client.smembers(this.GROUPS_KEY)
for (const groupId of allGroupIds) {
await client.srem(`${this.GROUP_MEMBERS_PREFIX}${groupId}`, accountId)
}
logger.success(`✅ 从所有分组移除账户成功: ${accountId}`)
} catch (error) {
logger.error('❌ 从所有分组移除账户失败:', error)
throw error
}
}
} }
module.exports = new AccountGroupService() module.exports = new AccountGroupService()

133
src/services/apiKeyService.js
View File

@@ -437,6 +437,139 @@ class ApiKeyService {
} }
} }
// 🔄 恢复已删除的API Key
async restoreApiKey(keyId, restoredBy = 'system', restoredByType = 'system') {
try {
const keyData = await redis.getApiKey(keyId)
if (!keyData || Object.keys(keyData).length === 0) {
throw new Error('API key not found')
}
// 检查是否确实是已删除的key
if (keyData.isDeleted !== 'true') {
throw new Error('API key is not deleted')
}
// 准备更新的数据
const updatedData = { ...keyData }
updatedData.isActive = 'true'
updatedData.restoredAt = new Date().toISOString()
updatedData.restoredBy = restoredBy
updatedData.restoredByType = restoredByType
// 从更新的数据中移除删除相关的字段
delete updatedData.isDeleted
delete updatedData.deletedAt
delete updatedData.deletedBy
delete updatedData.deletedByType
// 保存更新后的数据
await redis.setApiKey(keyId, updatedData)
// 使用Redis的hdel命令删除不需要的字段
const keyName = `apikey:${keyId}`
await redis.client.hdel(keyName, 'isDeleted', 'deletedAt', 'deletedBy', 'deletedByType')
// 重新建立哈希映射（恢复API Key的使用能力）
if (keyData.apiKey) {
await redis.setApiKeyHash(keyData.apiKey, {
id: keyId,
name: keyData.name,
isActive: 'true'
})
}
logger.success(`✅ Restored API key: ${keyId} by ${restoredBy} (${restoredByType})`)
return { success: true, apiKey: updatedData }
} catch (error) {
logger.error('❌ Failed to restore API key:', error)
throw error
}
}
// 🗑️ 彻底删除API Key（物理删除）
async permanentDeleteApiKey(keyId) {
try {
const keyData = await redis.getApiKey(keyId)
if (!keyData || Object.keys(keyData).length === 0) {
throw new Error('API key not found')
}
// 确保只能彻底删除已经软删除的key
if (keyData.isDeleted !== 'true') {
throw new Error('只能彻底删除已经删除的API Key')
}
// 删除所有相关的使用统计数据
const today = new Date().toISOString().split('T')[0]
const yesterday = new Date(Date.now() - 86400000).toISOString().split('T')[0]
// 删除每日统计
await redis.client.del(`usage:daily:${today}:${keyId}`)
await redis.client.del(`usage:daily:${yesterday}:${keyId}`)
// 删除月度统计
const currentMonth = today.substring(0, 7)
await redis.client.del(`usage:monthly:${currentMonth}:${keyId}`)
// 删除所有相关的统计键（通过模式匹配）
const usageKeys = await redis.client.keys(`usage:*:${keyId}*`)
if (usageKeys.length > 0) {
await redis.client.del(...usageKeys)
}
// 删除API Key本身
await redis.deleteApiKey(keyId)
logger.success(`🗑️ Permanently deleted API key: ${keyId}`)
return { success: true }
} catch (error) {
logger.error('❌ Failed to permanently delete API key:', error)
throw error
}
}
// 🧹 清空所有已删除的API Keys
async clearAllDeletedApiKeys() {
try {
const allKeys = await this.getAllApiKeys(true)
const deletedKeys = allKeys.filter((key) => key.isDeleted === 'true')
let successCount = 0
let failedCount = 0
const errors = []
for (const key of deletedKeys) {
try {
await this.permanentDeleteApiKey(key.id)
successCount++
} catch (error) {
failedCount++
errors.push({
keyId: key.id,
keyName: key.name,
error: error.message
})
}
}
logger.success(`🧹 Cleared deleted API keys: ${successCount} success, ${failedCount} failed`)
return {
success: true,
total: deletedKeys.length,
successCount,
failedCount,
errors
}
} catch (error) {
logger.error('❌ Failed to clear all deleted API keys:', error)
throw error
}
}
// 📊 记录使用情况（支持缓存token和账户级别统计） // 📊 记录使用情况（支持缓存token和账户级别统计）
async recordUsage( async recordUsage(
keyId, keyId,

4
src/services/azureOpenaiAccountService.js
View File

@@ -249,6 +249,10 @@ async function updateAccount(accountId, updates) {
// 删除账户 // 删除账户
async function deleteAccount(accountId) { async function deleteAccount(accountId) {
// 首先从所有分组中移除此账户
const accountGroupService = require('./accountGroupService')
await accountGroupService.removeAccountFromAllGroups(accountId)
const client = redisClient.getClientSafe() const client = redisClient.getClientSafe()
const accountKey = `${AZURE_OPENAI_ACCOUNT_KEY_PREFIX}${accountId}` const accountKey = `${AZURE_OPENAI_ACCOUNT_KEY_PREFIX}${accountId}`

5
src/services/claudeAccountService.js
View File

@@ -621,10 +621,7 @@ class ClaudeAccountService {
try { try {
// 首先从所有分组中移除此账户 // 首先从所有分组中移除此账户
const accountGroupService = require('./accountGroupService') const accountGroupService = require('./accountGroupService')
const groups = await accountGroupService.getAccountGroup(accountId) await accountGroupService.removeAccountFromAllGroups(accountId)
for (const group of groups) {
await accountGroupService.removeAccountFromGroup(accountId, group.id)
}
const result = await redis.deleteClaudeAccount(accountId) const result = await redis.deleteClaudeAccount(accountId)

8
web/admin-spa/.env.example
View File

@@ -23,6 +23,14 @@ VITE_APP_TITLE=Claude Relay Service - 管理后台
# 格式：http://proxy-host:port # 格式：http://proxy-host:port
#VITE_HTTP_PROXY=http://127.0.0.1:7890 #VITE_HTTP_PROXY=http://127.0.0.1:7890
# ========== 教程页面配置 ==========
# API 基础前缀（可选）
# 用于教程页面显示的自定义 API 前缀
# 如果不配置，则使用当前浏览器访问地址
# 示例：https://api.example.com 或 https://relay.mysite.com
# VITE_API_BASE_PREFIX=https://api.example.com
# ========== 使用说明 ========== # ========== 使用说明 ==========
# 1. 复制此文件为 .env.local 进行本地配置 # 1. 复制此文件为 .env.local 进行本地配置
# 2. .env.local 文件不会被提交到版本控制 # 2. .env.local 文件不会被提交到版本控制

200
web/admin-spa/src/components/accounts/AccountForm.vue
View File

@@ -244,19 +244,47 @@
>选择分组 *</label >选择分组 *</label
> >
<div class="flex gap-2"> <div class="flex gap-2">
<select <div class="flex-1">
v-model="form.groupId" <!-- 多选分组界面 -->
class="form-input flex-1 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200" <div
required class="max-h-48 space-y-2 overflow-y-auto rounded-md border p-3 dark:border-gray-600 dark:bg-gray-700"
> >
<option value="">请选择分组</option> <div
<option v-for="group in filteredGroups" :key="group.id" :value="group.id"> v-if="filteredGroups.length === 0"
class="text-sm text-gray-500 dark:text-gray-400"
>
暂无可用分组
</div>
<label
v-for="group in filteredGroups"
:key="group.id"
class="flex cursor-pointer items-center gap-2 rounded-md p-2 hover:bg-gray-50 dark:hover:bg-gray-600"
>
<input
v-model="form.groupIds"
class="rounded border-gray-300 text-blue-600 focus:ring-blue-500 dark:border-gray-600 dark:bg-gray-700"
type="checkbox"
:value="group.id"
/>
<span class="text-sm text-gray-700 dark:text-gray-200">
{{ group.name }} ({{ group.memberCount || 0 }} 个成员) {{ group.name }} ({{ group.memberCount || 0 }} 个成员)
</option> </span>
<option value="__new__">+ 新建分组</option> </label>
</select> <!-- 新建分组选项 -->
<div class="border-t pt-2 dark:border-gray-600">
<button <button
class="rounded-md border border-gray-300 bg-white px-3 py-2 text-sm font-medium text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2" class="flex items-center gap-2 text-sm text-blue-600 hover:text-blue-800 dark:text-blue-400 dark:hover:text-blue-300"
type="button"
@click="handleNewGroup"
>
<i class="fas fa-plus" />
新建分组
</button>
</div>
</div>
</div>
<button
class="rounded-md border border-gray-300 bg-white px-3 py-2 text-sm font-medium text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200 dark:hover:bg-gray-600"
type="button" type="button"
@click="refreshGroups" @click="refreshGroups"
> >
@@ -1269,19 +1297,47 @@
>选择分组 *</label >选择分组 *</label
> >
<div class="flex gap-2"> <div class="flex gap-2">
<select <div class="flex-1">
v-model="form.groupId" <!-- 多选分组界面 -->
class="form-input flex-1 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200" <div
required class="max-h-48 space-y-2 overflow-y-auto rounded-md border p-3 dark:border-gray-600 dark:bg-gray-700"
> >
<option value="">请选择分组</option> <div
<option v-for="group in filteredGroups" :key="group.id" :value="group.id"> v-if="filteredGroups.length === 0"
class="text-sm text-gray-500 dark:text-gray-400"
>
暂无可用分组
</div>
<label
v-for="group in filteredGroups"
:key="group.id"
class="flex cursor-pointer items-center gap-2 rounded-md p-2 hover:bg-gray-50 dark:hover:bg-gray-600"
>
<input
v-model="form.groupIds"
class="rounded border-gray-300 text-blue-600 focus:ring-blue-500 dark:border-gray-600 dark:bg-gray-700"
type="checkbox"
:value="group.id"
/>
<span class="text-sm text-gray-700 dark:text-gray-200">
{{ group.name }} ({{ group.memberCount || 0 }} 个成员) {{ group.name }} ({{ group.memberCount || 0 }} 个成员)
</option> </span>
<option value="__new__">+ 新建分组</option> </label>
</select> <!-- 新建分组选项 -->
<div class="border-t pt-2 dark:border-gray-600">
<button <button
class="rounded-md border border-gray-300 bg-white px-3 py-2 text-sm font-medium text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 dark:border-gray-600 dark:bg-gray-800 dark:text-gray-300 dark:hover:bg-gray-700" class="flex items-center gap-2 text-sm text-blue-600 hover:text-blue-800 dark:text-blue-400 dark:hover:text-blue-300"
type="button"
@click="handleNewGroup"
>
<i class="fas fa-plus" />
新建分组
</button>
</div>
</div>
</div>
<button
class="rounded-md border border-gray-300 bg-white px-3 py-2 text-sm font-medium text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200 dark:hover:bg-gray-600"
type="button" type="button"
@click="refreshGroups" @click="refreshGroups"
> >
@@ -1923,6 +1979,7 @@ const form = ref({
subscriptionType: 'claude_max', // 默认为 Claude Max，兼容旧数据 subscriptionType: 'claude_max', // 默认为 Claude Max，兼容旧数据
autoStopOnWarning: props.account?.autoStopOnWarning || false, // 5小时限制自动停止调度 autoStopOnWarning: props.account?.autoStopOnWarning || false, // 5小时限制自动停止调度
groupId: '', groupId: '',
groupIds: [],
projectId: props.account?.projectId || '', projectId: props.account?.projectId || '',
idToken: '', idToken: '',
accessToken: '', accessToken: '',
@@ -2030,15 +2087,24 @@ const nextStep = async () => {
return return
} }
// 分组类型验证 // 分组类型验证 - OAuth流程修复
if ( if (
form.value.accountType === 'group' && form.value.accountType === 'group' &&
(!form.value.groupId || form.value.groupId.trim() === '') (!form.value.groupIds || form.value.groupIds.length === 0)
) { ) {
showToast('请选择一个分组', 'error') showToast('请选择一个分组', 'error')
return return
} }
// 数据同步：确保 groupId 和 groupIds 保持一致 - OAuth流程
if (form.value.accountType === 'group') {
if (form.value.groupIds && form.value.groupIds.length > 0) {
form.value.groupId = form.value.groupIds[0]
} else {
form.value.groupId = ''
}
}
// 对于Gemini账户，检查项目 ID // 对于Gemini账户，检查项目 ID
if (form.value.platform === 'gemini' && oauthStep.value === 1 && form.value.addType === 'oauth') { if (form.value.platform === 'gemini' && oauthStep.value === 1 && form.value.addType === 'oauth') {
if (!form.value.projectId || form.value.projectId.trim() === '') { if (!form.value.projectId || form.value.projectId.trim() === '') {
@@ -2172,6 +2238,7 @@ const handleOAuthSuccess = async (tokenInfo) => {
description: form.value.description, description: form.value.description,
accountType: form.value.accountType, accountType: form.value.accountType,
groupId: form.value.accountType === 'group' ? form.value.groupId : undefined, groupId: form.value.accountType === 'group' ? form.value.groupId : undefined,
groupIds: form.value.accountType === 'group' ? form.value.groupIds : undefined,
proxy: form.value.proxy.enabled proxy: form.value.proxy.enabled
? { ? {
type: form.value.proxy.type, type: form.value.proxy.type,
@@ -2295,15 +2362,24 @@ const createAccount = async () => {
} }
} }
// 分组类型验证 // 分组类型验证 - 创建账户流程修复
if ( if (
form.value.accountType === 'group' && form.value.accountType === 'group' &&
(!form.value.groupId || form.value.groupId.trim() === '') (!form.value.groupIds || form.value.groupIds.length === 0)
) { ) {
showToast('请选择一个分组', 'error') showToast('请选择一个分组', 'error')
hasError = true hasError = true
} }
// 数据同步：确保 groupId 和 groupIds 保持一致 - 创建流程
if (form.value.accountType === 'group') {
if (form.value.groupIds && form.value.groupIds.length > 0) {
form.value.groupId = form.value.groupIds[0]
} else {
form.value.groupId = ''
}
}
if (hasError) { if (hasError) {
return return
} }
@@ -2315,6 +2391,7 @@ const createAccount = async () => {
description: form.value.description, description: form.value.description,
accountType: form.value.accountType, accountType: form.value.accountType,
groupId: form.value.accountType === 'group' ? form.value.groupId : undefined, groupId: form.value.accountType === 'group' ? form.value.groupId : undefined,
groupIds: form.value.accountType === 'group' ? form.value.groupIds : undefined,
proxy: form.value.proxy.enabled proxy: form.value.proxy.enabled
? { ? {
type: form.value.proxy.type, type: form.value.proxy.type,
@@ -2450,6 +2527,8 @@ const createAccount = async () => {
? form.value.supportedModels ? form.value.supportedModels
: [] : []
data.priority = form.value.priority || 50 data.priority = form.value.priority || 50
data.isActive = form.value.isActive !== false
data.schedulable = form.value.schedulable !== false
} }
let result let result
@@ -2463,8 +2542,10 @@ const createAccount = async () => {
result = await accountsStore.createOpenAIAccount(data) result = await accountsStore.createOpenAIAccount(data)
} else if (form.value.platform === 'azure_openai') { } else if (form.value.platform === 'azure_openai') {
result = await accountsStore.createAzureOpenAIAccount(data) result = await accountsStore.createAzureOpenAIAccount(data)
} else { } else if (form.value.platform === 'gemini') {
result = await accountsStore.createGeminiAccount(data) result = await accountsStore.createGeminiAccount(data)
} else {
throw new Error(`不支持的平台: ${form.value.platform}`)
} }
emit('success', result) emit('success', result)
@@ -2486,15 +2567,24 @@ const updateAccount = async () => {
return return
} }
// 分组类型验证 // 分组类型验证 - 更新账户流程修复
if ( if (
form.value.accountType === 'group' && form.value.accountType === 'group' &&
(!form.value.groupId || form.value.groupId.trim() === '') (!form.value.groupIds || form.value.groupIds.length === 0)
) { ) {
showToast('请选择一个分组', 'error') showToast('请选择一个分组', 'error')
return return
} }
// 数据同步：确保 groupId 和 groupIds 保持一致 - 更新流程
if (form.value.accountType === 'group') {
if (form.value.groupIds && form.value.groupIds.length > 0) {
form.value.groupId = form.value.groupIds[0]
} else {
form.value.groupId = ''
}
}
// 对于Gemini账户，检查项目 ID // 对于Gemini账户，检查项目 ID
if (form.value.platform === 'gemini') { if (form.value.platform === 'gemini') {
if (!form.value.projectId || form.value.projectId.trim() === '') { if (!form.value.projectId || form.value.projectId.trim() === '') {
@@ -2518,6 +2608,7 @@ const updateAccount = async () => {
description: form.value.description, description: form.value.description,
accountType: form.value.accountType, accountType: form.value.accountType,
groupId: form.value.accountType === 'group' ? form.value.groupId : undefined, groupId: form.value.accountType === 'group' ? form.value.groupId : undefined,
groupIds: form.value.accountType === 'group' ? form.value.groupIds : undefined,
proxy: form.value.proxy.enabled proxy: form.value.proxy.enabled
? { ? {
type: form.value.proxy.type, type: form.value.proxy.type,
@@ -2662,8 +2753,10 @@ const updateAccount = async () => {
await accountsStore.updateOpenAIAccount(props.account.id, data) await accountsStore.updateOpenAIAccount(props.account.id, data)
} else if (props.account.platform === 'azure_openai') { } else if (props.account.platform === 'azure_openai') {
await accountsStore.updateAzureOpenAIAccount(props.account.id, data) await accountsStore.updateAzureOpenAIAccount(props.account.id, data)
} else { } else if (props.account.platform === 'gemini') {
await accountsStore.updateGeminiAccount(props.account.id, data) await accountsStore.updateGeminiAccount(props.account.id, data)
} else {
throw new Error(`不支持的平台: ${props.account.platform}`)
} }
emit('success') emit('success')
@@ -2765,6 +2858,11 @@ const refreshGroups = async () => {
showToast('分组列表已刷新', 'success') showToast('分组列表已刷新', 'success')
} }
// 处理新建分组
const handleNewGroup = () => {
showGroupManagement.value = true
}
// 处理分组管理模态框刷新 // 处理分组管理模态框刷新
const handleGroupRefresh = async () => { const handleGroupRefresh = async () => {
await loadGroups() await loadGroups()
@@ -2791,10 +2889,28 @@ watch(
// 平台变化时，清空分组选择 // 平台变化时，清空分组选择
if (form.value.accountType === 'group') { if (form.value.accountType === 'group') {
form.value.groupId = '' form.value.groupId = ''
form.value.groupIds = []
} }
} }
) )
// 监听分组选择变化，保持 groupId 和 groupIds 同步
watch(
() => form.value.groupIds,
(newGroupIds) => {
if (form.value.accountType === 'group') {
if (newGroupIds && newGroupIds.length > 0) {
// 如果有选中的分组，使用第一个作为主分组
form.value.groupId = newGroupIds[0]
} else {
// 如果没有选中分组，清空主分组
form.value.groupId = ''
}
}
},
{ deep: true }
)
// 监听Setup Token授权码输入，自动提取URL中的code参数 // 监听Setup Token授权码输入，自动提取URL中的code参数
watch(setupTokenAuthCode, (newValue) => { watch(setupTokenAuthCode, (newValue) => {
if (!newValue || typeof newValue !== 'string') return if (!newValue || typeof newValue !== 'string') return
@@ -2956,6 +3072,7 @@ watch(
subscriptionType: subscriptionType, subscriptionType: subscriptionType,
autoStopOnWarning: newAccount.autoStopOnWarning || false, autoStopOnWarning: newAccount.autoStopOnWarning || false,
groupId: groupId, groupId: groupId,
groupIds: [],
projectId: newAccount.projectId || '', projectId: newAccount.projectId || '',
accessToken: '', accessToken: '',
refreshToken: '', refreshToken: '',
@@ -2997,24 +3114,35 @@ watch(
// 如果是分组类型，加载分组ID // 如果是分组类型，加载分组ID
if (newAccount.accountType === 'group') { if (newAccount.accountType === 'group') {
// 先加载分组列表 // 先加载分组列表
loadGroups().then(() => { loadGroups().then(async () => {
const foundGroupIds = []
// 如果账户有 groupInfo，直接使用它的 groupId // 如果账户有 groupInfo，直接使用它的 groupId
if (newAccount.groupInfo && newAccount.groupInfo.id) { if (newAccount.groupInfo && newAccount.groupInfo.id) {
form.value.groupId = newAccount.groupInfo.id form.value.groupId = newAccount.groupInfo.id
foundGroupIds.push(newAccount.groupInfo.id)
} else { } else {
// 否则查找账户所属的分组 // 否则查找账户所属的分组
groups.value.forEach((group) => { const checkPromises = groups.value.map(async (group) => {
apiClient try {
.get(`/admin/account-groups/${group.id}/members`) const response = await apiClient.get(`/admin/account-groups/${group.id}/members`)
.then((response) => {
const members = response.data || [] const members = response.data || []
if (members.some((m) => m.id === newAccount.id)) { if (members.some((m) => m.id === newAccount.id)) {
form.value.groupId = group.id foundGroupIds.push(group.id)
if (!form.value.groupId) {
form.value.groupId = group.id // 设置第一个找到的分组作为主分组
}
}
} catch (error) {
// 忽略错误
} }
}) })
.catch(() => {})
}) await Promise.all(checkPromises)
} }
// 设置多选分组
form.value.groupIds = foundGroupIds
}) })
} }
} }

34
web/admin-spa/src/components/apikeys/BatchEditApiKeyModal.vue
View File

@@ -188,12 +188,14 @@
<div> <div>
<label class="mb-1 block text-xs font-medium text-gray-700 dark:text-gray-300" <label class="mb-1 block text-xs font-medium text-gray-700 dark:text-gray-300"
>Token 限制</label >费用限制 (美元)</label
> >
<input <input
v-model="form.tokenLimit" v-model="form.rateLimitCost"
class="form-input w-full text-sm dark:border-gray-600 dark:bg-gray-800 dark:text-gray-200" class="form-input w-full text-sm dark:border-gray-600 dark:bg-gray-800 dark:text-gray-200"
min="0"
placeholder="不修改" placeholder="不修改"
step="0.01"
type="number" type="number"
/> />
</div> </div>
@@ -216,6 +218,24 @@
/> />
</div> </div>
<!-- Opus 模型周费用限制 -->
<div>
<label class="mb-3 block text-sm font-semibold text-gray-700 dark:text-gray-300">
Opus 模型周费用限制 (美元)
</label>
<input
v-model="form.weeklyOpusCostLimit"
class="form-input w-full dark:border-gray-600 dark:bg-gray-800 dark:text-gray-200"
min="0"
placeholder="不修改 (0 表示无限制)"
step="0.01"
type="number"
/>
<p class="mt-1 text-xs text-gray-500 dark:text-gray-400">
设置 Opus 模型的周费用限制（周一到周日），仅限 Claude 官方账户
</p>
</div>
<!-- 并发限制 --> <!-- 并发限制 -->
<div> <div>
<label class="mb-3 block text-sm font-semibold text-gray-700 dark:text-gray-300" <label class="mb-3 block text-sm font-semibold text-gray-700 dark:text-gray-300"
@@ -496,11 +516,12 @@ const unselectedTags = computed(() => {
// 表单数据 // 表单数据
const form = reactive({ const form = reactive({
tokenLimit: '', rateLimitCost: '', // 费用限制替代token限制
rateLimitWindow: '', rateLimitWindow: '',
rateLimitRequests: '', rateLimitRequests: '',
concurrencyLimit: '', concurrencyLimit: '',
dailyCostLimit: '', dailyCostLimit: '',
weeklyOpusCostLimit: '', // 新增Opus周费用限制
permissions: '', // 空字符串表示不修改 permissions: '', // 空字符串表示不修改
claudeAccountId: '', claudeAccountId: '',
geminiAccountId: '', geminiAccountId: '',
@@ -616,8 +637,8 @@ const batchUpdateApiKeys = async () => {
const updates = {} const updates = {}
// 只有非空值才添加到更新对象中 // 只有非空值才添加到更新对象中
if (form.tokenLimit !== '' && form.tokenLimit !== null) { if (form.rateLimitCost !== '' && form.rateLimitCost !== null) {
updates.tokenLimit = parseInt(form.tokenLimit) updates.rateLimitCost = parseFloat(form.rateLimitCost)
} }
if (form.rateLimitWindow !== '' && form.rateLimitWindow !== null) { if (form.rateLimitWindow !== '' && form.rateLimitWindow !== null) {
updates.rateLimitWindow = parseInt(form.rateLimitWindow) updates.rateLimitWindow = parseInt(form.rateLimitWindow)
@@ -631,6 +652,9 @@ const batchUpdateApiKeys = async () => {
if (form.dailyCostLimit !== '' && form.dailyCostLimit !== null) { if (form.dailyCostLimit !== '' && form.dailyCostLimit !== null) {
updates.dailyCostLimit = parseFloat(form.dailyCostLimit) updates.dailyCostLimit = parseFloat(form.dailyCostLimit)
} }
if (form.weeklyOpusCostLimit !== '' && form.weeklyOpusCostLimit !== null) {
updates.weeklyOpusCostLimit = parseFloat(form.weeklyOpusCostLimit)
}
// 权限设置 // 权限设置
if (form.permissions !== '') { if (form.permissions !== '') {

202
web/admin-spa/src/components/apistats/AggregatedStatsCard.vue Normal file
View File

@@ -0,0 +1,202 @@
<template>
<div class="card h-full p-4 md:p-6">
<h3
class="mb-3 flex flex-col text-lg font-bold text-gray-900 dark:text-gray-100 sm:flex-row sm:items-center md:mb-4 md:text-xl"
>
<span class="flex items-center">
<i class="fas fa-chart-pie mr-2 text-sm text-orange-500 md:mr-3 md:text-base" />
使用占比
</span>
<span class="text-xs font-normal text-gray-600 dark:text-gray-400 sm:ml-2 md:text-sm"
>({{ statsPeriod === 'daily' ? '今日' : '本月' }})</span
>
</h3>
<div v-if="aggregatedStats && individualStats.length > 0" class="space-y-2 md:space-y-3">
<!-- 各Key使用占比列表 -->
<div v-for="(stat, index) in topKeys" :key="stat.apiId" class="relative">
<div class="mb-1 flex items-center justify-between text-sm">
<span class="truncate font-medium text-gray-700 dark:text-gray-300">
{{ stat.name || `Key ${index + 1}` }}
</span>
<span class="text-xs text-gray-600 dark:text-gray-400">
{{ calculatePercentage(stat) }}%
</span>
</div>
<div class="h-2 w-full rounded-full bg-gray-200 dark:bg-gray-700">
<div
class="h-2 rounded-full transition-all duration-300"
:class="getProgressColor(index)"
:style="{ width: calculatePercentage(stat) + '%' }"
/>
</div>
<div
class="mt-1 flex items-center justify-between text-xs text-gray-500 dark:text-gray-400"
>
<span>{{ formatNumber(getStatUsage(stat)?.requests || 0) }}次</span>
<span>{{ getStatUsage(stat)?.formattedCost || '$0.00' }}</span>
</div>
</div>
<!-- 其他Keys汇总 -->
<div v-if="otherKeysCount > 0" class="border-t border-gray-200 pt-2 dark:border-gray-700">
<div class="flex items-center justify-between text-sm text-gray-600 dark:text-gray-400">
<span>其他 {{ otherKeysCount }} 个Keys</span>
<span>{{ otherPercentage }}%</span>
</div>
</div>
</div>
<!-- 单个Key模式提示 -->
<div
v-else-if="!multiKeyMode"
class="flex h-32 items-center justify-center text-sm text-gray-500 dark:text-gray-400"
>
<div class="text-center">
<i class="fas fa-chart-pie mb-2 text-2xl" />
<p>使用占比仅在多Key查询时显示</p>
</div>
</div>
<div
v-else
class="flex h-32 items-center justify-center text-sm text-gray-500 dark:text-gray-400"
>
<i class="fas fa-chart-pie mr-2" />
暂无数据
</div>
</div>
</template>
<script setup>
import { computed } from 'vue'
import { storeToRefs } from 'pinia'
import { useApiStatsStore } from '@/stores/apistats'
const apiStatsStore = useApiStatsStore()
const { aggregatedStats, individualStats, statsPeriod, multiKeyMode } = storeToRefs(apiStatsStore)
// 获取当前时间段的使用数据
const getStatUsage = (stat) => {
if (!stat) return null
if (statsPeriod.value === 'daily') {
return stat.dailyUsage || stat.usage
} else {
return stat.monthlyUsage || stat.usage
}
}
// 获取TOP Keys（最多显示5个）
const topKeys = computed(() => {
if (!individualStats.value || individualStats.value.length === 0) return []
return [...individualStats.value]
.sort((a, b) => {
const aUsage = getStatUsage(a)
const bUsage = getStatUsage(b)
return (bUsage?.cost || 0) - (aUsage?.cost || 0)
})
.slice(0, 5)
})
// 计算其他Keys数量
const otherKeysCount = computed(() => {
if (!individualStats.value) return 0
return Math.max(0, individualStats.value.length - 5)
})
// 计算其他Keys的占比
const otherPercentage = computed(() => {
if (!individualStats.value || !aggregatedStats.value) return 0
const topKeysCost = topKeys.value.reduce((sum, stat) => {
const usage = getStatUsage(stat)
return sum + (usage?.cost || 0)
}, 0)
const totalCost =
statsPeriod.value === 'daily'
? aggregatedStats.value.dailyUsage?.cost || 0
: aggregatedStats.value.monthlyUsage?.cost || 0
if (totalCost === 0) return 0
const otherCost = totalCost - topKeysCost
return Math.max(0, Math.round((otherCost / totalCost) * 100))
})
// 计算单个Key的百分比
const calculatePercentage = (stat) => {
if (!aggregatedStats.value) return 0
const totalCost =
statsPeriod.value === 'daily'
? aggregatedStats.value.dailyUsage?.cost || 0
: aggregatedStats.value.monthlyUsage?.cost || 0
if (totalCost === 0) return 0
const usage = getStatUsage(stat)
const percentage = ((usage?.cost || 0) / totalCost) * 100
return Math.round(percentage)
}
// 获取进度条颜色
const getProgressColor = (index) => {
const colors = ['bg-blue-500', 'bg-green-500', 'bg-purple-500', 'bg-yellow-500', 'bg-pink-500']
return colors[index] || 'bg-gray-400'
}
// 格式化数字
const formatNumber = (num) => {
if (typeof num !== 'number') {
num = parseInt(num) || 0
}
if (num === 0) return '0'
if (num >= 1000000) {
return (num / 1000000).toFixed(1) + 'M'
} else if (num >= 1000) {
return (num / 1000).toFixed(1) + 'K'
} else {
return num.toLocaleString()
}
}
</script>
<style scoped>
/* 卡片样式 - 使用CSS变量 */
.card {
background: var(--surface-color);
border-radius: 16px;
border: 1px solid var(--border-color);
box-shadow:
0 10px 15px -3px rgba(0, 0, 0, 0.1),
0 4px 6px -2px rgba(0, 0, 0, 0.05);
overflow: hidden;
position: relative;
transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
}
.card::before {
content: '';
position: absolute;
top: 0;
left: 0;
right: 0;
height: 1px;
background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.5), transparent);
}
.card:hover {
transform: translateY(-2px);
box-shadow:
0 20px 25px -5px rgba(0, 0, 0, 0.15),
0 10px 10px -5px rgba(0, 0, 0, 0.08);
}
:global(.dark) .card:hover {
box-shadow:
0 20px 25px -5px rgba(0, 0, 0, 0.5),
0 10px 10px -5px rgba(0, 0, 0, 0.35);
}
</style>

244
web/admin-spa/src/components/apistats/ApiKeyInput.vue
View File

@@ -1,24 +1,64 @@
<template> <template>
<div class="api-input-wide-card mb-8 rounded-3xl p-6 shadow-xl"> <div class="api-input-wide-card mb-8 rounded-3xl p-6 shadow-xl">
<!-- 标题区域 --> <!-- 标题区域 -->
<div class="wide-card-title mb-6 text-center"> <div class="wide-card-title mb-6">
<h2 class="mb-2 text-2xl font-bold text-gray-900 dark:text-white"> <h2 class="mb-2 text-2xl font-bold text-gray-900 dark:text-gray-200">
<i class="fas fa-chart-line mr-3" /> <i class="fas fa-chart-line mr-3" />
使用统计查询 使用统计查询
</h2> </h2>
<p class="text-base text-gray-600 dark:text-gray-300">查询您的 API Key 使用情况和统计数据</p> <p class="text-base text-gray-600 dark:text-gray-400">查询您的 API Key 使用情况和统计数据</p>
</div> </div>
<!-- 输入区域 --> <!-- 输入区域 -->
<div class="mx-auto max-w-4xl"> <div class="mx-auto max-w-4xl">
<div class="api-input-grid grid grid-cols-1 lg:grid-cols-4"> <!-- 控制栏 -->
<div class="control-bar mb-4 flex flex-wrap items-center justify-between gap-3">
<!-- API Key 标签 -->
<label class="text-sm font-medium text-gray-700 dark:text-gray-300">
<i class="fas fa-key mr-2" />
{{ multiKeyMode ? '输入您的 API Keys（每行一个或用逗号分隔）' : '输入您的 API Key' }}
</label>
<!-- 模式切换和查询按钮组 -->
<div class="button-group flex items-center gap-2">
<!-- 模式切换 -->
<div
class="mode-switch-group flex items-center rounded-lg bg-gray-100 p-1 dark:bg-gray-800"
>
<button
class="mode-switch-btn"
:class="{ active: !multiKeyMode }"
title="单一模式"
@click="multiKeyMode = false"
>
<i class="fas fa-key" />
<span class="ml-2 hidden sm:inline">单一</span>
</button>
<button
class="mode-switch-btn"
:class="{ active: multiKeyMode }"
title="聚合模式"
@click="multiKeyMode = true"
>
<i class="fas fa-layer-group" />
<span class="ml-2 hidden sm:inline">聚合</span>
<span
v-if="multiKeyMode && parsedApiKeys.length > 0"
class="ml-1 rounded-full bg-white/20 px-1.5 py-0.5 text-xs font-semibold"
>
{{ parsedApiKeys.length }}
</span>
</button>
</div>
</div>
</div>
<div class="api-input-grid grid grid-cols-1 gap-4 lg:grid-cols-4">
<!-- API Key 输入 --> <!-- API Key 输入 -->
<div class="lg:col-span-3"> <div class="lg:col-span-3">
<label class="mb-2 block text-sm font-medium text-gray-700 dark:text-gray-200"> <!-- 单 Key 模式输入框 -->
<i class="fas fa-key mr-2" />
输入您的 API Key
</label>
<input <input
v-if="!multiKeyMode"
v-model="apiKey" v-model="apiKey"
class="wide-card-input w-full" class="wide-card-input w-full"
:disabled="loading" :disabled="loading"
@@ -26,16 +66,33 @@
type="password" type="password"
@keyup.enter="queryStats" @keyup.enter="queryStats"
/> />
<!-- 多 Key 模式输入框 -->
<div v-else class="relative">
<textarea
v-model="apiKey"
class="wide-card-input w-full resize-y"
:disabled="loading"
placeholder="请输入您的 API Keys，支持以下格式：&#10;cr_xxx&#10;cr_yyy&#10;或&#10;cr_xxx, cr_yyy"
rows="4"
@keyup.ctrl.enter="queryStats"
/>
<button
v-if="apiKey && !loading"
class="absolute right-2 top-2 text-gray-400 hover:text-gray-600 dark:text-gray-500 dark:hover:text-gray-300"
title="清空输入"
@click="clearInput"
>
<i class="fas fa-times-circle" />
</button>
</div>
</div> </div>
<!-- 查询按钮 --> <!-- 查询按钮 -->
<div class="lg:col-span-1"> <div class="lg:col-span-1">
<label class="mb-2 hidden text-sm font-medium text-gray-700 dark:text-gray-200 lg:block">
&nbsp;
</label>
<button <button
class="btn btn-primary btn-query flex h-full w-full items-center justify-center gap-2" class="btn btn-primary btn-query flex h-full w-full items-center justify-center gap-2"
:disabled="loading || !apiKey.trim()" :disabled="loading || !hasValidInput"
@click="queryStats" @click="queryStats"
> >
<i v-if="loading" class="fas fa-spinner loading-spinner" /> <i v-if="loading" class="fas fa-spinner loading-spinner" />
@@ -48,19 +105,56 @@
<!-- 安全提示 --> <!-- 安全提示 -->
<div class="security-notice mt-4"> <div class="security-notice mt-4">
<i class="fas fa-shield-alt mr-2" /> <i class="fas fa-shield-alt mr-2" />
您的 API Key 仅用于查询自己的统计数据，不会被存储或用于其他用途 {{
multiKeyMode
? '您的 API Keys 仅用于查询统计数据，不会被存储。聚合模式下部分个体化信息将不显示。'
: '您的 API Key 仅用于查询自己的统计数据，不会被存储或用于其他用途'
}}
</div>
<!-- 多 Key 模式额外提示 -->
<div
v-if="multiKeyMode"
class="mt-2 rounded-lg bg-blue-50 p-3 text-sm text-blue-700 dark:bg-blue-900/20 dark:text-blue-400"
>
<i class="fas fa-lightbulb mr-2" />
<span>提示：最多支持同时查询 30 个 API Keys。使用 Ctrl+Enter 快速查询。</span>
</div> </div>
</div> </div>
</div> </div>
</template> </template>
<script setup> <script setup>
import { computed } from 'vue'
import { storeToRefs } from 'pinia' import { storeToRefs } from 'pinia'
import { useApiStatsStore } from '@/stores/apistats' import { useApiStatsStore } from '@/stores/apistats'
const apiStatsStore = useApiStatsStore() const apiStatsStore = useApiStatsStore()
const { apiKey, loading } = storeToRefs(apiStatsStore) const { apiKey, loading, multiKeyMode } = storeToRefs(apiStatsStore)
const { queryStats } = apiStatsStore const { queryStats, clearInput } = apiStatsStore
// 解析输入的 API Keys
const parsedApiKeys = computed(() => {
if (!multiKeyMode.value || !apiKey.value) return []
// 支持逗号和换行符分隔
const keys = apiKey.value
.split(/[,\n]+/)
.map((key) => key.trim())
.filter((key) => key.length > 0)
// 去重并限制最多30个
const uniqueKeys = [...new Set(keys)]
return uniqueKeys.slice(0, 30)
})
// 判断是否有有效输入
const hasValidInput = computed(() => {
if (multiKeyMode.value) {
return parsedApiKeys.value.length > 0
}
return apiKey.value && apiKey.value.trim().length > 0
})
</script> </script>
<style scoped> <style scoped>
@@ -101,7 +195,6 @@ const { queryStats } = apiStatsStore
/* 标题样式 */ /* 标题样式 */
.wide-card-title h2 { .wide-card-title h2 {
color: #1f2937;
text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1); text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
font-weight: 700; font-weight: 700;
} }
@@ -112,12 +205,12 @@ const { queryStats } = apiStatsStore
} }
.wide-card-title p { .wide-card-title p {
color: #4b5563; color: #6b7280;
text-shadow: 0 1px 1px rgba(0, 0, 0, 0.05); text-shadow: 0 1px 1px rgba(0, 0, 0, 0.05);
} }
:global(.dark) .wide-card-title p { :global(.dark) .wide-card-title p {
color: #d1d5db; color: #9ca3af;
text-shadow: 0 1px 1px rgba(0, 0, 0, 0.2); text-shadow: 0 1px 1px rgba(0, 0, 0, 0.2);
} }
@@ -251,6 +344,93 @@ const { queryStats } = apiStatsStore
text-shadow: 0 1px 2px rgba(16, 185, 129, 0.2); text-shadow: 0 1px 2px rgba(16, 185, 129, 0.2);
} }
/* 控制栏 */
.control-bar {
padding-bottom: 0.5rem;
border-bottom: 1px solid rgba(229, 231, 235, 0.3);
}
:global(.dark) .control-bar {
border-bottom-color: rgba(75, 85, 99, 0.3);
}
/* 按钮组 */
.button-group {
display: flex;
align-items: center;
gap: 0.5rem;
}
/* 模式切换组 */
.mode-switch-group {
display: inline-flex;
padding: 4px;
background: #f3f4f6;
border-radius: 0.5rem;
box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.05);
}
:global(.dark) .mode-switch-group {
background: #1f2937;
box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.3);
}
/* 模式切换按钮 */
.mode-switch-btn {
display: inline-flex;
align-items: center;
padding: 6px 12px;
font-size: 0.875rem;
font-weight: 500;
color: #6b7280;
background: transparent;
border: none;
border-radius: 0.375rem;
cursor: pointer;
transition: all 0.2s ease;
white-space: nowrap;
}
:global(.dark) .mode-switch-btn {
color: #9ca3af;
}
.mode-switch-btn:hover:not(.active) {
color: #374151;
background: rgba(0, 0, 0, 0.05);
}
:global(.dark) .mode-switch-btn:hover:not(.active) {
color: #d1d5db;
background: rgba(255, 255, 255, 0.05);
}
.mode-switch-btn.active {
color: white;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
box-shadow: 0 2px 4px rgba(102, 126, 234, 0.2);
}
.mode-switch-btn.active:hover {
box-shadow: 0 4px 6px rgba(102, 126, 234, 0.3);
}
.mode-switch-btn i {
font-size: 0.875rem;
}
/* 淡入淡出动画 */
.fade-enter-active,
.fade-leave-active {
transition: all 0.3s ease;
}
.fade-enter-from,
.fade-leave-to {
opacity: 0;
transform: translateX(-10px);
}
/* 加载动画 */ /* 加载动画 */
.loading-spinner { .loading-spinner {
animation: spin 1s linear infinite; animation: spin 1s linear infinite;
@@ -267,6 +447,18 @@ const { queryStats } = apiStatsStore
} }
/* 响应式优化 */ /* 响应式优化 */
@media (max-width: 768px) {
.control-bar {
flex-direction: column;
align-items: stretch;
gap: 1rem;
}
.button-group {
justify-content: center;
}
}
@media (max-width: 768px) { @media (max-width: 768px) {
.api-input-wide-card { .api-input-wide-card {
padding: 1.25rem; padding: 1.25rem;
@@ -304,6 +496,22 @@ const { queryStats } = apiStatsStore
} }
} }
@media (max-width: 480px) {
.mode-toggle-btn {
padding: 5px 8px;
}
.toggle-icon {
width: 18px;
height: 18px;
}
.hint-text {
font-size: 0.7rem;
padding: 4px 8px;
}
}
@media (max-width: 480px) { @media (max-width: 480px) {
.api-input-wide-card { .api-input-wide-card {
padding: 1rem; padding: 1rem;

120
web/admin-spa/src/components/apistats/LimitConfig.vue
View File

@@ -1,14 +1,108 @@
<template> <template>
<div> <div>
<!-- 限制配置 --> <!-- 限制配置 / 聚合模式提示 -->
<div class="card p-4 md:p-6"> <div class="card p-4 md:p-6">
<h3 <h3
class="mb-3 flex items-center text-lg font-bold text-gray-900 dark:text-gray-100 md:mb-4 md:text-xl" class="mb-3 flex items-center text-lg font-bold text-gray-900 dark:text-gray-100 md:mb-4 md:text-xl"
> >
<i class="fas fa-shield-alt mr-2 text-sm text-red-500 md:mr-3 md:text-base" /> <i class="fas fa-shield-alt mr-2 text-sm text-red-500 md:mr-3 md:text-base" />
限制配置 {{ multiKeyMode ? '限制配置（聚合查询模式）' : '限制配置' }}
</h3> </h3>
<div class="space-y-4 md:space-y-5">
<!-- 多 Key 模式下的聚合统计信息 -->
<div v-if="multiKeyMode && aggregatedStats" class="space-y-4">
<!-- API Keys 概况 -->
<div
class="rounded-lg bg-gradient-to-r from-blue-50 to-indigo-50 p-4 dark:from-blue-900/20 dark:to-indigo-900/20"
>
<div class="mb-3 flex items-center justify-between">
<span class="text-sm font-medium text-gray-700 dark:text-gray-300">
<i class="fas fa-layer-group mr-2 text-blue-500" />
API Keys 概况
</span>
<span
class="rounded-full bg-blue-100 px-2 py-1 text-xs font-semibold text-blue-700 dark:bg-blue-800 dark:text-blue-200"
>
{{ aggregatedStats.activeKeys }}/{{ aggregatedStats.totalKeys }}
</span>
</div>
<div class="grid grid-cols-2 gap-3">
<div class="text-center">
<div class="text-lg font-bold text-gray-900 dark:text-gray-100">
{{ aggregatedStats.totalKeys }}
</div>
<div class="text-xs text-gray-600 dark:text-gray-400">总计 Keys</div>
</div>
<div class="text-center">
<div class="text-lg font-bold text-green-600">
{{ aggregatedStats.activeKeys }}
</div>
<div class="text-xs text-gray-600 dark:text-gray-400">激活 Keys</div>
</div>
</div>
</div>
<!-- 聚合统计数据 -->
<div
class="rounded-lg bg-gradient-to-r from-purple-50 to-pink-50 p-4 dark:from-purple-900/20 dark:to-pink-900/20"
>
<div class="mb-3 flex items-center">
<i class="fas fa-chart-pie mr-2 text-purple-500" />
<span class="text-sm font-medium text-gray-700 dark:text-gray-300">聚合统计摘要</span>
</div>
<div class="space-y-2">
<div class="flex items-center justify-between">
<span class="text-xs text-gray-600 dark:text-gray-400">
<i class="fas fa-database mr-1 text-gray-400" />
总请求数
</span>
<span class="text-sm font-medium text-gray-900 dark:text-gray-100">
{{ formatNumber(aggregatedStats.usage.requests) }}
</span>
</div>
<div class="flex items-center justify-between">
<span class="text-xs text-gray-600 dark:text-gray-400">
<i class="fas fa-coins mr-1 text-yellow-500" />
总 Tokens
</span>
<span class="text-sm font-medium text-gray-900 dark:text-gray-100">
{{ formatNumber(aggregatedStats.usage.allTokens) }}
</span>
</div>
<div class="flex items-center justify-between">
<span class="text-xs text-gray-600 dark:text-gray-400">
<i class="fas fa-dollar-sign mr-1 text-green-500" />
总费用
</span>
<span class="text-sm font-medium text-gray-900 dark:text-gray-100">
{{ aggregatedStats.usage.formattedCost }}
</span>
</div>
</div>
</div>
<!-- 无效 Keys 提示 -->
<div
v-if="invalidKeys && invalidKeys.length > 0"
class="rounded-lg bg-red-50 p-3 text-sm dark:bg-red-900/20"
>
<i class="fas fa-exclamation-triangle mr-2 text-red-600 dark:text-red-400" />
<span class="text-red-700 dark:text-red-300">
{{ invalidKeys.length }} 个无效的 API Key
</span>
</div>
<!-- 提示信息 -->
<div
class="rounded-lg bg-gray-50 p-3 text-xs text-gray-600 dark:bg-gray-800 dark:text-gray-400"
>
<i class="fas fa-info-circle mr-1" />
每个 API Key 有独立的限制设置，聚合模式下不显示单个限制配置
</div>
</div>
<!-- 仅在单 Key 模式下显示限制配置 -->
<div v-if="!multiKeyMode" class="space-y-4 md:space-y-5">
<!-- 每日费用限制 --> <!-- 每日费用限制 -->
<div> <div>
<div class="mb-2 flex items-center justify-between"> <div class="mb-2 flex items-center justify-between">
@@ -221,7 +315,7 @@ import { useApiStatsStore } from '@/stores/apistats'
import WindowCountdown from '@/components/apikeys/WindowCountdown.vue' import WindowCountdown from '@/components/apikeys/WindowCountdown.vue'
const apiStatsStore = useApiStatsStore() const apiStatsStore = useApiStatsStore()
const { statsData } = storeToRefs(apiStatsStore) const { statsData, multiKeyMode, aggregatedStats, invalidKeys } = storeToRefs(apiStatsStore)
// 获取每日费用进度 // 获取每日费用进度
const getDailyCostProgress = () => { const getDailyCostProgress = () => {
@@ -239,6 +333,24 @@ const getDailyCostProgressColor = () => {
if (progress >= 80) return 'bg-yellow-500' if (progress >= 80) return 'bg-yellow-500'
return 'bg-green-500' return 'bg-green-500'
} }
// 格式化数字
const formatNumber = (num) => {
if (typeof num !== 'number') {
num = parseInt(num) || 0
}
if (num === 0) return '0'
// 大数字使用简化格式
if (num >= 1000000) {
return (num / 1000000).toFixed(1) + 'M'
} else if (num >= 1000) {
return (num / 1000).toFixed(1) + 'K'
} else {
return num.toLocaleString()
}
}
</script> </script>
<style scoped> <style scoped>

105
web/admin-spa/src/components/apistats/StatsOverview.vue
View File

@@ -1,14 +1,83 @@
<template> <template>
<div class="mb-6 grid grid-cols-1 gap-4 md:mb-8 md:gap-6 lg:grid-cols-2"> <div class="mb-6 grid grid-cols-1 gap-4 md:mb-8 md:gap-6 lg:grid-cols-2">
<!-- API Key 基本信息 --> <!-- API Key 基本信息 / 批量查询概要 -->
<div class="card p-4 md:p-6"> <div class="card p-4 md:p-6">
<h3 <h3
class="mb-3 flex items-center text-lg font-bold text-gray-900 dark:text-gray-100 md:mb-4 md:text-xl" class="mb-3 flex items-center text-lg font-bold text-gray-900 dark:text-gray-100 md:mb-4 md:text-xl"
> >
<i class="fas fa-info-circle mr-2 text-sm text-blue-500 md:mr-3 md:text-base" /> <i
API Key 信息 class="mr-2 text-sm md:mr-3 md:text-base"
:class="
multiKeyMode ? 'fas fa-layer-group text-purple-500' : 'fas fa-info-circle text-blue-500'
"
/>
{{ multiKeyMode ? '批量查询概要' : 'API Key 信息' }}
</h3> </h3>
<div class="space-y-2 md:space-y-3">
<!-- 多 Key 模式下的概要信息 -->
<div v-if="multiKeyMode && aggregatedStats" class="space-y-2 md:space-y-3">
<div class="flex items-center justify-between">
<span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">查询 Keys 数</span>
<span class="text-sm font-medium text-gray-900 dark:text-gray-100 md:text-base">
{{ aggregatedStats.totalKeys }} 个
</span>
</div>
<div class="flex items-center justify-between">
<span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">有效 Keys 数</span>
<span class="text-sm font-medium text-green-600 md:text-base">
<i class="fas fa-check-circle mr-1 text-xs md:text-sm" />
{{ aggregatedStats.activeKeys }} 个
</span>
</div>
<div v-if="invalidKeys.length > 0" class="flex items-center justify-between">
<span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">无效 Keys 数</span>
<span class="text-sm font-medium text-red-600 md:text-base">
<i class="fas fa-times-circle mr-1 text-xs md:text-sm" />
{{ invalidKeys.length }} 个
</span>
</div>
<div class="flex items-center justify-between">
<span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">总请求数</span>
<span class="text-sm font-medium text-gray-900 dark:text-gray-100 md:text-base">
{{ formatNumber(aggregatedStats.usage.requests) }}
</span>
</div>
<div class="flex items-center justify-between">
<span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">总 Token 数</span>
<span class="text-sm font-medium text-gray-900 dark:text-gray-100 md:text-base">
{{ formatNumber(aggregatedStats.usage.allTokens) }}
</span>
</div>
<div class="flex items-center justify-between">
<span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">总费用</span>
<span class="text-sm font-medium text-indigo-600 md:text-base">
{{ aggregatedStats.usage.formattedCost }}
</span>
</div>
<!-- 各 Key 贡献占比（可选） -->
<div
v-if="individualStats.length > 1"
class="border-t border-gray-200 pt-2 dark:border-gray-700"
>
<div class="mb-2 text-xs text-gray-500 dark:text-gray-400">各 Key 贡献占比</div>
<div class="space-y-1">
<div
v-for="stat in topContributors"
:key="stat.apiId"
class="flex items-center justify-between text-xs"
>
<span class="truncate text-gray-600 dark:text-gray-400">{{ stat.name }}</span>
<span class="text-gray-900 dark:text-gray-100"
>{{ calculateContribution(stat) }}%</span
>
</div>
</div>
</div>
</div>
<!-- 单 Key 模式下的详细信息 -->
<div v-else class="space-y-2 md:space-y-3">
<div class="flex items-center justify-between"> <div class="flex items-center justify-between">
<span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">名称</span> <span class="text-sm text-gray-600 dark:text-gray-400 md:text-base">名称</span>
<span <span
@@ -128,12 +197,38 @@
</template> </template>
<script setup> <script setup>
/* eslint-disable no-unused-vars */
import { computed } from 'vue'
import { storeToRefs } from 'pinia' import { storeToRefs } from 'pinia'
import { useApiStatsStore } from '@/stores/apistats' import { useApiStatsStore } from '@/stores/apistats'
import dayjs from 'dayjs' import dayjs from 'dayjs'
const apiStatsStore = useApiStatsStore() const apiStatsStore = useApiStatsStore()
const { statsData, statsPeriod, currentPeriodData } = storeToRefs(apiStatsStore) const {
statsData,
statsPeriod,
currentPeriodData,
multiKeyMode,
aggregatedStats,
individualStats,
invalidKeys
} = storeToRefs(apiStatsStore)
// 计算前3个贡献最大的 Key
const topContributors = computed(() => {
if (!individualStats.value || individualStats.value.length === 0) return []
return [...individualStats.value]
.sort((a, b) => (b.usage?.allTokens || 0) - (a.usage?.allTokens || 0))
.slice(0, 3)
})
// 计算单个 Key 的贡献占比
const calculateContribution = (stat) => {
if (!aggregatedStats.value || !aggregatedStats.value.usage.allTokens) return 0
const percentage = ((stat.usage?.allTokens || 0) / aggregatedStats.value.usage.allTokens) * 100
return percentage.toFixed(1)
}
// 格式化日期 // 格式化日期
const formatDate = (dateString) => { const formatDate = (dateString) => {

13
web/admin-spa/src/config/api.js
View File

@@ -98,9 +98,18 @@ class ApiClient {
// GET 请求 // GET 请求
async get(url, options = {}) { async get(url, options = {}) {
const fullUrl = createApiUrl(url) // 处理查询参数
let fullUrl = createApiUrl(url)
if (options.params) {
const params = new URLSearchParams(options.params)
fullUrl += '?' + params.toString()
}
// 移除 params 避免传递给 fetch
// eslint-disable-next-line no-unused-vars
const { params, ...configOptions } = options
const config = this.buildConfig({ const config = this.buildConfig({
...options, ...configOptions,
method: 'GET' method: 'GET'
}) })

16
web/admin-spa/src/config/apiStats.js
View File

@@ -76,6 +76,22 @@ class ApiStatsClient {
} }
} }
} }
// 批量查询统计数据
async getBatchStats(apiIds) {
return this.request('/apiStats/api/batch-stats', {
method: 'POST',
body: JSON.stringify({ apiIds })
})
}
// 批量查询模型统计
async getBatchModelStats(apiIds, period = 'daily') {
return this.request('/apiStats/api/batch-model-stats', {
method: 'POST',
body: JSON.stringify({ apiIds, period })
})
}
} }
export const apiStatsClient = new ApiStatsClient() export const apiStatsClient = new ApiStatsClient()

167
web/admin-spa/src/stores/apistats.js
View File

@@ -21,6 +21,14 @@ export const useApiStatsStore = defineStore('apistats', () => {
siteIconData: '' siteIconData: ''
}) })
// 多 Key 模式相关状态
const multiKeyMode = ref(false)
const apiKeys = ref([]) // 多个 API Key 数组
const apiIds = ref([]) // 对应的 ID 数组
const aggregatedStats = ref(null) // 聚合后的统计数据
const individualStats = ref([]) // 各个 Key 的独立数据
const invalidKeys = ref([]) // 无效的 Keys 列表
// 计算属性 // 计算属性
const currentPeriodData = computed(() => { const currentPeriodData = computed(() => {
const defaultData = { const defaultData = {
@@ -34,6 +42,16 @@ export const useApiStatsStore = defineStore('apistats', () => {
formattedCost: '$0.000000' formattedCost: '$0.000000'
} }
// 聚合模式下使用聚合数据
if (multiKeyMode.value && aggregatedStats.value) {
if (statsPeriod.value === 'daily') {
return aggregatedStats.value.dailyUsage || defaultData
} else {
return aggregatedStats.value.monthlyUsage || defaultData
}
}
// 单个 Key 模式下使用原有逻辑
if (statsPeriod.value === 'daily') { if (statsPeriod.value === 'daily') {
return dailyStats.value || defaultData return dailyStats.value || defaultData
} else { } else {
@@ -69,6 +87,11 @@ export const useApiStatsStore = defineStore('apistats', () => {
// 查询统计数据 // 查询统计数据
async function queryStats() { async function queryStats() {
// 多 Key 模式处理
if (multiKeyMode.value) {
return queryBatchStats()
}
if (!apiKey.value.trim()) { if (!apiKey.value.trim()) {
error.value = '请输入 API Key' error.value = '请输入 API Key'
return return
@@ -204,6 +227,12 @@ export const useApiStatsStore = defineStore('apistats', () => {
statsPeriod.value = period statsPeriod.value = period
// 多 Key 模式下加载批量模型统计
if (multiKeyMode.value && apiIds.value.length > 0) {
await loadBatchModelStats(period)
return
}
// 如果对应时间段的数据还没有加载，则加载它 // 如果对应时间段的数据还没有加载，则加载它
if ( if (
(period === 'daily' && !dailyStats.value) || (period === 'daily' && !dailyStats.value) ||
@@ -297,6 +326,127 @@ export const useApiStatsStore = defineStore('apistats', () => {
} }
} }
// 批量查询统计数据
async function queryBatchStats() {
const keys = parseApiKeys()
if (keys.length === 0) {
error.value = '请输入至少一个有效的 API Key'
return
}
loading.value = true
error.value = ''
aggregatedStats.value = null
individualStats.value = []
invalidKeys.value = []
modelStats.value = []
apiKeys.value = keys
apiIds.value = []
try {
// 批量获取 API Key IDs
const idResults = await Promise.allSettled(keys.map((key) => apiStatsClient.getKeyId(key)))
const validIds = []
const validKeys = []
idResults.forEach((result, index) => {
if (result.status === 'fulfilled' && result.value.success) {
validIds.push(result.value.data.id)
validKeys.push(keys[index])
} else {
invalidKeys.value.push(keys[index])
}
})
if (validIds.length === 0) {
throw new Error('所有 API Key 都无效')
}
apiIds.value = validIds
apiKeys.value = validKeys
// 批量查询统计数据
const batchResult = await apiStatsClient.getBatchStats(validIds)
if (batchResult.success) {
aggregatedStats.value = batchResult.data.aggregated
individualStats.value = batchResult.data.individual
statsData.value = batchResult.data.aggregated // 兼容现有组件
// 设置聚合模式下的日期统计数据，以保证现有组件的兼容性
dailyStats.value = batchResult.data.aggregated.dailyUsage || null
monthlyStats.value = batchResult.data.aggregated.monthlyUsage || null
// 加载聚合的模型统计
await loadBatchModelStats(statsPeriod.value)
// 更新 URL
updateBatchURL()
} else {
throw new Error(batchResult.message || '批量查询失败')
}
} catch (err) {
console.error('Batch query error:', err)
error.value = err.message || '批量查询统计数据失败'
aggregatedStats.value = null
individualStats.value = []
} finally {
loading.value = false
}
}
// 加载批量模型统计
async function loadBatchModelStats(period = 'daily') {
if (apiIds.value.length === 0) return
modelStatsLoading.value = true
try {
const result = await apiStatsClient.getBatchModelStats(apiIds.value, period)
if (result.success) {
modelStats.value = result.data || []
} else {
throw new Error(result.message || '加载批量模型统计失败')
}
} catch (err) {
console.error('Load batch model stats error:', err)
modelStats.value = []
} finally {
modelStatsLoading.value = false
}
}
// 解析 API Keys
function parseApiKeys() {
if (!apiKey.value) return []
const keys = apiKey.value
.split(/[,\n]+/)
.map((key) => key.trim())
.filter((key) => key.length > 0)
// 去重并限制最多30个
const uniqueKeys = [...new Set(keys)]
return uniqueKeys.slice(0, 30)
}
// 更新批量查询 URL
function updateBatchURL() {
if (apiIds.value.length > 0) {
const url = new URL(window.location)
url.searchParams.set('apiIds', apiIds.value.join(','))
url.searchParams.set('batch', 'true')
window.history.pushState({}, '', url)
}
}
// 清空输入
function clearInput() {
apiKey.value = ''
}
// 清除数据 // 清除数据
function clearData() { function clearData() {
statsData.value = null statsData.value = null
@@ -306,11 +456,18 @@ export const useApiStatsStore = defineStore('apistats', () => {
error.value = '' error.value = ''
statsPeriod.value = 'daily' statsPeriod.value = 'daily'
apiId.value = null apiId.value = null
// 清除多 Key 模式数据
apiKeys.value = []
apiIds.value = []
aggregatedStats.value = null
individualStats.value = []
invalidKeys.value = []
} }
// 重置 // 重置
function reset() { function reset() {
apiKey.value = '' apiKey.value = ''
multiKeyMode.value = false
clearData() clearData()
} }
@@ -328,6 +485,13 @@ export const useApiStatsStore = defineStore('apistats', () => {
dailyStats, dailyStats,
monthlyStats, monthlyStats,
oemSettings, oemSettings,
// 多 Key 模式状态
multiKeyMode,
apiKeys,
apiIds,
aggregatedStats,
individualStats,
invalidKeys,
// Computed // Computed
currentPeriodData, currentPeriodData,
@@ -335,13 +499,16 @@ export const useApiStatsStore = defineStore('apistats', () => {
// Actions // Actions
queryStats, queryStats,
queryBatchStats,
loadAllPeriodStats, loadAllPeriodStats,
loadPeriodStats, loadPeriodStats,
loadModelStats, loadModelStats,
loadBatchModelStats,
switchPeriod, switchPeriod,
loadStatsWithApiId, loadStatsWithApiId,
loadOemSettings, loadOemSettings,
clearData, clearData,
clearInput,
reset reset
} }
}) })

35
web/admin-spa/src/views/AccountsView.vue
View File

@@ -458,7 +458,8 @@
account.platform === 'claude-console' || account.platform === 'claude-console' ||
account.platform === 'bedrock' || account.platform === 'bedrock' ||
account.platform === 'gemini' || account.platform === 'gemini' ||
account.platform === 'openai' account.platform === 'openai' ||
account.platform === 'azure_openai'
" "
class="flex items-center gap-2" class="flex items-center gap-2"
> >
@@ -1024,11 +1025,26 @@ const sortedAccounts = computed(() => {
const loadAccounts = async (forceReload = false) => { const loadAccounts = async (forceReload = false) => {
accountsLoading.value = true accountsLoading.value = true
try { try {
// 构建查询参数（移除分组参数，因为在前端处理） // 检查是否选择了特定分组
if (groupFilter.value && groupFilter.value !== 'all' && groupFilter.value !== 'ungrouped') {
// 直接调用分组成员接口
const response = await apiClient.get(`/admin/account-groups/${groupFilter.value}/members`)
if (response.success) {
// 分组成员接口已经包含了完整的账户信息，直接使用
accounts.value = response.data
accountsLoading.value = false
return
}
}
// 构建查询参数（用于其他筛选情况）
const params = {} const params = {}
if (platformFilter.value !== 'all') { if (platformFilter.value !== 'all') {
params.platform = platformFilter.value params.platform = platformFilter.value
} }
if (groupFilter.value === 'ungrouped') {
params.groupId = groupFilter.value
}
// 根据平台筛选决定需要请求哪些接口 // 根据平台筛选决定需要请求哪些接口
const requests = [] const requests = []
@@ -1106,6 +1122,17 @@ const loadAccounts = async (forceReload = false) => {
apiClient.get('/admin/azure-openai-accounts', { params }) apiClient.get('/admin/azure-openai-accounts', { params })
) )
break break
default:
// 默认情况下返回空数组
requests.push(
Promise.resolve({ success: true, data: [] }),
Promise.resolve({ success: true, data: [] }),
Promise.resolve({ success: true, data: [] }),
Promise.resolve({ success: true, data: [] }),
Promise.resolve({ success: true, data: [] }),
Promise.resolve({ success: true, data: [] })
)
break
} }
} }
@@ -1178,8 +1205,8 @@ const loadAccounts = async (forceReload = false) => {
const boundApiKeysCount = apiKeys.value.filter( const boundApiKeysCount = apiKeys.value.filter(
(key) => key.azureOpenaiAccountId === acc.id (key) => key.azureOpenaiAccountId === acc.id
).length ).length
const groupInfo = accountGroupMap.value.get(acc.id) || null // 后端已经包含了groupInfos，直接使用
return { ...acc, platform: 'azure_openai', boundApiKeysCount, groupInfo } return { ...acc, platform: 'azure_openai', boundApiKeysCount }
}) })
allAccounts.push(...azureOpenaiAccounts) allAccounts.push(...azureOpenaiAccounts)
} }

188
web/admin-spa/src/views/ApiKeysView.vue
View File

@@ -54,7 +54,8 @@
<!-- Tab Content --> <!-- Tab Content -->
<!-- 活跃 API Keys Tab Panel --> <!-- 活跃 API Keys Tab Panel -->
<div v-if="activeTab === 'active'" class="tab-panel"> <div v-if="activeTab === 'active'" class="tab-panel">
<div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between"> <!-- 工具栏区域 - 添加 mb-4 增加与表格的间距 -->
<div class="mb-4 flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
<!-- 筛选器组 --> <!-- 筛选器组 -->
<div class="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-center sm:gap-3"> <div class="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-center sm:gap-3">
<!-- 时间范围筛选 --> <!-- 时间范围筛选 -->
@@ -136,17 +137,8 @@
/> />
<span class="relative">刷新</span> <span class="relative">刷新</span>
</button> </button>
</div>
<!-- 创建按钮 -->
<button
class="flex w-full items-center justify-center gap-2 rounded-lg bg-gradient-to-r from-blue-500 to-blue-600 px-5 py-2.5 text-sm font-medium text-white shadow-md transition-all duration-200 hover:from-blue-600 hover:to-blue-700 hover:shadow-lg sm:w-auto"
@click.stop="openCreateApiKeyModal"
>
<i class="fas fa-plus"></i>
<span>创建新 Key</span>
</button>
<!-- 批量编辑按钮 --> <!-- 批量编辑按钮 - 移到刷新按钮旁边 -->
<button <button
v-if="selectedApiKeys.length > 0" v-if="selectedApiKeys.length > 0"
class="group relative flex items-center justify-center gap-2 rounded-lg border border-blue-200 bg-blue-50 px-4 py-2 text-sm font-medium text-blue-700 shadow-sm transition-all duration-200 hover:border-blue-300 hover:bg-blue-100 hover:shadow-md dark:border-blue-700 dark:bg-blue-900/30 dark:text-blue-300 dark:hover:bg-blue-900/50 sm:w-auto" class="group relative flex items-center justify-center gap-2 rounded-lg border border-blue-200 bg-blue-50 px-4 py-2 text-sm font-medium text-blue-700 shadow-sm transition-all duration-200 hover:border-blue-300 hover:bg-blue-100 hover:shadow-md dark:border-blue-700 dark:bg-blue-900/30 dark:text-blue-300 dark:hover:bg-blue-900/50 sm:w-auto"
@@ -159,7 +151,7 @@
<span class="relative">编辑选中 ({{ selectedApiKeys.length }})</span> <span class="relative">编辑选中 ({{ selectedApiKeys.length }})</span>
</button> </button>
<!-- 批量删除按钮 --> <!-- 批量删除按钮 - 移到刷新按钮旁边 -->
<button <button
v-if="selectedApiKeys.length > 0" v-if="selectedApiKeys.length > 0"
class="group relative flex items-center justify-center gap-2 rounded-lg border border-red-200 bg-red-50 px-4 py-2 text-sm font-medium text-red-700 shadow-sm transition-all duration-200 hover:border-red-300 hover:bg-red-100 hover:shadow-md dark:border-red-700 dark:bg-red-900/30 dark:text-red-300 dark:hover:bg-red-900/50 sm:w-auto" class="group relative flex items-center justify-center gap-2 rounded-lg border border-red-200 bg-red-50 px-4 py-2 text-sm font-medium text-red-700 shadow-sm transition-all duration-200 hover:border-red-300 hover:bg-red-100 hover:shadow-md dark:border-red-700 dark:bg-red-900/30 dark:text-red-300 dark:hover:bg-red-900/50 sm:w-auto"
@@ -173,6 +165,16 @@
</button> </button>
</div> </div>
<!-- 创建按钮 - 独立在右侧 -->
<button
class="flex w-full items-center justify-center gap-2 rounded-lg bg-gradient-to-r from-blue-500 to-blue-600 px-5 py-2.5 text-sm font-medium text-white shadow-md transition-all duration-200 hover:from-blue-600 hover:to-blue-700 hover:shadow-lg sm:w-auto"
@click.stop="openCreateApiKeyModal"
>
<i class="fas fa-plus"></i>
<span>创建新 Key</span>
</button>
</div>
<div v-if="apiKeysLoading" class="py-12 text-center"> <div v-if="apiKeysLoading" class="py-12 text-center">
<div class="loading-spinner mx-auto mb-4" /> <div class="loading-spinner mx-auto mb-4" />
<p class="text-gray-500 dark:text-gray-400">正在加载 API Keys...</p> <p class="text-gray-500 dark:text-gray-400">正在加载 API Keys...</p>
@@ -1312,7 +1314,20 @@
</div> </div>
<!-- 已删除的 API Keys 表格 --> <!-- 已删除的 API Keys 表格 -->
<div v-else class="table-container"> <div v-else>
<!-- 工具栏 -->
<div class="mb-4 flex justify-end">
<button
v-if="deletedApiKeys.length > 0"
class="rounded-lg bg-red-600 px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-red-700 dark:bg-red-600 dark:hover:bg-red-700"
@click="clearAllDeletedApiKeys"
>
<i class="fas fa-trash-alt mr-2" />
清空所有已删除 ({{ deletedApiKeys.length }})
</button>
</div>
<div class="table-container">
<table class="w-full table-fixed"> <table class="w-full table-fixed">
<thead class="bg-gray-50/80 backdrop-blur-sm dark:bg-gray-700/80"> <thead class="bg-gray-50/80 backdrop-blur-sm dark:bg-gray-700/80">
<tr> <tr>
@@ -1346,6 +1361,11 @@
> >
使用统计 使用统计
</th> </th>
<th
class="w-[10%] min-w-[100px] px-3 py-4 text-left text-xs font-bold uppercase tracking-wider text-gray-700 dark:text-gray-300"
>
操作
</th>
</tr> </tr>
</thead> </thead>
<tbody class="divide-y divide-gray-200/50 dark:divide-gray-600/50"> <tbody class="divide-y divide-gray-200/50 dark:divide-gray-600/50">
@@ -1389,7 +1409,9 @@
</span> </span>
</div> </div>
</td> </td>
<td class="whitespace-nowrap px-3 py-4 text-sm text-gray-500 dark:text-gray-400"> <td
class="whitespace-nowrap px-3 py-4 text-sm text-gray-500 dark:text-gray-400"
>
{{ formatDate(key.createdAt) }} {{ formatDate(key.createdAt) }}
</td> </td>
<td class="px-3 py-4"> <td class="px-3 py-4">
@@ -1408,7 +1430,9 @@
</span> </span>
</div> </div>
</td> </td>
<td class="whitespace-nowrap px-3 py-4 text-sm text-gray-500 dark:text-gray-400"> <td
class="whitespace-nowrap px-3 py-4 text-sm text-gray-500 dark:text-gray-400"
>
{{ formatDate(key.deletedAt) }} {{ formatDate(key.deletedAt) }}
</td> </td>
<td class="px-3 py-4"> <td class="px-3 py-4">
@@ -1434,6 +1458,27 @@
<div v-else class="text-xs text-gray-400">从未使用</div> <div v-else class="text-xs text-gray-400">从未使用</div>
</div> </div>
</td> </td>
<td class="px-3 py-4">
<div class="flex items-center gap-2">
<button
v-if="key.canRestore"
class="rounded-lg bg-green-50 px-3 py-1.5 text-xs font-medium text-green-600 transition-colors hover:bg-green-100 dark:bg-green-900/30 dark:text-green-400 dark:hover:bg-green-900/50"
title="恢复 API Key"
@click="restoreApiKey(key.id)"
>
<i class="fas fa-undo mr-1" />
恢复
</button>
<button
class="rounded-lg bg-red-50 px-3 py-1.5 text-xs font-medium text-red-600 transition-colors hover:bg-red-100 dark:bg-red-900/30 dark:text-red-400 dark:hover:bg-red-900/50"
title="彻底删除 API Key"
@click="permanentDeleteApiKey(key.id)"
>
<i class="fas fa-times mr-1" />
彻底删除
</button>
</div>
</td>
</tr> </tr>
</tbody> </tbody>
</table> </table>
@@ -1441,6 +1486,7 @@
</div> </div>
</div> </div>
</div> </div>
</div>
<!-- 模态框组件 --> <!-- 模态框组件 -->
<CreateApiKeyModal <CreateApiKeyModal
@@ -2325,6 +2371,118 @@ const deleteApiKey = async (keyId) => {
} }
} }
// 恢复API Key
const restoreApiKey = async (keyId) => {
let confirmed = false
if (window.showConfirm) {
confirmed = await window.showConfirm(
'恢复 API Key',
'确定要恢复这个 API Key 吗？恢复后可以重新使用。',
'确定恢复',
'取消'
)
} else {
// 降级方案
confirmed = confirm('确定要恢复这个 API Key 吗？恢复后可以重新使用。')
}
if (!confirmed) return
try {
const data = await apiClient.post(`/admin/api-keys/${keyId}/restore`)
if (data.success) {
showToast('API Key 已成功恢复', 'success')
// 刷新已删除列表
await loadDeletedApiKeys()
// 同时刷新活跃列表
await loadApiKeys()
} else {
showToast(data.error || '恢复失败', 'error')
}
} catch (error) {
showToast(error.response?.data?.error || '恢复失败', 'error')
}
}
// 彻底删除API Key
const permanentDeleteApiKey = async (keyId) => {
let confirmed = false
if (window.showConfirm) {
confirmed = await window.showConfirm(
'彻底删除 API Key',
'确定要彻底删除这个 API Key 吗？此操作不可恢复，所有相关数据将被永久删除。',
'确定彻底删除',
'取消'
)
} else {
// 降级方案
confirmed = confirm('确定要彻底删除这个 API Key 吗？此操作不可恢复，所有相关数据将被永久删除。')
}
if (!confirmed) return
try {
const data = await apiClient.delete(`/admin/api-keys/${keyId}/permanent`)
if (data.success) {
showToast('API Key 已彻底删除', 'success')
// 刷新已删除列表
loadDeletedApiKeys()
} else {
showToast(data.error || '彻底删除失败', 'error')
}
} catch (error) {
showToast(error.response?.data?.error || '彻底删除失败', 'error')
}
}
// 清空所有已删除的API Keys
const clearAllDeletedApiKeys = async () => {
const count = deletedApiKeys.value.length
if (count === 0) {
showToast('没有需要清空的 API Keys', 'info')
return
}
let confirmed = false
if (window.showConfirm) {
confirmed = await window.showConfirm(
'清空所有已删除的 API Keys',
`确定要彻底删除全部 ${count} 个已删除的 API Keys 吗？此操作不可恢复，所有相关数据将被永久删除。`,
'确定清空全部',
'取消'
)
} else {
// 降级方案
confirmed = confirm(`确定要彻底删除全部 ${count} 个已删除的 API Keys 吗？此操作不可恢复。`)
}
if (!confirmed) return
try {
const data = await apiClient.delete('/admin/api-keys/deleted/clear-all')
if (data.success) {
showToast(data.message || '已清空所有已删除的 API Keys', 'success')
// 如果有失败的，显示详细信息
if (data.details && data.details.failedCount > 0) {
const errors = data.details.errors
console.error('部分API Keys清空失败:', errors)
showToast(`${data.details.failedCount} 个清空失败，请查看控制台`, 'warning')
}
// 刷新已删除列表
loadDeletedApiKeys()
} else {
showToast(data.error || '清空失败', 'error')
}
} catch (error) {
showToast(error.response?.data?.error || '清空失败', 'error')
}
}
// 批量删除API Keys // 批量删除API Keys
const batchDeleteApiKeys = async () => { const batchDeleteApiKeys = async () => {
const selectedCount = selectedApiKeys.value.length const selectedCount = selectedApiKeys.value.length

9
web/admin-spa/src/views/ApiStatsView.vue
View File

@@ -123,7 +123,10 @@
<!-- Token 分布和限制配置 --> <!-- Token 分布和限制配置 -->
<div class="mb-6 grid grid-cols-1 gap-4 md:mb-8 md:gap-6 lg:grid-cols-2"> <div class="mb-6 grid grid-cols-1 gap-4 md:mb-8 md:gap-6 lg:grid-cols-2">
<TokenDistribution /> <TokenDistribution />
<LimitConfig /> <!-- 单key模式下显示限制配置 -->
<LimitConfig v-if="!multiKeyMode" />
<!-- 多key模式下显示聚合统计卡片，填充右侧空白 -->
<AggregatedStatsCard v-if="multiKeyMode" />
</div> </div>
<!-- 模型使用统计 --> <!-- 模型使用统计 -->
@@ -153,6 +156,7 @@ import ApiKeyInput from '@/components/apistats/ApiKeyInput.vue'
import StatsOverview from '@/components/apistats/StatsOverview.vue' import StatsOverview from '@/components/apistats/StatsOverview.vue'
import TokenDistribution from '@/components/apistats/TokenDistribution.vue' import TokenDistribution from '@/components/apistats/TokenDistribution.vue'
import LimitConfig from '@/components/apistats/LimitConfig.vue' import LimitConfig from '@/components/apistats/LimitConfig.vue'
import AggregatedStatsCard from '@/components/apistats/AggregatedStatsCard.vue'
import ModelUsageStats from '@/components/apistats/ModelUsageStats.vue' import ModelUsageStats from '@/components/apistats/ModelUsageStats.vue'
import TutorialView from './TutorialView.vue' import TutorialView from './TutorialView.vue'
@@ -175,7 +179,8 @@ const {
error, error,
statsPeriod, statsPeriod,
statsData, statsData,
oemSettings oemSettings,
multiKeyMode
} = storeToRefs(apiStatsStore) } = storeToRefs(apiStatsStore)
const { queryStats, switchPeriod, loadStatsWithApiId, loadOemSettings, reset } = apiStatsStore const { queryStats, switchPeriod, loadStatsWithApiId, loadOemSettings, reset } = apiStatsStore

10
web/admin-spa/src/views/TutorialView.vue
View File

@@ -1639,7 +1639,7 @@
</template> </template>
<script setup> <script setup>
import { ref, computed } from 'vue' import { computed, ref } from 'vue'
// 当前系统选择 // 当前系统选择
const activeTutorialSystem = ref('windows') const activeTutorialSystem = ref('windows')
@@ -1653,6 +1653,14 @@ const tutorialSystems = [
// 获取基础URL前缀 // 获取基础URL前缀
const getBaseUrlPrefix = () => { const getBaseUrlPrefix = () => {
// 优先使用环境变量配置的自定义前缀
const customPrefix = import.meta.env.VITE_API_BASE_PREFIX
if (customPrefix) {
// 去除末尾的斜杠
return customPrefix.replace(/\/$/, '')
}
// 否则使用当前浏览器访问地址
// 更健壮的获取 origin 的方法，兼容旧版浏览器和特殊环境 // 更健壮的获取 origin 的方法，兼容旧版浏览器和特殊环境
let origin = '' let origin = ''