245583b96a
- 新增日志系统配置选项，支持日志级别、输出模式、文件大小等设置 - 添加当日日志文件下载功能，可通过Web界面直接下载 - 将console.log/error替换为结构化logger，提升日志可管理性 - 在日志页面添加自动滚动到底部功能 - 更新配置示例文件，包含完整的日志配置参数
722 lines
22 KiB
JavaScript
722 lines
22 KiB
JavaScript
/**
|
||
* API 大锅饭 - 用户数据管理模块
|
||
* 管理用户关联的凭据文件路径和资源包
|
||
* 使用 Mutex 解决并发问题
|
||
*/
|
||
|
||
import { promises as fs } from 'fs';
|
||
import logger from '../../utils/logger.js';
|
||
import { existsSync, readFileSync, writeFileSync, watch } from 'fs';
|
||
import path from 'path';
|
||
|
||
// 配置文件路径
|
||
const USER_DATA_FILE = path.join(process.cwd(), 'configs', 'api-potluck-data.json');
|
||
|
||
// 默认配置值
|
||
const DEFAULT_CONFIG = {
|
||
defaultDailyLimit: 500,
|
||
bonusPerCredential: 300,
|
||
bonusValidityDays: 30,
|
||
persistInterval: 5000
|
||
};
|
||
|
||
// 内存缓存
|
||
let userDataStore = null;
|
||
let isDirty = false;
|
||
let isWriting = false;
|
||
let persistTimer = null;
|
||
let fileWatcher = null;
|
||
let currentPersistInterval = DEFAULT_CONFIG.persistInterval;
|
||
|
||
// ============ 简易 Mutex 实现 ============
|
||
class SimpleMutex {
|
||
constructor() {
|
||
this._locked = false;
|
||
this._waiting = [];
|
||
}
|
||
|
||
async acquire() {
|
||
return new Promise((resolve) => {
|
||
if (!this._locked) {
|
||
this._locked = true;
|
||
resolve();
|
||
} else {
|
||
this._waiting.push(resolve);
|
||
}
|
||
});
|
||
}
|
||
|
||
release() {
|
||
if (this._waiting.length > 0) {
|
||
const next = this._waiting.shift();
|
||
next();
|
||
} else {
|
||
this._locked = false;
|
||
}
|
||
}
|
||
|
||
async runExclusive(fn) {
|
||
await this.acquire();
|
||
try {
|
||
return await fn();
|
||
} finally {
|
||
this.release();
|
||
}
|
||
}
|
||
}
|
||
|
||
// 全局锁：用于资源包消耗操作
|
||
const bonusMutex = new SimpleMutex();
|
||
|
||
// ============ 配置管理 ============
|
||
|
||
/**
|
||
* 获取完整配置（支持热更新）
|
||
*/
|
||
function getFullConfig() {
|
||
ensureLoaded();
|
||
const config = userDataStore.config || {};
|
||
return {
|
||
defaultDailyLimit: config.defaultDailyLimit ?? DEFAULT_CONFIG.defaultDailyLimit,
|
||
bonusPerCredential: config.bonusPerCredential ?? DEFAULT_CONFIG.bonusPerCredential,
|
||
bonusValidityDays: config.bonusValidityDays ?? DEFAULT_CONFIG.bonusValidityDays,
|
||
persistInterval: config.persistInterval ?? DEFAULT_CONFIG.persistInterval
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 获取资源包配置（兼容旧接口）
|
||
*/
|
||
function getBonusConfig() {
|
||
const config = getFullConfig();
|
||
return {
|
||
bonusPerCredential: config.bonusPerCredential,
|
||
bonusValidityDays: config.bonusValidityDays
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 更新配置
|
||
* @param {Object} newConfig - 新配置
|
||
* @returns {Object} 更新后的完整配置
|
||
*/
|
||
export async function updateConfig(newConfig) {
|
||
ensureLoaded();
|
||
|
||
if (!userDataStore.config) {
|
||
userDataStore.config = {};
|
||
}
|
||
|
||
// 验证并更新各配置项
|
||
if (typeof newConfig.defaultDailyLimit === 'number' && newConfig.defaultDailyLimit > 0) {
|
||
userDataStore.config.defaultDailyLimit = newConfig.defaultDailyLimit;
|
||
}
|
||
if (typeof newConfig.bonusPerCredential === 'number' && newConfig.bonusPerCredential >= 0) {
|
||
userDataStore.config.bonusPerCredential = newConfig.bonusPerCredential;
|
||
}
|
||
if (typeof newConfig.bonusValidityDays === 'number' && newConfig.bonusValidityDays > 0) {
|
||
userDataStore.config.bonusValidityDays = newConfig.bonusValidityDays;
|
||
}
|
||
if (typeof newConfig.persistInterval === 'number' && newConfig.persistInterval >= 1000) {
|
||
userDataStore.config.persistInterval = newConfig.persistInterval;
|
||
// 更新持久化定时器
|
||
updatePersistTimer(newConfig.persistInterval);
|
||
}
|
||
|
||
markDirty();
|
||
await persistIfDirty();
|
||
|
||
const updatedConfig = getFullConfig();
|
||
logger.info(`[API Potluck UserData] Config updated:`, updatedConfig);
|
||
return updatedConfig;
|
||
}
|
||
|
||
/**
|
||
* 更新持久化定时器间隔
|
||
*/
|
||
function updatePersistTimer(newInterval) {
|
||
if (newInterval === currentPersistInterval) return;
|
||
|
||
currentPersistInterval = newInterval;
|
||
if (persistTimer) {
|
||
clearInterval(persistTimer);
|
||
persistTimer = setInterval(persistIfDirty, currentPersistInterval);
|
||
logger.info(`[API Potluck UserData] Persist interval updated to ${currentPersistInterval}ms`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取当前配置（对外暴露）
|
||
*/
|
||
export function getConfig() {
|
||
return getFullConfig();
|
||
}
|
||
|
||
/**
|
||
* 兼容旧接口：更新资源包配置
|
||
*/
|
||
export async function updateBonusConfig(newConfig) {
|
||
return updateConfig(newConfig);
|
||
}
|
||
|
||
/**
|
||
* 初始化：从文件加载数据到内存
|
||
*/
|
||
function ensureLoaded() {
|
||
if (userDataStore !== null) return;
|
||
try {
|
||
if (existsSync(USER_DATA_FILE)) {
|
||
const content = readFileSync(USER_DATA_FILE, 'utf8');
|
||
userDataStore = JSON.parse(content);
|
||
// 兼容旧数据：确保 config 和 users 存在
|
||
if (!userDataStore.config) {
|
||
userDataStore.config = {};
|
||
}
|
||
if (!userDataStore.users) {
|
||
userDataStore.users = {};
|
||
}
|
||
} else {
|
||
userDataStore = { config: {}, users: {} };
|
||
syncWriteToFile();
|
||
}
|
||
} catch (error) {
|
||
logger.error('[API Potluck UserData] Failed to load user data:', error.message);
|
||
userDataStore = { config: {}, users: {} };
|
||
}
|
||
|
||
// 获取配置的持久化间隔
|
||
const config = userDataStore.config || {};
|
||
currentPersistInterval = config.persistInterval ?? DEFAULT_CONFIG.persistInterval;
|
||
|
||
// 启动定期持久化
|
||
if (!persistTimer) {
|
||
persistTimer = setInterval(persistIfDirty, currentPersistInterval);
|
||
}
|
||
// 启动文件监听（热更新）
|
||
startFileWatcher();
|
||
}
|
||
|
||
/**
|
||
* 同步写入文件（仅初始化时使用）
|
||
*/
|
||
function syncWriteToFile() {
|
||
try {
|
||
const dir = path.dirname(USER_DATA_FILE);
|
||
if (!existsSync(dir)) {
|
||
require('fs').mkdirSync(dir, { recursive: true });
|
||
}
|
||
writeFileSync(USER_DATA_FILE, JSON.stringify(userDataStore, null, 2), 'utf8');
|
||
} catch (error) {
|
||
logger.error('[API Potluck UserData] Sync write failed:', error.message);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 异步持久化（带写锁）
|
||
*/
|
||
async function persistIfDirty() {
|
||
if (!isDirty || isWriting || userDataStore === null) return;
|
||
isWriting = true;
|
||
try {
|
||
const dir = path.dirname(USER_DATA_FILE);
|
||
if (!existsSync(dir)) {
|
||
await fs.mkdir(dir, { recursive: true });
|
||
}
|
||
const tempFile = USER_DATA_FILE + '.tmp';
|
||
await fs.writeFile(tempFile, JSON.stringify(userDataStore, null, 2), 'utf8');
|
||
await fs.rename(tempFile, USER_DATA_FILE);
|
||
isDirty = false;
|
||
} catch (error) {
|
||
logger.error('[API Potluck UserData] Persist failed:', error.message);
|
||
} finally {
|
||
isWriting = false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 标记数据已修改
|
||
*/
|
||
function markDirty() {
|
||
isDirty = true;
|
||
}
|
||
|
||
/**
|
||
* 启动文件监听（热更新配置）
|
||
*/
|
||
let lastReloadTime = 0;
|
||
function startFileWatcher() {
|
||
if (fileWatcher) return;
|
||
|
||
try {
|
||
fileWatcher = watch(USER_DATA_FILE, { persistent: false }, (eventType) => {
|
||
if (eventType !== 'change') return;
|
||
|
||
// 防抖：忽略自己写入触发的事件
|
||
const now = Date.now();
|
||
if (now - lastReloadTime < 1000 || isWriting) return;
|
||
lastReloadTime = now;
|
||
|
||
// 重新加载配置部分
|
||
try {
|
||
const content = readFileSync(USER_DATA_FILE, 'utf8');
|
||
const newData = JSON.parse(content);
|
||
|
||
// 只热更新 config 部分，不覆盖内存中的 users 数据
|
||
if (newData.config) {
|
||
const oldConfig = userDataStore.config || {};
|
||
const newConfig = newData.config;
|
||
|
||
// 检查配置是否有变化
|
||
if (JSON.stringify(oldConfig) !== JSON.stringify(newConfig)) {
|
||
userDataStore.config = newConfig;
|
||
logger.info('[API Potluck UserData] Config hot-reloaded:', getBonusConfig());
|
||
}
|
||
}
|
||
} catch (error) {
|
||
logger.error('[API Potluck UserData] Hot-reload failed:', error.message);
|
||
}
|
||
});
|
||
|
||
logger.info('[API Potluck UserData] File watcher started for config hot-reload');
|
||
} catch (error) {
|
||
logger.error('[API Potluck UserData] Failed to start file watcher:', error.message);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 停止文件监听
|
||
*/
|
||
export function stopFileWatcher() {
|
||
if (fileWatcher) {
|
||
fileWatcher.close();
|
||
fileWatcher = null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取用户数据
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @returns {Object|null}
|
||
*/
|
||
export function getUserData(apiKey) {
|
||
ensureLoaded();
|
||
return userDataStore.users[apiKey] || null;
|
||
}
|
||
|
||
/**
|
||
* 初始化用户数据（如果不存在）
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @returns {Object}
|
||
*/
|
||
export function ensureUserData(apiKey) {
|
||
ensureLoaded();
|
||
if (!userDataStore.users[apiKey]) {
|
||
userDataStore.users[apiKey] = {
|
||
credentials: [],
|
||
credentialBonuses: [],
|
||
createdAt: new Date().toISOString()
|
||
};
|
||
markDirty();
|
||
}
|
||
// 兼容旧数据：添加 credentialBonuses 数组
|
||
if (!userDataStore.users[apiKey].credentialBonuses) {
|
||
userDataStore.users[apiKey].credentialBonuses = [];
|
||
markDirty();
|
||
}
|
||
return userDataStore.users[apiKey];
|
||
}
|
||
|
||
/**
|
||
* 添加凭据路径到用户
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @param {Object} credentialInfo - 凭据信息
|
||
* @param {string} credentialInfo.path - 凭据文件路径
|
||
* @param {string} credentialInfo.provider - 提供商类型 (如 'claude-kiro-oauth')
|
||
* @param {string} [credentialInfo.authMethod] - 认证方式 (如 'builder-id', 'google', 'github')
|
||
* @returns {Object} 添加的凭据信息
|
||
*/
|
||
export async function addUserCredential(apiKey, credentialInfo) {
|
||
ensureLoaded();
|
||
const userData = ensureUserData(apiKey);
|
||
|
||
// 检查是否已存在相同路径
|
||
const existingIndex = userData.credentials.findIndex(c => c.path === credentialInfo.path);
|
||
|
||
// 只保留核心字段，健康状态从主服务实时获取
|
||
const credential = {
|
||
id: `cred_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
|
||
path: credentialInfo.path,
|
||
provider: credentialInfo.provider || 'claude-kiro-oauth',
|
||
authMethod: credentialInfo.authMethod || 'unknown',
|
||
addedAt: new Date().toISOString()
|
||
};
|
||
|
||
if (existingIndex >= 0) {
|
||
// 更新已存在的凭据，保留原有 id 和 addedAt
|
||
credential.id = userData.credentials[existingIndex].id;
|
||
credential.addedAt = userData.credentials[existingIndex].addedAt;
|
||
userData.credentials[existingIndex] = credential;
|
||
} else {
|
||
userData.credentials.push(credential);
|
||
}
|
||
|
||
markDirty();
|
||
await persistIfDirty();
|
||
|
||
return credential;
|
||
}
|
||
|
||
/**
|
||
* 移除用户凭据
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @param {string} credentialId - 凭据 ID
|
||
* @returns {boolean}
|
||
*/
|
||
export async function removeUserCredential(apiKey, credentialId) {
|
||
ensureLoaded();
|
||
const userData = userDataStore.users[apiKey];
|
||
if (!userData) return false;
|
||
|
||
const index = userData.credentials.findIndex(c => c.id === credentialId);
|
||
if (index === -1) return false;
|
||
|
||
userData.credentials.splice(index, 1);
|
||
markDirty();
|
||
await persistIfDirty();
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 获取用户的所有凭据
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @returns {Array}
|
||
*/
|
||
export function getUserCredentials(apiKey) {
|
||
ensureLoaded();
|
||
const userData = userDataStore.users[apiKey];
|
||
return userData ? userData.credentials : [];
|
||
}
|
||
|
||
/**
|
||
* 通过路径查找凭据
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @param {string} credPath - 凭据文件路径
|
||
* @returns {Object|null}
|
||
*/
|
||
export function findCredentialByPath(apiKey, credPath) {
|
||
ensureLoaded();
|
||
const userData = userDataStore.users[apiKey];
|
||
if (!userData) return null;
|
||
|
||
return userData.credentials.find(c => c.path === credPath) || null;
|
||
}
|
||
|
||
/**
|
||
* 检查凭据路径是否已被任何用户使用
|
||
* @param {string} credPath - 凭据文件路径
|
||
* @returns {{exists: boolean, apiKey?: string}}
|
||
*/
|
||
export function isCredentialPathUsed(credPath) {
|
||
ensureLoaded();
|
||
for (const [apiKey, userData] of Object.entries(userDataStore.users)) {
|
||
const found = userData.credentials.find(c => c.path === credPath);
|
||
if (found) {
|
||
return { exists: true, apiKey };
|
||
}
|
||
}
|
||
return { exists: false };
|
||
}
|
||
|
||
/**
|
||
* 迁移用户凭据到新 Key（用于 Key 重置时）
|
||
* @param {string} oldApiKey - 旧 API Key
|
||
* @param {string} newApiKey - 新 API Key
|
||
* @returns {Promise<boolean>}
|
||
*/
|
||
export async function migrateUserCredentials(oldApiKey, newApiKey) {
|
||
ensureLoaded();
|
||
const oldUserData = userDataStore.users[oldApiKey];
|
||
if (!oldUserData) return false;
|
||
|
||
// 将旧用户数据迁移到新 Key
|
||
userDataStore.users[newApiKey] = {
|
||
...oldUserData,
|
||
migratedFrom: oldApiKey.substring(0, 12) + '...',
|
||
migratedAt: new Date().toISOString()
|
||
};
|
||
|
||
// 删除旧用户数据
|
||
delete userDataStore.users[oldApiKey];
|
||
|
||
markDirty();
|
||
await persistIfDirty();
|
||
|
||
logger.info(`[API Potluck UserData] Migrated credentials from ${oldApiKey.substring(0, 12)}... to ${newApiKey.substring(0, 12)}...`);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 获取所有用户及其凭据（用于批量健康检查）
|
||
* @returns {Array<{apiKey: string, credentials: Array}>}
|
||
*/
|
||
export function getAllUsersCredentials() {
|
||
ensureLoaded();
|
||
const result = [];
|
||
for (const [apiKey, userData] of Object.entries(userDataStore.users)) {
|
||
if (userData.credentials && userData.credentials.length > 0) {
|
||
result.push({
|
||
apiKey,
|
||
credentials: userData.credentials
|
||
});
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// ============ 凭证资源包管理 ============
|
||
|
||
/**
|
||
* 计算资源包过期时间（使用动态配置）
|
||
* @param {string} grantedAt - 授予时间
|
||
* @returns {Date}
|
||
*/
|
||
function calculateExpiresAt(grantedAt) {
|
||
const { bonusValidityDays } = getBonusConfig();
|
||
const granted = new Date(grantedAt);
|
||
return new Date(granted.getTime() + bonusValidityDays * 24 * 60 * 60 * 1000);
|
||
}
|
||
|
||
/**
|
||
* 检查资源包是否过期
|
||
* @param {Object} bonus - 资源包对象
|
||
* @returns {boolean}
|
||
*/
|
||
function isBonusExpired(bonus) {
|
||
const expiresAt = calculateExpiresAt(bonus.grantedAt);
|
||
return new Date() > expiresAt;
|
||
}
|
||
|
||
/**
|
||
* 为凭证添加资源包（凭证健康时调用）
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @param {string} credentialId - 凭证 ID
|
||
* @returns {Object|null} 添加的资源包信息
|
||
*/
|
||
export async function addCredentialBonus(apiKey, credentialId) {
|
||
ensureLoaded();
|
||
const userData = ensureUserData(apiKey);
|
||
|
||
// 检查是否已存在
|
||
const existing = userData.credentialBonuses.find(b => b.credentialId === credentialId);
|
||
if (existing) {
|
||
return existing;
|
||
}
|
||
|
||
const bonus = {
|
||
credentialId,
|
||
grantedAt: new Date().toISOString(),
|
||
usedCount: 0
|
||
};
|
||
|
||
userData.credentialBonuses.push(bonus);
|
||
markDirty();
|
||
|
||
logger.info(`[API Potluck UserData] Added bonus for credential: ${credentialId}`);
|
||
return bonus;
|
||
}
|
||
|
||
/**
|
||
* 移除凭证资源包（凭证失效时调用）
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @param {string} credentialId - 凭证 ID
|
||
* @returns {boolean}
|
||
*/
|
||
export async function removeCredentialBonus(apiKey, credentialId) {
|
||
ensureLoaded();
|
||
const userData = userDataStore.users[apiKey];
|
||
if (!userData || !userData.credentialBonuses) return false;
|
||
|
||
const index = userData.credentialBonuses.findIndex(b => b.credentialId === credentialId);
|
||
if (index === -1) return false;
|
||
|
||
userData.credentialBonuses.splice(index, 1);
|
||
markDirty();
|
||
|
||
logger.info(`[API Potluck UserData] Removed bonus for credential: ${credentialId}`);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 消耗资源包次数（FIFO 顺序，使用 Mutex 保证并发安全）
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @returns {boolean} 是否成功消耗
|
||
*/
|
||
export async function consumeBonus(apiKey) {
|
||
// 使用 Mutex 保证并发安全
|
||
return bonusMutex.runExclusive(async () => {
|
||
ensureLoaded();
|
||
const userData = userDataStore.users[apiKey];
|
||
if (!userData || !userData.credentialBonuses) return false;
|
||
|
||
const { bonusPerCredential } = getBonusConfig();
|
||
|
||
// 按 grantedAt 排序（FIFO）
|
||
const sortedBonuses = userData.credentialBonuses
|
||
.filter(b => !isBonusExpired(b))
|
||
.sort((a, b) => new Date(a.grantedAt) - new Date(b.grantedAt));
|
||
|
||
// 找到第一个有剩余次数的资源包
|
||
for (const bonus of sortedBonuses) {
|
||
const remaining = bonusPerCredential - bonus.usedCount;
|
||
if (remaining > 0) {
|
||
bonus.usedCount += 1;
|
||
markDirty();
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 计算用户的剩余资源包总次数
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @param {Set<string>} [healthyCredentialIds] - 健康凭证 ID 集合（可选，用于过滤）
|
||
* @returns {number}
|
||
*/
|
||
export function calculateBonusRemaining(apiKey, healthyCredentialIds = null) {
|
||
ensureLoaded();
|
||
const userData = userDataStore.users[apiKey];
|
||
if (!userData || !userData.credentialBonuses) return 0;
|
||
|
||
const { bonusPerCredential } = getBonusConfig();
|
||
|
||
let total = 0;
|
||
for (const bonus of userData.credentialBonuses) {
|
||
// 检查是否过期
|
||
if (isBonusExpired(bonus)) continue;
|
||
|
||
// 如果提供了健康凭证集合，检查凭证是否健康
|
||
if (healthyCredentialIds && !healthyCredentialIds.has(bonus.credentialId)) continue;
|
||
|
||
const remaining = bonusPerCredential - bonus.usedCount;
|
||
if (remaining > 0) {
|
||
total += remaining;
|
||
}
|
||
}
|
||
|
||
return total;
|
||
}
|
||
|
||
/**
|
||
* 同步资源包状态（根据健康凭证列表）
|
||
* 兼容历史数据：为已有健康凭证创建资源包，使用凭证的 addedAt 作为 grantedAt
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @param {Array<{id: string, isHealthy: boolean, addedAt?: string}>} credentialsWithHealth - 带健康状态的凭证列表
|
||
* @returns {{added: number, removed: number, bonusRemaining: number}}
|
||
*/
|
||
export async function syncCredentialBonuses(apiKey, credentialsWithHealth) {
|
||
ensureLoaded();
|
||
const userData = ensureUserData(apiKey);
|
||
|
||
let added = 0, removed = 0;
|
||
|
||
// 获取健康凭证 ID 集合
|
||
const healthyIds = new Set(
|
||
credentialsWithHealth
|
||
.filter(c => c.isHealthy === true)
|
||
.map(c => c.id)
|
||
);
|
||
|
||
// 为新的健康凭证添加资源包
|
||
for (const cred of credentialsWithHealth) {
|
||
if (cred.isHealthy !== true) continue;
|
||
|
||
const exists = userData.credentialBonuses.some(b => b.credentialId === cred.id);
|
||
if (!exists) {
|
||
// 使用凭证的 addedAt 作为资源包授予时间（兼容历史数据）
|
||
const grantedAt = cred.addedAt || new Date().toISOString();
|
||
userData.credentialBonuses.push({
|
||
credentialId: cred.id,
|
||
grantedAt: grantedAt,
|
||
usedCount: 0
|
||
});
|
||
added++;
|
||
logger.info(`[API Potluck UserData] Created bonus for credential ${cred.id}, grantedAt: ${grantedAt}`);
|
||
}
|
||
}
|
||
|
||
// 移除失效凭证的资源包
|
||
const toRemove = userData.credentialBonuses.filter(b => !healthyIds.has(b.credentialId));
|
||
for (const bonus of toRemove) {
|
||
const idx = userData.credentialBonuses.indexOf(bonus);
|
||
if (idx !== -1) {
|
||
userData.credentialBonuses.splice(idx, 1);
|
||
removed++;
|
||
}
|
||
}
|
||
|
||
// 清理过期资源包
|
||
const expiredCount = userData.credentialBonuses.filter(b => isBonusExpired(b)).length;
|
||
userData.credentialBonuses = userData.credentialBonuses.filter(b => !isBonusExpired(b));
|
||
|
||
if (added > 0 || removed > 0 || expiredCount > 0) {
|
||
markDirty();
|
||
}
|
||
|
||
// 计算剩余资源包次数
|
||
const bonusRemaining = calculateBonusRemaining(apiKey, healthyIds);
|
||
|
||
return { added, removed, bonusRemaining };
|
||
}
|
||
|
||
/**
|
||
* 获取用户的资源包详情
|
||
* @param {string} apiKey - 用户的 API Key
|
||
* @returns {Object}
|
||
*/
|
||
export function getBonusDetails(apiKey) {
|
||
ensureLoaded();
|
||
const { bonusPerCredential, bonusValidityDays } = getBonusConfig();
|
||
const userData = userDataStore.users[apiKey];
|
||
if (!userData) {
|
||
return {
|
||
bonuses: [],
|
||
totalRemaining: 0,
|
||
bonusPerCredential,
|
||
validityDays: bonusValidityDays
|
||
};
|
||
}
|
||
|
||
const bonuses = (userData.credentialBonuses || [])
|
||
.filter(b => !isBonusExpired(b))
|
||
.map(b => ({
|
||
credentialId: b.credentialId,
|
||
grantedAt: b.grantedAt,
|
||
expiresAt: calculateExpiresAt(b.grantedAt).toISOString(),
|
||
usedCount: b.usedCount,
|
||
remaining: bonusPerCredential - b.usedCount
|
||
}));
|
||
|
||
const totalRemaining = bonuses.reduce((sum, b) => sum + Math.max(0, b.remaining), 0);
|
||
|
||
return {
|
||
bonuses,
|
||
totalRemaining,
|
||
bonusPerCredential,
|
||
validityDays: bonusValidityDays
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 获取所有用户的 API Key 列表
|
||
* @returns {string[]}
|
||
*/
|
||
export function getAllUserApiKeys() {
|
||
ensureLoaded();
|
||
return Object.keys(userDataStore.users);
|
||
}
|
||
|
||
export { USER_DATA_FILE };
|